**Memory Leak** in MCP Server – will be a memory leak until OOM (Out of Memory) occurs

[MadanMaram]

Initial Checks

• I confirm that I'm using the latest version of MCP Python SDK
• I confirm that I searched for my issue in https://github.com/modelcontextprotocol/python-sdk/issues before opening this issue

Description

As part of our usage of FastMCP and Python MCP SDK, we observed a memory leak in the MCP server. When the client continuously calls a simple tool (e.g., a greet function), the server's memory usage steadily increases over time and does not get released, eventually leading to an Out of Memory (OOM) condition.

This issue is reproducible both in the fastmcp library and the MCP SDK.

Issue

Here is the Logs:Memory will keep increasing
memory_log_pythonmcp.txt

Example Code

Server.py
----------------------------------------------------
from mcp.server.fastmcp import FastMCP

# Create an MCP server
mcp = FastMCP("Demo Server")

# Add a simple tool
@mcp.tool()
def greet(name: str) -> str:
    """Return a greeting message."""
    return f"Hello, {name}!"

if __name__ == "__main__":
    # Run the server with streamable HTTP transport
    mcp.run(transport="streamable-http")

--------------------------------------------------
client.py(（with a while loop）
---------------------------------------------------
import asyncio
from mcp.client.streamable_http import streamablehttp_client
from mcp.client.session import ClientSession

async def call_tool(name: str):
    # Connect to the MCP server using streamable HTTP
    async with streamablehttp_client("http://127.0.0.1:8000/mcp") as (read, write, _):
        async with ClientSession(read, write) as session:
            # Initialize the connection
            await session.initialize()
            # Call the 'greet' tool
            result = await session.call_tool("greet", {"name": name})
            print(result)

async def main():
    while True:
        await call_tool("Bob")

if __name__ == "__main__":
    asyncio.run(main())
--------------------------------------------

Python & MCP Python SDK

Environment:

Python: 3.12.1

MCP Python SDK: 1.10.1

[yaronday]

Hi @MadanMaram,

The mem issue you observed has randomly caught my eye, and if I got it correctly, it looks like your current client implementation simply creates a new connection per call, which might result in such a monotonic memory usage growth on the MCP server.

Have you tried refactoring it, e.g. reusing a single connection and session for multiple tool calls?
Establishing multiple connections so rapidly is very likely to overwhelm the server's ability to garbage-collect
unused objects, leading to such an increase in memory consumption.

Could you please try rechecking the issue by running the refactored client code below
(of course after stopping the client and restarting the MCP server, ensuring a clean slate for its mem usage)?

client.py

import asyncio
import logging
from mcp.client.streamable_http import streamablehttp_client
from mcp.client.session import ClientSession


logging.basicConfig(filename='client.log',
                    level=logging.INFO,
                    format='%(asctime)s - %(levelname)s: %(message)s',
                    datefmt='%d-%m-%Y %H:%M:%S')
lgr = logging.getLogger(__name__)


async def run_greet_session(name: str) -> None:
    """Establish a client session once and repeatedly call the 'greet' tool"""
    try:
        async with streamablehttp_client("http://127.0.0.1:8000/mcp") as (read, write, _):
            async with ClientSession(read, write) as session:
                await session.initialize()
                lgr.info(f"Session started. Greeting '{name}'.")
                
                # Reuse the same session for all tool calls
                while True:
                    try:
                        result = await session.call_tool("greet", {"name": name})
                        lgr.info(f"Result: {result}")
                    except Exception as e:
                        lgr.error(f"An error occurred during tool call: {e}")
                        break
    except asyncio.CancelledError:
        lgr.info("Client session cancelled.")
    except Exception as e:
        lgr.error(f"A connection error occurred: {e}")


async def main():
    await run_greet_session(name="Bob")


if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        lgr.info("Client manually interrupted!")

[Kludex]

Your text file doesn't show a leak, it just shows the memory increased.

Closing this issue, since I couldn't visualize the leak with memray.