Never4gA MCP lets an agent resolve a workspace, assemble local context packs, search/read vault knowledge, record session activity, draft decisions, and inspect or propose tracker changes.
Resolve which workspace a directory belongs to, refusing to guess.
Open a session with a startup context pack and session ID, then get focused or deeper context by terms.
Search the vault lexically, plus semantically when configured, with reasons and staleness; fetch a concept by UUIDv7.
Check vault health with doctor, receiving findings and repair hints but no automatic repairs.
Read open tracker work items or one item by tracker ID.
Capture loose thoughts into the Inbox.
Checkpoint session progress in runtime state without touching the vault.
Wrap a session: write one idempotent activity log and report decisions, memories, work items, and changed context documents.
Draft a decision record as PROPOSED, never accepted.
Create, update, or comment on tracker work items; changes are only described unless apply=true, and session_id lets wrap see them.
Maps workspaces to Git repositories and includes live Git state and repository signals in context packs.
Works with Obsidian vaults as plain Markdown note stores, indexing notes and providing searchable context packs from the vault.
Pulls open work items from OpenProject into each context pack and lets agent sessions update tracker items.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@never4ga-mcp load the context pack for this repo before we start"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Never4gA, short for never forget again, is memory for you and every AI agent you work with. It keeps your notes, decisions and project history as plain Markdown on your machine, and hands each agent session exactly the part it needs before the session starts.
Early days. This is version 0.1, in daily use by the person who built it and new to everyone else. Expect rough edges and interfaces that still move, and tell us when you hit one.
It does that without a model. Finding the right context is lookups, queries and file reads, so it costs no tokens, takes seconds, and gives the same answer every time. Your agent spends its budget on the work, not on searching for what it should already know.
Most agent memory asks a model to decide what's relevant, or lets the agent go looking with its own tool calls. Both spend tokens and turns before any work happens. Never4gA does that part first, mechanically:
Fewer tokens. In the vault it was built in, 2,153 files and about 3 million tokens of notes, a session starts with a pack of about 10,000 tokens. That's what the agent reads. Nothing else is loaded.
Faster starts. That pack is assembled in about four seconds, including live Git and tracker state, with zero model calls.
You can see why. Every item in a pack names the reason it was included. The same question gets the same pack.
Related MCP server: RepoRecall
Remembers across sessions | Each session opens with what the project is, the rules it follows, what was decided, and what the last session left open. |
Remembers across tools | Claude Code, Codex, Antigravity and any MCP client read the same memory. Switch tools and nothing is lost. |
Writes back what happened | Sessions record progress and decisions as dated logs, so the next one picks up where this one stopped. |
Keeps your notes yours | Everything is Markdown in a normal Obsidian vault. Uninstall Never4gA and your notes are exactly as they were. |
Starts from the notes you have | Point it at an existing folder. Your files stay where they are, and your notes are searchable on the first run. |
Brings in your tracker | Open work items from OpenProject join the pack, and a session can update them. |
flowchart LR
V[("Your Markdown<br/>vault")] --> I["Local index"]
subgraph M["Found by lookup, not by a model"]
direction TB
S1["Where you are<br/>repo → workspace"] --> S2["Types and metadata"]
S2 --> S3["Full-text search"]
S3 --> S4["Links and relations"]
S4 --> S5["Git and tracker state"]
end
I --> M
M --> P["Context pack<br/>every item says why"]
P --> A["Claude Code · Codex<br/>Antigravity · MCP"]
A -. "what the session did" .-> VA pack is built in stages, and each stage is a query: which workspace this repository belongs to, which documents that workspace holds, what full-text search finds, what those documents link to, and what Git and your tracker say right now. A pack never grows past its budget. A model gets involved when you ask for judgment, and never for work a lookup can do.
In Obsidian: the Never4gA Companion plugin shows the same pack beside the note you're reading, with the reason each item is there. Install it from its latest release or with BRAT; it isn't in Obsidian's community plugin list yet.
Never4gA is made to be driven by your coding agents. You install it once and connect the agents, and from then on they open each session, look things up and write back what they did, using the Skills Never4gA gives them. You don't run it by hand in day-to-day work.
1. Install it and make a vault (a folder of Markdown, new or already full of your notes):
uv tool install never4ga
export NEVER4GA_VAULT=~/notes
never4ga init
never4ga indexuv installs the Python version Never4gA needs if you don't already have it.
2. Connect your agents to Claude Code, Codex or Antigravity, whichever you have installed. The Code tab in the Claude desktop app runs Claude Code, so it is connected the same way:
never4ga adapters sync --apply # the Skills, into each agent
never4ga adapters mcp --apply # the MCP server, so agents can call Never4gA directly3. Attach a project. Give the repository a workspace in your vault, and tell the agents working there to ask Never4gA for context:
cd ~/code/my-project
never4ga workspace create "My Project" --type project
never4ga workspace map <workspace-id>
never4ga adapters sync --apply --repositories--repositories writes a small pointer file into the mapped repository, ignored by Git, that tells an agent to start from Never4gA. Without it, adapters sync --apply only updates the agents themselves.
4. Start a session. Open Claude Code (in a terminal or the Claude desktop app), Codex or Antigravity in that repository and work as usual. The agent runs the never4ga-startup Skill first, which hands it the project's context pack: what the project is, the rules it follows, what was decided, and what the last session left open.
The Skills are what the agents actually use. Each one is a short set of instructions for a single job, so an agent does it the same way every session:
Skill | The agent uses it to |
| Open a session with the project's context pack. |
| Look up more on a topic once work is under way. |
| Record progress as it happens, so an interrupted session loses nothing. |
| Close a session by writing the dated log the next one starts from. |
| Write a plan, note or other document into the right place with valid metadata. |
| Draft a decision for you to accept. It never accepts one itself. |
| Put a loose thought in your Inbox for you to file. |
| Check the vault's health and report what it finds. |
You can ask for any of them in plain words ("check the vault", "write this up as a note") and the agent picks the Skill. The same operations are available to any other MCP client through never4ga-mcp.
Everything the agents do is also a never4ga command, and the commands are there when you want them: searching your notes, inspecting a pack, or scripting.
never4ga search "what we decided about auth"
never4ga context startup --client claude-code --cwd .
never4ga doctornever4ga --help lists the rest.
Call a model for you. It has no API key and never meters your usage. You bring the AI tools you already pay for.
Send your notes anywhere. Everything runs on your machine, and the service only listens on localhost.
Take over your files. The index is disposable and rebuilt from your Markdown. Your files are the only source of truth, and nothing is committed to Git for you.
Context packs follow repositories. A workspace is attached to a Git repository, and a pack is built for the repository you're in. Notes that aren't tied to one are fully searchable but don't get a pack yet.
Platforms. Built and tested on Linux and macOS. On Linux the background service runs under systemd; on macOS, run never4ga serve in a terminal instead. Windows is not supported yet.
Four ways in. The Skills and MCP server your agents use (never4ga-mcp), the never4ga command line, a local HTTP API, and the Obsidian companion. All four run the same code.
If something didn't make sense, or didn't work the way this page says it does, open an issue. That's the most useful thing you can send.
GitHub is Never4gA's only public home. Issues and pull requests go there. To report a security problem, see SECURITY.md rather than opening an issue.
The design is written down. docs/specs/ holds the specifications; start with 00-spec-index.md. They're generated from the maintainer's notes, so propose a change in an issue rather than editing them. AGENTS.md is the contract for AI agents working in this repository, and a fair summary of the rules for people too.
uv venv --python 3.14 .venv
VIRTUAL_ENV=.venv uv pip install -e '.[dev]'
.venv/bin/ruff check . && .venv/bin/ruff format --check . && .venv/bin/mypy && .venv/bin/pytestThat last line is the gate, and every pull request runs it.
Apache License 2.0. Never4gA, by BezaCore Labs.
Put a thought, link or fragment in the Inbox without deciding where it belongs. Use when something is worth keeping and classifying it now would interrupt the work.
Inputs: text (required), title.
Record what this session has done so far. Runtime state only: it never touches the vault, so an interruption cannot leave half a log behind.
Inputs: note (required), session_id (required), work, actions, +4 more.
More context about particular terms, at a stated depth. Use when the startup pack was not enough or work moved to an unfamiliar area.
Inputs: terms (required), cwd, depth.
The smallest useful context for starting a session in a workspace: what it is, what binds it, what the last session did. Opens a session and returns its id.
Inputs: cwd, task, client.
Draft a decision record. It is written as PROPOSED and is not in effect: an agent never authors an accepted decision, and only the maintainer moves one to accepted.
Inputs: title (required), series, numbered, description, +1 more.
Check vault health. Reports findings with repair hints and never repairs anything itself.
Inputs: level.
One concept by its Never4gA id: its frontmatter, its body, and the relations the projection knows about.
Inputs: id (required).
Search the vault. Lexical always, and semantic as well when an embedder is configured; the lanes are fused by rank. Returns ranked results with the reason each was retrieved, and says when the index is stale.
Inputs: query (required), limit, explain.
Comment on a work item, or replace a comment already made. Describes the change and sends nothing unless apply is true.
Inputs: body (required), work_item (required), cwd, apply, +2 more.
Create a work item on the workspace's tracker. Describes the change and sends nothing unless apply is true.
Inputs: title (required), cwd, apply, fields, +1 more.
Read one work item from the workspace's tracker.
Inputs: work_item (required), cwd.
Ask the workspace's tracker what is open. The tracker stays the system of record; this reads it rather than mirroring it.
Inputs: cwd, limit, terms, statuses.
Which Never4gA workspace a directory belongs to, and why. Mechanical: it refuses to guess rather than picking one.
Inputs: cwd.
Change fields on a work item. Describes the change and sends nothing unless apply is true; a change to nothing is refused either way.
Inputs: fields (required), work_item (required), cwd, apply, +1 more.
Close a session: write the one activity log it leaves behind, and report what was declared along the way -- decisions, things worth remembering, work items that may need an update, and the context documents the session was given, with the question whether it changed anything they assert. It writes nothing but the log. Idempotent: wrapping twice updates one document rather than writing two, and a title given the second time replaces the first and renames the file.
Inputs: session_id (required), into, title.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 15 tools
Each tool has a clearly distinct purpose: session lifecycle (startup, checkpoint, wrap), vault retrieval (search, get_concept, context_focus), and work tracker operations (search, get, create, update, comment) are separated by domain prefixes and descriptions. Overlap is minimal, and the descriptions clarify boundaries.
All tools share the never4ga_ prefix and snake_case, which makes them groupable, but the action ordering varies: some use noun_verb (work_get, workspace_resolve), others verb_noun (get_concept), and several are bare verbs/nouns (wrap, decide, search). This is mostly consistent with minor deviations.
15 tools is at the upper end of the ideal range, but each tool maps to a distinct operation in session management, vault access, and work tracking. The set is well-scoped with no obvious redundancy.
Core lifecycle and retrieval workflows are covered, including session start/checkpoint/wrap, vault search and concept retrieval, and work item create/read/update/comment. Minor gaps exist (e.g., no work item delete or direct concept update/delete), but these may be intentional or manageable via other tools.
Project memory, documentation and controlled secret access for AI coding agents.
Shared memory for your AI tools: tasks, notes and context every tool can read and write over MCP.
Shared AI memory. ChatGPT, Claude, Cursor and any MCP app read and write the same memory.
Private-by-default, local-first memory/context/task orchestrator for MCP apps and agents.
