Build an AI-Powered PDF Chatbot with RAG, FAISS, and Gemini

Introduction: When PDFs Meet Artificial Intelligence

Let me tell you about a problem I've encountered countless times: you're sitting there with a massive PDF document—maybe it's a research paper, a legal contract, or a technical manual—and you need to find specific information buried somewhere in those hundreds of pages. You could spend hours reading through it, or you could use Ctrl+F and hope you're searching for the right keywords. But what if you could just ask the document questions in plain English?

That's exactly what I built, and I'm going to walk you through every line of code, every decision, and every lesson learned along the way. This isn't just about creating a chatbot for PDFs—it's about understanding how modern AI systems work, how to make them efficient, and how to build something genuinely useful.

The Foundation: Understanding What We're Building

Before we dive into the code, let's talk about what this application actually does. Imagine you're at a library, and instead of reading every book to find information, you have a librarian who has read everything and can instantly pull relevant passages for you. That's essentially what we're building—an intelligent assistant that:

1. Reads your PDF document thoroughly
2. Remembers everything it contains
3. Understands what you're asking
4. Finds the most relevant sections
5. Responds with accurate, contextual answers

The magic happens through a combination of several cutting-edge technologies working together in harmony.

Setting Up the Stage: Imports and Configuration

import streamlit as st
import pdfplumber
import logging
import time
import os
from langchain.text_splitter import RecursiveCharacterTextSplitter
from sentence_transformers import SentenceTransformer
import faiss
import numpy as np
import google.generativeai as genai
from io import BytesIO

Why each library matters:

• Streamlit → UI framework (Python → web app in minutes)
• pdfplumber → Best-in-class PDF text extraction with layout preservation
• RecursiveCharacterTextSplitter → Smart text chunking that respects paragraphs
• SentenceTransformer → Converts meaning into vectors (semantic understanding)
• FAISS → Lightning-fast similarity search over thousands of embeddings
• Gemini → The conversational brain that generates human-like answers

Creating the User Experience: Streamlit Configuration

st.set_page_config(
    page_title="PDF Insight Assistant",
    page_icon="📚",
    layout="wide",
    initial_sidebar_state="expanded"
)

Wide layout + expanded sidebar = instant clarity on where to upload the PDF.

The Backbone: Session State Management

if 'processed' not in st.session_state:
    st.session_state.processed = False
if 'chunks' not in st.session_state:
    st.session_state.chunks = []

Critical: Streamlit reruns the entire script on every interaction. Without session_state, your processed PDF vanishes!

The Heart of the Operation: PDF Processing

def extract_text_from_pdf(uploaded_file):
    text_by_page = []
    total_pages = 0

    with pdfplumber.open(BytesIO(uploaded_file.getvalue())) as pdf:
        total_pages = len(pdf.pages)
        progress_bar = st.progress(0)
        progress_text = st.empty()

        for i, page in enumerate(pdf.pages):
            progress_text.text(f"Processing page {i+1}/{total_pages}")
            page_text = page.extract_text()
            if page_text:
                text_by_page.append(f"Page {i+1}: {page_text}")
            progress_bar.progress((i + 1) / total_pages)
            time.sleep(0.01)  # Smooth progress bar

Pro tip: Prefixing with Page X: enables precise citations later.

The Intelligence Layer: Text Chunking

splitter = RecursiveCharacterTextSplitter(
    chunk_size=800,
    chunk_overlap=150,
    separators=["\n\n", "\n", " ", ""]
)

• 800 tokens → sweet spot for context vs precision
• 150 overlap → prevents splitting critical sentences
• Smart separators → respects paragraphs first

The Semantic Understanding: Embeddings

@st.cache_resource
def load_embedding_model():
    return SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')

• Loads once per session
• 384-dimensional vectors where meaning = proximity
• "cat on mat" ≈ "feline on rug" (keyword search would fail)

The Search Engine: FAISS Index

index = faiss.IndexFlatL2(dim)
index.add(np.array(embeddings).astype('float32'))

Blazing-fast nearest neighbor search in 384D space.

The Retrieval: Finding Relevant Context

D, I = index.search(query_embedding, k=5)

• k=5 → perfect balance of context vs noise
• Returns chunks + relevance scores

The Intelligence: Gemini Integration

prompt = f"""
You are an intelligent assistant answering questions about a PDF document.
If the answer cannot be found, say "I don't have enough information..."

User Question: {question}

Document Contexts:
{chunks_with_scores}

Answer directly, cite pages, never hallucinate.
"""

Explicit instructions = reliable outputs

The Interface: Chat Experience

st.markdown("""
<div style="display: flex; justify-content: flex-end; ...">
    <div style="background-color: #2b313e; border-radius: 15px 2px 15px 15px; ...">
        <p><strong>You:</strong> {message}</p>
    </div>
</div>
""", unsafe_allow_html=True)

Modern chat bubbles with proper visual hierarchy.

Common Pitfalls & Solutions

Real-World Applications

• Legal contract review
• Research paper Q&A
• Technical manual search
• Textbook study assistant
• Business report analysis

Performance Benchmarks

Future Enhancements (v2.0)

• Multi-document support
• Automatic citation extraction
• Image/chart understanding (Gemini 1.5 Pro)
• Conversation memory across questions
• Response caching
• Domain-specific fine-tuned embeddings

The Bigger Picture: RAG Architecture

Retrieval → Augmentation → Generation

This is the same pattern powering:

• ChatGPT plugins
• Perplexity.ai
• Enterprise co-pilots

RAG Flowchart

%%{ init: { "theme": "dark", "themeVariables": { "primaryTextColor": "#f8fafc", "textColor": "#f8fafc" } } }%%
flowchart LR
    A[User Uploads PDF] --> B[Extract Text<br/>pdfplumber]
    B --> C[Split into Chunks<br/>RecursiveCharacterTextSplitter]
    C --> D[Generate Embeddings<br/>SentenceTransformer]
    D --> E[Build/Search Index<br/>FAISS]

    subgraph Retrieval
        F[User Question] --> G[Embed Question<br/>SentenceTransformer]
        G --> H[Similarity Search k=5<br/>FAISS]
        H --> I[Top-k Chunks]
    end

    I --> J[Augment Prompt<br/>Concatenate Context]
    J --> K[Generate Answer<br/>Gemini]
    K --> L[Streamlit UI<br/>Cited Response]

    style A fill:#1f2937,stroke:#38bdf8,stroke-width:1px,color:#f8fafc
    style B fill:#312e81,stroke:#c084fc,stroke-width:1px,color:#f8fafc
    style C fill:#065f46,stroke:#34d399,stroke-width:1px,color:#f8fafc
    style D fill:#7c2d12,stroke:#fb923c,stroke-width:1px,color:#f8fafc
    style E fill:#1e1b4b,stroke:#818cf8,stroke-width:1px,color:#f8fafc
    style F fill:#0f172a,stroke:#38bdf8,stroke-width:1px,color:#f8fafc
    style G fill:#1f2937,stroke:#facc15,stroke-width:1px,color:#f8fafc
    style H fill:#7f1d1d,stroke:#f87171,stroke-width:1px,color:#f8fafc
    style I fill:#14532d,stroke:#4ade80,stroke-width:1px,color:#f8fafc
    style J fill:#1e293b,stroke:#fbbf24,stroke-width:1px,color:#f8fafc
    style K fill:#0f766e,stroke:#2dd4bf,stroke-width:1px,color:#f8fafc
    style L fill:#312e81,stroke:#f472b6,stroke-width:1px,color:#f8fafc

Conclusion

"The best code is not the cleverest code. It's the code that solves real problems for real people in ways they can actually use."
— Jeff Atwood

You've just built a fully-functional RAG system. Now go make it your own.