Code intelligence for 15+ languages: semantic graph queries instead of file reads. 37 MCP tools.
io.github.aovestdipaperino/tokensave MCP Server
This MCP server provides code intelligence for 15+ programming languages using semantic graph queries instead of file reads. It exposes 37 MCP tools, as indicated by the repository description. The included excerpt frames the approach as targeting fewer tokens and fewer tool calls, with processing noted as local.
🛠️ Key Features
Semantic graph queries rather than file reads
Code intelligence support for 15+ languages
37 MCP tools
🚀 Use Cases
Querying code context across multiple languages
Reducing reliance on direct file reads during agent-assisted coding
⚡ Developer Benefits
Semantic graph-based access to code information
Potentially fewer tokens and tool calls, with “100% local” noted in the excerpt
⚠️ Limitations
Specific tool names, query scope, and supported graph operations are not detailed in the provided excerpt
AI coding agents waste tokens exploring codebases. Every grep, glob, and file read costs money. On complex tasks, agents spawn multiple Explore sub-agents that scan hundreds of files just to build context.
tokensave gives agents a pre-indexed semantic knowledge graph. Instead of scanning files, the agent queries the graph and gets instant, structured answers -- the right symbols, their relationships, and source code, in one call.
How It Works
flowchart TB
subgraph agent["AI Coding Agent (Claude Code, Codex, Gemini, Cursor, ...)"]
task["Implement user authentication"]
first["Sub-agent"]
second["Sub-agent"]
task --> first
task --> second
first --- second
end
subgraph server["tokensave MCP Server"]
search["Search: auth"]
callers["Callers: login()"]
context["Context for task"]
db[("libSQL Graph DB<br/>Instant lookups<br/>FTS5 search")]
search --> db
callers --> db
context --> db
end
first --> search
first --> callers
second --> context
Without tokensave: Agents use grep, glob, and Read to scan files -- many API calls, high token usage.
With tokensave: Agents query the graph via MCP tools -- instant results, local processing, fewer tokens.
Key Features
Smart Context Building
Semantic Search
Impact Analysis
One tool call returns everything the agent needs -- entry points, related symbols, and code snippets.
Find code by meaning, not just text. Search for "authentication" and find login, validateToken, AuthService.
Know exactly what breaks before you change it. Trace callers, callees, and the full impact radius of any symbol.
80+ MCP Tools
50+ Languages
12+ Agent Integrations
From call graph traversal to dead code detection, atomic edit primitives, code-health metrics, test mapping, and complexity analysis.
Rust, Go, Java, Python, TypeScript, C, C++, Swift, Svelte, Astro, and 48 more including WGSL/HLSL/Metal shaders, CUDA/HIP, and Markdown. Three tiers (lite/medium/full) control binary size.
Claude Code, Codex CLI, Gemini CLI, Qwen Code, Kiro, Cursor, OpenCode, Copilot, Cline, Roo Code, Zed, Antigravity, Kilo CLI, Kimi CLI, Mistral Vibe, Grok Build, Factory Droid, OMP, Pi, Plank.
Multi-Branch Indexing
100% Local
Always Fresh
Per-branch databases, tracked automatically as you check out branches. Cross-branch diff and search without switching your checkout.
No data leaves your machine. No API keys. No external services. Everything runs on a local libSQL database.
On-demand staleness check on every MCP call (30 s cooldown) plus catch-up sync when the server connects. Multi-agent work is expected to use git worktrees — each agent gets its own checkout and the index diverges are merged by git, not by a file watcher.
Subprocess-Isolated Extraction
Code-Health Analytics
Atomic Edit Primitives
A native crash in any tree-sitter grammar (abort, segfault, anything) kills only the worker; the pool respawns it and sync continues. Sync never dies on a malformed file.
Composite health score (0-10000), Gini inequality, file-DAG depth, design-structure matrix, risk-weighted test gaps, and session deltas.
Edit files without regex or shell-quoting hazards: unique-anchor str_replace, atomic multi-replace, AST-rewrite, anchored insert. Auto re-indexes after writes.
Quick Start
1. Install
Choose one installation method:
Platform
Command
Any platform (Cargo)
cargo install tokensave or, with cargo-binstall, cargo binstall tokensave
The default Cargo build includes all supported languages. For a smaller build:
bash
cargo install tokensave --no-default-features --features medium
cargo install tokensave --no-default-features # lite (smallest binary)
Prebuilt release archives:
Platform
Archive
macOS (Apple Silicon)
tokensave-vX.Y.Z-aarch64-macos.tar.gz
Linux (x86_64)
tokensave-vX.Y.Z-x86_64-linux.tar.gz
Linux (ARM64)
tokensave-vX.Y.Z-aarch64-linux.tar.gz
Windows (x86_64)
tokensave-vX.Y.Z-x86_64-windows.zip
2. Configure your agent
Run the setup command to auto-detect your installed agents:
bash
tokensave install
To choose an agent, use --agent (for example, codex, claude, or cursor):
bash
tokensave install --agent codex
Setup registers the MCP server and the agent's integration for Claude Code,
Codex CLI, Gemini CLI, Cursor, Copilot, Kiro, Pi, Zed, and
more than a dozen other agents.
It also offers global Git hooks to keep initialized projects up to date. You can
safely run setup again after upgrading. See
Agent Integrations for project-local installs,
several agents at once, and what setup writes for each agent.
3. Index your project
bash
cd /path/to/your/project
tokensave init
This creates a .tokensave/ directory with the knowledge graph database. A
repository you create with git init is initialized automatically on its first
commit or agent session (auto_init, on by default). After that,
tokensave sync updates the index incrementally, and a connected agent keeps it fresh automatically. Commands work
from any subdirectory of the project. See
Indexing and Freshness for details.
tokensave compared with CodeGraph and alternatives
The long-form User Guide walks through everyday use in more
depth. To contribute, see CONTRIBUTING.md.
Origin
This project is a Rust port of the original CodeGraph TypeScript implementation by @colbymchenry. The port maintains the same architecture and MCP tool interface while leveraging Rust for performance and native tree-sitter bindings.