Tentra — Memory for AI Coding Agents

io.github.rdanieliPublished by GitHub account rdanieliv1.3.2Updated Oct 24, 2026

Memory for AI coding agents. Call graphs + refactor safety + persistent code context. 35 MCP tools.

The publisher's own server: Memory.fit

Overview

AI-generated overview

Tentra gives AI coding agents a persistent code graph and architecture workspace, so they can query symbols, callers and designs instead of re-reading source.

What you can do
Query an indexed code graph: fuzzy symbol search, callers, rename patch plans, neighbor traversal, similar code, god nodes, hotspots and snapshot diffs, plus repo walkthroughs and code-path explanations. Index a repository and record semantic annotations, embeddings and indexing job status. Design, read, update, lint, sync and export architectures to many frameworks, and create flow visualizations. Store enrichment data: service mappings, domains, API contracts, architecture decision records and ownership.
When to use it
Useful when an assistant works repeatedly in the same repository and should answer questions like where something is implemented, what calls a symbol, or whether a diagram still matches the code. Also suited to teams that want architecture diagrams, ADRs and refactor-safety checks alongside coding agents such as Cursor, Claude Code, Codex or Windsurf.
Requirements
Either the hosted SSE endpoint or the local npm package tentra-mcp run with npx (Node.js). An account on the hosted service; authentication by GitHub device flow by default, or a TENTRA_API_KEY value passed as a key parameter or command-line flag. Local codebase scanning requires the local install. Network access to the hosted API.
Before you install
The server sends repository data, including indexed code and agent-generated annotations, to the hosted Tentra service. Credentials are stored on disk after GitHub device-flow login. The init command writes MCP configuration files for installed IDEs and installs a git post-commit hook that re-indexes in the background after every commit. Many tools write or modify stored architectures, contracts, decisions and mappings.

Installation

In SourceWeft

  1. Open Tentra — Memory for AI Coding Agents in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via SSE. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.rdanieli%2Ftentra/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "tentra-memory-for-ai-coding-agents": {
      "type": "sse",
      "url": "https://trytentra.com/api/mcp"
    }
  }
}

README

tentra-mcp

[npm version] [npm downloads] [CI] [License: MIT]

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 →

Quick Start (60 seconds)

bash
cd your-reponpx tentra-mcp init --hook

One command:

  1. Writes MCP config for Cursor / Claude Code / Codex / Windsurf (whichever are installed)
  2. Installs a git post-commit hook so the code graph auto-refreshes after every commit — no manual re-indexing
  3. 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-nodes

From 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.

What is Tentra?

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:

Architecture (10 tools)

ToolDescription
create_architectureDesign a new system from a description
update_architectureModify an existing architecture
get_architectureRead architecture details
list_architecturesBrowse all saved designs
analyze_codebaseScan local code and generate diagram
lint_architectureQuality checks (9 rules: orphans, SPOFs, god services)
sync_architectureDetect drift between diagram and code
get_spec_alignmentMid-implementation drift check — changed files in, spec context + drift signals out
export_architectureExport to 14 frameworks (Java, Python, Go, Rust, etc.)
create_flowCreate step-by-step flow visualization

Code Graph — Write (4 tools)

ToolDescription
index_codeWalk a repo, Tree-sitter locally, start a semantic indexing job
index_code_continueResume an in-progress indexing job
record_semantic_nodePersist an agent-extracted semantic annotation
get_index_jobCheck status of an indexing job

Code Graph — Read (13 tools)

ToolDescription
query_symbolsFuzzy trigram search across indexed symbols
find_referencesEvery resolved caller of a symbol — refactor-safety primitive
safe_renamePatch plan (definition + every call site) for renaming a symbol
explain_codebaseAgent-ready narrative walkthrough of a whole repo
get_symbol_neighborsBFS traversal in the call/import graph
get_service_code_graphSubgraph for a canvas service
explain_code_pathShortest path between two symbols with semantic context
find_similar_codepgvector cosine ANN over agent-generated embeddings
record_embeddingPersist an agent-generated embedding vector
list_god_nodesHighest fan-in/out symbols (architectural smells)
get_quality_hotspotsChurn × complexity ranking
list_snapshotsTime-travel listing of indexed snapshots
diff_snapshotsFiles / symbols / god-nodes added/removed between snapshots

Enrichment — Contracts, Decisions, Ownership, Domains (9 tools)

ToolDescription
set_service_mappingLink an indexed file or symbol to a canvas service
set_domain_membershipAssign a service or file to a domain (bounded context)
record_contractStore a parsed API contract payload (OpenAPI, GraphQL, Protobuf)
bind_contractLink a contract to the symbol that implements it
record_decisionCreate an Architecture Decision Record, optionally linking code
link_decisionAppend a link from an ADR to another symbol, file, or service
get_ownershipResolve the owner (team or person) for a file or service
get_decisions_forList ADRs linked to a given entity
get_contractsList contracts, optionally filtered by kind or service

Setup

Option 1: SSE (zero install)

Add to your IDE's MCP config — no local install needed:

Cursor (Settings > Features > MCP > Add Server):

json
{  "tentra": {    "type": "sse",    "url": "https://trytentra.com/api/mcp?key=YOUR_API_KEY"  }}

Claude Code (.mcp.json in project root):

json
{  "mcpServers": {    "tentra": {      "type": "sse",      "url": "https://trytentra.com/api/mcp?key=YOUR_API_KEY"    }  }}

Option 2: Local install (needed for codebase scanning)

bash
npx tentra-mcp

Authenticates automatically via GitHub on first use. Credentials are saved to ~/.tentra/credentials.

Cursor config for local server:

json
{  "tentra": {    "command": "npx",    "args": ["tentra-mcp"]  }}

Claude Code (.mcp.json):

json
{  "mcpServers": {    "tentra": {      "command": "npx",      "args": ["tentra-mcp"]    }  }}

Usage Examples

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 score

Export Formats

Java (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

Links

Development

This repo contains the open-source MCP server. The Tentra API and web app are a separate hosted service at trytentra.com.

bash
npm install --legacy-peer-depsnpm run build      # tsc --noEmit + esbuild bundle → dist/index.jsnpm start          # run the bundled servernpm test           # vitest

The published npm package (tentra-mcp) ships only the bundled dist/ — source is here for auditability and community contributions.

License

MIT

Source: README.md at commit 116cf71

Tools

0
SourceWeft has not read this server's tools yet.

Version history

1
  1. v1.3.2LatestSep 16, 2026

Score

85% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts

Other Memory integrations