ChatDev Memory

How it works

1. Install chatdev-memorysync into your ChatDev environment.
2. A .pth hook auto-registers the store — type: memorysync becomes valid in YAML and appears in the web console dropdown. No code changes to ChatDev.
3. Declare the store once in your workflow’s memory: block and attach it to agents.
4. Retrieved memories arrive in ChatDev’s standard ===== Related Memories ===== prompt block; each writing node’s input is sent for fact extraction automatically.

Before you start

1. A MemorySync API key. Create one in the dashboard under Settings → API Keys, inside a project.
2. A ChatDev (DevAll) checkout running on Python 3.12 or newer.

Install

Inside your ChatDev checkout’s environment:

uv pip install chatdev-memorysync

Activation is automatic: the .pth hook registers the store whenever ChatDev’s modules are importable and silently no-ops anywhere else — installing this package can never affect an unrelated Python environment.

Wire it into a workflow

Step 1 — declare the store

Add a memorysync store to the workflow’s top-level memory: list. user_id is REQUIRED — the config parser rejects a store without it:

graph:
  memory:
    - name: user_memory
      type: memorysync
      config:
        api_key: ${MEMORYSYNC_API_KEY}
        user_id: customer-42        # REQUIRED
        session_id: support

Step 2 — attach it to an agent

Reference the store by name from any agent node. ChatDev’s own attachment knobs (top_k, read, write, retrieve_stage, similarity_threshold) are honored — similarity_threshold filters on real scores:

graph:
  nodes:
    - id: writer
      type: agent
      config:
        # ... model config ...
        memories:
          - name: user_memory
            top_k: 5
            retrieve_stage: [gen]
            read: true
            write: true

After each agent node that writes to the store (write: true, ChatDev’s default) runs, the store sends that node’s input — the request it received, with ChatDev’s === INPUT FROM … === pipeline headers stripped — to MemorySync as the user’s turn. MemorySync extracts the durable facts in it (preferences, constraints, details about the user) and only those facts become memories; the input text itself is not stored. Agent outputs are not sent. Facts carry surface: chatdev, your session_id, and role: input.

A downstream node’s input is what the upstream nodes produced, and it is sent the same way. To learn only from the user’s own words, keep write: true on the node that receives the user’s request and set write: false on the others (they can still read).

Step 3 — or click it together

In the ChatDev web console, memorysync appears in the store-type dropdown like any built-in store — fill in the same fields and attach it to agents visually. Run the workflow; retrieved memories show up in the agent’s ===== Related Memories ===== block.

Configuration

Quotas and plan limits

Hitting a monthly plan limit never breaks a workflow run. Over-limit writes are accepted without storing and recalls return empty — agents keep working without the Related Memories block. Evaluation keys instead surface a truthful 429, so limits show up in testing, not production.

Troubleshooting

• `type: memorysync` rejected — the package isn’t installed in the SAME environment ChatDev runs from. Reinstall with uv pip install chatdev-memorysync inside the checkout’s venv and restart.
• Config error about `user_id` — deliberate: the store refuses to start with all operators sharing one memory partition. Set a real per-user value.
• No Related Memories block — first runs have nothing to recall yet; also check the attachment has read: true and the store’s recall didn’t exceed the 1.2s fail-open budget (the log line carries the HTTP status if the service was unreachable).
• Re-running a workflow duplicated nothing — that’s the deterministic idempotency seeds working; a re-run of the same input in the same session is recognised server-side and extracted once.
• Facts from agent outputs are missing — by design: agent outputs are not stored as memories, and store_outputs has no effect. Only the durable facts in a writing node’s input are kept.

Supported versions

How it compares

Where to go next