// Build production agentic applications on OCI using Oracle Agent Development Kit with multi-agent orchestration, function tools, and enterprise patterns
Expert in OCI Generative AI Dedicated AI Clusters - deployment, fine-tuning, optimization, and production operations
Expert guidance on Oracle Cloud Infrastructure services, cloud architecture patterns, cost optimization, deployment strategies, and OCI best practices for enterprise solutions
Design framework-agnostic AI agents using Oracle's Open Agent Specification for portable, interoperable agentic systems with JSON/YAML definitions
Expert in OCI Generative AI Dedicated AI Clusters - deployment, fine-tuning, optimization, and production operations
Design and implement Model Context Protocol servers for standardized AI-to-data integration with resources, tools, prompts, and security best practices
Build production agentic applications on OCI using Oracle Agent Development Kit with multi-agent orchestration, function tools, and enterprise patterns
| name | Oracle ADK Expert |
| description | Build production agentic applications on OCI using Oracle Agent Development Kit with multi-agent orchestration, function tools, and enterprise patterns |
| version | 1.1.0 |
| last_updated | "2026-01-06T00:00:00.000Z" |
| external_version | Oracle ADK 1.0 GA |
Master Oracle's Agent Development Kit (ADK) for building enterprise-grade agentic applications on OCI Generative AI Agents Service with code-first approach and advanced orchestration patterns.
Client-side library that simplifies building agentic applications on top of OCI Generative AI Agents Service.
Key Value: Code-first approach for embedding agents in applications (web apps, Slackbots, enterprise systems).
Requirements: Python 3.10 or later
Build agents that maintain context across multiple interactions.
Pattern:
from oci_adk import Agent
agent = Agent(
name="customer_support",
model="cohere.command-r-plus",
system_prompt="You are a helpful customer support agent"
)
# Multi-turn conversation
conversation = agent.create_conversation()
response1 = conversation.send("I need help with my order")
response2 = conversation.send("It's order #12345")
# Agent remembers context from previous messages
Routing Pattern:
# Route requests to specialized agents
def orchestrator(user_query):
if requires_technical_support(user_query):
return technical_agent.handle(user_query)
elif requires_billing(user_query):
return billing_agent.handle(user_query)
else:
return general_agent.handle(user_query)
Agent-as-a-Tool Pattern:
# One agent uses another agent as a tool
main_agent = Agent(
name="supervisor",
tools=[research_agent, analysis_agent, report_agent]
)
# Main agent orchestrates specialist agents
result = main_agent.execute("Research and analyze Q4 performance")
Build predictable, orchestrated workflows with explicit control flow.
from oci_adk import Workflow, Step
workflow = Workflow([
Step("validate_input", validation_agent),
Step("process_request", processing_agent),
Step("generate_response", response_agent)
])
result = workflow.execute(user_input)
Add custom capabilities to agents through function tools.
from oci_adk import FunctionTool
@FunctionTool(
name="get_customer_data",
description="Retrieve customer information from CRM",
parameters={
"customer_id": {"type": "string", "required": True}
}
)
def get_customer_data(customer_id: str):
return crm_api.get_customer(customer_id)
agent = Agent(
name="customer_agent",
tools=[get_customer_data]
)
Supervisor Agent
├─→ Research Agent (gathers information)
├─→ Analysis Agent (processes data)
└─→ Report Agent (generates output)
Use Case: Complex tasks requiring specialized subtask agents
Implementation:
supervisor = Agent(
name="supervisor",
system_prompt="Coordinate specialist agents to complete complex tasks",
tools=[research_tool, analysis_tool, report_tool]
)
Input → Agent 1 → Agent 2 → Agent 3 → Output
Use Case: Linear workflows with dependencies
Implementation:
pipeline = AgentPipeline([
("extract", data_extraction_agent),
("transform", data_transformation_agent),
("load", data_loading_agent)
])
result = pipeline.execute(raw_data)
Coordinator
├──→ Agent A ──┐
├──→ Agent B ──┤→ Aggregator Agent
└──→ Agent C ──┘
Use Case: Independent tasks that can run concurrently
Implementation:
import asyncio
async def parallel_processing(task):
results = await asyncio.gather(
agent_a.execute_async(task),
agent_b.execute_async(task),
agent_c.execute_async(task)
)
return aggregator_agent.synthesize(results)
# Integrate with OCI services
from oci import object_storage, database
agent = Agent(
name="data_agent",
tools=[
object_storage_tool,
autonomous_db_tool,
analytics_cloud_tool
]
)
# Use OCI IAM for authentication
from oci.config import from_file
config = from_file("~/.oci/config")
agent = Agent(
name="secure_agent",
oci_config=config,
compartment_id="ocid1.compartment..."
)
# Deploy agents across OCI regions
regions = ["us-ashburn-1", "eu-frankfurt-1", "ap-tokyo-1"]
for region in regions:
deploy_agent(
agent=my_agent,
region=region,
config=regional_config[region]
)
# Embed in FastAPI application
from fastapi import FastAPI
from oci_adk import Agent
app = FastAPI()
support_agent = Agent.load("customer_support_v2")
@app.post("/support/chat")
async def chat_endpoint(message: str, session_id: str):
conversation = support_agent.get_conversation(session_id)
response = await conversation.send_async(message)
return {"reply": response.text}
from slack_sdk import WebClient
from oci_adk import Agent
slack_client = WebClient(token=slack_token)
agent = Agent.load("slack_assistant")
@slack_app.event("message")
def handle_message(event):
user_message = event["text"]
response = agent.execute(user_message)
slack_client.chat_postMessage(
channel=event["channel"],
text=response.text
)
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("oci_agent")
agent = Agent(
name="monitored_agent",
on_tool_call=lambda tool: logger.info(f"Calling tool: {tool}"),
on_error=lambda error: logger.error(f"Agent error: {error}")
)
from oci.monitoring import MonitoringClient
def track_agent_metrics(agent_id, metrics):
monitoring_client.post_metric_data(
post_metric_data_details={
"namespace": "agent_performance",
"dimensions": {"agent_id": agent_id},
"datapoints": metrics
}
)
# Use appropriate models for tasks
simple_agent = Agent(
model="cohere.command-light", # Cheaper for simple tasks
)
complex_agent = Agent(
model="cohere.command-r-plus", # More capable for complex reasoning
)
from functools import lru_cache
@lru_cache(maxsize=1000)
def cached_agent_call(prompt: str):
return agent.execute(prompt)
def test_customer_agent():
agent = Agent.load("customer_support")
response = agent.execute("What's your return policy?")
assert "30 days" in response.text.lower()
def test_agent_workflow():
workflow = Workflow([
Step("classify", classification_agent),
Step("process", processing_agent)
])
result = workflow.execute(test_input)
assert result.status == "success"
# Integrate with Oracle Fusion
fusion_agent = Agent(
name="fusion_assistant",
tools=[
fusion_hcm_tool,
fusion_erp_tool,
fusion_scm_tool
]
)
# Connect to Autonomous Database
from oci_adk.tools import SQLTool
db_tool = SQLTool(
connection_string=autonomous_db_connection,
allowed_tables=["customers", "orders", "products"]
)
agent = Agent(
name="data_agent",
tools=[db_tool]
)
Use Oracle ADK when:
Consider alternatives when:
Documentation:
Support:
This skill enables you to build production-ready agentic applications on Oracle Cloud Infrastructure using ADK's code-first approach.