Build Enterprise RAG on AWS with Managed Knowledge Bases, Smart Parsing, and Agentic Retrieval

Enterprise AI assistants need more than a language model. They need access to the right documents, reliable retrieval, and answers that users can verify. When developing complex applications, developers often face infrastructural bottlenecks that slow down time-to-market. For production workloads demanding ultra-low latency and multi-model flexibility, integrating robust infrastructure layers like n1n.ai ensures seamless API routing and high availability.

Imagine asking an internal assistant: Which team owns our ML platform, what is its annual cloud budget, and does our purchasing policy allow annual prepayment? The answer may be spread across a team ownership document, a budget file, and an expense policy. A basic retrieval pipeline might find only one of them, leaving the answer incomplete.

Amazon Bedrock Managed Knowledge Base helps simplify enterprise Retrieval-Augmented Generation (RAG) with managed ingestion and retrieval, native data connectors, Smart Parsing, and agentic retrieval. In this tutorial, we'll explore these capabilities and build a Python demo that retrieves evidence from multiple enterprise documents.

Understanding Enterprise RAG Architecture

RAG combines document retrieval with a generative AI model. Instead of relying only on information learned during training, an application retrieves relevant information from configured sources and uses it to generate an answer. For enterprise systems scaling globally, developers also leverage aggregators like n1n.ai to optimize model inference costs and manage fallback providers effortlessly.

A typical RAG pipeline includes:

• Data source connections
• Document parsing and chunking
• Embeddings and indexing
• Retrieval and ranking
• Answer generation
• Source references and evaluation

Managing each component independently can add operational complexity. Amazon Bedrock Managed Knowledge Base provides a managed approach to knowledge ingestion and retrieval, helping developers focus on the application rather than building every RAG component themselves.

Native Data Connectors and Smart Parsing

Enterprise knowledge is often distributed across different platforms. Managed Knowledge Base supports native connectors for supported sources such as Amazon S3, Microsoft SharePoint, Atlassian Confluence, Google Drive, Microsoft OneDrive, and Web Crawlers. These connectors can reduce the amount of custom ingestion code required to bring enterprise content into a knowledge base.

Not all enterprise data is plain text. PDFs, reports, presentations, and technical documents may contain tables, diagrams, screenshots, or complex layouts. Smart Parsing helps process supported content so that it can be used more effectively during retrieval.

Implementing Agentic Retrieval

Traditional retrieval typically searches for content relevant to a query. This works well for straightforward questions, but more complex questions may require multiple searches. Agentic retrieval uses a foundation model to plan and refine retrieval across configured knowledge base retrievers. It can decompose a complex question into sub-queries, retrieve information iteratively, and assess whether enough evidence is available.

Setting Up the Project

We'll create an enterprise policy assistant using three fictional documents stored in an S3 bucket.

entrise-rag-demo/
├── documents/
│   ├── team-ownership.md
│   ├── cloud-budget.md
│   └── expense-policy.md
└── query_enterprise_kb.py

Create documents/team-ownership.md:

# ML Platform Team Ownership

The ML Platform team owns the internal machine learning platform and its shared deployment infrastructure.

Create documents/cloud-budget.md:

# ML Platform Cloud Budget

The ML Platform team has an illustrative annual cloud infrastructure budget of $120,000.

Create documents/expense-policy.md:

# Cloud Expense and Prepayment Policy

Annual cloud prepayment may be considered when the purchase meets procurement requirements.

Python Implementation with Boto3

Install the required AWS SDK for Python:

python -m pip install --upgrade boto3

Create query_enterprise_kb.py to handle agentic retrieval streams:

import os
import boto3

REGION = os.getenv("AWS_REGION", "us-east-1")
KNOWLEDGE_BASE_ID = os.environ["KNOWLEDGE_BASE_ID"]

client = boto3.client(
    "bedrock-agent-runtime",
    region_name=REGION
)

question = (
    "Which team owns the ML platform, what is its annual "
    "cloud budget, and does the expense policy allow annual "
    "prepayment? Explain the conditions and identify what "
    "must happen before a commitment is made."
)

response = client.agentic_retrieve_stream(
    messages=[
        {
            "role": "user",
            "content": {
                "text": question
            }
        }
    ],
    retrievers=[
        {
            "description": "Enterprise policies and platform documents",
            "configuration": {
                "knowledgeBase": {
                    "knowledgeBaseId": KNOWLEDGE_BASE_ID
                }
            }
        }
    ],
    agenticRetrieveConfiguration={
        "foundationModelType": "MANAGED",
        "rerankingModelType": "MANAGED"
    },
    generateResponse=True
)

for event in response["stream"]:
    if "responseEvent" in event:
        print(
            event["responseEvent"].get("text", ""),
            end="",
            flush=True
        )
    elif "result" in event:
        result = event["result"]
        print("\n\n--- Retrieved Sources ---")
        for index, item in enumerate(result.get("results", []), start=1):
            content = item.get("content", {})
            print(f"\nSource {index}: {content.get('text', '')}")

Production Best Practices

Before deploying an enterprise RAG application into production, consider these architectural pillars:

• Access Control: Ensure users retrieve only documents they are authorized to access.
• Observability & Routing: Combine AWS logging with gateway solutions like n1n.ai to monitor execution metrics, latency, and token consumption securely.
• Prompt Injection Defense: Treat retrieved content as untrusted input.

Get a free API key at n1n.ai