Imprint gives your AI coding agents one persistent memory. The decisions, fixes and context they learn come back in every session and every tool, sync to your other machines, and can be handed to a teammate in one command. It all runs on your machine.
curl -fsSL https://raw.githubusercontent.com/alexandruleca/imprint-memory-layer/main/install.sh | bash
Embedded Qdrant is single-writer: the MCP server, hooks and imprint ingest
can't share its on-disk lock. Auto-spawn a local server on 127.0.0.1:6333 instead.
One memory for every MCP agent · imprint setup all
Built-in agent memory lives in one tool, on one machine, for one person. Every new session starts blank and your agent re-reads the same files. Imprint keeps what it learns and takes it with you.
Hooks capture decisions as you work and save context before the window compacts. Your agent searches memory first, so it stops rediscovering the same answers. Guidelines you approve about how you like to work, drafted from what you have told your agents, reach every new session.
one shared store
Claude Code, Cursor, Copilot, Codex, Cline and other MCP hosts read and write the same memory. What one agent learns, the next one already knows.
Pair a laptop, a desktop and a cloud box with a one-time share code. Memories and facts merge both ways, or one way, without duplicates, end-to-end encrypted. Projects are identified by their manifest, not their path, so they line up everywhere.
Give a colleague what your agent has learned about a codebase: decisions, fixes and indexed docs. Copy just that project into a team workspace and send it, one way if you like. Everything else stays where it is.
Pair two machines through a relay and Imprint merges their memories, both ways or just one, end-to-end encrypted. Keep your laptop and workstation in step, or give a new teammate's agent the project's history on day one.
One machine runs the command below and prints a one-time share code.
imprint sync serve The other side passes the code: your desktop, a cloud VPS, or a teammate’s laptop. Joining receives; add --two-way to send back too.
imprint sync <code> The serving side sees the device’s hostname, user, OS and fingerprint and accepts it once or trusts it. A joining machine that sends sees the serving device and confirms first.
Memories and facts stream across and are deduplicated on arrival. The serving side can be --send-only or --receive-only; the joining side sends only with --two-way or --send-only.
Each session’s code becomes the key (SPAKE2) without crossing the relay; every frame is AES-256-GCM. The relay only ever sees ciphertext.
Memories and facts merge without duplicates. Unchanged workspace digests skip the next vector transfer.
Joining only receives unless you add --two-way, and you see which machine gets your workspace before anything is sent. The serving side enforces its own one-way choice.
Run the stateless relay from a small Docker image on your own domain, or move zipped snapshots instead.
Checking the public relay…
Sync codes made without --relay meet here.
Keep your own devices in step: enable automatic pairing on both sides, or add --remember
to both commands. While both dashboards or imprint sync watch processes run,
Imprint reconnects with the same workspace and approved direction. Pause anytime, or confirm forgetting
the device on both sides. Offline removal remains pending until they reconnect.
The code’s secret never crosses the relay, and the relay — including the default one — never sees your devices or your memories; a wrong code or an altered frame ends the session. Vectors travel with each record, so the receiving machine doesn't re-embed anything; both sides need the same embedding model. See it step by step, or read the sync docs.
A workspace is a separate memory with its own vector collection and fact graph. Keep client work, side projects and team knowledge apart. When you want to share, copy exactly what belongs into its own workspace and sync only that, one way if you prefer.
Copy a project, a topic or a single source into its own workspace. Your workspace keeps everything; add --dry-run to preview.
$ imprint migrate --from default --to team --project billing-api --copy Serve only that workspace. Your active workspace doesn’t change, and anything pushed back is refused.
$ imprint sync serve --workspace team --send-only Your teammate runs the code it prints, into the workspace they work in or a separate one with --workspace. Nothing of theirs is sent back.
$ imprint sync <code> --workspace from-you The dashboard has the same controls: copy or move memories between workspaces, and pick the workspace and direction on the Sync page. Workspace docs.
You don't curate notes. Imprint indexes what already exists and keeps learning while you work, then tags every chunk so agents can filter by language, layer, domain and topic.
automatic Agents store decisions, patterns and bug fixes through MCP. In Claude Code, hooks also extract them after each response and save context before compaction.
imprint ingest . Files are cut into overlapping spans at paragraph and line breaks, and each whole file is kept, redacted, for agents to read in full. Refresh re-indexes only the files that changed.
imprint learn --desktop Claude Code, Codex, Cursor, Copilot, Cline and OpenCode sessions, WSL profiles included, each kept whole and redacted with its tool calls and their output. Add Claude and ChatGPT data exports with --desktop.
imprint ingest-url <url> PDFs, office documents and URLs, or a page you save from Chrome with the preview extension. Stored pages are re-fetched only when their ETag or Last-Modified changes.
imprint ingest call.m4a Record a call in the dashboard, your microphone and optionally the computer’s audio, or index audio files. They are transcribed on your machine, with timestamps, and the audio stays there.
ingest_content Push text, Markdown, CSV, JSON or code from your own services through MCP or the HTTP API.
Your agent gets the few chunks that matter, with enough provenance to verify them. You get a dashboard
to see exactly what it knows. Run imprint ui, or open the desktop app.
Hybrid semantic and exact-term ranking. Every hit carries its source, hash and age, so the agent can check the live file before it edits.
A temporal knowledge graph stores subject → predicate → object with start and end dates, so a superseded decision doesn’t come back as current.
Reuse the fix you already shipped in another repo. Search covers every project in the workspace unless the agent narrows it, and a hit’s nearest neighbors turn up related work elsewhere.
Browse the graph, topics and sources, sort loose sources into projects with Organize, and run ingest and sync jobs. Ask Chat, or Echo by voice: it researches your memory, asks when a question is unclear, and sets reminders, timers and scheduled jobs.
Your agent talks MCP to a local Imprint server. Storage, embeddings and tagging all run on your machine, with no paid API calls. Data leaves only when you sync, encrypted end to end, or pick a cloud model for tagging, summaries or chat.
Uninstalling is symmetric: imprint disable removes every host entry it wrote
and keeps your data, so imprint enable brings it all back.
Architecture docs.
A self-contained .venv, an auto-downloaded Qdrant binary, and every installed host
wired in one run. Pin a version with IMPRINT_VERSION=vX.Y.Z, or grab a
desktop installer.
curl -fsSL https://raw.githubusercontent.com/alexandruleca/imprint-memory-layer/main/install.sh | bashimprint setup all imprint ingest . imprint ui Apache 2.0, self-updating, and removable with one command. Start on your laptop and sync to the rest of your machines, or your team, when you're ready.