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

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.

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.

Plugin Manifests

Each plugin can declare an MCP configuration in .mcp.json alongside the standard Codex manifest at .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 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.

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. Client libraries follow the latest MCP specification, including inputSchema and outputSchema fields, as noted in 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 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.

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.

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.

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 file illustrates how agents declare tools for the MCP runtime.

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 – Defines the MCP server endpoint, authentication, and tool list.
• plugins/metabase/.codex-plugin/plugin.json – Standard plugin manifest that may reference the MCP config.
• plugins/wix/skills/wix-app/SKILL.md – Provides the skill’s description, flow, and MCP fallback policy.
• plugins/vercel/README.md – High-level overview of MCP integration and specification fields.
• plugins/vercel/skills/ai-sdk/SKILL.md – Shows how to create an MCP client and call tools.
• 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 files), MCP clients (like @ai-sdk/mcp), and plugin manifests (.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 file at the plugin root, alongside the standard Codex manifest located at .codex-plugin/plugin.json. For example, the Cloudflare plugin defines its server in 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, 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.

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