Memory leak

[khromov]

👋 I deployed this package a while ago on a SvelteKit site using Node.js and there appears to be a memory leak where each connection instance is not being cleaned up. Here's a small heap snapshot comparison:

Recently started (17 instances of McpServer)

Running for a few hours (2121 instances of McpServer)

I am using the createMcpHandler function as instructed and can't see anything obvious on my side that could cause this. Here is the code for reference:

https://github.com/khromov/llmctx/blob/main-custom/src/lib/mcpHandler.ts#L43C24-L43C40

[quuu]

@khromov thanks for reporting, that snapshot is when you're running it locally right?

[khromov]

@quuu No, It's a production heap snapshot. I'm sure it would be possible to reproduce locally by writing a script that makes many connections and then terminates then immediately.

[quuu]

@khromov thanks - and where is your server deployed?

[khromov]

@quuu It's built with SvelteKits adapter-node and runs on a Node.js server (on a VPS using Docker). So it's a "long-lived" server, not serverless.

[moyounishimself]

I came across a "maybe" related issue.

I'm testing an MCP server that's been running for around a week. During that week I've been making about a dozen requests/day. This weekend, where I barely touched the server, I got an email informing me that I've used 75% of the included free tier usage for Fluid Provisioned Memory. 24 hours later and I'm at 100%.

Turned off Fluid memory and the same happened to my function duration limit. 75% of the limit then less than 2 hours later I'm at 100%. Upstash commands free tier limit also reached.

Removed the production domain, added it again and it's back to normal now.

[quuu]

@khromov @moyounishimself @acsrujan

I believe I was able to repro with this test script:

I can confirm that with this change: #98

the memory leak for SSE is fixed

current 1.0.1

1. running the stress test script once - note the memory climbs to 8.4%, and doesn't drop after
2. running the stress test script twice - note the memory climbs to 14.2%, and doesn't drop after

with the pr above
3) running the stress test script five times - note the memory climbs only up to 6%, and drops to 1.7% after cleanup happens on a recurring basis

Script ran with node --expose-gc scripts/test-client-stress.mjs http://localhost:3000 10000

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";

const origin = process.argv[2] || "https://mcp-for-next-js.vercel.app";
const SESSION_COUNT = parseInt(process.argv[3]) || 200;
const BATCH_SIZE = 100;

async function createSession(id, origin) {
  const startTime = Date.now();
  try {
    const transport = new SSEClientTransport(new URL(`${origin}/sse`));

    const client = new Client(
      {
        name: `stress-test-client-${id}`,
        version: "1.0.0",
      },
      {
        capabilities: {
          prompts: {},
          resources: {},
          tools: {},
        },
      },
    );

    await client.connect(transport);
    const connectTime = Date.now() - startTime;

    const capabilities = client.getServerCapabilities();
    const tools = await client.listTools();

    // Call the echo_message tool with test input
    let echoResult = null;
    try {
      const echoResponse = await client.callTool({
        name: "echo",
        arguments: {
          message: `Hello from stress test client ${id}! Testing echo functionality.`,
        },
      });
      echoResult = echoResponse.content?.[0]?.text || "No response";
    } catch (error) {
      echoResult = `Echo failed: ${error.message}`;
    }

    return {
      id,
      status: "connected",
      connectTime,
      toolCount: tools.tools?.length || 0,
      echoResult,
      client,
    };
  } catch (error) {
    return {
      id,
      status: "failed",
      error: error.message,
      connectTime: Date.now() - startTime,
    };
  }
}

async function runStressTest() {
  console.log(
    `🚀 Starting stress test with ${SESSION_COUNT} sessions to ${origin}`,
  );
  console.log(`Batching ${BATCH_SIZE} connections at a time...\n`);

  const results = [];
  const startTime = Date.now();

  for (let i = 0; i < SESSION_COUNT; i += BATCH_SIZE) {
    const batchStart = i;
    const batchEnd = Math.min(i + BATCH_SIZE, SESSION_COUNT);
    const batchSize = batchEnd - batchStart;

    console.log(
      `Starting batch ${Math.floor(i / BATCH_SIZE) + 1}: sessions ${batchStart + 1}-${batchEnd}`,
    );

    const batchPromises = [];
    for (let j = batchStart; j < batchEnd; j++) {
      batchPromises.push(createSession(j + 1, origin));
    }

    const batchResults = await Promise.all(batchPromises);
    results.push(...batchResults);

    const connected = batchResults.filter(
      (r) => r.status === "connected",
    ).length;
    const failed = batchResults.filter((r) => r.status === "failed").length;
    console.log(`  ✓ Batch complete: ${connected} connected, ${failed} failed`);
  }

  const totalTime = Date.now() - startTime;

  const connected = results.filter((r) => r.status === "connected");
  const failed = results.filter((r) => r.status === "failed");

  console.log("\n📊 STRESS TEST RESULTS");
  console.log("══════════════════════");
  console.log(`Total Sessions: ${SESSION_COUNT}`);
  console.log(
    `✅ Connected: ${connected.length} (${((connected.length / SESSION_COUNT) * 100).toFixed(1)}%)`,
  );
  console.log(
    `❌ Failed: ${failed.length} (${((failed.length / SESSION_COUNT) * 100).toFixed(1)}%)`,
  );
  console.log(`⏱️  Total Time: ${(totalTime / 1000).toFixed(2)}s`);

  if (connected.length > 0) {
    const avgConnectTime =
      connected.reduce((acc, r) => acc + r.connectTime, 0) / connected.length;
    const minConnectTime = Math.min(...connected.map((r) => r.connectTime));
    const maxConnectTime = Math.max(...connected.map((r) => r.connectTime));

    console.log("\n⚡ Connection Times:");
    console.log(`  Average: ${avgConnectTime.toFixed(0)}ms`);
    console.log(`  Min: ${minConnectTime}ms`);
    console.log(`  Max: ${maxConnectTime}ms`);

    const toolCounts = [...new Set(connected.map((r) => r.toolCount))];
    if (toolCounts.length === 1) {
      console.log(`\n🔧 Tools Available: ${toolCounts[0]}`);
    } else {
      console.log(`\n🔧 Tools Available: varies (${toolCounts.join(", ")})`);
    }

    // Show echo test results
    const echoSuccesses = connected.filter(
      (r) => r.echoResult && !r.echoResult.startsWith("Echo failed"),
    ).length;
    console.log(`\n📢 Echo Tool Tests:`);
    console.log(`  Successful: ${echoSuccesses}/${connected.length}`);
    if (echoSuccesses < connected.length) {
      const sampleFailure = connected.find((r) =>
        r.echoResult?.startsWith("Echo failed"),
      );
      if (sampleFailure) {
        console.log(`  Sample failure: ${sampleFailure.echoResult}`);
      }
    }
  }

  if (failed.length > 0) {
    console.log("\n⚠️  Failed Sessions:");
    const errorTypes = {};
    failed.forEach((r) => {
      errorTypes[r.error] = (errorTypes[r.error] || 0) + 1;
    });
    Object.entries(errorTypes).forEach(([error, count]) => {
      console.log(`  ${count}x: ${error}`);
    });
  }

  console.log("\n🧹 Cleaning up connections...");
  let closeCount = 0;
  for (const result of connected) {
    try {
      await result.client.close();
      closeCount++;
      if (closeCount % 20 === 0) {
        process.stdout.write(
          `  Closed ${closeCount}/${connected.length} sessions\r`,
        );
      }
    } catch (e) {}
  }
  console.log(`  ✓ Closed ${closeCount}/${connected.length} sessions    `);

  console.log("\n✨ Stress test complete!");
  process.exit(failed.length > SESSION_COUNT * 0.1 ? 1 : 0);
}

runStressTest().catch((error) => {
  console.error("Fatal error:", error);
  process.exit(1);
});

[khromov]

Thanks, I spun up the changeset in that PR, will know in ~24 hours if it worked or not. 🌞

[quuu]

@khromov feel free to use mcp-handler@0.0.0-1c08e814-2025081318112 for a snapshot published with the change!

[quuu]

@khromov checking in! how has it been?

[khromov]

I tried using the branch directly and that didn't seem to help. (This is a 7 day chart, I am restarting the Svelte MCP service every 24 hours hence the dips). Red outline is when I switched to new branch.

I will try the mcp-handler@0.0.0-1c08e814-2025081318112 release just in case I messed anything up when using the git branch, and I'll also try to get a heap snapshot again.

[quuu]

@khromov looking forward to hearing any updates!

[khromov]

The memory leak is under control now! I did a few other changes at the same time (such as simplifying some anonymous functions) when I updated mcp-adapter, so I need to roll back some changes and verify if it was the mcp-adapter fix or something in my code. Will get back in a few days.

[quuu]

@khromov thanks a lot! looking forward to hearing about your deep dive

[khromov]

@quuu Been testing this and can confirm that the proposed "mcp-handler": "^0.0.0-1c08e814-20250813181123", version solves the memory leak completely. Thank you for the patch!