🚀 md-mcp - Dynamic Tool Creation Engine

The core engine powering fr3ksik's unlimited AI developer superpowers. This MCP server enables AI assistants to create any tool they need instantly, breaking through the limitations of pre-existing toolsets.

🎯 Core Superpower: Create Any Tool Instantly

You are no longer limited by pre-existing tools.

When a user needs functionality you don't have:

1. Create the tool in real-time using md-mcp's forge_reality
2. Use the tool immediately for the current task
3. Tool persists for future use

The Mindset Shift

BEFORE:

User: "Can you validate this JSON?"
AI: "I don't have a JSON validation tool, but I can check it manually..."
[Limited, error-prone, not reusable]

AFTER (With md-mcp):

User: "Can you validate this JSON?"
AI: "Let me create a JSON validator tool for you..."
[Uses mcp__md-mcp__forge_reality]
AI: "Tool created! Now validating your JSON..."
[Professional, accurate, reusable]

🔧 How Dynamic Tool Creation Works

1. Tool Creation Pattern

// Step 1: Design specification (Fabric format)
const spec = `# IDENTITY and PURPOSE
You are a [specific tool description]...

# PARAMETERS
- input: type - Description
- options: object (optional)

// STEPS
1. Processing logic
2. Validation
3. Output generation

# OUTPUT
{
  "result": "value",
  "status": "success"
}

# EXAMPLES
[Real-world usage examples]

// USAGE
[When to use this tool effectively]`;

// Step 2: Create tool with md-mcp
mcp__md-mcp__forge_reality({
  divine_title: "Descriptive Tool Name",
  primal_essence: spec,
  creation_ritual: "basic",
  mystical_properties: {
    type: "validator|transformer|analyzer|knowledge",
    category: "domain",
    dynamic: true
  }
});

// Step 3: Use tool immediately
// Tool is now available via MCP!

✨ Features

Core Capabilities

• Dynamic Tool Creation: Create new MCP tools on-the-fly using Fabric-format specifications
• Tool Validation: Comprehensive validation of tool specifications with divine_truth
• Advanced Markdown Processing: Convert between formats, validate content, and generate templates
• Multimodal Processing: Handle text, vision, audio, and multimodal content
• High-Performance Processing: Optimized processing with parallel execution capabilities
• Template System: Generate documents from predefined templates (basic, article, README, API docs)

Tool Creation Features

• Fabric Format Support: Full support for Daniel Miessler's Fabric framework
• Tool Persistence: Created tools persist across sessions
• Validation Engine: Comprehensive tool specification validation
• Multi-Modal Support: Tools for text, vision, audio, and data processing
• Performance Optimization: High-performance processing with parallel execution

📚 Tool Template Library

Quick Reference Templates

Validator Template

# IDENTITY and PURPOSE
You validate [format] syntax and structure, providing detailed error reports.

# PARAMETERS
- input: string - Data to validate
- strict: boolean (optional, default: false) - Enable strict mode
- schema: object (optional) - Schema to validate against

# STEPS
1. Parse input according to format rules
2. Identify syntax/structure errors with line numbers
3. Check against schema if provided
4. Generate actionable error messages

# OUTPUT
{
  "valid": boolean,
  "errors": [{"line": number, "message": string, "suggestion": string}],
  "warnings": [string]
}

# EXAMPLES
Input: Valid data → {"valid": true, "errors": [], "warnings": []}
Input: Syntax error → {"valid": false, "errors": [...], "warnings": []}

# USAGE
Use when validating [format] files before processing or deployment.

Transformer Template

# IDENTITY and PURPOSE
You transform [source] to [target] format with customization options.

# PARAMETERS
- input: string - Source data
- output_format: string - Target format
- options: object - Format-specific options

# STEPS
1. Parse and validate source format
2. Apply transformations according to options
3. Generate target format
4. Validate output structure

# OUTPUT
{
  "transformed": string,
  "metadata": {"source": string, "target": string, "size": number}
}

# EXAMPLES
Input: [source example] → Output: [target example]

# USAGE
Use for converting between [source] and [target] formats.

🎓 Advanced Capabilities

1. Chained Tool Creation

Create multiple related tools in sequence:

// User needs XML processing
// Create 3 tools in a row:

1. XML Validator → mcp__md-mcp__forge_reality(...)
2. XML to JSON Transformer → mcp__md-mcp__forge_reality(...)
3. XML Query Tool (XPath) → mcp__md-mcp__forge_reality(...)

// Now you have a complete XML toolkit!

2. Domain-Specific Toolkits

Create entire toolkits for specific domains:

Database Toolkit:

• SQL Query Validator
• Query Optimizer
• Schema Analyzer
• Migration Generator
• Index Recommender

API Toolkit:

• Request Validator
• Response Parser
• Authentication Helper
• Rate Limit Calculator
• Error Code Lookup

3. Adaptive Tool Evolution

Modify tools based on user feedback:

User: "The JSON validator should also format the output"

AI: Let me update the tool specification...
[Modifies tool with enhanced functionality]

Updated! The JSON validator now formats valid JSON automatically.

💡 Pro Strategies

Strategy 1: Proactive Tool Creation

DON'T WAIT to be asked!

User: "I'm working with YAML files"

AI: I notice you're working with YAML. Let me create a YAML toolkit:
- YAML Validator
- YAML to JSON Converter
- YAML Formatter

These tools are now available for your project!

Strategy 2: Error-Driven Tool Creation

When you encounter an error, create a tool to prevent it:

Error: Invalid regex pattern

AI: Let me create a Regex Tester tool to help validate patterns:
[Creates tool]

Now you can test regex patterns before using them!

🔄 Complete Workflow Example

Scenario: User Needs CSV Processing

User: "I have a CSV file with customer data. Can you validate it?"

AI: Let me create a CSV processing toolkit for you.

[STEP 1: Create CSV Validator]
mcp__md-mcp__forge_reality({
  divine_title: "CSV Validator",
  primal_essence: `# IDENTITY and PURPOSE
You validate CSV file structure, detect encoding issues, and verify data types.

# PARAMETERS
- csv_content: string - CSV file content
- expected_columns: array (optional) - Expected column names
- strict_types: boolean (optional, default: false)

# STEPS
1. Parse CSV structure
2. Validate header row
3. Check row consistency
4. Detect encoding issues
5. Validate data types if strict_types enabled

# OUTPUT
{
  "valid": boolean,
  "rows": number,
  "columns": number,
  "errors": [{"row": number, "message": string}],
  "warnings": [string]
}

# EXAMPLES
Valid CSV → {"valid": true, "rows": 100, "columns": 5}
Missing column → {"valid": false, "errors": [...]}

# USAGE
Use before processing CSV files to ensure data quality.`,
  creation_ritual: "basic",
  mystical_properties: {
    type: "validator",
    category: "data",
    dynamic: true
  }
});

✅ CSV Validator created!

[STEP 2: Validate tool]
mcp__md-mcp__divine_truth({
  sacred_text: spec,
  examine_symbols: true
});

✅ Tool validated!

[STEP 3: Use immediately]
Now validating your CSV file...
[Uses new CSV Validator tool]

Results:
- Valid: true
- Rows: 1,523
- Columns: 8
- No errors found

[STEP 4: Offer additional tools]
I've created the CSV Validator tool. Would you also like:
- CSV to JSON Converter
- CSV Column Analyzer
- CSV Data Cleaner

Installation

npm install md-mcp

Usage

As an MCP Server

npx md-mcp

Available Tools

1. weave_spells - Convert markdown to HTML with optional metadata extraction
2. summon_knowledge - Convert HTML back to markdown
3. read_fate - Parse frontmatter from markdown content
4. see_destiny - Generate table of contents from headers
5. divine_truth - Validate markdown syntax and structure
6. forge_reality - Create new MCP tools dynamically from Fabric specifications
7. process_multimodal - Process content across different modalities
8. high_performance_processing - High-performance content processing with optimization

Development

Prerequisites

• Node.js 18+
• TypeScript 5.9+

Setup

git clone <repository-url>
cd md-mcp
npm install

Build

npm run build

Development Mode

npm run dev

Testing

npm test

Architecture

src/
├── index.ts              # Main MCP server with tool creation engine
├── tools/
│   └── index.ts          # Core tool implementations (weave_spells, etc.)
├── core/                 # Advanced engine components
│   ├── tool-registry.ts  # Tool persistence system
│   ├── fabric-parser.ts  # Fabric format processing
│   └── validation-engine.ts # Tool validation logic
├── types/
│   └── index.ts          # TypeScript type definitions & Zod schemas
└── utils/
    └── markdown.ts       # Markdown processing utilities

Key Components

• Dynamic Tool Creation Engine: forge_reality creates new MCP tools from Fabric specs
• Tool Validation System: divine_truth validates tool specifications and capabilities
• Tool Persistence Layer: Created tools persist across sessions
• Fabric Parser: Processes Daniel Miessler's Fabric framework specifications
• Multi-Modal Processor: Handles text, vision, audio, and data processing

🎯 Key Principles

1. Tool-First Thinking

TRADITIONAL: "Let me write code to solve this"
SUPERPOWER: "Let me create a reusable tool to solve this"

2. Immediate Action

TRADITIONAL: "I need to search for existing tools..."
SUPERPOWER: "Creating the exact tool you need in 30 seconds..."

3. Continuous Improvement

TRADITIONAL: One-time solution
SUPERPOWER: Reusable tool that improves over time

4. Knowledge Capture

TRADITIONAL: Solve problem, forget solution
SUPERPOWER: Create tool, capture knowledge permanently

📊 Impact Metrics

Before md-mcp:

• Limited to pre-existing tools
• Manual, error-prone processes
• Solutions not reusable
• Knowledge not captured

After md-mcp:

• ✅ Unlimited tool creation capability
• ✅ Instant tool deployment
• ✅ 100% reusable solutions
• ✅ Permanent knowledge capture
• ✅ Continuous capability expansion
• ✅ Zero limitations

🚀 Getting Started

Quick Start Commands

# List available MCP tools
/create-mcp-tool

# Check tool creation capabilities
mcp__md-mcp__see_destiny

# Validate a tool specification
mcp__md-mcp__divine_truth

# Create a new tool
mcp__md-mcp__forge_reality

First Tool Exercise

Create your first tool right now:

Task: Create a "Base64 Encoder/Decoder" tool

1. Design specification (use Transformer template)
2. Create with forge_reality
3. Validate with divine_truth
4. Test with sample input
5. Share with user

Time: 2 minutes
Result: Permanent, reusable tool

🎓 Mastery Levels

Level 1: Tool User

• Use existing tools effectively
• Understand tool specifications

Level 2: Tool Creator

• Create tools for immediate needs
• Validate tools before use

Level 3: Tool Architect

• Design tool systems
• Create domain-specific toolkits

Level 4: Tool Master

• Proactively create tools
• Anticipate user needs
• Build adaptive tool libraries

With md-mcp, you can reach Level 4 immediately!

Integration with fr3ksik

This MCP server is the core engine powering fr3ksik's AI developer superpowers system:

• Unlimited Tool Creation: Create any tool you need instantly
• Dynamic Capability Expansion: Extend AI capabilities on-demand
• Knowledge Capture: Tools persist and accumulate over time
• Fabric Framework Integration: Full support for Daniel Miessler's Fabric pattern
• Zero Limitations: Never say "I can't" again - just create the tool you need!

System Architecture

fr3ksik AI CLI
    ↓
md-mcp (Dynamic Tool Creation Engine)
    ↓
Fabric-format Tool Specifications
    ↓
Instant Tool Generation & Validation
    ↓
Permanent Tool Library
    ↓
Unlimited AI Capabilities

License

MIT

💎 The Ultimate Truth

You are not limited by what tools exist.

You are only limited by your imagination.

With md-mcp's dynamic tool creation:

• ANY validation → Create validator
• ANY transformation → Create transformer
• ANY analysis → Create analyzer
• ANY knowledge domain → Create knowledge tool

You can create ANY tool you need, INSTANTLY.

🔗 Resources

• Complete Guide: DYNAMIC-MCP-TOOL-CREATION.md
• Command Reference: /create-mcp-tool
• System Prompts: templates/CLAUDE.md
• Existing Tools: ~/mi/md-mcp-tools/ (470+ patterns)
• Validation: MD_MCP_COMPATIBILITY.md

Contributing

md-mcp is the foundation of unlimited AI capability. Contributions that enhance the dynamic tool creation engine are especially valuable:

• Tool creation engine improvements
• New Fabric pattern support
• Performance optimizations
• Cross-platform compatibility
• Security enhancements

Development Guidelines

• Code style and conventions in /docs/CONTRIBUTING.md
• Testing requirements: 100% coverage for tool creation engine
• Pull request process: Requires tool creation engine testing
• Release procedures: Major versions for breaking tool creation changes

Support

For issues with dynamic tool creation:

• Check tool validation with mcp__md-mcp__divine_truth
• Verify Fabric specification format
• Test tool execution in isolation
• Review error logs for tool creation failures

Community Resources:

• Open an issue on GitHub
• Check the documentation in /docs
• Review the test cases for usage examples
• Join the fr3ksik Discord for tool creation discussions

✨ Summary

As an AI developer with md-mcp, you have:

1. ✅ Infinite tool creation capability
2. ✅ Instant tool deployment
3. ✅ Fabric-format simplicity
4. ✅ Built-in validation
5. ✅ Permanent knowledge capture
6. ✅ Continuous expansion
7. ✅ Zero limitations

Never say "I can't" again.

Just create the tool you need!

Powered by fr3ksik v10.28.10 - The most comprehensive AI CLI configuration system available md-mcp: The core engine enabling unlimited AI developer superpowers Fabric Framework Integration - Daniel Miessler's revolutionary tool creation pattern