mcp-builder · diff
v1.0.0 to v1.0.0
1 added, 1 removed. Audit A to A.
---
name: mcp-builder
description: Dynamic MCP server builder that creates custom tools when existing capabilities can't handle specific tasks, with full Vodou integration
version: 1.0.0
kind: workflow
required_tools: []
trigger_phrases:
- "build mcp server"
- "create mcp for task"
- "need custom mcp"
- "generate mcp server"
- "build tool for [specific task]"
- "custom mcp server"
- "make mcp server"
stopping_points: required
actions: inline
imported_from:
source: hand-written
metadata:
vodou:
preservation_reason: user-preserved 2026-04-25
---
# Vodou MCP Builder - Dynamic Tool Creation Engine
## Overview
This skill transforms Vodou from a tool orchestrator into a **tool creator**. When existing MCP servers can't handle a specific task, this skill analyzes requirements, generates complete MCP servers with proper protocol compliance, and integrates them seamlessly into the Vodou ecosystem.
**The Innovation**: Dynamic capability expansion - Vodou builds new tools as needed, making the platform infinitely extensible.
## Core Workflow: Research → Analyze → Design → Build → Integrate
### 🔍 **Step 1: Intelligent Requirement Analysis**
**⏸️ STOPPING POINT - Research Approach Selection:**
I'll research [target] comprehensively before building. Let me analyze:
**Deep Thinking Research Options:**
- **Target System Analysis**: `./do deep think about [target] integration patterns`
- **Security Research**: `./do deep think about [target] security considerations`
- **Architecture Research**: `./do deep think about optimal MCP architecture for [target]`
- **Performance Research**: `./do deep think about [target] rate limiting and optimization`
**Real-Time System Analysis:**
- **System Capabilities**: Current system resources and network (mcp-monitor)
- **Codebase context**: Vodou memory (MEMORY.md / daily logs) + `rg` / editor — no shipped codebase MCP
- **Connection Assessment**: Network capabilities and constraints
**Research Depth Options:**
1. **Quick Build** - Use my current knowledge (5 minutes)
2. **Smart Research** - AI-driven analysis of target + system (15 minutes)
3. **Deep Research** - Comprehensive multi-perspective analysis (30 minutes)
4. **Collaborative Research** - Research together with your guidance
**Which research approach would you prefer?**
<!-- AGENT_ACTIONS: {"stopping_points": [
{
"id": 1,
"title": "Research Approach Selection",
"options": {
"2": {"label":"Smart Research","vars":{"DEPTH":"10"},"steps":[
{"server":"Vodou-Enhanced-Thinking","tool":"start_thinking_session","args":{"topic":"{{TOPIC}} API integration best practices and MCP server architecture","depth":"{{DEPTH}}"},"capture":{"SESSION_ID":"session_id"}},
{"server":"Vodou-Enhanced-Thinking","tool":"add_thought","args":{"session_id":"{{SESSION_ID}}","thought":"{{LLM:Analyze security considerations and rate limiting for {{TOPIC}}}}","thoughtNumber":"{{i}}","totalThoughts":3,"nextThoughtNeeded":true},"loop":2},
{"server":"Vodou-Enhanced-Thinking","tool":"add_thought","args":{"session_id":"{{SESSION_ID}}","thought":"{{LLM:Synthesize research into concrete MCP server architecture with tools, parameters, and error handling for {{TOPIC}}}}","thoughtNumber":3,"totalThoughts":3,"nextThoughtNeeded":false}},
{"server":"mcp-monitor","tool":"get_host_info","args":{}}
]},
"3": {"label":"Deep Research","vars":{"DEPTH":"15"},"steps":[
{"server":"Vodou-Enhanced-Thinking","tool":"start_thinking_session","args":{"topic":"Comprehensive analysis of {{TOPIC}} for MCP server creation","depth":"{{DEPTH}}"},"capture":{"SESSION_ID":"session_id"}},
{"server":"Vodou-Enhanced-Thinking","tool":"add_thought","args":{"session_id":"{{SESSION_ID}}","thought":"{{LLM:Deep analysis of {{TOPIC}} — security, authentication, rate limiting, API patterns, and architecture decisions}}","thoughtNumber":"{{i}}","totalThoughts":6,"nextThoughtNeeded":true},"loop":5,"stream_progress":true},
{"server":"Vodou-Enhanced-Thinking","tool":"add_thought","args":{"session_id":"{{SESSION_ID}}","thought":"{{LLM:Synthesize all research into optimal MCP architecture for {{TOPIC}}}}","thoughtNumber":6,"totalThoughts":6,"nextThoughtNeeded":false}},
{"server":"mcp-monitor","tool":"get_host_info","args":{}}
]}
}
}
]} -->
*Quick build is fastest, but Smart/Deep research produces dramatically better, more secure, and optimized results.*
### 🧠 **Step 1.5: AI-Driven Deep Research (NEW)**
When Smart/Deep research is selected, I'll conduct comprehensive analysis:
#### **Phase 1: Target System Deep Research**
```bash
# Research target integration patterns
./do "deep think about [target] API integration best practices"
# Analyze security considerations
./do "deep think about [target] security patterns and vulnerabilities"
# Research optimal architecture
./do "deep think about MCP server architecture for [target] integration"
# Performance and scalability analysis
./do "deep think about [target] rate limiting and performance optimization"
```
#### **Phase 2: Real-Time System Analysis**
```bash
# Analyze current system capabilities
- ./vodou-core call mcp-monitor get_system_info
+ ./vodou-core call mcp-monitor get_host_info
./vodou-core call mcp-monitor get_network_info
./vodou-core call mcp-monitor get_performance_baseline
# Check existing patterns: memory files + search
grep -nE "pattern|integration|{{TOPIC}}" .vodou/workspace/MEMORY.md 2>/dev/null || true
rg -n "[target]" src/ 2>/dev/null | head -30 || true
```
#### **Phase 3: Enhanced Thinking Session**
```bash
# Start comprehensive analysis session
./vodou-core call Vodou-Enhanced-Thinking start_thinking_session '{
"topic": "Optimal MCP architecture for [target] integration",
"context": "Building production-ready MCP server with security, performance, and maintainability"
}'
# Add research findings
./vodou-core call Vodou-Enhanced-Thinking add_thought '{
"session_id": "[session_id]",
"thought": "Research findings: [target] requires [auth method], has [rate limits], supports [features]..."
}'
# Analyze and synthesize
./vodou-core call Vodou-Enhanced-Thinking analyze_thinking '{
"session_id": "[session_id]"
}'
```
#### **Phase 4: Multi-Perspective Analysis**
- **Technical Perspective**: Implementation complexity, dependencies, maintenance
- **Security Perspective**: Authentication, data protection, compliance requirements
- **Performance Perspective**: Scalability, caching, rate limiting, error handling
- **Operational Perspective**: Monitoring, logging, deployment, updates
**⏸️ STOPPING POINT - Research Synthesis:**
"Based on comprehensive research, here's what I've discovered:
**[Target] Analysis Summary:**
- **Integration Patterns**: [Best practices found]
- **Security Requirements**: [Auth methods, data protection]
- **Performance Considerations**: [Rate limits, caching strategies]
- **System Compatibility**: [Current system assessment]
- **Recommended Architecture**: [Optimal approach]
**Research-Driven Recommendations:**
1. **Implementation Language**: [Python/Node.js/Rust] - [reasoning based on research]
2. **Architecture Pattern**: [Recommended pattern with justification]
3. **Security Approach**: [Research-backed security design]
4. **Performance Strategy**: [Optimization based on analysis]
5. **Integration Method**: [Best approach for your system]
**Proceed with this research-optimized architecture, or would you like to:**
- **Explore alternatives** - Research different approaches
- **Deep dive** - More detailed analysis of specific aspects
- **Customize** - Adjust recommendations based on your preferences
- **Build immediately** - Proceed with research-optimized design"
### 🔍 **Step 2: Enhanced Requirement Validation**
After research, I'll validate specific requirements:
**1. Target Integration Confirmation:**
- Confirmed: [Target] with [specific features]
- Authentication: [Method determined from research]
- Rate Limits: [Discovered limits and handling strategy]
- Security: [Research-backed security requirements]
**2. System Integration Requirements:**
- Deployment environment: [Based on system analysis]
- Performance targets: [Based on current system capabilities]
- Monitoring needs: [Based on operational analysis]
- Error handling: [Research-informed approach]
**3. Vodou Integration Optimization:**
- Natural language triggers: [Optimized based on user patterns]
- Parameter extraction: [Smart parameter handling]
- Parallel compatibility: [System-aware optimization]
- Caching strategy: [Performance-optimized]
**Your research-informed architecture will be dramatically more robust, secure, and performant than basic implementations.**
### 🎨 **Step 3: Research-Driven Architecture Design**
Based on comprehensive research and analysis, I'll design the optimal architecture:
#### **Research-Informed Design Decisions:**
**Implementation Language (Research-Driven):**
- **Python**: Chosen because research shows [target] has excellent Python libraries, strong security frameworks, and [specific advantages]
- **Node.js**: Selected because [target] offers Node.js SDKs, real-time requirements, and [research findings]
- **Rust**: Recommended because performance analysis shows [target] requires [specific performance characteristics]
**Security Architecture (Research-Based):**
- **Authentication**: [Research-discovered method] with [specific implementation]
- **Data Protection**: [Security patterns found in research]
- **Rate Limiting**: [Research-informed rate limiting strategy]
- **Error Handling**: [Security-focused error handling based on analysis]
**Performance Architecture (Analysis-Driven):**
- **Caching Strategy**: [Research-optimized caching approach]
- **Connection Pooling**: [Analysis-based connection management]
- **Async Operations**: [Performance-optimized async patterns]
- **Monitoring**: [Research-recommended monitoring approach]
**Vodou Integration Architecture (Intelligence-Enhanced):**
- **Intent Mappings**: [Smart trigger phrases based on user pattern analysis]
- **Parameter Extraction**: [Research-informed parameter handling]
- **Parallel Compatibility**: [System-aware parallel execution design]
- **Error Recovery**: [Robust error handling based on system analysis]
#### **Research Synthesis Integration:**
```bash
# Complete the enhanced thinking analysis
./vodou-core call Vodou-Enhanced-Thinking add_thought '{
"session_id": "[session_id]",
"thought": "Synthesizing architecture: Based on [target] research, optimal approach is [architecture] because [reasoning from multiple analyses]..."
}'
# Finalize architecture decision
./vodou-core call Vodou-Enhanced-Thinking complete_thinking_session '{
"session_id": "[session_id]",
"final_synthesis": "Recommended architecture: [final decision with full research backing]"
}'
```
**⏸️ STOPPING POINT - Research-Optimized Architecture Review:**
"Based on comprehensive research and analysis, here's the optimized architecture:
**MCP Server: [Research-Informed Name]**
- **Language**: [Language] - Chosen because research shows [specific advantages for target]
- **Tools**: [Research-optimized tool list] - Designed based on [target] best practices
- **Security**: [Research-backed security approach] - Implements [specific security patterns]
- **Performance**: [Analysis-driven performance strategy] - Optimized for [specific requirements]
- **Integration**: [Intelligence-enhanced Vodou integration] - Uses [smart patterns]
**Research Findings Applied:**
- **[Target] Best Practices**: [Specific patterns discovered and applied]
- **Security Considerations**: [Research-identified security requirements implemented]
- **Performance Optimizations**: [Analysis-driven optimizations included]
- **System Compatibility**: [Current system analysis results applied]
**Natural Language Examples (Intelligence-Optimized):**
- `./do "[research-optimized trigger phrase]"`
- `./do "[intelligent parameter handling example]"`
- `./do "[advanced usage pattern from research]"`
**Architecture Quality Score**: Based on research depth and system analysis
- **Security**: [Score/10] - [Research-backed security assessment]
- **Performance**: [Score/10] - [Analysis-driven performance assessment]
- **Maintainability**: [Score/10] - [Research-informed maintainability assessment]
- **Integration**: [Score/10] - [Intelligence-enhanced integration assessment]
**Proceed with this research-optimized architecture, or would you like to:**
1. **Build immediately** - Proceed with research-optimized design
2. **Refine further** - Additional research on specific aspects
3. **Alternative analysis** - Explore different architectural approaches
4. **Custom adjustments** - Modify based on your specific requirements"
**Only proceed to code generation after architecture approval.**
### ⚡ **Step 4: Research-Enhanced Parallel Code Generation**
Once research-optimized architecture is approved, I'll generate the enhanced MCP server:
#### **Research-Enhanced Code Generation Process:**
```bash
# Phase 1: Apply research insights to templates
./vodou-core call Vodou-Enhanced-Thinking get_thought_context '{"session_id": "[session_id]"}'
# Phase 2: Generate components with research optimizations
./do "generate-research-enhanced-mcp-server [target] [architecture-insights]"
# Phase 3: Create all components in parallel with intelligence:
# 1. Research-optimized MCP server implementation
# 2. Security-enhanced Vodou manifest (oi-manifest.json) with intelligent intent mappings
# 3. Performance-optimized installation script
# 4. Comprehensive test suite with research-backed test cases
# 5. Production-ready configuration with discovered best practices
# 6. Documentation with research findings and usage patterns
```
**Research-Enhanced Code Generation Includes:**
**Core Implementation (Research-Driven):**
- **MCP Protocol Compliance**: Enhanced with [target]-specific optimizations
- **Security Hardening**: Research-discovered security patterns implemented
- **Performance Optimization**: Analysis-driven caching, connection pooling, async operations
- **Error Handling**: Research-informed error patterns and recovery strategies
- **Rate Limiting**: Target-specific rate limiting based on API research
- **Monitoring Integration**: Research-recommended monitoring and logging
**Intelligence-Enhanced Features:**
- **Smart Authentication**: Research-optimized auth flows with token management
- **Adaptive Caching**: Performance-analysis-driven caching strategies
- **Intelligent Retries**: Research-based retry patterns with exponential backoff
- **Circuit Breakers**: System-analysis-informed circuit breaker patterns
- **Health Checks**: Comprehensive health monitoring based on operational research
**Vodou Integration (Intelligence-Optimized):**
- **Smart Intent Mappings**: User-pattern-aware trigger phrases
- **Enhanced Parameter Extraction**: Research-informed parameter handling
- **Context-Aware Responses**: Intelligence-driven response formatting
- **Parallel Execution Safety**: System-analysis-optimized parallel compatibility
- **Usage Analytics**: Research-recommended usage tracking and optimization
### 📋 **Step 5: Research-Enhanced Code Structure**
**Research-Enhanced Python MCP Servers:**
```
/MCP-servers/[research-optimized-name]/
├── server.py # Research-enhanced MCP server implementation
├── requirements.txt # Research-optimized dependencies
├── oi-manifest.json # Intelligence-enhanced OI integration
├── config/
│ ├── settings.py # Research-informed configuration
│ ├── security.py # Research-backed security settings
│ └── performance.py # Analysis-driven performance config
├── tools/
│ ├── __init__.py
│ ├── [target]_core.py # Core integration tools (research-optimized)
│ ├── [target]_auth.py # Research-enhanced authentication
│ └── [target]_utils.py # Target-specific utilities
├── utils/
│ ├── __init__.py
│ ├── auth_manager.py # Research-backed auth patterns
│ ├── rate_limiter.py # Analysis-driven rate limiting
│ ├── cache_manager.py # Performance-optimized caching
│ ├── error_handler.py # Research-informed error handling
│ └── monitoring.py # Research-recommended monitoring
├── tests/
│ ├── test_server.py # Enhanced MCP protocol tests
│ ├── test_integration.py # Research-based integration tests
│ ├── test_security.py # Security-focused test suite
│ └── test_performance.py # Performance validation tests
├── docs/
│ ├── research_findings.md # Research insights and decisions
│ ├── security_guide.md # Research-backed security documentation
│ └── performance_guide.md # Analysis-driven performance guide
└── README.md # Comprehensive setup with research insights
```
**Research-Enhanced Node.js MCP Servers:**
```
/MCP-servers/[research-optimized-name]/
├── server.js # Research-enhanced main server
├── package.json # Research-optimized dependencies and scripts
├── oi-manifest.json # Intelligence-enhanced OI integration
├── config/
│ ├── default.js # Research-informed base configuration
│ ├── security.js # Research-backed security configuration
│ └── performance.js # Analysis-driven performance settings
├── src/
│ ├── tools/ # Research-optimized tool implementations
│ ├── auth/ # Research-enhanced authentication modules
│ ├── cache/ # Performance-optimized caching
│ ├── monitoring/ # Research-recommended monitoring
│ └── utils/ # Target-specific utilities
├── tests/
│ ├── integration/ # Research-based integration tests
│ ├── security/ # Security-focused test suite
│ └── performance/ # Performance validation tests
└── docs/ # Research insights and guides
```
### 🔧 **Step 6: Intelligence-Enhanced Integration and Validation**
**⏸️ STOPPING POINT - Research-Enhanced Review and Validation:**
"Your research-optimized MCP server is ready! Here's what comprehensive analysis produced:
**Research-Enhanced MCP Server: [Intelligent Name]**
- **Core Tools**: [Research-optimized tools with descriptions]
- **Security Features**: [Research-backed security implementations]
- **Performance Optimizations**: [Analysis-driven performance features]
- **Intelligence Integrations**: [Smart features based on research]
**Example Usage (Intelligence-Optimized):**
```bash
# Natural language with smart parameter extraction
./do "[research-optimized trigger phrase]"
./do "[intelligent context-aware example]"
./do "[advanced usage pattern from research]"
# Direct tool access for power users
./vodou-core call [server-name] [research-enhanced-tool]
```
**Research-Driven Quality Metrics:**
- **Security Score**: [X/10] - Based on security research and threat analysis
- **Performance Score**: [X/10] - Based on system analysis and optimization
- **Integration Score**: [X/10] - Based on Vodou ecosystem intelligence
- **Maintainability Score**: [X/10] - Based on code pattern research
**Intelligence Features Applied:**
- **Smart Authentication**: [Research-discovered auth patterns]
- **Adaptive Rate Limiting**: [Target-specific rate limiting from API research]
- **Intelligent Caching**: [Performance-analysis-driven caching]
- **Enhanced Error Handling**: [Research-backed error patterns]
- **Context-Aware Responses**: [User-pattern-aware response formatting]
**Research Insights Implemented:**
- **[Target] Best Practices**: [Specific patterns discovered and applied]
- **Security Hardening**: [Research-identified security measures implemented]
- **Performance Optimizations**: [Analysis-driven performance enhancements]
- **Integration Intelligence**: [Smart Vodou ecosystem integration]
**Validation Options:**
1. **Install & Test** - Deploy with comprehensive testing suite
2. **Security Review** - Deep security analysis before deployment
3. **Performance Testing** - Benchmark against research projections
4. **Custom Refinement** - Adjust based on additional requirements
5. **Research Deep Dive** - Explore specific aspects further
**Recommended**: Install & Test - The research process has optimized this implementation for production readiness."
#### **Enhanced Validation Process:**
```bash
# Validate against research findings
./vodou-core call Vodou-Enhanced-Thinking analyze_thinking '{
"session_id": "[session_id]",
"validation_mode": true
}'
# Performance validation against system analysis
./vodou-core call mcp-monitor get_performance_baseline
# Security validation against research
./do "security audit [server-name] against [target] security research"
```
### 🚀 **Step 7: Intelligence-Guided Installation and Optimization**
Once validation is approved, I'll complete the intelligence-guided installation:
#### **Research-Enhanced Installation Process:**
```bash
# Phase 1: Pre-installation system optimization
./vodou-core call mcp-monitor get_system_readiness
./do "optimize system for [target] integration"
# Phase 2: Install with research-enhanced configuration
./do "install-research-enhanced-mcp [server-name] [research-insights]"
# Phase 3: Intelligence-guided configuration
./vodou-core call Vodou-Enhanced-Thinking get_thought_context '{"session_id": "[session_id]"}'
./do "apply-research-config [server-name] [performance-optimizations]"
# Phase 4: Comprehensive validation suite
./do "validate-mcp-installation [server-name] [research-benchmarks]"
# Phase 5: Smart intent mapping activation
./do "activate-intelligent-intents [server-name] [user-pattern-analysis]"
```
#### **Intelligence-Enhanced Post-Installation Validation:**
**Comprehensive Validation Suite:**
- **MCP Protocol Compliance**: Enhanced validation with [target]-specific tests
- **Security Validation**: Research-backed security testing
- **Performance Benchmarking**: Analysis-driven performance validation
- **Integration Testing**: Intelligence-enhanced Vodou ecosystem tests
- **Load Testing**: Research-informed load and stress testing
- **User Pattern Testing**: Smart intent mapping validation
**Continuous Intelligence Integration:**
```bash
./do "log: feature: Integrated [target] MCP | notes: [optimizations]"
./do "enable-adaptive-optimization [server-name]"
```
**Research-Driven Monitoring Setup:**
- **Performance Monitoring**: Research-recommended metrics tracking
- **Security Monitoring**: Research-informed security alerting
- **Usage Analytics**: Intelligence-driven usage pattern analysis
- **Optimization Recommendations**: Continuous improvement suggestions
## Research-Enhanced MCP Building Patterns
### 🧠 **Enhanced Intelligence Integration Patterns**
#### **Pattern 0: Pre-Build Intelligence Gathering**
**Use Case**: Any MCP server development
**Research Process:**
```bash
# Multi-perspective deep research
./do "deep think about [target] from security perspective"
./do "deep think about [target] from performance perspective"
./do "deep think about [target] from integration perspective"
./do "deep think about [target] from operational perspective"
# System analysis
./vodou-core call mcp-monitor get_comprehensive_system_analysis
grep -n "[target]" .vodou/workspace/MEMORY.md 2>/dev/null || true
# Enhanced thinking synthesis
./vodou-core call Vodou-Enhanced-Thinking start_thinking_session '{
"topic": "Optimal [target] MCP architecture",
"context": "Production deployment with security and performance priorities"
}'
```
**Research-Driven Architecture:**
```python
# Generated architecture incorporates ALL research findings
# Security: [Research-discovered security patterns]
# Performance: [Analysis-driven optimizations]
# Integration: [Intelligence-enhanced Vodou compatibility]
# Monitoring: [Research-recommended observability]
```
## Advanced Research-Enhanced Building Patterns
### Pattern 1: Research-Enhanced API Integration MCP
**Use Case**: "Build MCP for Slack integration"
**Research Process:**
```bash
# Comprehensive Slack research
./do "deep think about Slack API integration patterns and best practices"
./do "deep think about Slack OAuth security patterns and token management"
./do "deep think about Slack rate limiting and performance optimization"
./do "deep think about Slack webhook security and validation patterns"
```
**Research-Enhanced Architecture:**
```python
# Research-Discovered Tools:
# - send_message (with advanced formatting and thread support)
# - get_channels (with pagination and filtering)
# - create_channel (with template support and permissions)
# - manage_users (with role-based access)
# - webhook_handler (with signature verification)
# - file_upload (with virus scanning integration)
# Research-Backed Security:
# - OAuth 2.0 with PKCE and token rotation
# - Webhook signature verification
# - Rate limiting with exponential backoff
# - Input sanitization and XSS prevention
# - Audit logging for compliance
# Performance Optimizations:
# - Intelligent connection pooling
# - Response caching with TTL
# - Bulk operation batching
# - Circuit breaker pattern
```
**Intelligence-Enhanced Natural Language Integration:**
```bash
# Basic usage (research-optimized)
./do "send slack message to #general: Hello team!"
./do "get slack channels and filter by active users"
./do "create slack channel for project-updates with dev team access"
# Advanced usage (research-discovered patterns)
./do "send slack message with formatting and thread to #general"
./do "bulk upload files to slack with virus scanning"
./do "set up slack webhook listener with security validation"
./do "manage slack workspace permissions for user onboarding"
```
### Pattern 2: Research-Enhanced Database Integration MCP
**Use Case**: "Build MCP for PostgreSQL reporting"
**Research Process:**
```bash
# Comprehensive database security research
./do "deep think about PostgreSQL security best practices and threat mitigation"
./do "deep think about database performance optimization and indexing strategies"
./do "deep think about SQL injection prevention and query validation"
./do "deep think about database monitoring and alerting patterns"
```
**Research-Enhanced Architecture:**
```python
# Research-Discovered Tools:
# - execute_secure_query (with SQL injection prevention)
# - get_schema_analysis (with performance recommendations)
# - generate_intelligent_report (with data visualization)
# - backup_with_encryption (with compression and verification)
# - monitor_performance (with query optimization suggestions)
# - audit_access (with compliance logging)
# Research-Backed Security:
# - Connection pooling with SSL/TLS encryption
# - Parameterized queries with input validation
# - Role-based access control (RBAC)
# - Query timeout and resource limiting
# - Audit trail with tamper detection
# - Data masking for sensitive information
# Performance Intelligence:
# - Query plan analysis and optimization
# - Intelligent caching with invalidation
# - Connection pool sizing based on load
# - Result streaming for large datasets
# - Index usage recommendations
```
**Intelligence-Enhanced Natural Language Integration:**
```bash
# Basic usage (research-optimized)
./do "securely query database for sales data last month"
./do "generate report on user signups with visualizations"
./do "backup users table with encryption verification"
# Advanced usage (research-discovered patterns)
./do "analyze database performance and suggest index optimizations"
./do "generate compliance report with data masking for PII"
./do "monitor database health and alert on performance degradation"
./do "execute complex analytical query with result streaming"
```
### Pattern 3: Research-Enhanced Monitoring MCP
**Use Case**: "Build MCP for log monitoring and alerting"
**Generated Architecture:**
```python
# Tools: analyze_logs, set_alert, get_metrics, generate_summary
# Real-time: WebSocket integration for live monitoring
# Intelligence: Pattern recognition, anomaly detection
# Actions: Auto-response to critical alerts
```
**Natural Language Integration:**
```bash
./do "analyze error logs from last hour"
./do "set alert for high CPU usage"
./do "summarize system health"
```
### Pattern 4: Custom Business Logic MCP
**Use Case**: "Build MCP for complex pricing calculations"
**Generated Architecture:**
```python
# Tools: calculate_price, apply_discounts, get_rules, update_pricing
# Business Logic: Complex pricing algorithms, rule engines
# Integration: Multiple data sources, external validation
# Caching: Performance optimization for repeated calculations
```
## Code Generation Templates
### Template 1: Python MCP Server Base
```python
#!/usr/bin/env python3
"""
{SERVER_NAME} - Custom MCP Server
Generated by Vodou MCP Builder
"""
import asyncio
import json
from typing import Dict, Any, List, Optional
from mcp.server import Server
from mcp.types import Resource, Tool, TextContent
# Custom imports based on requirements
{CUSTOM_IMPORTS}
class {CLASS_NAME}MCPServer:
def __init__(self):
self.server = Server("{SERVER_NAME}")
self.setup_tools()
self.setup_resources()
{CUSTOM_INIT}
def setup_tools(self):
"""Register all MCP tools"""
{TOOL_REGISTRATIONS}
async def {TOOL_NAME}(self, arguments: Dict[str, Any]) -> List[TextContent]:
"""
{TOOL_DESCRIPTION}
"""
try:
# Input validation
{INPUT_VALIDATION}
# Tool implementation
{TOOL_IMPLEMENTATION}
# Return results
return [TextContent(
type="text",
text=json.dumps(result, indent=2)
)]
except Exception as e:
return [TextContent(
type="text",
text=f"Error: {str(e)}"
)]
# Server startup
if __name__ == "__main__":
server = {CLASS_NAME}MCPServer()
asyncio.run(server.server.run())
```
### Template 2: Vodou manifest (oi-manifest.json) Generation
```json
{
"server_name": "{SERVER_NAME}",
"version": "1.0.0",
"description": "{DESCRIPTION}",
"intents": [
{GENERATED_INTENTS}
],
"parameter_extractors": {
{GENERATED_EXTRACTORS}
},
"reminder_message": "{REMINDER_MESSAGE}"
}
```
### Template 3: Installation Script
```bash
#!/bin/bash
# Auto-generated installation script for {SERVER_NAME}
echo "🚀 Installing {SERVER_NAME} MCP Server..."
# Install dependencies
{DEPENDENCY_INSTALLATION}
# Copy server files
cp -r . "/path/to/MCP-servers/{SERVER_NAME}/"
# Install Vodou integration
./do "install-mcp-from-manifest {SERVER_NAME}"
# Test installation
./do "test-mcp {SERVER_NAME}"
echo "✅ {SERVER_NAME} MCP Server installed successfully!"
echo "Try: ./?do '{EXAMPLE_USAGE}'"
```
## Research-Enhanced Interactive Development Examples
### Example 1: Research-Driven Cryptocurrency Price Tracker
**User Request**: "oi build mcp server for cryptocurrency price tracking"
**Enhanced Skill Response**:
"I'll research cryptocurrency APIs and build an optimized tracking MCP server. Let me conduct comprehensive analysis:
**🔍 Research Phase (Recommended):**
```bash
# Deep API research
./do "deep think about cryptocurrency API comparison and security considerations"
./do "deep think about crypto data reliability and rate limiting strategies"
./do "deep think about cryptocurrency price prediction and analytics patterns"
```
**🔴 Real-Time Analysis:**
```bash
# System capability assessment
./vodou-core call mcp-monitor get_network_capabilities
./vodou-core call mcp-monitor get_performance_baseline
```
**Research Findings Applied:**
**Data Sources (Research-Optimized):**
1. **Multi-API Strategy** - Research shows redundancy prevents outages
2. **CoinGecko + CoinMarketCap** - Optimal balance of free + premium data
3. **WebSocket + REST Hybrid** - Research-backed performance pattern
4. **Intelligent Failover** - Research-discovered resilience patterns
**Security Enhancements (Research-Driven):**
- **API Key Rotation** - Security research recommendation
- **Rate Limit Intelligence** - Research-optimized throttling
- **Data Validation** - Research-backed input sanitization
- **Audit Logging** - Compliance research findings
**Performance Intelligence (Analysis-Driven):**
- **Adaptive Caching** - System-analysis-optimized caching
- **Connection Pooling** - Performance-research-backed pooling
- **Circuit Breakers** - Research-recommended fault tolerance
- **Load Balancing** - Multi-API intelligent routing
**Research-Enhanced Architecture:**
```python
# Research-Optimized Tools:
# - get_multi_source_price (aggregates multiple APIs)
# - get_validated_history (with data integrity checks)
# - get_predictive_analytics (research-backed algorithms)
# - set_intelligent_alerts (with smart thresholds)
# - get_market_sentiment (research-enhanced analysis)
# - monitor_api_health (with automatic failover)
```
**Installation with Intelligence:**
```bash
./do "install-research-enhanced-crypto-mcp"
# Now available (intelligence-optimized):
./do "get reliable bitcoin price with validation"
./do "analyze ethereum trends with predictive insights"
./do "monitor crypto market with intelligent alerts"
./do "get portfolio analysis with risk assessment"
```
### Example 2: Research-Enhanced Database Reporting Tool
**User Request**: "oi create mcp for generating sales reports from PostgreSQL"
**Enhanced Skill Response**:
"I'll research PostgreSQL best practices and create a production-ready reporting MCP server.
**🔍 Comprehensive Research Phase:**
```bash
# Database security research
./do "deep think about PostgreSQL security hardening and access control"
./do "deep think about SQL injection prevention and query validation"
./do "deep think about database performance optimization for reporting"
./do "deep think about data privacy and compliance for sales reporting"
```
**🔴 System Analysis:**
```bash
# Analyze existing database patterns
grep -n "reporting\\|postgres" .vodou/workspace/MEMORY.md 2>/dev/null || true
./vodou-core call mcp-monitor get_system_resources
```
**Research-Driven Configuration:**
**Security Architecture (Research-Enhanced):**
- **Zero-Trust Database Access** - Research-backed security model
- **Query Sanitization** - SQL injection research findings applied
- **Role-Based Permissions** - Security research recommendations
- **Audit Trail Compliance** - Research-informed logging
- **Data Masking** - Privacy research applications
**Performance Intelligence (Analysis-Driven):**
- **Query Optimization** - Database research patterns
- **Result Caching** - Performance-analysis-optimized
- **Connection Pooling** - Research-backed pool sizing
- **Streaming Results** - Memory-efficiency research
**Research-Enhanced Features:**
```python
# Research-Optimized Tools:
# - generate_secure_report (with data masking)
# - execute_validated_query (with injection prevention)
# - export_encrypted_data (with compliance features)
# - schedule_intelligent_reports (with optimization)
# - analyze_query_performance (with suggestions)
# - monitor_database_health (with alerting)
```
**Intelligence-Guided Installation:**
```bash
./do "install-research-enhanced-db-reporter"
# Now available (research-optimized):
./do "generate secure sales report with data masking"
./do "execute validated custom query with performance analysis"
./do "export encrypted sales data with compliance audit"
./do "schedule intelligent reports with optimization"
```
## Research-Enhanced Development Methodology
### 🔬 **The Intelligence Advantage**
**Traditional MCP Building:**
- ❌ Basic Q&A requirements gathering
- ❌ Generic architecture decisions
- ❌ Trial-and-error optimization
- ❌ Reactive security considerations
- ❌ Manual performance tuning
**Research-Enhanced MCP Building:**
- ✅ **Deep Research Phase** - Comprehensive target analysis
- ✅ **Intelligence Integration** - Vodou ecosystem intelligence applied
- ✅ **Multi-Perspective Analysis** - Security, performance, integration, operations
- ✅ **Proactive Optimization** - Research-driven design decisions
- ✅ **Continuous Intelligence** - Adaptive optimization and learning
**Quality Improvements:**
- **Security**: 10x improvement through research-backed security patterns
- **Performance**: 5-7x improvement through analysis-driven optimization
- **Reliability**: 15x improvement through research-informed error handling
- **Maintainability**: 8x improvement through intelligence-guided architecture
## Research-Enhanced Best Practices for Generated MCPs
### Research-Enhanced Security
- **Threat Modeling**: Research-driven threat analysis and mitigation
- **Input Validation**: Multi-layer validation with research-backed patterns
- **Authentication**: Research-optimized auth flows with security hardening
- **Authorization**: Role-based access with research-informed permissions
- **Rate Limiting**: Intelligence-driven rate limiting with adaptive thresholds
- **Audit Logging**: Compliance-ready logging based on security research
- **Vulnerability Assessment**: Proactive security validation
### Intelligence-Driven Performance
- **Adaptive Caching**: Research-optimized caching with intelligent invalidation
- **Smart Connection Pooling**: Analysis-driven pool sizing and management
- **Async Operations**: Research-backed async patterns for optimal performance
- **Error Handling**: Research-informed error patterns with graceful recovery
- **Circuit Breakers**: Intelligence-guided fault tolerance patterns
- **Performance Monitoring**: Research-recommended metrics and alerting
- **Load Balancing**: Research-optimized request distribution
### Enhanced Vodou Integration
- **Natural Language**: User-pattern-aware trigger phrases
- **Parallel Safe**: System-analysis-optimized parallel execution
- **Parameter Extraction**: Intelligence-enhanced parameter parsing
- **Result Formatting**: Context-aware response formatting
- **Intent Optimization**: Research-backed intent mapping strategies
- **Usage Analytics**: Intelligence-driven usage pattern analysis
- **Adaptive Responses**: User-behavior-optimized interactions
### Research-Backed Maintenance
- **Intelligent Logging**: Research-recommended log levels and structured logging
- **Proactive Monitoring**: Research-driven health checks and predictive alerts
- **Automated Updates**: Intelligence-guided version management
- **Self-Documenting**: Research-enhanced documentation generation
- **Performance Optimization**: Continuous intelligence-driven improvements
- **Security Updates**: Research-backed security patch management
- **Operational Intelligence**: Research-informed operational best practices
## Advanced Features
### 1. **AI-Assisted Code Generation**
```bash
# Generate intelligent MCP server based on natural language description
./do "build smart mcp that learns user preferences and optimizes API calls"
```
### 2. **Multi-Service Integration**
```bash
# Create MCP that combines multiple services
./do "build mcp that syncs data between Salesforce and HubSpot"
```
### 3. **Real-time Capabilities**
```bash
# Generate MCP with WebSocket support
./do "build mcp for real-time chat integration with Slack and Teams"
```
### 4. **Machine Learning Integration**
```bash
# Create MCP with ML capabilities
./do "build mcp that analyzes customer sentiment from support tickets"
```
## Troubleshooting Generated MCPs
### Common Issues and Solutions
**MCP Server Won't Start:**
```bash
# Debug generated server
./do "debug-mcp [server-name]"
# Check logs
./do "mcp-logs [server-name]"
# Validate configuration
./do "validate-mcp [server-name]"
```
**Intent Mappings Not Working:**
```bash
# Refresh intent database
./do "reload-mcp-intents [server-name]"
# Test specific intents
./do "test-intent [trigger-phrase]"
```
**Performance Issues:**
```bash
# Analyze MCP performance
./do "analyze-mcp-performance [server-name]"
# Optimize configuration
./do "optimize-mcp [server-name]"
```
## Quick Reference
### Build New MCP Server
```bash
# Start the building process
./do "build mcp server"
# Specific task
./do "build mcp for [specific task]"
# Quick generation (uses defaults)
./do "quick build mcp for [simple task]"
```
### Manage Generated MCPs
```bash
# List custom MCPs
./do "list custom mcps"
# Update existing MCP
./do "update mcp [server-name]"
# Remove MCP
./do "remove mcp [server-name]"
```
### Integration Commands
```bash
# Test MCP integration
./do "test mcp [server-name]"
# Validate Vodou integration
./do "validate oi integration [server-name]"
# Performance check
./do "benchmark mcp [server-name]"
```
## Remember: The Power of Research-Enhanced Dynamic Tool Creation
This enhanced skill transforms Vodou from a powerful orchestrator into an **infinitely intelligent and expandable platform**:
### 🧠 **Intelligence-Driven Capabilities**
- **Any Task**: If Vodou can't do it, Vodou researches and builds the optimal solution
- **Research-Backed Architecture**: Every MCP server built with comprehensive analysis
- **Security-First Design**: Research-driven security patterns applied automatically
- **Performance-Optimized**: Analysis-driven optimizations built-in
- **Future-Proof Integration**: Intelligence-guided ecosystem compatibility
### 🚀 **Competitive Advantages**
- **Research Intelligence**: Deep analysis before building (competitors build blind)
- **Multi-Perspective Optimization**: Security + Performance + Integration (competitors choose one)
- **Continuous Learning**: Vodou gets smarter with each MCP built (competitors stay static)
- **Proactive Problem Prevention**: Research identifies issues before they occur
- **Production-Ready Output**: Research-enhanced MCPs deploy successfully (no trial-and-error)
### 🎯 **The Enhanced Vision**
**Traditional AI**: "I'll build what you asked for"
**Research-Enhanced Vodou**: "I'll research the optimal approach, analyze your system, consider security/performance/integration perspectives, then build the perfect solution for your specific needs"
**The Ultimate Goal**: AI agents that don't just create tools, but research, analyze, optimize, and create the exact tools needed for any task - with intelligence that ensures they work perfectly the first time.
---
### 📋 **Quick Reference: Research-Enhanced Workflow**
```bash
# Start with intelligence
./do "build mcp server for [target] with deep research"
# Research phase (automatic)
# - Deep thinking about target integration
# - Security analysis and threat modeling
# - Performance analysis and optimization
# - System compatibility assessment
# - Multi-perspective architecture design
# Build phase (research-enhanced)
# - Security-hardened implementation
# - Performance-optimized architecture
# - Intelligence-guided Vodou integration
# - Production-ready configuration
# - Comprehensive validation suite
# Result: Production-ready MCP with research-backed optimizations
```
**Every MCP server built with this enhanced skill comes with built-in intelligence, security, performance optimization, and production readiness that would take competitors weeks to achieve manually.**