How do I test tools that call external APIs?

Mock the external call (for example with a test double or a mocking library) so the test exercises your tool logic without depending on a real network call.

What is the difference between integration and load testing?

Integration tests confirm correctness of the server-client protocol exchange. Load tests confirm the server holds up under concurrent traffic and measure latency under that load.

How often should I run load tests?

Before every major release, and periodically in production to catch performance regressions introduced by new tools or dependencies.

developmentHowTo

MCP Server Testing Strategies

Test MCP servers at three levels: unit tests for individual tools, integration tests for the server-client lifecycle, and load tests for production readiness.

Quick Answer / TL;DR

Test MCP servers at three levels: unit tests that exercise individual tool functions in isolation, integration tests that connect a real MCP client to the running server to verify tool listing and execution, and load tests that measure latency and error rate under concurrent traffic before a production launch.

Key Takeaways

Unit test tool logic directly; integration test the server through a real MCP client connection.
Assert both the happy path and the schema-validation failure path for every tool.
Run a load test before every major release, not only once before the first launch.

Unit and integration tests

Unit tests call a tool's implementation function directly with valid and invalid input. Integration tests go through the protocol layer itself: connect a real MCP client over stdio to the built server, list its tools, and call one to confirm the full request-response cycle works end to end.

typescript

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

describe("MCP server integration", () => {
  it("lists tools and executes one", async () => {
    const transport = new StdioClientTransport({ command: "node", args: ["dist/index.js"] });
    const client = new Client({ name: "test-client", version: "1.0.0" });
    await client.connect(transport);

    const { tools } = await client.listTools();
    expect(tools.length).toBeGreaterThan(0);

    const result = await client.callTool({ name: tools[0].name, arguments: {} });
    expect(result.content[0].type).toBe("text");
  });
});

Load testing before production

Run several concurrent MCP clients against the server for a fixed duration, record success rate and latency percentiles, and compare against your target before rolling out to production traffic.

Metric	What it tells you
P95 latency	Typical worst-case response time
Error rate	Stability under concurrent load
Requests per second	Throughput ceiling for capacity planning