How to add persistence sessions when working with langgraph

[monotykamary]

I have a super simple example that I use with langgraph dev where my config is:

{
  "dependencies": ["."],
  "graphs": {
    "agent": "./src/agent/graph.py:make_graph"
  },
  "env": ".env"
}

where agent invokes the make_graph function.

"""MCP client."""

import os

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent


SERVER_CONFIGS = {
    "playwright": {
        "command": "npx",
        "args": ["-y", "@playwright/mcp@latest"],
        "transport": "stdio",
    },
}

client = MultiServerMCPClient(SERVER_CONFIGS)


async def make_graph():
    """make_graph."""
    tools = await client.get_tools()
    agent = create_react_agent(
        "google_genai:gemini-2.5-pro-preview-05-06",
        tools,
    )
    return agent

However, when running playwright, the session gets cut off as each new tool call creates a new session. I have read here and there that the recommended solution is to add a session:

"""MCP client."""

import os

from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain_mcp_adapters.tools import load_mcp_tools
from langgraph.prebuilt import create_react_agent


SERVER_CONFIGS = {
    "playwright": {
        "command": "npx",
        "args": ["-y", "@playwright/mcp@latest"],
        "transport": "stdio",
    },
}

client = MultiServerMCPClient(SERVER_CONFIGS)


async def make_graph():
    """make_graph."""
    agent = None
    async with client.session("playwright") as session:
        tools = await load_mcp_tools(session)
        agent = create_react_agent(
            "google_genai:gemini-2.5-pro-preview-05-06",
            tools,
        )
    return agent

But I consistently get this error when the LLM attempts to run any of the tools in playwright:

Error: ClosedResourceError() Please fix your mistakes.

Am I doing something wrong here or am I missing something fundamental?

[l2leonardo]

I have the same issue with respect of not having a way to maintain the session open while langgraph is running, However, given that each MCP server needs its own Session, this would be impraticable very fast if you had an agent connected to many MCP Servers. That's why I think the default implementation is to open a new Session at every tool call...

Curious to see if there is any workaround this as well. It has been such an issue that I even explored other options. Some MCP servers can be very slow to open connections/sessions to and this is starting to become a bottleneck.

[pokutuna]

I was facing the same issue, but I found a solution after some investigation.
Sharing it here in case it helps others.

The following make_graph function works when specified in langgraph.json:

from contextlib import asynccontextmanager

@asynccontextmanager
async def make_graph():
    async with client.session("playwright") as session:
        tools = await load_mcp_tools(session)
        yield create_react_agent(model=model, tools=tools)

And you also need to use --allow-blocking because Playwright MCP may use subprocess:

$ langgraph dev --allow-blocking

The filename:attr_or_func setting in langgraph.json is interpreted by the langgraph_api package.
(I couldn't find this code on GitHub, so I read the package contents. Where is this repo?)

It appears that langgraph_api has implemented a mechanism to distinguish and call different types including not just simple variables/functions, but also contextmanager, asynccontextmanager, and coroutines. Therefore, this approach works.

---

Session handling in your code won't work properly with stateful MCP servers.

For example, Playwright requires sequential tool calls like
browser_navigate → browser_snapshot → browser_click to navigate pages.

These operations require a session (I believe you understand this), but the session ends when you exit the scope of async with client.session("playwright").

async def make_graph():
    agent = None
    async with client.session("playwright") as session:
        # <- session starts here
        tools = await load_mcp_tools(session)
        agent = create_react_agent(
            "google_genai:gemini-2.5-pro-preview-05-06",
            tools,
        )
        # <- session ends here
    return agent  # <- session is already closed

appendix

The TypeScript @langchain/mcp-adapters doesn't have session isolation - the MCP server connection stays open and is easier to use. However, this means you need to manage state independently from graph execution. If multiple users or executions share the same MCP client, they might see each other's state (which could be a security issue)

[l2leonardo]

Thanks for the write up @pokutuna. I wonder what would be the solution in case you have 2+ MCP servers? Openning the session at the graph generation as the code above will only concede you access to playwright...

So far this seems very counter intuitive with the notion that MCP clients want to connect to dozens of MCP servers at once.

[pokutuna]

@l2leonardo
You need to create sessions and load tools for each server, then pass them all together to the agent.

like this:

@asynccontextmanager
async def make_graph():
    async with (
        mcp_client.session("playwright") as s1,
        mcp_client.session("fetch") as s2, 
    ):
        tools = [
            *await load_mcp_tools(s1),
            *await load_mcp_tools(s2),
        ]
        yield create_react_agent(model=model, tools=tools)

To apply this approach to an arbitrary number of servers, you can use contextlib.AsyncExitStack and asyncio.gather:

server_names = ["playwright", "fetch"] # or mcp_client.connections.keys()

@asynccontextmanager
async def make_graph():
    async with AsyncExitStack() as st:
        sessions = [
            await st.enter_async_context(mcp_client.session(server))
            for server in server_names
        ]
        tools = sum(await asyncio.gather(*map(load_mcp_tools, sessions)), [])
        yield create_react_agent(model=model, tools=tools)

[soamati]

Hello everyone, I'm using the TypeScript mcp-adapters package.

So @pokutuna if I understood well, the right and only approach here is to create a new client in every request? User context and identification works well thanks to threadId's and passing JWT on client initialization, but I'm not sure if this is optimal, did you find a better way?

[eyurtsev]

To do it:

• Use the mcp sdk to create a session
• You can then use tooling in the adapters package to create tools for the given session

But keep in mind that this solution will create a new session with every request to langgraph, so it won't work in a conversational setting.

@asynccontextmanager
async def make_graph():
    async with (
        mcp_client.session("playwright") as s1,
        mcp_client.session("fetch") as s2, 
    ):
        tools = [
            *await load_mcp_tools(s1),
            *await load_mcp_tools(s2),
        ]
        yield create_react_agent(model=model, tools=tools)