EverMemOS

EverMemOS is an open source “memory operating system” developed by EverMind that adds durable, structured long-term memory to AI agents. Instead of treating every prompt as a fresh start, it lets LLM‑based assistants remember past interactions, build evolving user profiles, and reason with context over days, weeks, or months. Under the hood it uses a four‑layer architecture designed to mirror parts of human cognition: an agentic layer that plans memory tasks, a memory layer that stores and recalls information as structured units, an index layer that handles embeddings and keyword‑based search, and an API/MCP interface layer that connects to external services. The project is released under the Apache 2.0 license and is built to serve as a shared memory backbone for multiple agents and applications.

• Four‑Layer Memory Design: Separates agent behavior, long‑term storage, indexing, and integration, so teams can plug EverMemOS into existing systems as a centralized memory backbone without tight coupling.
• Structured MemCells and Multi‑Level Memories: Converts raw conversations into atomic MemCell units, then builds episodes, user profiles, preferences, semantic knowledge, and more—giving agents rich, queryable memories instead of loose text blobs.
• Hybrid Retrieval and Agentic Recall: Combines BM25 keyword search via Elasticsearch, vector retrieval via Milvus, reciprocal‑rank‑fusion (RRF), and optional LLM‑guided multi‑round retrieval, letting agents surface relevant memory while ignoring noise.
• Living Profiles and Personalization: Maintains continuously updated user profiles that learn preferences, habits, and relationships over time, so agents respond like a colleague who truly remembers previous chats.
• Benchmark‑Driven Memory Evaluation: Ships with an evaluation stack aligned with EverMind’s EverMemBench and related tools, and has reported state‑of‑the‑art scores such as 92.3 on LoCoMo and 82 on LongMemEval‑S for long‑term memory reasoning.
• Developer‑Friendly Infrastructure: Provides a Docker Compose file that spins up MongoDB, Elasticsearch, Milvus, and Redis, along with a Python API server offering REST endpoints for memorization and retrieval, plus ready‑to‑run demo applications.

1. Clone the repository and start the infrastructure: git clone the official EverMemOS repo, then run docker-compose up to launch the required backing services (MongoDB, Elasticsearch, Milvus, Redis) in one command.
2. Launch the API server: Start the Python‑based memory API server, which provides REST endpoints for storing memories, querying them, and managing user profiles.
3. Choose a retrieval mode: Configure the system to use BM25‑only, vector‑only, hybrid RRF, or LLM‑guided multi‑round retrieval depending on your latency, cost, and accuracy requirements.
4. Ingest raw conversations: Feed agent‑user dialogues through the /memorize endpoint. EverMemOS automatically converts them into MemCells, builds episodes, and updates user profiles.
5. Query memories in your agent: In your LLM‑agent code, call the retrieval API with a user ID and a natural language query to obtain a curated, context‑rich memory payload that can be injected into the model prompt.
6. Evaluate and iterate: Use the built‑in evaluation stack and EverMemBench benchmarks to measure memory accuracy and adjust retrieval strategies or memory‑building rules for your specific domain.

The core of EverMemOS is open source and released under the Apache 2.0 license, meaning it is free to use, modify, and deploy in both personal and commercial self‑hosted projects. There are no usage limits or license fees for the open source components. For organizations that want managed services, dedicated enterprise support, or private cloud deployments, EverMind offers custom enterprise plans. Those plans are handled directly through EverMind and do not have publicly listed price tiers at this time. Disclaimer: Pricing information may not be up to date. For the most accurate and current details, refer to the official EverMemOS website.

• Self‑hosted via Docker Compose: The complete stack (MongoDB, Elasticsearch, Milvus, Redis, API server) runs on your own infrastructure using a single Docker Compose file.
• Python API server with REST endpoints: The memory API exposes /memorize, /retrieve, and profile management endpoints, making it easy to integrate with any language that can call HTTP services.
• MCP (Memory Control Protocol) interface: A dedicated integration layer allows MCP‑compatible agent frameworks to use EverMemOS as a plug‑and‑play memory provider.
• Local demo applications: Ready‑to‑run CLI and chat demos let you experiment and debug memory behavior before integrating into a production agent.
• Platform‑agnostic core: Because the logic is containerized and API‑driven, EverMemOS can be deployed on cloud VMs, on‑prem servers, or even local development machines.

• Start with the quickstart demo: Use the included interactive chat demo to understand the full memory loop—ingestion, profile updates, and retrieval—within an hour before customizing.
• Tune retrieval mode to the task: For low‑latency scenarios, stick with BM25 or single‑stage vector search; save the more costly agentic multi‑round retrieval for complex, long‑context reasoning where precision is critical.
• Clean and archive old MemCells: Regularly review profiles and obsolete memories to keep retrieval fast and focused, especially when agents interact with hundreds of users over months.
• Leverage multi‑level memories deliberately: If your agent only needs episodic recall, you can skip profile updates or semantic knowledge to reduce storage and processing; enable the full stack only when personalization adds real value.
• Monitor infrastructure costs: The Docker stack runs MongoDB, Elasticsearch, Milvus, and Redis—plan resource allocation and scaling strategies early, particularly for high‑throughput production deployments.
• Test with your own benchmarks: While EverMemOS scores well on LoCoMo and LongMemEval‑S, create domain‑specific evaluation sets to ensure the memory system aligns with your exact user expectations.

• AI infrastructure teams that need a shared, versioned memory backbone for multiple internal agents, with full control over data and deployment.
• Product teams building agentic assistants, co‑pilots, or chatbots where remembering user context across sessions is a core requirement.
• Customer support automation providers who want bots to recall entire conversation histories and account details, rather than treating each ticket in isolation.
• Research labs and academic groups studying long‑term memory, retrieval‑augmented reasoning, and evaluation, especially those already working with benchmarks like EverMemBench.
• Security‑conscious organizations that prefer an open source, Apache‑2.0‑licensed solution they can deploy on‑premises or in their own VPC without vendor lock‑in.
• Developers comfortable with Docker and Python who want a memory layer that is transparent, inspectable, and fits into existing MCP‑based or REST‑based agent architectures.