Oracle Agentic AI for Oracle Data Platform

Flows are built from models, prompts and tools, so you need those first. You cover how language models work in practice, what an agent does with tools in a loop, and where agents go wrong.

• Language models, tokens and context
• Prompts, instructions and structured output
• Tool calling and the agent loop
• Agents versus fixed workflows
• Typical failures: hallucination, loops and wrong tools

You build A short written comparison of a workflow and an agent for one task.

An agent on the platform is a flow of connected nodes. You learn how triggers, agents, guardrails and tools connect, how data passes between them, and how to design a flow in the visual builder or in code.

• Nodes and connections in a flow
• Triggers, agents, guardrails and tools as node types
• Passing data between nodes
• Planning branches and error paths
• Building visually and in code
• Reading and debugging a flow

You build A flow diagram and a first working flow with one agent and one tool.

A flow must start for the right reason and stay inside safe bounds. You decide what starts an agent and what input it receives, then place guardrails on what goes in and what comes out.

• Choosing what should start a flow
• Defining and validating the input a trigger passes on
• Guardrails on incoming requests
• Guardrails on what an agent returns
• Limiting repeat and runaway runs
• Testing guardrails with hostile input

You build A trigger and guardrail design, with test cases that try to break it.

Agents answer better from your documents than from memory. You prepare content for a knowledge base, connect it through the RAG tool, and measure whether the agent retrieves what it should.

• What a knowledge base holds and how it is built
• Preparing and chunking source content
• Embeddings and semantic retrieval
• Using the RAG tool in a flow
• Grounding answers and citing sources
• Measuring retrieval quality and fixing misses

You build A knowledge base and a flow that answers questions from it with citations.

Letting an agent write free SQL against governed data is risky. You define SQL tools with fixed queries and typed parameters, so agents get the data they need and nothing else.

• Why predefined queries are safer than free-form SQL
• Writing parameterized queries for agent use
• Typed parameters and input validation
• Describing a SQL tool so the model uses it correctly
• Read-only access and limits on what a query returns
• Testing a SQL tool with awkward inputs

You build Three parameterized SQL tools, each tested with awkward inputs.

Prompts are reused, so they should be managed. You build prompt templates with variables, write tool descriptions that guide the model, and keep prompts testable as they change.

• Prompt templates with variables
• Writing instructions and a role for an agent node
• Tool descriptions that lead to correct calls
• Few-shot examples inside templates
• Testing and versioning templates

You build A set of prompt templates with tests, used by an agent in your flow.

Sometimes the platform’s own tools are not enough. You add custom Python code for logic of your own, and call outside services through HTTP requests, with care for secrets, errors and timeouts.

• When custom code is the right answer
• Writing and testing a Python tool
• Calling external services over HTTP
• Handling authentication and secrets
• Errors, retries and timeouts
• Keeping custom code reviewable

You build A custom Python tool and an HTTP tool added to an agent flow.

MCP lets agents use tools hosted elsewhere through one standard. You connect a flow to remote MCP servers, decide which of their tools an agent may use, and judge how far to trust each one.

• MCP concepts: servers, tools and clients
• Connecting a flow to a remote MCP server
• Choosing which tools to allow
• Authentication and trust boundaries
• Handling a slow or unavailable server
• Comparing MCP, HTTP and custom code

You build A flow that uses a tool from a remote MCP server, with access limits set.

Combine retrieval, SQL and extension tools in one flow for a real question. You design it, add guardrails, test it, and show that it respects the platform’s governance.

• Choosing a business question for an agent
• Designing the flow and its tools
• Building retrieval, SQL and extension nodes
• Adding guardrails and checks
• Testing against real and hostile cases
• Documenting the flow for others

You build A complete agent flow over governed data, with guardrails and a test record.