A simple, fully local application that lets you upload PDF documents and ask questions about them using AI — all running on your own computer. No data ever leaves your machine.

1. Drop PDFs — Place files in the pdf/ folder or upload through the browser
2. Select documents — Choose which files the assistant should read
3. Ask questions — Get answers drawn directly from your selected documents

Everything runs locally via Docker — no API keys, no cloud services, no internet required after setup.

Note: The llama3 model is ~4.7 GB. First-time setup downloads ~6 GB total.

• Docker Desktop installed and running
• Git (to clone this repository)

git clone <repository-url>
cd pythonLLM1

docker compose up --build -d

This starts three services:

• Qdrant (vector database) on port 6333
• Ollama (AI models) on port 11434
• Streamlit app (user interface) on port 8501

Run once after first startup:

# Language model (~4.7 GB)
docker compose exec ollama ollama pull llama3

# Embedding model (~274 MB)
docker compose exec ollama ollama pull nomic-embed-text

Models are stored in a Docker volume and persist across restarts.

http://localhost:8501

Option A — Folder drop (recommended): Copy any PDF into the pdf/ folder in this directory. Refresh the app and it loads automatically.

Option B — Upload: Use the file uploader in Step 1 of the app.

1. Select which documents to search (Step 2)
2. Type your question in the chat box (Step 3)
3. The assistant answers using only your selected documents and shows which file(s) the answer came from

docker compose down

To also delete all stored documents and models:

docker compose down -v

For faster responses with an NVIDIA GPU:

1. Install the NVIDIA Container Toolkit
2. Uncomment the GPU section in docker-compose.yml under the ollama service
3. Restart: docker compose up -d

This app uses modern LangChain (LCEL-based) throughout:

See scope.md for full architecture details.

• Qdrant Dashboard: http://localhost:6333/dashboard
• Metadata filtering: Each chunk stores source_filename. Qdrant MatchAny filters restrict search to user-selected documents.
• PDF folder: ./pdf/ on the host maps to /app/pdf inside the container

├── app.py               # Streamlit app + LangChain LCEL orchestration
├── requirements.txt     # Python dependencies
├── Dockerfile           # Container for the Streamlit app
├── docker-compose.yml   # Orchestrates all services
├── pdf/                 # Drop PDFs here — auto-loaded on startup
├── scope.md             # Architecture and feature scope
├── CLAUDE.md            # Project context for Claude Code
└── README.md            # This file

Two models run locally via Ollama:

Both are configured in app.py and pulled with:

docker compose exec ollama ollama pull llama3
docker compose exec ollama ollama pull nomic-embed-text

All LangChain logic lives in app.py. Here's where each function is and what it does:

build_chain() is the brain of the app — everything else is plumbing or UI.

How LangChain is used (four jobs):

1. Ingestion pipeline — SemanticChunker splits PDFs at meaning boundaries (not arbitrary character counts), OllamaEmbeddings converts chunks to vectors, QdrantVectorStore stores them.
2. Smart retrieval — MultiQueryRetriever rephrases your question 3 ways, searches Qdrant for each, then deduplicates results.
3. Conversation awareness — create_history_aware_retriever rewrites your question as standalone before searching, so follow-up questions like "Who wrote it?" work correctly.
4. Memory management — RunnableWithMessageHistory automatically saves every question and answer into InMemoryChatMessageHistory — no manual history tracking needed.

The full request flow:

Your question
    → RunnableWithMessageHistory  (injects chat history)
    → history_aware_retriever     (rewrites as standalone question)
    → MultiQueryRetriever         (searches Qdrant with 3 phrasings)
    → create_stuff_documents_chain (feeds docs + history to ChatOllama)
    → Answer + history auto-updated

Not currently — but it can be expanded. There are two scenarios:

Images inside PDFs (charts, scanned pages) Swap PyPDFLoader for UnstructuredPDFLoader (from langchain-unstructured) which can OCR embedded images. Add pytesseract as the OCR engine.

Standalone image files (JPG, PNG) This requires a vision-language model:

The Qdrant + retrieval pipeline stays the same because you're ultimately storing text descriptions of images. The new step is: image → vision model → description → store as text.

Think of it like a smart librarian for your own private files.

Setup (one-time): You drop PDFs into a folder. The app reads every page and breaks it into chunks — not by counting characters, but by detecting where the topic changes. Each chunk gets converted into a list of numbers called a vector (think GPS coordinates for meaning — similar ideas have similar coordinates). All vectors are stored in Qdrant, a searchable database of meaning.

When you ask a question: Your question becomes its own vector. The app finds chunks in Qdrant whose coordinates are closest to your question — that's how it finds relevant paragraphs without keyword matching. It does this 3 times with different phrasings to catch things a single search might miss. The relevant paragraphs go to the language model (llama3), which reads them and writes a natural-language answer using only what's in your documents.

Why Docker? The app needs three programs running simultaneously (Streamlit, Qdrant, Ollama). Docker starts all three with one command and wires them together.

Top 3 examples of how to use it:

1. Insurance or legal documents — Drop your health insurance policy or lease agreement. Ask "Does my plan cover physiotherapy?" or "What is the notice period if I want to leave?" Get the exact answer without reading 40 pages of fine print.

2. Study tool for course materials — Drop lecture PDFs or textbook chapters. Ask "Explain the difference between TCP and UDP" or "What were the main causes of World War I according to chapter 3?" Answers come only from your course material — not generic internet content.

3. Work contracts or HR documents — Drop an employment contract or company handbook. Ask "How many vacation days am I entitled to?" or "What is the remote work policy?" The assistant cites the exact clause so you know where the answer came from.