Skip to content
trags
Install Poppy

Agents forget. Poppy remembers.

Two commands give your AI memory: install Poppy, then connect your agent. Every coding agent on your machine reads the same store: capture a decision in your terminal, recall it in Cursor, keep it when you switch models. Free, local-first, Apache-2.0.

An enlarged poppy illustration on a green background.

Install, connect, remember, recall

Nothing to configure. Poppy keeps its memory store in ~/.poppy. Cloud sync is one extra command, off by default.

$ pipx install poppy-memory

$ poppy setup claude-code
Poppy is ready. Restart claude-code to activate.

$ poppy remember --type preference "prefer pnpm in monorepos"
Remembered (preference): prefer pnpm in monorepos

$ poppy recall "monorepos"
  prefer pnpm in monorepos
    preference | 2026-09-28 | score: 2.47

# the same store, from every tool wired above.
$ poppy serve

Install. Installs via pipx. Python 3.11+. Isolated in its own virtualenv.

Connect. One command per tool. Safe to re-run, safe to commit to your dotfiles and run in CI.

Remember. Say it in plain prose. Override with -⁠-⁠type or -⁠-⁠project.

Recall. Recall from your shell, Claude Code, Cursor, or Codex, all reading one store.

Every record is one small row

Six fields that matter, and no schema to maintain. You write the sentence, and Poppy fills in the id, project, source and time. Provenance follows the memory wherever it goes.

The format. A memory as Poppy stores it. A memory is a decision you made and the reason, a fact that stays true, a preference for how you want work done, or a lesson that cost you once.

What Poppy added. You typed the sentence and picked its type. Poppy filled in the id, the project, the source and the time, so the provenance travels with the memory wherever it goes.

id
mem_512d64f6a1e8
type
lesson
content
Integration tests only go flaky when they share one seeded database. Give each test file its own schema and the random failures stop.
project
checkout
source
claude-code
captured
2026-06-24

Eleven integrations, one command each

Poppy is MCP-native, so any agent that speaks MCP can read the memory. Below are the ones Poppy ships first-class setup for. The rest is one MCP entry away.

  • Claude CodeAnthropic · CLIpoppy setup claude-code

    MCP entry, lifecycle hooks, and a primer block in ~/.claude/CLAUDE.md. Memory survives /clear and /resume.

  • Claude DesktopAnthropic · macOS, Windowspoppy setup claude-desktop

    Writes the desktop MCP config, then prints a primer you paste into settings once.

  • CodexOpenAI · CLIpoppy setup codex

    Stdio entry in ~/.codex/config.toml, capture hooks, and an AGENTS.md primer. Codex asks you to trust the hooks once.

  • Copilot CLIGitHub · CLIpoppy setup copilot-cli

    MCP config plus the primer at ~/.copilot/copilot-instructions.md, the file Copilot CLI loads on its own.

  • CursorIDEpoppy setup cursor

    MCP entry into ~/.cursor/mcp.json, plus lifecycle hooks in ~/.cursor/hooks.json.

  • Gemini CLIGoogle · CLIpoppy setup gemini

    Adds the Poppy server to ~/.gemini/settings.json and leaves the rest of that file alone. MCP only.

  • GooseBlock · agentpoppy setup goose

    Registered as a Goose extension plus a .goosehints primer for tool discovery.

  • Hermes AgentNous Researchpoppy setup hermes-agent

    Drops a memory provider plugin into ~/.hermes/plugins/poppy and points the config at it.

  • Pibadlogic · agentpoppy setup pi

    Wires MCP through the pi-mcp-adapter shim, with an AGENTS.md primer beside it.

  • VS CodeMicrosoft · IDEpoppy setup vscode

    Poppy entry in the user-profile mcp.json. MCP only, no primer.

  • WindsurfCodeium · IDEpoppy setup windsurf

    MCP only. One command writes ~/.codeium/windsurf/mcp_config.json, no primer.

  • Any MCP agentprotocolpoppy serve

    If your agent speaks MCP, point it at poppy serve and it can read or write the memory. No SDK required: MCP is the API.

The protocol. MCP is the open protocol AI tools use to reach software outside themselves. Poppy speaks it, so anything that does reads the same local store, without an SDK in between.

Safe to re-run. Every setup command can be re-run. It writes the same config it wrote last time, which is what makes it safe to commit to dotfiles and to run in CI.

Your memories live where you do.

Poppy reads and writes a single SQLite database at ~/.poppy/memories.db. Lexical recall through FTS5, semantic recall through an on-device embedding model, reranked by a local cross-encoder.

The cloud is opt-in. Run poppy setup trags to sync to your account on trags.ai and see the same memories on every machine, plus a web dashboard with edit and provenance views.

You can stop syncing whenever, and the local store keeps working unchanged. Delete the file and the local store is gone. Removing the agent integrations is a separate step, and anything you synced stays in Trags until you delete it there.

In short. Every query runs on your machine. No network, no API key, no per-query cost, and nothing leaves the file until you turn on sync.

  • L1 Your machine

    ~/.poppy/memories.dbSQLite + FTS5 + bge-smallrequired

  • L2 MCP server

    poppy serveMCP over stdioon demand

  • L3 Trags

    trags.aiSupabase · device-code authopt-in

Give your AI memory.

One line to install, local forever if you want. Turn on Trags sync the day you don't.

pipx install poppy-memory
See the 11 hosts