# io.github.Siddhukaushik/slimdex-mcp (npm · slimdex-mcp)

Narrow code retrieval for agents: outlines, symbol context, dep graph, persistent memory.

- Trust score: 62/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-07

## Components

- npm · `slimdex-mcp`: 62/100 (this document), [markdown](https://verifymcp.io/servers/siddhukaushik-slimdex-mcp/slimdex-mcp.md), [page](https://verifymcp.io/servers/siddhukaushik-slimdex-mcp/slimdex-mcp)

## Channel facts

- Registry: `npm`
- Package: `slimdex-mcp`
- Version: `1.0.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-07.

- **Supply Chain Security**: 87/100
  - No malware found by supply-chain analysis.
  - Known CVEs were checked across the 95 of 99 dependencies we could resolve, so this covers what we could see, not the whole tree.
  - No install/post-install scripts declared.
  - Dependency health was assessed across the 95 of 99 dependencies we could resolve, so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 3 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 65/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 3954 tokens (~131/item across 30 items; 30 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 86/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 59% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### Claude

```bash
claude mcp add siddhukaushik-slimdex-mcp -- npx -y slimdex-mcp
```

### Codex

```bash
codex mcp add siddhukaushik-slimdex-mcp -- npx -y slimdex-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "siddhukaushik-slimdex-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "slimdex-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add siddhukaushik-slimdex-mcp --command npx --arg -y --arg slimdex-mcp
```

### Hermes

```yaml
mcp_servers:
  siddhukaushik-slimdex-mcp:
    command: "npx"
    args: ["-y", "slimdex-mcp"]
```

### Other

```json
{
  "mcpServers": {
    "siddhukaushik-slimdex-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "slimdex-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-04 (score 62)

First indexed and scored.

## MCP tools (30)

### `index_repo` (~89 tokens)

Index / refresh the repository

Build or refresh the persistent code index (symbols + imports). Only files whose mtime changed are re-parsed, so re-run it liberally, like `git fetch`, before trusting a search. Honors <root>/.slimdex.json (ignoreDirs/extensions/exclude/maxFileBytes) and reports config problems instead of ignoring them.

Input parameters:

- `force` (boolean): Ignore cache and reparse everything.

### `snapshot` (~66 tokens)

Snapshot uncommitted work

Copy every uncommitted file into .slimdex/snapshots/<timestamp>/ as insurance against accidental resets. Also runs automatically (at most hourly) when index_repo sees a dirty tree; newest 10 kept. Defeats a stray `git checkout .`; does NOT replace committing.

### `outline_file` (~34 tokens)

Outline a file (signatures only)

Compact outline of one file — declarations with line numbers, not the body. Orient before reading.

Input parameters:

- `path` (string, required)

### `read_lines` (~55 tokens)

Read a line range

Read only lines [start..end] (1-indexed, inclusive) of a file. Cheaper than the whole file.

Input parameters:

- `end` (integer, required)
- `path` (string, required)
- `start` (integer, required)

### `search_code` (~182 tokens)

Compact code search

Search indexed files; return path:line:col + the matching line (+ optional caret highlight). Every occurrence on a line counts, and the reported total is exact unless the scan cap trips (then it says so). Page with limit and either offset or the opaque cursor from a previous call. Vendor/build dirs are already excluded. Use pathPrefix to scope; for symbols prefer find_definition/find_references.

Input parameters:

- `cursor` (string): Opaque token from a previous call's 'next cursor' to fetch the next page.
- `highlight` (boolean)
- `ignoreCase` (boolean)
- `limit` (integer): Max matches to return (default 20).
- `offset` (integer): Skip this many matches. Ignored if cursor is given.
- `pathPrefix` (string)
- `pattern` (string, required)
- `regex` (boolean)

### `find_definition` (~112 tokens)

Find where a symbol is defined

Look up a symbol name in the index; return definition site(s) as path:line:col + kind. Heuristic. Paged: the total is always exact, `limit`/`offset` control how many are printed, `pathPrefix` scopes them.

Input parameters:

- `kind` (string)
- `limit` (integer): Max sites to print (default 50).
- `name` (string, required)
- `offset` (integer)
- `pathPrefix` (string): Only definitions under this path.

### `search_symbols` (~116 tokens)

Fuzzy symbol name search

Find indexed symbols whose name matches a query, ranked exact > prefix > substring > subsequence. Use this when you half-remember a name ("something like handleAuth") — it reads only the index, never the files, so it is far cheaper and far less noisy than search_code for finding a declaration.

Input parameters:

- `kind` (string): Filter by kind: function, class, method, interface, type, …
- `limit` (integer): Default 25.
- `pathPrefix` (string)
- `query` (string, required)

### `find_references` (~90 tokens)

Find references to a symbol (textual)

Whole-word textual search for a symbol, returned as path:line:col with the enclosing function/class. Counts every occurrence, including repeats on one line. Not scope-aware, so may include unrelated same-named identifiers. Supports pathPrefix, limit and offset.

Input parameters:

- `limit` (integer)
- `name` (string, required)
- `offset` (integer)
- `pathPrefix` (string)

### `find_tests` (~115 tokens)

Which tests exercise a symbol

Which references to a symbol live in TEST files: 'if I change calculateTax, which tests catch a break' — run exactly those, not the whole suite. Nothing covering it is surfaced as risk BEFORE you edit. Detected by path convention (*.test.*, *.spec.*, __tests__/, test_*.py …) or an indexed describe/it title. Textual, so same caveat as find_references.

Input parameters:

- `limit` (integer)
- `name` (string, required)
- `pathPrefix` (string)

### `search_intent` (~119 tokens)

Find code by intent (BM25, no embeddings)

Know WHAT the code does but not its name: a words query ranked over every indexed symbol by BM25 on tokenized names (camelCase/snake_case), kinds and filenames — 'validate user email' surfaces validateEmail / emailValidator. Matches WORDING, not meaning. Exact/partial name → search_symbols; literal string → search_code.

Input parameters:

- `limit` (integer): Top matches to return (default 10).
- `query` (string, required): What the code does, in words — 'parse the config file', 'retry a failed request'.

### `context_pack` (~182 tokens)

One-call task context bundle

Understand a whole topic in ONE call instead of ~10: give a natural-language query ('how does auth work') and slimdex runs the exploration itself — BM25-ranks the symbols, shows how their files connect (import graph, one hop), includes the top few bodies, all under a char budget. Saves the round-trips AND keeps ten separate results out of the transcript. Orient with this; drop to get_symbol_context / read_lines for exact source.

Input parameters:

- `bodies` (integer): How many top symbols to include full bodies for (default 3).
- `budget` (integer): Soft char cap on the whole pack (default 6000).
- `query` (string, required): The topic to understand, in words — 'how does login work', 'the indexing pipeline'.
- `symbols` (integer): How many ranked symbols to list (default 8).

### `get_symbol_context` (~234 tokens)

Surgical symbol snippet(s)

Return ONLY the body of a symbol (function/class/method) plus a few context lines — not the whole file. Give a name (resolved via the index), several `names` at once, or an explicit path+line. This is the biggest per-lookup token saver. When a skeleton showed you WHERE the functions are, pull their bodies with names:[...] here — do NOT fall back to reading the whole file for a handful of bodies.

Input parameters:

- `after` (integer)
- `before` (integer)
- `line` (integer): Definition line (use with path).
- `maxLines` (integer): Cap each returned span (default 200); tail elided with a notice.
- `name` (string): Symbol name to resolve via the index.
- `names` (array): Several symbol names in one call — one bounded body each. The narrow alternative to a whole-file read.
- `path` (string): File path (use with line instead of name).
- `pathPrefix` (string): Restrict name resolution to files under this prefix — disambiguates a duplicated name in ONE call.

### `replace_symbol` (~487 tokens)

Replace a symbol's body by name (write)

Write a symbol by NAME — you never re-send the old body to locate the edit. Two modes: REPLACE (name/path+line plus body) overwrites an existing definition; INSERT (after:"X" or before:"X" plus body) adds a NEW symbol next to an existing one, which is what you want for 'add a method beside the related ones' — the anchor's own span comes from the index, so `after` means after its closing brace, not its signature line. Insert puts `body` in verbatim: indent it for the file, and include a leading/trailing newline if you want a blank line. range comes from the index; the file is SNAPSHOTTED first (.slimdex/snapshots), re-indexed after, and the new line span is reported so you don't re-read to verify. Safe to mix with ordinary edit tools: if the file moved under the index, a NAME is re-resolved against a fresh parse automatically (an explicit path+line still refuses, since that coordinate is yours). Ambiguous/unknown names are refused, never guessed. `body` = the complete replacement definition, indented for the file. `edits:[…]` applies several at once (one snapshot, one re-index); the batch is refused before any write if a target is ambiguous, two edits overlap, or a file isn't writable, and a write that fails mid-batch rolls the earlier files back and says so.

Input parameters:

- `after` (string): INSERT mode: add `body` as a NEW symbol immediately after this existing symbol's closing brace. Pin which occurrence with path + line when the name repeats inside one file (normal for CSS).
- `before` (string): INSERT mode: add `body` as a NEW symbol immediately before this existing symbol.
- `body` (string): The complete new definition, replacing the old one verbatim.
- `edits` (array): Several replacements, applied atomically. Each entry takes name, or path+line, plus body.
- `line` (integer): Definition line (use with path).
- `name` (string): Symbol to replace, resolved via the index.
- `path` (string): File path (use with line instead of name).
- `pathPrefix` (string): Disambiguate the after/before anchor when the name exists in several files.

### `get_file_skeleton` (~73 tokens)

File skeleton (bodies elided)

Structural skeleton of a file: every declaration's signature with its indentation preserved and bodies replaced by ' … {line}'. Turns a 2,000-line file into a readable map for a fraction of the tokens. Use this before any full read of a file over ~300 lines.

Input parameters:

- `path` (string, required)

### `get_context` (~145 tokens)

One-shot context brief for a symbol

ONE call for what would take several: definition, signature, callers/references (attributed to their enclosing symbol — heuristic), imports, dependents. Sections are OPT-IN via `include` (default definition,signature,callers,imports); add 'body' for full source, 'dependents' for reverse deps. Bounded by callerLimit and maxChars with explicit truncation.

Input parameters:

- `callerLimit` (integer): Max callers to list (default 12).
- `include` (array): Which sections to return. Omit for the default set.
- `maxChars` (integer): Hard cap on response size (default 12000).
- `name` (string, required)

### `repo_map` (~115 tokens)

High-level repo map

Birds-eye overview: top directories with file counts, total lines, and symbol counts. Pass `path` to drill into one directory and list its largest files (with `top` to cap the list) — the bridge between orienting at the directory level and picking a file to skeleton. Start every session here.

Input parameters:

- `depth` (integer)
- `path` (string): Drill into this directory and list files instead of directories.
- `top` (integer): With `path`: how many files to list (default 20).

### `changed_files` (~116 tokens)

What changed, and which symbols it touched

Summarize the working-tree diff (or a diff against `base`) as changed files with +added/-deleted counts AND the enclosing functions/classes each hunk lands in — the blast radius, without pulling the patch into context. The cheap way to start a session on a dirty repo. Requires a git checkout.

Input parameters:

- `base` (string): Ref to diff against (e.g. 'main', 'HEAD~3'). Omit for working tree vs HEAD.
- `limit` (integer): Max files to list (default 30).

### `dep_graph` (~137 tokens)

Dependency graph query

Query the internal import graph. mode=imports: what a file imports. mode=dependents: what imports it. mode=mermaid: a diagram — pass root (+depth, default 2) to walk outward from one file instead of dumping the whole graph, or scope to a path prefix. Run before refactoring a shared module.

Input parameters:

- `depth` (integer): mermaid: import hops to follow from root (default 2).
- `mode` (string, required)
- `root` (string): mermaid: start file to walk out from (BFS).
- `scope` (string)
- `target` (string)

### `stats` (~194 tokens)

Tool usage and response-size accounting

Per-tool call counts and response sizes recorded to <root>/.slimdex/stats.json. Reported in characters, not tokens — char/4 estimates are unreliable across tokenizers, so this measures what it can measure honestly. Use it to see which tool is actually producing your context, and to tune limits. Counters are CUMULATIVE across every session on this repo until reset. To measure ONE task: call checkpoint:true when you start, then session:true when you finish — the server is long-lived, so session:true alone means 'since the server booted', which can span several chats.

Input parameters:

- `checkpoint` (boolean): Zero the session tally only (all-time history untouched). Call at the start of a task.
- `reset` (boolean): Clear ALL counters, including the repo's all-time history.
- `session` (boolean): Report what this process recorded since it started, or since the last checkpoint.

### `memory_save` (~48 tokens)

Persist a memory fact

Save a durable note (decision, gotcha, TODO, location) to <root>/.slimdex/memory.json.

Input parameters:

- `tags` (array)
- `text` (string, required)

### `memory_search` (~56 tokens)

Search saved memory

Find saved memory facts by substring and/or tag. Previews by default; memory_get expands one by id.

Input parameters:

- `full` (boolean): Whole bodies instead of previews.
- `query` (string)
- `tag` (string)

### `recap` (~95 tokens)

What previous sessions did (automatic)

Prior activity from the server's own tool-call journal — most-examined files, most-looked-up symbols, recent searches. Needs NO prior memory_save; works even when the last session saved nothing. recap = where sessions looked, memory = what they concluded. Normally use brief (folds both in); reach here for the raw journal.

Input parameters:

- `limit` (integer): How many recent journaled calls to summarize (default 200).

### `brief` (~110 tokens)

One-shot session onboarding brief

CALL THIS FIRST in a fresh chat — including on a repo slimdex has never seen, where it builds the index itself rather than sending you to index_repo. One synthesized opener instead of stitching memory_list + recap yourself: what the repo is, where recent sessions were digging (automatic journal), and each saved conclusion CHECKED against the current index so stale ones are flagged (✓ live, ⚠ may be stale).

Input parameters:

- `limit` (integer): Journaled calls to summarize for the focus section (default 200).

### `install_hook` (~198 tokens)

Install the PreToolUse hook

Wire slimdex's write discipline into the CLIENT, which registering the MCP server cannot do — the protocol has no mechanism for a server to add a hook, so this is the one call that closes the gap. Writes a PreToolUse hook that speaks up ONLY when an edit re-sends 25+ lines that an indexed symbol actually covers, or a whole file over 12KB is read. Merges rather than clobbers, is idempotent, and prints exactly what changed. scope: claude-global (default, all your repos) | claude-local | claude-project | copilot-global (VS Code, all your repos) | copilot-project (.github/hooks, COMMITTED). Use uninstall:true to remove it.

Input parameters:

- `scope` (string): Which config to write. Default claude-global; use copilot-global for a VS Code-only setup.
- `uninstall` (boolean): Remove the hook instead of adding it.

### `digest_save` (~122 tokens)

Save the repo architecture digest

Store a compact 'how this repo works' cheat-sheet — modules, flows, entry points, conventions — so future sessions read a page instead of re-exploring. `covers` (the paths it summarizes) lets later sessions be told when a covered file changed. Overwrites the previous one. Save the why and the shape, not a symbol list.

Input parameters:

- `covers` (array): Repo-relative paths/dirs this digest summarizes (omit = whole repo).
- `text` (string, required): The digest prose — compact, the architecture and flows, not a file dump.

### `digest_get` (~66 tokens)

Read the repo architecture digest

Return the stored architecture cheat-sheet plus a freshness verdict: covered files that changed since it was written are flagged as reasons it may be out of date. Read it early to understand the system without re-exploring; if flagged stale, re-read the changed areas and digest_save an update.

### `memory_list` (~89 tokens)

List memory

Saved facts newest-first as PREVIEWS (id, date, tags, opening clause); memory_get ids:[…] expands the ones that matter, full:true dumps everything. Prefer brief as the opener — same previews, staleness-checked.

Input parameters:

- `full` (boolean): Whole bodies instead of previews — costly on a large store.
- `limit` (integer): Max facts (default 50).

### `memory_get` (~70 tokens)

Read saved facts in full

Full text of specific facts by id, with the provenance note of what was being examined when each was saved. The expansion half of the preview model: triage cheaply with brief/memory_list, expand only what you need.

Input parameters:

- `ids` (array, required): Fact ids from memory_list/brief/memory_search.

### `memory_delete` (~24 tokens)

Delete a memory fact

Remove one saved memory fact by its id.

Input parameters:

- `id` (string, required)

### `batch` (~60 tokens)

Run several tool calls at once

Execute multiple slimdex calls in one request to avoid per-call protocol overhead. Pass calls: [{ "tool": "find_definition", "args": { "name": "login" } }, ...]. Cannot nest batch inside itself.

Input parameters:

- `calls` (array, required)

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/siddhukaushik-slimdex-mcp/slimdex-mcp#diagnostics

## Score history

- 2026-08-07: 62
- 2026-08-06: 62
- 2026-08-05: 62
- 2026-08-04: 62

## Links

- npm package: https://www.npmjs.com/package/slimdex-mcp
- Socket report: https://socket.dev/npm/package/slimdex-mcp
- Repository: https://github.com/Siddhukaushik/slimdex-mcp
- Changelog RSS feed: https://verifymcp.io/servers/siddhukaushik-slimdex-mcp/slimdex-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/siddhukaushik-slimdex-mcp/slimdex-mcp.json
- HTML version of this page: https://verifymcp.io/servers/siddhukaushik-slimdex-mcp/slimdex-mcp