Performance Impacts of MCP Configurations on OpenAI Plugins: 6 Optimization Strategies

Streamable HTTP transport, result-size limiting, and strategic API selection in OpenAI Plugins can reduce CPU usage and cut latency by optimizing how the Model Context Protocol (MCP) handles tool discovery and invocation.

The openai/plugins repository standardizes agent-to-service communication through the Model Context Protocol (MCP), a unified interface for AI-friendly tool calling. While MCP simplifies integration, configuration choices—from transport protocols to pagination limits—create measurable performance impacts on OpenAI plugins. This analysis examines the specific source code implementations that dictate CPU load, memory pressure, and response latency in production environments.

Streamable HTTP Transport: Lowering CPU and Memory Pressure

The migration from Server-Sent Events (SSE) to Streamable HTTP transport yields significant performance gains by eliminating persistent connection overhead. According to plugins/vercel/vercel.md at line 708, the newer transport protocol removes the need for maintaining long-lived HTTP connections, which directly reduces memory pressure on the MCP server.

In plugins/vercel/skills/vercel-api/SKILL.md (lines 30-34 and 96-97), the documentation notes that Streamable HTTP pushes newline-delimited JSON objects without keeping connections open, resulting in lower CPU load during log streaming operations. This architectural change avoids the resource drain associated with connection state management in high-throughput scenarios.

Result-Size Limiting with maxResults

Network bandwidth and deserialization costs dominate MCP latency when returning large datasets. The Wix plugin configuration in plugins/wix/skills/wix-app/SKILL.md (line 345) demonstrates the recommended pattern: capping results with maxResults: 5.

Smaller payloads reduce:

• Network transmission time over high-latency connections
• JSON parsing overhead on the client side
• Memory allocation for temporary response buffers

When additional data is required, implement cursor-based pagination rather than increasing the result limit. This maintains consistent response times at the cost of extra round-trips.

Strategic API Selection: When to Bypass MCP

Not all operations benefit from MCP abstraction. The Wix headless plugin documentation in plugins/wix/skills/wix-headless/SKILL.md (line 109) explicitly advises avoiding MCP for actions with well-defined APIs, such as new-site builds. Using MCP in these scenarios creates duplicate work and extends build times unnecessarily.

Direct API calls outperform MCP discovery when:

• The endpoint contract is stable and documented
• The operation is write-heavy (e.g., site creation, deployment)
• Real-time performance is critical

Reserve MCP for discovery-heavy read operations where the agent benefits from schema introspection and dynamic tool selection.

OAuth 2.1 Handling Efficiency

Token management overhead disappears with MCP's built-in OAuth 2.1 implementation. As documented in plugins/vercel/skills/vercel-api/SKILL.md (lines 30-34), the MCP client automatically refreshes tokens, eliminating manual expiration checks and retry logic.

The performance trade-off involves a one-time interactive authorization during the first agent execution. Subsequent calls proceed without the latency spikes associated with token validation errors or manual credential rotation.

MCP-First, CLI-Fallback Strategy

Process spawning constitutes the primary bottleneck in Node-based CLI invocations. The Vercel plugin conventions in plugins/vercel/commands/_conventions.md (line 30) establish an MCP-first, CLI-fallback pattern that prioritizes structured MCP reads over spawning Node processes.

This strategy delivers faster read-only operations by:

• Avoiding the initialization overhead of Node.js runtime startup
• Eliminating shell process context switching
• Using JSON-RPC over stdio rather than parsing CLI stdout

Fallback to CLI occurs only when a specific tool is missing from the MCP server manifest, ensuring minimal process creation while maintaining functionality coverage.

Implementation Examples

Configure an MCP client with performance-optimized settings using the following patterns:

// 1. Initialize with Streamable HTTP transport (default in modern SDK)
import { createMCPClient } from "@ai-sdk/mcp";

const mcp = await createMCPClient({
  url: "https://mcp.vercel.com",
  // OAuth 2.1 handled automatically; prompts user on first auth only
});

Limit payload size to reduce latency:

// 2. Respect maxResults limits for list operations
const projects = await mcp.callTool("listProjects", {
  maxResults: 5,  // Reduces bandwidth and parsing time
});

Bypass MCP for known Wix API endpoints to avoid discovery overhead:

// 3. Direct REST API call for Wix operations (faster than MCP discovery)
import fetch from "node-fetch";

async function getWixStoreProducts(siteId: string) {
  // Skip MCP; use documented REST endpoint directly
  const token = await fetch(`https://www.wix.com/cli/token?site=${siteId}`)
    .then(r => r.text());
    
  const resp = await fetch(`https://www.wixapis.com/stores/v1/products`, {
    headers: { Authorization: `Bearer ${token}` },
  });
  return resp.json();
}

Implement efficient pagination when exceeding default limits:

// 4. Cursor-based pagination to maintain small payload sizes
let cursor = null;
while (true) {
  const page = await mcp.callTool("searchDocs", {
    query: "deployment logs",
    maxResults: 5,
    cursor,
  });
  
  processResults(page.results);
  if (!page.nextCursor) break;
  cursor = page.nextCursor;  // Trade round-trips for payload size
}

Summary

Optimizing MCP configurations in OpenAI Plugins requires attention to transport-layer efficiency and API selection strategy:

• Streamable HTTP replaces SSE to reduce CPU load and memory pressure on MCP servers, as implemented in plugins/vercel/vercel.md.
• maxResults limiting to 5 items (documented in plugins/wix/skills/wix-app/SKILL.md) minimizes network bandwidth and deserialization costs.
• Direct API calls outperform MCP for write-heavy operations like site builds, avoiding duplicate processing overhead noted in plugins/wix/skills/wix-headless/SKILL.md.
• Automatic OAuth 2.1 handling eliminates token management latency after initial authorization.
• MCP-first, CLI-fallback patterns in plugins/vercel/commands/_conventions.md prevent expensive Node process spawning during read operations.

Frequently Asked Questions

How does Streamable HTTP improve performance compared to SSE?

Streamable HTTP eliminates the need for persistent HTTP connections required by Server-Sent Events, significantly reducing memory pressure on the MCP server. According to plugins/vercel/skills/vercel-api/SKILL.md, this transport pushes newline-delimited JSON without maintaining open connections, lowering CPU usage during log streaming and high-throughput operations.

What is the optimal maxResults value for MCP tool calls?

The OpenAI Plugins repository consistently uses maxResults: 5 as the default limit, as seen in plugins/wix/skills/wix-app/SKILL.md (line 345). This value balances data completeness with network efficiency; larger payloads increase deserialization time and bandwidth consumption disproportionately to the value of additional items in most agentic workflows.

When should I avoid using MCP in favor of direct API calls?

Avoid MCP for actions that have well-defined, stable REST APIs or involve write-heavy operations like site creation. The Wix headless plugin documentation in plugins/wix/skills/wix-headless/SKILL.md (line 109) specifically warns against using MCP for new-site builds, as it causes duplicate work and longer build times compared to direct API invocation.

How does the MCP-first, CLI-fallback strategy reduce latency?

This strategy minimizes expensive process spawning by preferring JSON-RPC communication over stdio instead of launching Node.js CLI processes. As defined in plugins/vercel/commands/_conventions.md (line 30), agents attempt MCP tool calls first and only fall back to CLI commands when tools are missing, avoiding the initialization overhead associated with shell command execution.

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