2026-06-20 23:00 UTCIn-site rewrite6 min readUpdated: 2026-06-21 23:31 UTC

Show HN: Callimachus – Local search across your AI coding-agent history

Callimachus is a local-first desktop app that indexes conversations from 11 AI coding agents into a SQLite database, enabling hybrid keyword and semantic search, knowledge distillation, and integration with various tools via CLI, MCP, and VS Code extension.

SourceHacker News AIAuthor: arishaller

Notifications You must be signed in to change notification settings

Fork 1

Star 7

BranchesTags

Open more actions menu

Folders and files

NameName

Last commit message

Last commit date

Latest commit

History

43 Commits

.changeset

.github

.vscode

apps

assets

scripts

.dockerignore

.gitignore

COMMERCIAL.md

CONTRIBUTING.md

Dockerfile

LICENSE

NOTICE

README.md

RELEASING.md

SECURITY.md

SIGNING.md

biome.json

glama.json

package.json

pnpm-lock.yaml

pnpm-workspace.yaml

turbo.json

Repository files navigation

Grab the latest signed build from Releases — macOS (.dmg, Apple Silicon), Windows (.msi), or Linux (.AppImage / .deb). The app auto-updates from there on. Prefer to build it yourself? See Develop.

What it does

Indexes every conversation from 11 coding agents into one local SQLite store — Claude Code, Codex, Cursor, Gemini CLI, Qwen Code, Goose, OpenCode, Continue, Cline, Roo Code, and Kilo Code. Adding another source is a small, documented contract.

Searches them with hybrid ranking: keyword (SQLite FTS5 / BM25) fused with on-device semantic similarity (sqlite-vec KNN, no cloud) via Reciprocal Rank Fusion. Filter by source, project, subagents, starred, and tags.

Finds code-aware — type file:embed/mod.rs in the search bar (or cal files ) to find every thread that touched a path; backed by a file-mention index built at index time.

Distills knowledge — free heuristic TODO extraction, plus opt-in LLM distillation of decisions, gotchas, and summaries, with cross-thread semantic recall of past decisions/gotchas. Optional auto-distillation drains new/changed threads in the background so memory self-populates. Needs local Ollama (keyless) or a cloud API key.

Curates the facts — pin, edit, or delete distilled facts so your edits survive re-distilling, plus an LLM "Review conflicts" pass that flags decisions that contradict each other.

Remembers per project — a Projects tab aggregates each repo's decisions, gotchas, and open TODOs into durable memory (grouped by a canonical project key, so worktrees / symlinks / ~ don't split one repo), with an LLM brief and a managed .callimachus/memory.md. That memory is prepended when you "Open in CLI", and you can inject it into any agent automatically: Update AGENTS.md (or cal agents) writes a managed block into the repo's AGENTS.md / CLAUDE.md, and cal hook feeds it to a Claude Code SessionStart hook.

Asks your history (RAG) — a synthesized, cited answer over your own threads, with [thread N] citations back to the sources it used. Needs an LLM engine (Knowledge/distillation enabled).

Organizes into collections — star threads and attach free-form tags, then filter the list by starred or by tag.

Chats with an in-app agent (Anthropic / OpenAI / Gemini / OpenRouter / Ollama — your key, your choice) that can search your own history and run shell commands with your approval; streaming, cancellable, with live model lists. Chats are saved and become searchable too.

Carries context across tools — open any thread in any agent CLI ("Open in Claude / Codex / Gemini …", seeded with the packed transcript), resume a Claude Code / Codex thread in its native CLI, copy context, or export a thread to Obsidian (optionally AI-summarized with decisions / gotchas / TODOs).

Surfaces to your agents — a bundled MCP server (callimachus-mcp) exposes the index as tools any agent can call mid-session, and it's two-way: agents can write back into Callimachus's own memory (close TODOs, record decisions/gotchas) without ever touching your files. The /recall skill teaches them when to use it.

Stays current via a background file watcher; stays private — API keys live in the OS keychain, nothing is sent anywhere except the LLM provider you pick.

Stack

Shell: Tauri 2 (Rust) + React 19 + TypeScript + Vite 8

Store/search: bundled SQLite + FTS5 (rusqlite); on-device embeddings via fastembed (bge-small-en-v1.5, 384-dim); KNN in SQL via sqlite-vec (vec0)

Watcher: notify + debouncer

Chat: multi-provider via the genai crate (Anthropic / OpenAI / Gemini / OpenRouter / Ollama), streaming tokens over a Tauri Channel, cancellable, with agent tool-calls (history search + approved shell)

Secrets: OS credential store via the cross-platform keyring crate — macOS Keychain, Windows Credential Manager, Linux Secret Service

Sidecars: callimachus-mcp (MCP server) and cal (CLI) — both reuse the desktop core lib against the same index.db

Editor: a VS Code / Cursor extension (apps/vscode, published to the Marketplace + Open VSX) that shells out to cal

Monorepo

This is a Turborepo + pnpm workspace.

apps/ desktop/ # the Tauri 2 desktop app + the cal CLI and MCP server (src-tauri) vscode/ # VS Code extension (search history from the editor) web/ # marketing + download site (reserved, not built yet) packages/ # shared code, when it appears .changeset/ # version + changelog management scripts/ # version-sync, release tagging

Releases, versioning, and the auto-updater are documented in RELEASING.md.

Develop

pnpm install pnpm desktop:dev # launches the desktop window (tauri dev)

from the repo root, across all apps:

pnpm build # turbo: build every app's frontend pnpm typecheck # turbo: typecheck every app

First launch: the index is empty — open Settings (or hit Reindex) to index your sources, then Build semantic index to enable semantic search. Reindex runs as a background job with a per-source progress bar, separate from Build semantic index — the two are mutually exclusive (one pauses while the other holds the write lock).

Tests

cd apps/desktop/src-tauri cargo test # fast unit tests cargo test -- --ignored --nocapture # real-data + model + keychain smoke tests

The --ignored tests touch live data on this machine: each source has a real__index smoke test that indexes your real history read-only (~/.claude, ~/.codex, Cursor, ~/.gemini, ~/.qwen, Goose, OpenCode, Continue, Cline/Roo/Kilo), plus the embedding-model download (first run, needs network) and a Keychain round-trip.

Use your history anywhere

Beyond the desktop window, the same local index is reachable from your agents, terminal, and editor — all reading one index.db.

MCP server — let any agent search its own past work mid-session. callimachus-mcp ships with the desktop app (on your PATH); just register it with your client:

claude mcp add callimachus -- callimachus-mcp # or any MCP client

Building from a checkout instead? cargo install --path apps/desktop/src-tauri --bin callimachus-mcp.

Tools (15) — now read and write. Reads: search_threads, search_current_project (auto-scoped to the repo it runs in), recent_threads, get_thread, list_tags, list_open_todos, get_thread_knowledge, recall_decisions, recall_gotchas, project_memory (a project's aggregated decisions / gotchas / open TODOs), ask_history (a cited RAG answer over your history), and threads_for_file (which sessions touched a path). Writes (into Callimachus's own memory, never your code): complete_todo (close an open TODO), record_decision, and record_gotcha (persist a fact into a project's memory). The bundled /recall skill (.claude/skills/recall) tells agents when to reach for them.

CLI — cal, pipe-friendly. Ships with the desktop app (on your PATH); or build from a checkout with cargo install --path apps/desktop/src-tauri --bin cal.

cal search "vector index migration" -y # -y = hybrid (semantic + keyword) cal recent -n 10 cal cat 42 | pbcopy # packed transcript → clipboard cal stats # index totals + per-source breakdown cal export 42 --vault ~/Obsidian # write a thread as an Obsidian note cal ask "how did we set up releases?" # cited RAG answer over your history cal files embed/mod.rs # threads that touched a file path cal memory # this repo's distilled memory (decisions/gotchas/TODOs) cal done 17 # mark an open TODO done (id from cal todos) cal remember decision "use sqlite-vec for KNN" # record a fact into the repo's memory cal agents # write the repo's memory into AGENTS.md (any agent reads it) cal hook # print the repo's memory (use as a Claude Code SessionStart hook)

star, tag, tags, todos, knowledge, distill, decisions, gotchas, and related also exist — run cal help for all 21.

VS Code / Cursor — the extension adds a "Callimachus History" sidebar, a status-bar search button, and commands to search / insert / copy threads (it shells out to cal). Install from the VS Code Marketplace or Open VSX (the registry Cursor and VSCodium use), or grab the .vsix from Releases. See apps/vscode/README.md.

Notes / limitations

Cross-platform (macOS / Windows / Linux). The only macOS-only piece left is the "Open in CLI" / "Resume" launchers (they drive Terminal via AppleScript); on Windows/Linux those actions return a "not supported yet" notice — everything else (index, search, chat, export, keychain) works everywhere.

Cline / Roo Code / Kilo Code are editor extensions with no CLI, so they are index-only (searchable, but not relaunchable via "Resume").

Cursor doesn't store a per-thread workspace, so Cursor threads currently have no project path.

Claude Code subagent transcripts are indexed but hidden behind a "subagents" toggle by default.

Large first index is a one-time cost (the Claude corpus here was ~90k messages in ~25s); subsequent passes skip unchanged files.

More sources (Charm Crush, Factory Droid, Copilot CLI) are scoped but not yet integrated — see the indexer guide.

Contributing

Issues and PRs welcome. CONTRIBUTING.md covers local setup, conventions, and the release flow. Adding support for another agent is a small, documented contract — usually one indexer module + a migration + a few wiring points.

Security & privacy

Callimachus is local-first by design: your conversation index never leaves your machine, API keys live in the OS keychain (never on disk), and the only outbound traffic is to the LLM provider you explicitly choose. To report a vulnerability, see SECURITY.md.

License

Dual-licensed. Free and open source under AGPL-3.0-or-later — use, modify, and share it; if you distribute it or run a modified version as a network service, you must release your source under the AGPL.

For closed-source, proprietary, or for-profit/SaaS use that the AGPL doesn't permit, a commercial license is required — see COMMERCIAL.md (contact [email protected]).

Acknowledgements

Built on Tauri, fastembed-rs, sqlite-vec, and genai. Named for Callimachus of Cyrene, who catalogued the Library of Alexandria.

Social preview: assets/og.png · brand sources in assets/brand/

About

One local, searchable index of your AI coding-agent history Claude Code, Codex, Cursor, Gemini & more. Keyword + semantic search, MCP server, CLI & VS Code extension.

callimachus.app

Topics

rust

sqlite

mcp

embeddings

gemini

developer-tools

vscode-extension

cursor

semantic-search

codex

ai-agents

tauri

local-first

ai-tools

llm

mcp-server

mcp-tools

claude-code

Resources

Readme

License

AGPL-3.0 license

Contributing

Security policy

Uh oh!

There was an error while loading. Please reload this page.

Activity

Custom properties

Stars

7 stars

Watchers

0 watching

Forks

1 fork

Report repository

Releases 8

v0.5.0

Latest

Jun 18, 2026

+ 7 releases

Packages 0

Uh oh!

There was an error while loading. Please reload this page.

Contributors

Uh oh!

There was an error while loading. Please reload this page.

Languages

Rust 50.6%

TypeScript 46.3%

CSS 2.1%

Other 1.0%