Claude RAG MCP Pipeline

# Claude RAG Pipeline with MCP Integration Retrieval Augmented Generation (RAG) system featuring conversational memory, hybrid knowledge modes, and Model Context Protocol (MCP) integration for document search functionality within Claude Desktop. ## Features - **Complete RAG Pipeline**: Document processing, vector embeddings, semantic search, and LLM-powered responses - **Conversational Memory**: Full ChatGPT-style conversations with context preservation across exchanges - **Hybrid Knowledge Mode**: Ability to switch between document-based responses and general knowledge - **Semantic Chunking**: Intelligent document segmentation that preserves meaning and context - **MCP Integration**: Native Claude Desktop integration for document access functionality - **Multi-format Support**: PDF, Word, Markdown, and plain text documents - **Vector Database**: ChromaDB for efficient semantic search - **Web Interface**: Streamlit app for document management and chat ## Architecture ``` Documents → Semantic Processing → Vector Embeddings → ChromaDB → Retrieval → Claude API → Response ↓ MCP Protocol ↓ Claude Desktop ``` ## Tech Stack - **LLM**: Claude 3.5 (Anthropic API) - **Embeddings**: OpenAI text-embedding-ada-002 or local sentence-transformers - **Vector Database**: ChromaDB - **Web Framework**: Streamlit - **Document Processing**: PyPDF2, python-docx - **Integration Protocol**: Model Context Protocol (MCP) ## Quick Start ### Prerequisites - Python 3.8+ - OpenAI API key - Anthropic API key - Claude Desktop app (for MCP integration) ### Installation 1. Clone the repository: ```bash git clone https://github.com/yourusername/claude-rag-mcp-pipeline.git cd claude-rag-mcp-pipeline ``` 2. Create virtual environment: ```bash python3 -m venv rag_env source rag_env/bin/activate ``` 3. Install dependencies: ```bash pip install -r requirements.txt ``` 4. Configure environment variables: ```bash cp .env.example .env # Edit .env with your API keys ``` ### Basic Usage 1. **Create documents folder**: ```bash mkdir documents ``` 2. **Add documents** to the `documents/` folder (PDF, Word, Markdown, or text files) 3. **Start the Streamlit app**: ```bash streamlit run app.py ``` 4. **Ingest documents** using the sidebar interface 5. **Chat with your documents** using the conversational interface ### MCP Integration (Advanced) Connect your RAG system to Claude Desktop for native document access: 1. **Configure Claude Desktop** (create config file if it doesn't exist): ```bash # Create the config file if it doesn't exist mkdir -p "~/Library/Application Support/Claude" touch "~/Library/Application Support/Claude/claude_desktop_config.json" ``` Edit the configuration file: ```json // ~/.../Claude/claude_desktop_config.json { "mcpServers": { "personal-documents": { "command": "/path/to/your/project/rag_env/bin/python", "args": ["/path/to/your/project/mcp_server.py"], "env": { "OPENAI_API_KEY": "your_key", "ANTHROPIC_API_KEY": "your_key" } } } } ``` 2. **Start the MCP server**: ```bash python mcp_server.py ``` 3. **Use Claude Desktop** - Chats will access your documents when relevant (e.g. try prompting "Can you search my documents for details regarding ...?"). Ensure "personal-documents" is enabled under "Search and tools". ## Project Structure ``` claude-rag-mcp-pipeline/ ├── src/ │ ├── document_processor.py # Document processing and semantic chunking │ ├── embeddings.py # Embedding generation (OpenAI/local) │ ├── vector_store.py # ChromaDB interface │ ├── llm_service.py # Claude API integration │ └── rag_system.py # Main RAG orchestration ├── documents/ # Your documents go here ├── chroma_db/ # Vector database (auto-created) ├── app.py # Streamlit web interface ├── mcp_server.py # MCP protocol server ├── requirements.txt # Python dependencies ├── .env.example # Environment variables template └── README.md ``` ## Key Components ### Document Processing - **Multi-format support**: Handles PDF, Word, Markdown, and text files - **Semantic chunking**: Preserves document structure and meaning - **Metadata preservation**: Tracks source files and chunk locations ### Vector Search - **Semantic similarity**: Finds relevant content by meaning, not keywords - **Configurable retrieval**: Adjustable number of context chunks - **Source attribution**: Clear tracking of information sources ### Conversational Interface - **Memory persistence**: Maintains conversation context across exchanges - **Hybrid responses**: Combines document knowledge with general AI capabilities - **Source citation**: References specific documents in responses ### MCP Integration - **Native Claude access**: Use Claude Desktop with your document knowledge - **Automatic tool detection**: Claude recognizes when to search your documents - **Secure local processing**: Documents never leave your machine ## Configuration ### Embedding Options Switch between OpenAI embeddings and local models: ```python # In src/rag_system.py rag = ConversationalRAGSystem(embedding_provider="openai") # or "local" ``` ### Chunking Parameters Adjust semantic chunking behavior: ```python # In src/document_processor.py chunks = self.semantic_chunk_llm(text, max_chunk_size=800, min_chunk_size=100) ``` ### Response Tuning Modify retrieval and response generation: ```python # Number of chunks to retrieve result = rag.query(question, n_results=5) # Claude response length response = llm_service.generate_response(query, chunks, max_tokens=600) ``` ### Claude Model Selection Change the Claude model version in `src/llm_service.py`: ```python # In LLMService class methods, update the model parameter (check console.anthropic.com for currently available models): model="claude-3-5-haiku-latest" # Fast, cost-effective model="claude-3-5-sonnet-latest" # Higher quality reasoning model="claude-3-opus-latest" # Most capable model="claude-4-sonnet-latest" # If available ``` ## Use Cases - **Personal Knowledge Base**: Make your documents searchable and conversational - **Research Assistant**: Query across multiple documents simultaneously - **Document Analysis**: Extract insights from large document collections - **Enterprise RAG**: Foundation for company-wide knowledge systems ## Technical Details ### Transformer Architecture Understanding This system demonstrates practical implementation of: - Vector embeddings for semantic representation - Attention mechanisms through retrieval scoring - Multi-step reasoning through conversation context - Hybrid AI architectures combining retrieval and generation ## API Costs **Typical monthly usage:** - OpenAI embeddings: $2-10 - Claude API calls: $5-25 - **Total: $7-35/month for moderate usage** **Cost reduction:** - Use local embeddings (sentence-transformers) for free embedding generation - Adjust response length limits - Optimize chunk retrieval counts ## Production Considerations ### Current Implementation Scope This system is designed for personal/single-user environments. However, the core RAG functionality, MCP integration, and conversational AI systems can be implemented at enterprise-level. ### Enterprise Production Deployment Requirements To deploy this system in a true production enterprise environment, the following additions would be needed: **Authentication & Authorization:** - Multi-user authentication system (SSO integration) - Role-based access controls (RBAC) - Document-level permissions and access policies - API key rotation and secure credential management **Infrastructure & Scalability:** - Container orchestration (Kubernetes deployment) - Production-grade vector database (Pinecone, Weaviate, or managed ChromaDB) - Load balancing and horizontal scaling - Database clustering and replication - CDN integration for document serving **Monitoring & Operations:** - Application performance monitoring (APM) - Logging aggregation and analysis - Health checks and alerting systems - Usage analytics and cost tracking - Backup and disaster recovery procedures **Security Hardening:** - Input validation and sanitization - Rate limiting and DDoS protection - Network security (VPC, firewalls, encryption in transit) - Data encryption at rest - Security audit trails and compliance logging **Enterprise Integration:** - Integration with existing identity providers - Corporate data governance policies - Compliance with data retention requirements - Integration with enterprise monitoring/alerting systems - Multi-tenancy support with resource isolation **Cost Management:** - Usage-based billing and chargeback systems - Cost optimization and budget controls - API usage monitoring and alerts - Resource utilization optimization ## Contributing 1. Fork the repository 2. Create a feature branch 3. Make your changes 4. Add tests for new functionality 5. Submit a pull request ## License MIT License - see LICENSE file for details. ## Acknowledgments Built with: - [Anthropic Claude](https://anthropic.com) for LLM capabilities - [OpenAI](https://openai.com) for embedding models - [ChromaDB](https://www.trychroma.com) for vector storage - [Streamlit](https://streamlit.io) for web interface - [Model Context Protocol](https://modelcontextprotocol.io) for Claude Desktop integration