Developer FAQ

1. Performance & Latency

MemorySync retrieval is a hybrid search (keyword plus vector) that runs on the server, so its latency is the server time plus the network path between your application and the API. Both numbers below were measured against production, not estimated.

• Every query response carries latency_ms, so you can measure it from your own region rather than trust a published figure.
• Round-trip time depends mostly on distance to the API and on connection reuse; a long-lived HTTP client that keeps connections open avoids paying TLS on every call.
• Retrieve once per task, not once per model token or tool call, and memory stays a small part of a turn that is usually dominated by model generation.

2. Token Economics & Cost Reduction

An agent that re-sends its whole history pays for every earlier turn again on each call, so its prompts grow with the length of the session. Retrieving only the memories a task needs keeps the prompt about the same size however long the session runs.

• Shorter prompts start faster: prefill time grows with prompt length, so sending 1,200 tokens instead of 45,000 shortens time-to-first-token. How much depends on the model and the provider.
• Less gets lost in the middle: models use information at the start and end of a long context better than information in the middle (Liu et al., 2023, "Lost in the Middle"). A short prompt with only the relevant facts avoids burying them.
• Requirements stay in view: integrations that recall memory before each reply put the relevant facts back into the prompt every turn, so a constraint stated early does not scroll out of the window.

3. Security, Privacy & Multi-Tenancy

MemorySync is built for applications that serve many end users from one API key, so every call is scoped to a single end user.

4. Namespaces & End-User Scoping

MemorySync enforces a three-tier hierarchical scope for every write and retrieval operation: project_id, end_user_id, and optional session_id.

• Project Boundaries: An API key is permanently scoped to a single project. Requests attempting to access resources from another project are rejected with HTTP 403 Forbidden.
• End-User Isolation: Every query is filtered to the end_user_id it names, so a query made for User A only searches User A’s memories. Your application decides which end user a request is for, so authorize the user in your own app before calling MemorySync.
• Shared Team Standards: To share organizational conventions across all team members, use a workspace-level identifier as the end_user_id (e.g. team-engineering).

5. MCP & IDE Integration

MemorySync runs a hosted MCP server at https://mcp.memorysync.io/mcp, so a coding assistant can store and search memory without a local server. Without an API key, clients sign you in with OAuth on first use.

{
  "mcpServers": {
    "memorysync": {
      "url": "https://mcp.memorysync.io/mcp"
    },
    "memorysync-docs": {
      "url": "https://docs.memorysync.io/mcp"
    }
  }
}

• No local server: Cursor, Claude Code, VS Code and other clients that accept a URL connect over Streamable HTTP. Claude Desktop’s config file starts local servers only, so it connects through the mcp-remote bridge, which needs Node.js.
• Fifteen tools, including search_memory, add_memory, get_memory, update_memory and delete_memory. tools/list returns the full set.
• Shared memory: two agents that use the same key and end-user ID, such as a planning agent and a coding agent, read and write the same memories.

6. Lifecycle & State Invalidation

Context changes over time. These are the controls MemorySync gives you for keeping it current, and what it does on its own.

• Facts outside those one-value slots are kept side by side with their timestamps: "uses MySQL" and "moved to Postgres" both come back until you delete the old one.
• Deleted memories stay deleted: forget removes the record and its vector, so a deleted memory does not come back in search.
• Summaries keep their sources: a summary records the IDs of the memories it condenses.

7. Ecosystem Comparison & Free Tier

How does MemorySync compare to other memory and state solutions in the AI agent ecosystem?