Unlock Intelligent Automation in Financial Services: Build AI Agents on Your Existing Oracle Data with Amazon Bedrock

Accelerate AI-driven insights without moving your data - combine Amazon Bedrock, Strands Agents SDK, and Oracle AI Database 26ai to build enterprise-grade AI agents on AWS

Nayan Karumuri

Published Jun 16, 2026

Last modified Jun 16, 2026

About This Post

Financial institutions are under pressure to deliver AI-powered experiences — from intelligent portfolio advisors to automated compliance monitoring — but moving sensitive regulated data into new systems creates risk, cost, and delay. This post shows how organizations with an existing Oracle database footprint can build agentic AI applications directly on their current data infrastructure using AWS AI services.

We walk through a practical architecture that combines Amazon Bedrock (foundation models and guardrails), the open-source Strands Agents SDK (intelligent orchestration), and Oracle AI Database 26ai (unified relational + vector store) running on Oracle Database@AWS. Using a real-world wealth management use case, we demonstrate how an AI agent can autonomously analyze portfolios, search internal research, validate compliance rules, and generate actionable risk assessments — all without a single byte of data leaving your existing database.

Who this is for: Technology leaders, architects, and data teams at financial services organizations evaluating how to bring generative AI to production without disrupting core banking and investment systems.

What you'll learn: Architecture patterns, integration code, security controls, and a step-by-step use case for building compliant AI agents on existing Oracle infrastructure within AWS.

Introduction

Financial services institutions face a unique challenge in the age of generative AI: they sit on vast repositories of structured and unstructured data — transaction histories, customer profiles, regulatory documents, risk models, and market intelligence — often stored in Oracle databases that have been battle-tested over decades. The question isn't whether to adopt agentic AI, but how to do so without disrupting the data foundation these organizations depend on.

Oracle AI Database 26ai introduces native vector search capabilities alongside its proven relational engine, creating a converged database that can serve as both a traditional RDBMS and a vector store in a single platform. For AWS financial services customers with an existing Oracle footprint, this opens a pragmatic path: use Amazon Bedrock for foundation model access, Strands Agents SDK for agentic orchestration, and Oracle AI Database 26ai running on Oracle Database@AWS (ODB@AWS) as the unified knowledge base — all within AWS infrastructure.

This post walks through the architecture, integration patterns, and a real-world financial services use case demonstrating how these components work together to build enterprise-grade agentic AI applications.

Why Oracle AI Database 26ai as a Knowledge Base for Financial Services

The Converged Database Advantage

Financial institutions have invested years — sometimes decades — in Oracle database ecosystems. These systems house:

Core banking data — accounts, transactions, balances, customer master records
Risk and compliance data — KYC documents, AML alerts, regulatory filings
Unstructured assets — loan agreements, research reports, internal policies, communication logs

Oracle AI Database 26ai introduces a native VECTOR data type that allows vector embeddings to coexist alongside this operational data. For financial services customers, this means:

Capability	Benefit for FSI
Unified storage	No data movement between operational DB and vector store — reduces latency, security risk, and compliance complexity
Row/column/cell-level security	Existing Oracle VPD (Virtual Private Database) policies apply to vector search results — critical for multi-tenant wealth management platforms
ACID transactions	Vector updates are transactionally consistent with relational updates — essential for regulatory auditability
Exadata performance	AI Smart Scan offloads vector operations to storage servers — handles high-throughput similarity search at scale
No additional licensing	AI Vector Search is included in Oracle AI Database 26ai at no extra cost for existing customers

Why Not Migrate the Vector Store?

For greenfield applications, purpose-built vector databases (Amazon OpenSearch Serverless, Amazon Aurora PostgreSQL with pgvector) are excellent choices. But for financial institutions with:

Petabytes of transactional history in Oracle
Complex security policies (row-level, label-based, data masking)
Regulatory requirements to minimize data replication
Existing disaster recovery and HA configurations (RAC, Data Guard)

...the most pragmatic path is to extend the existing Oracle investment with vector capabilities rather than replicate data into a separate store. This is especially true when the AI application needs to combine semantic search with real-time transactional context — a pattern that's fundamental in financial services.

Architecture: Bedrock + Strands Agents + Oracle 26ai on AWS

Component Overview

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
┌──────────────────────────────────────────────────────────────────────────┐
│                               AWS Cloud                                   
│                                                                           
│  ┌───────────────────────────┐       ┌────────────────────────────────┐  
│  │      Amazon Bedrock        │       │  Application Layer (ECS/EC2)   │  
│  │                            │       │                                │  
│  │  • Claude (reasoning)      │◄─────►│  Strands Agents SDK            │  
│  │  • Titan Embeddings        │       │  • Orchestration logic         │  
│  │  • Guardrails              │       │  • Custom tools (Python)       │  
│  │                            │       │  • MCP client integration      │  
│  └───────────────────────────┘       └───────────────┬────────────────┘  
│                                                       │                   
│                                            ODB Peering│                   
│                                                       ▼                   
│  ┌────────────────────────────────────────────────────────────────────┐  
│  │              Oracle Database@AWS (ODB@AWS)                           
│  │                                                                      
│  │   Oracle AI Database 26ai on Exadata                                
│  │   ┌──────────────────┐  ┌──────────────────┐  ┌─────────────────┐   
│  │   │ Relational Data   │  │ Vector Store      │  │ MCP Server      │  
│  │   │ (transactions,    │  │ (embeddings,      │  │ (Select AI      │   
│  │   │  customers,       │  │  HNSW index,      │  │  Agent tools)   │   
│  │   │  accounts)        │  │  AI Vector        │  │                 │  
│  │   │                   │  │  Search)          │  │                 │   
│  │   └──────────────────┘  └──────────────────┘  └─────────────────┘  │  │
│  └────────────────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────────────────┘

Amazon Bedrock — The Intelligence Layer

Amazon Bedrock provides:

Foundation models — Anthropic Claude for complex reasoning, Amazon Titan for embeddings
Bedrock Guardrails — Content filtering, PII redaction, and topic denial critical for regulated industries
Model choice — Switch between models without application changes
Pay-per-use — No infrastructure to manage, scales with demand

Strands Agents SDK — The Orchestration Framework

Strands Agents is AWS's open-source SDK for building model-driven AI agents. It takes a fundamentally different approach from workflow-based frameworks:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from strands import Agent
from strands.models.bedrock import BedrockModel

# Define the agent with model + tools + prompt
model = BedrockModel(
    model_id="us.anthropic.claude-sonnet-4-20250514",
    region_name="us-east-1"
)

agent = Agent(
    model=model,
    system_prompt=FINANCIAL_ADVISOR_PROMPT,
    tools=[query_oracle_vectors, get_customer_portfolio, check_compliance, generate_report]
)

# The model drives its own behavior
response = agent("Analyze recent transactions for account 4521 and flag any anomalies against historical patterns")

Key Strands capabilities for this architecture:

Model-driven orchestration — The LLM decides which tools to call and in what order, adapting dynamically
Native MCP support — Connect directly to Oracle 26ai's MCP server for tool discovery
Custom tools — Define Python functions as agent tools with @tool decorator
Multi-agent patterns — Supervisor, parallel, and sequential agent coordination
Observability — Built-in tracing for debugging and compliance audit trails

Oracle AI Database 26ai — The Unified Knowledge Base

Oracle 26ai serves triple duty:

Relational database — Core transactional data (accounts, trades, payments)
Vector store — Embeddings for documents, communications, and enriched transaction metadata
MCP server — Exposes database tools directly to AI agents via Model Context Protocol

The MCP server integration is particularly powerful for Strands agents:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from strands import Agent
from strands.tools.mcp import MCPClient
from mcp import stdio_client

# Connect Strands agent to Oracle 26ai MCP server
oracle_mcp = MCPClient(lambda: stdio_client(
    StdioServerParameters(command="oracle-mcp-client", args=["--endpoint", ODB_MCP_ENDPOINT])
))

with oracle_mcp:
    agent = Agent(
        model=model,
        tools=[*oracle_mcp.list_tools_sync(), *custom_tools]
    )

Financial Services Use Case: Intelligent Portfolio Risk Advisory Agent

Scenario

A mid-size wealth management firm running on Oracle Database@AWS needs to build an AI-powered portfolio risk advisory system that:

Monitors client portfolios in real-time against market conditions
Retrieves relevant research, compliance policies, and historical context via semantic search
Generates personalized risk assessments with supporting evidence
Ensures all recommendations comply with regulatory requirements (SEC, FINRA)
Maintains full audit trail for examiner review

Data Landscape (Already in Oracle 26ai)

Data Type	Storage Model	Example
Client portfolios	Relational tables	Holdings, allocations, risk tolerance, investment objectives
Transaction history	Relational + partitioned	10 years of trades, rebalances, distributions
Research documents	LOBs + Vector embeddings	Analyst reports, market outlook PDFs, investment committee minutes
Compliance policies	LOBs + Vector embeddings	Reg BI documentation, firm policies, suitability guidelines
Client communications	LOBs + Vector embeddings	Meeting notes, email summaries, advisor observations
Market data	Relational (real-time)	Prices, indices, sector performance, economic indicators

Agent Architecture

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
from strands import Agent
from strands.models.bedrock import BedrockModel
from strands.tools import tool
from strands.tools.mcp import MCPClient
import oracledb

# --- Custom Tools ---

@tool
def vector_search_research(query: str, top_k: int = 5) -> str:
    """Search internal research documents and compliance policies using semantic similarity."""
    with oracledb.connect(dsn=ODB_DSN) as conn:
        cursor = conn.cursor()
        # Generate embedding via Bedrock Titan
        embedding = generate_embedding(query)
        
        cursor.execute("""
            SELECT doc_title, doc_content, doc_type,
                   VECTOR_DISTANCE(doc_embedding, :embedding, DOT) as similarity
            FROM research_documents
            WHERE VECTOR_DISTANCE(doc_embedding, :embedding, DOT) < 0.3
            ORDER BY similarity
            FETCH FIRST :top_k ROWS ONLY
        """, {"embedding": embedding, "top_k": top_k})
        
        return format_results(cursor.fetchall())

@tool
def get_portfolio_summary(client_id: str) -> str:
    """Retrieve current portfolio holdings, allocation, and risk metrics for a client."""
    with oracledb.connect(dsn=ODB_DSN) as conn:
        cursor = conn.cursor()
        cursor.execute("""
            SELECT h.security_symbol, h.quantity, h.market_value,
                   h.sector, h.asset_class, h.weight_pct,
                   r.var_95, r.beta, r.sharpe_ratio
            FROM client_holdings h
            JOIN portfolio_risk_metrics r ON h.client_id = r.client_id
            WHERE h.client_id = :client_id
              AND h.as_of_date = TRUNC(SYSDATE)
        """, {"client_id": client_id})
        
        return format_portfolio(cursor.fetchall())

@tool  
def check_compliance_constraints(client_id: str, proposed_action: str) -> str:
    """Validate a proposed recommendation against regulatory and firm compliance rules."""
    with oracledb.connect(dsn=ODB_DSN) as conn:
        cursor = conn.cursor()
        # Hybrid query: relational constraints + semantic policy search
        cursor.execute("""
            SELECT constraint_type, constraint_rule, applies_to
            FROM compliance_constraints
            WHERE client_segment = (
                SELECT segment FROM clients WHERE client_id = :client_id
            )
        """, {"client_id": client_id})
        
        hard_constraints = cursor.fetchall()
        
        # Semantic search against policy documents
        policy_context = vector_search_research(
            f"compliance rules for {proposed_action}", top_k=3
        )
        
        return format_compliance_check(hard_constraints, policy_context)

@tool
def get_historical_context(client_id: str, lookback_days: int = 90) -> str:
    """Retrieve recent advisor notes, meeting summaries, and client communications."""
    with oracledb.connect(dsn=ODB_DSN) as conn:
        cursor = conn.cursor()
        cursor.execute("""
            SELECT interaction_date, interaction_type, summary,
                   advisor_notes, sentiment_score
            FROM client_interactions
            WHERE client_id = :client_id
              AND interaction_date >= SYSDATE - :lookback
            ORDER BY interaction_date DESC
        """, {"client_id": client_id, "lookback": lookback_days})
        
        return format_interactions(cursor.fetchall())

# --- Agent Definition ---

RISK_ADVISOR_PROMPT = """
You are an AI portfolio risk advisor for a registered investment advisory firm.
Your role is to analyze client portfolios, identify risks, and generate 
compliant recommendations.

RULES:
1. Always check compliance constraints before making recommendations
2. Support every risk assessment with evidence from research documents
3. Consider the client's stated risk tolerance and investment objectives
4. Reference historical context to personalize advice
5. Flag any concentration risks, liquidity concerns, or regulatory issues
6. Never provide specific buy/sell recommendations — flag for human advisor review

OUTPUT FORMAT:
- Risk Assessment Summary (2-3 sentences)
- Key Findings (bulleted, with evidence citations)
- Compliance Check Results
- Recommended Actions for Advisor Review
- Supporting Research References
"""

model = BedrockModel(
    model_id="us.anthropic.claude-sonnet-4-20250514",
    region_name="us-east-1",
    guardrail_id="financial-services-guardrail",
    guardrail_version="1"
)

risk_advisor = Agent(
    model=model,
    system_prompt=RISK_ADVISOR_PROMPT,
    tools=[
        vector_search_research,
        get_portfolio_summary,
        check_compliance_constraints,
        get_historical_context
    ]
)

Agent Execution Flow

When an advisor asks: "Review the portfolio for client C-4521. They mentioned concerns about tech concentration during our last meeting. What risks should I be aware of?"

The Strands agent autonomously:

Retrieves portfolio data → get_portfolio_summary("C-4521") — pulls current holdings from relational tables
Gets historical context → get_historical_context("C-4521") — finds the meeting note mentioning tech concerns
Searches research → vector_search_research("technology sector concentration risk 2026 outlook") — semantic search across analyst reports
Checks compliance → check_compliance_constraints("C-4521", "portfolio rebalancing") — validates against Reg BI suitability
Synthesizes → Generates a comprehensive risk assessment with citations, compliance status, and recommended actions

All data retrieval happens against a single Oracle 26ai instance — no data movement, no cross-system latency, full transactional consistency.

Sample Agent Output

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
## Portfolio Risk Assessment — Client C-4521

### Summary
Client C-4521's portfolio shows 47% technology sector concentration (vs. 32% 
benchmark weight), with elevated single-name risk in 3 positions. This aligns 
with concerns raised during the April 15 advisory meeting.

### Key Findings
• **Sector concentration**: Technology allocation at 47.2% exceeds firm's 
  40% single-sector guideline (Policy Doc: "Concentration Risk Framework v3.2")
• **Single-name exposure**: NVDA (12.4%), MSFT (9.8%), AAPL (8.1%) — 
  combined 30.3% in three names
• **Correlation risk**: Portfolio beta to NASDAQ-100 is 1.34, indicating 
  amplified downside in tech correction scenario
• **Client context**: During April 15 meeting, client expressed concern about 
  "too much tech" but deferred action pending Q2 earnings

### Compliance Check: ⚠️ ADVISORY
- Reg BI Suitability: Client risk tolerance = "Moderate Growth" — current 
  concentration MAY exceed suitability bounds per firm policy §4.3.2
- No hard regulatory violation identified
- Recommend documenting rationale if maintaining current allocation

### Recommended Actions (for Advisor Review)
1. Schedule rebalancing discussion with client
2. Model 3 scenarios: gradual reduction, sector rotation, hedging overlay
3. Document client's informed consent if maintaining concentration

### Supporting Research
- "Q3 2026 Tech Sector Outlook" (Investment Committee, Jun 2026) — 
  notes elevated valuation risk
- "Concentration Risk Framework v3.2" (Compliance, Jan 2026) — 
  40% sector cap guideline
- "Client C-4521 Meeting Notes" (Apr 15, 2026) — client's stated concerns

Integration Pattern: Strands + Oracle 26ai MCP Server

Oracle AI Database 26ai's built-in MCP server enables a particularly elegant integration with Strands. Instead of writing custom database tools, you can expose Oracle's capabilities directly as MCP tools:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
from strands import Agent
from strands.tools.mcp import MCPClient
from mcp.client.streamable_http import streamablehttp_client

# Connect to Oracle 26ai's managed MCP endpoint
async def oracle_mcp_transport():
    async with streamablehttp_client(
        url=f"https://{ODB_MCP_ENDPOINT}/mcp/v1",
        headers={"Authorization": f"Bearer {get_oci_token()}"}
    ) as transport:
        yield transport

oracle_mcp = MCPClient(oracle_mcp_transport)

with oracle_mcp:
    # Oracle MCP exposes tools like:
    # - execute_sql: Run queries against the database
    # - vector_search: Perform AI Vector Search
    # - get_schema: Discover table structures
    # - select_ai: Natural language to SQL
    
    tools = oracle_mcp.list_tools_sync()
    
    agent = Agent(
        model=model,
        system_prompt=ADVISOR_PROMPT,
        tools=tools  # Oracle DB tools auto-discovered via MCP
    )

This means the agent can dynamically discover and use database capabilities without hardcoded SQL — the model reasons about which tools to invoke based on the user's natural language request.

Security Considerations for Financial Services

Layer	Control	Implementation
Network	Private connectivity	ODB peering — no internet traversal between app and database
Authentication	Mutual TLS + IAM	EC2 instance role for Bedrock; wallet-based auth for Oracle
Authorization	Row-level security	Oracle VPD policies restrict vector search results by user/role
Data privacy	Dynamic masking	Oracle Data Redaction masks PII in query results returned to agents
AI safety	Guardrails	Bedrock Guardrails filter harmful content, deny off-topic queries, redact PII in prompts
Auditability	Full trace	Strands SDK traces + Oracle Unified Audit — every agent action logged
Encryption	Quantum-resistant	Oracle 26ai ML-KEM for data-in-flight + AES-256 at rest
Model governance	Centralized	Bedrock model access policies — control which models agents can invoke

Benefits Summary: Why This Architecture Works for FSI

For the Business

Faster time-to-value — No data migration project; AI agents work on data where it already lives
Reduced risk — No new data stores to secure, audit, or govern
Regulatory confidence — Existing Oracle audit, encryption, and access control policies apply to AI workloads

For the Technology Team

Minimal new infrastructure — Oracle 26ai on ODB@AWS is managed; Bedrock is serverless; Strands is a pip install
Familiar tools — SQL + Python + existing Oracle DBA expertise
Incremental adoption — Start with one agent, expand to multi-agent systems as confidence grows

For the SA/Account Team

Meets customers where they are — Doesn't require a database migration conversation
Demonstrates AWS AI value — Bedrock + Strands deliver the intelligence; Oracle provides the data gravity
Opens the door — Once customers experience Bedrock's capabilities, future conversations about Aurora PostgreSQL, OpenSearch, or fully cloud-native architectures become natural

Getting Started

Provision ODB@AWS — Deploy Oracle AI Database 26ai on Exadata Database Service or Autonomous Database within AWS
Enable vector capabilities — Configure vector_pool memory allocation, create vector-enabled tables
Set up ODB peering — Establish private network connectivity between your VPC and ODB network
Install Strands SDK — pip install strands-agents strands-agents-tools
Configure Bedrock access — IAM role with bedrock:InvokeModel permissions for your chosen models
Define tools — Create Python functions or connect to Oracle's MCP server
Build your agent — Combine model + tools + system prompt and iterate

For the complete reference implementation, see the Oracle Database@AWS and Amazon Bedrock integration guide .

Conclusion

For AWS financial services customers with an existing Oracle footprint, Oracle AI Database 26ai running on ODB@AWS provides a pragmatic unified knowledge base — eliminating the need to replicate sensitive financial data into a separate vector store. Combined with Amazon Bedrock's foundation models and the Strands Agents SDK's model-driven orchestration, this architecture enables sophisticated agentic AI applications that are secure, auditable, and compliant by design.

The pattern is simple: let Oracle do what it does best (store and secure data), let Bedrock do what it does best (provide world-class AI models with enterprise guardrails), and let Strands do what it does best (orchestrate intelligent agents that reason over both).

This isn't an end state — it's a starting point. As organizations build confidence with agentic AI and evaluate total cost of ownership, the natural evolution toward fully cloud-native architectures (Aurora PostgreSQL, OpenSearch Serverless, Amazon Bedrock Knowledge Bases) becomes a data-driven conversation rather than a leap of faith.

Nayan Karumuri is a Solutions Architect at AWS specializing in financial services modernization and AI/ML adoption strategies.

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.

Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article

Builder Center

Unlock Intelligent Automation in Financial Services: Build AI Agents on Your Existing Oracle Data with Amazon Bedrock

Nayan Karumuri

About This Post

Introduction

Why Oracle AI Database 26ai as a Knowledge Base for Financial Services

The Converged Database Advantage

Why Not Migrate the Vector Store?

Architecture: Bedrock + Strands Agents + Oracle 26ai on AWS

Component Overview

Amazon Bedrock — The Intelligence Layer

Strands Agents SDK — The Orchestration Framework

Oracle AI Database 26ai — The Unified Knowledge Base

Financial Services Use Case: Intelligent Portfolio Risk Advisory Agent

Scenario

Data Landscape (Already in Oracle 26ai)

Agent Architecture

Agent Execution Flow

Sample Agent Output

Integration Pattern: Strands + Oracle 26ai MCP Server

Security Considerations for Financial Services

Benefits Summary: Why This Architecture Works for FSI

For the Business

For the Technology Team

For the SA/Account Team

Getting Started

Conclusion