memU Frequently Asked Questions
Installation, host adapters, automatic skill extraction, retrieval, shared scopes, and deployment.
memU is a lightweight, agent-driven memory system for the agents you already use. It gives connected agents one shared, inspectable memory layer across sessions, agents, and devices, and can turn useful agent history into reusable Markdown skills.
The installation skill teaches the host agent how to install and configure its memU adapter. After setup, the agent uses the adapter's CLI as part of its normal workflow: session history is prepared for memory work, and relevant recall files are injected before future tasks. Users do not need to design or maintain a separate API integration.
Get an API key from memu.so, then send the installation prompt shown there to your agent.
- The agent reads the memU installation skill.
- It identifies the current host and installs the matching adapter.
- It configures the shared Cloud backend and verifies the record and retrieval seams.
- Run the same setup in another host to connect that agent to the same memory.
Ask your agent to read the open-source SKILL.md in the memU GitHub repository and follow its installation instructions. Self-hosted mode requires an embedding provider and a local storage configuration.
- SQLite is the default choice for private, single-device use.
- Postgres with pgvector supports larger stores and concurrent access.
- The in-memory backend is intended for tests and disposable sessions.
memU includes dedicated host adapters for:
- Codex
- Claude Code
- Cursor Agent and Cursor CLI
- OpenClaw
- Hermes Agent
- WorkBuddy
For other agents, the generic memu-agent adapter can inspect compatible JSONL session logs and instruction files such as AGENTS.md, CLAUDE.md, or SOUL.md.
Each host adapter connects two parts of the agent workflow:
- Record: a scheduled bridge reads new sessions and prepares self-contained jobs for the host agent.
- Inject: a standing instruction tells the host agent to retrieve relevant memory before it answers.
The adapter handles host-specific session paths and instruction files while the memory workflow stays shared.
Once the scheduled bridge is active, memU can turn useful session history into reusable skills:
- The adapter captures new messages and tool calls.
- It prepares a self-contained job with the required paths and context.
- The host agent reads related skills and chooses no change, a patch, or a new skill.
- The agent writes readable Markdown with a name, description, workflow, edge cases, and pitfalls.
- memU commits the changed files and indexes them under the skill track.
No. A scheduled task can prepare each new session for review, but the host agent decides whether anything is reusable. It may leave memory unchanged, improve an existing file, or create a new one. This keeps judgment in the agent instead of treating every transcript as durable memory.
No. The memory service makes no LLM or chat calls. Judgment, synthesis, and Markdown writing stay inside the host agent. memU stores the result, creates embeddings, and retrieves relevant context.
The retrieval path is embedding-only and does not invoke an LLM:
- The query is embedded once.
- Recall-file segments are ranked by vector similarity.
- Matching segments roll up to their complete memory or skill files.
- Workspace resource records are ranked and returned separately.
There is no BM25 fusion, graph traversal, query rewriting, sufficiency check, or summarization call in the current retrieval path.
The current memory model has three main record types:
- Recall files: readable memory or skill Markdown with a name, description, content, and track.
- Recall-file segments: searchable text slices and their embeddings.
- Resources: indexed workspace records containing path and descriptive metadata.
Yes. The agent-facing memory and skill artifacts are readable Markdown. Cloud users can view their memory files through memU Cloud, while self-hosted installations keep the committed records in the configured SQLite or Postgres store.
Every configured host adapter uses the backend selected in the shared memU configuration. When two hosts use the same backend and the same user and agent scope, memory or skills learned from one host can be retrieved by the other. Use different scope values when contexts should remain separate.
- memU Cloud: managed, cross-device memory configured with a memU Cloud API key.
- Self-hosted: private storage under your control, normally SQLite or Postgres, plus your own embedding provider credentials.
The host adapters and Skill-driven workflow remain the same in both modes.
Self-hosted memU supports OpenAI, Jina, Voyage, Doubao, and OpenRouter embedding providers. The provider, model, API key, and optional base URL are configured through the memU environment settings.
Run memu-agent detect. The generic adapter checks whether it can recognize the agent's session logs for memorization and an instruction file for retrieval. If both seams are available, it can use the same prepare, commit, and retrieve workflow as a dedicated adapter.
Run the selected host adapter's doctor command. It reports the resolved configuration and backend mode, then performs a live retrieval through the same path the host uses. This is the quickest way to identify missing credentials, storage configuration, or retrieval setup.
Yes. memU is available on GitHub under the Apache-2.0 license. The repository contains the Python package, CLI, installation skill, and host adapters.
- Use GitHub Issues for bugs and feature requests.
- Join the memU Discord community for discussion and support.
- Open a pull request to contribute code, tests, documentation, or a new host adapter.