Forem: Arsy Opraza Akma

How to Use RAG with Amazon Bedrock + Nova for Building Chatbots

Arsy Opraza Akma — Thu, 25 Sep 2025 06:43:59 +0000

Recently, I have been exploring Retrieval-Augmented Generation (RAG) and building a chatbot for fun. The reason became I interested in RAG because i use AI every day, especially Generative AI, such as large language models (LLM). LLM so helpful and often provide impressive responses.

However, LLM-generated response have a challenge. These response need to include with factual information. When you use an LLM to generate a response, it relies only on the data on which it was trained.

For example, when you ask, "What food should I eat when I do X?", the result will likely be a impressive, grammatically correct and logical response, but because it isn't based on factual or contextual data, it maybe inaccurate.

In contrast, you can use a data or knowledge with some relevant, factual context and information to generate a contextualized, relevant, and accurate response.

The data or knowledge can be any document of relevant data to provide relevant information. For example, you could use data from a daily food you eat to help answer the prompt "What food should i eat when do X?" so that the response includes relevant response.

To ensure that an LLM provides accurate and domain-specific responses, you can use Retrieval-Augmented Generation (RAG).

RAG is a process of optimizing the output of a large language model using retrieving information technique that is relevant to the user's prompt.

RAG have three steps:

Retrieve data based on the user prompt.
Augment the prompt with knowledge data.
Use a language model to generate a response.

By retrieving context from specified data, you ensure that the LLM uses relevant information when responding, rather than relying solely on its training data

A standard RAG app usually has two main parts:

Indexing: a process that takes data from a source, organizes it, and stores it in an index.
Retrieval and generation: the RAG workflow itself, where a user’s query is received, the system looks up the most relevant information from the index, and then sends that context to the model to generate a response.

In my explorations, I will build a simple chatbot that can generate answers based on a provided document using the following tools:

Langchain
Bedrock Embedding
Amazon titan embedding model
Amazon nova for chat model
Chroma as Vector DB

So, we will start by indexing. Let's go!

Setup

First, we will setup tools that will we use. Install this packages:
pip install -qU "langchain[aws]" langchain-aws langchain-chroma PyMuPDF langchain-text-splitters langchain-community langgraph

Indexing

After we setup the project, next we will indexing. Indexing data have this part:

Load: Start by loading data.
Split: Break big documents into smaller pieces.
Store: Save those in a storage system that supports indexing and searching. This is often done with a Vector Store combined with an embeddings model.

Write following code.

embeddings = BedrockEmbeddings(model_id="amazon.titan-embed-text-v2:0")
vector_store = Chroma(
    collection_name=COLLECTION,
    embedding_function=embeddings,
    persist_directory=DB_DIR,
)
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)

def index_documents():
    print("📂 Loading and indexing documents...")
    loader = PyMuPDFLoader(PDF_PATH, mode="page")
    docs = loader.load()
    chunks = splitter.split_documents(docs)

    vector_store.add_documents(chunks)
    vector_store.persist()
    print(f"✅ Indexed {len(chunks)} chunks into {DB_DIR}")

First, we set up embeddings using Amazon’s Titan model. Embeddings as a way to turn text into numbers so the computer can understand and compare meaning.

Then, we create a vector database with Chroma that can store and search those embeddings. We also set up a text splitter so large documents can be cut into smaller, manageable chunks of around 1,000 characters each, with a bit of overlap to keep context intact.

The function index_documents(), creates a loader that reads a PDF file (located at PDF_PATH). The mode="page" means it treats each page of the PDF as a separate unit.

Then, split the documents into smaller part (chunking) and saves those chunks into the vector database.

At the end, you’ll have your document neatly indexed, so later when a user asks a question, the system can quickly find the right pieces of text to feed into AI model.

Retrieval and Generation

Now, it’s time to build the core application. The goal is to make a simple app that takes a user’s question, finds the most relevant documents, sends both the question and those documents to a model, and then gives back an answer.

For generation, we will use the chat model with Amazon Nova. Write following code.

llm = init_chat_model("us.amazon.nova-lite-v1:0", model_provider="bedrock_converse")

Then, write RAG pipeline. We will write state for application. Write this code.

from langchain_core.documents import Document
from typing_extensions import List, TypedDict

class State(TypedDict):
    question: str
    context: List[Document]
    answer: str

We will keep track of the question, the context (docs we retrieve), and the answer.

Next, write this function.

def retrieve(state: State):
    retrieved_docs = vector_store.similarity_search(state["question"], k=4)
    return {"context": retrieved_docs}

When a user asks a question, this part looks inside the vector database and pulls out the top 4 most relevant documents. Those docs will become the context for the model to use.

After that, write system prompt and create generate function.

SYSTEM_PROMPT = "Your system prompt"

def generate(state: State):
    if not state["context"]:
        return {"answer": "Sorry, i can't answers."}

    docs_content = "\n\n".join(doc.page_content for doc in state["context"])
    user_payload = f"""Context: {docs_content} Question: {state['question']} Answer:"""
    messages = [
        SystemMessage(content=SYSTEM_PROMPT),
        HumanMessage(content=user_payload)
    ]
    response = llm.invoke(messages)
    return {"answer": response.content}

Lastly, we compile our application into a single graph object. In this case, we are just connecting the retrieval and generation steps into a single sequence.

graph_builder = StateGraph(State)
graph_builder.add_sequence([retrieve, generate])
graph_builder.add_edge(START, "retrieve")
graph = graph_builder.compile()

This is the complete code.

import argparse
import os
import textwrap
import langchain
from typing_extensions import List, TypedDict

from langchain_aws import BedrockEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.documents import Document
from langchain_community.document_loaders import PyMuPDFLoader
from langchain_chroma import Chroma
from langchain.chat_models import init_chat_model
from langchain.schema import SystemMessage, HumanMessage
from langgraph.graph import START, StateGraph


# ===================================================================
# Global Config
# ===================================================================
langchain.verbose = False
langchain.debug = False
langchain.llm_cache = None

DB_DIR = "./chroma_langchain_db"
COLLECTION = "example_collection"
PDF_PATH = "docs/ilovepdf_merged.pdf"

embeddings = BedrockEmbeddings(model_id="amazon.titan-embed-text-v2:0")
vector_store = Chroma(
    collection_name=COLLECTION,
    embedding_function=embeddings,
    persist_directory=DB_DIR,
)

llm = init_chat_model("us.amazon.nova-lite-v1:0", model_provider="bedrock_converse")

splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)


# ===================================================================
# Indexing Function
# ===================================================================
def index_documents():
    print("📂 Loading and indexing documents...")
    loader = PyMuPDFLoader(PDF_PATH, mode="page")
    docs = loader.load()
    chunks = splitter.split_documents(docs)

    vector_store.add_documents(chunks)
    vector_store.persist()
    print(f"✅ Indexed {len(chunks)} chunks into {DB_DIR}")


# ===================================================================
# RAG Pipeline
# ===================================================================
class State(TypedDict):
    question: str
    context: List[Document]
    answer: str


def retrieve(state: State):
    retrieved_docs = vector_store.similarity_search(state["question"], k=4)
    return {"context": retrieved_docs}


SYSTEM_PROMPT = "Your system prompts".
def generate(state: State):
    if not state["context"]:
        return {"answer": "Sorry, i can't answers."}

    docs_content = "\n\n".join(doc.page_content for doc in state["context"])
    user_payload = f"""Context: {docs_content} Question: {state['question']} Answer:"""
    messages = [
        SystemMessage(content=SYSTEM_PROMPT),
        HumanMessage(content=user_payload)
    ]
    response = llm.invoke(messages)
    return {"answer": response.content}

graph_builder = StateGraph(State)
graph_builder.add_sequence([retrieve, generate])
graph_builder.add_edge(START, "retrieve")
graph = graph_builder.compile()

def query_pipeline(question: str):
    response = graph.invoke({"question": question})
    print(f"Question: {question}\nAnswer: {response['answer']}")


# ===================================================================
# CLI Entrypoint
# ===================================================================
if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--index", action="store_true", help="Index documents into vector DB")
    parser.add_argument("--query", type=str, help="Run a query against the DB")
    args = parser.parse_args()

    if args.index:
        index_documents()
    elif args.query:
        query_pipeline(args.query)
    else:
        parser.print_help()

You can test give a prompt and ask a questions that relate with information on the documents.

If you encounter error, make sure you have a access to the Amazon Bedrock and the Amazon Titan and Nova models.

Thanks for reading.

Want to connect?
Arsy Opraza, Curriculum Developer at Dicoding.
https://www.linkedin.com/in/arasopraza/
https://github.com/arasopraza
https://twitter.com/arsyopraza

Beginner-Friendly: Cara Bangun Serverless Function dengan AWS Lambda

Arsy Opraza Akma — Wed, 11 Jun 2025 17:40:45 +0000

Dulu ketika sering datang ke event dan conference IT, banyak yang bahas mengenai AWS Lambda. Katanya sih modern app udah pake AWS Lambda.

Ketika lihat demonya, wah keren juga ya, kok bisa gitu. Sayangnya, cuma sebatas itu dan ga mencari tahu lebih detail dan nyobain AWS Lambda.

Nah, apa sih AWS Lambda itu. Yuk kita bahas!

AWS Lambda: Solusi Praktis untuk Backend Modern

AWS Lambda adalah layanan dari AWS yang memungkinkan untuk run code tanpa manage server. Yap, sering kali orang bilangnya serverless.

Lambda dapat running code pada infrastruktur komputasi dengan ketersediaan tinggi dan mengelola semua sumber daya komputasi, termasuk pemeliharaan server dan sistem operasi, penyediaan kapasitas, penskalaan otomatis, dan pencatatan.

Code tersebut diatur ke dalam sebuah Lambda functions. AWS Lambda hanya ngerunning function jika diperlukan saja. Untuk detail pricing-nya, dapat dilihat di bawah ini.

Detailnya, dapat dibaca di halaman Lambda Pricing.

Kapan saatnya menggunakan Lambda?

Gunakan Lambda ketika menangani kasus berikut.

Stream processing: AWS Lambda dapat digunakan untuk real-time streaming data bersamaan dengan Amazon Kinesis. Data yang distream terdiri dari activity tracking, log filtering, dan transaction order processing.
File processing: Gunakan Amazon Simple Storage Service (Amazon S3) untuk trigger Lambda untuk data processing secara real time setelah upload data ke Amazon S3.
Web applications: Lambda dapat digabungkan dengan services AWS lainnya untuk membangun web app yang powerful. Developer bisa menggunakan infrastructure as code (IaC) seperti AWS CloudFormation, AWS Cloud Development Kit (AWS CDK), AWS Serverless Application Model, dan AWS Step Functions.
Mobile backends: Lambda dan Amazon API Gateway dapat digunakan untuk autentikasi dan proses API Request. Gunakan juga AWS Amplify untuk terintegrasi dengan iOS, Android, Web, dan React Native.
IoT backends: Bangun serverless backends menggunakan Lambda untuk menangani web, mobile, IoT, dan third-party API.
Database Operations dan Integration: Gunakan Lambda untuk proses interaksi dengan database seperti Amazon RDS.

Oke, itu kasus yang pas untuk menggunakan Lambda. Lalu, apa saja fitur yang ada di Lambda?

Fitur utama Lambda

Berikut adalah beberapa fitur utama dari Lambda.

Environment variables: Dapat menggunakan environment variables tanpa mengubah code.
Versions: Versioning dapat digunakan untuk mengelola versi deployments dariLambda functions.
VPC networks: Lambda menjadi lebih aman dengan adanya VPC networks.
File system: Function dapat dikonfigurasi untuk mount sebuah Amazon Elastic File System (Amazon EFS) file system ke direktori lokal.
Function URLs: URL function merupakan dedicated HTTP(S) endpoint untuk Lambda function.

Itu beberapa fitur utama dari Lambda. Nah, biar lebih seru, setelah mengenal teori dasar dari Lambda. Kini, saatnya untuk nyobain langsung.

Hands-on Serverless dengan Lambda

Buka halaman Lambda.
Pilih Create Functions.
Kemudian, pilih Author from scratch
Pada bagian basic information, berikan nilai untuk function name. Misalnya, myFunctionDemo.
Untuk Runtime, dapat memilih beberapa bahasa pemrograman tetapi saat ini cukup pilih Node.js 22.
Selanjutnya, untuk architecture pilih x86_64.
Konfigurasi lainnya biarkan saja bernilai default. Klik Create function.
Lambda akan membuat sebuah code. Untuk mengubah code tersebut dapat dilakukan dengan cara _ console's built-in code editor_.
Misalnya, pengen ngubah teks "Hello from Lambda!" menjadi "Hello from Demo Lambda!". Langsung saja buka berkas index.mjs dan ubah kode yang ada pada bagian kanan.
Setelah itu, pada bagian DEPLOY, pilih Deploy.
Untuk menguji memanggil Lambda functions dapat dilakukan melalui console code editor. Buatlah sebuah test event dengan cara di bagian TEST EVENTS, pilih Create test event.
Masukin nama "testEvent" dan di Event JSON section, tambahkan sebuah JSON sederhana.

{
  "name": "Ini test lambda"
}

Klik save.
Kemudian, masih di bagian TEST EVENTS, klik icon run.
Jika tidak ada error, akan berhasil dengan message yang muncul pada bagian OUTPUT di code editor.

Oke, mudah, kan?

Nah, setelah deploy Lambda function, kita bisa memanggilnya dengan beberapa cara seperti:

The Lambda console
The AWS SDK
The Invoke API
The AWS Command Line Interface (AWS CLI)
A function URL HTTP(S) endpoint

Kita akan coba salah satu cara yaitu function URL. Simak caranya!

Invoke Lambda Function via URL HTTP(S)

Untuk membuat function URL dapat dilakukan dengan 4 langkah.

Buka tab Configuration dan pilih Function URL.
Kemudian, klik Create function URL.
Untuk Auth type, silakan pilih NONE.
Terakhir, klik Save.

Endpoint untuk function URL akan tampak di bagian Function URL.

Menguji Function URL.

Untuk mengujinya, akses endpoint tersebut di browser/Postman/cURL.

Yey, Berhasil!

Melihat function's invocation records di CloudWatch Logs

Ketika memanggil function di luar dari Lambda console, kita harus menggunakan CloudWatch Logs untuk melihat hasil eksekusi function-nya.

Caranya akses laman https://console.aws.amazon.com/cloudwatch/home#logs: secara otomatis akan terdapat log group yang dihasilkan oleh Lambda.

Klik nama log group-nya.

Pilih log stream dari salah satu function invocations dan akan tampak seperti berikut.

2025-06-11T17:06:24.229Z
INIT_START Runtime Version: nodejs:22.v43 Runtime Version ARN: arn:aws:lambda:ap-southeast-2::runtime:fd2e05b324f99edd3c6e17800b2535deb79bcce74b7506d595a94870b3d9bd2e
2025-06-11T17:06:24.377Z
START RequestId: 00529f70-dd62-414b-9aa4-483fc6a67b2a Version: $LATEST
2025-06-11T17:06:24.398Z
END RequestId: 00529f70-dd62-414b-9aa4-483fc6a67b2a
2025-06-11T17:06:24.398Z
REPORT RequestId: 00529f70-dd62-414b-9aa4-483fc6a67b2a Duration: 20.25 ms Billed Duration: 21 ms Memory Size: 128 MB Max Memory Used: 72 MB Init Duration: 144.59 ms
2025-06-11T17:06:24.895Z
START RequestId: 5d824554-3eb4-4f83-9826-36605c566659 Version: $LATEST
2025-06-11T17:06:24.916Z
END RequestId: 5d824554-3eb4-4f83-9826-36605c566659
2025-06-11T17:06:24.917Z
REPORT RequestId: 5d824554-3eb4-4f83-9826-36605c566659 Duration: 20.46 ms Billed Duration: 21 ms Memory Size: 128 MB Max Memory Used: 73 MB
2025-06-11T17:07:37.237Z
START RequestId: 3c86fb4b-a7a5-4fe8-b959-f1b2d91e24ff Version: $LATEST
2025-06-11T17:07:37.256Z
END RequestId: 3c86fb4b-a7a5-4fe8-b959-f1b2d91e24ff
2025-06-11T17:07:37.256Z
REPORT RequestId: 3c86fb4b-a7a5-4fe8-b959-f1b2d91e24ff Duration: 2.17 ms Billed Duration: 3 ms Memory Size: 128 MB Max Memory Used: 73 MB

Gampang, kan?

Di blog ini, kita udah melewati proses mulai dari bikin Lambda function, testing via test event, sampe expose via Function URL dan ngetes pake cURL.

Next step? Integrasi ke use case real. Bisa buat webhook, backend microservice, sampai automation kecil-kecilan.