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

Get API Reference

Fetch Code Examples

Get Tutorials

Version Information

🔌 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

🛠️ Configuration

Environment Variables

Docker Configuration

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

🔧 Development

Project Structure

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.