MCP Resource for LangGraph

A developer used MCP's Resource primitive to fix a LangGraph-based support bot that lost conversation context, enabling efficient knowledge graph updates and retrieval across tool calls. The approach centralizes device information in a Resource, allowing the agent to maintain coherent conversations and provide accurate troubleshooting. The developer warns against over-engineering Resources to avoid brittle knowledge graphs.

I was recently debugging a support bot built with LangGraph, where the agent would consistently forget the context of the conversation after a few turns. The bot would ask the user to repeat information they had already provided, leading to a frustrating experience. Upon closer inspection, I realized that the issue stemmed from the fact that the agent's knowledge graph was not being properly updated and retrieved across multiple tool calls. The agent was essentially starting from scratch every time it received a new input, which made it impossible to maintain a coherent conversation. This is where MCP's Resource primitive comes into play. The Resource primitive allows us to define a knowledge graph that can be efficiently updated and retrieved across multiple tool calls and conversation turns. By using the Resource primitive, we can create a centralized store of information that the agent can draw upon to inform its decisions and actions. To illustrate this, let's consider an example where we're building a support bot that helps users troubleshoot issues with their devices. We can define a Resource that represents the user's device information, which includes details such as the device type, operating system, and any error messages they've encountered. We can then use this Resource to inform the agent's responses and actions, such as providing troubleshooting steps or escalating the issue to a human support agent. Here's an example of how we might implement this using MCP's Resource primitive and LangGraph: python import langgraph from mcp import Resource Define the device information Resource device info resource = Resource name="device info", attributes= {"name": "device type", "type": "string"}, {"name": "operating system", "type": "string"}, {"name": "error messages", "type": "list<string "} Create a LangGraph agent that uses the device information Resource agent = langgraph.Agent Define a node in the agent's graph that retrieves the device information Resource device info node = agent.add node name="get device info", func=lambda: device info resource.get Define a node in the agent's graph that updates the device information Resource update device info node = agent.add node name="update device info", func=lambda device type, operating system, error messages: device info resource.update device type=device type, operating system=operating system, error messages=error messages Define a conditional edge between the nodes agent.add conditional edges from node=device info node, to node=update device info node, condition=lambda device info: device info is None Run the agent agent.run In this example, we define a Resource called device info that represents the user's device information. We then create a LangGraph agent that uses this Resource to inform its decisions and actions. The agent has two nodes: one that retrieves the device information Resource, and another that updates the Resource. The agent uses a conditional edge to determine which node to execute based on the current state of the Resource. One practical gotcha to watch out for when using MCP's Resource primitive is that it can be easy to over-engineer the Resource, leading to a complex and brittle knowledge graph. It's essential to strike a balance between providing enough information to inform the agent's decisions and actions, and avoiding unnecessary complexity. As we continue to build more sophisticated agentic AI systems, we'll need to explore new ways to manage complexity and ensure that our agents are able to effectively retrieve and update information across multiple tool calls and conversation turns. Tomorrow, we'll dive deeper into the challenges of scaling LangGraph agents to handle increasingly complex tasks and scenarios.