Retrieval Augmented Generation (RAG) has become the de facto standard for building AI systems that need to answer questions based on your own documents. But moving from a proof-of-concept to a production-ready system involves many decisions: chunking strategies, vector databases, embedding models, and infrastructure.

This tutorial walks you through building a complete RAG system using AWS Bedrock, featuring:

• Hierarchical Chunking: Parent chunks (1500 tokens) + Child chunks (300 tokens)
• FAISS Vector Search: High-performance similarity search with OpenSearch Serverless
• Automatic RAG: Bedrock Agents that know when to retrieve context
• Infrastructure as Code: Complete Terraform deployment

Our RAG system follows a multi-stage pipeline that transforms documents into semantic vectors, stores them efficiently, and retrieves relevant context for generation.

┌─────────────┐
│  S3 Bucket  │ ← Document Storage (PDFs, TXT, etc.)
└──────┬──────┘
       │
       ↓
┌──────────────────────────┐
│ Bedrock Knowledge Base   │ ← Hierarchical Chunking
│ (Titan Embeddings)       │   Parent: 1500 tokens
└──────┬───────────────────┘   Child: 300 tokens
       │                        Overlap: 60 tokens
       ↓
┌──────────────────────────┐
│ OpenSearch Serverless    │ ← FAISS Vector Search
│ (1536-dim vectors)       │   L2 distance + HNSW
└──────┬───────────────────┘
       │
       ↓
┌──────────────────────────┐
│   Bedrock Agent          │ ← Automatic RAG
│   (Claude/Nova)          │   Context-aware responses
└──────────────────────────┘
                

Key Components

The Problem RAG Solves

Large Language Models (LLMs) are trained on vast amounts of data, but they have two fundamental limitations:

• Knowledge Cutoff: They don't know about events after their training date
• No Private Data: They can't access your company's documents, databases, or internal knowledge

How RAG Works (Step by Step)

Most RAG systems use fixed-size chunking (e.g., 512 tokens per chunk). This works, but has a critical flaw: you lose context.

The Problem with Fixed-Size Chunking

Hierarchical Chunking Solution

Hierarchical chunking creates two levels of chunks:

Configuration

vector_ingestion_configuration {
  chunking_configuration {
    chunking_strategy = "HIERARCHICAL"
    hierarchical_chunking_configuration {
      level_configuration {
        max_tokens = 1500  # Parent chunk
      }
      level_configuration {
        max_tokens = 300   # Child chunk
      }
      overlap_tokens = 60  # Continuity between chunks
    }
  }
}

The 60-token overlap ensures that information spanning chunk boundaries isn't lost.

Prerequisites

• AWS Account with Bedrock access
• Terraform >= 1.0
• Python 3.8+
• AWS CLI configured

Step 1: Clone the Repository

git clone https://github.com/raulprocha/bedrock-rag-system.git
cd bedrock-rag-system
pip install -r requirements.txt

Step 2: Configure AWS Resources

Copy the example configuration and update with your AWS details:

cp config.py.example scripts/config.py
# Edit scripts/config.py with your AWS account ID and region

Step 3: Deploy Infrastructure

Use Terraform to deploy all AWS resources:

cd terraform
terraform init
terraform plan
terraform apply -auto-approve

This creates: S3 bucket, OpenSearch Serverless collection, Knowledge Base, and Bedrock Agent

Step 4: Create FAISS Index

Important: Bedrock requires the OpenSearch index to use FAISS engine (not the default nmslib).

python -m scripts.opensearch_manager create

python -m scripts.opensearch_manager recreate

Step 5: Upload Documents

BUCKET=$(terraform output -raw s3_bucket_name)
aws s3 cp your-document.pdf s3://$BUCKET/

Step 6: Sync Knowledge Base

Start the ingestion job to process and index your documents:

KB_ID=$(terraform output -raw knowledge_base_id)
DS_ID=$(terraform output -raw data_source_id)

aws bedrock-agent start-ingestion-job \
  --knowledge-base-id $KB_ID \
  --data-source-id $DS_ID \
  --region us-east-1

⏱️ Processing time: ~4-5 minutes for a 50MB PDF

Step 7: Test Your RAG System

# Test agent with RAG
python tests/test_agent.py

# Test direct KB retrieval
python tests/test_kb.py

# Interactive CLI
python cli.py "What are the main features of Amazon Bedrock?"

BedrockClient: High-Level API

The BedrockClient class provides a clean interface for interacting with Bedrock services:

from scripts.bedrock_client import BedrockClient

# Initialize client
client = BedrockClient()

# Query agent (automatic RAG)
response = client.invoke_agent("What is hierarchical chunking?")
print(response)

# Direct KB retrieval
results = client.retrieve_from_kb("FAISS vector search", max_results=5)
for result in results:
    print(f"Score: {result['score']:.4f}")
    print(f"Text: {result['content']['text'][:200]}...")

Understanding the Code

OpenSearch Manager

Manages OpenSearch Serverless index lifecycle:

from scripts.opensearch_manager import OpenSearchManager

manager = OpenSearchManager()

# Create index with FAISS
manager.create_index(
    index_name="bedrock-knowledge-base-index",
    dimension=1536,  # Titan embeddings
    engine="faiss"
)

# Check configuration
info = manager.get_index_info()
print(f"Engine: {info['mappings']['properties']['vector']['method']['engine']}")

# Recreate if needed
manager.recreate_index()

Benchmarks

Based on testing with 49.4 MB PDF (Amazon Bedrock User Guide):

Optimization Tips

Multimodal RAG

Bedrock Knowledge Bases support images, audio, and video through two approaches:

Metadata Filtering

Add metadata to documents for filtered retrieval:

response = client.retrieve(
    knowledgeBaseId='KB_ID',
    retrievalQuery={'text': 'query'},
    retrievalConfiguration={
        'vectorSearchConfiguration': {
            'filter': {
                'equals': {
                    'key': 'category',
                    'value': 'technical'
                }
            }
        }
    }
)

Semantic Chunking

Alternative to hierarchical chunking that uses NLP to split at semantic boundaries:

chunking_configuration {
  chunking_strategy = "SEMANTIC"
  semantic_chunking_configuration {
    max_tokens = 300
    buffer_size = 1
    breakpoint_percentile_threshold = 95
  }
}

You've now built a production-ready RAG system using AWS Bedrock with hierarchical chunking, FAISS vector search, and automatic retrieval through Bedrock Agents.

This architecture provides:

• Better context through hierarchical chunking
• Fast retrieval with FAISS indexing
• Scalability via serverless infrastructure
• Maintainability with Infrastructure as Code