Which integrations are available for this server?

Uses [OpenAI](/mcp/servers/integrations/openai)'s text-embedding-ada-002 model to generate vector embeddings for semantic document search and retrieval in the RAG system.

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

Clone the repository:

git clone https://github.com/yourusername/claude-rag-mcp-pipeline.git cd claude-rag-mcp-pipeline

Create virtual environment:

python3 -m venv rag_env source rag_env/bin/activate

Install dependencies:

pip install -r requirements.txt

Configure environment variables:

cp .env.example .env # Edit .env with your API keys

Basic Usage

Create documents folder:

mkdir documents

Add documents to the documents/ folder (PDF, Word, Markdown, or text files)
Start the Streamlit app:

streamlit run app.py

Ingest documents using the sidebar interface
Chat with your documents using the conversational interface

MCP Integration (Advanced)

Connect your RAG system to Claude Desktop for native document access:

Configure Claude Desktop (create config file if it doesn't exist):

# 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:

// ~/.../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" } } } }

Start the MCP server:

python mcp_server.py

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:

# In src/rag_system.py rag = ConversationalRAGSystem(embedding_provider="openai") # or "local"

Chunking Parameters

Adjust semantic chunking behavior:

# 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:

# 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:

# 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

Fork the repository
Create a feature branch
Make your changes
Add tests for new functionality
Submit a pull request

License

MIT License - see LICENSE file for details.

Acknowledgments

Built with:

Anthropic Claude for LLM capabilities
OpenAI for embedding models
ChromaDB for vector storage
Streamlit for web interface
Model Context Protocol for Claude Desktop integration

Claude RAG MCP Pipeline