Pack local or remote codebases into AI-friendly files that LLMs and coding agents can read or search
Nothing to run from here
Seshat is installed from its publisher's own source and answers where it runs, so this marketplace is not in the path of a single call. There is no address here to send one to, and a panel that pretended otherwise would be showing you an answer we made up. Install it and call it from your own client — the Installation tab has the entry for each one.
96/100
trust score
4
downloads a day
local
runs on your machine
350
downloads in 30d
What it does
Structural code intelligence for AI agents: real call graphs, blast radius, and change history.
Quickstart
# 1 — add it to Claude Code
claude mcp add --scope user --env 'SESHAT_API_KEY=${SESHAT_API_KEY}' --transport stdio seshat-mcp '--' npx -y @papyruslabsai/seshat-mcp
# 2 — ask your agent for something these tools do
# get_account_status, list_projects, sync_project and 32 more
It needs SESHAT_API_KEY: this reads it from your environment, so export it first.
Seshat costs nothing on mcprush: there is no plan to choose here, no cap to set and nothing mcprush can bill you for.
PublisherVerified · since 2026
Installation
Where are you running it?
Every route below installs the same thing and ends at the same approval screen. This one runs on your machine: your client starts Seshat as a process under your own user, with your files and your network, so the tool surface below is what it can do to your computer rather than to a server somewhere else. Its scan result is on the Security tab — read the surface before you approve it.
Claude Codedeclared by this listing
This is a public server: you run it yourself and this marketplace is not in the path. You need Node.js — the current LTS (24) is the safe choice; npx comes with it. Claude Code registers it in one command; --scope user makes it available in every project. Claude Code reads SESHAT_API_KEY (Your Seshat API key. Get one free at https://seshat.papyruslabs.ai) from your environment each time it starts the server, so the value stays out of its config: export it in your shell profile (macOS, Linux), or run setx SESHAT_API_KEY … and open a new terminal (Windows). The '--' is in quotes so that PowerShell passes it on.
claude mcp add --scope user --env 'SESHAT_API_KEY=${SESHAT_API_KEY}' --transport stdio seshat-mcp '--' npx -y @papyruslabsai/seshat-mcpReconnect, or start a new session, and the tools appear in the model’s tool list.
Free on mcprush, and it runs from its publisher’s own package: this marketplace is not in the path, so there is no key of ours to hold and no card to add.
What it asks of you
It reaches a system of yours, so it needs your own credential rather than the publisher’s: SESHAT_API_KEY — Your Seshat API key. Get one free at https://seshat.papyruslabs.ai. You set it in your own client’s config, on your machine — this marketplace never holds it.
What it writes
One config entry your client uses to start the process locally. A local server runs with your file system and your network, which is why it is priced without metering.
What you approve
35 tools, with what each one reads, writes and reaches shown before you agree — the same list on every route above. Read the tool surface.
Tool surface
What the model actually sees. Descriptions are diffed on every release — see version history.
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.
No parameter schema on file.
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.
No parameter schema on file.
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…
| Parameter | Type | Required | Notes |
|---|---|---|---|
| repo_url | string | no | Public GitHub repo URL (e.g., https://github.com/org/repo). If omitted, tries to detect from the current git remote. |
| force | boolean | no | Force re-extraction even if a cached snapshot exists. Default: false. |
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.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| query | string | no | Search term — matches against symbol name, ID, source file, and module |
| layer | string | no | Filter by architectural layer: route, controller, service, repository, utility, hook, component, schema |
| module | string | no | Filter by module (partial match) |
| language | string | no | Filter by source language: javascript, typescript, python, go, rust, etc. |
| limit | number | no | Max results to return (default: 50) |
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…
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| id | string | yes | Entity ID or name |
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.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| entity_id | string | yes | Entity ID or name |
| direction | string | no | Which direction to traverse (default: both) |
| depth | number | no | How many levels deep to traverse (default: 2) |
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.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| entity_id | string | yes | Entity ID or name |
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…
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| constraint | string | yes | Constraint tag to search for: AUTH, VALIDATED, PURE, THROWS, DB_ACCESS, NETWORK_IO, IMP, etc. |
| table | string | no | Optional: filter to functions that touch a specific database table (e.g., "walks", "users"). Returns structured db_operations showing read/write/mutate per function. |
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…
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| entity_ids | array | yes | Array of entity IDs or names to compute blast radius for |
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…
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| entity_id | string | yes | Entity ID or name to fetch change history for |
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…
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — |
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…
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — |
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.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| group_by | string | no | How to group entities (default: layer) |
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.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — |
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…
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| target_entity | string | yes | Entity ID or name to build context around |
| max_tokens | number | no | Token budget for the context window (default: 8000) |
| strategy | string | no | Traversal strategy: bfs (faster, local neighborhood) or blast_radius (full affected set) |
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…
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — |
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…
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| entity_id | string | yes | Entity ID or name to trace data flow from |
| max_depth | number | no | How many call hops to follow downstream (default: 5, max: 8) |
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.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| include_tests | boolean | no | Include test entities in dead code results (default: false) |
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.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — |
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…
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| group_by | string | no | Group entities by module or layer (default: module) |
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…
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| module | string | no | Filter to routes/controllers in a specific module or directory path (optional). |
| layer | string | no | Filter to a specific layer: "route" or "controller" (optional). |
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.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — |
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.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| weight_by_blast_radius | boolean | no | Rank uncovered entities by blast radius to prioritize testing (default: false, slower) |
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…
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — |
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…
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| trait | string | yes | The trait or capability to search for (e.g., "fallible", "asyncContext") |
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.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — |
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.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| min_complexity | number | no | Minimum logic expressions to count as a match (default: 5) |
Before starting a code change, estimate how many tokens it will consume. Computes the blast radius, sums source tokens across all affected symbols, and projects total burn including iteration cycles. Use this to check if a task fits your context budget before committing to it.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| target_entities | array | yes | Entity IDs or names that will be modified |
| context_budget | number | no | LLM context window token budget (default: 200000) |
Simulate a hypothetical code change without writing anything. Five mutation dimensions: constraints/traits (behavioral tags — who upstream breaks), edges (add/remove calls — orphaned callees, inherited error handling and data contracts), data (add/remove table access — which co-tenants of the…
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| entity_id | string | yes | The target entity to analyze. |
| mutation | object | yes | The hypothetical change to apply. |
Register a planned new symbol in the graph before it exists on disk. This lets simulate_mutation and conflict_matrix reason about code you haven't written yet. Nothing is written to disk.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| id | string | yes | The unique ID or name for the new symbol. |
| source_file | string | yes | The relative path to the file where this symbol will be created. |
| layer | string | no | The architectural layer (e.g., "service", "route", "component"). |
| description | string | no | Brief description of the symbol's purpose. |
Compare a worktree against the loaded project to see what changed structurally — not a line diff, but which symbols were added, removed, or had their signatures/dependencies changed. Use this after making changes to verify the structural impact.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| worktree_path | string | yes | Absolute path to the worktree or branch checkout to compare |
| include_unchanged | boolean | no | Include unchanged entities in the output (default: false) |
Given multiple planned tasks, check which ones can run in parallel safely. Classifies every task pair: Tier 1 (different files, safe), Tier 2 (same file different symbols, careful), Tier 3 (same symbol, must sequence). Returns a matrix and suggested execution order.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| tasks | array | yes | Array of tasks to check for conflicts. |
Identify the boundary surface of one or two codebases — entities that face outward (expose an API, accept network input, make network calls). When given two projects, surfaces both boundary sets so you can trace the handshake between a backend and frontend, detect orphaned routes with no consumer,…
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project_a | string | yes | First project name (e.g., the backend). Required. |
| project_b | string | no | Second project name (e.g., the frontend). Optional — if omitted, shows only project_a's boundary surface. |
Find every function that reads from or writes to a specific database table, state object, or data source. Use this when you need to understand all the code paths that touch a particular data store.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| project | no | — | |
| target_name | string | yes | The name of the database table, state object, or data source (e.g., "users", "auth_token"). |
No parameter schema on file.
Free
$0 forever
- Every tool, no call limit
- No card, and mcprush charges nothing for it
- Source published under MIT
- Runs on your machine — nothing of it reaches our gateway
- Nothing to cap, because mcprush bills nothing
What counts against your monthly calls
| Tool | Unit | Calls used | Out of the allowance |
|---|
Nothing here is billable: mcprush charges nothing to install Seshat or to call it, at any volume.
Call allowance · this installenforced at the gateway
Monthly allowance, in calls
—
—
Alert at 80% · then the tool returns a normal MCP error
Used this month: —
ATrust score 96 / 100
Release 0.21.0 · scanned 15 Oct 2026
Two independent axes, because powerful and malicious are different questions. The grade is threat only. The capability level is blast radius, and it is never a penalty on the grade — it is priced as one subtract-only term in the score, where you can see it.
Threat score100
Client score96
Findings1 threat · 2 capability
Capabilitymoderate
Coveragesource
Verificationrepo
Surface digest73d930d53510196c5160464eafb50bc337ffee0eaee927151a66e17b09b434aa
Score vectorthreat 100 → client 96
| Term | Level | What it prices | Points |
|---|---|---|---|
| capability-exposure | moderate | capability blast radius (moderate) — client exposure if the model is manipulated | −3 |
| verification-discount | repo | publisher verification (public source) — no provenance, but the source is public and inspectable | −1 |
| coverage-honesty | source | inspection depth (source) — how much of the target the scan could see | −0 |
score = clamp(round(threatScore − E_cap − E_ver − E_cov), 0, 100). No model, no opinion, no network call at scoring time: the same methodology version against the same bytes always produces this number, and every line above is a field of the report rather than a summary of it.
What the scan could actually read
A grade is only as meaningful as its coverage, so the scanner publishes its own depth before it publishes its result.
Tool surfaceread
Implementation sourceread
Package metadataread
Live transportnot available
Tools were statically extracted from the published source (35 recovered), not enumerated from a running server. Tool-poisoning, Unicode-smuggling, capability and toxic-flow analysis ran on this inferred surface, but a mis-parsed registration could be missed or mis-attributed, so tool-derived findings are capped below “confirmed”. To grade the real runtime surface, scan the running server: --command "npx -y <package>".
Capability — what it could do if the model were manipulated
Tags derived from each tool’s schema and the implementation, not from what the tool calls itself. moderate is the level these add up to.
| Tool | Capability tags | Why the tag was assigned |
|---|---|---|
| get_account_status | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| list_projects | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| sync_project | external-sink | external-sink: declares readOnlyHint: false, openWorldHint: true |
| query_entities | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| get_entity | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| get_dependencies | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| get_data_flow | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| find_by_constraint | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| get_blast_radius | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| get_lineage | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| get_hotspots | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| get_co_change_clusters | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| list_modules | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| get_topology | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| get_optimal_context | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| find_entry_points | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| trace_data_path | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| find_dead_code | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| find_layer_violations | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| get_coupling_metrics | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| get_auth_matrix | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| find_error_gaps | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| query_call_sites | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| get_test_coverage | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| find_ownership_violations | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| query_traits | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| find_exposure_leaks | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| find_semantic_clones | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| estimate_task_cost | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| simulate_mutation | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| create_symbol | external-sink | external-sink: declares readOnlyHint: false, openWorldHint: true |
| diff_bundle | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| conflict_matrix | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| trace_boundaries | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
| query_data_targets | untrusted-input | untrusted-input: declares openWorldHint: true (interacts with entities outside the server) |
Toxic-flow graph
The lethal trifecta, checked as a graph rather than as a checklist: untrusted input, a sensitive source and an external sink have to meet before there is a path worth worrying about.
flow-1
Untrusted input can drive an external action even though no sensitive source is exposed.
Supply chain and provenance
Integrityfirst-seen
Surface digest73d930d53510196c
Scanned2026-10-15
This is the first scan of this surface here, so there is nothing yet to compare it against.
Every result on this tab comes from one deterministic pass over the published package — offline, rule by rule, and auditable line by line above. Same methodology version, same bytes, same score.
Release history
Always latest — the install command names no version, so it installs the newest release when it runs; the current release on file is 0.21.0. Pin a release below and the command asks for exactly that one.
0.21.0
15 Oct 2026
latestNo release note was published with this version.
0.20.2
undated
- The version this listing was on when mcprush began following its releases. The registry was not asked when it shipped, so this row carries no date.
—
no reviews yet
Who can review
One review per account, from a signed-in account that does not publish this listing. Nothing else is asked — you can say what you think before you install it. Publishers can reply once per review, and a review can be edited or deleted by whoever wrote it.
Sign in to write one
Any signed-in account that does not publish Seshat can review it, once — before installing it or after. A review from an account that has installed it is marked as one.
No reviews yet
Nobody has reviewed this listing. The rating on the card is the mean of the reviews written here and nothing else, so there is no rating until somebody writes the first — which takes a signed-in account that does not publish it, and nothing else.