Transform any Python SDK into a comprehensive MCP server with automatic discovery, LLM enhancement, and production-ready safety controls.

# 1. Setup environment
uv sync
cp .env.example .env  # Add your API keys

# 2. Launch MCP Inspector with secure config
npx @modelcontextprotocol/inspector --config inspector_config.json

# 3. Select "GitHub Auto-Discovery" and connect
# 4. Test: github.search_repositories with {"query": "python"}

# 1. Start MCP Inspector
npx @modelcontextprotocol/inspector

# 2. Configure server:
#    Command: uv
#    Arguments: run python /path/to/mcp_server.py --sdk github-auto --debug
#    Working Directory: /path/to/anysdk-mcp
#    Environment: PYTHONPATH=/path/to/anysdk-mcp

• Automatically discovers ALL SDK methods using reflection
• No manual configuration - Just point it at any Python SDK
• Rich type extraction - Handles Union, Optional, Enum, datetime, etc.
• Docstring parsing - Extracts parameter descriptions automatically

• OpenAI integration - Improves tool descriptions for better agent UX
• Risk classification - AI-powered safety assessment
• Cost controls - $2 budget limit with intelligent caching
• Smart enhancement - Only uses LLM when confidence ≥ 0.7

• Plan/Apply pattern - Preview dangerous operations before execution
• Rate limiting - Configurable per-SDK limits
• Input validation - Sanitization and security controls
• Comprehensive testing - 52/53 tests passing (98% success rate)

• 37+ methods - Complete GitHub API coverage
• Authentication - Works with/without GitHub token
• Examples: github.search_repositories, github.get_user, github.search_code
• Write operations: github.create_repo.plan → github.create_repo.apply

• 100+ methods - All K8s API groups (Core, Apps, Networking, etc.)
• Namespace support - Automatic namespace handling
• Examples: k8s.CoreV1Api_list_namespaced_pod, k8s.AppsV1Api_scale_namespaced_deployment
• Safe operations - Dry-run support where available

• 200+ methods - Complete Azure Management SDK coverage
• LRO handling - Proper async operation support for begin_* methods
• Examples: azure.VirtualMachinesOperations_begin_create, azure.ResourceGroupsOperations_list
• Multi-client - Covers Compute, Network, Storage, Resource management

Write operations (create, delete, update) use a safe two-step process:

1. Plan: github.create_repo.plan {"name": "my-repo"} → Returns plan ID
2. Apply: github.create_repo.apply {"plan_id": "uuid-here"} → Executes operation

This prevents accidental destructive operations and allows review before execution.

• Read operations: Execute immediately (low risk)
• Write operations: Require plan/apply (medium/high risk)
• Risk levels: Low, Medium, High based on potential impact

• Configurable rate limiting per SDK
• Input validation and sanitization
• Response size limits
• Execution timeouts
• Operation logging

Each SDK can be customized via YAML configuration:

• configs/github.yaml - GitHub settings, rate limits, safety rules
• configs/k8s.yaml - Kubernetes settings, namespace restrictions

• GITHUB_TOKEN: GitHub personal access token for authenticated requests
• KUBECONFIG: Path to Kubernetes configuration file
• MCP_SDK: Default SDK to use (github-auto, k8s-auto, github, k8s)

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   MCP Client    │    │   SDK Bridge     │    │   Target SDK    │
│ (Investigator,  │◄──►│   (FastMCP)      │◄──►│   (GitHub,      │
│   Claude, etc.) │    │                  │    │    K8s, etc.)   │
└─────────────────┘    └──────────────────┘    └─────────────────┘
                              │
                              ▼
                       ┌──────────────┐
                       │ Auto-Discovery│
                       │ + Plan/Apply  │
                       │ + Safety      │
                       └──────────────┘

• Auto-Discovery: Automatically finds SDK methods using reflection
• Schema Generation: Creates MCP tool schemas from method signatures
• Plan/Apply: Safe execution pattern for write operations
• Safety Controls: Rate limiting, input validation, risk assessment
• Multi-SDK Support: GitHub, Kubernetes, extensible to any Python SDK

# Test GitHub access
python -c "from github import Github; print(Github().get_rate_limit())"

# Test with token  
GITHUB_TOKEN=your_token python -c "from github import Github; print(Github('your_token').get_rate_limit())"

# Check cluster access
kubectl cluster-info

# Check current context
kubectl config current-context

# Test server startup
python mcp_server.py --sdk github-auto --debug

# Check dependencies
uv run python -c "import mcp_sdk_bridge; print('✅ Package imported')"

The bridge supports any Python SDK through auto-discovery:

1. Install the SDK package
2. Create a minimal auto-adapter (see adapters/auto_github.py)
3. Add to CLI choices and validation
4. The bridge will automatically discover methods and create tools

# Run all tests
PYTHONPATH=/path/to/anysdk-mcp uv run pytest

# Run specific tests
PYTHONPATH=/path/to/anysdk-mcp uv run pytest tests/test_e2e.py -v

# Test individual components
python tests/test_e2e.py  # Runs sync tests

Once connected, you can use natural language with the auto-discovered tools:

"List my GitHub repositories" → Uses github.get_user + github.search_repositories

"Show pods in the default namespace" → Uses k8s.CoreV1Api_list_namespaced_pod

"Create a new repository called 'test-project'" → Uses github.create_repo.plan → Review → github.create_repo.apply

The auto-discovery adapters provide comprehensive access to SDK APIs while maintaining safety through the plan/apply pattern for potentially destructive operations.

• tools.search - Find tools by name/description: {"query": "repo"}
• meta.stats - Get comprehensive server statistics
• meta.export_tools - Export tool catalog in JSON/Markdown
• tools.validate - Validate all tools and check for issues
• tools.health_check - Run automated tests on all safe tools

• lro.get_status - Check operation status
• lro.wait - Wait for operation completion
• lro.list_operations - List all tracked operations

# GitHub
GITHUB_TOKEN=ghp_your_token_here

# Kubernetes  
KUBECONFIG=~/.kube/config

# Azure
AZURE_TENANT_ID=your_tenant_id
AZURE_SUBSCRIPTION_ID=your_subscription_id

# LLM Enhancement
OPENAI_API_KEY=sk-proj-your_key_here

• ✅ No API keys in config files - Environment-based secrets
• ✅ Automatic .env loading - Server loads environment on startup
• ✅ Shareable configurations - Safe to commit to version control

# Run all tests (52/53 passing - 98% success rate)
PYTHONPATH=. uv run pytest

# Test specific SDK
PYTHONPATH=. uv run pytest tests/test_azure_auto.py -v

• tools.validate - Check schemas and generate examples
• tools.health_check - Automated testing of read-only tools
• tools.test - Test specific tools with auto-generated parameters

class StripeAutoAdapter:
    def __init__(self, config):
        self.stripe = stripe.Client(api_key=config.api_key)
        self.discoverer = SDKDiscoverer("stripe")
        # Auto-discovery creates 50+ Stripe tools automatically!

Requirements for new SDKs:

• ✅ Well-documented - Methods have docstrings
• ✅ Standard Python patterns - Classes, methods, type hints
• ✅ Introspectable - Works with inspect.signature()

Your MCP Inspector is running at: http://localhost:6274

Test the power of universal SDK-to-MCP conversion:

1. Connect to "GitHub Auto-Discovery"
2. Try github.search_repositories with {"query": "python"}
3. Explore meta.stats to see 37+ available tools
4. Validate with tools.health_check for comprehensive testing

This solution transforms the MCP ecosystem by making ANY Python SDK instantly available to agents with production-grade safety and LLM-enhanced usability! 🚀