Building Apps with Amazon Bedrock

A comprehensive guide to building production-ready AI applications using Amazon Bedrock, featuring hands-on notebooks, agent frameworks, and deployment patterns.

building-apps-with-bedrock/
│
├── 1 Intro_to_Bedrock_Presentation/   # Presentation slides
│   ├── Module-1-GenAI-on-AWS.pdf
│   ├── Module-2-Getting-to-Know-Amazon-Bedrock.pdf
│   ├── Module-3-RAG-on-Bedrock.pdf
│   ├── Module-4-Agents-on-Amazon-Bedrock.pdf
│   ├── Module-5-LLM-Security-and-Observability-on-Bedrock.pdf
│   └── Module-6-Cost-Optimization.pdf
│
├── 1a Basic Bedrock/                   # Foundation concepts
│   ├── 1-bedrock_intro.ipynb
│   ├── 2-image_generation.ipynb
│   ├── 3-video_generation.ipynb
│   └── 4-inference_profiles.ipynb
│
├── 1b Async Pipeline/                  # Serverless async workflows
│   ├── async_pipeline_setup.ipynb
│   └── setup_infrastructure.py
│
├── 2 RAG_in_AWS/                       # Section header
│
├── 2a Bedrock RAG/                     # RAG implementations & patterns
│   ├── Demo1-Basic-RAG/                # Fully managed RAG with Aurora
│   ├── Demo2-S3-Vectors/               # Cost-effective S3 native vectors
│   ├── Demo3-Hybrid-Search/            # Vector + keyword search fusion
│   ├── Demo4-Reranking-Pipeline/       # Two-stage retrieval with re-ranking
│   ├── Demo5-Multi-Collection/         # Enterprise multi-collection RAG
│   ├── Demo-Chunking-Strategies/       # Document chunking optimization
│   ├── Demo-RAGAS-Evaluation/          # RAG evaluation metrics
│   ├── embedding_comparison_demo.ipynb # Embedding model comparison
│   └── vector_database_cost_comparison.ipynb
│
├── 2b S3VectorsApp/                    # Complete RAG application (CDK)
│   ├── lambda/                         # Lambda function code
│   ├── s3vectors_app/                  # CDK infrastructure
│   ├── streamlit_app.py                # Chat UI
│   ├── app.py                          # CDK app entry point
│   └── README.md                       # Deployment guide
│
├── 3 Agents_in_AWS/                    # Section header
│
├── 3a Bedrock_Agents/                  # Agent development & deployment
│   ├── 1-basic_agent_setup.ipynb
│   ├── 2-agent_with_knowledge_base.ipynb
│   ├── 3-multi_agent_collaboration.ipynb
│   ├── 4-strands_with_agentcore.ipynb
│   ├── 5-knowledge_base_s3_vectors.ipynb
│   ├── 6-strands_agent_kb_agentcore.ipynb
│   ├── 7-bedrock_guardrails.ipynb
│   └── 8-strands_guardrails_kb_agentcore.ipynb
│
├── 3b Agentcore/                       # AgentCore hands-on exercises
│   ├── 1-calculator_agent.ipynb
│   ├── 1a-deploy_agentcore.ipynb
│   ├── 2-demo_tools.ipynb
│   ├── 3-demo-agents_as_tools.ipynb
│   ├── 4-demo-graph_architecture.ipynb
│   ├── 5-error_handling_session_exercise.ipynb
│   ├── 6-agentcore_memory_demo.ipynb
│   └── exerciseA/                      # Practice exercises
│
├── 3c Application/                     # Heavy Machinery Assistant (Full Stack)
│   ├── terraform/                      # Infrastructure as Code
│   │   ├── 01_storage_stack/           # VPC, Aurora, S3
│   │   ├── 02_bedrock_rag_stack/       # Knowledge Base
│   │   └── modules/                    # Reusable modules
│   ├── pre-requisites/
│   │   ├── documents/spec-sheets/      # Equipment specifications
│   │   └── postgres_data/              # Database initialization
│   ├── rag_app/                        # RAG Streamlit app
│   ├── agent_app/                      # Agent Streamlit app
│   ├── python_sdk/                     # SDK-based deployment
│   └── README.md                       # Full deployment guide
│
├── 3d Lambda/                          # Strands Agent Lambda deployment
│   ├── agent_handler.py                # Lambda handler with Strands
│   ├── deploy.sh                       # Automated deployment script
│   ├── requirements.txt
│   └── README.md                       # Deployment guide
│
├── Sample_UI_for/                      # Interactive demo interface
│   ├── app.py                          # Streamlit application
│   ├── requirements.txt
│   └── README.md
│
├── AGENTCORE_SUMMARY.md                # AgentCore platform guide
├── STRANDS_AGENTS_SUMMARY.md           # Strands framework guide
└── BEDROCK_KB_S3_VECTORS_SUMMARY.md    # Knowledge Base + S3 Vectors guide

# Install required packages
pip install boto3 strands-agents strands-agents-tools bedrock-agentcore bedrock-agentcore-starter-toolkit

# Configure AWS credentials
aws configure

Launch the Streamlit interface to explore all capabilities:

cd Sample_UI_for
pip install -r requirements.txt
streamlit run app.py

Features:

• 💬 Chat with Bedrock models (Nova, Claude)
• 📚 Knowledge Base RAG with equipment specs
• 🛡️ Test guardrails in real-time
• 🎨 Generate images with Nova Canvas
• 🎬 Create videos with Nova Reel

Open http://localhost:8501 in your browser to start exploring!

Start here to understand core Bedrock capabilities:

• Bedrock Intro - Models, APIs, basic usage
• Image Generation - Nova Canvas for images
• Video Generation - Nova Reel for videos
• Inference Profiles - System vs Application profiles

Build serverless async pipelines:

• API Gateway + Step Functions + Lambda
• Image-to-video generation pipeline
• Status tracking and S3 artifact storage

Progress through agent complexity:

Basic Agents (3a Bedrock_Agents/):

• Traditional Bedrock Agents with action groups
• Knowledge Base integration
• Multi-agent collaboration patterns

Advanced Agents (3a Bedrock_Agents/):

• Strands framework with AgentCore deployment
• Knowledge Base with S3 Vectors (90% cost savings)
• Guardrails for content safety
• Production-ready secure agents

Hands-on AgentCore Exercises (3b Agentcore/):

• 1-calculator_agent.ipynb - Basic agent with tools
• 1a-deploy_agentcore.ipynb - AgentCore deployment
• 2-demo_tools.ipynb - Tool creation patterns
• 3-demo-agents_as_tools.ipynb - Multi-agent patterns
• 4-demo-graph_architecture.ipynb - Graph-based workflows
• 5-error_handling_session_exercise.ipynb - Error handling
• 6-agentcore_memory_demo.ipynb - Memory configuration

Comprehensive RAG patterns from basic to advanced:

Foundation RAG:

• Basic RAG with Bedrock Knowledge Bases
• S3 Vectors for 90% cost reduction
• Embedding model comparison and selection

Advanced Patterns:

• Hybrid search (vector + keyword fusion with OpenSearch)
• Re-ranking pipeline for improved accuracy
• Multi-collection enterprise RAG
• Document chunking strategies
• RAG evaluation with RAGAS metrics

Additional Notebooks:

• vector_database_cost_comparison.ipynb - Compare vector DB costs
• Demo3-Hybrid-Search/opensearch_hybrid_search_guide.md - OpenSearch guide
• Demo4-Reranking-Pipeline/demo4_reranking_pipeline.ipynb - Reranking with Bedrock
• Demo4-Reranking-Pipeline/demo4_s3_vectors_reranking.ipynb - Reranking with S3 Vectors

2b S3VectorsApp/ - Complete serverless RAG application:

• API Gateway with authentication
• Lambda-based vector operations
• Streamlit chat interface
• CDK infrastructure as code
• Production security practices

3d Lambda/ - Strands Agent Lambda deployment:

• Deploy Strands agents to AWS Lambda
• Public Function URL for testing
• Official Strands Lambda layers
• Automated deployment script
• Tool integration examples

3c Application/ - Heavy Machinery Assistant (Full Stack):

• Multi-AZ VPC with Aurora Serverless v2
• Bedrock Knowledge Base with pgvector
• Terraform infrastructure as code
• RAG and Agent Streamlit applications
• Equipment specification database

What: Serverless platform for deploying AI agents at scale
Why: Zero infrastructure, built-in memory, observability, security
When: Production deployments requiring scale and reliability

Key Features:

• Runtime: Serverless agent execution
• Memory: Persistent conversation history (short-term & long-term with fact extraction)
• Gateway: Transform APIs into tools
• Browser: Cloud-based automation
• Code Interpreter: Secure code execution
• Identity: Authentication & access control
• Observability: Real-time monitoring
• Policy: Security controls
• Evaluation: Continuous quality inspection

Deployment Modes:

Memory Options:

• Short-term memory (STM) only - available immediately
• Short-term + Long-term memory (LTM) - auto fact extraction (2-5 min to provision)
• No memory - use --disable-memory flag

📄 See AGENTCORE_SUMMARY.md for details

What: Open-source, lightweight Python SDK for building AI agents
Why: Model-driven approach, framework-agnostic, minimal code
When: Rapid agent development with any LLM provider

Key Features:

• Model-agnostic (Bedrock, OpenAI, Anthropic, Ollama, Gemini, LiteLLM, custom)
• Multi-agent patterns (Agents as Tools, Swarm, Graph, Workflow)
• Native MCP (Model Context Protocol) support
• Hot reloading for rapid development
• Bidirectional streaming for voice/audio (experimental)
• OpenTelemetry observability integration

Supported Models:

📄 See STRANDS_AGENTS_SUMMARY.md for details

What: Cost-effective RAG with native S3 vector storage
Why: 90% cost reduction vs traditional vector databases
When: Large-scale knowledge bases with subsecond latency tolerance

Key Features:

• Native S3 vector storage (no separate DB)
• Subsecond query performance
• Tens of millions of vectors per index
• Rich metadata filtering
• Fully managed, serverless
• SSE-S3 encryption by default

Limitations:

• Semantic search only (no hybrid search yet)
• Subsecond latency (not millisecond)
• Index immutable after creation (dimension, distance metric)
• Currently in Preview status

📄 See BEDROCK_KB_S3_VECTORS_SUMMARY.md for details

What: Deploy Strands agents to AWS Lambda with public Function URLs
Why: Serverless, pay-per-use, no infrastructure management
When: Simple agent deployments without persistent memory needs

Key Features:

• Official Strands Lambda layers (Python 3.10-3.13, x86_64/aarch64)
• Public Function URL for direct HTTP access
• Automated deployment via deploy.sh
• Configurable timeout (up to 900s) and memory

Layer ARN (us-east-1):

arn:aws:lambda:us-east-1:856699698935:layer:strands-agents-py3_12-x86_64:1

📄 See 3d Lambda/README.md for details

Goal: Production-ready agent with knowledge base and content safety

Steps:

1. Run 3a Bedrock_Agents/5-knowledge_base_s3_vectors.ipynb - Create KB with equipment specs
2. Run 3a Bedrock_Agents/7-bedrock_guardrails.ipynb - Set up content filters
3. Run 3a Bedrock_Agents/8-strands_guardrails_kb_agentcore.ipynb - Deploy secure agent

Result: Agent with RAG, guardrails, deployed to AgentCore

Goal: Serverless agent deployment with public Function URL

Steps:

1. Navigate to 3d Lambda/ folder
2. Customize agent_handler.py with your agent logic
3. Run ./deploy.sh to deploy
4. Test with curl or AWS CLI

Result: Production-ready Lambda function with Strands agent

Goal: Complete GenAI application with database, RAG, and agents

Steps:

1. Navigate to 3c Application/ folder
2. Deploy storage stack: cd terraform/01_storage_stack && terraform apply
3. Initialize Aurora database with equipment data
4. Upload spec sheets to S3
5. Deploy Bedrock stack: cd terraform/02_bedrock_rag_stack && terraform apply
6. Sync Knowledge Base
7. Launch RAG app: cd rag_app && streamlit run app.py
8. Launch Agent app: cd agent_app && streamlit run app.py

Result: Full-stack application with VPC, Aurora, S3, Bedrock KB, and interactive UIs

Goal: Specialized agents working together

Steps:

1. Run 3a Bedrock_Agents/3-multi_agent_collaboration.ipynb - Learn patterns
2. Run 3a Bedrock_Agents/4-strands_with_agentcore.ipynb - Deploy with Strands
3. Choose pattern: Agents as Tools, Swarm, Graph, or Workflow

Result: Coordinated multi-agent system

Goal: Complete serverless RAG app with authentication and UI

Steps:

1. Navigate to 2b S3VectorsApp/ folder
2. Follow deployment guide in README
3. Deploy with CDK: cdk deploy
4. Get API key and test endpoints
5. Launch Streamlit UI for chat interface

Result: Production-ready RAG application with API Gateway, Lambda, and chat UI

Goal: Master comprehensive RAG implementations and optimizations

Steps:

1. Foundation: 2a Bedrock RAG/Demo1-Basic-RAG/ - Fully managed Bedrock KB
2. Cost Optimization: 2a Bedrock RAG/Demo2-S3-Vectors/ - 90% cost reduction
3. Search Enhancement: 2a Bedrock RAG/Demo3-Hybrid-Search/ - Vector + keyword fusion
4. Quality Improvement: 2a Bedrock RAG/Demo4-Reranking-Pipeline/ - Two-stage retrieval
5. Enterprise Scale: 2a Bedrock RAG/Demo5-Multi-Collection/ - Multi-index routing
6. Optimization: 2a Bedrock RAG/Demo-Chunking-Strategies/ - Document processing
7. Evaluation: 2a Bedrock RAG/Demo-RAGAS-Evaluation/ - Quality metrics
8. Model Selection: 2a Bedrock RAG/embedding_comparison_demo.ipynb - Embedding comparison

Result: Complete RAG expertise from basic to production-grade implementations

Goal: Serverless image-to-video pipeline

Steps:

1. Run 1b Async Pipeline/async_pipeline_setup.ipynb - Provision infrastructure
2. Test with API Gateway endpoints
3. Monitor with CloudWatch

Result: Scalable async generation pipeline

from strands import Agent, tool

@tool
def search_docs(query: str) -> str:
    """Search documentation."""
    # Your implementation
    return results

agent = Agent(tools=[search_docs])
response = agent("Find information about X")

@tool
def search_kb(query: str) -> str:
    """Search knowledge base."""
    response = bedrock_runtime.retrieve_and_generate(
        input={'text': query},
        retrieveAndGenerateConfiguration={
            'type': 'KNOWLEDGE_BASE',
            'knowledgeBaseConfiguration': {
                'knowledgeBaseId': KB_ID,
                'modelArn': MODEL_ARN
            }
        }
    )
    return response['output']['text']

agent = Agent(tools=[search_kb])

response = bedrock_runtime.retrieve_and_generate(
    input={'text': query},
    retrieveAndGenerateConfiguration={
        'knowledgeBaseConfiguration': {
            'generationConfiguration': {
                'guardrailConfiguration': {
                    'guardrailId': GUARDRAIL_ID,
                    'guardrailVersion': VERSION
                }
            }
        }
    }
)

from bedrock_agentcore import BedrockAgentCoreApp

app = BedrockAgentCoreApp()

@app.entrypoint
def invoke(payload):
    prompt = payload.get("prompt")
    response = agent(prompt)
    return {"result": str(response)}

if __name__ == "__main__":
    app.run()

Then deploy:

agentcore configure -e agent.py -r us-east-1
agentcore deploy
agentcore invoke '{"prompt": "Hello"}'

Test in UI:

1. Copy Agent ARN from deployment output
2. Launch Streamlit UI: cd Sample_UI_for && streamlit run app.py
3. Select "🤖 Equipment Agent" or "🔒 Secure Agent"
4. Paste Agent ARN and start chatting

from strands import Agent
from strands.models import BedrockModel

SYSTEM_PROMPT = "You are a helpful assistant."

def handler(event, _context):
    agent = Agent(
        system_prompt=SYSTEM_PROMPT,
        model=BedrockModel(model_id="us.amazon.nova-micro-v1:0", region="us-east-1")
    )
    
    prompt = event.get("prompt", "Hello!")
    response = agent(prompt)
    
    return {"response": str(response)}

Deploy with:

cd "3d Lambda"
./deploy.sh

import boto3

bedrock_runtime = boto3.client('bedrock-agent-runtime')

# Retrieve and generate
response = bedrock_runtime.retrieve_and_generate(
    input={'text': 'What is machine learning?'},
    retrieveAndGenerateConfiguration={
        'type': 'KNOWLEDGE_BASE',
        'knowledgeBaseConfiguration': {
            'knowledgeBaseId': KB_ID,
            'modelArn': 'arn:aws:bedrock:us-east-1::foundation-model/amazon.nova-pro-v1:0',
            'retrievalConfiguration': {
                'vectorSearchConfiguration': {
                    'numberOfResults': 5
                }
            }
        }
    }
)

print(response['output']['text'])

Application stack breakdown:

• Aurora Serverless v2: ~$0.12/hr when active (0.5-1 ACU)
• Bedrock Knowledge Base: Pay per query
• Nova Models: Pay per token (Micro < Lite < Pro)
• NAT Gateway: ~$0.045/hr + data transfer

1. Use Guardrails - Content filtering, PII redaction, topic blocking
2. IAM Policies - Least privilege access
3. Application Profiles - Separate cost tracking and quotas
4. VPC Endpoints - Private connectivity
5. Encryption - KMS for sensitive data, SSE-S3 for S3 Vectors
6. Monitoring - CloudWatch logs and metrics
7. Secrets Manager - Store database credentials (never hardcode)
8. API Key Auth - Protect API Gateway endpoints
9. Rate Limiting - Usage plans to prevent overuse (e.g., 100 req/sec, 10K req/day)
10. Prompt Validation - Validate inputs before sending to models

The included Streamlit UI provides an interactive way to explore all Bedrock capabilities:

cd Sample_UI_for
streamlit run app.py

• Auto-Configuration - Loads KB and guardrail configs automatically
• Chat History - Maintains conversation context
• Source Citations - Shows RAG sources and confidence
• Real-time Blocking - See guardrails in action
• Media Download - Save generated images and videos

cd Sample_UI_for
streamlit run app.py  # Runs on localhost:8501

python agent.py  # Runs on localhost:8080

agentcore configure -e agent.py
agentcore deploy

cd "3d Lambda"
./deploy.sh
# Returns public Function URL for testing

Use notebooks in 1b Async Pipeline/ folder

cd "3c Application/terraform/01_storage_stack" && terraform apply
cd ../02_bedrock_rag_stack && terraform apply

cd "2b S3VectorsApp"
cdk bootstrap && cdk deploy

Container-based deployment (not covered in this repo)

• Agent logs: /aws/bedrock-agentcore/runtimes/{agent-id}
• Knowledge Base logs: Configure during KB creation
• Lambda logs: Automatic

# Enable in agent configuration
agentcore configure --enable-observability

• Invocation count
• Latency (p50, p99)
• Error rate
• Token usage
• Cost per request

This is a learning repository. Feel free to:

• Add new notebooks
• Improve existing examples
• Share use cases
• Report issues

• Amazon Bedrock
• Bedrock AgentCore
• S3 Vectors
• AWS Lambda
• Bedrock Knowledge Bases

• Strands Agents
• Strands SDK GitHub
• Strands Tools GitHub
• AgentCore SDK GitHub
• AgentCore Starter Toolkit
• AgentCore Samples

• Building cost-effective RAG with S3 Vectors
• Multi-Agent Collaboration with Strands

This project is for educational purposes. See individual component licenses:

• Strands Agents: Apache 2.0
• AWS Services: AWS Customer Agreement

By completing this repository, you will:

✅ Understand Bedrock core capabilities
✅ Build agents with action groups and knowledge bases
✅ Implement multi-agent collaboration patterns (Agents as Tools, Swarm, Graph, Workflow)
✅ Deploy production-ready agents to AgentCore
✅ Deploy Strands agents to AWS Lambda with Function URLs
✅ Optimize costs with S3 Vectors
✅ Implement content safety with guardrails
✅ Create async serverless pipelines
✅ Monitor and observe agent behavior
✅ Build interactive UIs for AI applications
✅ Deploy full-stack applications with Terraform and CDK
✅ Integrate Aurora Serverless with pgvector for RAG
✅ Evaluate RAG quality with RAGAS metrics
✅ Apply advanced RAG patterns (hybrid search, re-ranking, multi-collection)

Ready to build?

🎨 Quick Demo: cd Sample_UI_for && streamlit run app.py
📚 Learn: Start with 1a Basic Bedrock/1-bedrock_intro.ipynb
🚀 Deploy: Follow guides in 3a Bedrock_Agents/
⚡ Lambda: Deploy a Strands agent in minutes with cd "3d Lambda" && ./deploy.sh
🏗️ Full Stack: Build the complete app with cd "3c Application" && terraform apply