Five ways to connect.
Memomee meets your stack where it already is — over HTTP, MCP, an editor plugin, the CLI, or the SDK. These are previews of the shape of each surface; memomee is invite-first while we finish the managed product, and the full documentation is coming to docs.memomee.ai.
Get early accessTalk to the memory layer over HTTP.
Append events, ingest conversation turns, and retrieve governed, task-scoped context over a REST API with API-key auth. Managed hosting is on the way for design partners.
Full docs coming to docs.memomee.ai · join the waitlist
curl -X POST https://api.memomee.ai/v1/retrieve \
-H "Authorization: Bearer mem_..." \
-H "Content-Type: application/json" \
-d '{ "query": "how does the user want to be contacted?" }'Give any MCP client governed memory.
Point Claude, Cursor, or Cline at memomee's Model Context Protocol server — 32 tools over Streamable HTTP, from write_event and retrieve to supersede, forget, and checkpoint_resume. Bearer-auth, fully audited.
Full docs coming to docs.memomee.ai · join the waitlist
{
"mcpServers": {
"memomee": {
"type": "http",
"url": "https://api.memomee.ai/mcp/",
"headers": { "Authorization": "Bearer ${MEMOMEE_API_KEY}" }
}
}
}Continuity for your coding agent.
Passive capture hooks record what your agent does; 11 slash commands give it explicit memory — checkpoint a task, recall where you left off, supersede a stale fact. Secrets are scrubbed before anything is stored.
Full docs coming to docs.memomee.ai · join the waitlist
/plugin install memomee-claude-code@synapti /memomee:checkpoint "finished the auth refactor" /memomee:recall "where did we leave the payment work?"
Scriptable memory from the terminal.
The memomee command drives the whole surface — tasks, events, facts with supersession and lineage, checkpoints, and the planned retrieval bundle — against a local store or a remote server.
Full docs coming to docs.memomee.ai · join the waitlist
memomee init memomee task create --name "onboard customer 42" memomee recall "what are their integration requirements?"
Write and recall from your app.
Async and sync clients — an in-process LocalClient over the embedded store, and an HTTP client for a hosted server that exposes the full write-derive-retrieve pipeline. Typed responses and errors throughout.
Full docs coming to docs.memomee.ai · join the waitlist
from memomee import AsyncMemomee
async with AsyncMemomee(api_key="mem_...") as m:
await m.write_event(actor="agent", actor_type="assistant",
event_type="decision",
payload_summary="user prefers email",
raw_payload={"channel": "email"})
ctx = await m.retrieve(query="how to contact the user?")Keep your framework. Govern its memory.
Memomee is framework-agnostic by design — events in, governed context out — so it slots under whatever orchestrates your agents rather than replacing it. These are illustrative integration shapes, built from the same calls as the previews above; they're the shape of the integration, not shipped adapters.
A governed-context node in the graph.
Add a node that retrieves task-scoped context into the graph state before the model runs, and write events back as nodes execute. The graph keeps orchestrating; memomee governs what it remembers.
async def memory_node(state: State) -> State:
ctx = await m.retrieve(query=state['objective'])
return {**state, 'memory': ctx}
async def record_node(state: State) -> State:
await m.write_event(actor='agent', actor_type='assistant',
event_type='step', payload_summary=state['last_action'],
raw_payload=state['last_result'])
return stateMemory that survives the crew.
Hook task callbacks to capture each agent's output as events, and inject governed context when a task kicks off — so the researcher and the writer act on the same, current truth instead of drifting summaries.
def on_task_start(task):
task.context = m.retrieve(query=task.description)
def on_task_end(task, output):
m.write_event(actor=task.agent, actor_type='assistant',
event_type='finding', payload_summary=output.summary,
raw_payload={'task': task.name})The loop, unwrapped.
No framework at all: retrieve a governed context block, answer from it, append what happened. This is the whole contract — everything else is orchestration you already own.
ctx = await m.retrieve(query=user_msg)
answer = await model.complete(prompt(ctx, user_msg))
await m.write_event(actor='user', actor_type='user',
event_type='message', payload_summary=user_msg)
await m.write_event(actor='agent', actor_type='assistant',
event_type='message', payload_summary=answer)Full framework guides are coming to docs.memomee.ai · join the waitlist