# 1️⃣ Clone the repository
git clone https://github.com/rupali-chauksey/intellidocs-ai-enterprise-rag-mcp.git
cd intellidocs-ai-enterprise-rag-mcp

# 2️⃣ Create virtual environment
python -m venv venv

# Windows
venv\Scripts\activate

# macOS/Linux
source venv/bin/activate

# 3️⃣ Install dependencies
pip install -r requirements.txt

# 4️⃣ Setup environment variables
cp .env.example .env
# Edit .env and add your GROQ_API_KEY

# 5️⃣ Initialize database
python setup_db.py

# 6️⃣ Run the application
python -m uvicorn app.main:app --reload --port 8002

# 7️⃣ Open browser
# Navigate to http://localhost:8002

git clone https://github.com/rupali-chauksey/intellidocs-ai-enterprise-rag-mcp.git
cd intellidocs-ai-enterprise-rag-mcp

# Create virtual environment
python -m venv venv

# Activate it
# On Windows:
venv\Scripts\activate

# On macOS/Linux:
source venv/bin/activate

# You should see (venv) in your terminal

pip install --upgrade pip
pip install -r requirements.txt

# Copy template
cp .env.example .env

# Edit .env file and add your keys:
# GROQ_API_KEY=your_api_key_here
# CHROMA_DB_PATH=./chroma_db
# DATABASE_PATH=./company.db

# Create and populate SQLite database
python setup_db.py

# Verify database
sqlite3 company.db ".tables"

# Development mode (with auto-reload)
python -m uvicorn app.main:app --reload --port 8002

# Production mode
python -m uvicorn app.main:app --port 8002 --workers 4

📱 Open your browser: http://localhost:8002

Document Upload 
    ↓
Text Extraction & Preprocessing
    ↓
Smart Chunking (Overlap Detection)
    ↓
Embedding Generation (Sentence Transformers)
    ↓
ChromaDB Vector Storage
    ↓
User Query Processing
    ↓
Semantic Similarity Search
    ↓
Relevance Threshold Filtering
    ↓
LLM Answer Generation
    ↓
Source-Aware Response

python setup_db.py

                    User Query
                        ↓
                Pattern Matcher
                        ↓
        ┌───────────────┼────────────┐
        ▼               ▼            ▼
      RAG Only    Database Only    Web Only
        ├               ├             │
        └───────────────┼─────────────┘
                        ▼
            Check for Hybrid Patterns
                        ↓
            Route to Appropriate Handler

┌─────────────────────────────────┐
│   User Query (Hybrid Pattern)   │
└────────────┬────────────────────┘
             ↓
    ┌────────┴────────┐
    ↓                 ↓
 RAG Retrieval   MCP Database
   (Policy)      (Sales Data)
    │                 │
    └────────┬────────┘
             ↓
    Response Synthesis
    (LLM Combination)
             ↓
    ┌───────────────────┐
    │  Final Answer     │
    │ (Policy + Data)   │
    └───────────────────┘

User:  "Who are the top 3 salespeople?"
AI:    "Returns: Alice ($500K), Bob ($450K), Carol ($400K)"

User:  "What are their salaries?"
AI:    [Uses previous context, identifies 'their' = top 3 salespeople]
       "Returns their individual salaries from database"

User:  "What department are they in?"
AI:    [Maintains full conversation context]
       "Returns department info from database"

Query Input
    ↓
Vector Similarity Search
    ↓
Retrieved Chunks Scored
    ↓
┌───────────────────────┐
│ Relevance Threshold?  │
└───────────┬───────────┘
    ┌───────┴────────┐
    ▼                ▼
  PASS            FAIL
    │                │
Use RAG        Fallback to
Context        Web Search

RELEVANCE_THRESHOLD=0.7

                      START
                        │
                  Classify Query
       ┌─────────────────┼─────────────────┐
       ▼                 ▼                 ▼
      RAG            Database              Web
       │                 │                 │
  Retrieve           MCP Agent         Web Search
       │                 │                 │
Relevance Grade    Database Tool          │
       └────────────┬────┴────────────────┘
                    ▼
            Response Synthesis
            (Combine Results)
                    ▼
              Final Answer
                    │
                    ▼
            Stream to User

Input: RAG + Database Question
  │
  ├─→ [Parallel] RAG Retrieval
  │   │→ Vector Search
  │   └→ Relevance Filter
  │
  ├─→ [Parallel] MCP Database
  │   │→ Tool Selection
  │   └→ Database Query
  │
  └─→ [Merge] Response Synthesis
      │→ Combine contexts
      └→ LLM generates unified answer

┌─────────────────────────────────────────┐
│          User Interface (Browser)       │
│        (HTML/CSS/JavaScript)            │
└──────────────────┬──────────────────────┘
                   │ HTTP/WebSocket
         ┌─────────▼──────────┐
         │  FastAPI Backend   │
         │  (Uvicorn Server)  │
         └─────────┬──────────┘
                   │
         ┌─────────▼────────────────────┐
         │   LangGraph Router (Agent)   │
         │   • Query Classification     │
         │   • Tool Selection           │
         │   • Response Synthesis       │
         └─┬────────────────────┬───────┘
           │                    │
    ┌──────▼─────┐      ┌──────▼──────┐
    │   RAG      │      │  MCP/DB     │
    │  Pipeline  │      │  Agent      │
    │            │      │             │
    │ ChromaDB ◄─┼─────►│ MCP Server  │
    │ (Vectors)  │      │ SQLite DB   │
    └────────────┘      └─────────────┘
           │                    │
           └────────┬───────────┘
                    │
            ┌───────▼─────────┐
            │  Web Search     │
            │  (Fallback)     │
            └─────────────────┘
                    │
            ┌───────▼──────────────┐
            │ Response Synthesis   │
            │ (LLM Combination)    │
            └───────┬──────────────┘
                    │
            ┌───────▼──────────────┐
            │  Final Response      │
            │  (with Sources)      │
            └──────────────────────┘

IntelliDocs_AI_Enterprise_RAG_MCP/
│
├── 📂 app/
│   ├── __init__.py
│   ├── config.py              # Configuration & settings
│   ├── db_tools.py            # Database tool definitions
│   ├── graph.py               # LangGraph workflow
│   ├── ingestion.py           # Document ingestion pipeline
│   ├── main.py                # FastAPI application
│   ├── mcp_agent.py           # MCP agent logic
│   ├── mcp_server.py          # MCP server implementation
│   ├── tools.py               # Tool definitions
│   │
│   ├── 📂 routes/
│   │   ├── documents.py       # Document management endpoints
│   │   └── upload.py          # Upload handling endpoints
│   │
│   ├── 📂 services/
│   │   ├── chunker.py         # Text chunking logic
│   │   ├── document_loader.py # Format-specific loaders
│   │   ├── embedding.py       # Embedding generation
│   │   ├── uploader.py        # File upload service
│   │   └── vector_store.py    # ChromaDB operations
│   │
│   ├── 📂 static/
│   │   ├── index.html         # Main UI
│   │   └── 📂 assets/
│   │       ├── style.css      # Styling
│   │       └── script.js      # Frontend logic
│   │
│   └── 📂 uploads/            # Uploaded documents
│
├── 📂 data/
│   └── company_policy.txt     # Sample company docs
│
├── 📂 tests/
│   └── test_basic.py          # Unit tests
│
├── 📂 Assets/
│   ├── test_1.png
│   └── test_2.png
│
├── 📂 docs/
│   ├── API.md                 # API documentation
│   ├── ARCHITECTURE.md        # Detailed architecture
│   └── TROUBLESHOOTING.md     # Common issues
│
├── setup_db.py                # Database initialization
├── requirements.txt           # Python dependencies
├── .env.example               # Environment template
├── .gitignore                 # Git ignore rules
├── Dockerfile                 # Docker image
├── docker-compose.yml         # Docker Compose config
├── README.md                  # This file
└── LICENSE                    # MIT License

cp .env.example .env

# LLM Configuration
GROQ_API_KEY=your_groq_api_key_here
MODEL_NAME=mixtral-8x7b-32768

# Database Configuration
DATABASE_PATH=./company.db
CHROMA_DB_PATH=./chroma_db

# Server Configuration
API_PORT=8000
API_HOST=0.0.0.0

# RAG Configuration
CHUNK_SIZE=500
CHUNK_OVERLAP=50
RELEVANCE_THRESHOLD=0.7

# MCP Configuration
MCP_ENABLED=true
MCP_PORT=5678

User: "What is the pricing of the AI course?"

System Flow:
1. Classify as RAG query
2. Search documents
3. Find relevant sections
4. Generate answer with sources

Response: "The AI course costs $299..."

User: "Who is the top salesperson this quarter?"

System Flow:
1. Classify as Database query
2. Select MCP tool: get_sales_performance
3. Execute database query
4. Synthesize response

Response: "Alice Johnson leads with $500K revenue..."

User: "What is our sales incentive policy and who qualifies?"

System Flow:
1. Classify as Hybrid (RAG + Database)
2. [Parallel] RAG retrieval → Policy documents
3. [Parallel] MCP query → Top performers
4. Synthesize both contexts
5. Generate unified answer

Response: "Our policy offers 5-15% bonus... Top qualifiers: Alice ($500K), Bob ($450K)..."

User: "What is the current USD to INR exchange rate?"

System Flow:
1. Not found in documents or database
2. Trigger web search
3. Fetch current rate
4. Return real-time data

Response: "1 USD = 83.45 INR (as of today)"

.env                    # API keys & secrets
venv/                   # Virtual environment
chroma_db/              # Vector database
company.db              # Company data
__pycache__/            # Python cache
.pytest_cache/          # Test cache
.vscode/                # IDE settings
*.pyc                   # Compiled Python
.DS_Store               # macOS files

# 1. Revoke the compromised key immediately
# 2. Create a new key
# 3. Remove from Git history
git rm --cached .env
git commit --amend --no-edit
git push

# Build and run with Docker Compose
docker compose up --build

# Run in background
docker compose up -d

# View logs
docker compose logs -f

# Stop services
docker compose down

# Production setup
python -m uvicorn app.main:app --host 0.0.0.0 --port 8002 --workers 4

# With logging
python -m uvicorn app.main:app --host 0.0.0.0 --port 8002 --workers 4 --log-level info

# Install test dependencies
pip install pytest pytest-asyncio

# Run all tests
pytest

# Run specific test
pytest tests/test_basic.py

# With coverage
pytest --cov=app tests/

source venv/bin/activate  # Activate virtual environment
pip install -r requirements.txt  # Reinstall dependencies
python -m uvicorn app.main:app --reload --port 8002  # Run with correct import path

# Check .env file exists
cat .env

# Update .env with correct key
GROQ_API_KEY=sk_xxxxxxxxxxxxxxxxxxxx

# Restart application

# Check document status
curl http://localhost:8000/api/documents/status

# If status is "error", check logs:
# Look for chunking or embedding errors

# Re-upload document
# Or recreate ChromaDB:
rm -rf chroma_db/
# Restart application

# Option 1: Use different port
python -m uvicorn app.main:app --port 8003

# Option 2: Kill process using port (Linux/macOS)
lsof -ti:8002 | xargs kill -9

# Option 3: Find and kill process (Windows)
netstat -ano | findstr :8002
taskkill /PID <PID> /F

# Don't use --reload when testing uploads
python -m uvicorn app.main:app --port 8002

# Or use production mode:
python -m uvicorn app.main:app --port 8002 --workers 4

curl http://localhost:8002/api/health

{
  "status": "healthy",
  "components": {
    "api": "✓ Running",
    "database": "✓ Connected",
    "vector_store": "✓ Initialized",
    "mcp_server": "✓ Running"
  }
}

# Get all documents status
curl http://localhost:8002/api/documents/status

# Get specific document details
curl http://localhost:8002/api/documents/<doc_id>

# View application logs
tail -f app.log

# Check for errors
grep "ERROR" app.log

# Monitor MCP server
grep "MCP" app.log

# Install dev dependencies
pip install -r requirements-dev.txt

# Run with debug mode
export PYTHONUNBUFFERED=1
python -m uvicorn app.main:app --reload --port 8002 --log-level debug

# Format code
black app/

# Lint
flake8 app/

# Type check
mypy app/

Time Complexity:
- Vector Search: O(n) → ~100ms for 1M vectors
- Database Query: O(log n) → ~10ms with indexes
- LLM Inference: ~2-3 seconds
- Total Response: ~3-4 seconds

              INTELLIDOCS AI

       ┌──────────┬──────────┬──────────┐
       │          │          │          │
     RAG         MCP        WEB      MEMORY
       │          │          │          │
       ▼          ▼          ▼          ▼
   Documents   Database   Internet   Context
       │          │          │          │
       └──────────┴──────────┴──────────┘
                    │
                    ▼
             LangGraph Router
                    │
                    ▼
             Intelligent Answer