We’re excited to announce the release of the Oracle Cloud Infrastructure (OCI) Agent Development Kit (ADK) – a new lightweight client-side library that simplifies building powerful, production-ready agentic applications on top of the OCI Generative AI Agents.

With the ADK, developers benefit from a code-first experience designed to accelerate the creation of agent applications – whether building a Slack agent powered by LLMs or orchestrating complex multi-agent workflows. The ADK seamlessly integrates with existing OCI software development tools, enabling developers to add agentic functionality to new or existing codebases with ease and flexibility.

The ADK seamlessly integrates with OCI Generative AI Agents via a production-ready API endpoint, giving customers access to built-in agent components such as cloud-based session memory, a managed knowledge base, pre-built Retrieval Augmented Generation (RAG), and fast, direct connections to OCI Generative AI for inference. This eliminates the need for customers to build custom solutions for these capabilities and helps with rapid development of production-ready agents.

Python ADK is Generally Available (GA) today, and the Java ADK GA is coming soon. Follow this guide to get started now.

Key Benefits

Here’s how the OCI ADK helps you go from idea to agentic application – faster and smarter.

Intuitive Developer Experience

The ADK brings a developer experience on par with leading open-source agent frameworks:

  • Easy to learn, easy to use
  • Code-first design that integrates with your favorite dev tools
  • Easily embed your agents into new or existing applications like web apps, Slack bots, and more

Build Better Agentic Apps, Faster

With high-level abstractions that reduce boilerplate, you can focus on business-specific logic – not infrastructure

  • Rapid iteration cycles for testing and deploying agents
  • Built-in patterns for production readiness
  • Best practices for cloud integration baked in

Simplified & Extensible Tooling

Authoring and invoking tools just got easier:

  • Local processing and custom tool creation made simple
  • Built-in support for authentication and integration
  • Upcoming MCP integration allows seamless access to prebuilt tools and components

Rich Agentic Patterns

From simple chat to complex workflows, the ADK makes it easy to:

  • Support multi-turn conversations without the need to manage memory
  • Coordinate multiple agents (chaining, routing, agent-as-tool, etc.)
  • Orchestrate deterministic workflows, leveraging familiar Python ecosystems without introducing new abstractions

Ready to Get Started?

Explore the docs, try out our starter examples, and begin building with the ADK + OCI Generative AI Agents today. https://docs.oracle.com/en-us/iaas/Content/generative-ai-agents/adk/api-reference/quickstart.htm

Getting started with your first agent

Installing the OCI ADK is as simple as installing the OCI itself.

pip install "oci[adk]"

Now you have everything you need to start coding with the library. Next we need to take care of the authentication. The ADK provides an AgentClient class to simplify handling authentication and management of agent resources. API key authentication is the default and most common method for authenticating with OCI services, and works as following:

from oci.addons.adk import AgentClient
 
client = AgentClient(
    auth_type="api_key",
    profile="DEFAULT",
    region="<your-region>"  # OCI region such as "us-chicago-1" or airport code such as "ORD"
)

To set up API key authentication, follow the OCI API key setup guide.

Next, provision an agent in the OCI Console. To provision your agent, navigate to the OCI Console using the following link: https://cloud.oracle.com/genai-agent and log in with your account.  From the menu on the left, select Agents, then click the Create Agent button.  You don’t need to add any tools to the agent through the Console at this stage – we’ll use ADK to add them later.

OCI Agent Review and Create

After the agent endpoint is created, make a copy of its OCID and wait for the agent to complete the creation process.

OCI GenAI Agent Endpoint

After your agent endpoint is active, you can set up and run the following simple weather agent example using the ADK.

from typing import Dict
from oci.addons.adk import Agent, AgentClient, tool
 
# Use @tool to signal that this Python function is a function tool.
# Apply standard docstring to provide function and parameter descriptions.
@tool
def get_weather(location: str) -> Dict[str, str]:
    """
    Get the weather for a given location.
 
    Args:
      location(str): The location for which weather is queried
    """
    return {"location": location, "temperature": 72, "unit": "F"}
 
 
def main():
    # Create an agent client with your authentication and region details
    # Replace the auth_type with your desired authentication method.
    client = AgentClient(
        auth_type="api_key",
        profile="DEFAULT",
        region="us-chicago-1",
    )
 
    # Create a local agent object with the client, instructions, and tools.
    # You also need the agent endpoint id. To obtain the OCID, follow Step 1.
    agent = Agent(
        client=client,
        agent_endpoint_id="<your-agent-endpoint-OCID>",
        instructions="You perform weather queries using tools.",
        tools=[get_weather]
    )
 
    # Sync local instructions and tools to the remote agent resource
    # You only need to invoke setup() when you change instructions and tools
    agent.setup()
 
    # Run the agent. You can embed this method in your webapp, slack bot, etc.
    # You invoke the run() when you need to handle your user's request.
    input = "Is it cold in Seattle?"
    response = agent.run(input)
 
    # Print the response
    response.pretty_print()
 
if __name__ == "__main__":
    main()

 

Then just run the quickstart.py script

python quickstart.py

Now you have a simple weather agent using ADK running locally, with outbound connection to your agent endpoint on OCI.

This agent is equipped with a local custom function tool get_weather that you implemented. The agent is ready to handle your user’s request expressed in natural language. Behind the scenes, ADK handles the low-level client-server orchestration, while the Agent Endpoint handles running the core agent loop, talking to a powerful LLM, and potentially invoking other hosted tools such as RAG tool (not implemented in this quick start guide).

How the OCI Generative AI Agents ADK works

The ADK is typically embedded within a larger application and deployed in your environment. This application could be a web app, a Slack bot, a service, a script, and more. With the ADK’s function tools, you can easily integrate agents with your local codebase, remote databases, microservices, and other resources using the authentication mechanisms native to your environment.

The ADK communicates with the Agent Endpoint exposed by OCI Generative AI Agents, which runs the agent loop remotely from your environment. When the agent loop needs to use a hosted tool (such as a RAG tool), the call is handled directly by OCI Generative AI Agents without involving the ADK. However, when the agent loop needs to call a local function tool, control is passed back to the ADK. The ADK then invokes your local function, collects the output, and submits it back to the Agent Service, which resumes the agent loop for the next iteration.

https://agents.oraclecorp.com/adk/images/how-it-works.png

 

To learn more and get started today with the OCI Generative AI Agents ADK, visit this guide in the documentation.

For more information about Oracle Cloud Infrastructure and OCI Agents, see the following resources::