What Is MCP in Claude Plugins? Understanding Model-Connected Plugins

MCP stands for Model-Connected Plugin, a lightweight GraphQL-based server protocol that enables Claude to invoke external tools through standardized JSON-RPC calls instead of managing raw HTTP connections.

In the anthropics/claude-plugins-community repository, MCP serves as the foundational architecture bridging Claude's LLM capabilities with external data sources and services. Unlike traditional REST integrations, MCP servers provide a unified interface supporting dynamic schema discovery and type-safe tool invocation, allowing plugins to expose complex functionality while maintaining security and version consistency.

What MCP Means in the Claude Ecosystem

Within the Claude plugins framework, MCP represents more than a simple acronym—it defines a complete communication standard. The protocol treats external services as Model-Connected Plugins that expose their capabilities through a GraphQL surface, enabling Claude to discover and invoke tools without hard-coded API specifications.

This architecture appears throughout the community repository, with plugins declaring MCP dependencies in the central registry at .claude-plugin/marketplace.json and individual skills specifying required servers in their SKILL.md files. For example, the TRES Finance plugin explicitly declares its dependency on the TRES Finance MCP server at https://ai.tres.finance/mcp within tres-finance-plugin/skills/tres-wallets-upload/SKILL.md, establishing the connection requirements before any tool invocation occurs.

Core Architecture of MCP Servers

GraphQL-Based Interface

All MCP servers communicate through a unified GraphQL API, consolidating queries, mutations, and schema introspection into a single endpoint. This design eliminates the need for Claude to manage multiple REST endpoints or handle different authentication schemes for each external service.

The GraphQL layer provides several operational advantages:

• Dynamic schema discovery through the introspect tool, allowing Claude to query available fields, enums, and input types at runtime
• Type-safe operations with built-in validation against the server's schema
• Versioned interactions where schema changes are discoverable rather than breaking

Standardized Tool Surface

MCP servers expose functionality through a consistent set of tool calls rather than arbitrary HTTP requests. In tres-finance-plugin/skills/tres-report-create/tests/run_report_matrix.py, the McpClient class (lines 35-56) demonstrates how these invocations serialize to JSON-RPC payloads containing a tool name and structured arguments.

Essential MCP Tools and Their Functions

The Introspect Tool

Before executing operations, Claude skills query the MCP server's capabilities using the introspect tool. This returns the complete GraphQL schema, including available queries, mutations, types, and fields.

{
  "tool": "introspect",
  "arguments": {}
}

Skills in tres-finance-plugin/skills/tres-settings-management/SKILL.md leverage this capability to build dynamic queries without hard-coding field names, ensuring resilience against schema updates.

The Execute Tool

The primary mechanism for running GraphQL operations, the execute tool accepts query strings and variables, returning structured data or error objects. This is the workhorse of MCP communication:

{
  "tool": "execute",
  "arguments": {
    "query": "query GetViewer { viewer { id organization { name } } }"
  }
}

The response contains standard GraphQL data and errors fields, which the McpClient wrapper processes to extract results or handle failures gracefully.

The Build Query Tool

To simplify query construction, MCP provides the build_query tool, which generates valid GraphQL syntax from structured parameters:

{
  "tool": "build_query",
  "arguments": {
    "operation": "query",
    "field": "wallets",
    "filters": { "status": "ACTIVE" },
    "selectionSet": ["id", "balance"]
  }
}

This abstraction layer prevents syntax errors and ensures consistent query formatting across different MCP implementations.

The Get Viewer Tool

Most MCP implementations include a get_viewer tool that returns identity and context information about the current authenticated user, including organization details and permissions. This establishes the security context for subsequent operations.

Authentication and Security Model

MCP handles authentication at the session level, managed entirely by Claude rather than individual skills. When a user initiates a conversation requiring an MCP server, Claude establishes an authenticated session with the external service, passing only validated tool calls to the LLM.

This architecture provides critical security benefits:

• No API key exposure: Skills never handle raw credentials or tokens directly
• Scoped permissions: Authentication occurs at the connection level, with the MCP server enforcing access controls
• Audit trails: All tool invocations flow through Claude's MCP client, enabling centralized logging of external interactions

Implementation Example: TRES Finance Integration

The TRES Finance plugin demonstrates production MCP usage across multiple skill files. Located in tres-finance-plugin/skills/tres-wallets-upload/SKILL.md, the wallet onboarding skill declares its MCP dependency explicitly:

Requires TRES Finance MCP connected (https://ai.tres.finance/mcp)

The implementation uses get_viewer to establish context, introspect to discover available wallet fields, and execute to run GraphQL mutations for uploading wallet data. Additional reference material in quickdesign/skills/quickdesign/references/connecting-claude-ai-via-mcp.md provides general guidance on wiring Claude to MCP servers and utilizing the standardized tool set.

Summary

• MCP stands for Model-Connected Plugin, the standardized protocol enabling Claude to communicate with external services via GraphQL.
• Four core tools define the MCP interface: introspect for schema discovery, execute for running queries, build_query for constructing syntax, and get_viewer for establishing identity context.
• Authentication is session-managed by Claude, preventing skills from accessing raw API credentials while maintaining secure access to external data.
• GraphQL foundation provides type safety, dynamic discovery, and version resilience compared to traditional REST integrations.
• Repository implementations in anthropics/claude-plugins-community demonstrate MCP patterns in files like tres-finance-plugin/skills/tres-wallets-upload/SKILL.md and the McpClient class in tres-report-create/tests/run_report_matrix.py.

Frequently Asked Questions

What does MCP stand for in Claude plugins?

MCP stands for Model-Connected Plugin, referring to the GraphQL-based server architecture that exposes external APIs as standardized tools Claude can invoke through JSON-RPC calls. This protocol appears throughout the anthropics/claude-plugins-community repository as the primary integration method for external services.

How does authentication work with MCP servers?

Claude manages MCP authentication at the session level, establishing verified connections when users start conversations requiring external tools. Skills interact with authenticated sessions without handling raw API keys or tokens, as demonstrated in tres-finance-plugin/skills/tres-wallets-upload/SKILL.md where the get_viewer tool retrieves identity context without exposing credentials.

What is the difference between MCP tools and direct API calls?

MCP tools provide a standardized abstraction layer over direct HTTP requests. Instead of constructing raw REST calls with varying authentication headers, skills invoke JSON-RPC methods like execute and introspect against a GraphQL endpoint. This ensures type safety, dynamic schema discovery, and consistent error handling across different external services.

How does schema introspection work with MCP?

The introspect tool allows Claude to query an MCP server's live GraphQL schema at runtime, discovering available queries, mutations, and types without hard-coding. As shown in tres-finance-plugin/skills/tres-settings-management/SKILL.md, skills use this capability to build dynamic queries that adapt to schema changes, ensuring long-term compatibility with evolving MCP implementations.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}