One memory for every AI agent and every agent framework.
- Agents forget. Semurg remembers: facts and relationships written once, found again by the next agent, the next session and the next framework, each fact with the ids of the entities it connects.
- Your agent is the extractor: when it stores text it sends the entities and relations it found in the same call, so the graph grows with no schema to write first, and every answer comes back cited to the passage it came from.
- Every framework, one memory: LangChain and LangGraph, LangChain for Elixir, CrewAI, Microsoft Agent Framework, OpenAI Agents SDK, LlamaIndex, Mastra, Google ADK, Pydantic AI, the Vercel AI SDK and Jido have run end to end; Claude Code, Hermes Agent and OpenClaw connect with their own configuration (the integrations).
- Knowledge graph, vector search and graph RAG, built in: seven memory tools over MCP or plain HTTP (remember, document, recall, relate, forget, context and status), with vector search and graph RAG on the same copy of the data. Memory recall starts from the names you give it and walks their relationships.
- Bigger than RAM, on your own hardware: the engine's data lives on your disks, on-premises with no external cloud; built to grow past one node, licensed per node.
- One engine, written from scratch, for ten data domains: the memory is the same store that serves graph, vector, document, time-series, relational, columnar, key-value, object, streaming and search, in one on-disk format. Nine of the ten are measured in the open today against the engines teams use (graph, in memory and bigger than memory, vector, key-value, time-series, document, search, columnar, object and streaming, with vector + graph RAG: the benchmarks); relational is being measured on the current release and land there as they are measured, losses with the wins.
Try it in a minute with Docker on an Intel or AMD x86_64 Linux machine (WSL2 and Docker Desktop on Windows are being tested): start a node, remember a sentence, recall it.
docker run -d --name semurg -p 127.0.0.1:4000:4000 \
--ulimit memlock=-1 --ulimit nofile=1048576:1048576 --security-opt seccomp=unconfined \
-v semurg-data:/var/lib/semurg one.semurg.io/semurg
until docker logs semurg 2>&1 | grep -q 'Your API token'; do sleep 1; done
export SEMURG_API_TOKEN=$(docker exec semurg cat /var/lib/semurg/.api_token) NODE_URL=http://127.0.0.1:4000
mem() { curl -s -H "Authorization: Bearer $SEMURG_API_TOKEN" -H 'content-type: application/json' "$NODE_URL/v1/memory/$1" -d "$2"; }
mem remember '{"scope":"demo","content":"Ada Lovelace works at Acme."}'
mem recall '{"scope":"demo","subject":"Ada Lovelace"}'
Or install it on Ubuntu 24.04, as root: curl -fsSL https://one.semurg.io/install | sudo bash. A Mac version is coming. What it needs, and what it changes.
The memory layer for AI agents and agent frameworks
Every agent, every framework
Point any MCP client at your node, or call the same verbs over plain HTTP and the client SDKs. Eleven frameworks have run end to end and three agents have connected, each on a named release.
Memory that outlives the session
What one agent learns, the next agent, session and framework finds again. Scopes keep a team's memory shared and a user's private; forgetting supersedes, nothing is erased.
Knowledge graph, vectors and graph RAG in one engine
Facts and their relationships are kept as a knowledge graph, vectors live in the same store, and graph RAG finds the nearest vectors and then walks the graph: no separate vector database, graph database or retrieval service to run or keep in step. Memory recall starts from the names you give it and walks their relationships.
Why one engine
Measured in the open, across ten data domains
- Nine of the ten domains are published, with vector + graph RAG, each against the engines teams use today; relational lands as it is measured.
- Results publish per domain as they are measured, win or lose. Every figure on this site says what it was measured on: a named release, or, on the models page, a development tree, labelled as a diagnostic.
- A fairness bar applies to both sides: same data, same questions, both engines driven as hard as the machine allows, and the answers checked to match before any timing counts.
Start free, on your own hardware
Download the signed installer, verify it, and run a node. Your data stays on your machine: there is no account, no upload and no call home.
The first node is free, forever. Paid licences begin at the second node, either bought once for the life of that hardware or paid year by year, and updates are free.
What to know before you start
The things worth saying plainly, on the front page rather than in a footnote.
- A stopped or killed Semurg process loses nothing it acknowledged (tested with kill -9 on published releases). A power cut is the open item: on ext4 it can lose writes acknowledged in the last seconds before the cut, up to 14.6 s in our worst measured case. The durability page has every measurement and the release it was taken on.
- Network durability is being tested now. Replication across nodes and disaster recovery are being tested; nothing is claimed for more than one node until those tests pass on a published release, and the durability page shows each test and its result once it passes.
- The second node and every one after it are licensed per node, and the keys come from us: start on the free node, then talk to us about the cluster you need.
- Serving open-weight models from the same store is in progress: the models page lists each model and what it is waiting for, and the speed work is not finished.
- Nine of the ten domains are published on the benchmark page against the incumbents (graph, vector, key-value, time-series, document, search, columnar, object and streaming, with vector + graph RAG), the release and the machine beside each figure; relational is being measured on the current release and land there as they are measured, wins and losses alike.