Concepts Overview¶

Welcome to the Project Inception

Inception brings enterprise applications into the era of agentic AI. Built on OCI Enterprise AI and the AI Data Platform, it provides a secure, governed, and standardized foundation for building and deploying intelligent agents across Oracle applications. With reusable patterns and proven recipes, teams can accelerate from idea to implementation 60–80% faster. The result is scalable, enterprise-grade AI that continuously improves—creating a flywheel where each deployment makes the next faster, unlocking innovation across the business.

Code Accelerators — Inception runtime library, MCPs runtime, Patterns Agents, Patterns Solutions, and Recipes

Why this platform exists¶

Building production-grade AI agents is hard. Every project repeats the same foundational work: wiring up LLMs, setting up guardrails, managing memory, writing secure tool integrations, and provisioning infrastructure — weeks of effort before a single line of business logic ships.

Project Inception solves three recurring problems:

Problem	How this platform addresses it
Foundational complexity	Pre-built libraries for LLM handling, guardrails, logging, and memory ship as reusable packages
Governance & compliance	OCI Guardrails, LangFuse audit trails, structured logging, and IAM token propagation are baked in by default
Speed to production	End-to-end recipes, Docker containers, Terraform templates, and application stubs eliminate scaffolding overhead

Repository layout¶

inception_<customer_name>/
├── inception_core/          ← Shared libraries + accelerator patterns
│   ├── libs/                ← LLM factory, guardrails, logging, evals, DU tool
│   └── accelerators/        ← Runnable agent + solution patterns (incl. Swarm)
├── inception_mcp_servers/   ← FastMCP servers (SQLcl, Object Storage, ADW)
├── inception_skills/        ← recipe-builder + agentic-engineering skills —
│                               turn a use case into a full recipe, spec first
├── inception_recipes/       ← End-to-end domain implementations
│   ├── invoice_automation/  ← AP invoice processing with deep research agents
│   ├── smart_dispatch/      ← Multi-agent field service dispatch
│   ├── meridian_bank/       ← Loan approval swarm, dual-UI, deterministic decision
│   └── ebs_invoice_reconciliation/  ← AP three-way match, live-validated
├── applications_stub/       ← Production-ready starter app scaffolds
└── inception_devops/        ← Containers, Terraform, security automation

Core architectural concepts¶

Agent Definition¶

Every agent is composed of three runtime-configurable parts:

System prompt — shapes reasoning, persona, and scope
Model config — selects the LLM provider (OCI GenAI, OpenAI-compatible endpoints)
Tools / skills — Python functions, MCP tool calls, and agent skills the agent can invoke

Agent Harness¶

The harness wraps the agent definition with production infrastructure:

LangGraph — state-machine orchestration, conditional branching, multi-step reasoning loops
OCI GenAI — native LLM inference (Cohere, Meta LLaMA, and other hosted models)
LangFuse — full execution tracing: prompts, tool calls, token counts, latency, costs
Oracle-backed checkpointing — persist and resume conversation threads by ID
Memory store — virtual filesystem for long-term, episodic, semantic, and fleet-shared memory

MCP Tool Layer¶

Agents interact with external systems exclusively through Model Context Protocol servers. Each MCP server has a predictable 3-file structure:

server.py    ← bootstrap: loads env, creates FastMCP, starts transport
registry.py  ← exposes only explicitly registered tools at startup
tools.py     ← implements all tool functions

This makes tool surface area explicit, auditable, and easily extended.

Governance by Default¶

Security and observability are not afterthoughts:

OCI Guardrails — content safety and topic policy enforcement on all agent I/O
LangFuse — every chain step traced; replay any session for root-cause analysis
IAM token propagation — end-user IDCS identity flows through the stack to the database layer
VPD row-level security — Oracle Virtual Private Database enforces role-based data access per session

Platform architecture¶

┌─────────────────────────────────────────────────────────────────┐
│                      UI / API Layer                              │
│   React dashboards · FastAPI services · Node gateways · CLI     │
└────────────────────────────┬────────────────────────────────────┘
                             │
                             ▼
┌─────────────────────────────────────────────────────────────────┐
│                 Governance Layer                                 │
│   AI Guardrails · Security Policies · Auditing & Logging        │
└────────────────────────────┬────────────────────────────────────┘
                             │
                             ▼
┌─────────────────────────────────────────────────────────────────┐
│              Agent Orchestration Layer                           │
│   LangGraph · Deep Agents · HITL · Routing · Memory Patterns    │
└─────────────┬───────────────────────────────┬───────────────────┘
              ▼                               ▼
┌─────────────────────────┐     ┌─────────────────────────────────┐
│   LLM Provider Layer    │     │       MCP Tool Layer            │
│   OCI GenAI / OpenAI    │     │   SQLcl · Object Storage · ADW  │
└─────────────────────────┘     └─────────────────────────────────┘
              ▼                               ▼
┌─────────────────────────────────────────────────────────────────┐
│              Data · Memory · Policy Layer                        │
│   Oracle ADB · OracleDBSaver · OracleStore · IAM/OIDC · VPD    │
└─────────────────────────────────────────────────────────────────┘

The 7 AI Agent Design Patterns (+ Swarm)¶

The platform implements all seven canonical agentic patterns as runnable, composable templates, plus a peer-to-peer Swarm topology for multi-intent conversations that don't fit a fixed sequence:

#	Pattern	Description
1	Augmented LLM	Foundation — LLM enhanced with retrieval, tools, and memory
2	Prompt Chaining	Sequential LLM stages with quality gates between steps
3	Routing	Classify input, dispatch to specialized handlers
4	Parallelization	Split subtasks across parallel LLM workers and merge results
5	Orchestrator-Workers	Central LLM plans and delegates to specialized worker agents
6	Evaluator-Optimizer	Generate → Evaluate → Retry loop until quality criteria are met
7	Autonomous Agent	LLM-directed tool-use loop with guardrails — the most powerful and hardest to control
+	Swarm	Peer agents hand off control to each other directly — no central router. See Meridian Bank for the production example

Who this documentation is for¶

Audience	Start here
Developers with a new use case	Inception Skills — one prompt, spec first, then a full recipe
AI engineers building agentic workflows	Accelerators → Recipes
Platform engineers operating OCI	MCP Servers → DevOps
Solution architects	Architecture → Solution Patterns → Capability Matrix
New team members	Getting Started → this page