chat-recall

chat-recall is, in its own words, Ctrl+F for every conversation you've had with an AI. Your team has done months of work with AI assistants, and a single command — npx chat-recall init — reads what those assistants already wrote down and turns it into one searchable history. The product is aimed at teams and developers who work daily with AI coding assistants and who have accumulated a large, scattered record of that work: the chats, the plans, the task lists and the notes. Rather than asking people to remember which tool holds which decision, chat-recall collects everything into one place that is searchable the moment it arrives. Critically, passwords are removed before anything leaves your computer, so the searchable history can be assembled without shipping secrets off the machine. The stated purpose is simple: make months of AI-assisted work findable, and stop teams from redoing work they already finished. The problem it addresses is fragmentation and loss of recall. Claude Code, Codex, Cursor and OpenCode each keep a full record of a team's work, in its own format, and none can read the others. The result, as the site puts it, is that none of it is searchable — until now. The headline framing is that Ctrl+F doesn't work on your brain, but chat-recall makes it work on your chat history. That matters in two directions. First, knowledge: decisions, plans and completed work live inside conversation histories nobody can search, so your assistant keeps asking what was decided last month, and people repeat work that was already done. Second, security: conversations with AI assistants are a place where credentials leak, and an API key pasted into an old chat is a live liability that nobody can audit by hand across months of history. chat-recall addresses both the recall problem and the leaked-secret problem from the same source of truth. The first capability group is unified, searchable history. chat-recall reads the record your assistants already wrote — conversations, plans, task lists and notes, across five AI coding tools — and assembles everything into one searchable history. Everything is searchable the moment it arrives, so there is no separate export or migration step to perform. Beyond manual searching, your assistant searches the history itself, which means it stops asking what you decided last month. That closes the loop: instead of a person being the only bridge between five separate chat tools, the assistant you are currently talking to can reach the shared record and pick up the context the team has already established. For a team whose decisions live in chat, this converts an unsearchable archive into a lookup. The second capability group is secret handling and leaked-key detection. Password removal happens on your own computer, before anything leaves the machine, and the system only ever sees the last few characters of a value — the site illustrates this with a masked key that keeps only its final characters visible. On top of that, chat-recall finds keys that leaked into old chats and checks which ones still work. The security view shows every key that was found, whether it still works, and how many conversations it turned up in. Each row presents a masked preview, a live-or-dead verdict, the detectors that matched, and how many sessions the key appeared in, with entries grouped by rule. Detection is based on the key formats the big services publish. If a company invented its own key format, users can tell the system the pattern and it gets checked too. Together this turns an unbounded audit problem — months of chat logs and unknown leakage — into a screen with a concrete verdict per credential. The third capability group is keeping every assistant and every machine on the same setup. The toolkit coverage matrix shows six skills down the left-hand side and a column for each AI tool on each of two computers; a filled cell means the skill is installed there, an empty ring means it is not. Each row carries a coverage count and a sync-to-all action, so a blank cell can be clicked to copy the missing add-on across. This makes consistency visible rather than assumed. A new laptop already knows everything: sign in and your whole history is right there, with nothing to copy over by hand. Every add-on you have built up follows you to whichever assistant you pick up next, so trying a new assistant does not mean starting over. Rules are set once, per project: mark a project a prototype or a live product, and every assistant that opens it plays by the right rules. And bugs turn into tasks on their own — each one shows up with the fix already sketched out, and closes itself once the problem is actually gone. The methodology behind all of this is local-first. Steps one through three — reading your conversations, removing passwords, and producing one searchable history — happen on your computer, and that history never leaves your computer. The ordering is deliberate: redaction is applied at the point of collection rather than after transmission, so the pipeline that aggregates five tools' worth of chat data does not also aggregate the secrets inside them. Your assistants then reach that local history themselves, which is what makes "your assistant searches it itself" possible without a manual export-and-import cycle between tools. The benefits follow directly from those mechanics. Teams stop redoing work they already finished, because completed work is findable. Passwords come out before anything leaves the computer, and leaked credentials are surfaced with a verdict rather than buried in old chats. People see what to fix next instead of guessing. Moving to a new computer means signing in rather than copying files by hand. Adopting an additional assistant no longer resets the accumulated add-on setup. Project rules are applied consistently across every assistant that opens a given project, and bugs become tracked tasks that close themselves once the underlying problem is actually resolved. In practice, the described workflows are concrete. A developer installs the tool with one command and gains a searchable history spanning the five AI coding tools they already use. A team opens the security view and sees each leaked key grouped by rule, with a masked preview, a live-or-dead verdict and the number of sessions it appeared in, then decides what to act on. Someone sets up a second computer, signs in, and finds the whole history already there. A developer who wants to try a different assistant carries their add-ons with them instead of rebuilding them. A project is marked a prototype or a live product so every assistant that opens it applies the right rules. A bug reported during a session arrives as a task with the fix already sketched out, and closes itself once the problem is gone. And an assistant asked about an earlier decision searches the shared history itself rather than asking the user to repeat it. On audience and integrations, the content points to teams that run multiple AI coding assistants — Claude Code, Codex, Cursor and OpenCode are named, and the diagrams consistently describe five AI coding tools and two computers. Installation is a Node command run with npx: npx chat-recall init. The product also exposes a way for the assistant to query the history directly, described on the site as "what your assistant can ask" and linked at the /mcp/ path, which indicates an MCP-based interface for assistants. No pricing, plan tiers, or supported operating systems are stated in the provided content. The takeaway is that chat-recall treats AI chat history as a first-class, searchable, shared asset while treating the secrets inside that history as something to strip before it goes anywhere. One command turns scattered records from five AI coding tools into one history your assistant can search itself; passwords come out before anything leaves your computer; leaked keys get a verdict instead of a guess. Ctrl+F doesn't work on your brain, but with chat-recall it works on your chat history.