LangChain Documentation MCP Server

A comprehensive dual-mode server that provides real-time access to LangChain documentation, API references, and code examples. Supports both FastAPI web service and native Model Context Protocol (MCP) server modes, fetching live data from official LangChain sources.

🚀 Features

• �️ Dual Server Modes - Run as FastAPI web service or native MCP server
• �📚 Live Documentation Search - Search through official LangChain documentation in real-time
• 🔍 API Reference Lookup - Get detailed API references from GitHub source code
• 🐙 GitHub Code Examples - Fetch real code examples from the LangChain repository
• 📖 Tutorial Discovery - Find and access LangChain tutorials and guides
• 📦 Version Tracking - Get latest version information from PyPI
• 🔗 Direct API Search - Search specifically through API reference documentation
• 🔌 MCP Protocol Support - Native Model Context Protocol implementation

🌐 Data Sources

This server fetches live data from:

• python.langchain.com - Official LangChain documentation
• GitHub LangChain Repository - Source code and examples
• PyPI - Latest version and release information

📋 API Endpoints

Core Endpoints

• GET / - API documentation (Swagger UI)
• GET /health - Health check and service status

LangChain Documentation

• GET /search - Search general documentation
• GET /search/api - Search API reference specifically
• GET /api-reference/{class_name} - Get detailed API reference for a class
• GET /examples/github - Get real code examples from GitHub
• GET /tutorials - Get tutorials and guides
• GET /latest-version - Get latest LangChain version info

🚀 Quick Start

Option 1: Docker Compose (Recommended)

1. Clone the repository

   git clone https://github.com/LiteObject/langchain-mcp-server.git
   cd langchain-mcp-server
   

2. Start the FastAPI server

   docker-compose up --build
   

3. Access the API

   • API Documentation: http://localhost:8080/docs
   • Health Check: http://localhost:8080/health

Option 2: Local Development

FastAPI Mode

1. Install dependencies

   pip install -r requirements.txt
   

2. Run the FastAPI server

   # Using the main entry point
   python run.py
   
   # Or using the dedicated script
   python scripts/run_fastapi.py
   
   # Or directly with uvicorn
   uvicorn src.api.fastapi_app:app --host 0.0.0.0 --port 8000
   

MCP Server Mode

1. Install dependencies

   pip install -r requirements.txt
   

2. Run the MCP server

   # Using the main entry point
   python run.py mcp
   
   # Or using the dedicated script
   python scripts/run_mcp.py
   

📚 Usage Examples

Search Documentation

# Search for "ChatOpenAI" in documentation
curl "http://localhost:8080/search?query=ChatOpenAI&limit=5"

# Search API reference specifically
curl "http://localhost:8080/search/api?query=embeddings"

Get API Reference

# Get detailed API reference for ChatOpenAI
curl "http://localhost:8080/api-reference/ChatOpenAI"

# Get API reference for LLMChain
curl "http://localhost:8080/api-reference/LLMChain"

Fetch Code Examples

# Get real examples from GitHub
curl "http://localhost:8080/examples/github?query=chatbot&limit=3"

# Get general examples
curl "http://localhost:8080/examples/github"

Get Tutorials

# Fetch all available tutorials
curl "http://localhost:8080/tutorials"

Version Information

# Get latest version from PyPI
curl "http://localhost:8080/latest-version"

🔌 MCP Server Usage

When running in MCP mode, the server provides the following tools:

Available MCP Tools

• search_langchain_docs - Search LangChain documentation
• search_api_reference - Search API reference specifically
• get_api_reference - Get detailed API reference for a class
• get_github_examples - Get code examples from GitHub
• get_tutorials - Get available tutorials
• get_latest_version - Get latest LangChain version

MCP Client Integration

{
  "mcpServers": {
    "langchain-docs": {
      "command": "python",
      "args": ["path/to/langchain-mcp-server/run.py", "mcp"],
      "env": {
        "PYTHONPATH": "path/to/langchain-mcp-server"
      }
    }
  }
}

🛠️ Configuration

Environment Variables

Docker Configuration

The service runs on port 8080 by default to avoid conflicts. You can modify this in docker-compose.yml:

ports:
  - "8080:8000"  # Host:Container

🔧 Development

Project Structure

├── src/                    # Main source code package
│   ├── main.py            # Main entry point with dual mode support
│   ├── api/               # API layer
│   │   ├── fastapi_app.py # FastAPI application
│   │   └── mcp_server.py  # Native MCP server implementation
│   ├── config/            # Configuration management
│   │   ├── settings.py    # Application settings
│   │   └── logging.py     # Logging configuration
│   ├── models/            # Data models and schemas
│   │   └── schemas.py     # Pydantic models
│   ├── services/          # Business logic
│   │   └── langchain_service.py # LangChain documentation service
│   └── utils/             # Utility modules
│       ├── exceptions.py  # Custom exceptions
│       └── helpers.py     # Helper functions
├── scripts/               # Convenience scripts
│   ├── run_fastapi.py    # Run FastAPI mode
│   ├── run_mcp.py        # Run MCP mode
│   └── health_check.py   # Health check utility
├── tests/                 # Test suite
│   ├── test_api.py       # API tests
│   ├── test_services.py  # Service tests
│   └── test_integration.py # Integration tests
├── docs/                  # Documentation
│   └── API.md            # API documentation
├── logs/                  # Log files
├── run.py                # Simple entry point
├── requirements.txt      # Python dependencies
├── pyproject.toml        # Project configuration
├── Dockerfile           # Docker configuration
├── docker-compose.yml   # Docker Compose setup
├── DOCKER.md           # Docker documentation
└── README.md           # This file

Key Dependencies

• FastAPI - Web framework for REST API mode
• MCP - Native Model Context Protocol support
• FastAPI-MCP - MCP integration for FastAPI
• httpx - Async HTTP client for external API calls
• BeautifulSoup4 - HTML parsing for documentation scraping
• Pydantic - Data validation and settings management
• uvicorn - ASGI server for FastAPI

Adding New Endpoints

1. Define Pydantic models for request/response
2. Add endpoint function with proper type hints
3. Include comprehensive docstrings
4. Add error handling with specific exceptions
5. Update health check endpoint count

🐛 Error Handling

The server includes robust error handling for:

• Network failures - Graceful degradation when external APIs are unavailable
• Rate limiting - Handles GitHub API rate limits
• Invalid requests - Proper HTTP status codes and error messages
• Timeouts - Configurable request timeouts

📊 Health Monitoring

The /health endpoint provides:

• Service status
• Available endpoints count
• Data source URLs
• Current timestamp
• Updated documentation sections

🔒 Security Considerations

• Rate Limiting - Consider implementing rate limiting for production
• CORS - Configure CORS headers if needed for web access
• API Keys - Add GitHub token for higher API limits
• Input Validation - All inputs are validated using Pydantic

🚀 Production Deployment

For production use, consider:

1. Caching - Add Redis/Memcached for response caching
2. Rate Limiting - Implement request rate limiting
3. Monitoring - Add application monitoring and logging
4. Load Balancing - Use multiple instances behind a load balancer
5. Database - Store frequently accessed data
6. CI/CD - Set up automated deployment pipeline

🤝 Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests if applicable
5. Submit a pull request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🔗 Related Links

• LangChain Documentation
• LangChain GitHub
• FastAPI Documentation
• Model Context Protocol
• MCP Python SDK

🆘 Support

If you encounter any issues:

1. Check the health endpoint for service status (FastAPI mode)
2. Review Docker logs: docker-compose logs
3. Check application logs in the logs/ directory
4. Ensure network connectivity to external APIs
5. Verify all dependencies are installed correctly
6. For MCP mode issues, check the MCP client configuration

Note: This server requires internet connectivity to fetch live data from LangChain's official sources. API rate limits may apply for GitHub API calls.