Guides · Generative AI

How to Build a RAG Chatbot from a PDF: No-Code and Python Ways (Step by Step)

By Ravindra Bagale, trainer · LinkedIn · Published: 19 October 2026 · Last updated: 19 October 2026 · 12 min read

A RAG chatbot (Retrieval-Augmented Generation) answers questions from your document instead of from the AI's memory. It works in 5 steps: load the PDF, cut it into small chunks, index the chunks, retrieve the chunks that match the question, and let the AI generate an answer using only those chunks. The no-code way is Gemini Notebook (the new name of NotebookLM). The coding way is a 60-line Python script with pypdf, scikit-learn and the Gemini API, given below.

1. Suppose we work in HR at an IT company in Pune

Suppose we are Sneha, an HR executive at a mid-size IT company in Hinjewadi, Pune. Every week, 50 employees ask the same questions on Teams: "How many casual leaves do I get?", "Can I carry forward earned leave?", "How many days of work from home are allowed?"

All the answers are in one PDF: the leave policy. We want a chatbot that:

1. Answers only from this PDF.
2. Says which page the answer came from.
3. Says "I could not find this" when the PDF does not have the answer, instead of guessing.

That is exactly what a RAG chatbot does.

For this guide we use a small 2-page sample policy for a made-up company, "Sahyadri Infotech". It says, for example: 12 days of casual leave, 8 days of sick leave (a doctor's certificate for more than 2 days in a row), 18 days of earned leave after 6 months, and work from home up to 2 days a week.

2. What is RAG, in simple words?

Think of an open-book exam.

• A normal chatbot is a student answering from memory. It may sound confident and still be wrong.
• A RAG chatbot is a student who first opens the book to the right page, reads it, and then writes the answer.

RAG = Retrieval (find the right pages) + Augmented (add them to the prompt) + Generation (the AI writes the answer).

3. Way 1: a no-code PDF chatbot with Gemini Notebook

Google renamed NotebookLM to Gemini Notebook in July 2026. It is a ready-made RAG tool: it answers from the sources you upload and shows citations.

1. Open notebook.google.com (the old notebooklm.google.com address redirects there) and sign in with a personal Google account.
2. Create a new notebook.
3. Add a source and upload your PDF.
4. Ask in the chat: "How many sick leaves do I get, and when do I need a doctor's certificate?"
5. Click the small citation number in the answer. It shows the exact part of the PDF used.

On the free plan, Google's help page lists up to 100 notebooks and 50 sources per notebook (October 2026, subject to change).

Privacy: do not upload a company's internal policy to a personal account without permission. Use your company's approved tool for real company documents. For practice, use the sample policy or a public PDF.

4. Way 2: build it in Python (step by step)

Now let us build our own, so you understand what tools like Gemini Notebook do inside.

What you need

• Python 3.10 or newer on your laptop.
• A free Gemini API key from Google AI Studio (aistudio.google.com → API keys). Keep it private.
• Your PDF. For practice, download the sample leave_policy.pdf (2 pages, about 2 KB) used in this guide, or use any text PDF (not a scanned image). You can also download the finished script: pdf_chat.py.

Install the libraries

pip install -U google-genai pypdf scikit-learn

Set your key in the terminal (Windows PowerShell users: $env:GEMINI_API_KEY="YOUR_API_KEY"):

export GEMINI_API_KEY="YOUR_API_KEY"

The full script: save it as pdf_chat.py

# pdf_chat.py - a small RAG chatbot: ask questions about one PDF.
# Run: python pdf_chat.py leave_policy.pdf
import sys
from pypdf import PdfReader
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from google import genai

PDF_FILE = sys.argv[1] if len(sys.argv) > 1 else "leave_policy.pdf"
MODEL = "gemini-3.8-flash"   # check the current model name in Google's Gemini API docs

# Step 1. LOAD: read the text of every page
reader = PdfReader(PDF_FILE)
pages = [(n + 1, page.extract_text() or "") for n, page in enumerate(reader.pages)]

# Step 2. CHUNK: cut each page into pieces of about 80 words (20 words overlap)
chunks = []
for page_no, text in pages:
    words = text.split()
    for start in range(0, len(words), 60):
        piece = " ".join(words[start:start + 80])
        if piece:
            chunks.append((page_no, piece))
print(f"Loaded {len(pages)} pages and made {len(chunks)} chunks from {PDF_FILE}")

# Step 3. INDEX: turn every chunk into numbers so we can search it
vectorizer = TfidfVectorizer(stop_words="english")
matrix = vectorizer.fit_transform([text for _, text in chunks])

# Step 4. RETRIEVE: find the chunks that best match the question
def retrieve(question, top_k=3):
    scores = cosine_similarity(vectorizer.transform([question]), matrix)[0]
    best = scores.argsort()[::-1][:top_k]
    return [(chunks[i][0], chunks[i][1]) for i in best if scores[i] > 0]

# Step 5. GENERATE: give only those chunks to the model, with strict rules
client = genai.Client()   # reads your key from the GEMINI_API_KEY environment variable

def answer(question):
    found = retrieve(question)
    if not found:
        return "I could not find this in the document."
    context = "\n\n".join(f"[page {p}] {text}" for p, text in found)
    prompt = (
        "Answer the question using ONLY the context below.\n"
        'If the answer is not in the context, reply: "I could not find this in the document."\n'
        "Keep it short and mention the page number you used.\n\n"
        f"Context:\n{context}\n\nQuestion: {question}"
    )
    result = client.interactions.create(model=MODEL, input=prompt)
    return result.output_text

while True:
    q = input("\nAsk a question (or type exit): ").strip()
    if q.lower() == "exit":
        break
    if q.lower().startswith("show "):            # debug: see what was retrieved
        for p, text in retrieve(q[5:]):
            print(f"--- page {p}: {text[:120]}...")
        continue
    print(answer(q))

What each step does

1. Load: PdfReader reads the text page by page and remembers the page number.
2. Chunk: every page is cut into pieces of about 80 words. Each new piece starts 60 words after the last one, so the pieces overlap by 20 words. The overlap stops a sentence from being cut in half and lost.
3. Index: TfidfVectorizer turns each chunk into numbers based on its important words.
4. Retrieve: the question is turned into numbers the same way, and cosine_similarity finds the 3 most similar chunks.
5. Generate: only those chunks go to Gemini, with three rules: use only this context, say "I could not find this" if the answer is not there, and give the page number.

About the search method: this script uses TF-IDF, a keyword-based search, so it runs on any laptop with no extra downloads. Bigger projects usually use embeddings (meaning-based search) and a vector database. The 5 steps stay exactly the same; only step 3 and step 4 change.

5. Run it and test it

python pdf_chat.py leave_policy.pdf

Output when it starts:

Loaded 2 pages and made 4 chunks from leave_policy.pdf

First, look at what the search finds. Type show before a question:

Ask a question (or type exit): show How many sick leaves do I get?
--- page 1: Sahyadri Infotech Pvt Ltd - Leave Policy (sample for learning) 1. Casual leave: Every employee gets 12 days of casual le...

Now ask normally:

Ask a question (or type exit): How many sick leaves do I get?

Expected answer (yours will be similar, not the same):

You get 8 days of sick leave in a year. For more than 2 days in a row, you need a
doctor's certificate. (page 1)

Now ask something that is not in the PDF:

Ask a question (or type exit): What is the salary hike policy?

Expected answer:

I could not find this in the document.

The search still found a chunk (the word "policy" matched), but the rules in the prompt told Gemini to answer only from that chunk. The chunk says nothing about salary, so the bot did not invent anything. That is the main safety idea of RAG.

6. Why does RAG reduce wrong answers?

• The AI reads the real text before answering, instead of guessing from memory.
• You can check every answer because it gives the page number.
• You can update the knowledge by changing the PDF; no retraining is needed.

RAG reduces mistakes, but it does not remove them. If the search picks the wrong chunk, the answer can still be wrong. That is why the page number matters: a person can check it in 10 seconds.

7. Common problems and fixes

8. No-code or code: which should I choose?

9. Try at home

Recap

Run pdf_chat.py on one PDF from your own life today, like your college fee notice. Once you see the "show" step work, RAG will never feel like magic again.

Learn the basics first: What Is Generative AI and How Does ChatGPT Work?

Ravindra Bagale, trainer: linkedin.com/in/ravindra-bagale. Sneha, Sahyadri Infotech and its leave policy are made up for learning. The script was run on 19 October 2026 with google-genai 2.31.0, pypdf and scikit-learn; the loading, chunking and search output above is real. Gemini answers change every time, so yours will be similar, not the same. Gemini Notebook plans and the Gemini model name were checked on Google's pages the same day and can change.

Related: What Is RAG? Build a Chatbot from Your Own PDF