Memori
Persistent, structured memory from agent execution and conversation.
Per-dimension scores and reasoning
Evidence shows: SDK requires API keys but least privilege is not explicit; user confirmation mechanism absent; data flow transparency limited, only mentions background capture; sensitive data handling not detailed; dependency security has bandit and pip-audit in CI, but pip-audit failure does not block; external effects include installing plugins to Hermes directory but requires user action; rollback mechanism not mentioned; source attribution has author info but publisher unverified. Deductions: lack of user confirmation, opaque data flow, unclear sensitive data handling, no rollback.
Evidence shows: README and pyproject versions consistent (3.3.7), CI configuration complete, tests cover multiple Python versions; dependencies declared clearly but availability not verified; failure messages present in tests (e.g., missing dependency prompts pip install memori). Deductions: dependency availability not actually verified, failure message coverage limited.
Evidence shows: targets developers, supports multiple LLMs, frameworks, and platforms, clear scenarios (memory persistence); capability boundaries described in docs (e.g., requires attribution); triggers clear (automatic capture and explicit tools); environment fit broad (cloud, VPC, on-prem). Deductions: capability boundaries and trigger precision partially rely on docs, not fully verified.
Evidence shows: clear information architecture with README and docs links; detailed install notes (npm, pip); stable naming (SDK names consistent); rich examples (quickstart, OpenClaw, Hermes); known limitations mentioned sparsely; license Apache 2.0; version number exists, CHANGELOG link present; maintenance responsibility has contributing guide. Deductions: known limitations insufficient, changelog not directly provided.
Evidence shows: high output usability with SDK and CLI; clear marginal value (solves agent memory problem); cost-benefit supported by benchmark data (LoCoMo 87% accuracy, low token usage). Deductions: cost-benefit data not independently verified.
Evidence shows: README claims supported by docs and benchmarks; cross-source corroboration limited (only internal docs); fact-inference separation good (benchmark data clearly labeled). Deductions: insufficient cross-source verification.
- Publisher identity unverified; exercise caution.
- Data flow transparency limited; background capture may involve sensitive data; review needed.
- Dependency security scan (pip-audit) failure does not block CI, potentially introducing vulnerabilities.
- Rollback mechanism absent; upgrades or config changes may be hard to revert.
What does this agent do, and when should you use it?
Memori is production-oriented memory infrastructure for agents, with Python and TypeScript SDKs. It registers with an existing LLM client, records conversations in the background, and persists or recalls memory scoped by entity, process, and session. Advanced Augmentation organizes memory into attributes, events, facts, preferences, relationships, rules, skills, and related structures. The repository also ships an OpenClaw plugin, a Hermes Agent memory provider, and an HTTP MCP service for clients including Claude Code and Codex. It describes cloud, single-tenant cloud, VPC, on-premises, and BYODB paths, although their detailed deployment configuration is outside the supplied material.
After installing memori or @memorilabs/memori, a developer creates Memori() and registers an LLM client with .llm.register(client), then assigns an entity and process through attribution. Calls such as client.chat.completions.create(...) are recorded, and later calls can automatically receive persisted conversational memory. Session boundaries can be managed with new_session(), set_session(session_id), resetSession(), or setSession(sessionId). The OpenClaw plugin captures conversation and execution after each turn; the Hermes provider exposes memori_recall and memori_recall_summary; compatible clients can connect to the MCP endpoint over HTTP.
- A support-assistant team using OpenAI Chat Completions or the Responses API that needs to retain customer facts and preferences across requests.
- A developer operating a multi-step agent who needs interactions from one execution to be grouped into a single session.
- An OpenClaw gateway operator installing
@memorilabs/openclaw-memorito retain tool calls, decisions, and outcomes without changing prompts or agent code. - A Hermes Agent user configuring
memory.provider memoriso completed conversations can be retrieved through explicit recall tools. - A developer using Claude Code, Codex, Cursor, or Warp who wants MCP-connected memory for coding conventions, review preferences, and project context.
What are this agent's strengths and limitations?
- It offers Python, TypeScript, OpenClaw, Hermes, and MCP integration paths, covering both SDK interception and protocol-based clients.
- Memory is explicitly scoped by entity, process, and session, which supports separation across users, agents, and task runs.
- The README lists Anthropic, Bedrock, DeepSeek, Gemini, Grok, and OpenAI support, including streamed, unstreamed, synchronous, and asynchronous use.
- Its OpenClaw integration automatically captures conversations, tool calls, decisions, and outcomes without prompt or agent-code changes.
- The SDK quickstart depends on
MEMORI_API_KEYplus an API key for the chosen LLM provider. - Memori cannot create memories when entity and process attribution are not supplied.
- Advanced Augmentation is rate-limited without an account; higher limits require signup or an API key.
- The published LoCoMo figures are repository-reported benchmark results, so accuracy, token usage, and cost still need validation against the intended workload and configuration.
How do you install or deploy this agent?
For TypeScript, run npm install @memorilabs/memori. For Python, run pip install memori. The cloud quickstart requires MEMORI_API_KEY and an API key for the selected LLM provider; the supplied example uses OPENAI_API_KEY. For OpenClaw, run openclaw plugins install @memorilabs/openclaw-memori, followed by openclaw plugins enable openclaw-memori.
How do you use this agent?
A first Python invocation can use from memori import Memori, from openai import OpenAI, client = OpenAI(), and mem = Memori().llm.register(client), then mem.attribution(entity_id="user_123", process_id="support_agent") before calling client.chat.completions.create(...). The TypeScript equivalent is const client = new OpenAI(); const mem = new Memori().llm.register(client).attribution('user_123', 'support_agent');. The MCP example connects to https://api.memorilabs.ai/mcp/ with X-Memori-API-Key, X-Memori-Entity-Id, and X-Memori-Process-Id headers.
How does this agent compare with similar options?
The README reports 87% overall accuracy and an average of 721 tokens per query on the LoCoMo long-conversation benchmark, and states that Memori outperformed Zep, LangMem, and Mem0. It also claims more than 36x lower context cost than full-context prompting; these comparisons apply only to the described benchmark setting.