Mcp Code Execution

---
name: mcp-code-execution
description: Transform tool-heavy workflows into MCP code execution patterns
  using MECW principles for optimized token savings and hallucination prevention.
location: plugin
token_budget: 200  # Reduced for core hub functionality
progressive_loading: true
dependencies:
  hub: [context-optimization, token-conservation]
  modules: [mcp-subagents, mcp-patterns, mcp-validation]
---

# MCP Code Execution Hub

## Quick Start
Use specialized MCP modules for specific tasks:
- mcp-subagents for workflow decomposition
- mcp-patterns for transformation templates
- mcp-validation for hallucination prevention

## When to Use
- **Automatic**: Keywords: `code execution`, `MCP`, `tool chain`, `data pipeline`, `MECW`
- **Tool Chains**: >3 tools chained sequentially
- **Data Processing**: Large datasets (>10k rows) or files (>50KB)
- **Context Pressure**: Current usage >25% of total window (proactive context management)

## Core Hub Responsibilities
- Orchestrates MCP code execution workflow
- Routes to appropriate specialized modules
- Coordinates MECW compliance across submodules
- Manages token budget allocation for submodules

## Required TodoWrite Items
1. `mcp-code-execution:assess-workflow`
2. `mcp-code-execution:route-to-modules`
3. `mcp-code-execution:coordinate-mecw`
4. `mcp-code-execution:synthesize-results`

## Step 1 – Assess Workflow (`mcp-code-execution:assess-workflow`)

### Workflow Classification
```python
def classify_workflow_for_mecw(workflow):
    """Determine appropriate MCP modules and MECW strategy"""

    if has_tool_chains(workflow) and workflow.complexity == 'high':
        return {
            'modules': ['mcp-subagents', 'mcp-patterns'],
            'mecw_strategy': 'aggressive',
            'token_budget': 600
        }
    elif workflow.data_size > '10k_rows':
        return {
            'modules': ['mcp-patterns', 'mcp-validation'],
            'mecw_strategy': 'moderate',
            'token_budget': 400
        }
    else:
        return {
            'modules': ['mcp-patterns'],
            'mecw_strategy': 'conservative',
            'token_budget': 200
        }
```

### MECW Risk Assessment
Delegate to mcp-validation module for detailed risk analysis:
```python
def delegate_mecw_assessment(workflow):
    return mcp_validation_assess_mecw_risk(
        workflow,
        hub_allocated_tokens=self.token_budget * 0.5
    )
```

## Step 2 – Route to Modules (`mcp-code-execution:route-to-modules`)

### Module Orchestration
```python
class MCPExecutionHub:
    def __init__(self):
        self.modules = {
            'mcp-subagents': MCPSubagentsModule(),
            'mcp-patterns': MCPatternsModule(),
            'mcp-validation': MCPValidationModule()
        }

    def execute_workflow(self, workflow, classification):
        results = []

        # Execute modules in optimal order
        for module_name in classification['modules']:
            module = self.modules[module_name]
            result = module.execute(
                workflow,
                mecw_budget=classification['token_budget'] //
                len(classification['modules'])
            )
            results.append(result)

        return self.synthesize_results(results)
```

## Step 3 – Coordinate MECW (`mcp-code-execution:coordinate-mecw`)

### Cross-Module MECW Management
- Monitor total context usage across all modules
- Enforce 50% context rule globally
- Coordinate external state management
- Implement MECW emergency protocols

## Step 4 – Synthesize Results (`mcp-code-execution:synthesize-results`)

### Result Integration
```python
def synthesize_module_results(module_results):
    """Combine results from MCP modules into structured output"""

    return {
        'status': 'completed',
        'token_savings': calculate_savings(module_results),
        'mecw_compliance': verify_mecw_rules(module_results),
        'hallucination_risk': assess_hallucination_prevention(module_results),
        'results': consolidate_results(module_results)
    }
```

## Module Integration

### With Context Optimization Hub
- Receives high-level MECW strategy from context-optimization
- Returns detailed execution metrics and compliance data
- Coordinates token budget allocation

### Performance Skills Integration
- Leverages python-performance-optimization through mcp-patterns
- Aligns with cpu-gpu-performance for resource-aware execution
- Ensures optimizations maintain MECW compliance

## Emergency Protocols

### Hub-Level Emergency Response
When MECW limits exceeded:
1. Delegates immediately to mcp-validation for risk assessment
2. Route to mcp-subagents for further decomposition
3. Apply compression through mcp-patterns
4. Return minimal summary to preserve context

## Success Metrics
- **Workflow Success Rate**: >95% successful module coordination
- **MECW Compliance**: 100% adherence to 50% context rule
- **Token Efficiency**: Maintain >80% savings vs traditional methods
- **Module Coordination**: <5% overhead for hub orchestration