Pandas RAG: 5 Fun Starter Projects

Tiny, practical Retrieval-Augmented Generation projects that teach you the core moves — chunking, search, and answering — without heavy tooling.

Learn 5 beginner RAG projects with Pandas: CSV FAQ bot, PDF notes helper, support email triage, product search explainer, and receipts Q&A. Minimal code, real results.

You don’t need a vector database or a 20-service stack to try RAG. With Pandas, a simple search method, and a small model, you can build useful assistants in an afternoon. Let’s be real: the fastest way to learn RAG is to ship tiny projects you can actually use.

Setup (one time): pip install pandas scikit-learn sentence-transformers python-docx pypdf2

1) CSV FAQ Bot (TF-IDF, zero embeddings)

Great first win: answer questions from a simple FAQ sheet.

import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

faq = pd.read_csv("faq.csv")  # columns: question, answer
corpus = faq["question"].fillna("").tolist()

vec = TfidfVectorizer(ngram_range=(1,2), min_df=1).fit(corpus)
X = vec.transform(corpus)

def ask(q: str, k=3):
    qv = vec.transform([q])
    sims = cosine_similarity(qv, X).ravel()
    top = faq.iloc[sims.argsort()[::-1][:k]]
    context = "\n".join(f"Q: {r.question}\nA: {r.answer}" for _, r in top.iterrows())
    return f"Best answer:\n{top.iloc[0].answer}\n\nSources:\n{context}"

print(ask("How do I reset my password?"))

Why it works: TF-IDF + cosine similarity is fast, explainable, and perfect for small CSVs.

2) Class Notes Q&A (PDF to chunks with embeddings)

Turn lecture PDFs into a study buddy.

import pandas as pd, textwrap, numpy as np
from PyPDF2 import PdfReader
from sentence_transformers import SentenceTransformer, util

# 1) Extract + chunk
txt = "\n".join(page.extract_text() or "" for page in PdfReader("notes.pdf").pages)
chunks = [txt[i:i+800] for i in range(0, len(txt), 800)]
df = pd.DataFrame({"chunk": chunks})

# 2) Embed
model = SentenceTransformer("all-MiniLM-L6-v2")
emb = model.encode(df["chunk"].tolist(), normalize_embeddings=True)
df["emb"] = list(emb)

# 3) Retrieve + answer (toy answer: top passage)
def ask(q, k=4):
    qv = model.encode(q, normalize_embeddings=True)
    sims = util.cos_sim(qv, np.vstack(df["emb"])).ravel().numpy()
    idx = sims.argsort()[-k:][::-1]
    ctx = "\n---\n".join(df.iloc[i].chunk for i in idx)
    return f"Context:\n{textwrap.shorten(ctx, 1000)}\n\nDraft answer:\n{df.iloc[idx[0]].chunk[:300]}..."

print(ask("Explain gradient descent intuition."))

Beginner tip: Start by returning the best chunk. Later, add an LLM call that uses ctx as retrieval context.

3) Support Email Triage (tagging with Pandas rules + retrieval)

Mix vector search with a couple of crisp heuristics.

import pandas as pd, numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

kb = pd.read_csv("knowledge_base.csv")  # columns: title, text
vec = TfidfVectorizer().fit(kb["text"])
kbX = vec.transform(kb["text"])

def classify(email_text):
    # quick rule catches
    if "refund" in email_text.lower():
        rule = "billing"
    elif "password" in email_text.lower():
        rule = "auth"
    else:
        rule = "general"
    # retrieve closest article
    sims = cosine_similarity(vec.transform([email_text]), kbX).ravel()
    i = sims.argmax()
    return {"tag": rule, "suggested_article": kb.iloc[i].title}

print(classify("I was double charged for last month."))

Why it’s fun: you’ll see immediate utility — tags plus a suggested reply article.

4) Product Search Explainer (RAG over catalog)

Answer “Which model fits under ₹50k with 16GB RAM?” from your product CSV.

import pandas as pd, re

products = pd.read_csv("catalog.csv")  # name, price, ram_gb, gpu, desc

def parse(q):
    budget = re.search(r"(\d{2,})k", q)
    ram = re.search(r"(\d{2})\s*gb", q, re.I)
    return {
        "budget": int(budget.group(1))*1000 if budget else None,
        "ram": int(ram.group(1)) if ram else None,
        "gpu": ("rtx" in q.lower())
    }

def search(q):
    p = parse(q)
    df = products.copy()
    if p["budget"]: df = df[df.price <= p["budget"]]
    if p["ram"]: df = df[df.ram_gb >= p["ram"]]
    if p["gpu"]: df = df[df.desc.str.contains("rtx", case=False, na=False)]
    return df.sort_values(["price","ram_gb"]).head(5)[["name","price","ram_gb"]]

print(search("Best laptops under 50k with 16GB and RTX?"))

RAG twist: append the top 5 rows as context to your answer message.

5) Receipts Q&A (CSV → semantic lookup)

Let a simple RAG bot surface past purchases by meaning, not exact words.

import pandas as pd, numpy as np
from sentence_transformers import SentenceTransformer, util

tx = pd.read_csv("receipts.csv")  # date, merchant, category, memo, amount
tx["text"] = tx[["merchant","category","memo"]].fillna("").agg(" ".join, axis=1)

model = SentenceTransformer("all-MiniLM-L6-v2")
emb = model.encode(tx["text"].tolist(), normalize_embeddings=True)

def find(q, k=5):
    qv = model.encode(q, normalize_embeddings=True)
    sims = util.cos_sim(qv, emb).ravel().numpy()
    return tx.iloc[sims.argsort()[-k:][::-1]][["date","merchant","category","amount","memo"]]

print(find("team lunch pizza last month"))

Why it clicks: you’ll retrieve “pizza” even if the memo said “Dominos XL slice (team).”

What you just learned (and can reuse everywhere)

• Chunking & cleaning: split long text and keep it in a Pandas column.
• Two retrieval modes: TF-IDF for small corpora; embeddings for fuzzier matches.
• Context first, generation second: return a chunk before you call any model.
• Keep artifacts small: store CSVs/Parquet and precomputed embeddings side-by-side.

Conclusion

RAG isn’t a monolith. It’s a pattern: retrieve the right text, then answer. With Pandas as your data glue, you can build tiny assistants that genuinely help — no servers, no drama. Pick one project above, drop in your own files, and share what you ship.