🤖 AI PDF Assistant

Chat with Your PDFs Using Local AI

A modern Retrieval-Augmented Generation (RAG) application that allows users to upload one or more PDF documents and ask questions using a local Large Language Model (LLM) powered by Ollama and Qdrant Vector Database.

🚀 Built with Python • Streamlit • Ollama • Qdrant

⭐ If you find this project useful, consider giving it a star!

📖 Table of Contents

Overview
Features
System Architecture
Project Structure
Technology Stack
Installation
Configuration
Usage
Screenshots
RAG Workflow
Future Roadmap
Contributing
License
Author

🚀 Overview

AI PDF Assistant is a local Retrieval-Augmented Generation (RAG) application that enables users to interact with PDF documents using natural language.

Instead of manually searching through long PDF files, users can upload one or more documents and ask questions in plain English. The application retrieves the most relevant information using semantic search and generates answers with a local Large Language Model.

Unlike cloud-based AI applications, this project runs entirely on your machine using Ollama and Qdrant, helping keep your documents private while providing fast responses.

The project is designed as a modular, scalable codebase suitable for learning, portfolio projects, and further development.

✨ Features

📄 Document Management

📤 Upload one or multiple PDF documents
📚 Automatic PDF text extraction
✂️ Intelligent text chunking
🧠 Metadata-aware document processing
🗂️ Document Manager
🗑️ Delete individual documents
🧹 Clear the complete knowledge base

🤖 AI Chat

💬 Interactive chat interface
🧠 Conversation memory
📖 Context-aware responses
📚 Rich source references
🔍 Semantic document search
⚡ Fast local inference using Ollama
📝 Chat history

🔍 Retrieval-Augmented Generation (RAG)

Automatic text chunking
Sentence embeddings
Vector similarity search
Context retrieval
Metadata filtering
Grounded AI responses
Multi-document search

📊 User Interface

🎨 Modern Streamlit interface
📂 Sidebar document manager
📈 Knowledge base statistics
📤 Multiple PDF upload
🧹 Clear Chat
🗑️ Clear Database
📱 Simple and responsive layout

🌟 Project Highlights

✅ 100% Local AI

✅ No OpenAI API Required

✅ Privacy Friendly

✅ Multiple PDF Support

✅ Conversation Memory

✅ Rich Source References

✅ Qdrant Vector Database

✅ Semantic Search

✅ Modular Architecture

✅ Production-Oriented Code Structure

🛠️ Technology Stack

Category	Technology
Programming Language	Python 3.11+
User Interface	Streamlit
Local LLM	Ollama (Llama 3.2)
Vector Database	Qdrant
Embedding Model	all-MiniLM-L6-v2
PDF Processing	PyMuPDF
Vector Search	Semantic Similarity Search
Version Control	Git & GitHub
Dependency Management	uv

📌 Why This Project?

This project demonstrates the implementation of a complete Retrieval-Augmented Generation (RAG) pipeline using modern AI tools and frameworks.

It combines document processing, semantic search, vector databases, and local large language models into a single application capable of answering questions based on uploaded PDF documents.

The project is designed with a modular architecture, making it easy to extend with additional features such as streaming responses, PDF previews, dashboards, hybrid search, and cloud deployment.

🎯 Use Cases

This application can be used for:

📚 Study Notes
📖 Research Papers
📑 Company Documentation
📄 User Manuals
📘 E-books
🧾 Technical Documentation
🎓 Educational Material
📋 Project Reports

📈 Current Version

Version: v1.0

Included Features

✅ Multiple PDF Upload
✅ Local LLM (Ollama)
✅ Semantic Search
✅ Qdrant Vector Database
✅ Conversation Memory
✅ Rich Source References
✅ Document Manager
✅ Sidebar Statistics
✅ Clear Database
✅ Modular Service Architecture

🏆 Project Goals

The primary goals of this project are:

Build a complete local RAG application
Learn vector databases and semantic search
Explore local LLM deployment with Ollama
Develop a modular and scalable architecture
Create a portfolio-ready AI application
Demonstrate modern AI engineering practices

🏗️ System Architecture

The AI PDF Assistant follows a modular Retrieval-Augmented Generation (RAG) architecture.

                    +----------------------+
                    |    Upload PDF(s)     |
                    +----------+-----------+
                               |
                               ▼
                    +----------------------+
                    |   PDF Text Loader    |
                    +----------+-----------+
                               |
                               ▼
                    +----------------------+
                    |    Text Chunking     |
                    +----------+-----------+
                               |
                               ▼
                    +----------------------+
                    | Sentence Embeddings  |
                    +----------+-----------+
                               |
                               ▼
                    +----------------------+
                    |  Qdrant Vector DB    |
                    +----------+-----------+
                               ▲
                               |
                    User Question
                               |
                               ▼
                    +----------------------+
                    | Semantic Retrieval   |
                    +----------+-----------+
                               |
                               ▼
                    +----------------------+
                    |     Ollama LLM       |
                    +----------+-----------+
                               |
                               ▼
                    AI Answer + Sources

🔄 RAG Pipeline

The application follows the Retrieval-Augmented Generation workflow.

Step 1 — Upload PDF

The user uploads one or more PDF documents using the Streamlit interface.

↓

Step 2 — Extract Text

The application extracts readable text from every page of the uploaded PDF.

↓

Step 3 — Chunking

Large documents are divided into smaller chunks so they can be embedded efficiently.

↓

Step 4 — Generate Embeddings

Each text chunk is converted into a high-dimensional vector using the embedding model.

↓

Step 5 — Store in Qdrant

The generated vectors are stored inside Qdrant together with useful metadata.

Example metadata:

{
  "document_id": "...",
  "filename": "AI.pdf",
  "chunk_index": 12,
  "text": "Artificial Intelligence..."
}

↓

Step 6 — User Question

The user asks a question in natural language.

↓

Step 7 — Semantic Search

The question is embedded and compared against all stored vectors.

The most relevant chunks are retrieved.

↓

Step 8 — Context Building

Retrieved chunks are combined into a prompt.

Conversation history is also included.

↓

Step 9 — Ollama

The prompt is sent to the local Llama model.

↓

Step 10 — Response

The assistant generates an answer together with supporting source references.

📂 Project Structure

AI PDF Assistant
│
├── app
│   ├── api
│   │   └── upload.py
│   │
│   ├── core
│   │   ├── config.py
│   │   ├── constants.py
│   │   └── logger.py
│   │
│   ├── services
│   │   ├── chunker.py
│   │   ├── database_service.py
│   │   ├── document_service.py
│   │   ├── embedding_service.py
│   │   ├── ingestion_service.py
│   │   ├── llm_service.py
│   │   ├── pdf_loader.py
│   │   ├── search_service.py
│   │   └── vector_service.py
│   │
│   └── main.py
│
├── frontend
│   ├── chat_page.py
│   ├── sidebar.py
│   ├── streamlit_app.py
│   └── upload_page.py
│
├── tests
│
├── pyproject.toml
├── uv.lock
├── README.md
└── LICENSE

🧩 Service Layer

The application is divided into reusable service modules.

Service	Responsibility
PDF Loader	Extract text from PDF files
Chunker	Split documents into chunks
Embedding Service	Generate vector embeddings
Vector Service	Store and search vectors in Qdrant
Search Service	Retrieve relevant chunks
LLM Service	Communicate with Ollama
Database Service	Clear and manage the knowledge base
Document Service	Manage uploaded documents

🔐 Metadata Stored with Every Chunk

Each document chunk is stored with metadata to support advanced features.

Current metadata includes:

Document ID
Filename
Source Path
Chunk Index
Chunk Text

This metadata enables:

Individual document deletion
Rich source references
Document statistics
Future page-aware citations

📊 Data Flow

PDF
 │
 ▼
Text Extraction
 │
 ▼
Chunking
 │
 ▼
Embeddings
 │
 ▼
Qdrant
 │
 ▼
Semantic Search
 │
 ▼
Context
 │
 ▼
Ollama
 │
 ▼
Answer + Sources

💡 Design Principles

The project follows several software engineering principles:

Modular architecture
Separation of concerns
Service-oriented design
Reusable components
Scalable project structure
Easy future extensibility
Clean and maintainable code

⚙️ Installation

Follow these steps to set up the project on your local machine.

📋 Prerequisites

Before running the project, make sure you have the following installed:

Python 3.11 or later
Git
Ollama
Docker (for Qdrant)
uv (Python package manager)

📥 Clone the Repository

git clone https://github.com/sagarsoni7254-eng/ai-pdf-assistant.git

Move into the project directory:

cd ai-pdf-assistant

🐍 Create a Virtual Environment

Windows

python -m venv .venv

Activate:

.venv\Scripts\activate

macOS / Linux

python3 -m venv .venv

Activate:

source .venv/bin/activate

📦 Install Dependencies

This project uses uv for dependency management.

Install all required packages:

uv sync

This command installs all dependencies defined in:

pyproject.toml
uv.lock

🤖 Install Ollama

Download Ollama from:

https://ollama.com/download

Verify installation:

ollama --version

Download the required model:

ollama pull llama3.2

Start the Ollama server:

ollama serve

🗄️ Start Qdrant

Run Qdrant locally using Docker:

docker run -p 6333:6333 qdrant/qdrant

Verify Qdrant is running:

Open your browser:

http://localhost:6333/dashboard

🚀 Run the Application

Launch Streamlit:

streamlit run frontend/streamlit_app.py

Open:

http://localhost:8501

The application should now be running successfully.

📂 Configuration

Current default configuration:

Setting	Value
LLM	llama3.2
Embedding Model	all-MiniLM-L6-v2
Vector Database	Qdrant
Frontend	Streamlit
Language	Python

💻 Using the Application

Step 1

Upload one or more PDF documents.

Step 2

The application automatically:

Extracts text
Splits documents into chunks
Generates embeddings
Stores vectors in Qdrant

Step 3

Ask questions using natural language.

Examples:

What is Artificial Intelligence?

Explain Machine Learning.

Summarize Chapter 5.

Compare CNN and RNN.

List important interview questions.

Explain this topic for beginners.

Step 4

The assistant:

Retrieves relevant document chunks
Builds context
Sends the prompt to Ollama
Generates an answer
Displays source references

🛠 Troubleshooting

Ollama not running

Start Ollama:

ollama serve

Model not found

Download the model:

ollama pull llama3.2

Qdrant connection failed

Make sure Docker is running.

Restart Qdrant:

docker run -p 6333:6333 qdrant/qdrant

Streamlit not found

Activate the virtual environment:

source .venv/bin/activate

Then install dependencies again:

uv sync

📌 Supported Features

✅ Multiple PDF Upload
✅ Semantic Search
✅ Conversation Memory
✅ Rich Source References
✅ Local LLM
✅ Qdrant Vector Database
✅ Modular Architecture
✅ Modern UI
✅ Easy Installation

📸 Application Screenshots

Screenshots will be updated as the project evolves.

🏠 Home Page

The main interface where users can upload documents and interact with the AI assistant.

screenshots/home.png

📤 Upload PDF

Upload one or multiple PDF documents.

screenshots/upload.png

💬 AI Chat

Ask questions about uploaded documents using natural language.

screenshots/chat.png

📚 Rich Source References

Every response includes supporting document references.

screenshots/sources.png

📂 Document Manager

Manage uploaded documents and maintain your knowledge base.

screenshots/sidebar.png

🔮 Future Roadmap

The following features are planned for future releases.

🚀 Version 1.1

⚡ Streaming AI Responses
📄 Page-aware Source References
📊 Knowledge Base Dashboard
📈 Similarity Score Display

🚀 Version 1.2

📑 PDF Preview
📤 Export Chat (PDF & Markdown)
🎨 Improved User Interface
🌙 Dark / Light Theme

🚀 Version 2.0

🌐 Multi-user Authentication
☁ Cloud Deployment
🐳 Docker Compose Support
🔍 Hybrid Search (Semantic + Keyword)
📂 DOCX & TXT Support
🎙 Voice Input
🔊 Text-to-Speech Responses

🤝 Contributing

Contributions are welcome!

If you'd like to improve this project:

Fork the repository.
Create a new branch.

git checkout -b feature/my-feature

Commit your changes.

git commit -m "Add my feature"

Push your branch.

git push origin feature/my-feature

Open a Pull Request.

🐞 Reporting Issues

If you find a bug or want to request a feature, please create a GitHub Issue.

Please include:

Operating System
Python Version
Error Message
Steps to Reproduce

📚 Learning Outcomes

This project demonstrates practical experience with:

Python Development
Streamlit Applications
Retrieval-Augmented Generation (RAG)
Semantic Search
Vector Databases
Local Large Language Models
Software Architecture
Git & GitHub
AI Application Development

📜 License

This project is licensed under the MIT License.

See the LICENSE file for details.

👨‍💻 Author

Sagar Soni

AI & Machine Learning Enthusiast

Interested in:

🤖 Artificial Intelligence
🧠 Machine Learning
📄 Retrieval-Augmented Generation (RAG)
💬 Large Language Models
🐍 Python Development

GitHub:

https://github.com/sagarsoni7254-eng

🙏 Acknowledgements

This project would not have been possible without the amazing open-source community.

Special thanks to:

Python
Streamlit
Ollama
Qdrant
Sentence Transformers
PyMuPDF
GitHub

⭐ Support

If you found this project useful:

⭐ Star this repository

🍴 Fork the project

💬 Share your feedback

Your support motivates future improvements.

🤖 AI PDF Assistant

Built with ❤️ using Python, Streamlit, Ollama and Qdrant

Thank you for visiting this repository!

⭐ If you like this project, please consider giving it a star.

Name		Name	Last commit message	Last commit date
app		app
frontend		frontend
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
pyproject.toml		pyproject.toml
test_chat.py		test_chat.py
test_embedding.py		test_embedding.py
test_ingestion.py		test_ingestion.py
test_pdf.py		test_pdf.py
test_qdrant.py		test_qdrant.py
test_search.py		test_search.py
test_stream.py		test_stream.py
tests		tests
uv.lock		uv.lock

Latest commit

History

Folders and files

Repository files navigation

🤖 AI PDF Assistant

Chat with Your PDFs Using Local AI

🚀 Built with Python • Streamlit • Ollama • Qdrant

📖 Table of Contents

🚀 Overview

✨ Features

📄 Document Management

🤖 AI Chat

🔍 Retrieval-Augmented Generation (RAG)

📊 User Interface

🌟 Project Highlights

🛠️ Technology Stack

📌 Why This Project?

🎯 Use Cases

📈 Current Version

Included Features

🏆 Project Goals

🏗️ System Architecture

🔄 RAG Pipeline

Step 1 — Upload PDF

Step 2 — Extract Text

Step 3 — Chunking

Step 4 — Generate Embeddings

Step 5 — Store in Qdrant

Step 6 — User Question

Step 7 — Semantic Search

Step 8 — Context Building

Step 9 — Ollama

Step 10 — Response

📂 Project Structure

🧩 Service Layer

🔐 Metadata Stored with Every Chunk

📊 Data Flow

💡 Design Principles

⚙️ Installation

📋 Prerequisites

📥 Clone the Repository

🐍 Create a Virtual Environment

Windows

macOS / Linux

📦 Install Dependencies

🤖 Install Ollama

🗄️ Start Qdrant

🚀 Run the Application

📂 Configuration

💻 Using the Application

Step 1

Step 2

Step 3

Step 4

🛠 Troubleshooting

Ollama not running

Model not found

Qdrant connection failed

Streamlit not found

📌 Supported Features

📸 Application Screenshots

🏠 Home Page

📤 Upload PDF

💬 AI Chat

📚 Rich Source References

📂 Document Manager

🔮 Future Roadmap

🚀 Version 1.1

🚀 Version 1.2

🚀 Version 2.0

🤝 Contributing

🐞 Reporting Issues

📚 Learning Outcomes

📜 License

👨‍💻 Author

Sagar Soni

🙏 Acknowledgements

⭐ Support

🤖 AI PDF Assistant

Built with ❤️ using Python, Streamlit, Ollama and Qdrant