Audrey

Name: Audrey
Author: Evilander

by Evilanderversion 2.1.1i★ –iRuns on your computer

Registry nameio.github.Evilander/audrey

Install

Overview

Description from the maker (original English)

Local-first biological memory for coding agents: recall, consolidation, and pre-action Guard checks.

PopNx MCP’s three pillars

These three are never merged into one score: opinions, measurements and popularity are different things.

User voiceiNo reviews yetReviews open together with accounts in a later step
Our basic checksi1 of 1 passedChecked from public information; code not scanned yet
UsageiNot measured yet★ –

What you can do with it

We have not written a plain-language summary for this one yet. Below are the facts we read from the registry.

Connection: Runs on your computer
Transport: stdio
Category: Search & AI memory

Install

Pick the AI app you use, then copy the settings.

Before you install

Basic checks: 1 of 1 passed
Runs on your computer with your user’s permissions (files, network, apps).
You fill in yourself: AUDREY_DATA_DIR, AUDREY_AGENT, AUDREY_EMBEDDING_PROVIDER, AUDREY_LLM_PROVIDER, AUDREY_ENABLE_ADMIN_TOOLS

You need

npmNode.js installed (for the npx command)

Which app do you use?

ClaudeClaude CodeCursorVS CodeChatGPT

Pick your app above. We remember it, so next time the button says “Install in …”.

Open Claude Desktop → Settings → Developer → Edit Config, and paste this into claude_desktop_config.json

{
  "mcpServers": {
    "audrey": {
      "command": "npx",
      "args": [
        "-y",
        "audrey"
      ],
      "env": {
        "AUDREY_DATA_DIR": "your-value",
        "AUDREY_AGENT": "your-value",
        "AUDREY_EMBEDDING_PROVIDER": "your-value",
        "AUDREY_LLM_PROVIDER": "your-value",
        "AUDREY_ENABLE_ADMIN_TOOLS": "your-value"
      }
    }
  }
}

Run this in your terminal

claude mcp add audrey --env AUDREY_DATA_DIR=your-value --env AUDREY_AGENT=your-value --env AUDREY_EMBEDDING_PROVIDER=your-value --env AUDREY_LLM_PROVIDER=your-value --env AUDREY_ENABLE_ADMIN_TOOLS=your-value -- npx -y audrey

Fill in the empty values before running it.

Open in Cursor

Or copy the settings yourself

Paste into .cursor/mcp.json in your project, or ~/.cursor/mcp.json

{
  "mcpServers": {
    "audrey": {
      "command": "npx",
      "args": [
        "-y",
        "audrey"
      ],
      "env": {
        "AUDREY_DATA_DIR": "your-value",
        "AUDREY_AGENT": "your-value",
        "AUDREY_EMBEDDING_PROVIDER": "your-value",
        "AUDREY_LLM_PROVIDER": "your-value",
        "AUDREY_ENABLE_ADMIN_TOOLS": "your-value"
      }
    }
  }
}

Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.

Open in VS Code

Or copy the settings yourself

Paste into .vscode/mcp.json in your project

{
  "servers": {
    "audrey": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "audrey"
      ],
      "env": {
        "AUDREY_DATA_DIR": "your-value",
        "AUDREY_AGENT": "your-value",
        "AUDREY_EMBEDDING_PROVIDER": "your-value",
        "AUDREY_LLM_PROVIDER": "your-value",
        "AUDREY_ENABLE_ADMIN_TOOLS": "your-value"
      }
    }
  }
}

Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.

This one runs on your computer, and ChatGPT can only connect to servers on the internet. Pick another app.

Your choice stays on this device in a cookie; no account needed.

Values you fill in

AUDREY_DATA_DIR env
Directory for the SQLite memory store (defaults to ~/.audrey/data)
AUDREY_AGENT env
Logical memory owner used for scoped operations (defaults to local-agent)
AUDREY_EMBEDDING_PROVIDER env
local (default, on-device model), openai, gemini, or mock
AUDREY_LLM_PROVIDER env
Optional reflection/consolidation model: anthropic, openai, chatgpt, or mock; unset keeps everything local
AUDREY_ENABLE_ADMIN_TOOLS env
Set to 1 to expose the export, import, forget, and promote tools

These settings are generated from the maker’s registry entry. If the README says otherwise, follow the README.

What it can do

Runs on your computer; the tool list appears in your AI app after you install it.

Basic checksi

We check information anyone can see; we have not read the code. Checks that do not apply are left out of the count. · Checked Nov 6, 2026

✓ Pass
Maker matches the repo
The registry name was verified with the GitHub account Evilander, which owns the repo
… Not checked yet
Still maintained
We have not read this repo from GitHub yet
… Not checked yet
Has a licence
We have not read this repo from GitHub yet
– Not applicable
Endpoint responds
This one runs on your computer; there is no internet endpoint
– Not applicable
Sign-in with OAuth
Runs on your computer and uses local settings instead
… Not checked yet
No hidden instructions in tool descriptions
Runs on your computer; we can only read tool lists from internet endpoints

Compared with others in Search & AI memoryi

More stars than 0% of the other 7243 servers in this category
Published to the registry more recently than 81% of the other 7243 servers in this category
Basic checks equal to or better than 100% of the other 7243 servers in this category

Compared with every active server in this category in the registry. Stars count only when the publisher owns the repo.

Common questions

Is Audrey safe?

It passed 1 of 1 applicable basic checks. We have not read the code. Before adding a key or token, see what access the server asks for and use a key with only the permissions you need.

What keys or codes does it need?

The registry does not list a required key, though some servers ask you to sign in on first use.

Does it run on my computer or in the cloud?

It runs on your computer. Your AI app starts it when needed, and data does not pass through the maker’s servers (unless it calls an online service itself).

Is it still maintained?

The GitHub repo last changed –, and the latest version (2.1.1) reached the registry 8 days ago.

Which apps can use it?

Apps that support MCP, such as Claude Desktop, Claude Code, Cursor and VS Code. You also need Node.js on your computer.

What can I use instead?

In the same category: Context7, Codebase Memory, Exa

Alternatives

Servers in the same category from other makers, sorted by stars.

Reading a card:★ GitHub starsiThree pillars: reviews · checks · usageiUpdated = latest version published to the registryi

Context7

by upstash

Feeds AI the latest docs for libraries and frameworks before it answers, so code it writes does not use outdated, removed functions.

Computer or cloud★ 64,224MITUpdated 3 days ago

Install

Codebase Memory

by DeusData

Codebase knowledge graph for AI agents — 162 languages, sub-ms queries, 99% fewer tokens.

Runs on your computer★ 48,148MITUpdated 20 days ago

Install

Exa

by exa-labs

Connect AI agents to Exa for web search, content fetching, and multi-step research.

Runs in the cloud★ 5,213MITUpdated 44 days ago

Install

README from the maker

Open the README

Copied from the maker’s repo as written. PopNx MCP has not reviewed or endorsed it. HTML, images and scripts are removed. Links lead off this site.

Memory that shows up before your coding agent makes the same mistake twice.

Audrey gives Codex and Claude Code one local, evidence-backed memory loop: remember what mattered, recall it automatically, check before acting, and learn from what happened next.

Memory before action

You fix the deploy command on Monday. On Thursday, a fresh session tries the broken version again.

Audrey brings relevant project memory into the next session, checks supported tool calls before they run, and links their reported outcomes to the check that preceded them. A Guard decision carries evidence IDs you can inspect. Grounding can flag memories that reference deleted files or package scripts.

Try the SQLite-backed demo before configuring a host:

npm exec --yes --package=audrey -- audrey demo --scenario repeated-failure

The demo simulates a failed deploy, passes read-only inspection commands through the hook, and checks a proposed retry. It does not execute a deployment or change host configuration. After npm fetches the package, the demo needs no API key, model download, or network call.

Meet Audrey Autopilot

Install Audrey once, review the hooks once, and then use Codex or Claude Code normally.

npm install -g audrey

audrey install --host auto

Requires Node.js 22.16+ (22.x) or 24+. SQLite is built into Node, so fresh installs and npx launches work without approving dependency scripts. npm 11.17+ may warn about dependency scripts, and npm 12 may report that it blocked them; those scripts are not required for Audrey's CPU embedding runtime.

auto configures whichever supported CLIs are installed. You can choose one explicitly:

audrey install --host codex

audrey install --host claude-code

Restart the host after installation. Codex asks you to trust non-managed hooks once through /hooks; Claude Code may also ask you to approve project or plugin components. Audrey is automatic after that explicit install-and-trust step—never secretly installed.

Autopilot then closes the loop:

Moment	What Audrey does
Session starts	Injects a compact, agent-scoped memory briefing
You send a prompt	Recalls relevant evidence; explicitly durable phrases such as “remember that…” or “I prefer…” can become memories
Bash/edit/write is proposed	Checks exact prior failures, trusted rules, procedures, contradictions, and memory health
The tool finishes	Correlates `tool_use_id` to the Guard receipt and records the redacted outcome
A tool failure is reported	Forms a durable, sanitized failure memory for the next attempt
The turn stops or context compacts	Runs lightweight, due-only consolidation without holding the conversation open

An outcome reflects the tool's reported status. A zero exit code can still produce stale or incorrect output. Custom integrations can declare required result checks in beforeAction and supply the actual output to afterAction. Guard then records a mismatch as failed and an unverifiable reported success as unknown. Audrey does not generate application-specific checks or infer the expected values.

Each hook event carries a host-declared timeout (30 seconds for the PreToolUse Guard check). Audrey caps individual hosted embedding/LLM requests below that deadline; this is not a deadline for the entire hook, and local model initialization has no equivalent internal timeout. Errors caught by Audrey fail open by default: the hook emits no decision. Set AUDREY_HOOK_FAIL_CLOSED=1 to deny a PreToolUse action on a caught error. If the host terminates the process first, the host determines what happens. Other lifecycle hooks have no deny path and always degrade open on caught errors.

A small story about a failed deploy

The first attempt fails:

$ npm run deploy

Error: deployment target is missing

Audrey keeps a redacted trace and an action fingerprint. If another session under the same agent identity proposes that action, Guard can deny the retry with evidence. A later recorded success for that fingerprint clears the exact-failure block. If the failed action declared result checks, recovery must pass the same checks. The default exact-failure window is seven days; other memory warnings are evaluated separately.

Fixing a file or deployment target does not itself clear the block. For a deliberate retry, the Guard API accepts acknowledgePriorFailure: true (MCP/REST: acknowledge_prior_failure; CLI: --acknowledge-prior-failure). Autopilot also recognizes retry language in the current user prompt. Acknowledgement lowers the exact-failure block to a warning and preserves its evidence; it does not bypass separate policy warnings.

Guard does not yet evaluate whether a natural-language prerequisite has been satisfied. A trusted must-follow memory can keep blocking even after its suggested repair succeeds. Review the cited rule when that happens; changing a command's spelling is not proof that its underlying problem is fixed.

Looking is not doing

Inspection commands such as grep, git status, and cat normally need no memory check. A non-zero exit from grep can simply mean there was no match.

A command whose every part is positively recognised as read-only skips Guard. The classifier rejects command substitution, redirects other than /dev/null, sudo, xargs, and environment assignments that could change command resolution. Inspection outcomes can be recorded, but are excluded from failure learning. Unrecognised commands remain guarded.

$ grep -rn "prisma" src/          Guard: silent

$ git status --short Guard: silent $ cat prisma/schema.prisma Guard: silent $ npm run deploy Audrey Guard: BLOCKED

recent_failure (high): This exact Bash action failed before: Prisma client was not generated. Run npm run db:generate before deploy.
must_follow (high): Before running npm run deploy, run npm run db:generate because Prisma client must be generated first.

This excerpt illustrates the output of audrey demo --scenario repeated-failure.

When Guard does speak, it names the memory it is speaking from, and a remembered failure is matched to the proposed command by what it runs (npm run deploy against npm run deploy), not by how similar two strings look to an embedding.

Commands with execution-capable options or lifecycle scripts are guarded, including git ls-remote --upload-pack=..., npm pack --dry-run, and ss -K. The classifier is a convenience for ordinary inspection commands, not an operating-system sandbox. Repository configuration, shell expansion, and programs invoked by a reader can change what a command does. Use host permissions or a sandbox when enforcement is required.

What Audrey remembers

Audrey treats memory as more than a pile of text chunks.

Episodes are things that happened: a user decision, a tool result, a project fact, a preference.
Semantic memories are principles supported by accumulated evidence.
Procedural memories are ways of acting: how to retry, verify, avoid, or recover.
Contradictions stay visible instead of being silently overwritten.
Confidence changes with source quality, evidence, age, retrieval, interference, context, and feedback.
Low-value memories decay; repeated evidence can consolidate into longer-lived knowledge.

Every context packet includes memory IDs, confidence, provenance where available, and a reason for inclusion. Uncertain or disputed memories are labeled as such. Retrieved content is wrapped with a simple rule: memory is evidence, not authority; current system and user instructions always win.

Checking memories against the repository

Age is not the only way a memory goes wrong. A note saying "ship with npm run deploy:prod" is perfectly recent, well sourced, and completely wrong the day that script is deleted. Worse, every recall reinforces it, because retrieval counts as evidence that a memory is useful. A confidently stated, well-supported, false instruction is more damaging than no memory at all.

Audrey checks a narrow, useful part of this problem: whether referenced repository paths and package script names still exist. When a memory is written with project context, it records only anchors that resolve at that moment. A missing anchor can then distinguish a later repository change from a reference that never resolved.

Existence does not establish correctness. A script can keep its name while changing behavior, and an intact file can contain obsolete instructions. Grounding does not execute scripts, prove a fix, or verify arbitrary claims in prose.

audrey ground

[audrey] Grounding memories against /home/you/project

[audrey] Checked 14: 12 still true, 2 broken, 0 repaired. [audrey] 01K8ZQ... references a missing npm_script: deploy:prod [audrey] 01K8ZR... references a missing path: scripts/release.mjs

Broken memories are not deleted. They keep their content, say plainly what they still refer to, and take a confidence penalty so they stop leading by default while remaining readable and repairable. They also stop being eligible for the packet's must-follow section — that is the section that can force a Guard block, and a rule naming a file that no longer exists is a rule nobody can follow.

Repair is symmetric. Restore the file or the script and the next check clears the flag. A checkout that has moved reports unknown rather than broken, because a memory should not be discredited for describing a project this machine cannot currently see.

Memories with no checkable claims are left unlabeled. Silence is not a clean bill of health, and presenting it as one would be the same mistake pointed the other way.

Daily use

Most of this runs on its own once Autopilot is installed. You do not invoke recall, and you do not invoke Guard. The table is here for the parts you would reach for deliberately, and so the automatic parts are legible rather than magic.

What	When you want it	Why it helps	How
Autopilot	Always, after one install	The whole point. Memory arrives before the agent acts instead of after you notice it went wrong.	`audrey install --host auto`, restart the host, approve hooks once
Guard	Automatic, before supported edit, write, or shell tool calls	Checks action fingerprints against recorded failures and surfaces memory warnings. Recognised read-only commands skip the check. Repairing the repository alone does not clear a prior failure.	Runs at `PreToolUse`. Manually: `audrey guard --tool Bash --strict`
Grounding	After deleting or renaming things a memory might mention	Flags previously observed paths or package script names that no longer exist.	`audrey ground`, or let the maintenance sweep do it
Session briefing	Automatic at session start	Small, scoped packet instead of pasting context every time. Unchanged memories inject once per session; changes to content or standing are sent again.	`SessionStart` hook. Preview with `audrey greeting`
Explicit capture	When you say "remember that…" or "I prefer…"	Deliberate memories are worth more than inferred ones, and phrasing it that way is enough.	Just type it. Autopilot picks up those sentence shapes

| Consolidation | Automatic when idle; manually before a long break | Repeated ep

Only the beginning is shown; read the rest in the repo

Audrey

Overview

PopNx MCP’s three pillars

What you can do with it

Install

Before you install

Values you fill in

What it can do

Basic checksi

Maker matches the repo

Still maintained

Has a licence

Endpoint responds

Sign-in with OAuth

No hidden instructions in tool descriptions

Compared with others in Search & AI memoryi

Common questions

Alternatives

Context7

Codebase Memory

Exa

README from the maker

Memory before action

Meet Audrey Autopilot

A small story about a failed deploy

Looking is not doing

What Audrey remembers

Checking memories against the repository

Daily use