jambavan

In the Ramayana, when the army despaired at the ocean's edge, it was Jambavan — the ancient, wise bear-king — who turned to Hanuman and reminded him of his own forgotten, immeasurable strength. Hanuman had the power all along. He only needed to be reminded. Then he crossed the ocean in a single leap.

A large language model is Hanuman. It can already reason, plan, and write code. What it lacks is not intelligence — it is awareness of the ground it stands on: which files exist, what calls what, what was decided last week, what it already tried.

Jambavan is the voice at the ocean's edge. It is a Model Context Protocol server that gives any coding model a live map of the codebase, a durable memory, and a set of surgical tools — so the model's existing power actually lands.

Jambavan does not call an LLM and is not an agent. The host model thinks. Jambavan gives it the ground to leap from.

The powers it hands over

Related MCP server: MegaMemory

Install

One command. Finds every coding agent on your machine (Claude Code, Codex CLI, Cursor, Continue). Registers Jambavan as an MCP server for each one it finds.

# macOS · Linux · WSL · Git Bash
curl -fsSL https://raw.githubusercontent.com/beingmartinbmc/jambavan/main/install.sh | bash

# Windows · PowerShell 5.1+
irm https://raw.githubusercontent.com/beingmartinbmc/jambavan/main/install.ps1 | iex

~30 seconds. Needs Node ≥20. Skips agents you don't have. Safe to re-run. It never touches other MCP servers already in your config — read the script before piping it into a shell, as with anything on the internet.

Register manually

Prefer to wire it up yourself, or use an agent the installer doesn't know about? Same command everywhere: npx -y jambavan.

Claude Code

claude mcp add jambavan -- npx -y jambavan

Codex CLI

codex mcp add jambavan -- npx -y jambavan

Cursor (~/.cursor/mcp.json global, or .cursor/mcp.json per-project)

{
  "mcpServers": {
    "jambavan": { "command": "npx", "args": ["-y", "jambavan"] }
  }
}

Continue — drop a JSON file into ~/.continue/mcpServers/jambavan.json:

{ "command": "npx", "args": ["-y", "jambavan"] }

Troubleshooting (NVM, GUI apps, corporate npm)

npx -y jambavan works when the MCP host inherits a shell PATH containing node/npx and npm can reach the public registry. Two setups break that:

1. GUI-launched hosts (Cursor, etc.) don't see NVM. You'll see spawn npx ENOENT, or — after switching to an absolute npx — env: node: No such file or directory (because npx is a script with #!/usr/bin/env node). GUI apps launched outside your shell don't inherit NVM's PATH. Fix: run an absolute node against npm's npx-cli.js and set PATH explicitly.

2. Corporate npm registry / release-age policy. You'll see No versions available for jambavan (npm pointed at an internal mirror that doesn't proxy it) or No matching version found ... with a date before <date> (an --before / release-age policy rejecting a freshly published version). Fix: force the public registry, clear --before, and pin the version.

Find your paths:

command -v node                                   # → /abs/path/to/node
echo "$(npm prefix -g)/lib/node_modules/npm/bin/npx-cli.js"   # → npx-cli.js

Cursor config with all workarounds applied:

{
  "mcpServers": {
    "jambavan": {
      "command": "/abs/path/to/node",
      "args": [
        "/abs/path/to/npm/bin/npx-cli.js",
        "-y",
        "--registry=https://registry.npmjs.org",
        "--before=",
        "jambavan@0.3.0"
      ],
      "env": { "PATH": "/abs/path/to/node/dir:/usr/bin:/bin" }
    }
  }
}

Apply only the pieces you need: the absolute node + npx-cli.js + PATH fixes NVM/GUI PATH; --registry/--before/pinned version fix corporate npm policy.

Claude Code plugin

This repo is also a Claude Code plugin marketplace. Add it and install with two commands — no manual MCP config:

/plugin marketplace add beingmartinbmc/jambavan
/plugin install jambavan@jambavan

The plugin registers the same npx -y jambavan MCP server (read-only tools by default) and bundles a Vibhishana Niti skill — run /jambavan:vibhishana-niti to activate the efficient-dev discipline in any Claude Code session. Refresh later with /plugin marketplace update jambavan. The catalog lives in .claude-plugin/marketplace.json; the plugin manifest in plugins/jambavan/.claude-plugin/plugin.json.

Run directly

npm install
npm run build
node dist/index.js --help
node dist/index.js

Set JAMBAVAN_ROOT=/path/to/project when launching from outside the target repo.

The leap (recommended workflow)

1. jambavan_awaken — read the protocol and recent project memories.

2. jambavan_index — build the local SQLite code index.

3. jambavan_watch start — keep the index live while editing.

4. jambavan_context — pull ranked, token-budgeted context before touching unfamiliar code.

5. patch_file over write_file — surgical edits, cheaper tokens. (needs JAMBAVAN_ALLOW_WRITE=1)

6. Keep tool output Sankshipta: line ranges, max_results, git --stat / --name-only, jq/yq/awk/cut/head, quiet/no-color flags, and hash/mtime polling before full reads.

7. bash — run the smallest relevant check. (needs JAMBAVAN_ALLOW_BASH=1)

8. jambavan_memory_store / jambavan_memory_mine_session — persist what was decided, so the next session starts awake.

Safety

Read-only by default. read_file, search, and list_files are always available. The mutating and shell tools are off unless you explicitly opt in, because an autonomous host model should not get write/exec access by accident:

When disabled, these tools are not registered at all — the host never sees them. (jambavan_sankshipta rewrites files in place, so it counts as a write tool.)

File, search, list, and bash working directories are confined to JAMBAVAN_ROOT (or the detected project root). Set JAMBAVAN_ALLOW_OUTSIDE_ROOT=1 only for trusted local use. Files that look like secrets (.env*, *.pem, *.key, id_rsa, .npmrc, …) are refused by all file tools unless JAMBAVAN_ALLOW_SECRETS=1.

bash runs with a minimal no-color environment (host secrets are not inherited unless JAMBAVAN_BASH_INHERIT_ENV=1) and catches a few obvious footguns (rm -rf /, rm -rf /*, home/project wipes, git reset --hard, git clean -fx, blind curl | sh, and similar). This is not a security boundary — it is trivially bypassed by encoding, aliases, scripts, shell expansion, or unlisted commands like find . -delete. Treat bash as a local shell: review tool calls before approving them, and run the server inside a sandboxed workspace (container / microVM) if you need real isolation.

Configuration

Benchmark

npm run bench dogfoods the real pipeline — no LLM calls, no external services, fully deterministic. It auto-derives queries from the repo's own most common symbols, so it's meaningful on any codebase. It measures five dimensions, not just token savings, and every number below is a fresh run against this repo (33 files, 151 symbols):

1. Index — build speed and throughput.

2. Context — not only tokens, but how much the agent has to open. Baseline = an agent reads the full contents of every file a query matches; jambavan ships ranked, budgeted snippets instead.

3. Graph — relationships extracted from the AST (a coverage metric, not tokens).

4. Sankshipta — prose compression holds steady around 24%.

5. Tool latency — all 24 tools the MCP server advertises, timed over the real stdio transport (the same request/response path a host model uses): min/median/max over 10 calls for read-only tools, single-shot for mutating ones. Representative medians:

Everything driven purely in-process is sub-millisecond; the outliers (index, search, bash) are the ones that shell out or touch disk, exactly as expected. Every call succeeds — the benchmark exits non-zero if any tool errors, so it doubles as an end-to-end smoke test.

The larger the codebase, the bigger the win. The same benchmark run against a mid-size Java service (166 files, ~1,000 symbols) — every dimension scales in Jambavan's favour:

Incremental re-index and per-query context stay roughly flat while a from-scratch read grows with the repo, so the token savings widen as the codebase grows. Baseline is a conservative comparison — per-query results vary, and occasionally a query whose matches sit in tiny files reads cheaper whole than as ranked snippets. Run it on yours:

JAMBAVAN_ROOT=/path/to/your/repo npm run bench

Checks

npm run lint
npm run build
npm run unit        # node:test unit suite (test/*.test.ts)
npm run self-check
npm run bench

See ARCHITECTURE.md for internals.