Integrations

One engine, several front doors. sibyl setup wires most of these for you; the manual steps are here for when you want to know exactly what changed.

Hermes Agent

Bundled provider for Hermes Agent v0.13 and newer.

$ pip install sibyl-memory-hermes
$ sibyl-memory-hermes install-plugin

Then set Sibyl as the provider in ~/.hermes/config.yaml:

memory:
  provider: sibyl

Or let the CLI do it: sibyl setup hermes.

In Hermes the aggregate count of memory operations is off unless you opt in with SIBYL_MEMORY_TELEMETRY=1.

MCP clients

The MCP server wraps the local SQLite + FTS5 engine and exposes it over MCP (stdio) to any MCP-compatible agent: Claude Code, Codex, Cursor, Grok Bot, DeepSeek Harness, Continue, and anything else that speaks the protocol.

$ pip install sibyl-memory-mcp

Then point your MCP client at the server entry point. For the most common clients, the CLI wires them directly:

$ sibyl setup claude-code   # registers via `claude mcp add --scope user`
$ sibyl setup codex         # writes the entry into ~/.codex/config.toml
$ sibyl setup cursor        # writes the entry into ~/.cursor/mcp.json
$ sibyl setup grokbot       # the Cursor wiring, plus a confirmation for Grok Bot
$ sibyl setup deepseek      # adds one row to ~/.dsh/cordis.patch.yml

Your agent gets 15 memory tools: remember, recall, search, list, forget, set and get state, record event, the four reference-document tools (set, get, list, delete), and link, unlink and neighbors for the links between memories. Plus the save and debloat prompts.

Cursor

$ sibyl setup cursor

Writes the server into ~/.cursor/mcp.json. It backs the file up first, keeps every other server in it, and never replaces an existing sibyl-memory entry that points somewhere else unless you pass --force. A file that is not valid JSON is left untouched. Plain sibyl setup wires Cursor too when it finds it.

Grok Bot

Grok Bot runs on a persistent Cursor cloud machine that supports local stdio MCP servers, so the Cursor wiring is all it needs. Give the Bot these lines to run in its own shell:

$ curl -fsSL https://sibyllabs.org/install | sh
$ export PATH="$HOME/.local/bin:$PATH"   # a fresh shell may not have it yet
$ sibyl setup grokbot
$ sibyl init
$ sibyl doctor

The installer works without a terminal, so it runs fine inside an agent shell, and it already wires Cursor when it finds it. sibyl setup grokbot finds the absolute path of the server on that machine, wires ~/.cursor/mcp.json, and prints a confirmation: the server name, the command path, and the config file it wrote. Reload MCP servers (or start a new Bot session), sign in once with sibyl init, and sibyl doctor proves the whole path works.

DeepSeek Harness (developer preview)

$ sibyl setup deepseek

Adds one sibyl-memory row to DeepSeek Harness's home patch file, ~/.dsh/cordis.patch.yml (or $DSH_HOME), which covers every profile. --dsh-profile <name> writes to one profile's patch instead, and --dsh-home points at another home. The file is edited as text and every edit is checked by parsing it, so your own patches, comments and !!js values stay as written. A backup goes to ~/.sibyl-memory/backups/deepseek/ first. dsh works as a short name for the target.

Setup only recognizes DeepSeek Harness by its profiles/ folder or cordis.patch.yml. A ~/.dsh that belongs to the unrelated Debian dsh program is never detected or changed. The tools appear as mcp__sibyl-memory__*. DeepSeek Harness needs Node 24.9 or newer.

Any other MCP client

Any client that runs a local stdio server can use Sibyl Memory. If your agent can only edit a config file, print the absolute command path and a ready block:

$ sibyl setup --print-config

Paste the block into the client's mcpServers section, using the path printed on your machine:

{
  "mcpServers": {
    "sibyl-memory": {
      "type": "stdio",
      "command": "/home/you/.local/bin/sibyl-memory-mcp"
    }
  }
}

When sibyl setup finds no agent it recognizes, it prints the same block instead of stopping.

Check it end to end

$ sibyl doctor
$ sibyl doctor --json        # machine-readable result, for an agent

sibyl doctor starts the real MCP server, lists its tools, saves a clearly marked test memory, recalls it, deletes it, and checks nothing was left behind. Each step reports pass or fail. Your own memory is never touched.

It also checks how each agent on this computer is wired (Hermes, Claude Code, Codex, Cursor, Grok Bot, DeepSeek Harness) and says whether each entry is fine, missing, pointing at a path that no longer exists, or broken. It changes nothing unless you ask:

$ sibyl doctor --fix              # repair stale or broken entries; never adds a missing one
$ sibyl doctor --harness codex   # check one agent (repeatable)

A missing entry is a warning that names the sibyl setup command to run. Every repair backs the file up first.

The SDK directly

If you are writing your own Python orchestration and want to call memory yourself, skip the wrappers:

$ pip install sibyl-memory-client

from sibyl_memory_client import MemoryClient

memory = MemoryClient.local("~/.sibyl-memory/memory.db")
memory.set_entity("project", "atlas", {"status": "active"})

The client reads the account sibyl init signed in on this computer; without one it raises EntitlementError. The full API surface is on the How it works page.

LangGraph

A LangGraph BaseStore backed by Sibyl Memory: long-term, cross-thread memory on the same local store. Search is lexical (FTS5), not vector similarity.

$ pip install sibyl-memory-langgraph

from sibyl_memory_langgraph import SibylStore

store = SibylStore()  # ~/.sibyl-memory/memory.db; needs `sibyl init` once
graph = StateGraph(State, store=store)

Which package do I install?