多工具MCP服务器

git clone https://github.com/pacmac/mcpp.git
cd mcpp
pip install pyyaml

git clone https://github.com/pacmac/mcpp-plan.git ../mcpp-plan

modules:
  - path: ../mcpp-plan

claude mcp add mcpp --scope user \
  -- python3 /path/to/mcpp/mcpp.py

[mcp_servers.mcpp]
command = "python3"
args = ["/path/to/mcpp/mcpp.py"]
env = { MCPP_LOG_LEVEL = "error", MCPP_TIMEOUT_SECONDS = "30" }

python3 /path/to/mcpp/mcpp.py

> What tools do you have from mcpp?

I have these tools available:
- fetch_page -- fetch and cache web content
- what_add -- scaffold a new plan directory
- plan_task_new -- create a new task with steps
- plan_task_list -- list all tasks
  ... (19 plan tools total)

┌─────────────────────────────────────────────────────┐
│  AI Agent (Claude Code, Codex, etc.)                │
│                                                     │
│  tools/list  ──►  all tool schemas (from tool.yaml) │
│  tools/call  ──►  routed to correct module          │
└──────────────┬──────────────────────────────────────┘
               │ stdin/stdout (JSON-RPC 2.0)
┌──────────────▼──────────────────────────────────────┐
│  mcpp.py  (single process)                          │
│                                                     │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐          │
│  │tools.yaml│  │ tool     │  │ routing  │          │
│  │ registry │─►│ discovery│─►│ table    │          │
│  └──────────┘  └──────────┘  └────┬─────┘          │
│                                   │                 │
│            ┌──────────┬───────────┼──────────┐      │
│            ▼          ▼           ▼          ▼      │
│       fetch_page    what       plan      your_tool  │
│       tool.yaml    tool.yaml   tool.yaml  tool.yaml │
│       mcpptool.py  mcpptool.py mcpptool.py  ...    │
└─────────────────────────────────────────────────────┘

tools/my_tool/
  tool.yaml       # declares the contract (schema)
  mcpptool.py     # implements the logic

name: my_tool                    # unique module identifier
scope: local                     # "local" (workspace-relative) or "global"
about: "One-line description."   # shown in help listings

tools:
  - name: my_tool_search         # globally unique tool name
    description: "Search for items matching a query."
    inputSchema:
      type: object
      properties:
        query:
          type: string
          description: "Search query"
        limit:
          type: integer
          description: "Max results (default: 10)"
          minimum: 1
          maximum: 100
      required:
        - query

def execute(tool_name: str, arguments: dict, context: dict | None = None) -> dict:
    """Handle a tool call.

    Args:
        tool_name:  Which tool was called (matches a name from tool.yaml)
        arguments:  Parameters from the agent, validated against inputSchema
        context:    Runtime info from the server:
                    {
                        "workspace_dir": "/abs/path/to/cwd",
                        "module_dir":    "/abs/path/to/this/module",
                        "module_scope":  "local"  # or "global"
                    }

    Returns:
        {"success": True, "result": <any>}                     # success
        {"success": True, "result": <data>, "display": "..."}  # success with display text
        {"success": False, "error": "description"}             # failure
    """

def get_info(context: dict | None = None) -> dict:
    """Return runtime configuration for agent discoverability.
    Called by the built-in help tool."""
    return {
        "params": {
            "query": {"values": None, "default": None},
            "limit": {"values": None, "default": 10},
        }
    }

def initialize() -> dict:
    """Called once at module import time. Return {"success": False, ...} to warn."""
    return {"success": True}

return {
    "success": True,
    "result": {"tasks": [...]},             # structured data for the agent
    "display": "**Tasks**\n- alpha\n- beta"  # markdown for the human
}

modules:
  - path: tools/fetch_page          # built-in, relative to tools.yaml
  - path: tools/what                # built-in
  - path: ../mcpp-plan              # external: github.com/pacmac/mcpp-plan
  - path: /opt/custom/my_tool       # absolute paths work too

cp -r tools/_template_pkg tools/my_tool

mkdir tools/my_tool

name: my_tool
scope: local
about: "Does something useful."

tools:
  - name: my_tool_run
    description: "Run the tool with given parameters."
    inputSchema:
      type: object
      properties:
        target:
          type: string
      required:
        - target

from __future__ import annotations
from typing import Any

def execute(tool_name: str, arguments: dict[str, Any], context: dict[str, Any] | None = None) -> dict[str, Any]:
    if tool_name == "my_tool_run":
        target = arguments["target"]
        workspace = (context or {}).get("workspace_dir", ".")
        # ... do work ...
        return {"success": True, "result": {"target": target, "status": "done"}}

    return {"success": False, "error": f"Unknown tool: {tool_name}"}

modules:
  - path: tools/my_tool
  # ... existing modules ...

modules:
  - path: /home/user/projects/my-tool    # absolute path
  - path: ../../other-repo/tool-module   # relative to tools.yaml

name: plan
scope: local
about: "Manage project tasks and steps."

tools:
  # Task management (7 tools)
  - name: plan_task_new
  - name: plan_task_list
  - name: plan_task_show
  - name: plan_task_status
  - name: plan_task_switch
  - name: plan_task_archive
  - name: plan_task_notes

  # Step tracking (7 tools)
  - name: plan_step_list
  - name: plan_step_show
  - name: plan_step_switch
  - name: plan_step_done
  - name: plan_step_new
  - name: plan_step_delete
  - name: plan_step_notes

  # User identity (2 tools)
  - name: plan_user_show
  - name: plan_user_set

  # Project metadata (3 tools)
  - name: plan_project_show
  - name: plan_project_set
  - name: plan_readme

tool_map = {
    "plan_task_new": _cmd_task_new,
    "plan_task_list": _cmd_task_list,
    # ...
}

def execute(tool_name, arguments, context=None):
    handler = tool_map.get(tool_name)
    if not handler:
        return {"success": False, "error": f"Unknown tool: {tool_name}"}
    return handler(workspace_dir, arguments)

# No arguments: list all modules
help()
# Returns: module names and their 'about' descriptions (no Python imports needed)

# With tool name: get runtime details
help(tool="fetch_page")
# Returns: output of that module's get_info(), including param defaults and valid values

~/.config/plan/plan.db
├── project: webapp     (CWD: /home/user/webapp)
│   ├── user: alice     → active task: auth-refactor
│   └── user: bob       → active task: api-migration
├── project: cli-tool   (CWD: /home/user/cli-tool)
│   └── user: alice     → active task: add-flags

# Add with environment overrides
claude mcp add mcpp --scope user \
  --env MCPP_LOG_LEVEL=error \
  --env MCPP_TIMEOUT_SECONDS=60 \
  -- python3 /path/to/mcpp/mcpp.py

{
  "mcpServers": {
    "mcpp": {
      "command": "python3",
      "args": ["/path/to/mcpp/mcpp.py"],
      "env": {
        "MCPP_LOG_LEVEL": "error"
      }
    }
  }
}

# List all registered tools
python3 cli.py list

# Call a tool
python3 cli.py call fetch_page --url https://example.com --max_chars 5000

# Get help on a specific tool
python3 cli.py call help --tool plan_task_new

mcpp/
├── mcpp.py              # MCP server (reads stdin, writes stdout)
├── cli.py               # Human CLI wrapper
├── tools.yaml           # Module registry
├── tools/
│   ├── _template_pkg/   # Copy-paste starter for new tools
│   │   ├── tool.yaml
│   │   ├── mcpptool.py
│   │   └── helper.py
│   ├── fetch_page/      # URL fetcher with disk cache
│   │   ├── tool.yaml
│   │   └── mcpptool.py
│   └── what/            # Project scaffolding
│       ├── tool.yaml
│       └── mcpptool.py
└── README.md