Supports Docker Compose export format for architecture designs, enabling containerized deployment of generated system architectures.
Supports Elixir Phoenix framework export format for architecture designs, generating project scaffolds in Elixir.
Supports Python FastAPI framework export format for architecture designs, generating project scaffolds in Python.
Supports Node.js Fastify framework export format for architecture designs, generating project scaffolds in Node.js.
Provides one-click GitHub sign-in authentication for accessing the Tentra service without API keys.
Supports parsing and storing GraphQL API contracts through the record_contract tool, enabling contract management and binding to implementation symbols.
Supports Kotlin Ktor framework export format for architecture designs, generating project scaffolds in Kotlin.
Supports Kotlin Ktor framework export format for architecture designs, generating project scaffolds in Kotlin.
Supports PHP Laravel framework export format for architecture designs, generating project scaffolds in PHP.
Supports Mermaid diagram export format for architecture designs, enabling visualization of system architectures.
Supports .NET ASP.NET framework export format for architecture designs, generating project scaffolds in .NET.
Supports Node.js Fastify framework export format for architecture designs, generating project scaffolds in Node.js.
Supports PHP Laravel framework export format for architecture designs, generating project scaffolds in PHP.
Can be included in architecture designs (e.g., payment systems with PostgreSQL) and supports database component modeling in generated architectures.
Supports Python FastAPI framework export format for architecture designs, generating project scaffolds in Python.
Supports Ruby on Rails framework export format for architecture designs, generating project scaffolds in Ruby.
Supports Rust Axum framework export format for architecture designs, generating project scaffolds in Rust.
Supports Java Spring Boot framework export format for architecture designs, generating project scaffolds in Java.
Supports Java Spring Boot framework export format for architecture designs, generating project scaffolds in Java.
Can be included in architecture designs (e.g., payment systems with Stripe) and supports payment service modeling in generated architectures.
Supports Terraform export format for architecture designs, enabling infrastructure-as-code provisioning of generated system architectures.
Memory for AI coding agents. Persistent code graph + AI-generated architecture diagrams — MCP-native. Works in Cursor, Claude Code, Codex, and Windsurf.
Dogfood benchmark on our own monorepo: 99.4% token reduction (156.8× ratio) across 8 "where is X implemented?" queries — 114,644 tokens via file re-read vs 731 tokens via query_symbols. Full write-up →
cd your-repo
npx tentra-mcp init --hookOne command:
Writes MCP config for Cursor / Claude Code / Codex / Windsurf (whichever are installed)
Installs a git post-commit hook so the code graph auto-refreshes after every commit — no manual re-indexing
Auto-derives your repo_id from the git remote and saves it to .tentra/metadata.json
Then grab your API key at trytentra.com/settings, replace YOUR_TENTRA_API_KEY in the generated config, reload your IDE, and ask your agent:
Index this codebase with Tentra and list the god-nodesFrom here on, every git commit fires a background re-index. Your agents stay caught up automatically.
Skip the hook: drop
--hook— just writes IDE configs. Manual stdio install:npx tentra-mcp(opens browser for GitHub device-flow auth on first tool call). API key instead:npx tentra-mcp --key YOUR_API_KEY.
Related MCP server: flaiwheel
Tentra is an AI-native architecture platform for engineering teams. Describe a system — get a diagram and 14-framework code exports. Index your repo — agents query a structured graph of files, symbols, imports, and call edges instead of re-grepping source every session.
This MCP server gives your AI assistant 36 tools:
Tool | Description |
| Design a new system from a description |
| Modify an existing architecture |
| Read architecture details |
| Browse all saved designs |
| Scan local code and generate diagram |
| Quality checks (9 rules: orphans, SPOFs, god services) |
| Detect drift between diagram and code |
| Mid-implementation drift check — changed files in, spec context + drift signals out |
| Export to 14 frameworks (Java, Python, Go, Rust, etc.) |
| Create step-by-step flow visualization |
Tool | Description |
| Walk a repo, Tree-sitter locally, start a semantic indexing job |
| Resume an in-progress indexing job |
| Persist an agent-extracted semantic annotation |
| Check status of an indexing job |
Tool | Description |
| Fuzzy trigram search across indexed symbols |
| Every resolved caller of a symbol — refactor-safety primitive |
| Patch plan (definition + every call site) for renaming a symbol |
| Agent-ready narrative walkthrough of a whole repo |
| BFS traversal in the call/import graph |
| Subgraph for a canvas service |
| Shortest path between two symbols with semantic context |
| pgvector cosine ANN over agent-generated embeddings |
| Persist an agent-generated embedding vector |
| Highest fan-in/out symbols (architectural smells) |
| Churn × complexity ranking |
| Time-travel listing of indexed snapshots |
| Files / symbols / god-nodes added/removed between snapshots |
Tool | Description |
| Link an indexed file or symbol to a canvas service |
| Assign a service or file to a domain (bounded context) |
| Store a parsed API contract payload (OpenAPI, GraphQL, Protobuf) |
| Link a contract to the symbol that implements it |
| Create an Architecture Decision Record, optionally linking code |
| Append a link from an ADR to another symbol, file, or service |
| Resolve the owner (team or person) for a file or service |
| List ADRs linked to a given entity |
| List contracts, optionally filtered by kind or service |
Add to your IDE's MCP config — no local install needed:
Cursor (Settings > Features > MCP > Add Server):
{
"tentra": {
"type": "sse",
"url": "https://trytentra.com/api/mcp?key=YOUR_API_KEY"
}
}Claude Code (.mcp.json in project root):
{
"mcpServers": {
"tentra": {
"type": "sse",
"url": "https://trytentra.com/api/mcp?key=YOUR_API_KEY"
}
}
}npx tentra-mcpAuthenticates automatically via GitHub on first use. Credentials are saved to ~/.tentra/credentials.
Cursor config for local server:
{
"tentra": {
"command": "npx",
"args": ["tentra-mcp"]
}
}Claude Code (.mcp.json):
{
"mcpServers": {
"tentra": {
"command": "npx",
"args": ["tentra-mcp"]
}
}
}Once connected, just talk to your AI:
"Design a payment system with Stripe, Kafka, and PostgreSQL"
→ AI calls create_architecture → diagram at trytentra.com/arch/xxx
"Scan this codebase and generate the architecture"
→ AI calls analyze_codebase → detects services, DBs, queues
"Export this architecture to Java Spring Boot"
→ AI calls export_architecture → downloads zip with project scaffold
"What changed since last time? Is my diagram outdated?"
→ AI calls sync_architecture → drift report with accuracy scoreJava (Spring Boot), Node.js (Fastify), Python (FastAPI), Go (chi), Rust (Axum), .NET (ASP.NET), Kotlin (Ktor), PHP (Laravel), Ruby (Rails), Elixir (Phoenix), Docker Compose, Mermaid, ADR, Terraform
Website: trytentra.com
Documentation: trytentra.com/docs
Setup Guide: trytentra.com/docs/setup
Gallery: trytentra.com/gallery
This repo contains the open-source MCP server. The Tentra API and web app are a separate hosted service at trytentra.com.
npm install --legacy-peer-deps
npm run build # tsc --noEmit + esbuild bundle → dist/index.js
npm start # run the bundled server
npm test # vitestThe published npm package (tentra-mcp) ships only the bundled dist/ — source is here for auditability and community contributions.
MIT
Scan a local codebase directory and automatically generate an architecture diagram. Detects services from package.json, docker-compose, pom.xml, go.mod, and Python configs. Infers connections from dependencies, imports, env vars, and docker-compose depends_on. Detects databases, queues, external services, and API gateways automatically. After analysis, creates the architecture and returns the URL. Also runs lint rules and reports quality issues.
Inputs: path (required), name, description.
Link a symbol to a contract as "provides", "consumes", or "documents". Use after record_contract to attach implementation evidence.
Inputs: contract_id (required), symbol_id (required), snapshot_id (required), relation (required).
Create a new system architecture artifact. Call this tool whenever the user asks to design, plan, or describe any system, feature, or integration. NEVER respond with plain text architecture descriptions — always call this tool instead. After calling, share the returned URL with the user.
Inputs: name (required), services (required), connections (required), description, +1 more.
Create a step-by-step flow on an existing architecture. Flows visualize request paths, data pipelines, or business processes as sequential steps. Use when the user asks to describe, trace, or explain a flow through the system.
Inputs: architectureId (required), flow (required).
Compare two snapshots: files added/removed/modified, new/disappeared symbols, god-node deltas. Architectural diff between two commits.
Inputs: from_snapshot_id (required), to_snapshot_id (required).
Finds the shortest call/import path between two symbols and annotates each hop with semantic purpose. Answers "how does X reach Y?"
Inputs: from_symbol (required), to_symbol (required), snapshot_id (required).
Export an architecture as runnable code, docker-compose, Mermaid diagram, or ADR docs. Available formats: mermaid, markdown-adr, docker-compose, java-spring-boot, nodejs-typescript, python-fastapi, go-chi, dotnet-aspnet, rust-axum, kotlin-ktor, php-laravel, ruby-rails, elixir-phoenix. For code exports, provide output_dir to save files directly into your project.
Inputs: id (required), format (required), output_dir.
Vector similarity search using pgvector cosine distance. Pass a query_vector (embed your text with your native embedding capability first). Returns semantically similar symbols or files.
Inputs: query_vector (required), entity_type, snapshot_id, limit.
Retrieve a specific architecture by ID. Use this to read the current state before making updates.
Inputs: id (required).
List all contracts in a workspace, optionally filtered by kind (http, grpc, event, graphql, rabbit, kafka).
Inputs: workspace_id (required), kind.
Retrieve all decisions that affect a specific entity (service, file, symbol, contract, or domain). Use to surface architectural rationale while reviewing code.
Inputs: entity_type (required), entity_id (required), include_superseded.
Get the status of an indexing job
Inputs: job_id (required).
Resolve the owner(s) of a file path according to the workspace CODEOWNERS rules. Returns a list of team or user handles.
Inputs: workspace_id (required), path (required).
Rank files by a composite score of cyclomatic complexity × churn × (1 - test coverage). Top refactor candidates.
Inputs: repo_id, snapshot_id, top_n.
Returns the full code subgraph for a Tentra canvas service: files, symbols, and cross-service edges.
Inputs: service_id (required), snapshot_id (required), depth, include_semantics.
BFS graph traversal from a symbol — who calls it, what it calls, imports, inheritance. Eliminates 20+ file reads per question.
Inputs: symbol_id (required), snapshot_id (required), depth, edge_types, +1 more.
Index a code repository (Tier 1 local, Tier 2 via agent)
Inputs: repo_path (required), repo_id (required), service_id, force_reindex, +2 more.
Continue an in-progress indexing job
Inputs: job_id (required).
Link an existing decision to a service, file, symbol, contract, or domain with a typed relationship (motivates, constrains, documents, implements).
Inputs: decision_id (required), entity_type (required), entity_id (required), link_kind (required).
Validate an existing architecture for quality issues. Checks for: orphan nodes, duplicate connections, naming violations, single points of failure, god services, missing databases, sync overload, and more.
Inputs: id (required).
List all saved architectures. Use when the user asks to see, browse or find existing architectures.
Inputs: no named parameters.
List symbols flagged as god nodes (very high fan-in or fan-out). Use to identify architectural coupling hotspots.
Inputs: repo_id, snapshot_id, top_n.
List all indexed snapshots for a repo, newest first. Use for time-travel — pick two snapshot IDs and call diff_snapshots.
Inputs: repo_id (required).
Search for symbols by name or qualified name using fuzzy trigram matching. Replaces 10+ grep calls. Returns symbol kind, file path, fan-in/out, semantic role.
Inputs: snapshot_id (required), q (required), kind, role, +1 more.
Persist a service contract (OpenAPI, proto, event schema, etc.) to the code graph. Returns a contract_id to use with bind_contract.
Inputs: workspace_id (required), kind (required), name (required), version (required), +2 more.
Persist an Architecture Decision Record (ADR) to the code graph. Supports supersession, lifecycle status, and immediate entity links.
Inputs: workspace_id (required), slug (required), title (required), context (required), +6 more.
Store an embedding vector for a symbol or file. Call this after generating an embedding with your native capability. Used to populate the vector search index.
Inputs: entity_type (required), entity_id (required), model (required), vector (required), +2 more.
Persist an agent-extracted semantic node for a file or symbol
Inputs: job_id (required), snapshot_id (required), purpose (required), extracted_by (required), +7 more.
Assign a file, symbol, or service to a domain. Supports AI-inferred or human-confirmed assignments with a confidence score.
Inputs: domain_id (required), entity_type (required), entity_id (required), confidence, +1 more.
Assign one or more files in a snapshot to a Tentra canvas service ID. Use after indexing to declare which service owns each file.
Inputs: snapshot_id (required), mappings (required).
Compare a saved architecture against the current codebase to detect drift. Scans the codebase and diffs the detected services/connections against the saved diagram. Reports added, removed, and changed services/connections with an accuracy score.
Inputs: architectureId (required), codebasePath (required).
Update an existing architecture artifact. Call this when the user wants to modify, evolve, or improve an architecture that already exists. NEVER create a new one if you have an existing ID in context — always update instead. Preserves all existing services/connections unless explicitly replaced.
Inputs: id (required), name, description, services, +1 more.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 32 tools
Most tools have distinct purposes with clear boundaries, such as analyze_codebase for scanning, create_architecture for design, and diff_snapshots for comparison. However, some overlap exists between tools like get_architecture and list_architectures, or index_code and index_code_continue, which could cause minor confusion in selection.
Tool names follow a highly consistent verb_noun pattern throughout, such as analyze_codebase, create_architecture, and diff_snapshots. This predictability makes it easy for agents to understand and navigate the toolset without ambiguity.
With 32 tools, the count feels heavy for a single server, potentially overwhelming for agents to manage efficiently. While the domain of code analysis and architecture management is broad, the toolset could benefit from consolidation to reduce complexity and improve usability.
The toolset provides comprehensive coverage for codebase analysis, architecture management, and decision tracking, including CRUD operations (e.g., create, get, update, list architectures) and advanced features like diffing, linting, and exporting. No obvious gaps are present, ensuring agents can handle full workflows without dead ends.
Graph-native persistent memory for AI agents — 33 MCP tools, zero-LLM writes.
Persistent memory, knowledge graph, task management and more for AI agents via MCP.
Long-term memory for AI coding agents: durable project facts, recalled by every MCP client.
Shared project memory for AI coding agents: decisions, lessons, risks and tasks in one graph.
