Build a RAG Agent with Amazon Bedrock

Introduction

30 Second Summary

Imagine asking an AI a question about a specific document and getting a precise answer with a citation pointing you to the exact source. That's the power of Retrieval Augmented Generation, and it's the most in-demand skill in AWS ML engineering today.

In this project, you will build a Research Paper Q&A Agent powered by Amazon Bedrock. You'll upload papers to cloud storage, turn them into searchable vector embeddings, and wire up an agent that answers detailed questions with citations back to the source material.

What You'll Build

A fully functional RAG agent running on AWS that retrieves information from your uploaded research papers and generates grounded answers with source citations.

By the end of this project, you'll have:

• An S3 bucket storing research paper documents as your knowledge source.
• A Bedrock Knowledge Base that converts your documents into searchable vector embeddings using Amazon Titan.
• A Bedrock Agent powered by Amazon Nova Lite that answers questions about your papers with source citations.
• Secret Mission: Add Bedrock Guardrails to filter harmful content and block off-topic queries.

Are there any prerequisites?

You'll need an AWS account (free or paid). New accounts created after July 15, 2025 receive $100 in credits on sign-up, which more than covers this project's costs. No prior AWS experience is required.

Set Up Your AWS Environment

To build a RAG agent, you need two things from AWS: foundation models that can understand and generate text, and a place to store the documents your agent will learn from.

In this step, you'll enable access to the models your agent needs in Amazon Bedrock and create an S3 bucket to hold your research papers.

In this step, get ready to:

• Enable model access for Amazon Nova Lite and Amazon Titan Text Embeddings V2 in Bedrock.
• Create an S3 bucket and upload research documents to it.
• Verify your environment is configured correctly.

Enable model access in Amazon Bedrock

Before you can use any foundation model in Bedrock, you need to explicitly enable access to it. You'll enable two models: one for generating responses and one for converting documents into searchable vector embeddings.

• Open your web browser and navigate to the AWS Management Console at https://console.aws.amazon.com.
• Sign in with your AWS account credentials.
• In the top-right corner of the console, click the Region name (next to your account name).
• Select US East (N. Virginia) to set your region to us-east-1.
• In the top search bar, type Bedrock and select Amazon Bedrock from the dropdown results.

Why us-east-1?

The us-east-1 region has the widest model availability and is where most Bedrock features launch first. Model access you request in one region only applies to that region, so all resources in this project will live in us-east-1.

• In the left navigation pane of the Bedrock console, expand Bedrock configurations and choose Model access.
• Choose Enable specific models.
• In the Base models list, select the checkbox next to Nova Lite.
• Also select the checkbox next to Titan Text Embeddings V2.
• Click Next.
• On the Review and submit page, click Submit.

Refresh the Base models table after a few seconds. Both models should display an Access granted status.

What are these two models for?

Amazon Nova Lite is the orchestration model. It reads the user's question, decides what to do, and generates the final answer. It costs $0.00006 per 1,000 input tokens, making it one of the cheapest agent-capable models on Bedrock.

Amazon Titan Text Embeddings V2 converts your research documents into numerical vectors so the Knowledge Base can search them semantically. It handles up to 8,192 tokens per input and outputs vectors of 1,024 dimensions by default.

Model access not showing as granted?

Amazon-owned models (Nova, Titan) are typically granted instantly. If you still see a pending status after 30 seconds, refresh the page again. Make sure you are in the us-east-1 region. Model access is region-specific.

If your account has restrictive IAM policies, you may need the AmazonBedrockFullAccess managed policy attached to your user or role.

Help me troubleshoot why my Bedrock model access request is stuck in pending status.

Create an S3 bucket and upload your documents

Your agent needs source material to answer questions from. You'll upload research papers to an S3 bucket, which the Knowledge Base will index in the next step.

• In the top search bar of the AWS Console, type S3 and select S3 from the results.
• Confirm you are still in the US East (N. Virginia) region (check the top-right corner).
• In the left navigation pane, choose General purpose buckets.
• Click Create bucket.
• For Bucket name, enter a unique name like research-papers-yourname-2026 (replace yourname with your actual name to make it globally unique).
• Leave all other settings at their defaults.
• Scroll down and click Create bucket.

Why does the bucket name need to be globally unique?

S3 bucket names must be unique across all AWS customers worldwide. Adding your name and a year to the bucket name ensures no one else has claimed it. Bucket names can only contain lowercase letters, numbers, and hyphens.

Now create a folder inside the bucket and upload your research documents.

• Click the name of your newly created bucket to open it.
• On the Objects tab, click Create folder.
• Enter documents as the folder name.
• Click Create folder.
• Click the documents/ folder to open it.
• Click Upload.
• Click Add files and select 2-3 PDF research papers or text documents from your computer.
• Click Upload at the bottom of the page.

You should see a green success banner confirming your files uploaded successfully.

Choose papers you want to ask questions about

Pick research papers on a topic you find interesting. The agent you build will answer questions about these specific papers. Any PDF or plain text file will work. If you do not have papers handy, search for open-access PDFs on a topic like machine learning or climate science.

Seeing a bucket name error?

S3 bucket names must be 3-63 characters long, use only lowercase letters, numbers, and hyphens, and start and end with a letter or number. If you get a naming error, try adding extra numbers or changing the format.

Help me fix my S3 bucket naming error so I can create the bucket.

Verify your environment is ready

• Navigate back to the Bedrock console by searching Bedrock in the top search bar.
• In the left navigation pane, expand Bedrock configurations and choose Model access.
• Confirm both Amazon Nova Lite and Amazon Titan Text Embeddings V2 show Access granted in the status column.
• Navigate back to S3 by searching S3 in the top search bar.
• Click your bucket name, then click the documents/ folder.
• Confirm you see your 2-3 uploaded files listed inside the folder.

Your AWS environment is ready to go. Next up, you'll create a Knowledge Base that turns these documents into searchable vector embeddings.

Create the Knowledge Base

Your documents are sitting in S3, but an AI agent can't understand raw PDFs. It needs a way to search through them quickly and find the most relevant passages for any question.

A Knowledge Base solves this by converting your documents into vector embeddings. These are numerical representations that capture the meaning of your text, making it searchable by similarity rather than exact keyword matches.

In this step, get ready to:

• Create a Bedrock Knowledge Base connected to your S3 documents.
• Configure the embeddings model and vector store.
• Sync and test the Knowledge Base with a question about your papers.

Create the Knowledge Base and connect your S3 data source

The Bedrock console walks you through a guided wizard that sets up the Knowledge Base, its IAM service role, and the connection to your S3 data source all in one flow.

• In the Amazon Bedrock console's left navigation pane, click Knowledge bases.
• Click Create, then select Knowledge Base with vector store.
• Under Knowledge base details, change the default name to Research-Papers-KB.
• Under IAM permissions, select Create and use a new service role.
• For Data source, choose Amazon S3, then click Next.

What is the IAM service role doing?

Bedrock auto-provisions an IAM role with permissions to read from your S3 bucket and write to the vector store. You don't need to configure any IAM policies manually.

Now you'll configure the S3 data source details.

• Enter a data source name (the default is fine).
• For the S3 URI, enter s3:// followed by your bucket name (e.g., s3://research-papers-yourname-2026).
• In the inclusion prefix field, type documents/ to limit ingestion to your uploaded papers.
• Leave the Content parsing and chunking section at its defaults (fixed-size chunking).
• Click Next.

Why use an inclusion prefix?

The inclusion prefix tells Bedrock to only ingest files from the documents/ folder. This keeps your Knowledge Base focused on your research papers and ignores any other files you might add to the bucket later.

Configure the embeddings model and vector store

The embeddings model converts your document text into vectors. The vector store holds those vectors so the Knowledge Base can search them at query time.

• Under Embeddings model, select Titan Text Embeddings v2.
• Under Vector database, select Quick create a new vector store.
• Choose Amazon S3 Vectors as the vector store type.
• Click Next.
• Review the configuration summary, then click Create knowledge base.

What is Quick create doing behind the scenes?

When you choose Quick create, Bedrock automatically provisions an S3 Vectors bucket and a vector index with the correct settings. It also configures all the IAM permissions linking the Knowledge Base to the new vector store.

This saves you from manually setting up a vector database like OpenSearch Serverless, which has its own pricing and IAM complexity.

Wait for the knowledge base status to change to Available. This can take a few minutes.

Knowledge base stuck on In progress?

Creation typically takes 1-3 minutes. If it stays in progress for more than 5 minutes, refresh the page to check for an updated status.

If creation fails, check that your S3 bucket is in us-east-1 (the same region as the Knowledge Base). The bucket and Knowledge Base must be in the same region.

help me debug why my Bedrock Knowledge Base creation failed

Sync and test the Knowledge Base

Creating the Knowledge Base set up the infrastructure. Now you need to sync your documents so Bedrock actually ingests them into vector embeddings.

• On the Knowledge Base detail page, scroll to the Data source section.
• Select your data source, then click Sync.
• Wait for the sync status to show a green success banner confirming ingestion is complete.

What happens during a sync?

Bedrock reads each document from your S3 bucket, splits it into chunks (using the default fixed-size strategy), and sends each chunk through Amazon Titan Text Embeddings V2 to generate a vector. Those vectors are stored in your S3 Vectors index, ready for similarity search.

Now test the Knowledge Base to confirm it can retrieve relevant information from your papers.

• Click Test knowledge base at the top of the page. A test window expands from the right.
• Turn on Generate responses for your query.
• Click Select model, choose a model (e.g., Amazon Nova Lite), and click Apply.
• Type a question about your uploaded papers in the text box (e.g., "What are the key findings of this paper?").
• Click Run.

You should see a generated response with footnote citations. Click any footnote to view the source chunk and a link back to the S3 object.

What makes a good test question?

Ask something specific to your papers that a general model wouldn't know. For example, ask about a specific methodology, dataset, or conclusion. If the response cites your uploaded document, the Knowledge Base is working correctly.

Not seeing relevant results?

Make sure the sync completed successfully (green banner). If it shows warnings, click the sync event to see which files failed to ingest.

Check that your uploaded documents contain readable text. Scanned PDFs without OCR may not be parseable by the default parser.

help me figure out why my Knowledge Base test isn't returning relevant results

Your Knowledge Base is live and searchable. Next, you'll build a Bedrock Agent that uses this Knowledge Base to have intelligent conversations about your research papers.

Build and Configure the Agent

Your Knowledge Base is indexed, synced, and returning relevant chunks. Now you need something that can reason about user questions and decide when to query that Knowledge Base.

In this step, you will create a Bedrock Agent that uses Amazon Nova Lite as its foundation model. The agent will orchestrate the full RAG loop: interpret the user's question, query the Knowledge Base, retrieve relevant document chunks, and generate a cited answer.

In this step, get ready to:

• Create a Bedrock Agent named Research-Assistant with Amazon Nova Lite.
• Attach your Knowledge Base and configure interaction instructions.
• Test the agent and use Trace view to observe the orchestration steps.

Create a new Bedrock Agent

A Bedrock Agent is the orchestration layer that sits between the user and your Knowledge Base. It uses a foundation model to interpret questions, decide when to query the Knowledge Base, and compose answers from the retrieved chunks.

• In the Bedrock console, select Agents from the left navigation pane.
• Click Create Agent.
• For Name, replace the auto-generated name with Research-Assistant.
• Click Create. The Agent builder page opens automatically.

You are now in the Agent builder where you configure the model and instructions.

• In the Agent details section, for Agent resource role, select Create and use a new service role.
• For Select model, choose Amazon Nova Lite.
• In the Instructions for the Agent section, enter the following instructions:

You are a research assistant that answers questions about academic papers. Use the knowledge base to find relevant information. Always cite the source document when answering. If you cannot find relevant information in the knowledge base, say so clearly.

What do these instructions do?

The instructions define the agent's persona and behavior rules. They tell the model to always pull from the Knowledge Base, cite its sources, and be transparent when it does not have relevant information.

These instructions populate the orchestration prompt that the agent uses behind the scenes to decide how to handle each user message.

• Click Save. A green success banner confirms the agent details are saved.

Don't see Amazon Nova Lite in the model list?

Make sure your region is set to US East (N. Virginia) (us-east-1). Also confirm that model access for Amazon Nova Lite shows Access granted on the Bedrock Model access page from Step 1.

Help me troubleshoot why Amazon Nova Lite isn't showing up in my Bedrock Agent model selection.

Attach your Knowledge Base to the agent

Without a Knowledge Base attached, the agent can only answer from the foundation model's general training data. Attaching your Knowledge Base gives the agent access to the specific research papers you uploaded.

• In the Agent builder, scroll down to the Knowledge bases section.
• Click Add.
• Select your Research-Papers-KB Knowledge Base from the list.
• In the interaction instructions field, enter the following text that tells the agent when to query this Knowledge Base:

Use this knowledge base to answer all questions about research papers, findings, methodologies, and conclusions.

Why do I need interaction instructions?

Interaction instructions help the agent decide when to query the Knowledge Base versus answering from its general knowledge. Without them, the agent might not retrieve from your documents at all.

Being specific about the topics (research papers, findings, methodologies) gives the agent a clear signal for routing user questions to the right source.

• Click Add. A green success banner confirms the Knowledge Base is attached.
• Click Prepare at the top of the page to package the agent with your latest configuration.

What does Prepare do?

Every time you change an agent's configuration, you need to click Prepare to apply those changes to the working draft. Until you prepare, the test panel uses the previous configuration.

Don't see your Knowledge Base in the list?

Confirm you created the Knowledge Base in the same region (us-east-1) as the agent. Knowledge Bases from other regions will not appear in the dropdown.

Help me troubleshoot why my Knowledge Base isn't showing up when I try to attach it to my Bedrock Agent.

Test the agent with Trace view

The built-in test panel lets you interact with your agent directly in the console. The Trace view reveals every orchestration step the agent takes, from interpreting your question to retrieving Knowledge Base chunks to generating the final response.

• The Test window should appear in a pane on the right side of the Agent builder. If it is closed, click Test at the top of the page to reopen it.
• In the Test window, type a question about your uploaded papers. For example:

What methodology did the authors use?

• Click Run.
• While the response is generating (or after it finishes), click Show trace.

The Trace view updates in real-time. You can expand or collapse each step by clicking the arrow next to it.

What should I see in the Trace view?

The trace shows the agent's step-by-step reasoning process. You will see multiple trace types:

• PreProcessingTrace shows how the agent interprets and categorizes your question.
• OrchestrationTrace shows the agent deciding to query the Knowledge Base, retrieving chunks, and generating a response.
• PostProcessingTrace shows how the agent shapes the final output before returning it to you.

This trace is the same observability pattern used in production debugging. It lets you understand exactly why the agent gave a specific answer.

• Try a second question to further verify the agent works. For example:

What were the key findings?

• Click Run and confirm the response includes citations from your uploaded documents. If a Knowledge Base is invoked, the response contains footnotes linking to the S3 objects with the cited information.

Agent not returning relevant answers?

Make sure you clicked Prepare after attaching the Knowledge Base. Without preparing, the test panel still uses the old configuration.

Also verify that your Knowledge Base sync completed successfully in Step 2. If the documents were not ingested, the agent has nothing to retrieve.

Help me troubleshoot why my Bedrock Agent isn't returning answers from my Knowledge Base.

Your Research-Assistant agent is live and answering questions from your papers with citations. Next up, you will iterate on the agent's instructions to handle edge cases and improve response quality.

Iterate and Optimize Agent Behavior

Your agent can answer questions about your research papers. But what happens when someone asks it something completely unrelated to your documents?

In production, users ask all sorts of unexpected questions. A well-built agent handles these gracefully instead of hallucinating answers or returning confusing responses. In this step, you'll stress-test your agent with edge cases and refine its instructions to improve behavior.

In this step, get ready to:

• Test how the agent handles out-of-scope questions.
• Refine agent instructions to handle edge cases gracefully.
• Update knowledge base interaction instructions for more precise retrieval.

Test edge cases with out-of-scope questions

The best way to find weaknesses in your agent is to ask it something your papers definitely don't cover. This reveals whether the agent tries to hallucinate an answer or admits it doesn't know.

• Return to the test panel for your Research-Assistant agent in the Bedrock console.
• Type an out-of-scope question into the test panel, such as: What is the weather today?
• Press Run and observe how the agent responds.

Pay attention to whether the agent attempts to answer from the knowledge base, makes something up, or clearly states it cannot help with that topic.

Why does this matter?

In production, users will always ask questions outside your agent's scope. Without clear instructions on how to handle these, the agent might query the knowledge base anyway and return irrelevant chunks as if they were answers.

A well-configured agent says "I don't have information about that" instead of guessing. This is the difference between a prototype and a production-quality system.

Now you'll refine the agent's instructions so it handles these out-of-scope queries gracefully.

• Close the test panel and click Edit in Agent Builder at the top of your agent page.
• In the Instructions for the Agent field, update the text to add explicit guidance on handling out-of-scope queries. For example, add a sentence like: "If the user asks about something unrelated to academic research papers, politely let them know you can only help with research paper questions."
• Click Prepare at the top of the Agent Builder to apply your changes.

What does Prepare do?

Every time you update agent instructions, you need to click Prepare before testing again. This repackages your agent configuration so the orchestration model uses your updated instructions. Without preparing, you'll still be testing the old version.

• Once preparation completes, open the test panel again.
• Ask the same out-of-scope question: What is the weather today?
• Confirm the agent now responds gracefully, telling you it can only assist with research paper questions instead of attempting to answer.

Agent still trying to answer out-of-scope questions?

Make sure you clicked Prepare after editing. If you only saved the instructions without preparing, the agent still uses the previous configuration.

If you prepared and the agent still answers off-topic questions, try making your instructions more direct. For example: "Do NOT attempt to answer questions about weather, sports, news, or anything unrelated to research papers."

Help me refine my Bedrock Agent instructions so it stops answering out-of-scope questions.

Update knowledge base interaction instructions for precision

The agent instructions control overall behavior. The knowledge base interaction instructions control when the agent decides to query the knowledge base specifically. Making these more precise reduces unnecessary retrievals and improves response quality.

• In the Agent Builder, scroll down to the Knowledge bases section.
• Select your Research-Papers-KB and click Edit.
• Replace the existing interaction instructions with a more specific version:

Only use this knowledge base when the user asks about research methodology, findings, or paper content. For general questions, respond from your own knowledge.

• Click Save to confirm the knowledge base interaction update.
• Click Prepare at the top to apply the changes.

Why more specific interaction instructions?

Your original instructions told the agent to "use this knowledge base to answer all questions about research papers, findings, methodologies, and conclusions." That broad phrasing can cause the agent to query the knowledge base for every question, even ones it could answer on its own.

The updated instructions draw a clear boundary. The agent only queries the knowledge base for paper-specific questions and uses its own training for general knowledge. This reduces latency and keeps responses focused.

• Open the test panel and ask a question about your papers, such as: What methodology did the authors use?
• Enable Trace view to see the orchestration steps.
• Confirm the trace shows the agent querying the knowledge base and returning relevant chunks with source citations.

• Now ask a general question that isn't paper-specific, such as: What is machine learning?
• Check the trace output. The agent should respond from its own knowledge without querying the knowledge base.

Compare traces side by side

Look at the trace for your in-scope question versus the general question. In the in-scope trace, you'll see a "Knowledge Base Lookup" step where the agent retrieves chunks. In the general question trace, this step should be absent. This is exactly how production teams verify their agents are routing queries correctly.

Validate your agent's final behavior

Time to run a final round of tests to confirm your agent meets production-quality standards.

• In the test panel, ask a specific question about your papers (e.g., What were the key findings?). Verify the response includes citations pointing to the source document.
• Ask an out-of-scope question (e.g., What is the weather today?). Verify the agent clearly indicates it cannot help with that topic.
• Check the Trace view on your in-scope question. Confirm you see clean orchestration: the agent decides to query the KB, retrieves relevant chunks, and generates its answer from those chunks.

What should a clean trace look like?

A well-functioning RAG trace shows three distinct phases. First, the agent interprets the user's question and decides it needs to check the knowledge base. Second, it retrieves matching document chunks ranked by relevance. Third, it generates a response grounded in those chunks, citing the source.

This is the same observability pattern production teams use when debugging why an agent gave a wrong answer. The trace tells you exactly where things went right or wrong.

Your agent now handles both in-scope and out-of-scope questions cleanly. Next up, you'll take things further in the Secret Mission by adding Bedrock Guardrails for content safety and topic filtering.

Secret mission

Add Bedrock Guardrails

Your agent answers questions well, but what stops it from generating harmful content or giving investment advice? In production, every AI system needs safety boundaries. In this secret mission, you will create a Bedrock Guardrail that blocks denied topics and filters harmful content, then attach it to your Research-Assistant agent.

Clean Up Your Resources

Clean Up Your Resources

Decide whether to keep your resources running, pause them to come back later, or delete them entirely. All Bedrock resources in this project are serverless and only incur charges when invoked, so costs remain minimal when idle.

Cost warning

While idle costs are very low (under $1/month for S3 storage), any Bedrock model invocations are charged per token on-demand. If you plan to leave resources running and continue testing, be aware that each agent conversation uses Amazon Nova Lite and Titan Embeddings tokens.

If you are not planning to use the agent again soon, choose Pause or Delete below to avoid any unexpected charges.

Resources you used:

• S3 bucket (e.g., research-papers-yourname-2026) with uploaded research documents.
• Bedrock Knowledge Base (Research-Papers-KB) with an auto-provisioned S3 Vectors bucket and index.
• Bedrock Agent (Research-Assistant) using Amazon Nova Lite.
• Bedrock Guardrail with denied topic and content filters.
• Auto-created IAM service roles for the Knowledge Base and Agent.

Keep everything running

No action needed. Choose this if you are still actively building or plan to keep testing your agent.

• Your Bedrock Agent and Knowledge Base are serverless. They only charge per invocation, not while idle.
• S3 storage costs for a few PDFs are negligible (pennies per month).
• Model access grants remain active at no cost.

Pause - I'll come back to this later

Shut down active usage to free up any background costs, while keeping your configuration intact.

• No specific pause action is required. Bedrock Agents, Knowledge Bases, and Guardrails are serverless and do not charge while idle.
• Simply stop invoking the agent. Your resources will remain configured and ready when you return.
• S3 storage charges continue but are minimal for a few documents.

Delete - I don't want to use this again

Remove all project resources completely. Follow these steps in order to avoid dependency errors.

Delete the Bedrock Agent:

• In the Bedrock console, select Agents from the left navigation pane.
• Select the radio button next to Research-Assistant.
• Choose Delete. Type delete in the confirmation field and confirm.

Delete the Bedrock Guardrail:

• In the Bedrock console, select Guardrails from the left navigation pane.
• Select your guardrail in the Guardrails section.
• Choose Delete. Type delete in the confirmation field and confirm.

Delete the Bedrock Knowledge Base:

• In the Bedrock console, select Knowledge bases from the left navigation pane.
• Select Research-Papers-KB and choose Delete.
• Type delete in the confirmation field and confirm.

What about the vector store?

Deleting the Knowledge Base does not automatically delete the auto-provisioned S3 Vectors bucket. The vector data is deleted, but the S3 Vectors bucket remains. You can delete it in the S3 console (see below) if you want a full cleanup.

Empty and delete the S3 buckets:

• Open the S3 console at https://console.aws.amazon.com/s3/.
• In General purpose buckets, select your research papers bucket (e.g., research-papers-yourname-2026).
• Choose Empty. Type permanently delete to confirm, then choose Empty.
• Return to the bucket list. Select the now-empty bucket and choose Delete. Enter the bucket name to confirm and choose Delete bucket.
• Repeat the empty-and-delete steps for the auto-provisioned S3 Vectors bucket (it will have a name starting with bedrock or similar).

Delete the auto-created IAM roles (optional):

• Open the IAM console at https://console.aws.amazon.com/iam/.
• In the left navigation pane, choose Roles.
• Search for roles containing AmazonBedrockExecution in the name. You should find roles for both the Knowledge Base and the Agent.
• Select the checkbox next to each Bedrock role, choose Delete at the top of the page, enter the role name to confirm, and choose Delete.

That's a Wrap!

That's a Wrap!

Nice work! You just built a production-pattern RAG agent on Amazon Bedrock that retrieves information from research papers and answers questions with source citations.

You've learned how to:

• Built a Bedrock Knowledge Base that converts research documents into searchable vector embeddings using Amazon Titan Text Embeddings V2.
• Created and tested a Bedrock Agent powered by Amazon Nova Lite that answers domain-specific questions with source citations from your papers.
• Used Trace view to debug the agent's orchestration steps and iterated on instructions to handle edge cases gracefully.
• Secret Mission: Added Bedrock Guardrails to enforce content safety and block off-topic queries from reaching your agent.

Ready to quiz yourself?