Skip to content
Tanvrit AI
Web App
The private AI engineering platformv1.6.4 · VS Code v1.5.1

Your codebase, indexed locally. Queryable by any AI client.

Tanvrit AI parses 21 languages into a SQLite index on your machine and serves 45 MCP tools on localhost:19281, so Claude Code, Cursor, Zed or your own agent answer from your real call graph instead of guessing from filenames. Your code never leaves the machine, and every agent edit is staged, reviewable and reversible.

Download for desktopTry it in the browser

macOS (Apple Silicon) · Windows · Linux — v1.6.4. A free Tanvrit account is required to sign in; indexing, the local model and all 45 MCP tools then run offline.

v1.6.4Context Pack grounding on every agent surface
claude_desktop_config.jsonBearer-gated · loopback only
{
  "mcpServers": {
    "tanvrit-ai": {
      "type": "http",
      "url": "http://localhost:19281",
      "headers": {
        "Authorization": "Bearer YOUR_TANVRIT_BEARER_TOKEN"
      }
    }
  }
}

One entry, and every question your client asks is answered from the index instead of from your context window. Five-minute quickstart

MCP tools
45
Languages parsed
21
AI providers
10
Fewer tokens per call
90–95%

Token figures are the mechanism, not a survey: get_chunk returns one function body instead of the file it lives in, and get_file_structure returns the symbol outline with no bodies.

Index once. Every AI client gets the same ground truth.

Three steps, and no step involves uploading anything.

  1. 1

    Index your project

    Point Tanvrit AI at any directory. It parses 21 languages, extracts symbols, and builds dependency and call graphs into a local SQLite file you can open yourself.

  2. 2

    Connect your AI client

    Add one MCP server entry to Claude Code, Claude Desktop, Cursor, Zed or your own agent — http://localhost:19281 with the bearer token from Settings.

  3. 3

    Ask a real question

    “Which callers of refreshToken skip the retry path?” The client calls find_references and get_call_graph and answers from your code, not from filenames.

The platform

Six pillars, one local core

From provider routing to a VS Code copilot — every one of them runs against an index that never leaves your machine.

Shipped

AI Router

One routing layer over 10 providers — automatic fallback, circuit breakers, and a cost-aware registry of 33 models with per-token pricing verified against published rate cards. AI Mesh is one of those providers: it routes a turn to a machine you own instead of a vendor. The client router is shipped and the gateway is live for org policy and metering; hosted inference on Tanvrit-managed keys is the one thing still rolling out.

Shipped

Agent runtime

Named, scope-pinned agents on a runtime with staged edits — apply or reject every hunk — self-verification with rollback, run history with token and cost attribution, headless CLI runs, and scheduled agents on Tanvrit Compute.

Shipped

Repository intelligence

A 21-language indexer with dependency and call graphs and 45 MCP tools (per-pack tools register when you enable a Domain Pack). Hybrid search fuses SQLite FTS5 full-text with real semantic embeddings over your code, and the fused Context Pack grounds an agent's first turn in one budgeted call.

Shipped — opt-in

Team knowledge

Opt-in sync of curated decisions, rationales and annotations across your team — default off, every payload redacted. The raw code index never leaves your machine; only the notes you choose to share do.

Server-side live

Enterprise

Org allowlists, enforced local-only mode and BYOK keys encrypted at rest ship in the client. At Enterprise tier a mesh outage refuses cloud fallback rather than silently taking it, so an outage never becomes a data-egress event. Seats, entitlements and marketplace curation are live on the Tanvrit server; a self-host bundle ships in evaluation mode.

Live

VS Code copilot

Streaming agent runs in a panel, Pending Edits review from the editor (the extension never writes files itself), context sync and run history. Extension v1.5.1 pairs fully with desktop v1.6.4.

Explore the platform in depth

The agent platform

Agents that do real work

Four Engineering Agents ship in the box. Each is named, versioned and documented, runs with a tool scope the runtime enforces rather than the prompt requests, stages every edit for your review, and attributes every token it spends.

How agents are governed

Code Reviewer

v1.0.0
read-only

Diff-first review with blast-radius analysis and severity-ranked file:line findings — plus an explicit “Not checked” list. Produces findings, never edits.

Test Writer

v1.0.0
staged writes · verified

Finds untested changed code, mirrors your project's own test style, and runs the suite to green — a headless run fails and rolls back without passing verification.

Migration Agent

v1.0.0
staged writes

Exhaustive from→to migrations: triple-search site discovery, staged per-site edits, and a changed/skipped summary table that must reconcile with discovery.

Docs Agent

v1.0.0
Markdown-jailed

Keeps documentation truthful against the diff — never documents a claim it can't trace to code. Reads anything, writes only Markdown.

Agent Marketplace

in-app

Install agents and Domain Packs in one click — curated, reviewed, scope-pinned. Installs are validated and provenance-stamped, and a download can never shadow first-party code.

Store Operations Agent

Commerce Pack

Works the order queue — investigates with catalog, customer and analytics lookups, then proposes confirm, decline or inventory actions. Ships with the Commerce Domain Pack's 12 governed commerce_* tools, opt-in, and every money-affecting call needs your approval.

Model Context Protocol

45 precision tools

Every tool returns the exact context the model asked for and nothing else. The count is pinned by a test against the live dispatcher catalogue, and CI fails the build if this page drifts from it.

Browse every tool
  • search_codeFull-text code search with context
  • get_chunk90% fewer tokensOne function or class body, not the file
  • get_file_structure95% fewer tokensSymbol outline, no bodies
  • get_call_graphCallers and callees of a function
  • find_referencesEvery usage of a symbol
  • analyze_impactBlast radius of a change
  • analyze_inheritanceType hierarchy traversal
  • analyze_dependenciesImport graph analysis
  • semantic_searchEmbedding search fused with FTS5
  • find_dead_codeUnreferenced symbols
  • get_metricsComplexity and quality metrics
  • git_blameAuthor per line, with the commit

Plus 33 more, including tanvrit_context, get_context, get_imports, search_definitions, get_project_overview and get_file — 45 built in, plus per-pack tools that register only when you enable a Domain Pack.

20 built-in dev prompts

Ready in every connected client, each one running against your indexed codebase.

  • code-review
  • explain-code
  • refactor
  • write-tests
  • document
  • find-bugs
  • optimize
  • optimize-sql
  • architecture-review
  • security-audit
  • migration-guide
  • debug-error
  • fix-compilation-errors
  • add-error-handling
  • add-type-annotations
  • suggest-design-pattern
  • create-data-model
  • generate-api-docs
  • generate-changelog
  • write-commit-message

One codebase, every desktop

Built with Kotlin Multiplatform and Compose Multiplatform. Native builds for macOS, Windows and Linux, plus an install-free browser build.

.dmg · ~270 MB

macOS

Native desktop app with the full MCP server on 127.0.0.1:19281. Apple Silicon or Intel, macOS 13 Ventura or later.

Download
.msi · ~265 MB

Windows

Native installer with the full MCP server on 127.0.0.1:19281. Windows 10 (1809+) or later, x64.

Download
.deb · ~250 MB

Linux

Debian package with the full MCP server on 127.0.0.1:19281. Ubuntu 20.04+ or compatible, glibc 2.31+.

Download
.apk · ~86 MB

Android

Mobile app — chat, your indexed projects and the agent on the go. Sideload the APK (enable “Install unknown apps”). Cloud models run anywhere; local inference is desktop-only.

Download APK

Web

Browser build via Kotlin/WASM — explore the UI and your indexed projects with no install. The MCP server, Local API and local inference engine are desktop-only.

Try in browser

All builds, checksums and system requirements

There is also a tanvrit command line over the same runtime — a standalone Linux download, built from source on macOS and Windows, and not part of these installers.

Architecture

Everything runs on your machine

The index is a SQLite file you can open with any client. The MCP server listens on 127.0.0.1:19281 and nowhere else — binding 0.0.0.0 was considered and deliberately rejected — so any AI client on the same machine gets deep access to your codebase and nothing off it can.

Local by construction

  • Local by construction — no code uploads
  • SQLite database, fully inspectable
  • Incremental, hash-based reindexing
  • 20 tables — symbols, call edges, embeddings, agent runs

Under the hood

MCP server
Ktor CIO · 127.0.0.1:19281
Database
SQLDelight · SQLite · 20 tables
Parsers
21 languages · ANTLR (Kotlin) + tuned extractors
AI providers
10 registered · local engine first
Platforms
macOS · Windows · Linux · Web

Built for real work

What developers do with Tanvrit AI

From onboarding to refactoring — the same local index, six different jobs.

Onboarding

Ramp up on a new codebase in hours

Ask your AI “how does auth work here?” and it traces the real call graph instead of guessing from filenames — including the two callers that bypass it.

Refactoring

Safe refactors with real blast-radius analysis

Before renaming a function, see every caller, every test and every cross-module reference. No more “oops, that was used in 14 places.”

Cost control

Stop paying to re-read your repo

A get_chunk call returns one function body instead of the file it lives in. Same answer, a fraction of the context window — and you can watch the difference in your client's tool log.

Dead code

Find unreferenced symbols in minutes

Unreferenced functions, orphan classes, unused types — Tanvrit AI builds the real reference graph, so you can cut cruft with the callers in front of you.

Code review

Catch architectural drift before it ships

Feed PR diffs plus dependency and metric context into your AI reviewer. Feedback grounded in your actual architecture, not generic style rules.

Agent tools

Build agents that understand your code

Any MCP-compatible agent — Claude Code, Claude Desktop, Cursor, Zed or your own — plugs into 45 tools on localhost:19281. Bring your own LLM.

How Tanvrit AI compares

Named categories and checkable claims. Every row below is something you can verify yourself once it is installed.

Tanvrit AI compared with cloud code-index services and an AI client used on its own
CapabilityTanvrit AICloud code-index SaaSYour AI client alone
Your index leaves your machineNeverAlways—
Server listens on127.0.0.1 onlyVendor cloud—
Answers from a real call graphYesSomeNo
Languages parsed21Varies—
Response scoped to a symbol, not a fileYesVariesNo
Air-gapped / self-hosted deploymentEvaluation previewRarely—

— = not applicable to that category.

Pricing

Start free. Pay when you want priority.

Your code stays on your machine on every tier. The prices below are the ones the in-app checkout charges.

Free

Local-first — bring your own keys

₹0/ month

  • All 45 MCP tools and the full agent runtime
  • All 21 language parsers, unlimited local repos
  • Built-in local model runtime — no Ollama or Docker needed
  • Bring-your-own key: Claude, GPT, Gemini, DeepSeek, Groq, Mistral
  • AI Mesh, standard routing
  • Community support
Download
Most popular

Pro

For individuals shipping daily

₹1,000/ month

  • Everything in Free
  • AI Mesh priority routing and higher limits
  • No trial-expiry prompt at launch
  • Priority support
Upgrade in the app

Team

Team Knowledge sync — shared decisions, local code

₹1,000/ user / month

  • Everything in Pro
  • Team Knowledge sync — curated decisions, opt-in and redacted
  • Workspace billing and audit log
  • Org policy and metering through the AI gateway
Talk to us

Every account starts with a 30-day full-access trial; Free keeps working after it, with your own keys and the bundled local model. Compare every plan, including self-hosted

Frequently asked

Does my code leave my machine?

No. Indexing, parsing and MCP tool execution happen entirely locally, and the MCP server binds 127.0.0.1 only — run lsof -i :19281 and see for yourself. The only outbound calls are to whichever AI provider you configure, and those receive just the chunks your agent asks for.

Do I need an account?

Yes. Sign-in is mandatory on every platform, and you set a display name once on first run. That account is the only thing that leaves your machine — your source, your index and your tool responses never do.

Which AI clients work with Tanvrit AI?

Any MCP-compatible client: Claude Code, Claude Desktop, Cursor, Zed, Continue.dev or an agent you write yourself, over HTTP or stdio on localhost:19281. We also ship a VS Code extension and a built-in chat UI across 10 registered providers — the bundled local engine, Ollama, Claude, GPT, Gemini, DeepSeek, Groq, Mistral, AI Mesh and Local ML.

Do I need to bring my own API keys?

Not for local use. The app ships its own inference runtime and downloads a coder model on first run, so there is no Ollama or Docker prerequisite — point it at an existing Ollama library only if you already have one. Bring your own Anthropic, OpenAI, Gemini, DeepSeek, Groq or Mistral key when you want a frontier model: bring-your-own-key is on the Free tier, not a paid add-on.

Is there a free trial?

Every account starts with a 30-day full-access trial. When it ends on the Free tier the app shows an upgrade prompt at launch; dismiss it with “Continue with my own API key” and Free keeps working — local indexing, all 45 MCP tools, the agent runtime, the bundled local model and your own provider keys. What moves behind Pro is AI Mesh priority routing and the higher hosted limits.

How big a codebase can it handle?

The index is SQLite with incremental, hash-based reindexing, so the cost of staying current scales with what changed rather than with repo size. We have not published a benchmark at a specific line count, so we are not going to quote one; for very large monorepos, point Tanvrit AI at the subtree you are actually working in.

What languages are parsed?

21: Kotlin, Swift, Objective-C, TypeScript, JavaScript, Python, Go, Rust, Zig, Java, C, C++, C#, Dart, Scala, Ruby, PHP, Elixir, Haskell, Lua and Shell. Kotlin is parsed with a real ANTLR grammar; the rest use tuned extractors built for symbol, import and reference recovery. Ask for yours.

Can I self-host?

Running the whole stack inside your own network is the Self-hosted tier — a per-deployment licence, currently shipping as an evaluation preview. Team runs against Tanvrit's hosted sync layer, with the code index still local to each machine.

How do the token savings work?

Instead of your agent dumping a whole file into the context window, the tools return only the piece being asked about: get_chunk returns one function body, get_file_structure returns the symbol outline with no bodies. On a large file that is 90–95% less text for the same answer.

Put agents to work on your code

Index your first repo in about two minutes. Your source stays on disk — only the chunks your agent asks for ever go anywhere. A free Tanvrit account is required to sign in.

Download for Mac (Apple Silicon)WindowsLinux

All builds and checksumsTry it in the browser