# 🤖 Business Knowledge AI Bot with RAG & MCP

An AI-powered enterprise knowledge assistant that answers company-specific questions using Retrieval-Augmented Generation (RAG), ChromaDB, LangChain, OpenAI, and the Model Context Protocol (MCP).

The assistant retrieves relevant information from internal company documents before generating accurate, context-aware responses.

---

## 📖 Project Overview

This project demonstrates how a business can use AI to provide employees with instant access to company knowledge without requiring manual document searches.

Instead of relying solely on an LLM's general knowledge, the assistant searches a private knowledge base built from company documentation and uses the retrieved information to generate reliable answers.

The project is designed as a portfolio example of an enterprise AI assistant.

---

## 🚀 Features

- 📄 PDF document ingestion
- 🔍 Semantic search using vector embeddings
- 🧠 Retrieval-Augmented Generation (RAG)
- 💬 Natural language question answering
- 🗂️ ChromaDB vector database
- 🤖 OpenAI GPT integration
- 🔌 Model Context Protocol (MCP) server
- 🌐 Gradio web interface
- ⚡ Fast semantic document retrieval

---

## 🏗️ System Architecture

```
                 Company Documents
                         │
                         ▼
                 PDF Document Loader
                         │
                         ▼
                  Text Chunking
                         │
                         ▼
          Sentence Transformers Embeddings
                         │
                         ▼
                  Chroma Vector Database
                         │
                         ▼
                Semantic Similarity Search
                         │
                         ▼
                  Retrieved Context
                         │
                         ▼
                 OpenAI GPT-4.1-mini
                         │
                         ▼
                     MCP Server
                         │
                         ▼
                   Gradio Web UI
```

---

## 🛠️ Technology Stack

| Technology | Purpose |
|------------|---------|
| Python 3.14 | Programming Language |
| LangChain | RAG Framework |
| OpenAI | Large Language Model |
| ChromaDB | Vector Database |
| Sentence Transformers | Text Embeddings |
| HuggingFace | Embedding Models |
| MCP SDK | Model Context Protocol |
| Gradio | Web Interface |
| PyPDF | PDF Processing |

---

## 📂 Project Structure

```
mcp-business-bot/
│
├── app.py
├── config.py
├── ingest.py
├── rag.py
├── mcp_server.py
├── prompts.py
├── requirements.txt
├── README.md
│
├── assets/
│   └── screenshot.png
│
├── knowledge/
│   ├── company_handbook.pdf
│   ├── TechSolutions_Company_Policies.pdf
│   ├── TechSolutions_Internal_Procedures.pdf
│   ├── TechSolutions_Product_Information.pdf
│   ├── TechSolutions_Technical_Documentation.pdf
│   └── mcp_architecture.md
│
└── chroma_db/
```

---

## 📚 Knowledge Base

The assistant indexes multiple business documents, including:

- Company Handbook
- Company Policies
- Internal Procedures
- Product Information
- Technical Documentation
- MCP Architecture

These documents are converted into semantic embeddings and stored in ChromaDB for efficient retrieval.

---

## ⚙️ Installation

Clone the repository:

```bash
git clone https://github.com/Akes102/mcp-business-bot.git

cd mcp-business-bot
```

Create a virtual environment:

```bash
python -m venv .venv
```

Activate the environment.

Windows:

```bash
.venv\Scripts\activate
```

Install dependencies:

```bash
pip install -r requirements.txt
```

Create a `.env` file:

```text
OPENAI_API_KEY=your_api_key_here
```

---

## 📥 Build the Knowledge Base

After adding PDF documents to the `knowledge` folder:

```bash
python ingest.py
```

The ingestion process:

- Loads PDFs
- Splits text into chunks
- Generates embeddings
- Stores vectors in ChromaDB

---

## ▶️ Run the Application

Start the Gradio interface:

```bash
python app.py
```

Open your browser:

```
http://127.0.0.1:7860
```

---

## 💬 Example Questions

Try asking:

- What cybersecurity policies does TechSolutions have?
- Explain the employee onboarding process.
- What products does TechSolutions provide?
- What is the company's password policy?
- How are IT incidents escalated?
- Explain the MCP architecture used in this project.

---

## 🔄 How RAG Works

1. User submits a question.
2. The question is converted into an embedding.
3. ChromaDB searches for similar document chunks.
4. Relevant context is retrieved.
5. The retrieved context is sent to the OpenAI model.
6. The AI generates an accurate response based on company documentation.

This process helps reduce hallucinations by grounding responses in the indexed documents.

---

## 🔌 Model Context Protocol (MCP)

This project includes an MCP server that exposes the RAG functionality through the Model Context Protocol.

Using MCP allows compatible AI clients to access the enterprise knowledge base in a standardized way.

---

## 📸 Demo

### Application

Replace with your own screenshot:

```
assets/screenshot.png
```

---

## 📈 Future Improvements

- User authentication
- Multi-user support
- Role-based access control
- Conversation history
- Source citations
- Streaming responses
- Docker deployment
- Cloud deployment
- Multi-document collections
- Admin dashboard

---

## 🎯 Learning Outcomes

This project demonstrates practical experience with:

- Retrieval-Augmented Generation (RAG)
- Enterprise AI Assistants
- LangChain
- ChromaDB
- OpenAI API
- Vector Embeddings
- MCP
- Gradio
- Semantic Search
- Prompt Engineering
-------
---

## 📄 License

This project is intended for educational and portfolio purposes.