# ai.papyruslabs/seshat-mcp (npm · @papyruslabsai/seshat-mcp)

Structural code intelligence for AI agents: real call graphs, blast radius, and change history.

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

## Components

- npm · `@papyruslabsai/seshat-mcp`: 70/100 (this document), [markdown](https://verifymcp.io/servers/ai-papyruslabs-seshat-mcp/papyruslabsai-seshat-mcp.md), [page](https://verifymcp.io/servers/ai-papyruslabs-seshat-mcp/papyruslabsai-seshat-mcp)

## Channel facts

- Registry: `npm`
- Package: `@papyruslabsai/seshat-mcp`
- Version: `0.20.2`
- 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-10-07.

- **Supply Chain Security**: 98/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 31 of 92 dependencies flagged as unhealthy.
- **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 5 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 75/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4070 tokens (~150/item across 27 items; 27 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**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 27 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 28 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **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

### How do I install the ai.papyruslabs/seshat-mcp server?

ai.papyruslabs/seshat-mcp runs locally as an npm package, launched with npx -y @papyruslabsai/seshat-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add ai-papyruslabs-seshat-mcp -- npx -y @papyruslabsai/seshat-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "ai-papyruslabs-seshat-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@papyruslabsai/seshat-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "ai-papyruslabs-seshat-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@papyruslabsai/seshat-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add ai-papyruslabs-seshat-mcp -- npx -y @papyruslabsai/seshat-mcp
```

### opencode

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

### OpenClaw

```bash
openclaw mcp add ai-papyruslabs-seshat-mcp --command npx --arg -y --arg @papyruslabsai/seshat-mcp
```

### Hermes

```yaml
mcp_servers:
  ai-papyruslabs-seshat-mcp:
    command: "npx"
    args: ["-y", "@papyruslabsai/seshat-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "ai-papyruslabs-seshat-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@papyruslabsai/seshat-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add ai-papyruslabs-seshat-mcp -t stdio -c npx -a -y @papyruslabsai/seshat-mcp
```

### Other

```json
{
  "mcpServers": {
    "ai-papyruslabs-seshat-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@papyruslabsai/seshat-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-10-03 (score 70, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-10-02 (score 55)

First indexed and scored.

## MCP tools (27)

### `get_account_status` (~40 tokens)

Account Status

See your current plan, available tools, and credit balance. Call this if a tool returns a tier error or you want to know what tools are available.

### `list_projects` (~50 tokens)

List Projects

Start here. Returns all synced codebases with their size, language, and project name. You need the project name for every other tool. If this returns empty, use sync_project to import the current repo.

### `sync_project` (~161 tokens)

Sync Project

Import a public GitHub repo into Seshat for structural analysis. Call this when list_projects returns empty or when the user wants to analyze a new repo. Detects the git remote automatically if no URL is provided. Extraction typically takes 5-30 seconds. After syncing, call list_projects to confirm the project is available. Use force: true to re-extract even if a cached snapshot exists (useful after code changes or when Seshat extraction has been updated).

Input parameters:

- `force` (boolean): Force re-extraction even if a cached snapshot exists. Default: false.
- `repo_url` (string): Public GitHub repo URL (e.g., https://github.com/org/repo). If omitted, tries to detect from the current git remote.

### `query_entities` (~193 tokens)

Query Entities

Like grep but for code structure. Find functions, classes, and routes by name, architectural layer (route/service/component), or module. Returns matching symbols with their type, file, and layer — use this instead of grep when you need to find code by what it does, not by text content.

Input parameters:

- `language` (string): Filter by source language: javascript, typescript, python, go, rust, etc.
- `layer` (string): Filter by architectural layer: route, controller, service, repository, utility, hook, component, schema
- `limit` (number): Max results to return (default: 50)
- `module` (string): Filter by module (partial match)
- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.
- `query` (string): Search term — matches against symbol name, ID, source file, and module

### `get_entity` (~106 tokens)

Get Entity Details

Get everything about one function or class — its signature, callers, callees, data flow, constraints, source location, and database operations (which tables it reads/writes). Use this when you need to deeply understand a single symbol before modifying it. Returns more than reading the source file because it includes the dependency context.

Input parameters:

- `id` (string, required): Entity ID or name
- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `get_dependencies` (~132 tokens)

Get Dependencies

Trace who calls a function and what it calls, up to N levels deep. Use this instead of grep-for-function-name when you need the actual call chain — returns the dependency graph, not text matches. Covers callers (upstream), callees (downstream), or both.

Input parameters:

- `depth` (number): How many levels deep to traverse (default: 2)
- `direction` (string): Which direction to traverse (default: both)
- `entity_id` (string, required): Entity ID or name
- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `get_data_flow` (~86 tokens)

Get Data Flow

See what data a function reads, returns, and mutates (DB writes, state changes). Use this when debugging data bugs or when you need to verify whether a function has side effects before refactoring it.

Input parameters:

- `entity_id` (string, required): Entity ID or name
- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `find_by_constraint` (~220 tokens)

Find by Constraint

Find every function with a specific syntactic constraint tag — AUTH (requires authentication), DB_ACCESS (touches database), THROWS (explicit throw statement), PURE (no side effects), NETWORK_IO (makes HTTP calls), VALIDATED (has input validation). Also supports table-level queries: pass table="walks" to find every function that reads or writes the walks table (answers "what touches this table?" for schema migrations). Constraints are extracted from source syntax, not inferred. For semantic/behavioral properties (e.g., "can fail transitively"), use query_traits instead.

Input parameters:

- `constraint` (string, required): Constraint tag to search for: AUTH, VALIDATED, PURE, THROWS, DB_ACCESS, NETWORK_IO, IMP, etc.
- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.
- `table` (string): Optional: filter to functions that touch a specific database table (e.g., "walks", "users"). Returns structured db_operations showing read/write/mutate per function.

### `get_blast_radius` (~126 tokens)

Get Blast Radius

Before modifying a function, call this to see everything that could break. Returns all transitively affected symbols — both upstream callers and downstream callees — with distance from the change point. Like git log --follow but for runtime impact. Designed for repeated use: as you discover new symbols with other tools, call this again on them to expand your understanding of the affected surface.

Input parameters:

- `entity_ids` (array, required): Array of entity IDs or names to compute blast radius for
- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `get_lineage` (~147 tokens)

Get Lineage

The change history of one symbol, typed by what kind of change each commit made (body, calls, data, signature, constraints…), with CI verdicts, reverts, rename tracking, co-change partners, and rejected PRs that touched it. Call before modifying anything load-bearing: it answers "how does this entity usually change, and what happened last time someone tried?" — which no text diff can. Complements get_blast_radius (current impact) with history (past behavior).

Input parameters:

- `entity_id` (string, required): Entity ID or name to fetch change history for
- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `get_hotspots` (~138 tokens)

Get Hotspots

Project-level change-history orientation: the most-changed entities (and what kind of change dominates each), low-survival thrash spots where changes don't stick, heavily-depended-on entities that haven't changed all window (interface freeze), and directories with no recent changes. Call it after list_modules when orienting in a codebase — it answers "where does development actually happen, and where does it fail?" from commit history rather than current structure. Complements get_lineage (one entity's story) with the project-wide map.

Input parameters:

- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `get_co_change_clusters` (~129 tokens)

Get Co-Change Clusters

The codebase's hidden modules: groups of symbols that historically change together (≥3 shared commits, sweep commits excluded), computed from real commit history. Clusters that span multiple directories reveal coupling the file tree doesn't show. Call it when planning a change or splitting work across agents — touching one member of a cluster usually means touching the rest, even when no static dependency connects them. Correlation evidence, honestly framed; complements get_blast_radius (static reach) with empirical reach.

Input parameters:

- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `list_modules` (~96 tokens)

List Modules

Get a bird's-eye view of how the codebase is organized. Groups all symbols by architectural layer (route/service/component), module, file, or language with counts. Use this to orient yourself in an unfamiliar codebase before diving into specifics.

Input parameters:

- `group_by` (string): How to group entities (default: layer)
- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `get_topology` (~82 tokens)

Get Topology

Get the full API surface map in one call — all routes, middleware, auth patterns, and database tables. Use this when you need to understand the overall architecture without reading every file. Returns the information you'd normally piece together from dozens of file reads.

Input parameters:

- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `get_optimal_context` (~169 tokens)

Get Optimal Context

Before working on a function, call this to get the most relevant related code ranked by importance and fitted to a token budget. Returns a prioritized reading list of symbols you should understand — better than guessing which files to open. Designed for iterative use: call it on your target, read the top results, then call it again on any surprising dependencies to build a complete picture.

Input parameters:

- `max_tokens` (number): Token budget for the context window (default: 8000)
- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.
- `strategy` (string): Traversal strategy: bfs (faster, local neighborhood) or blast_radius (full affected set)
- `target_entity` (string, required): Entity ID or name to build context around

### `find_entry_points` (~117 tokens)

Find Entry Points

List the ways into the system: route/controller handlers, test entries, framework plugin registrations, and exported symbols (the public API surface), classified by kind and ranked by reach. Call it first when orienting in an unfamiliar codebase — it answers "where does execution start, and what is the public surface?" Complements list_modules (structure) and find_dead_code (its exact inverse: these are the reachability roots).

Input parameters:

- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `trace_data_path` (~181 tokens)

Trace Data Path

Follow data from one function through the call graph to its sinks. From a start entity it walks callees, records the data each hop consumes/produces/mutates, and reports the chain from the start to every sink the data reaches — database writes, network egress, filesystem writes — plus the tables touched. Call it before changing a function that handles real data: it answers "where does this data end up?", the cross-call composition get_data_flow (one entity) cannot give. Flags untrusted inputs at the source.

Input parameters:

- `entity_id` (string, required): Entity ID or name to trace data flow from
- `max_depth` (number): How many call hops to follow downstream (default: 5, max: 8)
- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `find_dead_code` (~94 tokens)

Find Dead Code

Find functions that nothing calls. Walks the call graph from all entry points (routes, exports, tests) and flags symbols that are unreachable. Use this during cleanup or before a release to find safe deletion candidates.

Input parameters:

- `include_tests` (boolean): Include test entities in dead code results (default: false)
- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `find_layer_violations` (~68 tokens)

Find Layer Violations

Find places where the architecture is broken — a database repository calling a route handler, a utility importing a component. Returns every backward or skip-layer dependency that violates clean architecture.

Input parameters:

- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `get_coupling_metrics` (~124 tokens)

Get Coupling Metrics

Measure how tangled your code is. Returns coupling (cross-boundary dependencies), cohesion (within-group dependencies), and instability scores. High coupling + low cohesion = refactoring candidates. Start with group_by: "layer" for the architectural health view ("are my controllers more coupled than my services?"), then drill into group_by: "module" for specific hotspots.

Input parameters:

- `group_by` (string): Group entities by module or layer (default: module)
- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `get_auth_matrix` (~152 tokens)

Get Auth Matrix

Audit authentication coverage. Shows which API routes and controllers require auth and which don't, plus inconsistencies like database access without auth checks. For large codebases, use the module parameter to drill into a specific module/directory. Most useful for backend codebases with middleware-based auth. Frontend frameworks (React, Vue) handle auth via component wrappers, which this tool won't detect as AUTH constraints.

Input parameters:

- `layer` (string): Filter to a specific layer: "route" or "controller" (optional).
- `module` (string): Filter to routes/controllers in a specific module or directory path (optional).
- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `find_error_gaps` (~77 tokens)

Find Error Gaps

Find crash risks: functions that throw or have network/DB side effects whose callers don't catch errors. Returns the specific caller→callee pairs where exceptions can propagate unhandled. Use this before shipping to find missing error handling.

Input parameters:

- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `get_test_coverage` (~99 tokens)

Get Test Coverage

See which production functions are actually exercised by tests via the call graph — semantic coverage, not line coverage. Optionally ranks uncovered functions by blast radius so you know which missing tests are riskiest.

Input parameters:

- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.
- `weight_by_blast_radius` (boolean): Rank uncovered entities by blast radius to prioritize testing (default: false, slower)

### `find_ownership_violations` (~95 tokens)

Find Ownership Violations

Find memory and lifecycle issues — entities with complex ownership, unsafe blocks, escaping references, or illegal mutability on borrowed data. Returns 0 for most JS/Python codebases — a non-zero result in those languages indicates a serious boundary violation worth investigating. Most detailed results for Rust and C++.

Input parameters:

- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `query_traits` (~144 tokens)

Query Traits

Find functions by inferred behavioral trait — "fallible" (can fail, including transitively via callees that throw), "asyncContext" (carries async state), "generator" (yields values). Traits are semantic properties inferred from the call graph, not just syntax. Use this when you need to find all code with a specific capability. For syntactic tags (explicit throw statements, DB access), use find_by_constraint instead.

Input parameters:

- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.
- `trait` (string, required): The trait or capability to search for (e.g., "fallible", "asyncContext")

### `find_exposure_leaks` (~65 tokens)

Find Exposure Leaks

Find places where public/API code directly accesses private internals, bypassing the intended abstraction boundary. Use this during API design reviews or before extracting a module.

Input parameters:

- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

### `find_semantic_clones` (~94 tokens)

Find Semantic Clones

Find duplicated logic across the codebase. Normalizes variable names and compares code structure to catch identical algorithms in different files — even across different languages. Use this before a DRY refactor.

Input parameters:

- `min_complexity` (number): Minimum logic expressions to count as a match (default: 5)
- `project` (string): Project name (required in multi-project mode). Use list_projects to see available projects.

## Diagnostics

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

## Score history

- 2026-10-07: 70
- 2026-10-05: 70
- 2026-10-04: 70
- 2026-10-03: 70
- 2026-10-02: 55

## Common questions

### What is the ai.papyruslabs/seshat-mcp server?

ai.papyruslabs/seshat-mcp is listed in the public MCP registry as ai.papyruslabs/seshat-mcp. Structural code intelligence for AI agents: real call graphs, blast radius, and change history. This page covers its npm package (@papyruslabsai/seshat-mcp).

### Is the ai.papyruslabs/seshat-mcp server safe to use?

ai.papyruslabs/seshat-mcp scores 70 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 7 October 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the ai.papyruslabs/seshat-mcp server expose?

ai.papyruslabs/seshat-mcp exposes 27 tools: get_account_status, list_projects, sync_project, query_entities, get_entity, and 22 more. Their descriptions and schemas cost roughly 3,185 tokens of context every time the server is loaded.

### Is the ai.papyruslabs/seshat-mcp server still maintained?

ai.papyruslabs/seshat-mcp is still listed as active in the MCP registry. We last reached this channel on 7 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the ai.papyruslabs/seshat-mcp server under?

ai.papyruslabs/seshat-mcp declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/@papyruslabsai/seshat-mcp
- Socket report: https://socket.dev/npm/package/@papyruslabsai/seshat-mcp
- Repository: https://github.com/papyruslabs-ai/seshat-mcp
- Website: https://seshat.papyruslabs.ai/
- Changelog RSS feed: https://verifymcp.io/servers/ai-papyruslabs-seshat-mcp/papyruslabsai-seshat-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/ai-papyruslabs-seshat-mcp/papyruslabsai-seshat-mcp.json
- HTML version of this page: https://verifymcp.io/servers/ai-papyruslabs-seshat-mcp/papyruslabsai-seshat-mcp