DEV Community: Mohammed Rafay

How to Build Multi-Agent Systems with Shared Persistent Memory in Python (LangGraph + MemorySync)

Mohammed Rafay — Mon, 14 Sep 2026 09:50:03 +0000

Building multi-agent systems using frameworks like LangGraph, CrewAI, or AutoGen is one of the most exciting patterns in modern AI engineering.

Instead of a single massive prompt, you break tasks down into specialized agents:

Supervisor Agent: Coordinates requirements, plans architecture, and establishes rules.
Researcher Agent: Gathers documentation, API specs, and citations.
Coder Agent: Implements and tests code based on architecture decisions.

The Problem: Context Drift and Amnesia Across Agents

Most multi-agent frameworks use short-term execution graphs or in-memory state objects (like LangGraph's StateGraph or thread checkpointers). While this passes messages during a single run, it creates two major production bottlenecks:

Context Drift: Feeding a 20-page web dump from a Researcher agent directly into the Coder agent wastes tokens, degrades reasoning, and causes hallucinations.
Cross-Session Amnesia: When the workflow finishes and the developer returns tomorrow, the agents start with a blank slate. The Coder forgets the architecture decisions made by the Supervisor yesterday.

Below, we build a production multi-agent workflow using LangGraph where agents share a scoped, persistent memory layer via MemorySync.

Architecture: Shared Scoped Memory vs. State Bloat

Rather than passing monolithic chat histories between nodes in your state graph, agents read and write to an external scoped memory store:

Dimension	Native LangGraph StateGraph	MemorySync Shared Memory Layer
Persistence	Ephemeral (resets on process restart)	Durable across sessions and restarts
Context Window Cost	Linear growth with every intermediate agent output	Constant: queries retrieve only top-k relevant facts
Agent Isolation	Monolithic state visible to all nodes	Scoped recall (`tenant_id`, `project_id`, `agent_role`)
Deduplication	None (duplicate facts bloat context)	Automatic semantic deduplication and compaction
Latency	In-memory serialization	Sub-50ms hybrid vector retrieval

Prerequisites and Installation

Install the required Python packages:

pip install langgraph langchain-openai memorysync-python

Set your API keys:

export OPENAI_API_KEY="sk-..."
export MEMORYSYNC_API_KEY="ms_..."

Step 1: Initialize the Scoped Memory Client

MemorySync organizes memories using Scopes (tenant_id, project_id, and user_id). This ensures multi-agent workflows in one company or project never pollute another:

from memorysync import MemorySync
import os

memory = MemorySync(
    api_key=os.environ["MEMORYSYNC_API_KEY"],
    endpoint="https://api.memorysync.io"
)

PROJECT_SCOPE = {
    "tenant_id": "org_acme_corp",
    "project_id": "ai_agent_swarm_v1",
    "user_id": "lead_dev_01"
}

Step 2: Define Shared Memory Tools for Agents

We equip our agents with two tools: store_shared_memory and recall_shared_memory:

from langchain_core.tools import tool

@tool
def store_shared_memory(content: str, category: str = "architecture"):
    """Store an architectural decision or constraint into shared memory."""
    result = memory.add(
        content=content,
        tenant_id=PROJECT_SCOPE["tenant_id"],
        project_id=PROJECT_SCOPE["project_id"],
        metadata={
            "category": category,
            "recorded_by": "agent_worker"
        }
    )
    return f"Memory stored successfully with ID: {result.id}"

@tool
def recall_shared_memory(query: str, top_k: int = 3):
    """Search and recall relevant past architectural decisions or constraints."""
    memories = memory.query(
        query=query,
        tenant_id=PROJECT_SCOPE["tenant_id"],
        project_id=PROJECT_SCOPE["project_id"],
        top_k=top_k
    )

    if not memories:
        return "No relevant memories found in project scope."

    formatted = []
    for m in memories:
        formatted.append(f"- [Score: {m.score:.2f}] {m.content}")
    return "\n".join(formatted)

Step 3: Build the Multi-Agent Workflow in LangGraph

Now we connect our agents using LangGraph's StateGraph:

from typing import TypedDict, Annotated, Sequence
from langchain_core.messages import BaseMessage
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, END
import operator

class AgentState(TypedDict):
    messages: Annotated[Sequence[BaseMessage], operator.add]
    task: str
    current_agent: str

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.2)

def supervisor_node(state: AgentState):
    task = state["task"]
    past_context = recall_shared_memory.invoke({"query": task, "top_k": 3})

    system_prompt = f"""You are the System Architect.
Past Project Memory:
{past_context}

Break down the user's task into clear architectural constraints."""

    response = llm.invoke([
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": task}
    ])

    store_shared_memory.invoke({
        "content": response.content,
        "category": "architecture_constraint"
    })

    return {
        "messages": [response],
        "current_agent": "coder"
    }

def coder_node(state: AgentState):
    task = state["task"]
    recalled_rules = recall_shared_memory.invoke({
        "query": f"architecture constraints for {task}",
        "top_k": 2
    })

    system_prompt = f"""You are the Senior Implementation Engineer.
Follow these recalled project constraints strictly:
{recalled_rules}

Write clean, robust code that adheres to all project rules."""

    response = llm.invoke([
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": task}
    ])

    return {
        "messages": [response],
        "current_agent": "finished"
    }

workflow = StateGraph(AgentState)
workflow.add_node("supervisor", supervisor_node)
workflow.add_node("coder", coder_node)

workflow.set_entry_point("supervisor")
workflow.add_edge("supervisor", "coder")
workflow.add_edge("coder", END)

app = workflow.compile()

Step 4: Run the Cross-Session Verification Test

First, run Session 1 where the Supervisor establishes a strict constraint:

# Session 1: Establish project convention
inputs = {
    "task": "Design our user auth endpoints. Constraint: All timestamps must be ISO-8601 UTC and tokens expire in 15 minutes.",
    "messages": [],
    "current_agent": "start"
}

print("=== Running Session 1 ===")
for output in app.stream(inputs):
    for key, value in output.items():
        print(f"[{key.upper()} Finished]: {value['messages'][-1].content[:150]}...\n")

Now, simulate a fresh process restart tomorrow. The Coder is asked to write a new profile endpoint without re-explaining the timestamp rule:

# Session 2: Fresh session, different prompt
fresh_inputs = {
    "task": "Write the GET /user/profile endpoint response handler.",
    "messages": [],
    "current_agent": "start"
}

print("=== Running Session 2 (Fresh Restart) ===")
for output in app.stream(fresh_inputs):
    for key, value in output.items():
        print(f"[{key.upper()} Output]:\n{value['messages'][-1].content}\n")

Result

The Coder agent automatically recalls:

"Constraint from past session: All timestamps must be ISO-8601 UTC and tokens expire in 15 minutes."

The generated endpoint includes datetime.now(timezone.utc).isoformat() without the developer ever re-typing the requirement.

Key Takeaways

Zero Prompt Bloat: Instead of passing 50,000-token histories across agents, workers query 2ΓÇô3 relevant facts into context.
Full Auditability: Every recalled fact carries an explicit memory ID and score, making agent behavior reproducible.
Multi-Tenant Isolation: tenant_id prevents data leakage across client accounts or disparate agent swarms.

Resources

Interactive Documentation: docs.memorysync.io/guides/langgraph
Model Context Protocol (MCP) Server: docs.memorysync.io/mcp
Quickstart Guide: docs.memorysync.io/quickstart

How to Give Cursor and Claude Code Persistent Memory Across Sessions via MCP

Mohammed Rafay — Sun, 13 Sep 2026 10:15:52 +0000

How to Give Cursor and Claude Code Long-Term Memory Across Sessions via MCP

By MemorySync Team ΓÇó Published September 2026 ΓÇó 8 min read

The Problem: Context Amnesia in AI Coding Assistants

If you use Cursor, Claude Code, or Claude Desktop for serious software development, you have encountered this daily frustration:

You explain your project's architecture, database conventions, and pinned dependency versions in one chat session. An hour later, you open a new chatΓÇöand the model has completely forgotten everything.

Developers typically resort to two flawed workarounds:

Static Rules Files (.cursorrules / CLAUDE.md): As your project grows, these files bloat to thousands of lines, eating up expensive context window tokens on every single query and causing the model to miss instructions.
Copy-Pasting Context: You waste the first 5 minutes of every coding session copying past decisions, API schemas, and test conventions.

What coding agents need is durable, semantic, cross-session memory: the ability to store architectural decisions once, and automatically recall only the relevant facts when a specific question is asked in a fresh conversation.

In this guide, we will set up persistent long-term memory for Cursor and Claude Code in under 60 seconds using the Model Context Protocol (MCP) and MemorySync.

How It Works: The Remote MCP Memory Architecture

The Model Context Protocol (MCP) is the open standard developed by Anthropic that allows LLMs to interact with external tools and state.

MemorySync provides a high-speed, remote MCP memory server:

Key Architectural Advantages:

Zero Local Daemons: No Docker containers, Python venvs, or local Postgres/Qdrant processes running on your laptop.
Cross-Client Synchronization: Decisions saved in Cursor while writing frontend code are instantly accessible to Claude Code running in your CLI terminal.
Cryptographic Isolation: Every memory is strictly isolated by X-Project-ID and X-End-User-ID, preventing cross-project context pollution.
Auditability: Every recalled memory has an immutable ID and timestamp, so you always know why the model made a specific architectural choice.

60-Second Setup: Cursor

Option A: Install via Cursor Directory (1-Click)

Visit the official listing on cursor.directory/plugins/memorysync.
Click Install Plugin to automatically configure the MCP server, rules, and memory hooks.

Option B: Manual Configuration

In Cursor, open Settings (Ctrl + , or Cmd + ,) -> Features -> MCP Servers.
Click + Add New MCP Server.

Fill in the connection parameters:

Name: memorysync
Type: sse
Server URL: https://mcp.memorysync.io/mcp
Headers:

 {
   "Authorization": "Bearer YOUR_MEMORYSYNC_API_KEY",
   "X-Project-ID": "your-project-slug"
 }

Click Save. Cursor will verify the connection and show a green dot next to memorysync.

(You can get a free API key at app.memorysync.io).

60-Second Setup: Claude Code & Claude Desktop

For Claude Desktop:

Open your claude_desktop_config.json:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

Add the MemorySync MCP server definition:

{
  "mcpServers": {
    "memorysync": {
      "url": "https://mcp.memorysync.io/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_MEMORYSYNC_API_KEY",
        "X-Project-ID": "your-project-slug"
      }
    }
  }
}

For Claude Code (Terminal CLI):

Run the following command in your terminal:

claude mcp add memorysync https://mcp.memorysync.io/mcp --header "Authorization: Bearer YOUR_MEMORYSYNC_API_KEY" --header "X-Project-ID: your-project-slug"

Verifying Persistent Memory: The "Fresh Session" Test

To prove that memory persists across chat sessions, run this quick 2-minute test:

Step 1: Store an Architecture Constraint (Session 1)

In Cursor or Claude, start a chat and write:

"Remember this project decision: All API endpoints must use strict UTC ISO-8601 timestamps with millisecond precision (e.g., 2026-09-13T12:00:00.000Z). Do not use Unix epoch integers."

The model will invoke save_memory via the MemorySync MCP server:

{
  "status": "success",
  "memory_id": "mem_9f82a1b",
  "stored": "All API endpoints must use strict UTC ISO-8601 timestamps with millisecond precision. Do not use Unix epoch integers."
}

Step 2: Open a Brand New Chat (Session 2)

Close the current chat window.
Open a completely fresh chat session (do not mention the rule from Step 1).
Ask the assistant: > "Write a FastAPI route that returns the current server status and response timestamp."

Step 3: Observe Automatic Retrieval

Notice what happens before the model writes the code:

It automatically calls query_memory(query="server timestamp API endpoint").
MemorySync returns mem_9f82a1b.
The generated code strictly uses datetime.now(timezone.utc).isoformat(timespec='milliseconds') instead of time.time().

The model recalled your architecture rule without you re-explaining it.

Comparison: How MemorySync Compares to Alternatives

Capability	MemorySync (MCP)	Mem0	Zep	Static `.cursorrules`
Model Context Protocol (MCP)	Native Remote SSE	Custom tool wrapper	REST API	None (Static file)
Setup Overhead	60 Seconds (1-line)	Requires Python environment	Complex cloud dashboard	Manual copy/paste
Cross-IDE Sync	Cursor + Claude Code synced	Single environment	Single environment	Workspace-local only
Token Efficiency	High (Dynamic semantic recall)	Moderate	Moderate	Poor (Consumes prompt tokens every turn)
Multi-Tenant Isolation	Cryptographic Headers	String filtering	Session IDs	None
Free Tier / Zero Cost	Free Community Tier	Self-hosted or Cloud	Paid Cloud	Free

Next Steps

Read the Documentation: docs.memorysync.io/guides/cursor
Explore Migration Guides: Migrating from Mem0 or Migrating from Zep
Join the Community: Star and explore the official Cursor plugin at cursor.directory/plugins/memorysync