Zero to Job-Ready RAG
Engineer in 5 Days

# Complete Document Loading + Chunking Example
from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
import tiktoken

# Step 1: Load a PDF
loader = PyPDFLoader("company_handbook.pdf")
raw_docs = loader.load()
print(f"Loaded {len(raw_docs)} pages")

# Step 2: Count tokens to understand document size
enc = tiktoken.encoding_for_model("gpt-4")
total_tokens = sum(len(enc.encode(doc.page_content)) for doc in raw_docs)
print(f"Total tokens: {total_tokens} (~${total_tokens/1000 * 0.005:.2f} if sent directly)")

# Step 3: Smart chunking — Recursive splits at natural boundaries
splitter = RecursiveCharacterTextSplitter(
    chunk_size=512,       # tokens per chunk (NOT characters)
    chunk_overlap=50,     # overlap to preserve context at boundaries
    length_function=lambda text: len(enc.encode(text)),
    separators=["\n\n", "\n", ". ", " ", ""]  # try these in order
)

chunks = splitter.split_documents(raw_docs)
print(f"Created {len(chunks)} chunks")
print(f"Sample chunk:\n{chunks[0].page_content[:200]}")
print(f"Chunk metadata: {chunks[0].metadata}")  # includes page number, source!

# Complete Embedding + ChromaDB Storage Pipeline
from langchain.embeddings import OpenAIEmbeddings
from langchain.embeddings import HuggingFaceEmbeddings  # free alternative
from langchain.vectorstores import Chroma
import os

# Option A: OpenAI embeddings (paid, high quality)
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
embed_model = OpenAIEmbeddings(model="text-embedding-3-small")
# Cost: $0.02 per million tokens — very cheap

# Option B: Free local embeddings (great for learning)
embed_model = HuggingFaceEmbeddings(
    model_name="all-MiniLM-L6-v2",  # 384 dimensions, fast
    model_kwargs={'device': 'cpu'}
)

# Step 4: Create vector store — embeds and stores all chunks
vectorstore = Chroma.from_documents(
    documents=chunks,           # your chunked documents
    embedding=embed_model,      # embedding model
    persist_directory="./chroma_db",  # save to disk
    collection_name="company_docs"
)

print(f"Stored {vectorstore._collection.count()} embeddings!")

# To reload later without re-embedding:
vectorstore = Chroma(
    persist_directory="./chroma_db",
    embedding_function=embed_model,
    collection_name="company_docs"
)

# Step 5: Retrieval — find relevant chunks for a query
retriever = vectorstore.as_retriever(
    search_type="similarity",   # or "mmr" for diverse results
    search_kwargs={"k": 4}       # retrieve top 4 chunks
)

query = "What is the parental leave policy?"
relevant_chunks = retriever.get_relevant_documents(query)
for i, chunk in enumerate(relevant_chunks):
    print(f"Chunk {i+1} (page {chunk.metadata.get('page', '?')}):")
    print(chunk.page_content[:200])
    print()

# Step 6: Build augmented prompt
def build_rag_prompt(query: str, chunks: list) -> str:
    context = "\n\n---\n\n".join([c.page_content for c in chunks])
    
    return f"""You are a helpful assistant that answers questions based ONLY on 
the provided context. If the answer is not in the context, say 
"I don't have that information in the provided documents."

CONTEXT:
{context}

QUESTION: {query}

ANSWER (based only on context above):"""

prompt = build_rag_prompt(query, relevant_chunks)
print(f"Total prompt tokens: ~{len(prompt.split()) * 4 // 3}")

# Step 7: Generate response with LLM
from openai import OpenAI
client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o-mini",   # cheapest GPT-4 class model
    messages=[{"role": "user", "content": prompt}],
    temperature=0,         # 0 = deterministic, grounded answers
    max_tokens=500
)

answer = response.choices[0].message.content
print(f"Answer: {answer}")

# LangChain handles the whole pipeline in a few lines
from langchain.chains import RetrievalQA
from langchain.chat_models import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",          # "stuff" all chunks into prompt
    retriever=retriever,
    return_source_documents=True   # get source chunks back
)

result = qa_chain.invoke({"query": "What is the refund policy?"})
print(f"Answer: {result['result']}")
print(f"Sources: {[d.metadata['source'] for d in result['source_documents']]}")

# OpenAI API — Everything You Need for RAG
from openai import OpenAI
import os

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

## 1. Generate embeddings (for indexing documents)
def embed_text(text: str) -> list[float]:
    response = client.embeddings.create(
        input=text,
        model="text-embedding-3-small"
    )
    return response.data[0].embedding  # list of 1536 floats

## 2. Batch embedding (more efficient)
def embed_batch(texts: list[str]) -> list[list[float]]:
    response = client.embeddings.create(
        input=texts,  # send up to 2048 texts at once
        model="text-embedding-3-small"
    )
    return [item.embedding for item in response.data]

## 3. Chat completion with full control
def generate_answer(system_prompt: str, user_query: str, context: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": f"Context:\n{context}\n\nQuestion: {user_query}"}
        ],
        temperature=0,
        max_tokens=800
    )
    return response.choices[0].message.content

## 4. Streaming response (better UX — shows answer as it generates)
def stream_answer(prompt: str):
    stream = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        stream=True
    )
    for chunk in stream:
        if chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end="", flush=True)

# LCEL: Modern LangChain RAG Chain
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma

# Setup
embed = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=embed)
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

# Prompt template
prompt = ChatPromptTemplate.from_template("""
You are an expert assistant. Answer based ONLY on the context below.
If unsure, say "I don't know based on the provided documents."

Context:
{context}

Question: {question}

Answer:
""")

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# Helper to format retrieved docs into a string
def format_docs(docs):
    return "\n\n---\n\n".join(doc.page_content for doc in docs)

# LCEL Chain — reads left to right like a pipeline
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

# Use it:
answer = rag_chain.invoke("What is the leave encashment policy?")
print(answer)

# Streaming (yields tokens as generated):
for token in rag_chain.stream("What is the leave encashment policy?"):
    print(token, end="", flush=True)

# rag_api/main.py — Production FastAPI RAG Backend
from fastapi import FastAPI, UploadFile, File, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
from contextlib import asynccontextmanager
import tempfile, os, asyncio

from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser

# === MODELS ===
class QueryRequest(BaseModel):
    question: str
    k: int = 4         # number of chunks to retrieve
    stream: bool = False  # streaming response?

class QueryResponse(BaseModel):
    answer: str
    sources: list[str]
    chunks_used: int

# === GLOBALS ===
vectorstore = None
embed_model = OpenAIEmbeddings(model="text-embedding-3-small")
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# === APP ===
app = FastAPI(
    title="RAG Document QA API",
    description="Upload documents and query them with AI",
    version="1.0.0"
)

@app.on_event("startup")
async def startup():
    global vectorstore
    # Load existing vector store if it exists
    if os.path.exists("./chroma_db"):
        vectorstore = Chroma(
            persist_directory="./chroma_db",
            embedding_function=embed_model
        )
        print(f"Loaded existing vector store")

@app.get("/health")
async def health():
    return {"status": "healthy", "docs_indexed": vectorstore._collection.count() if vectorstore else 0}

@app.post("/ingest")
async def ingest_document(file: UploadFile = File(...)):
    """Upload and index a PDF document"""
    global vectorstore
    
    if not file.filename.endswith('.pdf'):
        raise HTTPException(400, "Only PDF files supported")
    
    # Save uploaded file temporarily
    with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as tmp:
        tmp.write(await file.read())
        tmp_path = tmp.name
    
    try:
        loader = PyPDFLoader(tmp_path)
        docs = loader.load()
        
        splitter = RecursiveCharacterTextSplitter(chunk_size=512, chunk_overlap=50)
        chunks = splitter.split_documents(docs)
        
        # Add source filename to metadata
        for chunk in chunks:
            chunk.metadata["filename"] = file.filename
        
        vectorstore = Chroma.from_documents(
            chunks, embed_model, persist_directory="./chroma_db"
        ) if not vectorstore else vectorstore.add_documents(chunks)
        
        return {"message": f"Indexed {len(chunks)} chunks from {file.filename}", "chunks": len(chunks)}
    finally:
        os.unlink(tmp_path)

@app.post("/query", response_model=QueryResponse)
async def query_documents(req: QueryRequest):
    """Query the indexed documents"""
    if not vectorstore:
        raise HTTPException(404, "No documents indexed yet. Use /ingest first.")
    
    retriever = vectorstore.as_retriever(search_kwargs={"k": req.k})
    retrieved_docs = retriever.get_relevant_documents(req.question)
    
    prompt = ChatPromptTemplate.from_template("""Answer using ONLY the context. 
If not in context, say "I don't have that information."

Context: {context}
Question: {question}
Answer:""")
    
    chain = (
        {"context": lambda x: "\n\n".join(d.page_content for d in retrieved_docs),
         "question": lambda x: x}
        | prompt | llm | StrOutputParser()
    )
    
    answer = chain.invoke(req.question)
    sources = list({d.metadata.get("filename", "unknown") for d in retrieved_docs})
    
    return QueryResponse(answer=answer, sources=sources, chunks_used=len(retrieved_docs))

# app.py — Streamlit Chat UI for RAG
import streamlit as st
import requests

st.set_page_config(page_title="📚 Doc QA", layout="wide")
st.title("📚 AI Document Q&A")
st.caption("Upload a PDF and ask anything about it")

API_URL = "http://localhost:8000"

# Sidebar: document upload
with st.sidebar:
    st.header("📤 Upload Document")
    uploaded = st.file_uploader("Choose a PDF", type=["pdf"])
    if uploaded and st.button("Index Document"):
        with st.spinner("Indexing..."):
            resp = requests.post(f"{API_URL}/ingest", files={"file": uploaded})
            if resp.status_code == 200:
                st.success(resp.json()["message"])
            else:
                st.error("Failed to index")

# Chat interface with history
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 question := st.chat_input("Ask about your document..."):
    st.session_state.messages.append({"role": "user", "content": question})
    with st.chat_message("user"):
        st.write(question)
    
    with st.chat_message("assistant"):
        with st.spinner("Thinking..."):
            resp = requests.post(f"{API_URL}/query", json={"question": question})
            if resp.status_code == 200:
                data = resp.json()
                st.write(data["answer"])
                st.caption(f"📎 Sources: {', '.join(data['sources'])}")
                st.session_state.messages.append({"role": "assistant", "content": data["answer"]})

# Run: streamlit run app.py
# Backend: uvicorn rag_api.main:app --reload

# Hybrid Search with LangChain + BM25
from langchain.retrievers import BM25Retriever, EnsembleRetriever
from langchain_community.vectorstores import Chroma

# Assume chunks is your list of LangChain Documents

# BM25 (keyword-based)
bm25_retriever = BM25Retriever.from_documents(chunks)
bm25_retriever.k = 4

# Vector (semantic)
vector_retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

# Ensemble: 40% BM25, 60% semantic (tune these weights)
hybrid_retriever = EnsembleRetriever(
    retrievers=[bm25_retriever, vector_retriever],
    weights=[0.4, 0.6]
)

results = hybrid_retriever.get_relevant_documents("What is the API rate limit?")
# Better at finding "rate limit" (exact) AND "throttling/quota" (semantic)

# Re-ranking with Cohere Rerank (cloud) or cross-encoder (local)

## Option A: Cohere Rerank API (easy, high quality)
import cohere
co = cohere.Client(os.getenv("COHERE_API_KEY"))

def rerank_documents(query: str, docs: list, top_n: int = 4):
    texts = [d.page_content for d in docs]
    results = co.rerank(
        query=query,
        documents=texts,
        top_n=top_n,
        model="rerank-english-v3.0"
    )
    return [docs[r.index] for r in results.results]

## Option B: Local cross-encoder (free)
from sentence_transformers import CrossEncoder

reranker = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')

def rerank_local(query: str, docs: list, top_n: int = 4) -> list:
    pairs = [(query, doc.page_content) for doc in docs]
    scores = reranker.predict(pairs)
    # Sort by score descending, take top N
    ranked = sorted(zip(docs, scores), key=lambda x: x[1], reverse=True)
    return [doc for doc, score in ranked[:top_n]]

# Usage: retrieve 20, rerank to top 4
candidates = vectorstore.as_retriever(search_kwargs={"k": 20}).get_relevant_documents(query)
reranked = rerank_local(query, candidates, top_n=4)

# Multi-Query Retrieval — Most commonly used in production
from langchain.retrievers.multi_query import MultiQueryRetriever
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.3)  # slight creativity for variety

multi_query_retriever = MultiQueryRetriever.from_llm(
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3}),
    llm=llm
)
# For query "What's the leave policy?", generates:
# 1. "How many vacation days do employees get?"
# 2. "What are the sick leave rules?"
# 3. "How do I apply for time off?"
# Retrieves for all 3, deduplicates, returns union

# HyDE — Hypothetical Document Embeddings
hyde_prompt = ChatPromptTemplate.from_template("""
Write a short paragraph that would be a perfect answer to this question.
Write it as if it's from a document, not as a direct answer.

Question: {question}

Hypothetical document paragraph:""")

hyde_chain = hyde_prompt | llm | StrOutputParser()

def hyde_retrieve(question: str, retriever, k: int = 4):
    # Generate hypothetical answer, use it as query
    hypothetical_doc = hyde_chain.invoke({"question": question})
    return retriever.get_relevant_documents(hypothetical_doc)

# Metadata filtering: search only within specific documents/sections
# ChromaDB supports filtering during search

# When ingesting, add rich metadata:
for chunk in chunks:
    chunk.metadata.update({
        "department": "HR",
        "doc_type": "policy",
        "year": 2024,
        "filename": "hr_policy_2024.pdf"
    })

# Filter search to only HR department docs from 2024:
results = vectorstore.similarity_search(
    query="What is the leave policy?",
    k=4,
    filter={"department": "HR", "year": 2024}  # ChromaDB $and filter
)
# Only searches HR 2024 docs — much more precise, faster

# RAG Evaluation with RAGAS (the standard library)
from ragas import evaluate
from ragas.metrics import (
    faithfulness,        # answer grounded in context?
    answer_relevancy,   # answer relevant to question?
    context_recall,     # retrieved right context?
    context_precision   # retrieved only relevant context?
)
from datasets import Dataset

# Build test dataset: question, expected answer, retrieved context, generated answer
test_data = {
    "question": ["What is the parental leave policy?", "How do I apply for remote work?"],
    "answer": [generated_answer_1, generated_answer_2],
    "contexts": [[chunk.page_content for chunk in retrieved_1], 
               [chunk.page_content for chunk in retrieved_2]],
    "ground_truth": ["Employees get 26 weeks paid leave...", "Submit a remote work request form..."]
}

dataset = Dataset.from_dict(test_data)
results = evaluate(dataset, metrics=[faithfulness, answer_relevancy, context_recall])
print(results)
# Output:
# faithfulness: 0.92    ← 92% of answers grounded in context ✅
# answer_relevancy: 0.87 ← 87% answers actually address question ✅  
# context_recall: 0.79  ← missed some relevant chunks ⚠️ (tune chunk size)

# Conversational RAG with memory — the right way
from langchain.memory import ConversationBufferWindowMemory
from langchain.chains import ConversationalRetrievalChain

# Keep last 5 conversation turns in memory
memory = ConversationBufferWindowMemory(
    memory_key="chat_history",
    k=5,
    return_messages=True,
    output_key="answer"
)

conv_chain = ConversationalRetrievalChain.from_llm(
    llm=ChatOpenAI(model="gpt-4o-mini", temperature=0),
    retriever=hybrid_retriever,
    memory=memory,
    return_source_documents=True
)

# Turn 1
r1 = conv_chain.invoke({"question": "What is the parental leave policy?"})
print(r1["answer"])

# Turn 2 — system remembers we're talking about parental leave
r2 = conv_chain.invoke({"question": "Does it apply to adoption too?"})
print(r2["answer"])  # Correctly contextualizes "it" = parental leave

# LCEL approach with manual history (more control):
from langchain_core.messages import HumanMessage, AIMessage

chat_history = []

def chat_with_memory(question: str) -> str:
    # Condense question with history context
    condense_prompt = f"""Given the conversation history and new question, 
rephrase the question to be standalone.
History: {chat_history[-4:]}
Question: {question}
Standalone question:"""
    standalone = llm.invoke(condense_prompt).content
    
    # Retrieve and answer
    docs = retriever.get_relevant_documents(standalone)
    answer = rag_chain.invoke(standalone)
    
    # Update history
    chat_history.append(HumanMessage(content=question))
    chat_history.append(AIMessage(content=answer))
    
    return answer

rag-pdf-chatbot/
├── backend/
│   ├── main.py             # FastAPI app
│   ├── rag/
│   │   ├── __init__.py
│   │   ├── ingestion.py    # Document loading + chunking
│   │   ├── embeddings.py   # Embedding model wrapper
│   │   ├── retrieval.py    # Vector store + retrieval
│   │   ├── generation.py   # LLM + prompt building
│   │   └── evaluation.py   # RAGAS evaluation
│   ├── tests/
│   │   └── test_rag.py
│   ├── Dockerfile
│   └── requirements.txt
├── frontend/
│   └── streamlit_app.py
├── data/
│   └── sample_docs/
├── docker-compose.yml
├── .env.example           # Template for env vars (NO real keys)
├── .gitignore             # Include: chroma_db/, .env, __pycache__
└── README.md              # Architecture diagram + setup instructions

# Dockerfile
FROM python:3.11-slim

WORKDIR /app

# Install dependencies first (caching layer)
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY . .

# Create directory for ChromaDB persistence
RUN mkdir -p /app/chroma_db

EXPOSE 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

# docker-compose.yml
version: '3.8'
services:
  backend:
    build: ./backend
    ports: ["8000:8000"]
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - COHERE_API_KEY=${COHERE_API_KEY}
    volumes:
      - chroma_data:/app/chroma_db  # persist vector DB
  
  frontend:
    build: ./frontend
    ports: ["8501:8501"]
    depends_on: [backend]
    environment:
      - API_URL=http://backend:8000

volumes:
  chroma_data:

# Run: docker-compose up --build

# The most impressive feature: streaming RAG with sources
from fastapi.responses import StreamingResponse
import json

@app.post("/chat")
async def chat_stream(req: ChatRequest):
    """Stream RAG response with sources"""
    
    # Retrieve with hybrid search
    docs = hybrid_retriever.get_relevant_documents(req.question)
    docs = rerank_local(req.question, docs, top_n=4)
    
    context = "\n\n---\n\n".join(d.page_content for d in docs)
    sources = list({d.metadata.get("filename") for d in docs})
    
    prompt = build_prompt(req.question, context, req.chat_history)
    
    async def generate():
        # First yield: sources (so UI can show them immediately)
        yield f"data: {json.dumps({'type': 'sources', 'data': sources})}\n\n"
        
        # Stream LLM tokens
        stream = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": prompt}],
            stream=True
        )
        for chunk in stream:
            token = chunk.choices[0].delta.content or ""
            if token:
                yield f"data: {json.dumps({'type': 'token', 'data': token})}\n\n"
        
        yield f"data: {json.dumps({'type': 'done'})}\n\n"
    
    return StreamingResponse(generate(), media_type="text/event-stream")

AI PDF Research Assistant | Python, FastAPI, LangChain, ChromaDB, OpenAI
github.com/yourname/ai-pdf-chatbot  |  live: railway.app/project/...

• Built a production-ready RAG system enabling conversational Q&A over
  multiple PDF documents with <2s response latency
• Implemented hybrid search (BM25 + semantic vectors) with cross-encoder
  re-ranking, improving retrieval accuracy by ~30% vs naive vector search
• Designed streaming FastAPI backend with conversation memory supporting
  multi-turn queries with source citations
• Deployed containerized application (Docker + docker-compose) serving
  both FastAPI and Streamlit frontend
• Integrated RAGAS evaluation framework; achieved faithfulness score 0.89
  and context recall 0.83 on test dataset

Skills demonstrated: RAG architecture, LLM engineering, FastAPI, vector
databases, embeddings, hybrid search, Docker, prompt engineering

AI / LLM Engineering:  RAG systems, LangChain, OpenAI API (Chat + Embeddings),
                      Prompt engineering, ChromaDB, FAISS, Semantic search,
                      Hybrid search, Re-ranking, RAGAS evaluation

Backend:  FastAPI, Python, REST APIs, async programming, Docker

Databases:  ChromaDB (vector), PostgreSQL, MongoDB, pgvector