🤖 RAG Chatbot

A production-style conversational AI chatbot built with LangGraph, RAG, and Streamlit — featuring five backend variants from a simple LLM chat all the way to MCP-powered tool-using agents with persistent memory.

---

📌 What This Project Is

This repo is a fully functional chatbot application built in progressive layers. Each backend adds a new capability on top of the previous one — from a bare-bones LangGraph conversational agent to a RAG-powered document chatbot with MCP tool integration, SQLite persistence, real-time streaming, and threaded async UI.

Every backend has a paired Streamlit frontend so you can run and interact with each variant independently.

---

🏗️ Architecture Overview

The project follows a clean backend / frontend separation:

┌─────────────────────────────────────────────────────────────┐
│                     Streamlit Frontend                      │
│  (streamlit_frontend*.py / streamlit_rag_frontend.py)       │
└─────────────────────┬───────────────────────────────────────┘
                      │ calls
┌─────────────────────▼───────────────────────────────────────┐
│                    LangGraph Backend                        │
│  (langgraph_backend.py / langgraph_*_backend.py)            │
│                                                             │
│   StateGraph ──► LLM Node ──► Tool/RAG/MCP Node            │
│                      │                                      │
│              SqliteSaver (chatbot.db)                       │
└─────────────────────────────────────────────────────────────┘

---

🗂️ File Structure

rag-chatbot/
│
├── 🔧 Backends (LangGraph agents)
│   ├── langgraph_backend.py              # Variant 1: Base conversational agent
│   ├── langgraph_tool_backend.py         # Variant 2: Agent with custom tools
│   ├── langraph_rag_backend.py           # Variant 3: RAG over documents
│   ├── langgraph_database_backend.py     # Variant 4: Persistent memory (SQLite)
│   └── langgraph_mcp_backend.py          # Variant 5: MCP tool integration
│
├── 🖥️ Frontends (Streamlit UIs)
│   ├── streamlit_frontend.py             # UI for base agent
│   ├── streamlit_frontend_tool.py        # UI for tool-using agent
│   ├── streamlit_rag_frontend.py         # UI for RAG chatbot
│   ├── streamlit_frontend_database.py    # UI for persistent chatbot
│   ├── streamlit_frontend_mcp.py         # UI for MCP agent
│   ├── streamlit_frontend_streaming.py   # UI with token-by-token streaming
│   └── streamlit_frontend_threading.py   # UI with threaded async execution
│
├── 🗄️ Database
│   ├── chatbot.db                        # SQLite checkpoint store
│   ├── chatbot.db-shm                    # Shared memory file (WAL mode)
│   └── chatbot.db-wal                    # Write-ahead log (WAL mode)
│
├── requirements.txt
└── .gitignore

---

🔄 Backend Variants

Variant 1 — Base LangGraph Agent

Files: langgraph_backend.py + streamlit_frontend.py

A clean conversational agent built with LangGraph's MessagesState. Handles multi-turn chat with full message history maintained in graph state.

Stack: StateGraph · ChatOpenAI · MessagesState · MemorySaver

---

Variant 2 — Tool-Using Agent

Files: langgraph_tool_backend.py + streamlit_frontend_tool.py

Extends the base agent with custom tool bindings. The LLM can decide when to invoke tools (web search, calculators, APIs, etc.) using a ReAct-style loop.

Stack: Tool node · ToolNode · bind_tools · conditional edges

---

Variant 3 — RAG Chatbot

Files: langraph_rag_backend.py + streamlit_rag_frontend.py

The core feature of this repo. Ingests documents, builds a FAISS vector index, and grounds every LLM response in retrieved context. Answers questions based on your own knowledge base.

User Query → Embed → FAISS Similarity Search → Retrieve Chunks → LLM → Answer

Stack: PyPDFLoader · RecursiveCharacterTextSplitter · OpenAIEmbeddings · FAISS · RetrievalQA

---

Variant 4 — Persistent Memory (Database)

Files: langgraph_database_backend.py + streamlit_frontend_database.py

Adds SQLite-backed checkpointing so conversation state survives across sessions. Each conversation is tracked by a thread_id and can be resumed exactly where it left off.

Stack: SqliteSaver · chatbot.db (WAL mode) · thread_id config · state resumption

---

Variant 5 — MCP Agent

Files: langgraph_mcp_backend.py + streamlit_frontend_mcp.py

The most advanced variant. Integrates Model Context Protocol (MCP) — allowing the agent to connect to external MCP servers and use their tools dynamically. Enables filesystem access, API calls, browser automation, and more through a standardised protocol.

Stack: MCP client · dynamic tool discovery · LangGraph agent loop

---

🖥️ Frontend Variants

Frontend	Description
streamlit_frontend.py	Standard chat UI — input, output, message history
streamlit_frontend_tool.py	Shows tool calls and results inline in the chat
streamlit_rag_frontend.py	RAG UI with document upload and source attribution
streamlit_frontend_database.py	Session selector — load/resume past conversations
streamlit_frontend_mcp.py	MCP-connected UI with live tool status
streamlit_frontend_streaming.py	Real-time token-by-token streaming output
streamlit_frontend_threading.py	Async execution via threading — prevents UI blocking

---

⚙️ Setup & Installation

1. Clone the repo

git clone https://github.com/codeantik/rag-chatbot.git
cd rag-chatbot

2. Create a virtual environment

python -m venv venv
source venv/bin/activate        # macOS/Linux
venv\Scripts\activate           # Windows

3. Install dependencies

pip install -r requirements.txt

4. Set up environment variables

Create a .env file in the root:

OPENAI_API_KEY=your_openai_api_key_here
LANGCHAIN_API_KEY=your_langsmith_api_key_here   # optional, for tracing
LANGCHAIN_TRACING_V2=true
LANGCHAIN_PROJECT=rag-chatbot

---

▶️ Running the App

Each variant is run by pairing its backend with its frontend. Pick the variant you want:

# Variant 1 — Base chatbot
streamlit run streamlit_frontend.py

# Variant 2 — Tool-using agent
streamlit run streamlit_frontend_tool.py

# Variant 3 — RAG chatbot
streamlit run streamlit_rag_frontend.py

# Variant 4 — Persistent memory chatbot
streamlit run streamlit_frontend_database.py

# Variant 5 — MCP agent
streamlit run streamlit_frontend_mcp.py

# Streaming UI
streamlit run streamlit_frontend_streaming.py

# Threaded async UI
streamlit run streamlit_frontend_threading.py

The corresponding backend is imported automatically by each frontend — no need to run them separately.

---

🗄️ Database & Persistence

The chatbot.db SQLite file stores LangGraph checkpoints using WAL (Write-Ahead Logging) mode for concurrent read safety. The three files serve these roles:

File	Role
chatbot.db	Main checkpoint database
chatbot.db-shm	Shared memory index for WAL
chatbot.db-wal	Pending write buffer

To reset all conversation history:

rm chatbot.db chatbot.db-shm chatbot.db-wal

---

🔑 Key Dependencies

Package	Purpose
langgraph	Graph-based agent orchestration
langchain	Chains, prompts, retrievers
langchain-openai	OpenAI model integration
langchain-community	FAISS, document loaders, tools
streamlit	Interactive web UI
faiss-cpu	Vector similarity search for RAG
pypdf	PDF document loading
openai	Direct OpenAI API access
python-dotenv	Environment variable management

---

🗺️ Roadmap

• Base LangGraph conversational agent
• Tool-using ReAct agent
• RAG over documents (FAISS)
• SQLite persistent memory
• MCP tool integration
• Token streaming UI
• Threaded async UI
• Multi-document upload support
• User authentication & multi-user sessions
• Deploy to Streamlit Cloud / Docker

---

👨‍💻 Author

Ankit Singh — Full Stack Developer & Agentic AI Specialist

Also check out the foundational learning repos:

• 🔗 codeantik/langsmith — LangChain & RAG fundamentals
• 🕸️ codeantik/langgraph — LangGraph patterns & workflows

---

📄 License

This project is open source and available under the MIT License.