documentation-search-enhanced 1.3.0

Enhanced MCP server for searching documentation with OSINT vulnerability scanning, security analysis, and AWS-style deployment

🚀 Enhanced Documentation Search MCP Server

Transform Claude into your personal development advisor 🤖✨

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

Key Features	Description	Example Query
📚 Multi-Lib Search	Search across 104+ docs simultaneously	"Compare state management in react vs vue"
🛡️ Project Security	Scan all dependencies for vulnerabilities	"Are there any security issues in my project?"
🏗️ Project Generation	Create boilerplate for new projects	"Create a new fastapi project called my-api"
🐳 Docker Environments	Set up local services like Postgres/Redis	"Set up a postgres database for me"
🎓 Learning Paths	Get a structured learning plan	"Give me a learning path for devops"
⚖️ Security Comparison	Compare security scores of libraries	"Compare security of flask vs django"

🎯 What This Does

Transforms your AI assistant into a documentation expert!

Instead of Claude saying "I don't have access to current documentation", it now:

1. 🔍 Searches live documentation from 45+ popular libraries
2. 📚 Returns current, accurate code examples
3. 🎯 Provides contextual recommendations based on your needs
4. ⚡ Caches results for lightning-fast follow-up questions

🚀 AWS-Style Deployment Ready

This MCP server follows the exact same deployment pattern as AWS MCP servers:

# Just like AWS MCP servers - zero setup required!
uvx documentation-search-enhanced@latest

Same professional experience:

• ✅ No local cloning or setup
• ✅ Automatic dependency management
• ✅ Always up-to-date with @latest
• ✅ Works with any MCP-compatible AI assistant

---

⭐ Why This MCP Server is Different

🎯 Intelligent Recommendations - Not just search, but smart suggestions based on your skill level and project needs
📊 Data-Driven Insights - Real popularity scores, job market trends, and learning time estimates
🚀 Career-Focused - Salary insights, trending technologies, and market positioning
⚡ Lightning Fast - Smart caching delivers responses in 2-5 seconds
🔧 AWS-Style Deployment - Same professional deployment model as AWS MCP servers - just run uvx documentation-search-enhanced@latest
🛠️ Universal Compatibility - Works with Cursor, Claude Desktop, Windsurf, and any MCP-compatible tool

🎬 See the Transformation

🤖 Question: "What's the best agentic framework?"

❌ Generic AI Response:

"Popular agentic frameworks include LangChain, AutoGPT, and CrewAI."

✅ Enhanced MCP Server Response:

🎯 LANGCHAIN - Leading Agentic Framework (Score: 92/100)

📊 Real-Time Market Analysis:
• GitHub Stars: 95,247+ ← Live data from GitHub API
• Job Market: EXPLOSIVE (500% increase in Q4 2024)  
• Salary Impact: $50k-$120k+ increase potential
• Companies: Google, Microsoft, OpenAI, Anthropic actively hiring

💡 Career Intelligence:
"LangChain skills can increase salary by $50k-$120k+. 
500% growth in job postings makes it THE #1 AI skill for 2024.
Best time to learn: NOW - market demand far exceeds supply."

🚀 Quick Start (30 seconds)

No local setup required! Run directly with uvx just like AWS MCP servers.

# 1. Install and run directly (no cloning needed)
uvx documentation-search-enhanced@latest

# 2. Get your free API key from serper.dev
export SERPER_API_KEY="your_key_here"

🔧 Add to Your AI Assistant

For Cursor

Create .cursor/mcp.json in your project root:

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

For Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

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

For Windsurf

Add to ~/.codeium/windsurf/mcp_config.json:

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

That's it! 🎉 Claude now has intelligent development superpowers.

🎯 Quick Reference

Command	What It Does	Example
uvx documentation-search-enhanced@latest	Install/run MCP server	One-time setup
Get docs for library	Search documentation	"Find FastAPI authentication examples"
Get library suggestions	Auto-complete libraries	"What libraries start with 'lang'?"
Check system health	Monitor performance	"Check if documentation sources are working"
Compare technologies	Side-by-side analysis	"Compare FastAPI vs Django for APIs"

🔑 Supported Libraries (45+)

🔥 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

✨ Benefits of AWS-Style Deployment

✅ 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

🔄 Update to Latest Version

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

---

🏠 Local Development (Optional)

If you want to contribute or customize:

# 1. Clone and setup
git clone https://github.com/antonmishel/documentation-search-mcp.git
cd documentation-search-mcp
uv sync

# 2. Get your free API key from serper.dev
echo "SERPER_API_KEY=your_key_here" > .env

# 3. Test the MCP server
python src/documentation_search_enhanced/main.py
# Press Ctrl+C when you see it waiting for input ✅

# 4. Add to Cursor (.cursor/mcp.json):

For local development:

{
  "mcpServers": {
    "documentation-search-enhanced": {
      "command": "/path/to/.local/bin/uv", 
      "args": [
        "--directory",
        "/path/to/documentation-search-mcp",
        "run", 
        "src/documentation_search_enhanced/main.py"
      ],
      "env": {
        "SERPER_API_KEY": "your_key_here"
      }
    }
  }
}

🛠️ 7 Specialized AI Tools

Transform Claude from a generic assistant into a data-driven development expert:

Tool	What It Does	Example Output
🔍 get_docs	Smart documentation search	Returns targeted FastAPI auth docs in 3 seconds
🎯 recommend_libraries	Personalized suggestions with real-time career impact	"FastAPI (91/100): $45k salary boost, 83k+ GitHub stars"
⚖️ compare_libraries	Multi-dimensional analysis with live data	"Winner: Django (91.2/100) vs FastAPI vs Flask (real-time)"
📈 get_trending_libraries	Live trend analysis with growth metrics	"AutoGen: Explosive growth, 500% job increase in Q4"
💡 get_library_insights	Real-time market analysis with ROI data	"React: 236k+ stars, $35k-$85k salary increase, 2-month ROI"
🔤 suggest_libraries	Smart autocomplete with live popularity	"lang" → LangChain (95k+ stars, explosive growth)"
⚡ health_check	Performance tracking of 20+ sources	"20/20 sources healthy, avg 180ms response"

📚 20+ Supported Technologies

🔥 Hot & Trending: FastAPI, LangChain, PromptFlow, AutoGen, OpenAI, Anthropic
⚡ Frontend: React, JavaScript, TypeScript
🛠️ Backend: Django, Flask, Express, Node.js, Python
☁️ Cloud Platforms: AWS, Google Cloud, Azure
🤖 AI Frameworks: LangChain, PromptFlow, AutoGen
🤖 AI Services: OpenAI, Anthropic
🛠️ DevOps: Docker, Kubernetes
📊 Data Science: Pandas, Streamlit

All with real-time GitHub data, job market trends, and career insights!

🌟 Core Intelligence Features

🧠 Real-Time Intelligence (Default)

• Live GitHub Data - Real-time stars, forks, activity, community metrics
• Career Intelligence - Current salary data, job market trends, hiring insights
• Experience Matching - Beginner/Intermediate/Advanced optimization
• Trend Analysis - Live growth velocity and market timing advice

🎯 Personalized Recommendations

• Experience-Level Adaptation - Tailored advice for your skill level
• Use Case Optimization - Web-API, Frontend, AI, Data-Science specific
• Context-Aware Suggestions - Considers project type, timeline, team size
• Future-Proof Guidance - Trend analysis for long-term skill investment

⚖️ Objective Comparisons

• Winner Declarations - Data-driven "best choice" recommendations
• Pros/Cons Analysis - Detailed advantage/disadvantage breakdowns
• Market Position Mapping - Leader/Strong/Moderate/Niche classifications

Prerequisites

• Serper API Key: Get your free key from serper.dev
• UV Package Manager: Install with curl -LsSf https://astral.sh/uv/install.sh | sh

That's it! No Python installation, no virtual environments, no dependency management needed.

Configuration

Adding New Documentation Sources

Adding new libraries is incredibly simple! Just edit src/documentation_search_enhanced/config.json:

{
    "docs_urls": {
        "your_library": {
            "url": "https://docs.example.com/",
            "category": "web-framework",
            "learning_curve": "easy",
            "tags": ["python", "web", "api"]
        }
    },
    "categories": {
        "web-framework": ["fastapi", "django", "flask", "your_library"]
    }
}

That's it! The system automatically:

• ✅ Makes the library searchable immediately
• ✅ Includes it in suggestions and recommendations
• ✅ Provides intelligent categorization
• ✅ Delivers contextual help

For step-by-step contribution guide, see CONTRIBUTING.md.

Usage

Running the Server

# AWS-style deployment (recommended)
uvx documentation-search-enhanced@latest

# Local development (if you've cloned the repo)
python src/documentation_search_enhanced/main.py

Integration with AI Tools

The server integrates seamlessly with any MCP-compatible AI assistant. Simply add the configuration above to your AI tool's MCP settings and restart.

Configuration Files

• Cursor: .cursor/mcp.json (project-specific) or ~/.cursor/mcp.json (global)
• Claude Desktop:
  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %APPDATA%\Claude\claude_desktop_config.json
• Windsurf: ~/.codeium/windsurf/mcp_config.json

Security Best Practices

⚠️ Important: Keep your API keys secure and never commit them to version control. The MCP configuration files should be private and not shared publicly.

Available Tools

1. get_docs - Documentation Search

Search for specific information within library documentation.

Example:

🤖 You: "Using the documentation-search-enhanced MCP server, find FastAPI authentication examples"

Claude: I'll search the FastAPI documentation for authentication examples.

📚 FastAPI Authentication Examples:

From FastAPI's security documentation:

**OAuth2 with Password Bearer**
```python
from fastapi import Depends, FastAPI, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

@app.post("/token")
async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
    # Authenticate user and return token
    return {"access_token": access_token, "token_type": "bearer"}

JWT Authentication

from jose import JWTError, jwt
from datetime import datetime, timedelta

def create_access_token(data: dict):
    to_encode = data.copy()
    expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

2. suggest_libraries - Smart Auto-complete

Get library suggestions based on partial names.

Example:

🤖 You: "What libraries start with 'lang'?"

Claude: Here are libraries matching "lang":

• **langchain** - AI framework for building applications with LLMs
• **language-tool** - Grammar and spell checking
• **langdetect** - Language detection library

Would you like more details about any of these?

3. health_check - System Status

Monitor the health of documentation sources.

Example:

🤖 You: "Check if the documentation sources are working"

Claude: 📊 Documentation Health Status:

✅ **fastapi**: Healthy (142ms response)
✅ **langchain**: Healthy (203ms response) 
✅ **react**: Healthy (186ms response)
✅ **django**: Healthy (167ms response)
✅ **openai**: Healthy (124ms response)

📈 **Cache Stats**: 47 active entries, 12% utilization
🚀 **Overall Status**: All systems operational

4. Real-World Usage Scenarios

Scenario 1: Learning New Technology

🤖 You: "I'm new to web development. What's the easiest Python web framework to start with?"

Claude: Based on the documentation and current trends:

🎯 **Flask** - Perfect for Beginners (Score: 88/100)
• **Learning Curve**: Easy (2-3 weeks to proficiency)
• **Documentation Quality**: Excellent, beginner-friendly
• **Community**: Large, helpful community
• **Job Market**: Strong demand, good entry-level opportunities

📚 **Getting Started with Flask**:
```python
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run(debug=True)

Next Steps: Try the Flask tutorial, build a simple blog, then explore Flask-SQLAlchemy for databases.

**Scenario 2: Technology Comparison**

🤖 You: "Compare FastAPI vs Django for building APIs"

Claude: 🔍 FastAPI vs Django - Comprehensive Analysis

FastAPI (Winner for APIs - 94/100) ✅ Pros:

• Automatic API documentation (Swagger/OpenAPI)
• Built-in async support
• Type hints integration
• 3x faster performance
• Modern Python features

Django (Better for Full-Stack - 89/100)
✅ Pros:

• Mature ecosystem
• Built-in admin interface
• Comprehensive ORM
• Better for full-stack applications
• Larger community

🎯 Recommendation:

• Choose FastAPI for pure APIs, microservices, high-performance needs
• Choose Django for full-stack web applications with admin interfaces

**Scenario 3: Debugging and Problem Solving**

🤖 You: "I'm getting CORS errors in my FastAPI app. How do I fix this?"

Claude: 🔧 FastAPI CORS Configuration

From FastAPI documentation:

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # Allows all origins
    allow_credentials=True,
    allow_methods=["*"],  # Allows all methods
    allow_headers=["*"],  # Allows all headers
)

# For production, be more specific:
app.add_middleware(
    CORSMiddleware,
    allow_origins=["http://localhost:3000", "https://yourdomain.com"],
    allow_credentials=True,
    allow_methods=["GET", "POST"],
    allow_headers=["*"],
)

🔐 Security Note: Never use allow_origins=["*"] in production with allow_credentials=True.

## How It Works

1. **Query Processing** - Takes your search query and target library
2. **Real-Time Enhancement** - Fetches live GitHub data, job market trends (default)
3. **Smart Search** - Uses Serper API for site-specific documentation search
4. **Parallel Fetching** - Concurrently fetches multiple documentation pages
5. **Content Extraction** - Parses clean text using BeautifulSoup
6. **Intelligence Analysis** - Applies real-time scoring and career recommendations
7. **Intelligent Caching** - Stores results for faster future requests

## Environment Variables

### For AWS-Style Deployment (Recommended)
Set in your MCP configuration:

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

For Local Development

Create a .env file with:

SERPER_API_KEY=your_serper_api_key_here

Real-Time Intelligence (Default)

The MCP server uses real-time data by default for maximum accuracy:

# Real-time mode is DEFAULT - no setup needed!
# System automatically fetches:
# - Live GitHub stars, forks, activity
# - Current job market trends  
# - Real-time popularity calculations
# - Career impact analysis

# Optional: Add GitHub token for higher API rate limits
export GITHUB_TOKEN=your_github_token

# Switch to static mode only if needed (not recommended)

Benefits of Real-Time Mode:

• ✅ Always current data (never stale)
• ✅ Accurate trending analysis
• ✅ Current job market insights
• ✅ Zero maintenance overhead

Project Structure

documentation-search-mcp/
├── src/
│   └── documentation_search_enhanced/
│       ├── __init__.py              # Package initialization
│       ├── main.py                  # Main MCP server implementation
│       ├── config.json              # Documentation sources configuration
│       ├── config_manager.py        # Environment-aware configuration
│       ├── content_enhancer.py      # Content enhancement and analysis
│       ├── logger.py                # Structured logging system
│       ├── smart_search.py          # Smart search with AI features
│       ├── vulnerability_scanner.py # Security vulnerability scanning
│       ├── project_scanner.py       # Scans project dependency files
│       ├── project_generator.py     # Generates project boilerplate
│       └── docker_manager.py        # Manages Docker environments
├── pyproject.toml                   # Project dependencies and packaging
├── publish_to_pypi.sh               # Publishing script for AWS-style deployment
├── publish_instructions.md          # Detailed publishing instructions
├── samples/                         # Usage examples
│   └── README.md                    # Configuration samples
├── test_instructions.md             # Testing guide
├── quick_test.py                    # Automated test script
├── interactive_test.py              # Interactive testing menu
├── demo_usage.py                    # Real-world usage demos
├── CHANGELOG.md                     # Version history
├── README.md                        # This file
├── CONTRIBUTING.md                  # Contribution guidelines
├── LICENSE                          # MIT License
└── .env                             # Environment variables (create this for local dev)

Contributing

To add support for new libraries:

1. Add the library and its documentation URL to config.json
2. Test that the documentation site returns useful content
3. Submit a pull request

Troubleshooting

Common Issues

❌ "Library not supported"

Solution: Check available libraries with suggest_libraries tool
Available: python, javascript, react, fastapi, django, langchain, openai, anthropic, etc.

❌ "No results found"

Solution: Try broader search terms
❌ "FastAPI OAuth implementation with custom scopes"
✅ "FastAPI authentication" or "FastAPI security"

❌ Tool not appearing in AI assistant

1. Verify MCP configuration file location:
   - Cursor: .cursor/mcp.json
   - Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json
   
2. Check configuration syntax:
   - JSON must be valid
   - Use "uvx" command for AWS-style deployment
   - Include SERPER_API_KEY in env section
   
3. Restart your AI assistant after configuration changes

❌ "SERPER_API_KEY not set" error

1. Get free API key from https://serper.dev
2. Add to MCP configuration:
   "env": {
     "SERPER_API_KEY": "your_key_here"
   }
3. Restart AI assistant

❌ "uvx command not found"

Install UV package manager:
curl -LsSf https://astral.sh/uv/install.sh | sh

Performance Issues

🐌 Slow responses

• First search is slower (cache warming)
• Subsequent searches are much faster
• Use health_check tool to monitor performance

🔧 Clear cache if issues persist

• Use clear_cache tool in your AI assistant
• This forces fresh fetches from documentation sources

🎯 Complete Enhancement Recommendations (Based on AWS MCP Analysis)

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

✅ Already Implemented

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.

🚀 High Priority Enhancements

7. Rate Limiting & Resource Management

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

8. Auto-Approve Tool Integration

# 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

9. Enhanced Analytics & Metrics

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

10. Plugin Architecture

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

🎯 Medium Priority Enhancements

11. Persistent Caching

# 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()

12. Configuration Validation

# Add pydantic-based config validation
from pydantic import BaseModel, validator

class ServerConfig(BaseModel):
    name: str
    version: str
    logging_level: str = "INFO"
    max_concurrent_requests: int = 10
    
    @validator('logging_level')
    def validate_log_level(cls, v):
        if v not in ['ERROR', 'WARN', 'INFO', 'DEBUG']:
            raise ValueError('Invalid log level')
        return v

13. Health Check Enhancements

# 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()
    }

📊 Advanced Features (AWS MCP Inspired)

14. Multiple Sub-Servers (Like AWS MCP Collection)

# 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

15. Environment-Specific Configurations

{
  "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
    }
  }
}

16. Advanced Search Features

@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"""

🎉 Implementation Priority

Phase 1 (Done)

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

Phase 2 (Done)

6. ✅ Multi-Library Search

Phase 3 (Done)

7. ✅ Local Dev Environment Management

Phase 4 (Next)

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

🚀 Expected Benefits

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?

🎯 Ready to Transform Your Development Workflow?

⭐ Star this repository if you find it valuable!

🚀 Get Started Now

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?"

🤝 Join the Community

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

---

📜 License

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

---

Made with ❤️ by developers, for developers

Transform Claude into your personal development advisor today!

⭐ Don't forget to star this repo if it helped you! ⭐

@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"""

Multi-Library Search

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..."
    }
  ]
}

🚀 New in Version 1.2: Project-Aware Tools

Project Security Audit