Tools for Checking MCP Configurations in OpenAI Plugins: CLI, SDK, and Validation Utilities

OpenAI Plugins provide a Model Context Protocol (MCP) ecosystem that includes declarative .mcp.json files, the @ai-sdk/mcp runtime client, the mcp-to-ai-sdk CLI generator, and platform-specific helpers to inspect and validate MCP configurations.

The openai/plugins repository hosts community plugins that expose structured tool definitions through the Model Context Protocol (MCP). Checking MCP configurations in OpenAI plugins requires combining declarative files, command-line utilities, and runtime libraries that verify endpoints, schemas, and tool discoverability.

Inspect Static MCP Definitions with .mcp.json

Every plugin in the repository can declare its MCP server metadata in a .mcp.json file. In plugins/daloopa/README.md, the presence of this file signals where the MCP endpoints, authentication rules, and schemas are defined. Reading this file directly is the fastest way to check a plugin’s static MCP configuration.

import json, pathlib

# Path to the plugin (example: Daloopa)

mcp_path = pathlib.Path("plugins/daloopa/.mcp.json")
config = json.loads(mcp_path.read_text())
print(json.dumps(config, indent=2))

Source: The Daloopa README notes the presence of a .mcp.json file.

Register and Verify MCP Configurations with the Vercel CLI

The vercel mcp command materializes a local MCP configuration and registers it with the Vercel MCP server. As documented in plugins/vercel/skills/vercel-cli/SKILL.md, this CLI wrapper writes the .mcp.json file and connects the project to the server, letting developers verify registration immediately. The Vercel plugin manifest in plugins/vercel/.app.json also points to the generated MCP client, linking project metadata to its tool definitions.

# From a Vercel project root

vercel mcp   # writes .mcp.json and registers the MCP server

Source: Vercel CLI integration described in plugins/vercel/skills/vercel-cli/SKILL.md.

Validate Live MCP Tool Reachability with the @ai-sdk/mcp Client

The @ai-sdk/mcp package provides a runtime library that loads a plugin’s MCP specification and creates strongly-typed tool objects for agents. According to plugins/vercel/skills/ai-sdk/SKILL.md, developers can use createMCPClient to instantiate a client that auto-detects .mcp.json and validates that expected tools are reachable.

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

async function listProjects() {
  const client = await createMCPClient({ /* auto‑detect .mcp.json */ });
  const { result } = await client.callTool("list_projects", {});
  console.log(result);
}
listProjects();

Source: Example of creating an MCP client appears in plugins/vercel/skills/ai-sdk/SKILL.md.

Generate Static MCP Tool Definitions with mcp-to-ai-sdk

For compile-time safety, the mcp-to-ai-sdk CLI converts a live MCP server into static TypeScript definitions. The same Vercel AI SDK skill file documents this workflow, ensuring agents only call supported tools. Running this generator is an effective way to check that the server’s exposed tools match the client’s expectations.

npx mcp-to-ai-sdk \
  --server https://my-plugin.vercel.app/api/mcp \
  --out src/mcp-tools.ts

Source: Guidance on using mcp-to-ai-sdk is in the same AI‑SDK skill file.

Use Platform-Specific MCP Discovery and Server Builders

When API references are incomplete, the Wix plugin skill recommends falling back to MCP discovery only for gaps. The plugins/wix/skills/wix-app/SKILL.md file outlines this decision flow: check API references first, then invoke MCP discovery tools. Additionally, plugins/cloudflare/skills/building-mcp-server-on-cloudflare/SKILL.md provides sample scripts for spinning up an MCP-compatible server on Cloudflare Workers, enabling local validation of MCP configs.

# In a Wix skill’s plan flow

if (!apiReferenceFound) {
  # invoke MCP discovery tool

  callTool: "search_wix_api"
}

Source: The Wix app skill outlines the “check API references first, use MCP only for gaps” policy.

Summary

• .mcp.json files provide the declarative source of truth for MCP endpoints and schemas in plugins such as Daloopa.
• The vercel mcp CLI writes and registers local MCP configurations, offering immediate verification.
• The @ai-sdk/mcp client enables runtime validation by loading a spec and calling live tools.
• The mcp-to-ai-sdk generator produces static TypeScript definitions for compile-time contract checking.
• Wix and Cloudflare helpers cover edge cases like API-gap discovery and local server emulation.

Frequently Asked Questions

What file declares an MCP configuration in an OpenAI plugin?

Plugins declare MCP settings in a .mcp.json file stored alongside the plugin source. The Daloopa plugin README explicitly references this file path, and it typically contains endpoints, authentication rules, and tool schemas.

How can I verify that an MCP server is reachable and returning the expected tools?

Use the createMCPClient function from @ai-sdk/mcp to load the plugin’s spec and programmatically call tools. This approach validates both network reachability and tool discovery at runtime.

Is there a way to enforce type safety when consuming MCP tools from a plugin?

Yes. The mcp-to-ai-sdk CLI generates static TypeScript definitions from a live MCP server. By importing these generated types, you gain compile-time guarantees that agents only invoke supported tool signatures.

What CLI command registers an MCP configuration for a Vercel-based plugin?

The vercel mcp command writes the local .mcp.json file and registers the project with the Vercel MCP server. Documentation in plugins/vercel/skills/vercel-cli/SKILL.md covers this workflow in detail.

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