MCP Tool Schemas

MyClaude products can expose MCP (Model Context Protocol) tools that Claude Code invokes directly. This page defines the tool schema format, lists the standard tool categories, and explains how agents consume these tools.

What MCP means for MyClaude

The Model Context Protocol is an open standard for connecting AI agents to external tools and data sources. An MCP server exposes a set of tools — each with a name, description, and input schema — that an MCP client (such as Claude Code) can discover and invoke.

MyClaude integrates with MCP at two levels:

1. Product-level tools. A marketplace product (Skill, Agent, Squad, or Workflow) can declare MCP tools in its manifest. When installed, these tools become available to Claude Code in the project where the product is installed.
2. Platform-level tools. MyClaude itself will expose marketplace operations as MCP tools — search, install, publish — so agents can interact with the marketplace without leaving the Claude Code environment. These are defined in the forthcoming spec at /specs/mcp-tools.json.

Tool schema format

Every MCP tool is defined by three fields: a unique name, a natural-language description, and a JSON Schema for input parameters. The format follows the MCP specification.

{
  "name": "tool_name",
  "description": "What this tool does. Written for the agent, not the user.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "param_name": {
        "type": "string",
        "description": "What this parameter controls."
      }
    },
    "required": ["param_name"]
  }
}

Schema rules

Writing effective tool descriptions

The description field is the primary signal an agent uses to decide whether to invoke a tool. Effective descriptions follow three principles:

1. State the action, not the implementation. Write "Search the MyClaude marketplace for products matching a query" rather than "Calls the /api/cli/products/search endpoint."
2. Specify when to use it. Write "Use when the user asks to find a Claude Code skill, agent, or workflow" to give the agent clear invocation criteria.
3. Declare the output shape. Write "Returns an array of products with name, slug, category, price, and download count" so the agent knows what to expect.

Example tool definitions

Marketplace search

{
  "name": "myclaude_search",
  "description": "Search MyClaude marketplace for products matching a query. Use when the user asks to find skills, agents, squads, workflows, or other Claude Code ecosystem products. Returns an array of products with name, slug, category, price, and download count.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "Search query. Matches against product name, description, and tags."
      },
      "category": {
        "type": "string",
        "enum": [
          "skills",
          "squads",
          "agents",
          "workflows",
          "design-systems",
          "prompts",
          "claude-md",
          "applications"
        ],
        "description": "Filter results to a specific product category."
      },
      "sort": {
        "type": "string",
        "enum": ["relevance", "downloads", "newest", "price"],
        "description": "Sort order for results. Defaults to relevance."
      }
    },
    "required": ["query"]
  }
}

Product install

{
  "name": "myclaude_install",
  "description": "Install a MyClaude product into the current project. Use when the user wants to add a skill, agent, or other product to their Claude Code environment. Requires the product identifier in @creator/product format. Returns the installation path and version installed.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "product": {
        "type": "string",
        "description": "Product identifier in @creator/product format."
      },
      "version": {
        "type": "string",
        "description": "Specific semver version to install. Defaults to latest."
      },
      "global": {
        "type": "boolean",
        "description": "Install globally instead of project-local. Defaults to false."
      }
    },
    "required": ["product"]
  }
}

Product info

{
  "name": "myclaude_info",
  "description": "Retrieve detailed information about a MyClaude product. Use when the user asks about a specific product before installing or purchasing it. Returns name, description, category, version, price, author, download count, and license.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "product": {
        "type": "string",
        "description": "Product identifier in @creator/product format, or a product slug."
      }
    },
    "required": ["product"]
  }
}

Manifest validation

{
  "name": "myclaude_validate",
  "description": "Validate a vault.yaml manifest against the MyClaude schema. Use before publishing to catch errors early. Returns validation result with any errors or warnings.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "manifest_path": {
        "type": "string",
        "description": "Path to the vault.yaml file to validate. Defaults to ./vault.yaml."
      }
    },
    "required": []
  }
}

Standard MyClaude MCP tool categories

MyClaude organizes MCP tools into four categories. Platform-level tools (marked below) will ship in the /specs/mcp-tools.json spec. Product-level tools are declared by individual marketplace products.

How products declare MCP tools

A marketplace product exposes MCP tools through its vault.yaml manifest using the config field. The product category determines the expected tool format.

# vault.yaml for a Skill that exposes an MCP tool
name: code-review-skill
version: 1.0.0
category: skills
description: "Automated code review with security focus."
author: securitydev
license: MIT
entry: SKILL.md
price: 0
tags: [code-review, security, linting]
config:
  mcp_tools:
    - name: review_code
      description: "Review code for security vulnerabilities and best practices."
      inputSchema:
        type: object
        properties:
          file_path:
            type: string
            description: "Path to the file to review."
          focus:
            type: string
            enum: [security, performance, style, all]
            description: "Review focus area."
        required: [file_path]

When this product is installed via myclaude install @securitydev/code-review-skill, the declared MCP tools become available to Claude Code within the project.

Consuming MCP tools from Claude Code

Claude Code discovers MCP tools from servers configured in the project's .claude/ directory. MyClaude products that declare MCP tools are registered automatically during installation.

Discovery flow

myclaude install @creator/product
  → Product files written to .claude/skills/ (or relevant category path)
  → MCP tool declarations extracted from vault.yaml config
  → Tools registered with local MCP server configuration
  → Claude Code detects new tools on next session start

Invoking tools

Once registered, MCP tools appear in Claude Code's tool inventory. The agent sees the tool name, description, and input schema. Invocation is transparent — the agent calls the tool by name with the required parameters, and the MCP runtime handles execution.

An agent interacting with a MyClaude-installed tool follows this pattern:

1. The user's request triggers tool selection (e.g., "search MyClaude for a code review skill").
2. The agent identifies myclaude_search as the appropriate tool based on its description.
3. The agent constructs the input: {"query": "code review", "category": "skills"}.
4. The MCP runtime executes the tool and returns the result.
5. The agent interprets the result and responds to the user.

No additional configuration is required from the user. The tool schema provides all the information the agent needs to construct valid inputs.

OpenAPI-to-MCP bridging

The MyClaude REST API (defined in /specs/openapi.yaml) can be bridged to MCP using tools like Speakeasy or FastMCP. This allows agents that prefer MCP tool invocation to access the full API surface without writing HTTP requests.

The mapping is direct:

Agents that already consume the REST API directly do not need the MCP bridge. The MCP layer is an ergonomic convenience for agents operating within Claude Code's native tool-calling interface.

Future: SP-6 MCP tools spec

The complete MyClaude platform MCP tools specification will ship at /specs/mcp-tools.json. This spec will define all platform-level tools (Discovery, Management, Publishing categories) with full schemas, example inputs, and expected outputs.

Track the specification status in the MyClaude documentation index.

Related pages

• Agent Integration Overview — entry points and the PRISM architecture
• Context Payloads — pre-packaged YAML for bootstrapping agent knowledge
• CLI Commands — all 12 CLI commands with flags and examples
• vault.yaml Specification — product manifest format including config field
• Security Model — authentication for API and MCP tool access