/* code intelligence for ai agents */

sverklo

Other tools remember your conversations. Sverklo understands your code.

Local-first code intelligence MCP with hybrid semantic search, symbol-level impact analysis, and bi-temporal memory tied to git state. Runs entirely on your machine — no API keys, no cloud, no data leaves your laptop.

~/your-project claude code

# install sverklo and set it up in any project $ npm install -g sverklo $ cd your-project && sverklo init ✓ .claude/mcp.json ✓ .claude/settings.local.json ✓ CLAUDE.md # ask your agent anything — sverklo is preferred automatically > how does the auth middleware work? ⚡ sverklo_search query="authentication middleware" ─ src/middleware/auth.ts:42 validateToken() score: 0.89 ─ src/routes/auth.ts:18 requireAuth() score: 0.84 ─ src/lib/jwt.ts:12 verifyJWT() score: 0.81 ✓ 3 results in 23ms — 847 files searched, 2,431 tokens used

/* how it works */

indexed.
ranked.
remembered.

hybrid search

BM25 for precision, semantic embeddings for recall, PageRank for structural importance — fused via RRF. Faster and more accurate than grep.

local embeddings

all-MiniLM-L6-v2 via ONNX runtime. 384-dimensional vectors generated on your machine. No API calls, no data leaves your laptop.

pagerank ranking

Files that are imported by many others rank higher. Your agent finds the actually-important code first, not just keyword matches.

persistent memory

Save decisions, patterns, and preferences with git-state linking. Stale memories flagged automatically when referenced files change.

incremental

File watcher updates the index on every save. Dependency graph and PageRank recompute in real time. Always fresh.

twenty languages

TypeScript, JavaScript, Python, Go, Rust, Java, C, C++, Ruby, PHP, Kotlin, Scala, Swift, Dart, Elixir, Lua, Zig, Haskell, Clojure, OCaml.

/* persistent memory */

your agent
finally
remembers.

Every AI coding session starts from zero. Decisions vanish after context compaction. Sverklo fixes this with persistent memory linked to git state.

On sverklo init, your existing CLAUDE.md, .cursorrules, and ADRs get parsed into searchable memories — categorized, tagged, and embedded automatically.

Tell your agent to remember new things as they come up. Ask later. It's already there.

session 0 · day one import

# bring your existing docs — sverklo ingests them automatically $ sverklo init ✓ .claude/mcp.json · .claude/settings.local.json · CLAUDE.md Scanning for existing project knowledge... ✓ imported 18 memories from: · CLAUDE.md (12) — conventions, tech stack · .cursorrules (3) — style preferences · docs/adr/001-prisma.md — decision, tagged adr · docs/adr/002-auth.md — decision, tagged adr · CONTRIBUTING.md (1) — review process

session 1 · tuesday remember

> we decided to use Prisma for the ORM because it gives better TypeScript types than Drizzle ⚡ sverklo_remember category="decision" content: "We chose Prisma over Drizzle for better TypeScript types" tags: ["database", "orm"] git: main@a3f29e1 confidence: 1.0 ✓ memory #42 saved

session 2 · thursday (new conversation) recall

# session start — sverklo://context auto-injected Loaded 3 memories: ORM choice, auth pattern, API conventions > add a new API endpoint for user profiles # Claude knows: Prisma for DB (from memory #42) # Claude knows: JWT validation before DB calls (from memory #43) ⚡ writes endpoint with Prisma + JWT validation — no rediscovery

bring your own docs

Auto-imports memories from CLAUDE.md, .cursorrules, AGENTS.md, CONTRIBUTING.md, and ADRs on init. Your existing project knowledge becomes semantically searchable instantly.

bi-temporal (unique to sverklo)

Every memory has valid_from_sha and valid_until_sha. Memories are never deleted, only superseded — so you can query "what we believed at commit X". Zep does this for conversations; sverklo is the only one doing it for code.

staleness detection

If a memory references a file that no longer exists, it's flagged as stale. No more advice based on deleted code.

semantic recall

Memories are embedded and searched the same way as code. Ask "what did we decide about auth?" and get the relevant memory.

auto-inject on session start

An MCP resource surfaces top memories to Claude before you type anything. Your decisions travel across sessions automatically.

/* mcp tools */

fifteen tools
your agent
actually uses.

Each tool gets registered with the MCP server's instructions field, telling Claude to prefer them over built-in grep. Combined with a SessionStart hook, adoption is guaranteed.

sverklo_search

Hybrid semantic + text search across the codebase. Preferred over grep.

sverklo_overview

Structural codebase map ranked by PageRank importance.

sverklo_lookup

Direct symbol lookup by name with full definitions.

sverklo_refs

Find all references to a function, class, or type.

sverklo_deps

Show file dependency graph — imports and importers with ref counts.

sverklo_status

Index health check. File count, chunk count, languages.

only one tool
has everything.

The code intelligence and memory space is fragmented. Each competitor gives up at least two of these six dimensions. Sverklo is the only one with all six.

Tool	Code-native	Local-first	MCP drop-in	Git-aware memory	Symbol graph	Bi-temporal
sverklo	●	●	●	●	●	●
mempalace	—	●	●	—	—	●
claude-mem	—	●	CC only	—	—	—
Mem0	—	crippled	SDK	—	—	—
Zep / Graphiti	—	Neo4j	●	—	—	●
Augment Code	●	cloud	●	—	●	—
Greptile	●	cloud	3rd party	—	●	—
Aider repo-map	●	●	—	—	—	—
Zilliz claude-context	●	Milvus	●	—	—	—
XRAY MCP	●	●	●	—	partial	—

Different lanes: Most "AI memory" tools (mempalace, claude-mem, Mem0, Zep) are built to remember conversations. Sverklo is built to understand code. We index 20 languages with tree-sitter-style parsers, build a symbol-level dependency graph, and run hybrid BM25 + vector + PageRank search — then bolt a bi-temporal memory layer on top that's tied to git commits, not wall-clock time.

The wedge: Sverklo is the only tool that knows what the code looked like when you made that decision — and warns you when the code has drifted since. If you want conversation memory, use mempalace. If you want your agent to actually understand a codebase, use sverklo.