Skip to main content
Glama
tendboat-mcp

tendboat-mcp

Official
by tendboat

tendboat

Tendboat is a deterministic cross-language taint-analysis engine. It indexes a repository, accepts structured facts supplied by a host agent, composes those facts with an IFDS solver, and emits SARIF 2.1.0.

Tendboat does not start or call a model. A host communicates with it over MCP and provides structure and security judgement one source file at a time. The core owns indexing, validation, persistence, linking, solving, triage, and reporting.

Architecture

source repository
  -> tree-sitter index       -> .tendboat/blackboard.db
  -> host-supplied IR        -> .tendboat/cache.db
  -> IFDS solver             -> findings / SARIF
  -> review decisions        -> .tendboat/triage.db

The MCP surface exposes:

  • tendboat_index — build the deterministic source index;

  • tendboat_scope — expand a set of changed paths to related paths;

  • tendboat_view — return a numbered listing with resolved parser facts;

  • tendboat_put_struct — store functions, calls, entries, and dataflow;

  • tendboat_put_judge — store sources, sinks, sanitizers, and callee contracts;

  • tendboat_solve — solve all current stored units;

  • tendboat_triage — record review decisions;

  • tendboat_paths — inspect flows already reaching a location;

  • lookup_symbol and resolve_target — resolve canonical identities.

Every tool receives the absolute repository path explicitly. The server never infers the target from its own working directory.

Related MCP server: Codex Security Cloud MCP

Development setup

Python 3.14 and uv are required for a source checkout.

make sync

Run the server directly:

uv run tendboat-mcp

Print a host configuration without editing host-owned files:

uv run tendboat mcp-config
uv run tendboat mcp-config codex
uv run tendboat mcp-config claude

Command-line solver

The command-line interface solves the current IR stored under the target repository:

uv run tendboat /path/to/repository --output findings.sarif
uv run tendboat /path/to/repository --index
uv run tendboat /path/to/repository --only src/api/user.py

Exit codes are 0 when no finding is emitted, 1 when findings are emitted, and 2 for missing input or an I/O failure.

Local verification

make check

The command runs formatting, linting, type checking, and the compact deterministic checks stored in tests/.

Build

make dist

This creates the standalone executable at dist/tendboat. The executable contains the parser data and CWE hierarchy required at runtime.

Source layout

src/tendboat/
  contract/   IR models, identity rules, and schema prose
  index/      source indexing and deterministic facts
  brief/      listings and bounded file partitioning
  memory/     persistent IR, contracts, and triage state
  solve/      IFDS analysis and CWE relations
  report/     SARIF output
  surface/    CLI and MCP tools
tests/        compact deterministic checks for the core

License

Tendboat is licensed under the Apache License, Version 2.0. See LICENSE.

Available Tools

12 tools
lookup_symbolA
Read-only

Resolve a class/function/method NAME to its definition and CANONICAL gid. Use the gid this returns for Call.target.gid: it is the id the analyzer joins on, so a guessed format silently fails to link.

Inputs: name (required), repo (required), limit. Returns: result

read_linesA
Read-only

Read a slice of a repo file, 1-indexed and inclusive, returned with a NNNN| line-number margin. Use those numbers verbatim for Loc.line -- they are the file's own numbering. At most 400 lines per call.

Inputs: path (required), end, start. Returns: result

resolve_targetA
Read-only

Resolve what a CROSS-BOUNDARY call launches into the gid of its entry point. Use the gid this returns as the boundary target.

spec is what the source says, verbatim: a container path (/entry.sh), a command line (python3 app/ingest.py), an HTTP path (/api/lookup), or a fully-qualified name. One call per boundary, no guessing.

Naming the gid is the whole point: free-form addresses written on two sides independently are not a stable join key. Returns no target indexed for ... when nothing in this repository serves it -- that answer is correct and useful: it means the peer is outside, and the boundary should say so rather than name a gid.

Inputs: repo (required), spec (required). Returns: result

search_repoA
Read-only

Regex over file contents; path:line: text per hit. path_glob is REQUIRED -- name the file or directory you mean.

For rare identifiers, not for common tokens: a query like \btrue\b matches hundreds of lines, you get the first few, and you learn nothing. The hit COUNT is always reported so a bad query is visible as such. Literals, call sites and config settings are already in your prompt -- this tool is for what is not.

Inputs: pattern (required), path_glob (required), max_hits. Returns: result

tendboat_indexA

Build the deterministic whole-repo index for repo (absolute path of the repository you are working in). Once per repository, again after a large checkout change. No model.

Inputs: repo (required). Returns: result

tendboat_pathsA
Read-only

What already-known taint flows touch this file, or this line. Answers from stored state; asks nothing of you. path is relative to repo.

Inputs: path (required), repo (required), line. Returns: result

tendboat_put_judgeB

Store one file's SECURITY assertions as JSON: sources, sinks, sanitizers, contracts, dangerous constants. Needs its structure stored first. Rejects with the exact validation errors.

Inputs: repo (required), unit (required). Returns: result

tendboat_put_structB

Store one file's STRUCTURE as JSON: functions, call sites, dataflow edges. No security judgement. Pass through the part number requested by tendboat_view. Rejects with the exact validation errors.

Inputs: repo (required), unit (required), part. Returns: result

tendboat_scopeB
Read-only

Given the files you are about to judge -- a commit, a diff, a handful of paths relative to repo -- name the files at the OTHER end of what they touch, and say which are already described. A flow with one end described and the other not is found by nothing, and the silence looks like a clean result.

Inputs: repo (required), paths (required). Returns: result

tendboat_solveB

Compose everything stored for repo and return the findings, each with a short id. Deterministic, ~1s, safe at any point. Says how many findings earlier triage hid; include_suppressed prints those with their reasons.

Inputs: repo (required), write_sarif_to, include_suppressed. Returns: result

tendboat_triageA

Record what your review decided: a JSON list of {"id","verdict","severity"|"fp_reason","evidence"}; a sanitizer-present FP also needs evidence_loc="path:line". The next tendboat_solve still FINDS everything and hides what you judged false, saying how many it hid. A false positive means tendboat read the code wrong, and needs a reason from a closed list. A verdict dies when the line it was about changes.

Inputs: repo (required), verdicts (required). Returns: result

tendboat_viewA
Read-only

The file as tendboat sees it: a numbered listing with resolved callee gids, entry points and deploy mappings attached to their lines. Says what to send next, and carries the rules for filling it. Call before describing any file. path is relative to repo; omit part to receive the next missing size-bounded part automatically.

Inputs: path (required), repo (required), part. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 12 tools

    Disambiguation4/5

    Each tool occupies a distinct slot in a staged pipeline (index -> view -> put_struct -> put_judge -> solve -> triage), and the descriptions actively draw boundaries, e.g. search_repo is 'for what is not' already in the prompt and tendboat_paths 'answers from stored state; asks nothing of you'. The main soft spots are lookup_symbol vs resolve_target (both 'resolve X to a gid', differing only in input domain) and tendboat_scope vs tendboat_paths vs tendboat_solve, which all reason about cross-file reachability and require careful reading to keep apart.

    Naming Consistency4/5

    All twelve names are snake_case verb_noun (lookup_symbol, read_lines, search_repo, put_struct, put_judge, solve, triage), so the surface reads predictably. The only deviation is the arbitrary split between eight tendboat_-prefixed tools and four bare ones, which does not map cleanly onto any stated distinction since lookup_symbol and resolve_target are just as domain-specific as the prefixed tools.

    Tool Count5/5

    Twelve tools is squarely in the well-scoped range, and each maps to a real step in the workflow rather than a redundant variant. Nothing looks like padding: the three 'resolve/read/search' utilities, the index/view pair, the two put_* writers, and the scope/solve/triage/paths analysis loop all have a job.

    Completeness4/5

    The lifecycle is well covered: index build, file inspection, structure and security storage, scope expansion, solve, and triage verdicts, plus symbol/boundary resolution and raw file access. The gaps are administrative rather than blocking: no tool to invalidate or delete stale stored state, no way to list indexed repos or per-file progress, and no way to revoke a triage verdict except by touching the line it refers to.

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI clients to perform local code search, indexing, and analysis across Java, JavaScript/TypeScript, .NET/C#, and Python projects through the MCP protocol.
      1
      Apache 2.0
    • A
      license
      A
      quality
      C
      maintenance
      Enables policy-first defensive security operations for MCP, providing repository and web-security analysis with controlled authorization, scoped execution, and auditability.
      9
      1
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables MCP-compatible agent hosts to delegate governed, read-only security audits and reviews of code, applications, agents, prompts, MCP configurations, and cloud environments through evidence-first findings and stable schemas.
      2
      Apache 2.0