Epiphany

io.github.GATSV-techPublished by GitHub account GATSV-techv0.5.0Updated Oct 25, 2026

One private, local memory your AI tools share. Cross-model, on-device, never lose a session.

VerifiedSTDIODesktop onlyKnowledge & MemoryAI & ML

Overview

AI-generated overview

Epiphany is a local, private memory server that lets AI assistants recall and remember shared context across different AI tools on your machine.

What you can do
Recall stored thoughts and their reasoning from a shared local memory graph, so an assistant can pick up context from earlier sessions or other AI tools. Save new memories with explicit reasoning links between thoughts, such as because or builds_on. Capture session transcripts from connected tools through a background watcher so crashed or ended sessions are filed automatically. Inspect, search and curate the memory through a dashboard and an interactive graph view. Wire the server into supported AI tools and install a standing rule so agents reach for the memory on their own.
When to use it
Use it when you work across several AI tools and keep re-explaining the same context, or when you want session reasoning preserved after a chat ends. It suits people who want memory kept entirely on their own machine rather than in a cloud account.
Requirements
A local process on a desktop machine with Node.js 18 or newer, installed from the npm package or built from source. The memory is stored in a SQLite file in the user's home directory. No account, API key or cloud service is required; the optional weave command uses your own LLM key.
Before you install
The background watcher reads the session transcripts your AI tools already write to disk and files them into the local memory, so review what those logs contain. The memory database is a plain file on disk that you are responsible for backing up or deleting. The optional weave command uses your own LLM key. Connecting a tool modifies that tool's configuration and adds a standing rule.

Installation

In SourceWeft

  1. Open Epiphany in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Desktop only via STDIO. STDIO servers start a local process, so they need the SourceWeft desktop host.

Other MCP clients

Follow the launch instructions in the repository.

README

Epiphany

One private, local memory your AI tools share.

Every AI you use forgets you the moment the chat ends. You re-explain the same context over and over, and when a session dies, the reasoning behind it is gone for good. Epiphany fixes that. It's a single memory that lives on your machine, that Claude, Grok, Gemini, and more all read from and write to, so what you tell one, the others already know.

  • Local-first. Your brain is a file on your disk. Nothing leaves the machine. No account, no cloud, no company owns your memory.
  • Cross-model. One shared memory across Claude (Desktop + Code), Grok, Gemini, Cursor, Antigravity, Warp, Hermes, and Perplexity. Tell Grok something, ask Claude about it.
  • Real memory, not bullet points. Thoughts carry their reasoning and connect into a graph, so recall returns why something is true and what it followed from, not a lone fact. Ask a follow-up and it holds the thread.
  • Never lose a session. A background watcher reads the transcripts your tools already write to disk and files every session into the brain in near-real-time, even ones that crashed before anything was saved.

How it works

Epiphany is a local MCP server plus a tiny CLI.

  1. It runs a small server on your machine that exposes two tools to any AI client: recall and remember.
  2. epiphany connect <tool> wires that server into each AI tool, in the tool's own config format, and installs a standing rule so the agent reaches for your memory on its own.
  3. Memories are embedded on-device (a local model, nothing sent anywhere) and stored in SQLite. Agents wire explicit reasoning connections between thoughts (because, builds_on, part_of, ...), and recall walks that graph to reconstruct the whole thought-string.
  4. A background watcher sees your tools' session logs the moment they change and sweeps them into the brain, so nothing is ever lost.

The intelligence stays in the models you already use. The brain itself is a fast, private librarian: it holds, connects, and recalls. It never phones home.

Quickstart

Requires Node 18+.

bash
npm install -g epiphany-mcp   # puts the `epiphany` command on your PATH

Or build from source:

bash
git clone https://github.com/GATSV-tech/epiphany.gitcd epiphanynpm installnpm run buildnpm link

Wire it into the tools you use, then fully restart each one:

bash
epiphany connect claude-codeepiphany connect grokepiphany connect geminiepiphany list          # see all supported tools

Turn on the background "never lose a session" sweep:

bash
epiphany schedule

That's it. Now talk to any connected AI. It will recall what you've told the others and save what's worth keeping, on its own.

Run epiphany with no arguments any time to open the dashboard and look inside your brain.

Supported tools

ToolConnectorStanding rule
Claude Code (every terminal)autoauto
Grok CLIautoauto
Gemini CLIautoauto
Antigravity (Google IDE)autoshared with Gemini
Claude Desktopautoguided (account setting)
Cursorautoguided (app setting)
Warp (terminal, Agent Mode)autoguided (app setting)
Hermes (Nous Research agent)autoguided (instructions)
Perplexity (Mac app)guidedguided (instructions)

Commands

epiphany connect <tool>   wire Epiphany into an AI tool (connector + rule)epiphany rule <tool>      update just the standing rule for a toolepiphany list             show supported toolsepiphany dash             open the interactive dashboard (browse, search, curate)epiphany graph            see your whole brain as an interactive visual graphepiphany weave            wire the reasoning connections between related memories (optional; uses your LLM key)epiphany status           show brain size, connected tools, and auto-capture stateepiphany ingest           sweep session logs into the brain now (one-shot)epiphany watch            run the near-real-time watcher in the foregroundepiphany schedule         install the background watcher (captures sessions as they happen)

Your brain lives at ~/.epiphany/brain.db. It's yours. Back it up, inspect it, delete it, it's just SQLite.

Roadmap

Epiphany's core, local cross-model memory with reasoning graphs and automatic capture, works today. Next:

  • More session sources for the ingestor (Claude Code, Cursor transcripts).
  • Reconciliation. When a fact changes, the brain flags the conflict and you confirm the update, so memory self-corrects instead of piling up contradictions.
  • Cloud bridge. An optional relay so cloud-only surfaces (ChatGPT on the web, wearables) can reach your local brain.
  • Desktop app. A download-and-run shell for people who don't live in a terminal.

Contributions and ideas welcome.

License

MIT.

Source: README.md at commit eecacea

Tools

0
SourceWeft has not started this package in its sandbox yet, so its tools are not known.

Version history

1
  1. v0.5.0LatestSep 16, 2026

Score

50% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 days25 pts

    Keep the endpoint answering the MCP handshake; SourceWeft probes it every 30 days.

  • Auth declared10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts