Context-Pods

The MCP development framework that creates MCP servers

Context-Pods is a comprehensive development framework for creating, testing, and managing Model Context Protocol (MCP) servers. It provides a Meta-MCP Server that can generate other MCP servers through natural language descriptions or by wrapping existing scripts.

🚀 Quick Start

# Install and run Context-Pods CLI
npx @context-pods/create

# Or install globally
npm install -g @context-pods/cli
context-pods generate

✨ Features

🎯 Multiple Language Support

Create MCP servers in your preferred language:

• TypeScript - Full type safety with TurboRepo optimization
• Python - Async support with built-in data science tools
• Rust - High-performance servers with Tokio async runtime
• Shell - Wrap existing CLI tools and scripts as MCP servers
• JavaScript - Simple, no-build-step servers (coming soon)

🤖 Meta-MCP Server

The Meta-MCP Server exposes Context-Pods functionality through the MCP protocol itself:

{
  "tools": [
    "create-mcp", // Generate servers from descriptions
    "wrap-script", // Convert scripts to MCP servers
    "list-mcps", // Manage existing servers
    "validate-mcp", // Validate MCP compliance
    "analyze-codebase" // AI-powered MCP opportunity detection
  ]
}

🛠️ Advanced Features

• AI-Powered Analysis - Automatically identify MCP opportunities in existing codebases
• TurboRepo Integration - Optimized builds and caching
• Hot Reloading - Live development with automatic restarts
• Comprehensive Testing - Built-in MCP protocol compliance tests with 95%+ coverage
• Schema Validation - Zod-based runtime validation
• Multi-Transport Support - stdio, HTTP, and WebSocket
• Production Ready - Error handling, logging, and monitoring

📦 Templates

Basic Templates

basic (TypeScript)

Minimal TypeScript MCP server with essential features:

context-pods generate basic --name my-server

python-basic

Self-contained Python server with async support:

context-pods generate python-basic --name my_python_server

rust-basic

High-performance Rust server with Tokio:

context-pods generate rust-basic --name my_rust_server

shell-wrapper

Expose shell scripts and CLI tools via MCP:

context-pods generate shell-wrapper --name my_cli_wrapper

Advanced Templates

typescript-advanced

Full-featured TypeScript server with utilities, validation, and testing:

context-pods generate typescript-advanced --name my-advanced-server

🤖 AI-Powered Codebase Analysis

Context-Pods includes an intelligent codebase analyzer that identifies functions in your existing code that would make excellent MCP tools. This feature helps you discover MCP opportunities and provides implementation guidance.

How It Works

The analyzer uses a multi-phase approach:

1. File Discovery - Recursively scans your codebase with intelligent filtering
2. AST Parsing - Extracts function metadata using language-specific parsers
3. Pattern Detection - Identifies MCP-suitable patterns (API calls, file operations, etc.)
4. Scoring Algorithm - Ranks functions using a sophisticated scoring system (0-100)
5. Template Matching - Suggests the best template for each opportunity

Supported Languages

• TypeScript/JavaScript - Full AST analysis with type information
• Python - AST-based function extraction (coming soon)
• Rust/Go - Pattern-based analysis (planned)
• Shell - Script pattern detection (planned)

Usage Examples

# Basic analysis
context-pods analyze ./src

# With filtering and output options
context-pods analyze ./src --min-score 80 --format summary --max-results 5

# Language-specific analysis
context-pods analyze ./src --languages typescript,python

# Include test files
context-pods analyze ./src --include-tests

Via Meta-MCP Server

{
  "tool": "analyze-codebase",
  "arguments": {
    "path": "./src",
    "minScore": 70,
    "outputFormat": "detailed",
    "maxResults": 10
  }
}

What It Detects

The analyzer identifies functions with:

• API Integration Patterns - HTTP clients, REST calls, GraphQL queries
• File Processing Operations - File I/O, data transformation, parsing
• Database Interactions - SQL queries, ORM operations, data validation
• Utility Functions - Data validation, formatting, conversion
• External Service Integrations - Third-party API usage

Scoring Factors

Functions are scored based on:

• Complexity - Sweet spot is medium complexity (3-15 cyclomatic complexity)
• Accessibility - Exported functions score higher
• Documentation - Well-documented functions are preferred
• Parameters - Clear input parameters (1-5 params optimal)
• Patterns - Detected MCP-suitable patterns boost scores
• Async Nature - Async functions often perform useful I/O operations

Sample Output

🎯 Top MCP Opportunities Found (Score: 85+)

📁 src/api/weather.ts
└── fetchWeatherData (Score: 92/100)
    ├── Category: API Integration
    ├── Template: typescript-advanced
    ├── Complexity: Medium (8 cyclomatic)
    ├── Patterns: HTTP calls, JSON parsing
    └── Reasoning:
        • Exported async function with clear parameters
        • Makes external API calls (confidence: 0.9)
        • Well-documented with TypeScript types
        • Optimal complexity for MCP tool

📁 src/utils/validator.ts
└── validateUserInput (Score: 88/100)
    ├── Category: Validation
    ├── Template: basic
    ├── Complexity: Low (4 cyclomatic)
    ├── Patterns: Zod validation, error handling
    └── Implementation Guidance:
        • Tool Name: validate-user-input
        • Input Schema: { data: object, rules: string[] }
        • Dependencies: zod, validator
        • Estimated Effort: Low

🔧 CLI Commands

# Generate a new MCP server
context-pods generate [template] [options]

# Wrap an existing script as MCP server
context-pods wrap <script> [options]

# List all managed MCP servers
context-pods list

# Run development server with hot reload
context-pods dev

# Build all packages
context-pods build

# Run tests
context-pods test

# Validate MCP compliance
context-pods validate <path>

# Analyze codebase for MCP opportunities
context-pods analyze <path>

🏗️ Architecture

Context-Pods uses a monorepo structure powered by TurboRepo:

context-pods/
├── packages/
│   ├── core/        # Core utilities, schemas, and codebase analysis
│   ├── cli/         # Command-line interface
│   ├── templates/   # Server templates
│   ├── testing/     # MCP testing framework
│   ├── server/      # Meta-MCP server
│   └── create/      # npx runner
├── docs/            # Documentation
└── examples/        # Example implementations

🔌 Integration

Claude Desktop

Add to your Claude Desktop configuration:

{
  "mcpServers": {
    "context-pods": {
      "command": "npx",
      "args": ["@context-pods/server"]
    }
  }
}

VS Code (Cody, Continue)

Configure in your extension settings:

{
  "mcp.servers": {
    "context-pods": {
      "command": "npx",
      "args": ["@context-pods/server"]
    }
  }
}

🧪 Testing

Context-Pods includes a comprehensive testing framework:

import { validateMCPServer, testHarness } from '@context-pods/testing';

// Validate MCP compliance
const validation = await validateMCPServer('./my-server');

// Test server communication
const harness = testHarness('./my-server');
await harness.testTool('my-tool', { input: 'test' });

📚 Documentation

• Getting Started Guide
• Meta-MCP Server Guide
• Template Development
• Testing Framework
• API Reference

🧪 Test Coverage

Context-Pods maintains comprehensive test coverage across all packages:

Coverage by Package

Package	Coverage	Tests	Description
@context-pods/server	95%+	287+	MCP server tools, registry, and protocol handling
@context-pods/cli	90%+	150+	CLI commands, caching, and output formatting
@context-pods/core	90%+	75+	Template engine, language detection, and utilities
@context-pods/testing	95%+	45+	MCP protocol compliance and script wrapper testing
@context-pods/templates	85%+	25+	Template validation and structure verification
@context-pods/create	75%+	30+	NPX runner and package installation

Test Categories

• Unit Tests - Individual function and class testing
• Integration Tests - End-to-end workflow validation
• Protocol Compliance - MCP specification adherence
• Template Validation - Generated code quality assurance
• Error Handling - Resilience and recovery testing
• Performance Tests - Scalability and resource usage

Quality Assurance

• Pre-commit Hooks - Automated linting, type-checking, and testing
• CI/CD Pipeline - Continuous testing on multiple Node.js versions
• Coverage Tracking - Minimum 80% coverage requirement
• Mutation Testing - Advanced test quality verification

Run tests locally:

# Run all tests
npm test

# Run tests with coverage
npm run test:coverage

# Run specific package tests
npm test --workspace=@context-pods/server

# Run integration tests
npm run test:e2e

Development Setup

# Clone the repository
git clone https://github.com/conorluddy/ContextPods.git
cd ContextPods

# Install dependencies
npm install

# Build all packages
npm run build

# Run tests
npm test

# Start development
npm run dev

📈 Roadmap

• [ ] Additional language templates (Go, Ruby, Java)
• [ ] Visual template builder
• [ ] MCP server marketplace
• [ ] Cloud deployment options
• [ ] Performance profiling tools
• [ ] GraphQL transport support

📄 License

MIT © Conor Luddy

🙏 Acknowledgments

Built with the Model Context Protocol SDK by Anthropic.

---

<p align="center"> <i>Context-Pods: Where context creates context</i> </p>