Build Your Own AI Chatbot — Python RAG System From Scratch to Deployment [2026 Tutorial]

[User Question]
      ↓
[Document Retrieval] ← Find semantically similar passages from your documents
      ↓
[Retrieved Passages + Question sent to LLM]
      ↓
[LLM answers accurately, grounded in the provided documents]

📄 PDF Upload
      ↓
[Document Chunking] → Split long documents into small passages
      ↓
[Embedding] → Convert each passage into a numerical vector
      ↓
[Vector DB Storage] → ChromaDB (local, free)
      ↓
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📨 User Submits a Question
      ↓
[Question Embedding] → Convert the question into a vector too
      ↓
[Similarity Search] → Find the 3–5 most relevant passages in the DB
      ↓
[LLM Call] → "Answer this question using only the provided passages"
      ↓
✅ Accurate Answer Returned

pip install langchain langchain-anthropic langchain-community \
            chromadb fastapi uvicorn python-dotenv \
            pymupdf sentence-transformers

my-rag-chatbot/
├── .env                  # API keys (never commit this!)
├── main.py               # FastAPI server
├── rag_pipeline.py       # RAG logic
├── uploads/              # PDF upload folder (auto-created)
└── vector_store/         # ChromaDB storage (auto-created)

ANTHROPIC_API_KEY=your-api-key-here

# rag_pipeline.py
from langchain_community.document_loaders import PyMuPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
def load_and_split_pdf(file_path: str):
    """
    Load a PDF and split it into chunks.
    Chunks too large overflow the LLM context window;
    chunks too small lose their context. 500 chars is a good starting point.
    """
    # 1. Load PDF
    loader = PyMuPDFLoader(file_path)
    documents = loader.load()
    # 2. Split text
    splitter = RecursiveCharacterTextSplitter(
        chunk_size=500,       # Max 500 chars per chunk
        chunk_overlap=50,     # 50-char overlap between chunks (context preservation)
        length_function=len,
    )
    chunks = splitter.split_documents(documents)
    print(f"✅ {len(documents)} pages → split into {len(chunks)} chunks")
    return chunks

# rag_pipeline.py (continued)
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import HuggingFaceEmbeddings
# Embedding model init (free, runs locally)
# First run downloads the model (~90MB)
embedding_model = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-MiniLM-L6-v2"
)
VECTOR_STORE_PATH = "./vector_store"
def save_to_vector_db(chunks, collection_name: str = "my_docs"):
    """
    Convert chunks to vectors and save to ChromaDB.
    Same collection_name appends to existing data.
    """
    vector_db = Chroma.from_documents(
        documents=chunks,
        embedding=embedding_model,
        persist_directory=VECTOR_STORE_PATH,
        collection_name=collection_name,
    )
    vector_db.persist()
    print(f"✅ {len(chunks)} chunks saved to vector DB")
    return vector_db
def load_vector_db(collection_name: str = "my_docs"):
    """Load an existing vector DB."""
    return Chroma(
        persist_directory=VECTOR_STORE_PATH,
        embedding_function=embedding_model,
        collection_name=collection_name,
    )

# rag_pipeline.py (continued)
from langchain_anthropic import ChatAnthropic
from langchain.prompts import ChatPromptTemplate
from langchain.schema.runnable import RunnablePassthrough
from langchain.schema.output_parser import StrOutputParser
import os
def create_rag_chain(vector_db):
    """
    Assemble the RAG pipeline.
    Question → retrieve docs → LLM answer, wired as a single chain.
    """
    # 1. Retriever: fetch top 4 similar chunks
    retriever = vector_db.as_retriever(
        search_type="similarity",
        search_kwargs={"k": 4}
    )
    # 2. Prompt template
    prompt = ChatPromptTemplate.from_template("""
You are an AI assistant that answers questions strictly based on the provided documents.
[Reference Documents]
{context}
[Question]
{question}
Answer based only on the documents above.
If the answer cannot be found in the documents, say: "I couldn't find that information in the provided documents."
Do not make anything up.
""")
    # 3. LLM config
    llm = ChatAnthropic(
        model="claude-sonnet-4-20250514",
        api_key=os.getenv("ANTHROPIC_API_KEY"),
        temperature=0,  # 0 = most consistent, minimizes hallucination
        max_tokens=1024
    )
    # 4. Assemble the chain (LangChain Expression Language)
    def format_docs(docs):
        return "\n\n---\n\n".join(
            f"[Source: {doc.metadata.get('source', 'Unknown')}, "
            f"Page: {doc.metadata.get('page', '?')}]\n{doc.page_content}"
            for doc in docs
        )
    rag_chain = (
        {"context": retriever | format_docs, "question": RunnablePassthrough()}
        | prompt
        | llm
        | StrOutputParser()
    )
    return rag_chain
def ask_question(question: str, collection_name: str = "my_docs") -> dict:
    """
    Accept a question, run it through the RAG pipeline, return the answer.
    """
    vector_db = load_vector_db(collection_name)
    chain = create_rag_chain(vector_db)
    # Also return the source docs for citation
    retriever = vector_db.as_retriever(search_kwargs={"k": 4})
    source_docs = retriever.invoke(question)
    answer = chain.invoke(question)
    return {
        "answer": answer,
        "sources": [
            {
                "page": doc.metadata.get("page", "?"),
                "source": doc.metadata.get("source", "Unknown"),
                "snippet": doc.page_content[:200] + "..."
            }
            for doc in source_docs
        ]
    }

# main.py
from fastapi import FastAPI, UploadFile, File, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from pathlib import Path
import shutil
import os
from dotenv import load_dotenv
from rag_pipeline import load_and_split_pdf, save_to_vector_db, ask_question
load_dotenv()
app = FastAPI(
    title="My RAG Chatbot API",
    description="Upload a PDF and ask questions about its content",
    version="1.0.0"
)
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_methods=["*"],
    allow_headers=["*"],
)
UPLOAD_DIR = Path("./uploads")
UPLOAD_DIR.mkdir(exist_ok=True)
# ── Request / Response Models ──────────────────────
class QuestionRequest(BaseModel):
    question: str
    collection_name: str = "my_docs"
class QuestionResponse(BaseModel):
    answer: str
    sources: list
# ── Endpoints ──────────────────────────────────────
@app.get("/")
async def root():
    return {"message": "RAG Chatbot API is running 🚀"}
@app.post("/upload")
async def upload_pdf(
    file: UploadFile = File(...),
    collection_name: str = "my_docs"
):
    """Upload a PDF and store it in the vector DB."""
    if not file.filename.endswith(".pdf"):
        raise HTTPException(status_code=400, detail="Only PDF files are accepted.")
    file_path = UPLOAD_DIR / file.filename
    with open(file_path, "wb") as f:
        shutil.copyfileobj(file.file, f)
    try:
        chunks = load_and_split_pdf(str(file_path))
        save_to_vector_db(chunks, collection_name)
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Processing error: {str(e)}")
    return {
        "message": f"✅ '{file.filename}' uploaded successfully",
        "chunks_created": len(chunks),
        "collection": collection_name
    }
@app.post("/ask", response_model=QuestionResponse)
async def ask(request: QuestionRequest):
    """Answer a question based on the uploaded documents."""
    if not request.question.strip():
        raise HTTPException(status_code=400, detail="Please enter a question.")
    try:
        result = ask_question(request.question, request.collection_name)
        return QuestionResponse(
            answer=result["answer"],
            sources=result["sources"]
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Answer generation error: {str(e)}")
@app.delete("/collection/{collection_name}")
async def delete_collection(collection_name: str):
    """Delete a document collection."""
    import shutil
    store_path = f"./vector_store/{collection_name}"
    if os.path.exists(store_path):
        shutil.rmtree(store_path)
        return {"message": f"'{collection_name}' collection deleted"}
    raise HTTPException(status_code=404, detail="Collection not found.")

uvicorn main:app --reload --port 8000

# 1. Upload a PDF
curl -X POST "http://localhost:8000/upload" \
  -F "file=@./my_document.pdf" \
  -F "collection_name=my_docs"
# Sample response:
# {"message": "✅ 'my_document.pdf' uploaded successfully", "chunks_created": 47, "collection": "my_docs"}
# 2. Ask a question
curl -X POST "http://localhost:8000/ask" \
  -H "Content-Type: application/json" \
  -d '{"question": "What are the main points of this document?", "collection_name": "my_docs"}'

import requests
BASE_URL = "http://localhost:8000"
# Upload PDF
with open("my_document.pdf", "rb") as f:
    response = requests.post(
        f"{BASE_URL}/upload",
        files={"file": f},
        data={"collection_name": "test"}
    )
print(response.json())
# Ask a question
response = requests.post(
    f"{BASE_URL}/ask",
    json={"question": "What is the main conclusion?", "collection_name": "test"}
)
result = response.json()
print("Answer:", result["answer"])
print("\nSources:")
for src in result["sources"]:
    print(f"  - Page {src['page']}: {src['snippet'][:80]}...")

langchain==0.3.19
langchain-anthropic
langchain-community
chromadb
fastapi
uvicorn
python-dotenv
pymupdf
sentence-transformers

web: uvicorn main:app --host 0.0.0.0 --port $PORT

.env
uploads/
vector_store/
__pycache__/
*.pyc

# 1. Initialize Git and push to GitHub
git init
git add .
git commit -m "Initial RAG chatbot deployment"
git remote add origin https://github.com/your-username/my-rag-chatbot.git
git push -u origin main
# 2. Go to railway.app → "New Project" → "Deploy from GitHub"
# 3. Select your repository
# 4. Settings → Environment Variables → Add ANTHROPIC_API_KEY
# 5. Auto-deploy complete — access your live URL

# Multi-turn conversation with memory
from langchain.memory import ConversationBufferWindowMemory
memory = ConversationBufferWindowMemory(
    k=5,                        # Remember last 5 turns
    return_messages=True,
    memory_key="chat_history"
)