// 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
Build production agentic applications on OCI using Oracle Agent Development Kit with multi-agent orchestration, function tools, and enterprise patterns
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
| 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.