Skip to main content
Glama
testigo-recall-mcp

testigo-recall-mcp

Official

testigo-recall-mcp

MCP server that exposes a pre-scanned codebase knowledge base to AI agents. Instead of reading source files directly, agents query pre-extracted facts about code behavior, design decisions, and assumptions — saving time and tokens.

Works with Claude Code, Cursor, Windsurf, and any MCP-compatible client.

Installation

pip install testigo-recall-mcp

Related MCP server: codemap

Configuration

GitHub Releases (default)

Auto-downloads knowledge base .db files from a GitHub release:

{
  "mcpServers": {
    "testigo-recall": {
      "command": "testigo-recall-mcp",
      "env": {
        "TESTIGO_RECALL_REPO": "owner/repo",
        "GITHUB_TOKEN": "ghp_..."
      }
    }
  }
}

Azure Blob Storage

Downloads .db files from an Azure Blob Storage container. Auth uses your existing az login session — no secrets needed:

{
  "mcpServers": {
    "testigo-recall": {
      "command": "testigo-recall-mcp",
      "env": {
        "TESTIGO_RECALL_AZURE_URL": "https://account.blob.core.windows.net/container"
      }
    }
  }
}

Auth priority: SAS token > az login bearer token > public container.

Local files

Point directly at local .db files (useful for development/demos):

{
  "mcpServers": {
    "testigo-recall": {
      "command": "testigo-recall-mcp",
      "env": {
        "TESTIGO_RECALL_DB_PATH": "/path/to/knowledge.db"
      }
    }
  }
}

All backends can be combined — DBs are merged at startup.

Environment Variables

Variable

Description

TESTIGO_RECALL_REPO

GitHub repo(s), comma-separated (e.g. owner/repo). Auto-downloads from knowledge-base release tag.

TESTIGO_RECALL_AZURE_URL

Azure Blob Storage container URL(s), comma-separated.

TESTIGO_RECALL_AZURE_SAS

Optional SAS token for Azure (read+list). Not needed if az login is active.

TESTIGO_RECALL_DB_PATH

Local .db file path(s), comma-separated.

GITHUB_TOKEN

GitHub token for private repos. Public repos work without auth.

Tools

The server exposes 6 tools to AI agents:

search_codebase

Full-text search across the knowledge base. Returns facts ranked by relevance. Supports semicolon-separated multi-query batching (e.g. "auth login; session JWT; middleware").

  • query — search keywords

  • category — optional filter: behavior, design, or assumption

  • min_confidence — confidence threshold 0.0-1.0

  • limit — max results (default: 20)

  • repo_name — optional filter to scope to one repository

get_module_facts

Deep dive into a specific module. Use search_codebase first to discover module IDs.

  • module_id — e.g. SCAN:backend/app/api or PR-123

get_recent_changes

Most recently extracted facts across the codebase.

  • category — optional filter

  • limit — number of results (default: 10)

get_component_impact

Blast radius analysis — shows what depends on a component and what it depends on.

  • component_name — file path or service name (e.g. api_service.py)

list_modules

Lists all scanned modules in the knowledge base. Call without arguments for a compact repo summary.

  • repo_name — optional repository filter

get_repo_dependencies

Cross-repo dependency graph from package manifests (go.mod, package.json).

  • repo_name — optional filter

  • direction — outgoing, incoming, or both

How It Works

The knowledge base contains pre-extracted facts organized by category:

  • behavior — what the code does (triggers, outcomes)

  • design — how it's built (decisions, patterns, trade-offs)

  • assumption — what it expects (invariants, prerequisites)

Facts come from two sources:

  • SCAN facts (SCAN:module/path) — current state of a module, refreshed automatically

  • PR facts (PR-123) — what a specific PR changed, preserved as history

The server uses SQLite with FTS5 full-text search for fast, relevance-ranked queries.

Multi-repo support

All backends support multiple repositories in a single MCP server instance. Each repo gets its own .db file, stored in a shared location (GitHub release, Azure container, or local directory). The server downloads all .db files and merges them into a unified knowledge base at startup.

knowledge-base/
  ├── frontend-app.db
  ├── backend-api.db
  ├── shared-lib.db
  └── infrastructure.db

Use list_modules() to see all available repos, and repo_name parameter on search_codebase to scope queries.

Available Tools

6 tools
get_component_impactA

Find all modules and PRs where a specific component (file/service) appears.

Use this to understand the blast radius of changes to a component — what depends on it and what it depends on.

Args: component_name: File path or service name (e.g. "api_service.py", "backend/app/auth")

Inputs: component_name (required). Returns: result

get_module_factsA

Get all extracted facts for a specific module.

Module IDs look like "SCAN:backend/app/api". Use search_codebase first to discover module IDs, then use this for a deep dive into a specific module.

Args: module_id: The module identifier (e.g. "SCAN:backend/app/api/simplified")

Inputs: module_id (required). Returns: result

get_recent_changesA

Get the most recently extracted facts across the entire codebase.

Useful for understanding what changed recently or getting an overview of the codebase.

Args: category: Optional filter — "behavior", "design", or "assumption" limit: Number of recent facts to return (default: 10)

Inputs: limit, category. Returns: result

get_repo_dependenciesA

Get cross-repo dependency graph showing which repos depend on each other.

Use this to understand the blast radius of changes across repositories. Data comes from package manifests (go.mod, package.json), not code analysis.

Args: repo_name: Filter to a specific repo. Without this, returns entire graph. direction: "outgoing" (what this repo depends on), "incoming" (what depends on this repo), "both"

Inputs: direction, repo_name. Returns: result

list_modulesA

List scanned modules in the knowledge base.

Without repo_name: returns a compact summary of repos with module/fact counts. With repo_name: returns the full list of modules for that specific repo.

Always call without repo_name first to discover available repos, then call again with repo_name to get the module list for a specific repo.

Args: repo_name: Repository name — pass this to get the full module list for one repo

Inputs: repo_name. Returns: result

search_codebaseA

Search the codebase knowledge base for facts about what the code does, how it's built, and what it assumes.

Use this FIRST before reading source files. It returns pre-extracted facts ranked by relevance, saving significant time and tokens.

MULTI-QUERY: Use semicolons to search multiple keyword groups in one call. Example: "payment gateway; checkout flow; stripe webhooks" This runs 3 searches, deduplicates, and returns combined results. ALWAYS batch related searches into one call — this is dramatically cheaper.

Args: query: Search keywords (e.g. "authentication", "payment flow", "database connection") Use semicolons to batch multiple searches: "auth login; session JWT; middleware" category: Optional filter — "behavior" (what it does), "design" (how it's built), or "assumption" (what it expects) min_confidence: Minimum confidence threshold 0.0-1.0 (default: 0.0) limit: Max results per query (default: 20). With batched queries, total results can be up to limit × number of queries (max 65). repo_name: Optional filter to scope search to a specific repository

Inputs: query (required), limit, category, repo_name, +1 more. Returns: result

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.5/5.0

    Scored across 6 tools

    Disambiguation5/5

    Each tool targets a distinct retrieval need: keyword search, module-specific facts, recent changes, component impact, module listing, and repo dependency graph. No two tools overlap in purpose, making misselection unlikely.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern (search_codebase, get_module_facts, get_recent_changes, get_component_impact, list_modules, get_repo_dependencies). The naming convention is uniform and predictable.

    Tool Count5/5

    With 6 tools, the set is well-scoped for a codebase knowledge base. Each tool provides a distinct function without redundancy, fitting comfortably within the optimal 3-15 tool range.

    Completeness5/5

    The tool surface covers the full read-only workflow: discover repos and modules, search facts, drill into specific modules, view recent changes, analyze component impact, and explore cross-repo dependencies. No significant gaps exist for its stated purpose.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that transforms codebases into intelligent, queryable knowledge bases, enabling AI assistants to perform semantic search, explore architecture, and analyze code relationships.
      166
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      MCP server for local-first code intelligence, providing structural code graph, semantic search, and impact analysis to AI agents.
      2
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      MCP server that helps AI coding agents understand a repository by providing lightweight tree/map, code search, and token-budgeted context packing tools without dumping the entire monorepo into the prompt.
      3
      104
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server that provides a structured project knowledge base for AI coding agents, enabling project memory management, targeted document retrieval, and symbol map queries to improve token efficiency and context persistence.
      5 npm
      MIT