Zaxy — event-sourced agent memory with cited checkout and reversible forgetting (stdio/SSE via PyPI)

by syndicalt

15 stars

205 downloads

Not rated

GitHub Website

Knowledge Base

About

Zaxy turns agent work into durable, auditable memory: a hash-chained Eventloom log as the source of truth, an embedded temporal knowledge graph for reasoning (local-first, no sidecar; Neo4j/Postgres optional), cited Memory Checkout for compact context, and MCP tools for model-fa

Details

Author: syndicalt
GitHub stars: 15
Downloads: 205
Categories: Knowledge Base

- Immutable audit trail via Eventloom append‑only JSONL with SHA‑256 hash chains.
- Bi‑temporal graph with validity windows (valid_from, valid_to).
- Hybrid extraction: rule‑based for typed events, LLM fallback.
- Hybrid retrieval: exact + keyword + vector + graph traversal with configurable fusion weights.
- Session sharding: one Eventloom log per agent/session, shared graph.
- MCP‑native integration over stdio or SSE.
- Optional Pathlight traces, breakpoints, and diff support.
- Hardened local defaults: bounded inputs, safe session IDs, embedded graph without sidecar.

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Zaxy — event-sourced agent memory with cited checkout and reversible forgetting (stdio/SSE via PyPI)

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "zaxy \u2014 event-sourced agent memory with cited checkout and reversible forgetting (stdio/sse via pypi)": {
            "zaxy": {
                "command": "python",
                "args": [
                    "examples/single_agent_memory.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zaxy \u2014 event-sourced agent memory with cited checkout and reversible forgetting (stdio/sse via pypi)": {
            "zaxy": {
                "command": "python",
                "args": [
                    "examples/single_agent_memory.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zaxy \u2014 event-sourced agent memory with cited checkout and reversible forgetting (stdio/sse via pypi)": {
            "zaxy": {
                "command": "python",
                "args": [
                    "examples/single_agent_memory.py"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "zaxy \u2014 event-sourced agent memory with cited checkout and reversible forgetting (stdio/sse via pypi)": {
            "zaxy": {
                "command": "python",
                "args": [
                    "examples/single_agent_memory.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zaxy \u2014 event-sourced agent memory with cited checkout and reversible forgetting (stdio/sse via pypi)": {
            "zaxy": {
                "command": "python",
                "args": [
                    "examples/single_agent_memory.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zaxy \u2014 event-sourced agent memory with cited checkout and reversible forgetting (stdio/sse via pypi)": {
            "zaxy": {
                "command": "python",
                "args": [
                    "examples/single_agent_memory.py"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "zaxy \u2014 event-sourced agent memory with cited checkout and reversible forgetting (stdio/sse via pypi)": {
            "zaxy": {
                "command": "python",
                "args": [
                    "examples/single_agent_memory.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zaxy \u2014 event-sourced agent memory with cited checkout and reversible forgetting (stdio/sse via pypi)": {
            "zaxy": {
                "command": "python",
                "args": [
                    "examples/single_agent_memory.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zaxy \u2014 event-sourced agent memory with cited checkout and reversible forgetting (stdio/sse via pypi)": {
            "zaxy": {
                "command": "python",
                "args": [
                    "examples/single_agent_memory.py"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "zaxy \u2014 event-sourced agent memory with cited checkout and reversible forgetting (stdio/sse via pypi)": {
            "zaxy": {
                "command": "python",
                "args": [
                    "examples/single_agent_memory.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zaxy \u2014 event-sourced agent memory with cited checkout and reversible forgetting (stdio/sse via pypi)": {
            "zaxy": {
                "command": "python",
                "args": [
                    "examples/single_agent_memory.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zaxy \u2014 event-sourced agent memory with cited checkout and reversible forgetting (stdio/sse via pypi)": {
            "zaxy": {
                "command": "python",
                "args": [
                    "examples/single_agent_memory.py"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "zaxy \u2014 event-sourced agent memory with cited checkout and reversible forgetting (stdio/sse via pypi)": {
            "zaxy": {
                "command": "python",
                "args": [
                    "examples/single_agent_memory.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zaxy \u2014 event-sourced agent memory with cited checkout and reversible forgetting (stdio/sse via pypi)": {
            "zaxy": {
                "command": "python",
                "args": [
                    "examples/single_agent_memory.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zaxy \u2014 event-sourced agent memory with cited checkout and reversible forgetting (stdio/sse via pypi)": {
            "zaxy": {
                "command": "python",
                "args": [
                    "examples/single_agent_memory.py"
                ]
            }
        }
    }
}

From the repository

Install the PyPI package zaxy-memory with pipx install zaxy-memory, then run zaxy init to set up a local embedded graph, repo‑local profile, and deterministic capture config. Verify with zaxy memory log and zaxy doctor. Start the MCP server over stdio or SSE with zaxy serve. Run the single‑agent example with python examples/single_agent_memory.py. For Claude Code, use zaxy init --preset local-claude; for Hermes Agent, zaxy ide-config hermes --install.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "zaxy \u2014 event-sourced agent memory with cited checkout and reversible forgetting (stdio/sse via pypi)": {
            "zaxy": {
                "command": "python",
                "args": [
                    "examples/single_agent_memory.py"
                ]
            }
        }
    }
}

McpServers

{
    "zaxy": {
        "command": "python",
        "args": [
            "examples/single_agent_memory.py"
        ]
    }
}

Zaxy

Production memory for agent teams that need receipts.

Zaxy turns agent context into an auditable project memory fabric. It captures
parent missions, worker sessions, tool observations, cited findings, conflict
review, approval packets, and accepted merge-back into one durable history that
can be queried, replayed, and inspected.

Under the hood, Zaxy uses Eventloom append-only JSONL as the source of truth and
an embedded LadybugDB graph projection for local reasoning. It is built for agents
that need to remember what happened, cite where it came from, and avoid turning
project state into a pile of markdown files and vector chunks.

The embedded LadybugDB graph projection is the default local runtime.

The plain install uses embedded LadybugDB. Install zaxy-memory[neo4j] only for the
optional Neo4j sidecar, and zaxy-memory[pathlight] only for Pathlight tracing.

Why It Matters

- Auditable memory: every accepted fact can point back to Eventloom history.
- Agent-team coordination: parent and worker sessions stay isolated until
findings are reviewed and merged.
- Local-first runtime: the default path uses embedded LadybugDB, no Neo4j sidecar.
- MCP-native integration: Codex, Claude Code, Cursor, VS Code, Hermes Agent,
LangGraph, CrewAI, and AutoGen can use the same memory interface.

> Benchmark claims withdrawn (2026-07-03). The prior LongMemEval numbers
> were withdrawn: they were produced in oracle mode (mean ~1.9 candidate
> sessions per question, so Recall@5/citation-coverage were ~1.0 by
> construction, not by retrieval) and the preference-question scores rested on a
> hardcoded answer table that has since been removed. Zaxy does not currently
> publish a LongMemEval score. A real, full-haystack LongMemEval run is planned;
> until it lands, treat the earlier 0.956/0.910/1.000 figures as retracted.
> The Harvey LAB claim is pending the same audit.

Quick Start

Install, init, verify

pipx install zaxy-memory
zaxy init
zaxy memory log --eventloom-path .eventloom --limit 5
zaxy memory bootstrap --eventloom-path .eventloom
zaxy doctor --eventloom-path .eventloom

The PyPI distribution is zaxy-memory; the import package and console command
are still zaxy. Bare zaxy init sets up the local embedded graph posture,
repo-local profile, deterministic capture config, genesis event, heartbeat, and
MCP guidance. For Codex, the printed activation launcher starts the managed
capture watcher when the local capture config is present; pass --capture start
only when you want init itself to start the watcher before opening Codex. The
default human output is compact and action-first; add --verbose when you need
the full setup diagnostics, optional checks, fallback commands, resume guidance,
and notes.
For automation, zaxy init --json keeps the raw onboarding fields and adds
setup.status, setup.issues, setup.pending, readiness.status,
readiness.reasons, readiness.actions, and structured
readiness.action_items for both commands and non-command review tasks. Each
structured action carries label, command, original source, and hints
for compact-output tips such as activation <task> replacement and path-stable
command guidance. Installers can render those tips without parsing prose. It also
includes setup.summary, readiness.summary,
readiness.required_action_count, and readiness.reason_count, so client UIs
can render compact status without parsing human output. It also
separates readiness.blocking_diagnostics from
readiness.non_blocking_diagnostics so scripts can distinguish setup
completion, required actions, and advisory doctor warnings before relying on
live memory.

For Codex, zaxy init --codex-mcp-install auto is the default. It writes or
reuses the user-level Codex MCP config when that can be done without replacing
an existing zaxy server entry. If no safe config target exists, it prints the
copyable codex mcp add command. If an existing zaxy entry differs, it asks
you to review that config before replacing it because Codex can silently replace
servers with the same name. Use an explicit mode when you need to force one side
of that decision after review:

```bash
zaxy init --codex-mcp-install user

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

Zaxy

Why It Matters

Quick Start

Install, init, verify

Install

More like this

Aws Kb Retrieval Server

Memory

Context 7

MaxKB

AWS MCP Servers

Git (GitHub to MCP)