testigo-recall-mcp
OfficialEnables automatic download of knowledge base .db files from GitHub releases for multi-repo support.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@testigo-recall-mcp search codebase for authentication behavior"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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-mcpRelated 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 |
| GitHub repo(s), comma-separated (e.g. |
| Azure Blob Storage container URL(s), comma-separated. |
| Optional SAS token for Azure (read+list). Not needed if |
| Local |
| 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 keywordscategory— optional filter:behavior,design, orassumptionmin_confidence— confidence threshold 0.0-1.0limit— 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/apiorPR-123
get_recent_changes
Most recently extracted facts across the codebase.
category— optional filterlimit— 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 filterdirection—outgoing,incoming, orboth
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 automaticallyPR 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.dbUse list_modules() to see all available repos, and repo_name parameter on search_codebase to scope queries.
Available Tools
6 toolsget_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
Scored across 6 tools
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.
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.
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.
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
Related MCP Connectors
An MCP server that gives your AI access to the source code and docs of all public github repos
Repository knowledge graph MCP server for codebase understanding and debugging.
Team memory for AI coding agents and code reviews, reviewed by humans and served over MCP.
Shared memory MCP server for Claude Code, Codex, Gemini CLI and Cursor. Cited, editable.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceAn MCP server that transforms codebases into intelligent, queryable knowledge bases, enabling AI assistants to perform semantic search, explore architecture, and analyze code relationships.166-
- AlicenseNot gradedqualityBmaintenanceMCP server for local-first code intelligence, providing structural code graph, semantic search, and impact analysis to AI agents.2MIT
- AlicenseAqualityDmaintenanceMCP 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.3104MIT
- AlicenseNot gradedqualityDmaintenanceMCP 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 npmMIT