A brief introduction to MCP server performance optimization

The Model Context Protocol (MCP) is rapidly transforming how AI applications interact with external systems and data sources. MCP provides a standardized way for AI models to securely connect to databases, APIs, file systems, and other resources through dedicated servers. What started as an experimental protocol has exploded into widespread adoption, with thousands of MCP servers being deployed across industries in just the first few months of 2025.

This massive rollout has revealed something crucial: MCP servers operate under fundamentally different performance constraints than traditional web services or APIs. While conventional optimization wisdom still applies, the unique characteristics of AI-driven workloads demand new approaches to performance tuning.

Understanding MCP's Unique Performance Profile

Unlike traditional client-server architectures where humans generate requests, MCP servers primarily serve AI models that can generate hundreds of requests per conversation, process massive amounts of data simultaneously, and have entirely different latency tolerance patterns. The AI client might fire off dozens of parallel database queries, file system operations, or API calls as it works through a complex task.

This creates performance bottlenecks in unexpected places. Traditional optimization techniques like caching, connection pooling, and load balancing remain important, but they're no longer sufficient on their own. The sheer volume and unpredictable patterns of AI-generated requests require rethinking how we architect and optimize these systems.

Why Token Usage Matters More Than You Think

Before diving into optimization techniques, it's crucial to understand why token efficiency is paramount in MCP server design. Unlike traditional APIs where response size primarily affects network transfer speed, every token returned by your MCP server directly consumes the AI model's context window.

Modern AI models have substantial context windows - Claude can handle 200,000+ tokens - but they fill up surprisingly quickly in real-world applications. A single conversation might involve dozens of MCP server calls, each returning data that accumulates in the context. What seems like a reasonable 500-token response becomes problematic when the AI makes 50 similar requests during a complex task.

Once the context window approaches its limit, the AI must start "forgetting" earlier information to make room for new data. This can lead to degraded performance, loss of important context, or conversations that simply can't continue. By optimizing your MCP server responses to use fewer tokens, you're not just improving speed - you're extending the AI's effective working memory and enabling more sophisticated, longer-running tasks.

Reducing JSON Payload Size

One of the most impactful optimizations for MCP servers involves trimming JSON responses to their essential elements. AI models consume every byte of data you send, and unnecessary properties directly impact both response time and token usage.

Consider a database query that returns address records. Instead of returning the full object:

{
  "addresses": [
    {
      "id": 12345,
      "street_address": "123 Main Street",
      "apartment": null,
      "city": "Springfield",
      "state": "IL",
      "postal_code": "62701",
      "country": "USA",
      "created_at": "2024-01-15T10:30:00Z",
      "updated_at": "2024-06-20T14:22:00Z",
      "is_primary": true,
      "is_billing": true,
      "is_shipping": false,
      "latitude": 39.7990,
      "longitude": -89.6436,
      "timezone": "America/Chicago"
    }
  ]
}

Return only what the AI actually needs for the current task:

{
  "addresses": [
    {
      "id": 12345,
      "address": "123 Main Street, Springfield, IL 62701",
      "is_primary": true
    }
  ]
}

This approach can reduce payload sizes by 60-80% in many cases. Implement dynamic field selection where clients can specify which properties they need, or create specialized endpoints for common AI use cases that return pre-optimized data sets.

The Controversial Alternative: Skip JSON Entirely

Here's where things get interesting, and potentially controversial. For certain types of data, especially large datasets or simple lists, returning plain text instead of JSON can dramatically improve performance.

Consider this JSON response for address data:

{
  "addresses": [
    {
      "id": 1,
      "title": "Mr.",
      "first_name": "John",
      "middle_name": "Robert",
      "last_name": "Smith",
      "street_number": "123",
      "street_name": "Main Street",
      "street_type": "Street",
      "apartment": null,
      "city": "Springfield",
      "state": "Illinois",
      "state_code": "IL",
      "postal_code": "62701",
      "country": "United States",
      "country_code": "US",
      "latitude": 39.7990,
      "longitude": -89.6436
    }
  ]
}

Versus this human-readable plain text equivalent:

Mr. John Robert Smith
123 Main Street, Springfield, IL 62701

The plain text version uses roughly 80% fewer tokens because it eliminates JSON overhead: the curly braces, square brackets, property names, and quotes that don't carry semantic meaning for the AI. Modern language models excel at parsing structured plain text, especially when the format is consistent and well-documented.

This approach works particularly well for:

File and directory listings
Log entries
Simple tabular data
Status reports
Search results

The tradeoff is reduced machine parseability for downstream systems that expect JSON, so use this technique judiciously and document your formats clearly.

Interestingly, we have seen many cases of Gemini mistakenly outputting its tool call source to the user output. It does not look like Google uses JSON for their tool responses - instead a much more abbriviated format, similar to the human readable one above.

The Hidden Context Cost of Tool Definitions

One of the most overlooked aspects of MCP server performance is the token overhead introduced by the tool definitions themselves. Unlike traditional APIs where endpoint documentation lives separately from requests, MCP tool definitions must be included in the AI model's context for every conversation. This means that every function description, parameter schema, and example you provide is consuming precious context tokens before the AI even begins its actual work.

Schema Complexity Compounds Quickly

The impact becomes particularly pronounced with complex tool schemas. A simple tool definition might consume 50-100 tokens, but enterprise-grade tools with detailed parameter descriptions, nested object schemas, enum validations, and comprehensive examples can easily consume 500-1,000 tokens each. Consider a database query tool that supports multiple table joins, filtering options, pagination parameters, and error handling - the schema alone might require 800+ tokens to fully describe. When you multiply this across a typical enterprise MCP server offering 15-20 specialized tools, you're looking at 10,000-15,000 tokens consumed purely by tool definitions.

The Multiplicative Effect

This overhead scales multiplicatively, not linearly, as users integrate multiple MCP servers. A developer working with separate servers for database access, file operations, API integrations, and monitoring tools might have 50+ available tools in their context. Even with modest 200-token average definitions, this represents 10,000 tokens - roughly 5% of Claude's context window - consumed before any actual conversation begins. For power users leveraging dozens of specialized MCP servers, tool definitions alone can consume 20,000+ tokens, significantly constraining the AI's working memory for complex, multi-step tasks.

Optimization Strategies for Tool Schemas

The solution lies in ruthless schema optimization. Replace verbose descriptions with concise but clear language, eliminate redundant examples, and use references to external documentation rather than embedding lengthy explanations. Consider implementing dynamic tool loading where only relevant tools are exposed based on conversation context, or create tool "bundles" that combine related functionality to reduce overall definition overhead. Remember that every word in your tool schema directly competes with the user's actual task data for context space.

Geographic Proximity: Location Still Matters

Physical location remains crucial for MCP server performance. Since Anthropic's infrastructure is primarily based in North America, MCP servers serving Claude perform best when hosted in US data centers. The difference can be substantial - servers in US-East typically see 100-300ms lower latencies compared to European or Asian deployments.

This geographic sensitivity is amplified by MCP's request patterns. AI models often make sequential chains of requests where each depends on the previous response, meaning even small latency improvements compound significantly across a conversation.

As AI providers expand their global infrastructure, optimal server locations will shift. OpenAI has significant presence in both US and European regions, while other providers are building out Asian capabilities. Monitor your performance metrics and be prepared to relocate or replicate your MCP servers as the AI landscape evolves.

For applications serving multiple AI providers or global users, consider implementing geographic load balancing with MCP servers deployed across multiple regions. The additional infrastructure complexity often pays for itself through improved user experience and reduced token costs from faster response times.

The Path Forward

MCP server optimization represents a new frontier in performance engineering. While traditional techniques remain foundational, the unique demands of AI workloads require fresh approaches. Focus on reducing unnecessary data transmission, consider alternative response formats where appropriate, and don't underestimate the impact of physical proximity to AI infrastructure.

As the MCP ecosystem continues its rapid expansion, these performance considerations will only become more critical. The servers that deliver the best performance will ultimately provide the best user experiences and most cost-effective AI integrations.

Catch Metrics is a leading web performance agency and we'd love to hear from anyone who is having MCP performance issues. Reach out to discuss how we can help optimize your MCP server implementations.