AI/TLDR

MemOS

A memory operating system that gives LLM agents persistent, manageable long-term memory

Overview

MemOS is an open-source memory layer for large language models and AI agents. It unifies the three jobs of long-term memory — storing, retrieving, and managing it — behind a single API, so an agent can remember facts about a user across many conversations instead of starting fresh each time.

It is built for developers who are wiring memory into chatbots, assistants, or multi-agent systems and want an inspectable store rather than a black-box embedding index. Memory is structured as a graph you can read and edit, and you can correct or delete individual memories with natural-language feedback or by ID.

Within the agent-memory space, MemOS sits alongside other memory frameworks but leans toward an operating-system model: multiple knowledge bases (memory cubes), multi-modal content (text, images, tool traces), and asynchronous ingestion for production workloads. You can run it self-hosted or use the hosted cloud service.

What it does

  • Unified memory API to add, retrieve, edit, and delete memories, structured as an inspectable graph rather than a black-box embedding store
  • Multi-cube knowledge base management — isolate or share memory across users, projects, and agents
  • Multi-modal memory covering text, images, tool traces, and personas in one system
  • Natural-language feedback and correction to refine, supplement, or replace existing memories
  • Asynchronous ingestion via MemScheduler for low-latency operation under high concurrency
  • Self-hosted REST API plus a hosted cloud option and plugins for agent frameworks

Getting started

Install the Python package, run the self-hosted service, then add and search memory over its REST API.

Install MemOS

Install the package from PyPI. MemOS requires Python 3.10 or newer.

bashbash
pip install MemoryOS

Add a memory

With the service running locally (default http://localhost:8000), POST a message to store it under a user and memory cube.

pythonpython
import requests, json

data = {
    "user_id": "8736b16e-1d20-4163-980b-a5063c3facdc",
    "mem_cube_id": "b32d0977-435d-4828-a86f-4f47f8b55bca",
    "messages": [
        {"role": "user", "content": "I like strawberry"}
    ],
    "async_mode": "sync"
}
headers = {"Content-Type": "application/json"}
url = "http://localhost:8000/product/add"

res = requests.post(url=url, headers=headers, data=json.dumps(data))
print(f"result: {res.json()}")

Search the memory

Query the same user and cube to retrieve what was stored.

pythonpython
import requests, json

data = {
    "query": "What do I like",
    "user_id": "8736b16e-1d20-4163-980b-a5063c3facdc",
    "mem_cube_id": "b32d0977-435d-4828-a86f-4f47f8b55bca"
}
headers = {"Content-Type": "application/json"}
url = "http://localhost:8000/product/search"

res = requests.post(url=url, headers=headers, data=json.dumps(data))
print(f"result: {res.json()}")

Commands and code are distilled from the project's own documentation — always check the official repo for the latest.

When to use it

  • Give a chatbot or assistant persistent memory of a user's preferences and past conversations across sessions
  • Share and isolate memory across a multi-agent system using separate memory cubes keyed by user or project
  • Store and reason over tool traces and images alongside text so an agent can plan from past tool usage
  • Correct or delete what an agent has learned over time using natural-language feedback or memory IDs

How MemOS compares

MemOS alongside other open-source agent memory tools AI/TLDR tracks, ranked by GitHub stars.

ToolStarsWhat it does
Mem0★ 59.6kA memory layer that you add to existing LLM agents to extract, store, and recall user facts and preferences across sessions using vector, graph, and key-value backends.
Graphiti★ 28.1kA library that builds a temporal knowledge graph from an agent's conversations and data so facts can be tracked and queried as they change over time.
Supermemory★ 27.8kA memory and context engine that ingests information across tools and sessions and can run fully locally, acting as a second brain for AI applications.
Cognee★ 24.1kA graph-native memory engine that turns raw documents and conversations into a queryable knowledge graph for agents that need to build lasting knowledge.
Letta★ 23.6kA framework (formerly MemGPT) for building stateful agents with long-term memory that persists across sessions and conversations.
Memvid★ 15.7kMemvid packs an AI agent's data, embeddings, and search index into one portable file, so it can retrieve memory fast without running a vector database.
Memori★ 15.5kAn SQL-native memory engine that gives any LLM persistent, structured memory stored in standard PostgreSQL or MySQL databases instead of a vector store.
MemOS★ 10kA memory operating system that gives LLM agents persistent, manageable long-term memory