Fahd Mirza on AI, Cloud, DevOps and Databases

Weekly AI Recap - Qwen3.7, MTP in llama.cpp, SANA and More | May 2026

2026-05-24T00:29:31.201-07:00

AI Enrichment in Oracle SQL Developer for VS Code: Make Your Database AI-Ready

2026-05-24T00:26:50.963-07:00

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

Open your database connection in SQL Developer for VS Code
Expand the connection → Click the AI Enrichment folder
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: The Complete Guide to Key Features

2026-05-09T23:47:00.000-07:00

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.

Why Oracle AI Database is the Best Choice for Modern OLTP Workloads

2026-05-08T23:46:00.000-07:00

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.

Speed Up Vector Search in Oracle AI Database: GPU Offload Made Simple

2026-05-01T23:27:00.000-07:00

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.

Build Enterprise AI Agents on Real Exadata - Zero Database License Cost for Development

2026-04-29T23:44:00.000-07:00

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

Provision a free Exadata Database Service for Developers instance
Deploy Oracle AI Database Private Agent Factory from Oracle Cloud Marketplace
Use the Visual Agent Builder to connect agents to your data
Build RAG agents, analysis agents, or custom multi-agent workflows
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.

Building Cost-Safe AI Agents: Practical Runtime Spending Limits That Actually Work

2026-04-24T23:25:00.000-07:00

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 + MCP Server: Chat with Your Database Using AI

2026-04-22T23:40:00.000-07:00

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.

Run Production LLMs Faster & Cheaper on OCI: Practical Guide to llm-d with Disaggregated Inference

2026-04-10T23:29:00.000-07:00

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.

NemoClaw Tutorial: Run Locally with Free Local Models: Easy Guide

2026-03-18T21:42:00.000-07:00

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

Run Semantic Search Directly on Apache Iceberg Tables with Oracle AI Database 26ai

2026-03-07T21:35:00.000-08:00

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.

Build Secure Enterprise AI Agents in Minutes: Oracle Private Agent Factory

2026-03-06T21:31:00.000-08:00

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)

Choose a template (e.g., Knowledge Agent)
Connect data sources (Oracle Database + Vector Store)
Select embedding model and LLM (private or cloud)
Define tools and workflows visually
Test with sample queries
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.

Prompt Engineering Magic: Build Complete Oracle Schemas in Minutes with SQLcl MCP Server + AI Agent

2026-02-13T21:39:00.000-08:00

Starting a new project with an empty database schema? Stop writing DDL scripts manually. With **SQLcl MCP Server** and any good AI agent (Cline, Cursor, Claude, etc.), you can generate realistic tables, relationships, sample data, and useful views — all from a single well-crafted prompt.

This powerful combination turns natural language into production-ready database objects in under 5 minutes.

Why This Approach Rocks

Zero manual DDL writing
Consistent, realistic sample data with proper constraints
Foreign keys, indexes, comments — all handled automatically
Ready-to-use views for dashboards
Works with any Oracle database (19c, 23ai, 26ai, etc.)

Prerequisites

SQLcl with MCP Server enabled
VS Code + SQL Developer for VS Code extension
An AI coding agent (Cline recommended)
A test database user with CONNECT, RESOURCE, and DB_DEVELOPER_ROLE

The Ultimate Starter Prompt

Copy and paste this prompt into your AI agent (replace <USERNAME> with your schema name):

# Create realistic vehicle schema with sample data and views

## Task
1. Connect as user <USERNAME>. If unsure, list available connections and ask me to choose.

2. Create these tables with proper constraints:
   - car, truck, motorcycle (with make, model, year, engine_displacement, wheelbase, etc.)
   - manufacturer (dba_name, hq_city, hq_country, founded_year, ownership_type)

   Add: Primary keys, Foreign keys, Indexes, Comments, and any useful extra columns.

3. Insert realistic sample data:
   - 50 rows each for car/truck/motorcycle
   - 25 rows for manufacturer
   Use bulk INSERT statements and COMMIT after each.

4. Show first 5 rows of every table to verify.

5. Create these 4 views + recommend 2 more useful ones with comments:
   - Vehicle Count by Manufacturer
   - Average Engine Displacement by Vehicle Type
   - Vehicles by Year of Manufacture
   - Manufacturer Details with Vehicle Counts

6. Once done, disconnect from the database.

How to Execute

Start SQLcl MCP Server
In your AI agent (e.g. Cline), create a new task and attach the prompt
Switch to **Plan** mode first → Review the plan
Switch to **Act** mode and let the agent execute
Approve steps as they appear

What You’ll Get Automatically

4 fully normalized tables with proper relationships
Realistic sample data (no duplicates, valid FKs)
Indexes and comments for maintainability
4+ useful analytical views ready for dashboards
Clean, commented SQL you can version-control

Best Practices & Tips

Always review the plan before switching to Act mode
Use a dedicated test schema
Be extremely specific in your prompt — the more details, the better the result
Save successful prompts in a library for reuse
Combine with SQLcl Projects (Liquibase + Git) for version control

Conclusion

SQLcl MCP Server + a smart AI agent is one of the fastest ways to bootstrap Oracle schemas in 2025–2026. What used to take hours of tedious scripting now takes minutes of thoughtful prompting.

Try it today — you’ll never want to create sample schemas manually again.

SODA Collections with Partitioning in Oracle Database: The Practical Guide

2026-02-06T21:42:00.000-08:00

Need to store large volumes of JSON documents in SODA collections while keeping query performance high? You can now combine the simplicity of SODA with the power of Oracle table partitioning using **Mapped Collections**.

This approach lets you scale SODA collections efficiently without sacrificing flexibility.

Why Partition SODA Collections?

Improve query performance on time-based or range-based data
Enable easy data archiving and purging (drop old partitions)
Better manage storage and maintenance for large document stores
Support massive document workloads while keeping SODA APIs simple

Two Easy Ways to Add Partitioning

Option 1: Using a Trigger (Most Flexible)

CREATE TABLE MYCOL (
    "ID"           VARCHAR2(255) NOT NULL,
    "CREATED_ON"   TIMESTAMP DEFAULT SYS_EXTRACT_UTC(SYSTIMESTAMP) NOT NULL,
    "LAST_MODIFIED" TIMESTAMP DEFAULT SYS_EXTRACT_UTC(SYSTIMESTAMP) NOT NULL,
    "VERSION"      VARCHAR2(255) NOT NULL,
    "JSON_DOCUMENT" BLOB,
    "ORDER_TIMESTAMP" TIMESTAMP NOT NULL,
    PRIMARY KEY ("ID"),
    CHECK ("JSON_DOCUMENT" IS JSON FORMAT JSON STRICT)
)
LOB("JSON_DOCUMENT") STORE AS (CACHE)
PARTITION BY RANGE (ORDER_TIMESTAMP) 
(
    PARTITION p2019 VALUES LESS THAN (TIMESTAMP '2020-01-01 00:00:00'),
    PARTITION p2020 VALUES LESS THAN (TIMESTAMP '2021-01-01 00:00:00'),
    PARTITION p2021 VALUES LESS THAN (TIMESTAMP '2022-01-01 00:00:00')
);

-- Trigger to populate partition key from JSON
CREATE OR REPLACE TRIGGER MYCOL_PART_TRG
BEFORE INSERT OR UPDATE ON MYCOL
FOR EACH ROW
BEGIN
    :NEW.ORDER_TIMESTAMP := JSON_OBJECT_T.PARSE(:NEW.JSON_DOCUMENT).GET('timestamp').TO_TIMESTAMP;
END;
/

Option 2: Using a Virtual Column (Simpler, No Trigger)

CREATE TABLE MYCOL (
    "ID"            VARCHAR2(255) NOT NULL,
    "CREATED_ON"    TIMESTAMP DEFAULT SYS_EXTRACT_UTC(SYSTIMESTAMP) NOT NULL,
    "LAST_MODIFIED" TIMESTAMP DEFAULT SYS_EXTRACT_UTC(SYSTIMESTAMP) NOT NULL,
    "VERSION"       VARCHAR2(255) NOT NULL,
    "JSON_DOCUMENT" BLOB,
    "ORDER_TIMESTAMP" TIMESTAMP GENERATED ALWAYS AS 
        (JSON_VALUE("JSON_DOCUMENT", '$.timestamp' RETURNING TIMESTAMP)) NOT NULL,
    PRIMARY KEY ("ID"),
    CHECK ("JSON_DOCUMENT" IS JSON FORMAT JSON STRICT)
)
LOB("JSON_DOCUMENT") STORE AS (CACHE)
PARTITION BY RANGE (ORDER_TIMESTAMP) 
(
    PARTITION p2019 VALUES LESS THAN (TIMESTAMP '2020-01-01 00:00:00'),
    PARTITION p2020 VALUES LESS THAN (TIMESTAMP '2021-01-01 00:00:00')
);

Create a Mapped SODA Collection

DECLARE
    metadata CLOB;
    col      SODA_COLLECTION_T;
BEGIN
    metadata := '{
        "tableName": "MYCOL",
        "keyColumn": {"name":"ID", "sqlType":"VARCHAR2", "maxLength":255, "assignmentMethod":"UUID"},
        "contentColumn": {"name":"JSON_DOCUMENT", "sqlType":"BLOB", "compress":"NONE", "cache":true},
        "versionColumn": {"name":"VERSION", "method":"SHA256"},
        "lastModifiedColumn": {"name":"LAST_MODIFIED"},
        "creationTimeColumn": {"name":"CREATED_ON"}
    }';

    col := DBMS_SODA.CREATE_COLLECTION('MYCOL', metadata, DBMS_SODA.CREATE_MODE_MAP);
END;
/

Best Practices & Tips

Use ISO 8601 format for timestamp fields in your JSON documents
Enable row movement if documents may change partitions: ALTER TABLE MYCOL ENABLE ROW MOVEMENT;
Partition pruning works perfectly with regular SQL queries
You can still use all SODA operations (insert, find, replace, etc.) normally
Remember: Drop mapped collections via SODA API first, then drop the table manually if needed

Conclusion

With Mapped Collections, you can bring the full power of Oracle partitioning to your SODA document stores. Whether you prefer triggers or virtual columns, the setup is straightforward and gives you excellent performance and manageability for large-scale JSON workloads.

This pattern is perfect for time-series data, audit logs, event stores, and any high-volume document use case.

Oracle 19c Developer: Super Fast JSON Handling with New Features

2026-01-23T21:16:00.000-08:00

Oracle Database 19c brings major improvements in JSON handling, making it production-ready for modern applications. Developers can now store, query, and index JSON documents with near-relational performance.

Why JSON in Oracle 19c is a Game Changer

Native JSON data type with automatic validation
High-performance JSON search indexes
Powerful SQL/JSON functions with better optimization
Seamless integration with existing relational data

1. Creating JSON Columns & Tables

CREATE TABLE api_logs (
    log_id        NUMBER GENERATED ALWAYS AS IDENTITY,
    log_date      DATE DEFAULT SYSDATE,
    payload       JSON,                    -- Native JSON type
    CONSTRAINT json_check CHECK (payload IS JSON)
);

2. Inserting JSON Data

INSERT INTO api_logs (payload) VALUES (
    JSON_OBJECT(
        'user_id' VALUE 12345,
        'action' VALUE 'login',
        'status' VALUE 'success',
        'items' VALUE JSON_ARRAY(10, 20, 30),
        'metadata' VALUE JSON_OBJECT('ip' VALUE '192.168.1.1', 'browser' VALUE 'Chrome')
    )
);

3. Super Fast Querying

-- Simple queries
SELECT 
    payload.user_id,
    payload.status,
    JSON_VALUE(payload, '$.metadata.ip') AS client_ip
FROM api_logs 
WHERE JSON_EXISTS(payload, '$.action');

-- Complex filtering (very fast with index)
SELECT * FROM api_logs 
WHERE JSON_VALUE(payload, '$.status') = 'success'
  AND JSON_EXISTS(payload, '$.items[*]?(@ > 15)');

4. JSON Search Index (The Real Performance Booster)

-- Create a search index (highly recommended for production)
CREATE SEARCH INDEX api_logs_idx ON api_logs(payload) 
FOR JSON 
PARAMETERS('SYNC EVERY 5 MINUTES');

-- Oracle automatically maintains this index

Performance Tip: JSON search indexes can improve query speed by 10x–100x on large datasets.

5. Updating & Merging JSON

-- Update specific fields
UPDATE api_logs 
SET payload = JSON_MERGEPATCH(payload, 
    JSON_OBJECT('status' VALUE 'failed', 'error_code' VALUE 401))
WHERE log_id = 100;

Best Practices for Developers

Always create a JSON Search Index on frequently queried columns.
Use JSON_SERIALIZE when returning large JSON to clients.
Combine JSON with relational columns for hybrid models.
Monitor index usage with DBA_INDEX_USAGE.
Avoid storing extremely large JSON documents (> 32KB) in one column.

Conclusion

With Oracle 19c’s enhanced JSON capabilities, developers can build modern APIs and microservices without needing a separate NoSQL database. The combination of native JSON type + search indexes gives you the best of both relational power and document flexibility.

Start using JSON today — your queries will thank you!

Oracle 19c | JSON | Developer Tips | Performance

Tags: Oracle 19c, JSON, SQL/JSON, JSON Search Index, Developer Features

Oracle 19c DBA: Fast PDB Clone & Refresh in Multitenant Environment

2026-01-17T20:42:00.000-08:00

Need to refresh a development PDB from production quickly in Oracle 19c? Here’s the fastest method.

Commands

-- On Source CDB
CREATE PLUGGABLE DATABASE dev_pdb FROM prod_pdb 
  FILE_NAME_CONVERT=('/u01/data/prod_pdb/','/u01/data/dev_pdb/') 
  SNAPSHOT COPY;

-- Open it
ALTER PLUGGABLE DATABASE dev_pdb OPEN;

-- Refresh (if using snapshot copy)
ALTER PLUGGABLE DATABASE dev_pdb CLOSE;
ALTER PLUGGABLE DATABASE dev_pdb OPEN UPGRADE;
-- Apply changes and reopen READ WRITE

Advantage in 19c: Snapshot Copy is extremely fast and uses almost zero additional storage.

Oracle 19c | Multitenant | PDB Clone | DBA

Oracle 19c Developer Feature: Automatic Indexing – Let Oracle Do the Work

2026-01-16T20:41:00.000-08:00

Oracle 19c introduced **Automatic Indexing** – a game changer for developers and DBAs dealing with slow queries.

How to Enable & Monitor

-- Enable Automatic Indexing
EXEC DBMS_AUTO_INDEX.CONFIGURE('AUTO_INDEX_MODE','IMPLEMENT');

-- Check status
SELECT * FROM DBA_AUTO_INDEX_CONFIG;

-- Monitor auto indexes created
SELECT owner, table_name, index_name, status 
FROM dba_indexes 
WHERE index_type = 'FUNCTION-BASED NORMAL' 
AND index_name LIKE 'SYS_AI%';

Developer Benefit: No more manual index creation for ad-hoc queries. Oracle automatically creates, monitors, and drops unused indexes.

Oracle 19c | Automatic Indexing | Performance

Oracle 19c DBA Tip: Fix ORA-01555 Snapshot Too Old Error Quickly

2026-01-10T20:40:00.000-08:00

One of the most frustrating errors DBAs face in Oracle 19c is ORA-01555: snapshot too old. Here’s a practical fix.

Cause

Undo retention is too low or undo tablespace is undersized for long-running queries.

Solution

-- Check current settings
SHOW PARAMETER undo_retention;
SELECT tablespace_name, size_in_gb FROM (
  SELECT tablespace_name, ROUND(SUM(bytes)/1024/1024/1024,2) size_in_gb 
  FROM dba_data_files GROUP BY tablespace_name);

-- Fix
ALTER SYSTEM SET undo_retention=7200 SCOPE=BOTH;   -- 2 hours

-- Resize undo tablespace
ALTER TABLESPACE UNDOTBS1 RESIZE 10G;

Pro Tip (Developer): Use /*+ RESULT_CACHE */ or smaller batch processing in long queries.

Oracle Database 19c Best Practices: Essential Tips for Performance, Security & High Availability

2026-01-09T20:38:00.000-08:00

Oracle Database 19c is the final long-term support release of the 19c family. Following proven best practices ensures better performance, security, stability, and easier maintenance.

1. Architecture & Installation Best Practices

Always use Multitenant Architecture (CDB + PDB) for new deployments.
Separate Oracle Home from data files and FRA (Fast Recovery Area).
Enable Automatic Memory Management (AMM) or use appropriate SGA/PGA settings.
Install latest RU (Release Update) / RUR patches regularly.

2. Database Configuration Best Practices

-- Enable key parameters
ALTER SYSTEM SET db_flashback_retention_target=1440 SCOPE=BOTH;  -- 1 day
ALTER SYSTEM SET undo_retention=3600 SCOPE=BOTH;
ALTER SYSTEM SET enable_ddl_logging=TRUE SCOPE=BOTH;
ALTER SYSTEM SET diagnostic_dest='/u01/app/oracle/diag' SCOPE=BOTH;

Use Automatic Undo Management and set proper undo tablespace size.
Enable Force Logging for GoldenGate / Data Guard setups.
Configure proper REDO log size (minimum 1GB per group) and multiple groups.
Turn on Automatic Statistics Gathering (default in 19c).

3. Security Best Practices

Use Oracle Unified Auditing (recommended over traditional auditing).
Implement Database Vault and Label Security where required.
Enforce strong password policies and profile limits.
Regularly rotate passwords and use Oracle Wallet for TDE (Transparent Data Encryption).
Apply least privilege principle – avoid granting DBA role unnecessarily.

4. Performance Tuning Best Practices

Regularly gather system statistics and fixed object statistics.
Use AWR, ADDM, and ASH reports for performance analysis.
Implement Index usage monitoring and rebuild indexes when needed.
Use Real Application Testing (RAT) before major changes.
Enable In-Memory Column Store for analytical workloads.

5. High Availability & GoldenGate Best Practices

Use Data Guard for disaster recovery (Maximum Performance mode for most cases).
For GoldenGate:
- Always enable supplemental logging at database and table level.
- Use dedicated GoldenGate tablespaces.
- Implement Checkpoint Table.
- Monitor lag using LAG EXTRACT * and set alerts.
- Use Parallel Extract/Replicat for high volume environments.

6. Backup & Recovery Best Practices

-- Configure RMAN
CONFIGURE RETENTION POLICY TO RECOVERY WINDOW OF 7 DAYS;
CONFIGURE BACKUP OPTIMIZATION ON;
CONFIGURE DEFAULT DEVICE TYPE TO DISK;
CONFIGURE CONTROLFILE AUTOBACKUP ON;

Take consistent RMAN full + incremental backups.
Test your recovery regularly (validate backups).
Use FRA for archived logs and control file autobackups.

7. Monitoring & Maintenance

Configure Enterprise Manager 13c or use Oracle Autonomous Health Framework.
Set up alert notifications for ORA- errors, tablespace full, etc.
Schedule regular purging of audit trails and trace files.
Review alert log daily using ADRCI tool.

Conclusion

Implementing these Oracle 19c best practices will significantly improve your database reliability, performance, and security. Always test changes in a non-production environment first and refer to the latest Oracle documentation for your specific environment.

This post is for educational purposes. Best practices may vary based on workload and business requirements.

Tags: Oracle 19c, Oracle Database Best Practices, Oracle Performance, Oracle Security, GoldenGate, Data Guard, Multitenant

GoldenGate 19c Error: Replicat Abended - ORA-00942 or Mapping Error

2026-01-04T20:37:00.000-08:00

Common Replicat error in GoldenGate 19c: ORA-00942: table or view does not exist or mapping failures.

Cause

Target table does not exist, wrong schema mapping, or missing privileges.

Fix

-- Login to GGSCI on Target
./ggsci

-- Check replicat status
INFO REPLICAT rep1, DETAIL

-- View error report
VIEW REPORT rep1

Solution Steps:

1. Create missing table on target (or use DDL replication)
2. Fix mapping in replicat parameter file:

EDIT PARAMS rep1

-- Add correct mapping
MAP schema_name.*, TARGET target_schema.*;

Then restart Replicat:

STOP REPLICAT rep1
START REPLICAT rep1

Quick Tip: Use ASSUMETARGETDEFS if source and target structures are identical.

GoldenGate 19c | Replicat Error | Fix

GoldenGate 19c Error: ORA-12899 or Supplemental Logging Issues

2026-01-04T00:30:00.000-08:00

Error: Replicat is abending with ORA-12899: value too large for column or Extract is not capturing changes.

Cause

Supplemental logging is not enabled properly at schema or table level.

Fix Commands

-- On Source Database (as SYSDBA)
ALTER DATABASE ADD SUPPLEMENTAL LOG DATA;
ALTER DATABASE FORCE LOGGING;

-- Enable schema level supplemental logging
ADD SCHEMATRANDATA schema_name ALLCOLS

-- OR for specific table
ADD TRANDATA schema_name.table_name ALLCOLS

After enabling logging, restart the Extract process:

STOP EXTRACT ext1
START EXTRACT ext1

Check status:

INFO EXTRACT ext1
SEND EXTRACT ext1, STATUS

GoldenGate 19c | Supplemental Logging | CDC

GoldenGate 19c Error: Extract Not Starting - "No Valid Checkpoint Found"

2026-01-03T20:35:00.000-08:00

One of the most common issues when setting up Oracle GoldenGate 19c is the Extract process failing to start with the error "No valid checkpoint found".

Cause

This usually happens when the Extract is added with BEGIN NOW but the checkpoint was not properly registered or the process was deleted without cleanup.

Fix

-- Stop and delete the existing extract
STOP EXTRACT ext1
DELETE EXTRACT ext1

-- Add extract again with proper checkpoint
ADD EXTRACT ext1, TRANLOG, BEGIN NOW, THREADS 2   -- Use THREADS if using RAC

ADD EXTTRAIL /u01/app/oracle/gg19c/dirdat/lt, EXTRACT ext1

-- Start the extract
START EXTRACT ext1

-- Verify
INFO EXTRACT ext1, DETAIL

Tip: Always use ADD EXTRACT ... ETROLLOVER if you want to start fresh with new trail files.

GoldenGate 19c | Error Fix

Oracle GoldenGate 19c: A Comprehensive Guide to Real-Time Data Replication

2026-01-02T20:30:00.000-08:00

Oracle GoldenGate 19c (19.1.0) is a powerful, high-performance software solution for real-time transactional change data capture (CDC), transformation, and delivery across heterogeneous databases and platforms. It enables zero-downtime migrations, high availability, data integration, and real-time analytics by replicating committed transactions with low latency while maintaining data integrity.

Whether you're synchronizing data between on-premises Oracle databases, moving to the cloud, or feeding data lakes, GoldenGate 19c excels in bidirectional replication, active-active configurations, and support for diverse targets like MySQL, SQL Server, Big Data platforms, and more.

Key Features and Enhancements in GoldenGate 19c

Microservices Architecture (MA): Modern REST API-driven design with web-based management, improved security, and easier scalability (Classic Architecture is still available in 19c but Microservices is recommended for new deployments).
Oracle Database 19c Support and broader heterogeneous capabilities (MySQL 8.0, cross-endian support, etc.).
Enhanced Security: Centralized key management, SSL, encryption, and target-initiated distribution paths.
Performance & Reliability: Parallel processing, schema change tracking, long-running transaction monitoring, and low-impact capture.
Use Cases: Real-time data warehousing, disaster recovery, data synchronization, ETL/ELT, and event-driven architectures.

Prerequisites

Source and target databases in ARCHIVELOG mode.
Supplemental logging and forced logging enabled.
Adequate CPU, memory, and disk space.
Oracle GoldenGate software downloaded from Oracle Software Delivery Cloud.

Installation Steps (Silent Mode Example on Linux)

Unzip the software:

unzip fbo_ggs_Linux_x64_shiphome.zip -d /u01/app/oracle/gg19c

Create a response file (oggcore.rsp):

INSTALL_OPTION=ORA19c
SOFTWARE_LOCATION=/u01/app/oracle/product/gg19c
UNIX_GROUP_NAME=oinstall
INVENTORY_LOCATION=/u01/app/oraInventory

Run silent installation:

cd /u01/app/oracle/gg19c/Disk1
./runInstaller -silent -responseFile /path/to/oggcore.rsp -waitforcompletion

Initial Configuration (Source Database)

-- Enable archive log and supplemental logging
ALTER DATABASE ARCHIVELOG;
ALTER DATABASE ADD SUPPLEMENTAL LOG DATA;
ALTER SYSTEM SET ENABLE_GOLDENGATE_REPLICATION=TRUE SCOPE=BOTH;

-- Create GoldenGate user
CREATE USER c##ggadmin IDENTIFIED BY password CONTAINER=ALL;
GRANT DBA, CONNECT, RESOURCE TO c##ggadmin CONTAINER=ALL;
GRANT UNLIMITED TABLESPACE TO c##ggadmin;

Enable schema-level supplemental logging:

ADD SCHEMATRANDATA schema_name ALLCOLS

GGSCI Commands

cd $GG_HOME
./ggsci

Common GGSCI Commands:

INFO MANAGER
START MANAGER
STOP MANAGER

-- Create Extract
ADD EXTRACT ext1, TRANLOG, BEGIN NOW
ADD EXTTRAIL /u01/app/oracle/gg19c/dirdat/lt, EXTRACT ext1

-- Create Data Pump (optional)
ADD EXTRACT pump1, EXTTRAILSOURCE /u01/app/oracle/gg19c/dirdat/lt
ADD RMTTRAIL /u01/app/oracle/gg19c/dirdat/rt, EXTRACT pump1

-- Create Replicat
ADD REPLICAT rep1, EXTTRAIL /u01/app/oracle/gg19c/dirdat/rt

Example Extract Parameter File (ext1.prm):

EXTRACT ext1
USERID c##ggadmin@source, PASSWORD password
EXTTRAIL /u01/app/oracle/gg19c/dirdat/lt
TABLE schema_name.*;

Monitoring Commands

INFO ALL
STATUS EXTRACT ext1
STATS REPLICAT rep1
LAG EXTRACT *

Best Practices

Use dedicated tablespaces and users for GoldenGate.
Add checkpoint table: ADD CHECKPOINTTABLE
Monitor lag and trail files regularly.
Enable parallelism for high volume.
Test failover and conflict resolution.

Troubleshooting Tips

Check report files in dirrpt/ folder.
Use SEND EXTRACT ext1, STATUS or VIEW REPORT
Common issues: Missing supplemental logging, wrong credentials, network blocks.

Conclusion

Oracle GoldenGate 19c remains one of the best solutions for real-time, low-latency data replication. Start with a simple unidirectional setup and then scale up according to your needs.

Run Microsoft VibeVoice TTS Locally on CPU

2025-09-04T14:25:00.000-07:00

In this tutorial, I install the Microsoft VibeVoice model locally and test.

app.py:

"""

VibeVoice with Fahd Mirza

"""

import argparse

import os

import tempfile

import time

import threading

import subprocess

import numpy as np

import gradio as gr

import librosa

import soundfile as sf

import torch

from pathlib import Path

from typing import Iterator, Dict, Any

# Clone and setup VibeVoice if not already present

vibevoice_dir = Path('./VibeVoice')

if not vibevoice_dir.exists():

print("Cloning VibeVoice repository...")

subprocess.run(['git', 'clone', 'https://github.com/vibevoice-community/VibeVoice'], check=True)

print("Installing VibeVoice...")

subprocess.run(['pip', 'install', '-e', './VibeVoice'], check=True)

print("Installing wheel (required for flash-attn)...")

subprocess.run(['pip', 'install', 'wheel'], check=True)

print("Installing flash-attn...")

try:

subprocess.run(['pip', 'install', 'flash-attn', '--no-build-isolation'], check=True)

except subprocess.CalledProcessError:

print("Warning: flash-attn installation failed. Continuing without it...")

# Add the VibeVoice directory to path

import sys

sys.path.insert(0, str(vibevoice_dir))

# Import VibeVoice modules

try:

from vibevoice.modular.configuration_vibevoice import VibeVoiceConfig

from vibevoice.modular.modeling_vibevoice_inference import VibeVoiceForConditionalGenerationInference

from vibevoice.processor.vibevoice_processor import VibeVoiceProcessor

from vibevoice.modular.streamer import AudioStreamer

except ImportError:

try:

import importlib.util

def load_module(module_name, file_path):

spec = importlib.util.spec_from_file_location(module_name, file_path)

module = importlib.util.module_from_spec(spec)

sys.modules[module_name] = module

spec.loader.exec_module(module)

return module

config_module = load_module(

"vibevoice_config",

vibevoice_dir / "modular" / "configuration_vibevoice.py"

)

VibeVoiceConfig = config_module.VibeVoiceConfig

model_module = load_module(

"vibevoice_model",

vibevoice_dir / "modular" / "modeling_vibevoice_inference.py"

)

VibeVoiceForConditionalGenerationInference = model_module.VibeVoiceForConditionalGenerationInference

processor_module = load_module(

"vibevoice_processor",

vibevoice_dir / "processor" / "vibevoice_processor.py"

)

VibeVoiceProcessor = processor_module.VibeVoiceProcessor

streamer_module = load_module(

"vibevoice_streamer",

vibevoice_dir / "modular" / "streamer.py"

)

AudioStreamer = streamer_module.AudioStreamer

except Exception as e:

raise ImportError(

f"VibeVoice module not found. Error: {e}\n"

"Please ensure VibeVoice is properly installed:\n"

"git clone https://github.com/vibevoice-community/VibeVoice\n"

"cd VibeVoice/\n"

"pip install -e .\n"

)

from transformers.utils import logging

from transformers import set_seed

logging.set_verbosity_info()

logger = logging.get_logger(__name__)

class VibeVoiceChat:

def __init__(self, model_path: str, device: str = "cuda", inference_steps: int = 5):

"""Initialize the VibeVoice chat model."""

self.model_path = model_path

self.device = device if torch.cuda.is_available() else "cpu"

self.inference_steps = inference_steps

self.is_generating = False

self.stop_generation = False

self.current_streamer = None

# Check GPU availability and CUDA version

if torch.cuda.is_available():

print(f"✓ GPU detected: {torch.cuda.get_device_name(0)}")

print(f" Memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.2f} GB")

print(f" CUDA Version: {torch.version.cuda}")

print(f" PyTorch CUDA: {torch.cuda.is_available()}")

# Set memory fraction to avoid OOM

torch.cuda.set_per_process_memory_fraction(0.95)

# Enable TF32 for faster computation on Ampere GPUs

torch.backends.cuda.matmul.allow_tf32 = True

torch.backends.cudnn.allow_tf32 = True

else:

print("✗ No GPU detected, using CPU (generation will be VERY slow)")

print(" For faster generation, ensure CUDA is properly installed")

self.load_model()

self.setup_voice_presets()

def load_model(self):

"""Load the VibeVoice model and processor."""

print(f"Loading model from {self.model_path}")

start_time = time.time()

self.processor = VibeVoiceProcessor.from_pretrained(self.model_path)

if torch.cuda.is_available():

print("Loading model with GPU acceleration...")

try:

self.model = VibeVoiceForConditionalGenerationInference.from_pretrained(

self.model_path,

torch_dtype=torch.bfloat16,

device_map='cuda:0',

attn_implementation="flash_attention_2",

low_cpu_mem_usage=True,

)

print("✓ Flash Attention 2 enabled for faster generation")

except Exception as e:

print(f"Warning: Could not load with flash_attention_2: {e}")

print("Falling back to standard attention...")

self.model = VibeVoiceForConditionalGenerationInference.from_pretrained(

self.model_path,

torch_dtype=torch.bfloat16,

device_map='cuda:0',

low_cpu_mem_usage=True,

)

else:

print("Loading model on CPU (this will be slow)...")

self.model = VibeVoiceForConditionalGenerationInference.from_pretrained(

self.model_path,

torch_dtype=torch.float32,

device_map='cpu',

low_cpu_mem_usage=True,

)

self.model.eval()

# Configure noise scheduler for faster inference

self.model.model.noise_scheduler = self.model.model.noise_scheduler.from_config(

self.model.model.noise_scheduler.config,

algorithm_type='sde-dpmsolver++',

beta_schedule='squaredcos_cap_v2'

)

self.model.set_ddpm_inference_steps(num_steps=self.inference_steps)

load_time = time.time() - start_time

print(f"✓ Model loaded in {load_time:.2f} seconds")

# Print model device

if hasattr(self.model, 'device'):

print(f"Model device: {self.model.device}")

def setup_voice_presets(self):

"""Setup voice presets from the voices directory."""

voices_dir = os.path.join(os.path.dirname(__file__), "voices")

# Create voices directory if it doesn't exist

if not os.path.exists(voices_dir):

os.makedirs(voices_dir)

print(f"Created voices directory at {voices_dir}")

print("Please add voice sample files (.wav, .mp3, etc.) to this directory")

self.available_voices = {}

audio_extensions = ('.wav', '.mp3', '.flac', '.ogg', '.m4a', '.aac')

# Scan for audio files

for file in os.listdir(voices_dir):

if file.lower().endswith(audio_extensions):

name = os.path.splitext(file)[0]

self.available_voices[name] = os.path.join(voices_dir, file)

# Sort voices alphabetically

self.available_voices = dict(sorted(self.available_voices.items()))

if not self.available_voices:

print(f"Warning: No voice files found in {voices_dir}")

print("Using default (zero) voice samples. Add audio files to the voices directory for better results.")

# Add a default "None" option

self.available_voices = {"Default": None}

else:

print(f"Found {len(self.available_voices)} voice presets: {', '.join(self.available_voices.keys())}")

def read_audio(self, audio_path: str, target_sr: int = 24000) -> np.ndarray:

"""Read and preprocess audio file."""

try:

wav, sr = sf.read(audio_path)

if len(wav.shape) > 1:

wav = np.mean(wav, axis=1)

if sr != target_sr:

wav = librosa.resample(wav, orig_sr=sr, target_sr=target_sr)

return wav

except Exception as e:

print(f"Error reading audio {audio_path}: {e}")

return np.zeros(24000) # Return 1 second of silence as fallback

def format_script(self, message: str, num_speakers: int = 2) -> str:

"""Format input message into a script with speaker assignments."""

lines = message.strip().split('\n')

formatted_lines = []

for i, line in enumerate(lines):

line = line.strip()

if not line:

continue

# Check if already formatted

if line.startswith('Speaker ') and ':' in line:

formatted_lines.append(line)

else:

# Auto-assign speakers in rotation

speaker_id = i % num_speakers

formatted_lines.append(f"Speaker {speaker_id}: {line}")

return '\n'.join(formatted_lines)

def generate_audio_stream(

self,

message: str,

history: list,

voice_1: str,

voice_2: str,

num_speakers: int,

cfg_scale: float

) -> Iterator[tuple]:

"""Generate audio stream from text input."""

try:

self.stop_generation = False

self.is_generating = True

# Validate inputs

if not message.strip():

yield None

return

# Format the script

formatted_script = self.format_script(message, num_speakers)

print(f"Formatted script:\n{formatted_script}")

print(f"Using device: {self.device}")

# Start timing

start_time = time.time()

# Select voices based on number of speakers

selected_voices = []

if voice_1 and voice_1 != "Default":

selected_voices.append(voice_1)

if num_speakers > 1 and voice_2 and voice_2 != "Default":

selected_voices.append(voice_2)

# Load voice samples

voice_samples = []

for i in range(num_speakers):

# Use the appropriate voice for each speaker

if i < len(selected_voices):

voice_name = selected_voices[i]

if voice_name in self.available_voices and self.available_voices[voice_name]:

audio_data = self.read_audio(self.available_voices[voice_name])

else:

audio_data = np.zeros(24000) # Default silence

else:

# Use first voice or default if not enough voices selected

if selected_voices and selected_voices[0] in self.available_voices and self.available_voices[selected_voices[0]]:

audio_data = self.read_audio(self.available_voices[selected_voices[0]])

else:

audio_data = np.zeros(24000) # Default silence

voice_samples.append(audio_data)

print(f"Loaded {len(voice_samples)} voice samples")

# Process inputs

inputs = self.processor(

text=[formatted_script],

voice_samples=[voice_samples],

padding=True,

return_tensors="pt",

return_attention_mask=True,

)

# Move to device and ensure correct dtype

if self.device == "cuda":

inputs = {k: v.to(self.device) if torch.is_tensor(v) else v for k, v in inputs.items()}

print(f"✓ Inputs moved to GPU")

# Check GPU memory

if torch.cuda.is_available():

print(f"GPU memory allocated: {torch.cuda.memory_allocated() / 1e9:.2f} GB")

# Create audio streamer

audio_streamer = AudioStreamer(

batch_size=1,

stop_signal=None,

timeout=None

)

self.current_streamer = audio_streamer

# Start generation in separate thread

generation_thread = threading.Thread(

target=self._generate_with_streamer,

args=(inputs, cfg_scale, audio_streamer)

)

generation_thread.start()

# Wait briefly for generation to start

time.sleep(1)

# Stream audio chunks

sample_rate = 24000

audio_stream = audio_streamer.get_stream(0)

all_audio_chunks = []

chunk_count = 0

for audio_chunk in audio_stream:

if self.stop_generation:

audio_streamer.end()

break

chunk_count += 1

# Convert to numpy

if torch.is_tensor(audio_chunk):

if audio_chunk.dtype == torch.bfloat16:

audio_chunk = audio_chunk.float()

audio_np = audio_chunk.cpu().numpy().astype(np.float32)

else:

audio_np = np.array(audio_chunk, dtype=np.float32)

# Ensure 1D

if len(audio_np.shape) > 1:

audio_np = audio_np.squeeze()

# Convert to 16-bit

audio_16bit = self.convert_to_16_bit_wav(audio_np)

all_audio_chunks.append(audio_16bit)

# Yield accumulated audio

if all_audio_chunks:

complete_audio = np.concatenate(all_audio_chunks)

yield (sample_rate, complete_audio)

# Wait for generation to complete

generation_thread.join(timeout=5.0)

# Final yield with complete audio

if all_audio_chunks:

complete_audio = np.concatenate(all_audio_chunks)

generation_time = time.time() - start_time

audio_duration = len(complete_audio) / sample_rate

print(f"✓ Generation complete:")

print(f" Time taken: {generation_time:.2f} seconds")

print(f" Audio duration: {audio_duration:.2f} seconds")

print(f" Real-time factor: {audio_duration/generation_time:.2f}x")

yield (sample_rate, complete_audio)

self.current_streamer = None

self.is_generating = False

except Exception as e:

print(f"Error in generation: {e}")

import traceback

traceback.print_exc()

self.is_generating = False

self.current_streamer = None

yield None

def _generate_with_streamer(self, inputs, cfg_scale, audio_streamer):

"""Helper method to run generation with streamer."""

try:

def check_stop():

return self.stop_generation

# Use torch.cuda.amp for mixed precision if available

if self.device == "cuda" and torch.cuda.is_available():

with torch.cuda.amp.autocast(dtype=torch.bfloat16):

outputs = self.model.generate(

**inputs,

max_new_tokens=None,

cfg_scale=cfg_scale,

tokenizer=self.processor.tokenizer,

generation_config={'do_sample': False},

audio_streamer=audio_streamer,

stop_check_fn=check_stop,

verbose=False,

refresh_negative=True,

)

else:

outputs = self.model.generate(

**inputs,

max_new_tokens=None,

cfg_scale=cfg_scale,

tokenizer=self.processor.tokenizer,

generation_config={'do_sample': False},

audio_streamer=audio_streamer,

stop_check_fn=check_stop,

verbose=False,

refresh_negative=True,

)

except Exception as e:

print(f"Error in generation thread: {e}")

import traceback

traceback.print_exc()

audio_streamer.end()

def convert_to_16_bit_wav(self, data):

"""Convert audio data to 16-bit WAV format."""

if torch.is_tensor(data):

data = data.detach().cpu().numpy()

data = np.array(data)

if np.max(np.abs(data)) > 1.0:

data = data / np.max(np.abs(data))

data = (data * 32767).astype(np.int16)

return data

def stop_audio_generation(self):

"""Stop the current audio generation."""

self.stop_generation = True

if self.current_streamer:

try:

self.current_streamer.end()

except:

pass

def create_chat_interface(chat_instance: VibeVoiceChat):

"""Create a simplified Gradio ChatInterface for VibeVoice."""

# Get available voices

voice_options = list(chat_instance.available_voices.keys())

if not voice_options:

voice_options = ["Default"]

default_voice_1 = voice_options[0] if len(voice_options) > 0 else "Default"

default_voice_2 = voice_options[1] if len(voice_options) > 1 else voice_options[0]

# Define the chat function that returns audio

def chat_fn(message: str, history: list, voice_1: str, voice_2: str, num_speakers: int, cfg_scale: float):

"""Process chat message and generate audio response."""

# Extract text from message

if isinstance(message, dict):

text = message.get("text", "")

else:

text = message

if not text.strip():

return ""

try:

# Generate audio stream

audio_generator = chat_instance.generate_audio_stream(

text, history, voice_1, voice_2, num_speakers, cfg_scale

)

# Collect all audio data

audio_data = None

for audio_chunk in audio_generator:

if audio_chunk is not None:

audio_data = audio_chunk

# Return audio file path or error message

if audio_data:

# Save audio to temporary file

with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:

sample_rate, audio_array = audio_data

sf.write(tmp_file.name, audio_array, sample_rate)

# Return the file path directly

return tmp_file.name

else:

return "Failed to generate audio"

except Exception as e:

print(f"Error in chat_fn: {e}")

import traceback

traceback.print_exc()

return f"Error: {str(e)}"

# Create the interface using Blocks for more control

with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="purple"), fill_height=True) as interface:

gr.Markdown("# 🎙️ VibeVoice Chat\nGenerate natural dialogue audio with AI voices")

with gr.Row():

with gr.Column(scale=1):

gr.Markdown("### Voice & Generation Settings")

voice_1 = gr.Dropdown(

choices=voice_options,

value=default_voice_1,

label="Voice 1",

info="Select voice for Speaker 0"

)

voice_2 = gr.Dropdown(

choices=voice_options,

value=default_voice_2,

label="Voice 2",

info="Select voice for Speaker 1 (if using multiple speakers)"

)

num_speakers = gr.Slider(

minimum=1,

maximum=2,

value=2,

step=1,

label="Number of Speakers",

info="Number of speakers in the dialogue"

)

cfg_scale = gr.Slider(

minimum=1.0,

maximum=2.0,

value=1.3,

step=0.05,

label="CFG Scale",

info="Guidance strength (higher = more adherence to text)"

)

with gr.Column(scale=2):

chatbot = gr.Chatbot(

label="Conversation",

height=400,

type="messages",

elem_id="chatbot"

)

msg = gr.Textbox(

label="Message",

placeholder="Type your message or paste a script...",

lines=3

)

audio_output = gr.Audio(

label="Generated Audio",

type="filepath",

autoplay=True,

visible=False

)

with gr.Row():

submit = gr.Button("🎵 Generate Audio", variant="primary")

clear = gr.Button("🗑️ Clear")

# Example messages

gr.Examples(

examples=[

"Hello! How are you doing today?",

"Speaker 0: Welcome to our podcast!\nSpeaker 1: Thanks for having me!",

"Tell me an interesting fact about space.",

"What's your favorite type of music and why?",

inputs=msg,

label="Example Messages"

)

# Set up event handlers

def process_and_display(message, history, voice_1, voice_2, num_speakers, cfg_scale):

"""Process message and update both chatbot and audio."""

# Add user message to history

history = history or []

history.append({"role": "user", "content": message})

# Generate audio

audio_path = chat_fn(message, history, voice_1, voice_2, num_speakers, cfg_scale)

# Add assistant response with audio

if audio_path and audio_path.endswith('.wav'):

history.append({"role": "assistant", "content": f"🎵 Audio generated successfully"})

return history, audio_path, gr.update(visible=True), ""

else:

history.append({"role": "assistant", "content": audio_path or "Failed to generate audio"})

return history, None, gr.update(visible=False), ""

submit.click(

fn=process_and_display,

inputs=[msg, chatbot, voice_1, voice_2, num_speakers, cfg_scale],

outputs=[chatbot, audio_output, audio_output, msg],

queue=True

)

msg.submit(

fn=process_and_display,

inputs=[msg, chatbot, voice_1, voice_2, num_speakers, cfg_scale],

outputs=[chatbot, audio_output, audio_output, msg],

queue=True

)

clear.click(lambda: ([], None, gr.update(visible=False)), outputs=[chatbot, audio_output, audio_output])

return interface

def parse_args():

parser = argparse.ArgumentParser(description="VibeVoice Chat Interface")

parser.add_argument(

"--model_path",

type=str,

default="microsoft/VibeVoice-1.5B",

help="Path to the VibeVoice model",

)

parser.add_argument(

"--device",

type=str,

default="cuda" if torch.cuda.is_available() else "cpu",

help="Device for inference",

)

parser.add_argument(

"--inference_steps",

type=int,

default=5,

help="Number of DDPM inference steps (lower = faster, higher = better quality)",

)

return parser.parse_args()

def main():

"""Main function to run the chat interface."""

args = parse_args()

set_seed(42)

print("🎙️ Initializing VibeVoice Chat Interface...")

# Initialize chat instance

chat_instance = VibeVoiceChat(

model_path=args.model_path,

device=args.device,

inference_steps=args.inference_steps

)

# Create interface

interface = create_chat_interface(chat_instance)

print(f"🚀 Launching chat interface")

print(f"📁 Model: {args.model_path}")

print(f"💻 Device: {chat_instance.device}")

print(f"🔢 Inference steps: {args.inference_steps}")

print(f"🎭 Available voices: {len(chat_instance.available_voices)}")

if chat_instance.device == "cpu":

print("\n⚠️ WARNING: Running on CPU - generation will be VERY slow!")

print(" For faster generation, ensure you have:")

print(" 1. NVIDIA GPU with CUDA support")

print(" 2. PyTorch with CUDA installed: pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118")

# Launch the interface

interface.queue(max_size=10).launch(

show_error=True,

quiet=False,

)

if __name__ == "__main__":

main()

Install Wan2.2 Locally with Free ComfyUI Workflow: Text-to-Video and Image-to-Video

2025-07-28T14:10:00.000-07:00

This video locally installs Wan2.2, which is the premier video foundation model.

Models :

Comfy-Org/Wan_2.2_ComfyUI_Repackaged at main

Workflow:

https://github.com/fahdmirza/comfyuiworkflows