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

> Discover what Model-Connected Plugin (MCP) means for Claude AI. Learn how this GraphQL protocol lets Claude easily use external tools via JSON-RPC calls.

- Repository: [Anthropic/claude-plugins-community](https://github.com/anthropics/claude-plugins-community)
- Tags: deep-dive
- Published: 2026-08-28

---

**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`](https://github.com/anthropics/claude-plugins-community/blob/main/.claude-plugin/marketplace.json) and individual skills specifying required servers in their [`SKILL.md`](https://github.com/anthropics/claude-plugins-community/blob/main/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`](https://github.com/anthropics/claude-plugins-community/blob/main/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`](https://github.com/anthropics/claude-plugins-community/blob/main/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.

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

```

Skills in [`tres-finance-plugin/skills/tres-settings-management/SKILL.md`](https://github.com/anthropics/claude-plugins-community/blob/main/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:

```json
{
  "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:

```json
{
  "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`](https://github.com/anthropics/claude-plugins-community/blob/main/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`](https://github.com/anthropics/claude-plugins-community/blob/main/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`](https://github.com/anthropics/claude-plugins-community/blob/main/tres-finance-plugin/skills/tres-wallets-upload/SKILL.md) and the `McpClient` class in [`tres-report-create/tests/run_report_matrix.py`](https://github.com/anthropics/claude-plugins-community/blob/main/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`](https://github.com/anthropics/claude-plugins-community/blob/main/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`](https://github.com/anthropics/claude-plugins-community/blob/main/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.