Oracle Agentic AI for Oracle AI Database

Vector search begins with turning data into numbers that capture meaning. You learn what an embedding is, how its dimensions and format matter, and how to store vectors beside ordinary columns.

• What an embedding represents
• The VECTOR data type, its dimensions and formats
• Generating embeddings outside and inside the database
• Loading and managing embedding models
• Storing vectors alongside relational data
• Choosing an embedding model for the content

You build A table that holds source text and its embeddings, generated and loaded end to end.

Finding relevant data means measuring how close vectors are. You compare distance metrics, run exact top-K searches, and combine them with ordinary filters to answer real questions.

• Cosine, Euclidean, dot product and other metrics
• Matching the metric to the embedding model
• VECTOR_DISTANCE and exact nearest-neighbor queries
• Top-K queries and similarity thresholds
• Filtering by relational attributes
• Reading execution plans for vector queries

You build A set of similarity queries on your embedding table, with metrics compared.

Exact search slows as data grows. You build approximate indexes such as HNSW and IVF, trade accuracy against speed, and size the memory they need so that they perform as intended.

• Approximate versus exact search
• HNSW graph indexes
• IVF partition indexes
• Target accuracy and its effect on speed
• Sizing and monitoring vector memory
• Index maintenance as data changes

You build Two index types on one dataset, with accuracy, speed and memory use compared.

Meaning alone misses exact terms, and keywords alone miss meaning. You combine vector and keyword search, merge their scores and add relational filters to get the best of each.

• Where vector search misses and keyword search wins
• Hybrid vector indexes in outline
• Combining and weighting scores
• Metadata filters and access controls in search
• Evaluating search quality with test queries
• Tuning a hybrid search over time

You build A hybrid search over one document collection, with test queries showing where it beats either method alone.

RAG joins search to a language model. You chunk and embed documents, keep them in a vector store, retrieve by meaning, and send the passages to OCI Generative AI services to produce grounded, citable answers.

• Chunking documents for retrieval
• Embedding models and the vector store
• Semantic search for the retrieval step
• Prompting OCI Generative AI with retrieved passages
• Citations and handling no-answer cases
• Evaluating retrieval and answer quality
• Refreshing data as sources change

You build An end-to-end RAG application over a real document set, with cited answers.

Select AI Agents bring agent behavior into the database. You learn how an agent, its tools and its tasks fit together, and configure an agent that automates a business workflow under database privileges.

• Agent, tool and task: how the pieces fit
• Connecting an agent to a language model
• Configuring built-in and custom tools
• Automating a business workflow step by step
• Privileges and identity for an agent
• Testing an agent’s behavior with sample requests

You build A configured Select AI agent that automates one business workflow.

A first configuration rarely holds up. You refine instructions and tools from test results, handle errors and ambiguity, and choose a deployment pattern that fits how the agent will be called.

• Refining instructions from failed requests
• Handling ambiguity and unsafe requests
• Human confirmation for sensitive actions
• Deployment patterns: application, scheduled and conversational
• Monitoring agent activity and cost
• Versioning and promoting an agent between environments

You build A refined agent with a test suite and a chosen deployment pattern.

MCP lets outside agents use database capabilities as tools. You learn the protocol’s concepts, configure the server, expose the right tools and secure the connection, so that agents work with the database safely.

• Model Context Protocol concepts: tools, resources, clients
• Configuring the database MCP server
• Choosing which database tools to expose
• Authentication and least-privilege access
• Connecting an external agent to the server
• Orchestrating several tools in one workflow
• Testing and debugging an MCP connection

You build An external agent connected to a database MCP server, using three tools.

Not every agent should be built from scratch. You work with pre-built agents and templates, develop a custom agent for what they do not cover, and manage agents through their whole life.

• What Private Agent Factory provides
• Using pre-built agents and templates
• Developing a custom agent
• Connecting agents to data and tools
• Managing the agent lifecycle: build, test, release, retire
• Choosing between Private Agent Factory and Select AI Agents

You build A custom agent built from a template, with a lifecycle plan.

Combine vector search, RAG, agents and MCP in one solution. You pick the right component for each need, build it, and show how it keeps data secure and answers grounded.

• Scoping a business problem and its data
• Choosing among the building blocks
• Building the retrieval and agent layers
• Exposing and consuming tools through MCP
• Evaluating answers and agent actions
• Presenting the design and its limits

You build An agent solution over enterprise data, with grounded answers and a security review.