DEV Community: Ragavi S

RAG Tutorial 2026: Build AI Chatbot with LangChain & ChromaDB (Step-by-Step Guide)

Ragavi S — Fri, 20 Mar 2026 15:10:50 +0000

I've seen a lot of RAG tutorials that explain the concept beautifully — then leave you staring at a 10-line pseudocode example. Not useful. This one is different. We're building an actual working AI chatbot using LangChain and ChromaDB, the kind where you drop in a real PDF and start asking questions immediately. Every file. Every line. Explained. If you've been googling "RAG LangChain tutorial" or "ChromaDB vector database" and landing on half-finished Medium posts — stick around. This is the guide I wish existed when I first started.

💬 "Most teams that think they need fine-tuning actually just need RAG. Fine-tuning costs thousands. RAG costs an API call."

RAG Tutorial for Beginners — What is Retrieval Augmented Generation?

Here's the thing nobody tells you when you first start building with LLMs — they're confidently wrong. GPT-4, Claude, Gemini, it doesn't matter. Ask any of them about your internal documentation, your last product release, or something that happened three months ago and you'll get either a hallucinated answer or a polite "I don't have access to that." Neither works in production. This RAG tutorial is how you fix that properly.

The core idea behind Retrieval Augmented Generation is honestly pretty elegant. Rather than trying to shove all your knowledge into model weights (expensive, slow, inflexible), you just retrieve the relevant pieces at query time and hand them to the model as context. Three steps, and you're done:

Break your documents into chunks, embed them, store in a ChromaDB vector database
When someone asks something, run a semantic similarity search to pull the relevant chunks
Feed those chunks to your LLM as context — it answers from your actual data, not from training memory

RAG Pipeline:

📄 Your Docs → ✂️ Chunking → 🧮 Embeddings → 🗄️ ChromaDB → 🤖 LLM Answer

How to Build AI Chatbot using LangChain — Architecture

Before writing code, here are the 4 components you need to understand:

Component	What it does
🔀 Document Loader	Ingests PDFs, Word docs, web pages. LangChain has 100+ loaders built-in
✂️ Text Splitter	Breaks docs into overlapping chunks — overlap stops answers being cut mid-thought
🧮 Embedding Model	Converts text to vectors. We use OpenAI text-embedding-3-small — cheap and good
🗄️ Vector Store	ChromaDB locally, Pinecone for production. Switching takes 3 lines

Environment Setup — LangChain RAG Python Installation

Python 3.10 or higher. Use a virtual environment — mixing global packages is how you end up spending an afternoon debugging import errors that have nothing to do with your actual RAG code.

# Create virtual environment
python -m venv rag-env
source rag-env/bin/activate  # Windows: rag-env\Scripts\activate

# Install all dependencies for RAG LangChain ChromaDB
pip install langchain langchain-community langchain-openai
pip install chromadb openai tiktoken pypdf
pip install python-dotenv streamlit

RAG Document Loader — Load and Split Documents with LangChain

# document_processor.py
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter

def load_and_split(file_path: str) -> list:
    loader = PyPDFLoader(file_path)
    documents = loader.load()

    splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000,
        chunk_overlap=200,
        separators=["\n\n", "\n", " ", ""]
    )
    chunks = splitter.split_documents(documents)
    print(f"✅ {len(documents)} pages → {len(chunks)} chunks")
    return chunks

The chunk_size and chunk_overlap parameters here are things I've tweaked across multiple projects. 1000 characters per chunk works well for most documents. The 200-character overlap? That's the bit most tutorials skip. Without it, you'll occasionally get answers that feel cut off because the relevant sentence happened to fall right at a chunk boundary.

ChromaDB Vector Database Explained — Build Your Vector Store

ChromaDB is what makes this whole setup so easy to get running locally. It's just a folder on your disk — no Docker, no cloud account, no sign-up. You embed your chunks, it saves them, and later you query by meaning instead of keyword matching. That last part is what makes vector search feel almost magical the first time you try it.

# vectorstore.py
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma

def create_vectorstore(chunks, persist_dir="./chroma_db"):
    embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
    vectorstore = Chroma.from_documents(
        documents=chunks,
        embedding=embeddings,
        persist_directory=persist_dir
    )
    return vectorstore

def load_vectorstore(persist_dir="./chroma_db"):
    embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
    return Chroma(persist_directory=persist_dir, embedding_function=embeddings)

Build AI Chatbot with RAG — The Core Chain Logic

# rag_chain.py
from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate

PROMPT_TEMPLATE = """Use ONLY the context below to answer.
If not in context, say "I don't have enough information."

Context: {context}
Question: {question}
Answer:"""

def build_rag_chain(vectorstore):
    llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
    chain = RetrievalQA.from_chain_type(
        llm=llm,
        chain_type="stuff",
        retriever=vectorstore.as_retriever(search_kwargs={"k": 4}),
        chain_type_kwargs={"prompt": PromptTemplate.from_template(PROMPT_TEMPLATE)},
        return_source_documents=True
    )
    return chain

⚠️ Keep temperature=0. I know it's tempting to bump it up for more "creative" responses — don't. The whole point of RAG is factual grounding. A temperature above 0 lets the model start improvising around your retrieved context, which brings hallucinations right back in through the side door.

Streamlit Chat Interface — Run Your RAG AI Chatbot

# app.py
import streamlit as st
from vectorstore import load_vectorstore
from rag_chain import build_rag_chain

st.title("📄 RAG AI Chatbot — Document Aware")

@st.cache_resource
def load_chain():
    return build_rag_chain(load_vectorstore("./chroma_db"))

chain = load_chain()

if "messages" not in st.session_state:
    st.session_state.messages = []

for msg in st.session_state.messages:
    with st.chat_message(msg["role"]):
        st.write(msg["content"])

if prompt := st.chat_input("Ask anything about your document..."):
    result = chain({"query": prompt})
    answer = result["result"]
    with st.chat_message("assistant"):
        st.write(answer)
    st.session_state.messages.append({"role": "assistant", "content": answer})

Run it:

streamlit run app.py

ChromaDB vs Pinecone vs Weaviate — Which Vector Database to Choose?

Quick honest answer: start with ChromaDB, switch to Pinecone when you ship. I've used all three — ChromaDB is unbeatable for local development because there's literally nothing to set up. Pinecone is where you go when you have real users and need reliability and scale. Weaviate is worth looking at if you need hybrid search.

Feature	ChromaDB	Pinecone	Weaviate
Setup	pip install · local	Managed cloud	Docker / Cloud
Cost	Free	Paid after free tier	Open source
Scale	Millions of docs	Billions of vectors	Enterprise scale
Best For	Dev · Prototyping	Production SaaS	Hybrid search

Retrieval Augmented Generation Example — RAG vs Naive LLM

	✗ Naive LLM	✓ RAG System
Data source	Training data only	Your actual documents
Hallucinations	Confident and frequent	Grounded in retrieved context
Knowledge	Frozen at cutoff	Update docs anytime
Attribution	None	Cites exact source + page

GitHub Repository

All code from this tutorial is on GitHub:

👉 ragavi-s/rag-langchain-chromadb

rag-langchain-chromadb/
├── docs/                   # Put your PDFs here
├── chroma_db/              # Auto-generated vector store
├── document_processor.py   # Step 4 — Load & split
├── vectorstore.py          # Step 5 — ChromaDB logic
├── rag_chain.py            # Step 6 — RAG chain
├── app.py                  # Step 7 — Streamlit UI
├── requirements.txt
└── README.md

Recommended Tools for Production RAG

🌲 Pinecone — What I'd use when this goes to production. Fully managed, scales without you touching anything.
🔷 Weaviate — Open-source vector DB with hybrid search. Self-hostable, solid docs.
🦜 LangChain Cloud — LangSmith is genuinely useful once you start debugging why your retrieval is returning wrong chunks.

Before You Close This Tab

What is RAG — Stop thinking of it as a fancy feature. It's just: retrieve relevant chunks, hand them to the LLM, get an answer grounded in your data.

Core Stack — LangChain (orchestration) + ChromaDB (vectors) + OpenAI (embeddings + generation). Each piece is replaceable.

Dev → Prod — Build with ChromaDB locally. Swap to Pinecone when you ship. Seriously, it's 3 lines.

Don't Skip This — temperature=0, chunk_overlap=200, k=4 chunks retrieved. These defaults took me a while to land on — trust them until you have a reason to change them.

What's Next — Once this works, look into re-ranking and hybrid search (BM25 + vector) if your documents have lots of proper nouns or codes that semantic search struggles with.

Independent tech writer based in India. I write about AI, Python, and developer tools — mostly things I've actually built and broken myself before writing about them. Founder of Tech Journalism. No sponsored opinions, no hype, just code that works.

If this saved you time — drop a GitHub link in the comments. Always curious to see how people extend it.

How to Learn Python in 2026: Complete Beginner Roadmap (Zero to Job-Ready in 4 Weeks)

Ragavi S — Thu, 05 Feb 2026 11:53:34 +0000

Every few months someone asks me what language they should learn first. My answer has been the same for two years now — Python. Not because it's perfect, but because it's the one language where you can go from "I've never written a line of code" to "I built something real" faster than anything else out there.

This is the roadmap I'd hand someone starting today. Four weeks. No paid courses. No bootcamp. Just you, a laptop, and consistent daily practice.

Why Python specifically?

The honest answer is that Python is everywhere in 2026 in a way that's hard to overstate. AI and ML are almost entirely built on it. Backend web development, data analysis, automation — Python shows up in all of it. When companies need someone to glue systems together or build something quickly, Python is what they reach for.

The other reason beginners do well with it is the syntax. It reads close to plain English, which means you spend less time fighting the language and more time actually learning to think like a programmer. Compare a basic conditional in Python versus Java and you'll see what I mean immediately.

From a career standpoint, entry-level Python roles have grown significantly. Salaries range from around $55K for data analyst positions up to $100K+ for ML engineer roles, depending on specialisation. More importantly, the skill compounds — once you're solid in Python, picking up frameworks like Django, FastAPI, or LangChain is much faster.

What you actually need to start

A computer. An internet connection. VS Code, which is free. That's genuinely it.

You don't need a math background. You don't need a CS degree — a large percentage of working Python developers are self-taught. You don't need an expensive course. The free resources available in 2026 are better than what people were paying for five years ago.

The one thing you do need is consistency. Thirty minutes a day beats a four-hour session on weekends. The brain retains programming concepts better with daily repetition.

Setting up your environment

Step 1 — Install Python

Go to python.org/downloads and download Python 3.12. When the installer runs, there's one checkbox you must not miss: "Add Python to PATH". If you skip it, Python won't be accessible from your terminal and you'll spend an hour confused. Check it, install, done.

Verify it worked by opening your terminal and running:

python --version

You should see Python 3.12.x. If you do, you're good to go.

Step 2 — Install VS Code

Download from code.visualstudio.com. After installing, open it, go to the Extensions panel on the left sidebar, search for "Python", and install the official Microsoft extension. This gives you syntax highlighting, autocomplete, and the ability to run files directly from the editor.

Step 3 — Your first program

Create a new file, save it as hello.py, and write:

print("Hello, Python!")

Run it with the play button. That's it. You're a programmer now.

Week 1 and 2 — The fundamentals

These are the concepts that form the foundation of everything else. Don't rush past them.

Variables and data types

name = "Ragavi"      # String — text
age = 25             # Integer — whole number
height = 5.6         # Float — decimal
is_student = True    # Boolean — True or False

print(f"{name} is {age} years old")

Conditionals

age = 18

if age >= 18:
    print("You can vote")
else:
    print("Not yet")

One thing that catches beginners: Python uses indentation to define code blocks. Four spaces. This isn't optional — get it wrong and your code breaks.

Loops

for i in range(5):
    print(f"Number: {i}")

count = 5
while count > 0:
    print(f"Countdown: {count}")
    count -= 1

Lists

fruits = ["apple", "banana", "orange"]

print(fruits[0])        # apple
print(fruits[-1])       # orange — negative index counts from the end
fruits.append("mango")
print(len(fruits))      # 4

Functions

Once you understand the basics, functions are how you stop repeating yourself:

def greet(name):
    print(f"Hello, {name}!")

greet("Ragavi")
greet("Alex")

def add(a, b):
    return a + b

result = add(10, 5)
print(result)  # 15

Week 3 — Build actual projects

Reading about programming and writing programs are completely different things. The only way concepts stick is by building something. Here are four projects that cover the fundamentals without being trivial.

Project 1: Calculator

def calculator():
    num1 = float(input("First number: "))
    op = input("Operation (+, -, *, /): ")
    num2 = float(input("Second number: "))

    if op == "+":
        print(f"Result: {num1 + num2}")
    elif op == "-":
        print(f"Result: {num1 - num2}")
    elif op == "*":
        print(f"Result: {num1 * num2}")
    elif op == "/":
        if num2 != 0:
            print(f"Result: {num1 / num2}")
        else:
            print("Can't divide by zero")

calculator()

Project 2: To-do list

tasks = []

def add_task():
    task = input("Task: ")
    tasks.append({"title": task, "done": False})
    print(f"Added: {task}")

def view_tasks():
    if not tasks:
        print("No tasks yet")
        return
    for i, task in enumerate(tasks, 1):
        status = "done" if task["done"] else "pending"
        print(f"{i}. [{status}] {task['title']}")

def main():
    while True:
        print("\n1. View  2. Add  3. Exit")
        choice = input("Choose: ")
        if choice == "1":
            view_tasks()
        elif choice == "2":
            add_task()
        elif choice == "3":
            break

main()

Project 3: Number guessing game

import random

secret = random.randint(1, 100)
attempts = 0

print("Guess a number between 1 and 100")

while True:
    guess = int(input("Your guess: "))
    attempts += 1

    if guess == secret:
        print(f"Correct! You got it in {attempts} tries")
        break
    elif guess < secret:
        print("Too low")
    else:
        print("Too high")

Project 4: Quiz game

quiz = [
    {"q": "Capital of France?", "a": "Paris"},
    {"q": "What is 2 + 2?", "a": "4"},
    {"q": "Who created Python?", "a": "Guido van Rossum"}
]

score = 0

for item in quiz:
    answer = input(item["q"] + " ")
    if answer.lower() == item["a"].lower():
        print("Correct")
        score += 1
    else:
        print(f"Wrong. Answer: {item['a']}")

print(f"\nScore: {score}/{len(quiz)}")

Week 3-4 — Error handling and useful modules

Real programs break. Learning to handle errors gracefully is what separates beginner code from code you can actually ship.

try:
    age = int(input("Enter your age: "))
    print(f"You are {age} years old")
except ValueError:
    print("That's not a valid number")

A few standard library modules worth knowing early:

# File handling
with open("notes.txt", "w") as f:
    f.write("Hello from Python")

with open("notes.txt", "r") as f:
    print(f.read())

# Random
import random
print(random.randint(1, 6))
print(random.choice(["red", "blue", "green"]))

# DateTime
from datetime import datetime
now = datetime.now()
print(f"Today: {now.strftime('%B %d, %Y')}")

Week 4 — Libraries and portfolio

In the final week, start touching the ecosystem that makes Python powerful for real work.

NumPy — array operations, the foundation of data science
Pandas — working with tabular data and CSVs
Requests — making API calls, pulling data from the web

More importantly: set up GitHub and push everything you've built. Employers look at GitHub. Two or three working projects, even simple ones, are worth more than a certificate from any course.

The learning roadmap at a glance

Week	Focus	What you build
1	Variables, conditionals, loops, lists	Calculator, grade checker
2	Functions, dictionaries, string methods	Contact book, text analyzer
3	Error handling, file I/O, projects	To-do list, quiz game
4	NumPy, Pandas, APIs, GitHub	Weather app, portfolio

Resources worth your time

For learning: Real Python is the best written resource. For video, Corey Schafer's Python series on YouTube is thorough and clear. For practice, HackerRank has good Python challenges that start easy and scale up.

Don't buy a course until you've exhausted the free material. You probably never will.

Mistakes that slow people down

Tutorial hell is the big one — watching video after video without actually writing code. You can watch someone swim all day and still drown the first time you get in the water. Close the tutorial and build something.

Not reading error messages is the other common one. That red text in your terminal is telling you exactly what went wrong and on which line. Read it before you Google anything.

Trying to learn everything before building is how people quit. Learn what you need for the next thing you're building. The rest follows naturally.

Where to go after 4 weeks

Once you've finished this roadmap, pick a direction:

Web development — Learn Django or FastAPI
Data science — Go deeper into Pandas, then pick up Scikit-learn
AI/ML — Start with the OpenAI API, then look into LangChain and RAG systems
Automation — Learn Selenium, write scripts that save you time

The fundamentals you've built carry you into all of these. Python is a good first language precisely because the second thing is always easier.

Written by Ragavi S — tech writer and founder of Tech Journalism. Questions or feedback? Leave a comment below.