Skip to main content
Glama

MCP Dynamic Tools

Drop Python files, get MCP tools instantly.

A dynamic MCP server that automatically discovers Python files in a directory and exposes them as tools to any MCP-compatible AI client. Created through collaboration between Ben Wilson and Claude (Anthropic).

How it works

# 1. Write a Python file or have the LLM write one
def invoke(arguments):
    """Generate a secure password
    
    Parameters:
    - length: Length of password (default: 12)
    - include_symbols: Include special characters (default: true)
    """
    import random, string
    length = int(arguments.get('length', 12))
    chars = string.ascii_letters + string.digits
    if arguments.get('include_symbols', 'true').lower() == 'true':
        chars += "!@#$%^&*"
    return ''.join(random.choice(chars) for _ in range(length))
# 2. Save it to your tools directory
echo "# Above code" > tools/password_generator.py
# 3. AI can now use it immediately (after restart in Claude Desktop)
šŸ¤– "Generate a 16-character password with symbols"
šŸ”§ Tool: password_generator(length="16", include_symbols="true")
šŸ“¤ Result: "K9#mP2$vR8@nQ3!x"

Related MCP server: Modular MCP Server

Quick Start

1. Clone and Setup

git clone https://github.com/your-username/mcp-dynamic-tools
cd mcp-dynamic-tools

2. Create Tools Directory

mkdir tools

3. Configure Your MCP Client

Claude Desktop (~/.config/claude_desktop_config.json):

{
  "mcpServers": {
    "mcp-dynamic-tools": {
      "command": "python3",
      "args": [
        "/path/to/mcp-dynamic-tools/src/mcp_dynamic_tools/server.py",
        "--tools-dir",
        "/path/to/tools"
      ]
    }
  }
}

4. Create Your First Tool

# tools/hello.py
def invoke(arguments):
    """Say hello to someone
    
    Parameters:
    - name: The person to greet
    """
    name = arguments.get('name', 'World')
    return f"Hello, {name}! šŸ‘‹"

5. Restart Your MCP Client

Your hello tool is now available to any AI using your MCP client!

How It Works

  1. File Discovery: Server monitors your tools directory

  2. Code Analysis: Validates Python files have invoke(arguments) function

  3. Schema Extraction: Parses docstrings for parameter definitions

  4. MCP Integration: Exposes tools via standard MCP protocol

  5. Error Handling: Provides detailed feedback for debugging

Writing Tools

Function Signature

Every tool must have this exact signature:

def invoke(arguments):
    # Your tool logic here
    return result

Documentation Format

def invoke(arguments):
    """Brief description of what the tool does
    
    Parameters:
    - param_name: Description of the parameter
    - another_param: Description with (default: value)
    """

Example Tools

Text Processor:

def invoke(arguments):
    """Transform text in various ways
    
    Parameters:
    - text: The text to transform
    - operation: Type of transformation (uppercase, lowercase, reverse)
    """
    text = arguments.get('text', '')
    operation = arguments.get('operation', 'uppercase')
    
    if operation == 'uppercase':
        return text.upper()
    elif operation == 'lowercase':
        return text.lower()
    elif operation == 'reverse':
        return text[::-1]
    else:
        return f"Unknown operation: {operation}"

API Caller:

def invoke(arguments):
    """Fetch data from a REST API
    
    Parameters:
    - url: The API endpoint to call
    - method: HTTP method (default: GET)
    """
    import urllib.request
    import json
    
    url = arguments.get('url')
    method = arguments.get('method', 'GET')
    
    if not url:
        return "Error: URL is required"
    
    try:
        with urllib.request.urlopen(url) as response:
            return json.loads(response.read())
    except Exception as e:
        return f"Error: {str(e)}"

Robust Error Handling

The server provides detailed error messages to help you debug:

  • Syntax Errors: Shows line numbers and specific issues

  • Import Errors: Reports missing dependencies

  • Function Signature: Validates invoke(arguments) signature

  • Runtime Errors: Captures and reports execution problems

Known Limitations

Claude Desktop 0.9.2

Claude Desktop currently doesn't support dynamic tool discovery (see discussion). This means:

  • āœ… Tools work perfectly once discovered

  • āŒ Restart required when adding new tools

  • šŸ”„ Future support planned - our server is ready with listChanged: true

Workaround: Restart Claude Desktop after adding new tools.

Tool Naming in Claude Desktop

Tools appear with server prefix: local__mcp-dynamic-tools__your_tool_name

Contributing

This project was created through human-AI collaboration. We welcome contributions!

  1. Fork the repository

  2. Create your feature branch

  3. Add tests for new functionality

  4. Submit a pull request

License

MIT License - see LICENSE file for details.

Acknowledgments

  • Ben Vierck - Architecture and development

  • Claude (Anthropic) - Co-development and testing

  • MCP Community - Protocol development and feedback

Available Tools

1 tool
write_toolB

Create a new dynamic MCP tool by writing Python code to a file

Inputs: name (required), content (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.2/5.0

    Scored across 1 tool

    Disambiguation5/5

    With only one tool, there is no possibility of confusion. The tool's purpose is clearly distinct and singular.

    Naming Consistency5/5

    Naming is perfectly consistent as there is only one tool. The verb_noun pattern 'write_tool' is clear and follows a logical structure.

    Tool Count3/5

    The single tool is appropriate for the core functionality of creating a dynamic tool, but the server's purpose suggests a need for additional management tools (e.g., list, delete), making the count feel slightly thin.

    Completeness2/5

    The tool set covers creation only, lacking any lifecycle operations like listing, updating, or deleting dynamic tools. This leaves significant gaps for agents needing to manage tools beyond creation.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      A dynamic MCP server implementation that automatically loads tools, resources, and prompts from their respective directories, allowing for easy extension and configuration.
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      A scalable, auto-discovering Model Context Protocol server that dynamically loads tools from the tools directory, enabling LLMs to access various capabilities through a standardized interface.
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      A hot-reloadable MCP proxy server that enables users to create and manage custom Python tools through dynamic module loading. Users can build their own utilities, wrap APIs, and extend functionality by simply adding Python files to designated folders.
      7
      Apache 2.0
    • F
      license
      Not graded
      quality
      Not graded
      maintenance
      A dynamic server that automatically discovers and executes scripts from a tools directory as isolated processes using the MCP protocol. It enables users to easily extend server capabilities by adding new tool scripts that communicate via JSON.
      -