# What Does MCP Stand For in OpenAI Plugins? A Guide to the Model Context Protocol

> Discover what MCP stands for in OpenAI plugins. Learn how the Model Context Protocol enables AI agents to call external services using structured tool definitions for seamless integration.

- Repository: [OpenAI/plugins](https://github.com/openai/plugins)
- Tags: explainer
- Published: 2026-06-06

---

**MCP stands for Model Context Protocol, a standardized protocol that lets OpenAI-powered agents call external services through structured tool definitions rather than raw HTTP requests.**

In the `openai/plugins` repository, the **Model Context Protocol (MCP)** is the backbone that lets AI agents discover and invoke external tools safely. It replaces ad-hoc HTTP calls with schema-enforced function definitions, making plugin integrations predictable and secure.

## What Is the Model Context Protocol (MCP)?

The **Model Context Protocol (MCP)** is a standardized way for OpenAI-powered agents to call external services — databases, APIs, or custom back-ends — through structured tool definitions. Instead of generating raw HTTP requests, the model invokes pre-approved tools that expose strict **inputSchema** and **outputSchema** fields. This design is implemented throughout the `openai/plugins` codebase, from the Cloudflare plugin to the Vercel AI SDK integration.

## How MCP Fits Into the Plugin Architecture

### MCP Servers

An **MCP server** is a small, purpose-built service that exposes a set of **tools** (functions) with an **input schema** and an **output schema**. The server authenticates callers, typically via OAuth, and enforces schemas so the language model can safely generate tool calls. For example, the Cloudflare plugin ships an official MCP server defined in [`plugins/cloudflare/.mcp.json`](https://github.com/openai/plugins/blob/main/plugins/cloudflare/.mcp.json).

### MCP Clients

Libraries such as `@ai-sdk/mcp` (used by the Vercel AI SDK) let an agent **discover** available tools from a remote MCP server and invoke them. The client handles authentication, network transport (Streamable HTTP), and schema validation. The `createMCPClient` function is documented in [`plugins/vercel/skills/ai-sdk/SKILL.md`](https://github.com/openai/plugins/blob/main/plugins/vercel/skills/ai-sdk/SKILL.md).

### Plugin Manifests

Each plugin can declare an MCP configuration in [`.mcp.json`](https://github.com/openai/plugins/blob/main/.mcp.json) alongside the standard Codex manifest at [`.codex-plugin/plugin.json`](https://github.com/openai/plugins/blob/main/.codex-plugin/plugin.json). This tells the Codex runtime that the plugin has an MCP endpoint available for the agent. The Metabase plugin’s README at [`plugins/metabase/README.md`](https://github.com/openai/plugins/blob/main/plugins/metabase/README.md) references this required MCP config file.

### Skill Documentation and Fallback Patterns

Skills that need structured data may first consult **reference** files (API docs) and fall back to MCP discovery only when a method is missing. This “check-reference-then-MCP” pattern is described in skill files such as [`plugins/wix/skills/wix-app/SKILL.md`](https://github.com/openai/plugins/blob/main/plugins/wix/skills/wix-app/SKILL.md).

### Transport and Spec Compliance

MCP servers deployed on Vercel use **Streamable HTTP** (replacing the older SSE transport) as of the March 2025 spec, according to [`plugins/vercel/skills/vercel-api/SKILL.md`](https://github.com/openai/plugins/blob/main/plugins/vercel/skills/vercel-api/SKILL.md). Client libraries follow the latest **MCP specification**, including `inputSchema` and `outputSchema` fields, as noted in [`plugins/vercel/README.md`](https://github.com/openai/plugins/blob/main/plugins/vercel/README.md).

## Why MCP Matters for Agent Safety and Portability

- **Safety** – The model never invents raw HTTP calls; it can only invoke tools whose schemas are pre-approved.
- **Discoverability** – Agents can query the MCP server for a list of available tools, making it easy to expose new capabilities without changing the model prompt.
- **Portability** – Any MCP-compatible server (Vercel, Cloudflare, self-hosted) can be swapped in, and the same client code continues to work.
- **Extensibility** – Plugins can add new tools simply by extending their [`.mcp.json`](https://github.com/openai/plugins/blob/main/.mcp.json) file, without rewriting the agent logic.

## Practical MCP Code Examples

### Creating an MCP Client in Node.js

The `@ai-sdk/mcp` package exposes `createMCPClient` to connect to a remote server.

```typescript
import { createMCPClient } from "@ai-sdk/mcp";

const client = await createMCPClient({
  // URL of the remote MCP server (provided by the plugin)
  endpoint: "https://my-plugin.mcp.vercel.app/api/mcp",
  // OAuth is handled automatically by the library
});

// List available tools
const tools = await client.listTools();
console.log("Available tools:", tools);

```

This pattern is demonstrated in [`plugins/vercel/skills/ai-sdk/SKILL.md`](https://github.com/openai/plugins/blob/main/plugins/vercel/skills/ai-sdk/SKILL.md).

### Calling a Tool Exposed by an MCP Server

Assume the server exposes a `searchDocuments` tool that takes a `query` string and returns an array of documents.

```typescript
const result = await client.callTool("searchDocuments", {
  query: "latest quarterly earnings for Apple",
});

console.log("Search results:", result);

```

The tool’s **inputSchema** (`{ query: "string" }`) and **outputSchema** (`{ documents: "Array<Document>" }`) are enforced by the client, guaranteeing the model’s output matches the expected shape.

### Defining MCP Tools in a Skill Flow

The [`plugins/vercel/skills/vercel-api/agents/openai.yaml`](https://github.com/openai/plugins/blob/main/plugins/vercel/skills/vercel-api/agents/openai.yaml) file illustrates how agents declare tools for the MCP runtime.

```yaml
description: |
  Agent that interacts with Vercel through the MCP server.
tools:
  - name: getRuntimeLogs
    inputSchema:
      deploymentId: string
      level: enum("info","error","debug")
    outputSchema:
      logs: array<string>

```

When the agent needs logs, it calls `getRuntimeLogs` via the MCP client, and the Vercel MCP server streams the logs back in the structured format.

## Key Files in the OpenAI Plugins Repository

- [`plugins/cloudflare/.mcp.json`](https://github.com/openai/plugins/blob/main/plugins/cloudflare/.mcp.json) – Defines the MCP server endpoint, authentication, and tool list.
- [`plugins/metabase/.codex-plugin/plugin.json`](https://github.com/openai/plugins/blob/main/plugins/metabase/.codex-plugin/plugin.json) – Standard plugin manifest that may reference the MCP config.
- [`plugins/wix/skills/wix-app/SKILL.md`](https://github.com/openai/plugins/blob/main/plugins/wix/skills/wix-app/SKILL.md) – Provides the skill’s description, flow, and MCP fallback policy.
- [`plugins/vercel/README.md`](https://github.com/openai/plugins/blob/main/plugins/vercel/README.md) – High-level overview of MCP integration and specification fields.
- [`plugins/vercel/skills/ai-sdk/SKILL.md`](https://github.com/openai/plugins/blob/main/plugins/vercel/skills/ai-sdk/SKILL.md) – Shows how to create an MCP client and call tools.
- [`plugins/vercel/skills/vercel-api/SKILL.md`](https://github.com/openai/plugins/blob/main/plugins/vercel/skills/vercel-api/SKILL.md) – Demonstrates MCP tool definitions and Streamable HTTP transport details.

## Summary

- **MCP stands for Model Context Protocol** in the OpenAI plugin ecosystem.
- It enables agents to call external services through **schema-enforced tools** instead of raw HTTP.
- The architecture relies on **MCP servers** (defined in [`.mcp.json`](https://github.com/openai/plugins/blob/main/.mcp.json) files), **MCP clients** (like `@ai-sdk/mcp`), and **plugin manifests** ([`.codex-plugin/plugin.json`](https://github.com/openai/plugins/blob/main/.codex-plugin/plugin.json)).
- Key benefits include **safety**, **discoverability**, **portability**, and **extensibility** across plugins such as Cloudflare, Metabase, and Vercel.

## Frequently Asked Questions

### What does MCP stand for in OpenAI plugins?

**MCP stands for Model Context Protocol.** It is a standardized protocol that allows OpenAI-powered agents to interact with external services through structured tool definitions rather than generating raw HTTP requests.

### How does an MCP server differ from a traditional REST API?

An **MCP server** exposes tools with strict **inputSchema** and **outputSchema** definitions, typically authenticated via OAuth. Unlike a traditional REST API, the model can only invoke pre-approved functions, which prevents hallucinated requests and enforces type safety at runtime.

### Where is the MCP configuration stored in a plugin?

Each plugin stores its MCP configuration in a [`.mcp.json`](https://github.com/openai/plugins/blob/main/.mcp.json) file at the plugin root, alongside the standard Codex manifest located at [`.codex-plugin/plugin.json`](https://github.com/openai/plugins/blob/main/.codex-plugin/plugin.json). For example, the Cloudflare plugin defines its server in [`plugins/cloudflare/.mcp.json`](https://github.com/openai/plugins/blob/main/plugins/cloudflare/.mcp.json).

### Which transport protocol do MCP servers in the OpenAI plugins repo use?

According to [`plugins/vercel/skills/vercel-api/SKILL.md`](https://github.com/openai/plugins/blob/main/plugins/vercel/skills/vercel-api/SKILL.md), MCP servers deployed on Vercel use **Streamable HTTP**, which replaced the older SSE transport as of the March 2025 MCP specification. This modern transport is now the default for MCP clients such as `@ai-sdk/mcp`.