Context Engineering MCP Server

🚀 A comprehensive MCP server that automates Cole Medin's context engineering methodology for creating high-quality Product Requirements Prompts (PRPs).

🎯 Overview

This MCP server implements the context engineering methodology created by Cole Medin in his Context Engineering Introduction repository. It provides intelligent automation for creating comprehensive Product Requirements Prompts that account for your existing codebase context.

What This Server Does

The Context Engineering MCP Server intelligently analyzes your existing codebase and automatically generates:

🔍 Contextual Questions based on detected patterns and frameworks
📋 Comprehensive INITIAL.md documentation following Cole's methodology
📝 Product Requirements Prompts (PRPs) using proven templates
🎯 Execution Guidance with agent recommendations and task breakdowns
💾 Persistent Storage for managing PRPs and project context
🔗 Archon Integration for seamless task and knowledge management

Why Use This Server?

Instead of starting with blank requirements documents:

Analyzes your existing code to understand architecture and patterns
Asks intelligent questions specific to your tech stack and domain
Synthesizes insights into comprehensive documentation
Generates actionable PRPs that account for your current context
Provides storage and versioning for long-term project management

📋 MCP Tools (9 Available)

Core Context Engineering Tools

list_templates - List all available PRP templates with optional category filtering
generate_prp - Generate a Product Requirements Prompt based on a template and project context
validate_prp - Validate a PRP against context engineering best practices
search_templates - Search for templates by name, description, or tags
create_custom_template - Create new custom PRP templates
analyze_context - Analyze project context to recommend suitable templates and improvements

Storage & Management Tools

list_prps - List all stored PRPs with filtering and search capabilities
update_prp - Update existing PRPs with version tracking
manage_storage - Manage storage operations, backup, and maintenance

📚 MCP Resources (5 Available)

Templates (context-engineering://templates) - Collection of PRP templates
Patterns (context-engineering://patterns) - Code analysis patterns and rules
Initial (context-engineering://initial) - INITIAL.md generation templates
Rules (context-engineering://rules) - Global context engineering rules
PRPs (context-engineering://prps) - Stored Product Requirements Prompts

🚀 Quick Start

Installation

# Clone the repository
git clone https://github.com/locomotive-agency/context-engineering-mcp.git
cd context-engineering-mcp

# Install dependencies
npm install

# Build the TypeScript code
npm run build

# Start the MCP server
npm start

Demo Integration

# Run the comprehensive demo
node demo-integration.js

⚙️ Claude Desktop Configuration

Add this configuration to your Claude Desktop claude_desktop_config.json:

{
  "mcpServers": {
    "context-engineering": {
      "command": "node",
      "args": ["/path/to/context-engineering-mcp-server/dist/index.js"],
      "env": {
        "TEMPLATES_DIR": "/path/to/context-engineering-mcp-server/templates",
        "EXTERNAL_TEMPLATES_DIR": "/path/to/context-engineering-mcp-server/external/context-engineering-intro",
        "DATA_DIR": "/path/to/context-engineering-mcp-server/data"
      }
    }
  }
}

Claude Code Integration

# Add to Claude Code via MCP
claude-code mcp add context-engineering /path/to/context-engineering-mcp-server/dist/index.js

🔧 Configuration Options

Environment Variables

TEMPLATES_DIR - Directory containing internal templates (default: ./templates)
EXTERNAL_TEMPLATES_DIR - Directory for Cole's external templates (default: ./external/context-engineering-intro)
DATA_DIR - Directory for persistent storage (default: ./data)
NODE_ENV - Environment mode (development, production, test)

Server Capabilities

Archon Integration - Automatic integration with Archon MCP for task and knowledge management
Version Control - Full version tracking for PRPs with diff generation
Concurrent Operations - Supports up to 10 concurrent storage operations
Template Synchronization - Automatic syncing with Cole's upstream templates

📖 Usage Examples

Basic PRP Generation

// List available templates
const templates = await mcp.call('list_templates', { category: 'web-app' });

// Generate a PRP for a Next.js project
const prp = await mcp.call('generate_prp', {
  templateId: 'nextjs-app-template',
  projectContext: {
    name: 'E-commerce Platform',
    domain: 'retail',
    stakeholders: ['Product Manager', 'Engineering Team', 'Design Team'],
    objectives: ['Build scalable e-commerce platform', 'Implement modern UX'],
    constraints: ['Budget: $50k', 'Timeline: 3 months']
  },
  saveToStorage: true,
  outputFormat: 'markdown'
});

Context Analysis Workflow

// Analyze project context
const analysis = await mcp.call('analyze_context', {
  projectContext: {
    name: 'Mobile Banking App',
    domain: 'fintech',
    description: 'Secure mobile banking application with real-time transactions',
    stakeholders: ['Bank Executives', 'Compliance Team', 'Customers'],
    constraints: ['PCI DSS Compliance', 'SOX Compliance', 'High Security Requirements']
  }
});

// Use recommended template
const prp = await mcp.call('generate_prp', {
  templateId: analysis.recommendedTemplates[0].id,
  projectContext: analysis.enhancedContext
});

Storage Management

// List stored PRPs
const prps = await mcp.call('list_prps', {
  category: 'fintech',
  status: 'active',
  limit: 10
});

// Update a PRP
const updated = await mcp.call('update_prp', {
  id: 'prp-123',
  updates: {
    status: 'completed',
    metadata: { version: '2.0' }
  },
  comment: 'Updated requirements based on stakeholder feedback'
});

🏗️ Architecture

Transport & Protocol

Protocol: MCP (Model Context Protocol) v0.6.0
Transport: StdioServerTransport for client communication
Security: Input validation with Zod schemas

Core Components

TemplateManager

Loads templates from internal and external directories
Provides search, filtering, and categorization
Handles template validation and caching
Syncs with Cole Medin's upstream repository

PRPGenerator

Generates PRPs from templates with context substitution
Supports multiple output formats (Markdown, JSON, HTML)
Handles custom sections and metadata
Integrates with storage and version control

StorageSystem

Persistent storage for PRPs and project context
Version tracking with diff generation
Concurrent operation management
Backup and recovery capabilities

IntegrationsManager

Seamless integration with Archon MCP server
Automatic task creation from PRP sections
Knowledge synchronization
Health monitoring and fallback handling

External Integration

The project uses git subtree to integrate Cole Medin's original templates:

# Sync with upstream templates
./scripts/sync-templates.sh

🧪 Testing

The project follows Test-Driven Development (TDD) principles:

# Run all tests
npm test

# Run tests with coverage
npm run test:coverage

# Run specific test suites
npm run test:unit        # Unit tests
npm run test:integration # Integration tests
npm run test:e2e        # End-to-end tests
npm run test:performance # Performance tests

# Watch mode for development
npm run test:watch

Test Coverage

Project Structure Tests: Validate directory structure and configuration
Unit Tests: Test individual components and functions
Integration Tests: Test MCP tool and resource handlers
End-to-End Tests: Test complete workflows
Performance Tests: Test under load and stress conditions

Current test status: 58 tests passing with comprehensive coverage.

🛠️ Development

Prerequisites

Node.js 18+
npm or yarn
TypeScript 5.3+

Development Commands

# Watch mode for development
npm run dev

# Type checking
npm run type-check

# Linting and formatting
npm run lint
npm run lint:fix
npm run format
npm run format:check

# Validation pipeline
npm run validate  # Runs lint + type-check + all tests

# Template synchronization
npm run sync-templates

Project Structure

├── src/
│   ├── tools/              # MCP tool implementations (9 tools)
│   │   ├── generate-prp.ts
│   │   ├── validate-prp.ts
│   │   ├── list-templates.ts
│   │   ├── search-templates.ts
│   │   ├── create-custom-template.ts
│   │   ├── analyze-context.ts
│   │   ├── list-prps.ts
│   │   ├── update-prp.ts
│   │   └── manage-storage.ts
│   ├── resources/          # MCP resource handlers (5 resources)
│   │   ├── handlers/
│   │   └── resource-manager.ts
│   ├── lib/                # Core logic components
│   │   ├── template-manager.ts
│   │   ├── prp-generator.ts
│   │   ├── storage.ts
│   │   ├── change-tracker.ts
│   │   ├── integrations.ts
│   │   └── execution-guidance.ts
│   ├── types/              # TypeScript type definitions
│   └── index.ts            # Main server entry point
├── templates/              # Internal PRP templates
├── external/               # Git subtree for Cole's templates
│   └── context-engineering-intro/
├── data/                   # Persistent storage directory
├── scripts/                # Utility scripts
│   ├── sync-templates.sh   # Template synchronization
│   └── test-coverage-report.js
├── test/                   # Test suites
│   ├── unit/
│   ├── integration/
│   ├── e2e/
│   └── performance/
└── dist/                   # Built JavaScript output

🤝 Contributing

We welcome contributions! This project builds upon Cole Medin's excellent foundation.

Development Workflow

Follow TDD approach - write tests first
Use TypeScript with strict mode
Follow ESLint and Prettier configurations
Update tests when adding new features
Keep external templates synced via git subtree
Ensure all CI checks pass

Code Style

TypeScript strict mode enabled
ESLint + Prettier for consistent formatting
Comprehensive type definitions
Extensive test coverage required
Documentation for all public APIs

🙏 Credits & Attribution

This project is built upon the excellent context engineering methodology created by Cole Medin:

Original Repository: context-engineering-intro
Methodology: Cole Medin's context engineering approach for PRP generation
Templates: Integrated via git subtree from Cole's repository
Inspiration: Cole's systematic approach to requirements engineering

Contributors

Cole Medin - Original context engineering methodology and templates
Claude/Anthropic - MCP server implementation and automation
croakingtoad - Project coordination and testing

📄 License

MIT License - see LICENSE file for details.

This project incorporates templates and methodology from Cole Medin's context-engineering-intro repository, used with attribution under open source principles.

🔗 Related Resources

MCP Specification - Model Context Protocol documentation
Cole's Context Engineering - Original methodology
Archon MCP - Task and knowledge management integration
Claude Desktop - Primary MCP client

📞 Support & Issues

Issues: Report bugs and feature requests via GitHub Issues
Discussions: Use GitHub Discussions for questions and ideas
Documentation: Comprehensive docs in the /docs directory (coming soon)

Made with ❤️ by the Locomotive Agency team, built upon Cole Medin's excellent foundation

Name		Name	Last commit message	Last commit date
Latest commit History 29 Commits
.github		.github
data		data
external/context-engineering-intro		external/context-engineering-intro
scripts		scripts
src		src
templates		templates
test-fixtures		test-fixtures
test		test
.eslintrc.js		.eslintrc.js
.gitignore		.gitignore
.prettierrc		.prettierrc
CLAUDE.md		CLAUDE.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
demo-integration.js		demo-integration.js
jest.config.js		jest.config.js
package-lock.json		package-lock.json
package.json		package.json
tsconfig.json		tsconfig.json
verify-installation.js		verify-installation.js

License

croakingtoad/context-engineering-mcp

Folders and files

Latest commit

History

Repository files navigation