Pakistan's First Oracle Blog

RAG (Retrieval-Augmented Generation) is great for looking things up. But it’s not memory. Real AI agents need continuity — they need to remember user preferences, past decisions, policies, and completed work across sessions. That’s where a proper memory system comes in.

This guide shows how to evolve basic RAG into a production-grade memory layer that gives your agents true statefulness, continuity, and governance.

Why Basic RAG Falls Short

• No multi-turn continuity — agents forget what was just discussed
• No resumability — close the tab and everything is lost
• No long-term recall of user preferences or policies
• Prompts grow uncontrollably, leading to higher costs and lost-in-the-middle problems

RAG is retrieval. Memory is a write path + retrieval + governance loop.

What a Real Memory System Looks Like

A memory system adds a durable write path and a manager that decides what to store, how to retrieve it, and how to rebuild the prompt on every turn. It turns one-time lookup into reusable, governed knowledge.

Core loop per turn:

1. Append user message to trace
2. Retrieve relevant typed memory (policy, preferences, facts, episodes)
3. Reassemble prompt from memory (never accumulate transcript)
4. Call the model
5. Extract and promote new artifacts through a gate

The Five Types of Memory

Don’t throw everything into one vector store. Separate concerns:

1. Policy Memory

Rules, guardrails, compliance constraints. Exact-match lookup, never similarity.

2. Preference Memory

User settings and personalization (“always return JSON”, “use DD/MM/YYYY”). Fast keyed lookup.

3. Fact Memory

Durable assertions with provenance (“Acme’s production DB is in us-east-1”). Hybrid lexical + semantic retrieval.

4. Episodic Memory

Summaries of completed tasks. Reusable patterns for similar future work.

5. Trace Memory

Raw execution log for replay, debugging, and audit. Append-only, high volume.

Storage Tradeoffs That Matter

• Short-term vs Long-term — Keep working set in RAM, durable state in the database
• Filesystem vs Database — Files are great for single-tenant prototypes; databases are required for multi-tenant production
• Typed tables vs single store — Separate tables per memory type give you the right indexes, retention, and access patterns

Two Retrieval Paths You Need

1. Known-scope lookup — Policy and preferences (exact match, runs every turn)
2. Semantic discovery — Facts and episodes (hybrid lexical + vector search)

Always filter by scope before ranking — never after.

How to Add Memory to Your Agent (Practical Steps)

1. Type your memory — label everything as policy, preference, fact, episodic, or trace
2. Scope every record (tenant_id, user_id, agent_id)
3. Build a promotion gate that decides what gets stored durably
4. Reassemble the prompt on every turn from memory (don’t accumulate transcript)
5. Instrument the entire loop for replay and audit

Conclusion

RAG gives you lookup. A memory system gives you continuity, personalization, and governed recall. The difference is the write path, typed storage, scoped retrieval, and a manager that reassembles context intelligently on every turn.

Once you have a real memory layer, your agents stop feeling stateless and generic. They start to feel like they actually know the user, remember past work, and follow the right rules — every single time.

Models are shared. Your memory system is what makes your AI product yours.

Start small, type your memory early, and build the promotion gate before you scale. The investment pays off the moment your users come back for a second conversation.

AI agents are powerful, but they introduce a serious new risk: they act as autonomous insiders with broad database access. Traditional application-layer security can’t keep up. Oracle Deep Data Security changes that by enforcing end-user authorization directly inside the database — even when AI agents, vibe-coded apps, or analytics tools query data on a user’s behalf.

Now available in Oracle AI Database 26ai, Deep Data Security brings true “security at the source” to the agentic era.

The Problem: Privileged Access in the AI Era

Most applications use highly privileged database connections. The app layer is supposed to filter data for each user. But AI agents don’t follow predefined queries — they generate their own. This creates massive risk of unauthorized data exposure, especially with prompt injection or unexpected agent behavior.

Even vibe-coded or rapidly evolving applications can’t be trusted to enforce security perfectly every time.

How Oracle Deep Data Security Solves It

Deep Data Security lets you propagate the real end-user identity and context (via OAuth tokens or direct authentication) into the database at runtime. Declarative data grants then enforce row-level, column-level, and cell-level access based on who the user is — not on what the application or agent asks for.

The database automatically rewrites every query to apply the correct authorization rules before any data is returned. This works consistently whether the request comes from a traditional app, an AI agent, or a direct SQL query.

Real-World Example: Human Capital Management (HCM)

Consider an HR table containing sensitive employee data (SSN, salary, phone number, etc.).

• Emma (employee) should only see her own record.
• Marvin (her manager) should see his own record plus his direct reports, but not SSN or home address.

With Deep Data Security, both users (or any AI agent acting on their behalf) can query the same table. The database automatically returns only the data each person is authorized to see — no application code required.

Key Capabilities

• End users (distinct from schema users) authenticate directly to the database
• Data roles + data grants define precise row/column access using predicates
• ORA_END_USER_CONTEXT.username resolves the current user’s identity at runtime
• Works for AI agents, traditional apps, analytics tools, and direct SQL
• Centralized policy management — no duplication of security logic across layers

Getting Started (FastLab Highlights)

Oracle provides a complete LiveLab to explore Deep Data Security in minutes. Here’s the core flow:

1. Create end users (Emma and Marvin)
2. Define data roles (HRAPP_EMPLOYEES and HRAPP_MANAGERS)
3. Create data grants with predicates like:

   WHERE upper(user_name) = upper(ORA_END_USER_CONTEXT.username)

   or manager lookup logic
4. Connect as each user and run queries — the database enforces boundaries automatically

Even if an AI agent generates unexpected SQL, the results are still correctly restricted.

Analyst Perspective

Leading analysts agree this is a critical shift for the agentic era:

“Oracle Deep Data Security introduces identity-aware, fine-grained access control enforced at the database layer… This is a big step up from application-layer controls that are hard to enforce consistently across rapidly evolving agentic workflows.” — Steve McDowell, NAND Research Conclusion

In the age of autonomous AI agents, security at the application layer is no longer enough. Oracle Deep Data Security moves enforcement to the database — where the data lives — giving you consistent, trustworthy, and auditable protection regardless of how data is accessed.

Modern applications and AI workloads demand global speed, strong security, and simple operations. Cloudflare@OCI delivers exactly that by combining Oracle Cloud Infrastructure’s powerful compute and AI platform with Cloudflare’s massive global edge network (330+ cities worldwide).

This strategic partnership lets you accelerate and protect your OCI workloads without managing multiple vendors or complex integrations.

Key Benefits of Cloudflare@OCI

• Significantly reduce latency for users worldwide with Cloudflare’s global CDN
• Protect against DDoS, bots, and API threats at the edge — before traffic reaches OCI
• Apply consistent security policies across hybrid, multicloud, and on-premises environments
• Simplify procurement and billing — everything is available directly in the OCI Console
• Lower data transfer costs through the Bandwidth Alliance (zero egress fees for OCI Object Storage in North America)

Four Service Bundles to Match Your Needs

Choose the right level of edge protection and performance:

• Cloudflare Business Services — Essential CDN, DDoS protection, WAF, and basic rate limiting
• Cloudflare Enterprise Entry — Advanced certificate management, load balancing, and logging
• Cloudflare Enterprise Essential — Optimized routing, enhanced DDoS protection, and accelerated DNS
• Cloudflare Enterprise Advanced — Full security suite including Bot Management, advanced rate limiting, content scanning, and client-side protection

Perfect for AI Workloads

AI applications require low latency, strong security, and reliable global delivery. Cloudflare@OCI helps you:

• Accelerate AI inference and model serving at the edge
• Secure AI APIs and vector search endpoints
• Protect against prompt injection and other emerging AI threats
• Deliver consistent performance for distributed AI systems across regions

How to Get Started

1. Log in to the OCI Console
2. Navigate to Identity & Security
3. Browse and select the Cloudflare@OCI package that fits your needs
4. Purchase and connect your OCI workloads to Cloudflare
5. Configure policies and deploy in minutes

Conclusion

Cloudflare@OCI gives you the best of both worlds: OCI’s high-performance cloud infrastructure paired with Cloudflare’s industry-leading edge security and global performance platform — all managed through a single, Oracle-led experience.

Whether you’re building traditional web apps, modern microservices, or production AI systems, this partnership helps you deliver faster, safer, and more reliable experiences to users everywhere.

Regular expressions (regex) are one of the most powerful tools for working with text in Oracle AI Database. Whether you need to validate phone numbers, extract email addresses, clean messy data, or enforce complex business rules, Oracle’s built-in regex support makes it fast, efficient, and easy to implement directly in SQL.

Why Use Regular Expressions in Oracle?

• Centralize complex pattern-matching logic in the database instead of the application layer
• Enforce data quality and business rules with CHECK constraints
• Search, replace, and transform text with simple SQL functions
• Greatly simplify data validation, extraction, and cleansing tasks

Oracle SQL Regex Functions

Oracle provides five powerful functions/conditions for regular expressions:

Function / ConditionDescription REGEXP_LIKEReturns TRUE if the string matches the pattern (perfect for WHERE clauses and CHECK constraints) REGEXP_COUNTCounts how many times the pattern appears REGEXP_INSTRReturns the position where the pattern starts REGEXP_SUBSTRExtracts the matching substring REGEXP_REPLACEReplaces matching text with new content Basic Syntax and Options

REGEXP_LIKE(source_string, pattern [, match_parameter])

Common match parameters:

• 'i' — case-insensitive
• 'c' — case-sensitive (default)
• 'n' — dot (.) matches newline
• 'm' — multiline mode (^ and $ match start/end of lines)
• 'x' — ignore whitespace in pattern

Practical Examples Example 1: Enforce Phone Number Format with a CHECK Constraint

CREATE TABLE contacts (
    last_name  VARCHAR2(30),
    phone      VARCHAR2(30)
    CONSTRAINT valid_phone 
    CHECK (REGEXP_LIKE(phone, '^\(\d{3}\) \d{3}-\d{4}$'))
);

Example 2: Count Occurrences (Case-Insensitive)

SELECT REGEXP_COUNT('Albert Einstein', 'e', 1, 'i') AS count_e
FROM dual;

Example 3: Extract Email Addresses

SELECT REGEXP_SUBSTR(email, '\w+@\w+(\.\w+)+') AS email_address
FROM employees;

Example 4: Reposition Characters with Back References

SELECT 
    names,
    REGEXP_REPLACE(names, '^(\S+)\s(\S+)\s(\S+)$', '\3, \1 \2') AS formatted_name
FROM famous_people;

POSIX and PERL-Influenced Operators

Oracle supports the full set of POSIX operators plus useful PERL-style shortcuts:

• \d — digit
• \w — word character (alphanumeric + underscore)
• \s — whitespace
• \A, \Z, \z — string anchors
• Nongreedy quantifiers (+?, *?, etc.)

Best Practices

• Use regex in CHECK constraints to enforce data quality at the database level
• Prefer regex over complex string functions when pattern matching is involved
• Test thoroughly — regex can be tricky with edge cases
• Use the 'x' flag to make complex patterns more readable
• Combine with other SQL features (e.g., REGEXP_REPLACE inside UPDATE statements)

Conclusion

Regular expressions in Oracle AI Database give you enterprise-grade text processing power directly in SQL. From simple validation to complex data transformation, regex lets you solve real-world text problems efficiently without leaving the database.

Whether you’re cleaning data, enforcing business rules, or building sophisticated search features, mastering Oracle regex will make you a much more effective developer.

Building applications on Oracle AI Database that scale, stay fast, and remain secure in production requires deliberate design choices. The Oracle Real-World Performance group has proven over years of testing that three simple practices make the biggest difference: **bind variables**, **instrumentation**, and **set-based processing**.

These techniques are even more critical in the AI era, where applications often combine transactional workloads with AI agents, vector search, and MCP Server interactions.

1. Always Use Bind Variables

Bind variables are one of the easiest ways to dramatically improve scalability and security.

Instead of concatenating strings into SQL (which causes hard parsing, latch contention, and SQL injection risks), use placeholders:

-- Bad: String concatenation
INSERT INTO test (x, y) VALUES (''' || REPLACE(x, '''', '''''') || ''', ''' || REPLACE(y, '''', '''''') || '''');

-- Good: Bind variables
INSERT INTO test (x, y) VALUES (:x, :y);

Benefits:

• Only one statement is parsed and cached in the shared pool
• Massive reduction in latches and CPU overhead
• Supports thousands of users without performance degradation
• Protects against SQL injection attacks

2. Add Instrumentation Everywhere

Instrumentation means adding debug/trace code that helps you understand exactly what your application is doing at runtime.

In Oracle, this is as simple as setting MODULE and ACTION in V$SESSION or enabling SQL Trace. When something goes wrong in a multi-tier or AI-augmented application, trace files quickly show you which tier is causing the issue.

Good practice in PL/SQL or application code:

DBMS_APPLICATION_INFO.SET_MODULE(module_name => 'AI_AGENT_WORKFLOW', 
                                 action_name => 'PROCESS_CUSTOMER_DATA');

Instrumentation is essential when working with AI agents, MCP Server, or Private Agent Factory — it lets you trace exactly what the LLM is doing in the database.

3. Prefer Set-Based Processing Over Iterative (Row-by-Row)

For large data volumes, set-based SQL is orders of magnitude faster than row-by-row processing.

Row-by-Row (Slow)

DECLARE
  CURSOR c IS SELECT * FROM ext_scan_events;
BEGIN
  FOR r IN c LOOP
    INSERT INTO stage1_scan_events VALUES r;
    COMMIT;   -- Very expensive!
  END LOOP;
END;

Set-Based (Fast)

ALTER SESSION ENABLE PARALLEL DML;

INSERT /*+ APPEND */ INTO stage1_scan_events
SELECT * FROM ext_scan_events;

COMMIT;

Why set-based wins:

• Eliminates network round-trips and repeated parsing
• Leverages Oracle’s parallel execution and direct-path loads
• Reduces commits dramatically
• Handles billions of rows efficiently

Array processing and manual parallelism are better than pure row-by-row, but set-based SQL remains the clear winner for performance.

Summary: Three Rules for Real-World Performance

1. Use bind variables everywhere — for security and scalability
2. Instrument your code — so you can debug and monitor AI-augmented workflows
3. Think in sets, not rows — let the database do the heavy lifting

Conclusion

In the AI era, applications are more complex than ever — mixing OLTP, vector search, agents, and analytics. Following these three real-world performance practices will keep your Oracle AI Database applications fast, scalable, and easy to maintain.

Small design decisions made early (bind variables, instrumentation, set-based SQL) deliver massive returns in production.

Need to calculate different aggregates based on conditions in a single query — without multiple subqueries or CASE statements? Oracle AI Database 26ai introduces **Aggregation Filters**, a clean and powerful new feature that makes conditional SUM, COUNT, AVG, and other aggregates much simpler.

What Are Aggregation Filters?

Aggregation filters let you apply a WHERE condition directly inside an aggregate function. Only rows that match the condition are included in that specific calculation.

Syntax

aggregate_function ( expression ) FILTER ( WHERE condition )

Works with any aggregate function: SUM, COUNT, AVG, MAX, MIN, etc.

Practical Examples Example 1: Count Only Active Records

SELECT COUNT(*) FILTER (WHERE status = 'ACTIVE') AS active_count
FROM employees;

Example 2: Sum Salaries for a Specific Department

SELECT SUM(salary) FILTER (WHERE department = 'SALES') AS sales_total
FROM employees;

Example 3: Multiple Conditional Counts in One Query

SELECT
    COUNT(*) FILTER (WHERE status = 'ACTIVE')   AS active_count,
    COUNT(*) FILTER (WHERE status = 'INACTIVE') AS inactive_count
FROM employees;

Example 4: Quarterly Sales Breakdown in One Pass

SELECT
    year,
    SUM(sales)                                   AS year_sales,
    SUM(sales) FILTER (WHERE qtr_num IN (1, 2)) AS q1q2_sales,
    SUM(sales) FILTER (WHERE qtr_num IN (3, 4)) AS q3q4_sales
FROM sales_fact f
LEFT OUTER JOIN time_dim t ON (f.time_id = t.month_id)
GROUP BY year
ORDER BY year;

Key Notes

• Aggregation filters are evaluated after the main WHERE clause of the query.
• They provide a much cleaner alternative to writing separate subqueries or complex CASE expressions.
• You can combine multiple filtered aggregates in the same SELECT list.

Best Practices

• Use aggregation filters whenever you need different conditional totals in the same result set
• They are especially powerful for reporting, dashboards, and analytics queries
• Combine with GROUP BY for even more flexible breakdowns
• Great for simplifying queries that previously required multiple CTEs or subqueries

Conclusion

Aggregation filters are a small but incredibly useful enhancement in Oracle AI Database 26ai. They make your SQL cleaner, more readable, and more performant by eliminating unnecessary subqueries and complex logic.

Whether you’re building reports, dashboards, or analytical applications, aggregation filters will quickly become one of your favorite new SQL features.

JSON-Relational Duality Views let you expose your relational tables as flexible JSON documents — and update them both ways — without any data duplication. Here’s a practical, step-by-step guide to creating them.

Why Create Duality Views?

• Developers get simple JSON documents for modern apps
• DBAs keep normalized, relational tables for consistency and analytics
• Both views work on the exact same underlying data

Simple Duality View Example (Department)

-- 1. Create the underlying relational table
CREATE TABLE dept_tab (
    deptno    NUMBER(2,0) PRIMARY KEY,
    dname     VARCHAR2(14),
    code      NUMBER(13,0),
    state     VARCHAR2(15),
    country   VARCHAR2(15)
);

-- 2. Create the Duality View
CREATE JSON RELATIONAL DUALITY VIEW dept_dv AS
  SELECT JSON { '_id'      : d.deptno,
                'deptName' : d.dname,
                'location' : { 'zipcode' : d.code,
                               'country' : d.country }
    FROM dept_tab d
    WITH UPDATE INSERT DELETE;

This view now supports clean JSON documents while the data stays normalized in the table.

More Complex Example: Orders with Nested Data

CREATE OR REPLACE JSON RELATIONAL DUALITY VIEW orders_ov AS
SELECT JSON { '_id'          : ord.order_id,
              'orderTime'    : ord.order_datetime,
              'orderStatus'  : ord.order_status,
              'customerInfo' : (SELECT JSON { 'customerId'   : cust.customer_id,
                                             'customerName' : cust.full_name,
                                             'customerEmail': cust.email_address }
                                FROM customers cust 
                                WHERE cust.customer_id = ord.customer_id),
              'orderItems'   : (SELECT JSON_ARRAYAGG(
                                   JSON { 'orderItemId' : oi.line_item_id,
                                          'quantity'    : oi.quantity,
                                          'productInfo' : ...,
                                          'shipmentInfo': ... }
                                 ) 
                                 FROM order_items oi 
                                 WHERE ord.order_id = oi.order_id)
    }
FROM orders ord
WITH INSERT UPDATE DELETE;

Controlling Updatability

Use the WITH clause to control what operations are allowed:

• WITH INSERT UPDATE DELETE — Fully updatable (default for root table)
• WITH NOINSERT NODELETE NOUPDATE — Read-only
• You can override at column level: WITH NOUPDATE or WITH UPDATE

Key Rules for Duality Views

• Every underlying table needs at least one identifying column (primary key, unique key, or identity column)
• Use nested subqueries for 1-to-N relationships → becomes a JSON array
• Use UNNEST for 1-to-1 relationships to merge into the same object
• Supported column types include VARCHAR2, NUMBER, DATE, JSON, VECTOR, etc.
• Each duality view has a single DATA column of type JSON

Automatic Metadata Fields

Every document automatically includes:

{
  "_metadata": {
    "etag": "abc123...",     -- for optimistic concurrency
    "asof": 1234567890       -- system change number (SCN)
  }
}

Best Practices

• Start with simple single-table views to learn the pattern
• Use meaningful field names in JSON (not just column names)
• Combine with AI Vector Search or Private Agent Factory for powerful AI apps
• Always test updates through both the document view and relational tables

Conclusion

Creating JSON-Relational Duality Views is straightforward with a simple SQL statement. You get the best of both worlds: document flexibility for modern apps and relational power for analytics and integrity — all on the same data.

Oracle AI Database 26ai introduces **JSON-Relational Duality Views** — a powerful feature that lets you access the exact same data as either relational tables **or** JSON documents, without any data duplication or complex synchronization.

It gives you the flexibility of documents and the power of relational databases at the same time.

Why Duality Views Matter

• Developers love JSON documents for their simplicity and hierarchy
• DBAs and analysts love relational tables for normalization, consistency, and analytics
• Duality views let both teams work on the **same underlying data** using whichever model fits their needs

How Duality Views Work

A duality view is a declarative mapping between relational tables and JSON documents. The data is stored **relationally** (in tables), but you can read and write it as JSON documents — the database automatically handles the assembly and disassembly.

Changes made through the document view instantly appear in the tables, and vice versa.

Simple Example

-- 1. Create the underlying relational table
CREATE TABLE dept_tab (
    deptno    NUMBER(2,0) PRIMARY KEY,
    dname     VARCHAR2(14),
    code      NUMBER(13,0),
    state     VARCHAR2(15),
    country   VARCHAR2(15)
);

-- 2. Create the Duality View
CREATE JSON RELATIONAL DUALITY VIEW dept_dv AS
  SELECT JSON { '_id'      : d.deptno,
                'deptName' : d.dname,
                'location' : { 'zipcode' : d.code,
                               'country' : d.country }
    FROM dept_tab d
    WITH UPDATE INSERT DELETE;

This single view now supports a collection of JSON documents like this:

{
  "_id"      : 200,
  "deptName" : "HR",
  "location" : {
    "zipcode" : 94065,
    "country" : "USA"
  }
}

Key Benefits

• Document-centric apps can use MongoDB API, ORDS, or SQL/JSON functions
• Relational apps can query the underlying tables directly with SQL
• No data duplication — everything stays normalized and consistent
• Full updatability (INSERT, UPDATE, DELETE) on the document side
• Multiple duality views can be built on the same tables for different use cases

Advanced Capabilities

• Some columns can be left unmapped (not exposed in JSON)
• You can store parts of the document as native JSON columns for maximum flexibility
• Fields can be generated automatically or hidden for internal use
• Views can be fully updatable, partially updatable, or read-only

Best Practices

• Use duality views for applications that need both flexible documents and strong relational integrity
• Start simple — map one or two tables first
• Leverage JSON columns for complex nested structures that don’t need normalization
• Combine with Oracle AI Vector Search, Private Agent Factory, or MCP Server for powerful AI use cases

Conclusion

JSON-Relational Duality Views eliminate the traditional trade-off between document and relational models. You get the best of both worlds in a single, high-performance, secure Oracle Database engine.

Whether you’re building modern microservices, AI-powered applications, or traditional enterprise systems, duality views give you maximum flexibility without compromising on data integrity or performance.

 

Want your AI tools and LLMs to generate accurate SQL queries and truly understand your database? AI Enrichment lets you add business context, descriptions, and metadata to your schema — without changing any data or structure.

This powerful feature turns opaque database schemas into clear, AI-friendly assets.

What is AI Enrichment?

AI Enrichment is the process of adding human-readable descriptions, synonyms, business context, and logical groupings to your database objects (schemas, tables, and columns).

It helps LLMs and AI agents understand the real meaning and relationships in your data, dramatically improving the quality of generated SQL and natural language responses.

Why AI Enrichment Matters

• Raw table/column names (like T1, C123, EMP_ID) are ambiguous to LLMs
• Enrichment provides the missing business context
• Leads to more accurate, efficient, and trustworthy AI-generated queries
• Makes your database truly AI-ready for tools like Select AI, MCP Server, and Agent Factory

How It Works with LLMs

When you ask an AI tool a question, it automatically pulls your enrichment metadata and injects it into the prompt sent to the LLM. This gives the model rich context such as:

“The table EMPLOYEE contains current and former staff. EMP_ID is also known as employee number or worker id...” Getting Started Prerequisites

• VS Code 1.101.0 or higher
• Oracle SQL Developer for VS Code 25.3.0 or higher
• Active connection to your Oracle Database
• User with CREATE VIEW, CREATE TABLE, CREATE SEQUENCE, CREATE PROCEDURE privileges

Step 1: Enable AI Enrichment

1. Open your database connection in SQL Developer for VS Code
2. Expand the connection → Click the AI Enrichment folder
3. Click Yes to create the required metadata objects

Step 2: Use the AI Enrichment Dashboard

The dashboard is your central command center. It shows:

• Schema-level description
• Table groups and enrichment percentage
• Intelligent suggestions for missing context

Enrich Your Schema Step-by-Step 1. Define Schema Business Context

In the dashboard, add a high-level description under “About this schema”, for example:

This schema manages core HR processes including employees, departments, payroll, and benefits.

2. Create Table Groups

Group related tables by business domain (e.g., “Employee Management”, “Payroll”, “Recruitment”). This helps LLMs understand logical relationships even without foreign keys.

3. Enrich Tables & Columns

• Add clear natural language descriptions
• Create key-value annotations (synonyms, business rules, valid values, etc.)
• Mark tables as “Enrichment Complete” when done

Best Practices

• Start with the most important / frequently queried tables
• Use consistent, concise language in descriptions
• Add synonyms and common business terms as annotations
• Keep enrichment up-to-date as your schema evolves
• Use Table Groups to reflect real business domains

Conclusion

AI Enrichment is one of the highest-ROI steps you can take to make your Oracle Database truly intelligent and AI-ready. By investing a little time in adding context today, you unlock much more accurate and useful AI interactions tomorrow.

Whether you're using Select AI, MCP Server, Private Agent Factory, or any LLM-powered tool — enriched schemas deliver dramatically better results. 

Oracle AI Database 26ai is a converged, AI-native platform that brings together transactional, analytical, and AI workloads in one secure, high-performance engine. It eliminates data movement, reduces complexity, and delivers enterprise-grade capabilities for modern AI-powered applications.

AI Designed for Data Foundational AI Technologies

• Unified Hybrid Vector Search — Combine semantic vector search with relational, JSON, graph, spatial, and text search in a single query.
• Model Context Protocol (MCP) Server — Enables AI agents and LLMs to interact directly with the database for iterative reasoning and accurate results.
• Built-in Data Privacy Protection — Row, column, and cell-level security with dynamic masking so agents only see authorized data.
• Oracle Unified Memory Core — Low-latency reasoning across all data types (vector, JSON, graph, relational, etc.) in one engine.
• Oracle Exadata for AI — Hardware + software co-engineered for massive acceleration of vector queries via AI Smart Scan and offload.
• NVIDIA Integration — Support for NVIDIA NIM containers and future GPU acceleration via Private AI Services Container.

AI for Application Development

• Private Agent Factory — No-code visual builder to create, deploy, and manage secure data-centric AI agents (Knowledge Agent, Data Analysis Agent, etc.).
• Select AI Agent — In-database framework for building and orchestrating agentic workflows.
• AI Semantic Modeling — Helps AI understand data context for better code generation and answers.
• Unified Data Model — Access the same data as relational, JSON document, or graph using SQL.

End Data Chaos – Converged Data Architecture

• Native support for relational, vector, JSON, graph, spatial, and more — all in one database
• Unified support for OLTP, analytics, AI Vector Search, Agentic AI, IoT, and streaming
• Single management plane via Oracle Enterprise Manager and OCI Database Management

End Data Lock-in – Open & Multicloud

• Autonomous AI Lakehouse with full Apache Iceberg support
• Oracle Vectors on Ice — Run AI Vector Search directly on Iceberg tables in your data lake
• Available on OCI, AWS, Azure, Google Cloud, and on-premises (Exadata, etc.)
• Oracle APEX for rapid low-code development

End Data Risk – Mission-Critical Security & Availability

• Oracle Database Vault, Label Security, SQL Firewall, Deep Data Security
• Flashback Technologies and Zero Data Loss Cloud Protect
• Real Application Clusters (RAC), Active Data Guard, Globally Distributed Database with RAFT replication
• Post-quantum cryptography support
• True Cache for consistent mid-tier caching

Conclusion

Oracle AI Database 26ai is more than just a database — it’s a complete AI-powered data platform that brings together vectors, agents, analytics, and mission-critical OLTP in one secure, high-performance engine.

Whether you’re building RAG applications, agentic workflows, or modern data lakehouses, Oracle AI Database gives you the convergence, security, and performance enterprises demand — without data movement or lock-in.

Modern OLTP systems power the heartbeat of business — processing orders, payments, bookings, and customer interactions with strict demands for low latency, high concurrency, and unbreakable reliability. Oracle AI Database delivers exactly what mission-critical OLTP needs, combining decades of proven engineering with the latest AI and converged database innovations.

Enterprise-Grade High Availability

Oracle AI Database is built for continuous operations using Maximum Availability Architecture (MAA):

• Real Application Clusters (RAC) — Active-active clustering with instant failover and Transparent Application Continuity that masks outages from applications.
• Active Data Guard — Zero-data-loss protection, automatic failover, and offload reporting to standby databases.
• Globally Distributed Database — Sharded active-active architectures for massive scale across regions.

Predictable Low Latency & High Performance

Especially powerful on Exadata, Oracle AI Database delivers consistently low tail latency:

• Sub-millisecond reads and commits even under heavy load
• AI Smart Scan and storage offload for faster processing
• RDMA networking and XRMEM for ultra-low latency communication
• Partner Cache Reads to maintain performance during maintenance or failures

Rock-Solid Concurrency & Scalability

• Advanced multi-version concurrency control (MVCC) for consistent reads without blocking writers
• Optimized redo logging for predictable commit behavior
• RAC Cache Fusion for efficient block sharing across cluster nodes
• Proven ability to handle thousands of concurrent sessions and mixed OLTP + analytics workloads

Superior Data Protection & Recoverability

Oracle provides unmatched protection against both technical and human errors:

• Flashback Technologies — Query or rewind the database, tables, or individual transactions to any point in time while staying online.
• Online schema changes and Edition-Based Redefinition for zero-downtime application upgrades.
• Comprehensive RMAN backup and recovery with fast incremental backups and block-level recovery.

Enterprise Security Built into the Database

• Database Vault, Label Security, and Virtual Private Database for fine-grained access control
• Transparent Data Encryption and Key Vault for data at rest
• SQL Firewall to block injection attacks and unauthorized SQL
• Unified Auditing and Deep Data Security for agentic AI workloads
• Post-quantum cryptography support (ML-KEM, etc.)

Operational Maturity & Ease of Management

• Automatic Workload Repository (AWR), Active Session History (ASH), and SQL Monitor for deep diagnostics
• Multitenant architecture for efficient consolidation and fleet management
• Powerful automation with Fleet Patching & Provisioning and Enterprise Manager

Converged Capabilities for Modern Applications

Oracle AI Database is not just an OLTP engine — it’s a converged platform that supports:

• JSON document store (SODA)
• AI Vector Search for semantic capabilities
• Graph, spatial, and machine learning — all in the same database
• Apache Iceberg support for lakehouse integration

Conclusion

For organizations that require predictable performance, continuous availability, strong security, and operational excellence in their transactional systems, Oracle AI Database remains the most mature and capable platform available today.

Whether running on Exadata, Cloud, or on-premises, it delivers the reliability enterprises have trusted for decades — now enhanced with powerful AI and converged data capabilities for the next generation of intelligent applications.

Creating and maintaining vector indexes on millions of embeddings can be painfully slow on CPU alone. Oracle AI Database (23ai/26ai) now lets you offload this heavy lifting to a GPU — delivering massive performance gains while keeping your database CPU free for queries and transactions.

In this practical guide, you’ll learn how to set up GPU-powered vector index creation using the Private AI Services Container — perfect for developers and DBAs who want faster indexing without complex infrastructure.

Why GPU Offload Matters for Vector Workloads

• CPU-based HNSW index creation is slow on large datasets
• GPU can build indexes significantly faster (often 5x–10x depending on data size)
• Frees up database CPU for real-time similarity searches
• Easy to run on separate machines (on-prem or cloud)

High-Level Architecture

Your Oracle AI Database sends embedding vectors to a remote GPU container over a secure HTTPS connection. The GPU builds the index and sends it back. The whole process is transparent to your SQL queries.

Prerequisites (Keep It Minimal)

• Oracle AI Database 23ai or 26ai (Free or Enterprise)
• One NVIDIA GPU with compute capability 7.5+ (RTX 3060, A10, A100, etc.)
• Oracle Linux 8 or 9 on the GPU machine
• At least 24GB VRAM recommended for good performance

Step-by-Step Setup Overview 1. Prepare the GPU Server

# Update system and install GPU drivers (OCI GPU images come pre-installed)
sudo dnf update -y

# Install NVIDIA Container Toolkit
curl -s -L https://nvidia.github.io/libnvidia-container/stable/rpm/nvidia-container-toolkit.repo | sudo tee /etc/yum.repos.d/nvidia-container-toolkit.repo
sudo dnf install -y nvidia-container-toolkit

# Verify GPU
nvidia-smi

2. Install Podman and Pull the Container

sudo dnf install -y container-tools

# Login to Oracle Container Registry
podman login container-registry.oracle.com

# Pull the GPU Index Service image
podman pull container-registry.oracle.com/database/private-ai:gpu-index-26.1.0.0.0

3. Run the Easy Setup Scripts

# Extract setup scripts from container
IMAGEID=`podman create container-registry.oracle.com/database/private-ai:gpu-index-26.1.0.0.0`
podman cp $IMAGEID:/privateai/scripts/privateai-setup-gpu-index-26.1.0.0.0.zip .
unzip privateai-setup-gpu-index-26.1.0.0.0.zip

# Run configuration
mkdir -p ~/privateai ~/secrets
cd setup
./secretsSetup.sh -s ~/secrets
./configSetup.sh -d ~/privateai -s ~/secrets
./containerSetup.sh -d ~/privateai

4. Start and Verify the Service

podman ps
curl --http2-prior-knowledge --cacert ~/secrets/cert.pem https://$(hostname -f):8443/health

Connect from Oracle AI Database

-- In your database session
BEGIN
  DBMS_VECTOR_INDEX.SET_OFFLOAD(
    offload_url => 'https://your-gpu-host:8443/v1/index',
    api_key     => 'your-api-key-from-secrets',
    cert_path   => '/path/to/cert.pem'
  );
END;
/

Best Practices & Tips

• Run the GPU container on a separate machine from the database for best results
• Start with smaller datasets to test performance gains
• Monitor GPU utilization with nvidia-smi during index creation
• Use TLS 1.3 (automatically configured by the setup scripts)
• Scale vertically with bigger GPUs or horizontally with multiple GPU nodes later

Expected Results

Users typically see **dramatic reductions** in index creation time — especially on datasets with millions of vectors. Your database remains responsive while the heavy compute happens on the GPU.

Next Steps

Once set up, you can create vector indexes normally using DBMS_VECTOR_INDEX.CREATE_INDEX — the offload happens automatically in the background.

Most AI agents fail in the real world because they don’t have secure, real-time access to enterprise data. Oracle solves this by bringing AI directly to your data — and now you can do it on production-grade Exadata infrastructure completely free during development and testing.

Why This Matters for Developers

• No more moving or duplicating sensitive data to build RAG or agentic apps
• Work with real Exadata performance (AI Smart Scan, RDMA, Smart Flash)
• Full access to Oracle AI Vector Search, JSON, Graph, and converged database features
• Zero Oracle Database licensing cost for dev/test environments

Oracle AI Database Private Agent Factory

A no-code / low-code platform to build powerful, secure AI agents that work directly with your enterprise data:

• Knowledge Agent — Ready-to-use RAG over your documents and internal systems
• Data Analysis Agent — Natural language analytics directly on structured data
• Visual Agent Builder — Drag-and-drop workflow designer with tools, data sources, and LLMs
• Built-in security, auditing, row-level access controls, and human-in-the-loop

In-Database AI Vector Search on Exadata

Store vectors alongside relational, JSON, and unstructured data in the same database. Run hybrid semantic + SQL queries at lightning speed thanks to Exadata’s AI Smart Scan and storage offload.

No separate vector database. No data synchronization headaches.

Exadata Database Service for Developers — Free Tier

Oracle now offers a dedicated developer environment on full Exadata infrastructure with:

• Real Exadata hardware and software (same as production)
• Oracle AI Database 26ai features included
• Zero license cost for development and testing
• Resource limits appropriate for dev workloads

Quick Start Steps

1. Provision a free Exadata Database Service for Developers instance
2. Deploy Oracle AI Database Private Agent Factory from Oracle Cloud Marketplace
3. Use the Visual Agent Builder to connect agents to your data
4. Build RAG agents, analysis agents, or custom multi-agent workflows
5. Test with real Exadata performance before moving to production

Best Practices for Success

• Keep data movement to absolute minimum — let agents query data where it lives
• Use in-database vector indexes for fast similarity search
• Start with pre-built agents and customize them
• Implement strict governance and approval workflows for production agents
• Leverage Exadata’s hardware acceleration for large-scale vector workloads

Conclusion

Oracle AI Database Private Agent Factory combined with the free Exadata Database Service for Developers gives you everything you need to build secure, high-performance AI agents on real enterprise data — at zero license cost during development.

Stop moving data to AI. Bring AI to your data — on the world’s best database platform for it.

Agentic AI systems are incredibly powerful — but they can quietly burn through your API budget in minutes if left unchecked. A single agent that gets stuck in a retry loop, over-delegates, or keeps calling expensive models can turn a $2 task into a $200 surprise.

Here’s a practical, developer-friendly approach to add smart runtime budget controls that prevent runaway costs without killing useful work.

Why Most Budget Controls Fail in Agentic AI

• Post-run dashboards only tell you what already happened.
• Hard token caps feel too restrictive and stop good runs prematurely.
• Developers need controls that understand context — not just raw numbers.

The solution? Lightweight runtime spending limits that watch behavior in real time and take smart action before costs explode.

Core Idea: Context-Aware Budget Tracking

Instead of a simple dollar counter, track three things at every step:

• Actual spend so far
• Estimated remaining cost for the current plan
• Progress score — is the agent actually getting closer to the goal?

Implementation in 5 Minutes (Python Example)

class BudgetGuard:
    def __init__(self, max_budget=5.0, warning_threshold=0.7):
        self.max_budget = max_budget          # e.g. $5.00
        self.spent = 0.0
        self.warning_threshold = warning_threshold
    
    def check(self, step_cost_estimate: float, progress_score: float) -> str:
        self.spent += step_cost_estimate
        
        if self.spent > self.max_budget:
            return "TERMINATE"
        
        remaining = self.max_budget - self.spent
        burn_rate_ok = progress_score > 0.3 or remaining > 2.0
        
        if self.spent / self.max_budget > self.warning_threshold and not burn_rate_ok:
            return "DEGRADE"      # switch to cheaper model, limit tools
        
        if self.spent / self.max_budget > 0.9:
            return "APPROVAL"     # pause and ask human
        
        return "CONTINUE"

# Usage in your agent loop
guard = BudgetGuard(max_budget=8.0)

for step in agent_steps:
    estimated_cost = calculate_step_cost(step)   # e.g. model price × tokens
    progress = evaluate_progress(current_state)  # 0.0 to 1.0
    
    decision = guard.check(estimated_cost, progress)
    
    if decision == "TERMINATE":
        print("Budget limit reached - stopping safely")
        break
    elif decision == "DEGRADE":
        agent.switch_to_cheap_model()
        agent.limit_tool_usage()
    # ... continue execution

Smart Actions When Limits Are Hit

• DEGRADE: Switch to faster/cheaper model, disable expensive tools, reduce retry attempts
• APPROVAL: Pause and send a summary to Slack/Teams for human review
• TERMINATE: Gracefully stop with full trace and cost breakdown

Real-World Example: Research Agent Gone Wrong

An agent researching market trends starts calling premium models 40+ times with almost no new insights. Without controls, it easily exceeds $50. With the guard in place:

• After 8 expensive calls with low progress → automatically degrades to a lighter model
• After 12 calls → requests human approval with a one-click summary
• Never reaches the $50 mark

Best Practices for Developers

• Estimate cost before every model call or tool invocation
• Calculate a simple progress score (new information gained, task completeness)
• Log every decision with trace ID for later debugging
• Start with generous limits in dev, tighten them in production
• Combine with token limits and time limits for layered protection

Conclusion

Runtime budget controls turn expensive surprises into predictable, manageable behavior. By checking spend against real progress at every step, you keep your agentic AI systems both powerful and cost-efficient.

No more “I ran one agent and got a $400 bill” stories. Just reliable, governed AI that stays within budget while still delivering results.

: 

Oracle SQLcl just got supercharged. With the built-in **MCP Server**, you can now talk to your Oracle Database using natural language through any AI agent or LLM. It’s one of the most powerful developer productivity tools released for Oracle AI Database professionals.

What is SQLcl MCP Server?

MCP (Model Context Protocol) Server turns SQLcl into a bridge between your Oracle Database and modern AI models. It allows LLMs (like Claude, GPT, Gemini, or local models) to:

• Execute SQL queries interactively
• Generate schema objects and sample data
• Perform data loading and transformation
• Create reports and analytics views
• Build complete applications from prompts

Key Benefits

• Works Everywhere — Oracle 19c, 23ai, 26ai, on-premises, cloud (OCI, AWS, Azure, Google), or even your laptop
• Free & Lightweight — SQLcl is completely free
• Secure — Runs with your existing database credentials and security model
• Highly Extensible — Works with Cline, Cursor, VS Code agents, LangChain, and more

Quick Start: Enable MCP Server

# 1. Start SQLcl
sql /nolog

# 2. Enable MCP Server
MCP START;

# 3. Note the port (usually 8080 or 5050)
MCP STATUS;

Once running, connect your favorite AI coding agent to the MCP endpoint and start chatting with your database.

Real-World Use Cases

• Generate entire schemas with realistic data using a single prompt
• Ask “Show me sales by region last quarter” and get formatted results
• Build RAG applications that query live database data
• Automate data transformation and ETL tasks
• Prototype new features in minutes instead of hours

Best Practices

• Always use a dedicated low-privilege test user when experimenting
• Review AI-generated SQL before executing in production
• Combine with SQLcl Projects (Liquibase + Git) for version control
• Use detailed, structured prompts for best results

Conclusion

Oracle SQLcl with MCP Server is a game-changer for modern Oracle developers and DBAs. It brings the power of AI directly into your database workflow, dramatically increasing productivity while maintaining full control and security.

Whether you’re building new applications, exploring data, or automating routine tasks — SQLcl MCP Server makes your Oracle AI Database truly conversational.

Moving Large Language Models from quick demos to real production is tough. Traffic is unpredictable, context windows grow, and costs can explode if your serving setup isn’t optimized.

Here’s a better way: Use **llm-d** (a Kubernetes-native open-source framework) on Oracle Cloud Infrastructure (OCI) to separate prompt processing from token generation. This “disaggregated” approach delivers more consistent latency, higher GPU efficiency, and lower overall cost — without throwing more hardware at the problem.

Why Traditional LLM Serving Falls Short in Production

• Prompt ingestion (prefill) is compute-heavy
• Token generation (decode) is memory-bandwidth sensitive
• Running both on the same GPU replicas leads to poor utilization and inconsistent latency
• Scaling out identical replicas wastes resources under real user loads

llm-d solves this by letting you run specialized workers for prefill and decode phases independently — giving each phase exactly what it needs.

Key Benefits You’ll See in Production

• 10–30% better GPU efficiency
• Much more stable latency even as user count grows
• Lower infrastructure cost for the same performance
• Easy scaling using familiar Kubernetes tools

Architecture Overview

llm-d on OCI uses Oracle Kubernetes Engine (OKE) + Bare Metal AMD MI300X GPUs. Prefill workers handle heavy prompt processing, while decode workers focus on fast token streaming. RDMA networking keeps communication between nodes extremely fast.

Quick Start: Deploy llm-d on OKE 1. Prepare Your OKE Cluster

# Create OKE cluster with AMD MI300X bare metal nodes
# Use shapes like BM.GPU.MI300X.8 for high-memory GPUs

# Install kubectl and configure access
oci ce cluster create-kubeconfig --cluster-id <your-cluster-id>

2. Deploy llm-d with Disaggregated Mode

# Clone the llm-d repo with OCI/AMD examples
git clone https://github.com/llm-d/llm-d.git
cd llm-d

# Apply the disaggregated deployment (prefill + decode)
kubectl apply -f examples/oci-amd/disaggregated/

# Check pods
kubectl get pods -n llm-serving
kubectl get services -n llm-serving

3. Configure Your Model

# Example values for Llama-3.1-70B or similar
model:
  name: meta-llama/Llama-3.3-70B-Instruct
  tensor-parallel: 8
  pipeline-parallel: 2

serving:
  prefill:
    replicas: 4
    gpu-memory-utilization: 0.85
  decode:
    replicas: 8
    gpu-memory-utilization: 0.75

Real-World Performance Gains

Teams running disaggregated inference on OCI typically see:

• Flatter, more predictable latency curves under load
• Better throughput per GPU compared to traditional serving
• Ability to serve more concurrent users on the same hardware

Best Practices for Production

• Start with 2–4 node clusters and scale horizontally
• Monitor GPU utilization separately for prefill and decode pods
• Use OCI Monitoring + Prometheus for custom dashboards
• Implement request routing based on prompt length when possible
• Enable auto-scaling based on queue depth and latency SLAs

Conclusion

llm-d on OCI gives you a modern, production-ready way to serve large language models efficiently. By separating prefill and decode phases on powerful AMD MI300X GPUs with OKE, you get better performance, lower costs, and much more predictable behavior under real traffic.

Whether you’re building copilots, RAG systems, or agentic workflows — this approach helps you move from “it works in the demo” to “it works reliably at scale.”

Ready to try it? Start with the official llm-d OCI examples and scale from there.

 This video locally installs NemoClaw with OpenShell and vllm Qwen3.5 9B.

Tired of duplicating massive datasets just to add vector search capabilities? With Oracle AI Database 26ai, you can now run high-performance similarity search directly on your existing Apache Iceberg tables stored in object storage — no data copying, no extra ETL pipelines, and no governance headaches.

This feature is a game-changer for data lakes built on Iceberg, Parquet, and cloud storage (OCI Object Storage, S3, etc.).

Why This Matters

• Avoid massive data duplication and sync issues
• Keep data in its original governed location
• Query Iceberg + Oracle tables together in the same SQL
• Create fast vector indexes without moving the source data
• Works great for RAG, semantic search, and recommendation systems

Step-by-Step: Query Iceberg Vectors in Minutes 1. Create External Table over Iceberg

CREATE TABLE ext_iceberg_vectors (
    id           VARCHAR2(100),
    content      CLOB,
    embedding    VECTOR(1024, FLOAT32)   -- match your embedding dimension
)
ORGANIZATION EXTERNAL
(
    TYPE ORACLE_BIGDATA
    DEFAULT DIRECTORY DATA_PUMP_DIR
    ACCESS PARAMETERS
    (
        com.oracle.bigdata.credential.name = 'OCI_CRED',
        com.oracle.bigdata.fileformat = 'parquet',
        com.oracle.bigdata.access_protocol = 'iceberg'
    )
    LOCATION ('iceberg:https://objectstorage.<region>.oraclecloud.com/.../metadata/v1.metadata.json')
)
REJECT LIMIT UNLIMITED;

2. Run Similarity Search (with on-the-fly embedding)

SELECT id,
       content,
       VECTOR_DISTANCE(embedding, 
                       VECTOR_EMBEDDING(embedding_model USING :search_query AS data)) AS score
FROM   ext_iceberg_vectors
ORDER  BY score
FETCH FIRST 10 ROWS ONLY;

3. Speed It Up with Vector Index

CREATE VECTOR INDEX iceberg_vec_idx 
ON ext_iceberg_vectors(embedding)
ORGANIZATION NEIGHBOR PARTITIONS
WITH TARGET ACCURACY 95;

Best Practices for Production

• Use credential objects for secure access to object storage
• Match vector dimension and type exactly with your embedding model
• Create IVF or HNSW indexes for large Iceberg tables
• Combine with Oracle tables in the same query for hybrid search
• Great for air-gapped environments (embeddings run in-database via ONNX)

Real-World Use Cases

• Semantic search over data lake documents
• RAG applications using Iceberg as the knowledge base
• Real-time recommendations without data movement
• Unified analytics across structured + unstructured data

Conclusion

Oracle AI Database 26ai + Apache Iceberg gives you the best of both worlds: the governance and scale of a modern data lake with the powerful, familiar vector search capabilities of Oracle.

No more unnecessary data copies. Just point, index, and query — delivering fast semantic search on your existing Iceberg tables today.

Enterprise AI agents often fail in production due to data security concerns, complex coding, and integration nightmares. Oracle AI Database 26ai’s **Private Agent Factory** changes that — giving developers and DBAs a no-code platform to build, test, and deploy powerful, secure agents that work directly with your private enterprise data.

Whether you need a Knowledge Agent for RAG, a Data Analysis Agent, or custom multi-agent workflows, Agent Factory makes it fast, safe, and production-ready.

Why Enterprises Love Private Agent Factory

• Fully Private & Air-Gapped — Run everything on-premises or in isolated environments
• No-Code Canvas — Drag-and-drop agent builder with visual workflow design
• Native Oracle Integration — Direct access to your database, vector search, and hybrid data
• Secure by Default — Row-level security, data masking, auditing, and SQL Firewall
• Portable Agents — Export using Open Agent Specification to LangGraph, CrewAI, etc.

Key Capabilities

• Pre-built agents for Knowledge (RAG), Data Analysis, Finance, HR, and more
• Connect to documents, databases, SharePoint, Object Storage, and REST APIs
• Choose private LLMs, OCI GenAI, OpenAI, Gemini, or others
• Multi-agent orchestration with human-in-the-loop approval
• REST API + Chat interface for easy application integration

Quick Start: Deploy Your First Agent

# 1. Download from Oracle Cloud Marketplace or Downloads
# 2. Deploy the Agent Factory Container (Docker/Podman)

podman run -d --name agent-factory \
  -p 8080:8080 \
  -v /path/to/data:/app/data \
  oracle/agent-factory:latest

# 3. Access the No-Code Builder
# Open browser → http://your-server:8080

Building an Agent in the Canvas (Typical Flow)

1. Choose a template (e.g., Knowledge Agent)
2. Connect data sources (Oracle Database + Vector Store)
3. Select embedding model and LLM (private or cloud)
4. Define tools and workflows visually
5. Test with sample queries
6. Publish → Get secure REST endpoint

Enterprise-Grade Security Highlights

• In-database row/column/cell level security
• Dynamic data masking for agents
• Full audit trail of agent actions
• SQL Firewall to block injection attacks
• Zero Data Loss Recovery protection

Best Practices for Production Agents

• Start with pre-built templates and customize
• Always use private embeddings and vector indexes
• Implement human approval gates for sensitive actions
• Monitor agent performance and cost via Oracle AI Database tools
• Export agents for version control and cross-team reuse

Conclusion

Oracle Private Agent Factory removes the biggest barriers to enterprise Agentic AI — security, complexity, and integration. You can now build trustworthy agents that combine your private data with powerful LLMs, all while staying in full control.

Perfect for developers who want speed and DBAs who demand governance. Available at no extra cost with Oracle AI Database 26ai — on cloud, on-premises, or hybrid.

Ready to build your first production agent? Check out the hands-on labs and get started today.