An enhanced MCP server for documentation search, security analysis, and developer productivity. Deploys instantly with uvx, just like official AWS MCP servers.

To understand the impact of this MCP server, let's compare a common, critical developer task with and without the tool.

Scenario: "Are there any vulnerabilities in my project's dependencies?"

This is the core value: automating tedious, complex, and critical developer workflows to deliver instant, accurate, and actionable insights.

# No git clone required! Needs Python 3.12+
uvx documentation-search-enhanced@latest

Add to your Claude Desktop or Cursor configuration:

{
  "mcpServers": {
    "documentation-search-enhanced": {
      "command": "uvx",
      "args": ["documentation-search-enhanced@latest"],
      "env": {
        "SERPER_API_KEY": "your_serper_api_key_here"
      }
    }
  }
}

This server provides a powerful suite of tools to enhance your development workflow:

You can customize the server by creating a config.json file in your project directory.

1. Get the default config: Ask your AI assistant, "get the current configuration".
2. Save as config.json: Save the output to a config.json file in your project's root.
3. Modify: Add your own private documentation URLs or change settings.

The server will automatically use your local config.json if it exists.

If you want to contribute or customize the server's code:

git clone https://github.com/antonmishel/documentation-search-mcp.git
cd documentation-search-mcp
uv sync
echo "SERPER_API_KEY=your_key_here" > .env
uv run python src/documentation_search_enhanced/main.py

Contributions are welcome! Please see CONTRIBUTING.md for details.

This project is open source under the MIT License. See LICENSE for details.

🔥 AI & ML: langchain, openai, anthropic, transformers, scikit-learn, spacy
🌐 Web Frameworks: fastapi, django, flask, express
⚛️ Frontend: react, svelte, javascript, typescript
☁️ Cloud: aws, google-cloud, azure, boto3
🐍 Python: pandas, numpy, matplotlib, requests, streamlit
🛠️ DevOps: docker, kubernetes
💾 Data: duckdb, jupyter, papermill

✅ Zero Local Setup - No cloning, no path management
✅ Automatic Updates - Always get the latest version with @latest
✅ Isolated Environment - uvx handles dependencies automatically
✅ Universal Compatibility - Works with any MCP-compatible AI assistant
✅ No Maintenance - No local virtual environments to manage

# The @latest tag automatically gets the newest version
# Just restart your AI assistant to get updates

Based on my analysis of the AWS MCP repository, here are priority enhancements that would make your documentation-search-enhanced MCP server enterprise-grade:

1. Enhanced Configuration Management - Added AWS-style config with auto_approve, priority, features
2. Structured Logging - Created AWS-style logging with FASTMCP_LOG_LEVEL support
3. Samples Directory - Added comprehensive usage examples and configurations
4. Project-Aware Security Scan - Scans pyproject.toml, etc. for vulnerabilities.
5. Project Boilerplate Generation - Creates starter projects from templates.
6. Local Dev Environment Management - Generates docker-compose.yml for services.
7. Configuration Validation - Ensures config.json is valid on startup, providing clear errors.

# Add to main.py
from asyncio import Semaphore
from collections import defaultdict
from datetime import datetime, timedelta

class RateLimiter:
    def __init__(self, requests_per_minute: int = 60):
        self.requests_per_minute = requests_per_minute
        self.requests = defaultdict(list)
    
    async def check_rate_limit(self, identifier: str = "default"):
        now = datetime.now()
        # Implementation...

# Modify tools to respect auto-approve settings
@mcp.tool()
async def get_docs(query: str, library: str):
    """Enhanced with auto-approve support"""
    config = load_config()
    auto_approve = config["server_config"]["auto_approve"].get("get_docs", False)
    
    if not auto_approve:
        # Request user approval for external fetch
        pass

# Add usage analytics like AWS MCP servers
class AnalyticsTracker:
    def __init__(self):
        self.metrics = {
            "requests_total": 0,
            "libraries_searched": defaultdict(int),
            "response_times": [],
            "error_count": 0
        }

# Enable community extensions
class PluginManager:
    def __init__(self):
        self.plugins = []
    
    def register_plugin(self, plugin):
        self.plugins.append(plugin)
    
    async def execute_plugins(self, event_type: str, data: dict):
        for plugin in self.plugins:
            await plugin.handle(event_type, data)

# Add SQLite-based persistent cache
import sqlite3
import pickle

class PersistentCache(SimpleCache):
    def __init__(self, db_path: str = "cache.db"):
        super().__init__()
        self.db_path = db_path
        self._init_db()

# Add comprehensive health monitoring
@mcp.tool()
async def detailed_health_check():
    """Enhanced health check with more metrics"""
    return {
        "status": "healthy",
        "uptime_seconds": (datetime.now() - start_time).total_seconds(),
        "memory_usage_mb": psutil.Process().memory_info().rss / 1024 / 1024,
        "cache_hit_rate": cache.get_hit_rate(),
        "active_connections": len(active_connections),
        "rate_limit_status": rate_limiter.get_status()
    }

# Modular architecture
uvx documentation-search-enhanced.core@latest      # Core search
uvx documentation-search-enhanced.ai@latest        # AI-specific docs  
uvx documentation-search-enhanced.web@latest       # Web framework docs
uvx documentation-search-enhanced.cloud@latest     # Cloud platform docs

{
  "environments": {
    "development": {
      "logging_level": "DEBUG",
      "cache_ttl_hours": 1,
      "rate_limit_enabled": false
    },
    "production": {
      "logging_level": "ERROR", 
      "cache_ttl_hours": 24,
      "rate_limit_enabled": true
    }
  }
}

@mcp.tool()
async def semantic_search(query: str, libraries: list[str], context: str = None):
    """AI-powered semantic search across multiple libraries"""

@mcp.tool() 
async def code_examples_search(query: str, language: str = "python"):
    """Search specifically for code examples"""

@mcp.tool()
async def trending_topics(category: str = "ai"):
    """Get trending topics in a category"""

1. ✅ Enhanced Configuration
2. ✅ Structured Logging
3. ✅ Samples Directory
4. ✅ Project-Aware Security Scan
5. ✅ Project Boilerplate Generation

6. ✅ Multi-Library Search

7. ✅ Local Dev Environment Management

8. ✅ Configuration Validation
9. 🔄 Rate Limiting Implementation
10. 🔄 Auto-Approve Tool Integration
11. Analytics & Metrics Tracking

After implementing these AWS MCP-inspired enhancements:

• 🏢 Enterprise-Ready: Production-grade reliability and monitoring
• 🔒 Security: Rate limiting, auto-approve controls, audit trails
• 📈 Scalability: Plugin architecture, modular design, resource management
• 🛠️ Developer Experience: Better logging, samples, configuration validation
• 📊 Observability: Comprehensive metrics, health checks, performance tracking

Your MCP server would then match or exceed the capabilities of AWS MCP servers while maintaining the same professional deployment model! 🎯

Would you like me to implement any specific enhancement from this list?

1. Install: uvx documentation-search-enhanced@latest
2. API Key: Get free key from serper.dev
3. Configure: Add to your AI assistant (see Quick Start above)
4. Experience: Ask Claude "What's the best framework for my project?"

• 💬 Questions? Open an issue
• 🐛 Bug Reports: We fix them fast!
• ✨ Feature Requests: Your ideas make this better
• 🔀 Pull Requests: Contributions welcome!

This project is open source under the MIT License. See LICENSE file for details.

@mcp.tool() async def semantic_search(query: str, libraries: list[str], context: str = None): """AI-powered semantic search across multiple libraries"""

@mcp.tool() async def code_examples_search(query: str, language: str = "python"): """Search specifically for code examples"""

@mcp.tool() async def trending_topics(category: str = "ai"): """Get trending topics in a category"""

Get a broader perspective by searching across multiple libraries at once.

🤖 You: How do I handle state management in React vs Vue? (This will search both libraries and return a combined, ranked result)

Claude:

{
  "query": "state management",
  "libraries_searched": ["react", "vue"],
  "total_results": 20,
  "results": [
    {
      "source_library": "react",
      "title": "React Docs: State and Lifecycle",
      "relevance_score": 95.5,
      "snippet": "Learn how to use state and lifecycle methods in React components..."
    },
    {
      "source_library": "vue",
      "title": "Vue Docs: State Management with Pinia",
      "relevance_score": 92.1,
      "snippet": "Pinia is the now the official state management library for Vue..."
    },
    {
      "source_library": "react",
      "title": "Redux Toolkit Tutorial",
      "relevance_score": 88.7,
      "snippet": "The official, opinionated, batteries-included toolset for efficient Redux development..."
    }
  ]
}

Your MCP server comes pre-configured with 104 popular libraries, but you can easily customize it.

1. Get the Default Configuration: Ask your AI assistant: "Show me the current configuration" This will output the entire config.json content.

2. Create a Local config.json:

   • Save the output from the previous step into a file named config.json in your project's root directory.

3. Modify Your Local Config:

   • Add your own private documentation URLs, internal libraries, or tweak any settings.

The MCP server will automatically detect and use your local config.json instead of the default one.

To add a new library, simply edit your local config.json and add a new entry to the docs_urls and categories sections: