MCP server de codeTree
Commit 12 nov 2026Proporciona a los agentes de programación una comprensión estructurada del código mediante tree-sitter para permitir consultas precisas y una reducción significativa de tokens.
También conocido como ThinkyMiner/codeTree
- Stars
- 30
- Herramientas
- —
- Descargas, 30 días
- —
- Última versión
- —
- Último commit
- 12 nov 2026
- Licencia
- MIT
¿Qué es codeTree MCP?
Proporciona a los agentes de programación una comprensión estructurada del código mediante tree-sitter para permitir consultas precisas y una reducción significativa de tokens.
Resumen generado a partir del README del proyecto
Acerca del MCP server de codeTree
Los agentes de programación que necesitan navegar por repositorios grandes sin consumir cantidades masivas de tokens pueden usar codeTree para obtener una comprensión estructurada de su base de código. Al utilizar tree-sitter, este MCP server ofrece una forma para que los clientes de IA consulten elementos de código específicos como clases, métodos y docstrings en lugar de leer archivos enteros. Este enfoque puede reducir el consumo de tokens hasta 25 veces en comparación con la lectura de código fuente sin procesar.
Los desarrolladores pueden integrar este servidor en entornos como Claude Code, Cursor, VS Code, Windsurf o Claude Desktop. Soporta 11 lenguajes, incluyendo Python, TypeScript, Go, Rust y Java. El servidor se ejecuta localmente y no requiere bases de datos vectoriales externas ni modelos de embeddings, lo que lo convierte en una solución ligera que se inicia en aproximadamente un segundo. Utiliza un proceso de indexación en segundo plano para construir un grafo de símbolos y una caché local para mantener el rendimiento.
A través de 23 herramientas especializadas, el servidor permite operaciones complejas como encontrar referencias de símbolos, analizar la complejidad ciclomática, detectar código muerto y realizar análisis de flujo de datos o de contaminación (taint analysis). También proporciona información de todo el repositorio, como grafos de dependencias y análisis de impacto de cambios, para ayudar a los agentes a comprender las consecuencias de las modificaciones de código.
Qué puedes hacer con él
- 1Reducir el uso de tokens durante la exploraciónUn agente de IA puede solicitar el esqueleto de un archivo para ver la estructura de una clase sin leer cada línea de su implementación.
- 2Rastrear el flujo de datos de las variablesUn desarrollador puede usar el agente para realizar un análisis de contaminación o rastrear cómo se mueven las variables a través de diferentes funciones.
Escrito a partir del README del proyecto. Cada caso de uso se verifica con una cita del mismo.
Verificaciones automáticas
Ejecutado 14 nov 2026Informe completo →Aún no verificado. Un servidor necesita una puntuación de 80, ningún hallazgo grave y suficientes datos para que podamos revisarlo. Cómo funcionan las verificaciones · Qué corregir para obtener más puntos
- Repositorio de origen vinculado y accesiblethinkyminer/codetree is public and reachablegithub.com/thinkyminer/codetree ↗Aprobado
- El paquete indica este repositorio como su origenNo verificado
- Procedencia de la compilación (atestación de Sigstore)No verificado
- Licencia de código abierto (OSI)MITspdx.org/licenses/MIT.html ↗Aprobado
- Commit o lanzamiento en el último añoLast commit or release 2026-11-12github.com/thinkyminer/codetree ↗Aprobado
- OpenSSF ScorecardNo verificado
- El nombre del paquete no es similar a un paquete popularNo verificado
- No hay avisos críticos en el paquete ni en sus dependenciasNo verificado
- Sin instrucciones ocultas para el modelo0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersAprobado
- Las herramientas destructivas están etiquetadasNo verificado
- El endpoint remoto responde al handshake de MCPNo verificado
README
Ver en GitHubcodetree
Stop feeding entire files to your AI agent.
codetree is an MCP server that gives coding agents structured code understanding via tree-sitter — so they ask precise questions instead of reading thousands of lines. 23 tools, 11 languages, ~1 second startup. No vector DB, no embedding model, no config.
Quick Start
Prerequisite: Install uv if you don't have it (curl -LsSf https://astral.sh/uv/install.sh | sh).
Then cd into any project and run:
claude mcp add codetree -- uvx --from mcp-server-codetree codetree --root .
That's it. The . means "this project." Your agent now has structured code understanding.
Not using Claude Code? See Editor Setup for Cursor, VS Code, Windsurf, and Claude Desktop.
Before / After
Before codetree — agent reads the raw file:
$ cat calculator.py
import math
from typing import Optional
class Calculator:
"""A scientific calculator with memory."""
def __init__(self):
self.memory = 0
self.history = []
def add(self, a: float, b: float) -> float:
"""Add two numbers."""
result = a + b
self.history.append(('add', a, b, result))
return result
def divide(self, a: float, b: float) -> Optional[float]:
"""Divide a by b, returns None on zero division."""
if b == 0:
return None
result = a / b
self.history.append(('divide', a, b, result))
return result
# ... 200 more lines of methods ...
Tokens consumed: ~2,000+ for the full file
After codetree — agent asks for the skeleton:
class Calculator → line 4
"A scientific calculator with memory."
def __init__(self) (in Calculator) → line 7
def add(self, a: float, b: float) (in Calculator) → line 11
"Add two numbers."
def divide(self, a: float, b: float) (in Calculator) → line 17
"Divide a by b, returns None on zero division."
def sqrt(self, x: float) (in Calculator) → line 24
"Square root using math.sqrt."
Tokens consumed: ~80. That's a 25x reduction.
The agent sees every class, method, and docstring — with line numbers — without reading a single function body. When it needs the full source of divide, it calls get_symbol("calculator.py", "divide") and gets just those 6 lines.
23 Tools
Understand Structure
| Tool | Purpose |
|---|---|
get_file_skeleton(file_path) |
Classes, functions, methods with line numbers + doc comments |
get_symbol(file_path, symbol_name) |
Full source of a function or class |
get_skeletons(file_paths) |
Batch skeletons for multiple files |
get_symbols(symbols) |
Batch source for multiple symbols |
get_imports(file_path) |
Import statements with line numbers |
Navigate Relationships
| Tool | Purpose |
|---|---|
find_references(symbol_name) |
All usages of a symbol across the repo |
get_call_graph(file_path, function_name) |
What a function calls + what calls it |
get_blast_radius(file_path, symbol_name) |
Transitive impact — what breaks if you change this |
Analyze Quality
| Tool | Purpose |
|---|---|
get_complexity(file_path, function_name) |
Cyclomatic complexity breakdown |
find_dead_code(file_path?) |
Symbols defined but never referenced |
detect_clones(file_path?, min_lines?) |
Duplicate / near-duplicate functions |
Inspect & Search
| Tool | Purpose |
|---|---|
search_symbols(query?, type?, parent?) |
Flexible symbol search with filters |
find_tests(file_path, symbol_name) |
Find test functions for a symbol |
Onboarding & Graph
| Tool | Purpose |
|---|---|
index_status() |
Indexing progress, graph freshness and stats (never blocks) |
get_repository_map(max_items?) |
Compact repo overview: languages, entry points, hotspots |
resolve_symbol(query, kind?, path_hint?) |
Disambiguate short name into ranked qualified matches |
search_graph(query?, kind?, file_pattern?) |
Graph search with degree filters and pagination |
Change & Dataflow
| Tool | Purpose |
|---|---|
get_change_impact(symbol_query?, diff_scope?) |
Impact analysis via symbol or git diff, with risk levels |
analyze_dataflow(file_path, function_name, mode?) |
Variable dataflow, taint analysis, or cross-function taint tracing |
Visualization & History
| Tool | Purpose |
|---|---|
find_hot_paths(top_n?) |
High-complexity × high-call-count optimization targets |
get_dependency_graph(file_path?, format?) |
File-level dependency graph as Mermaid or list |
git_history(mode?, file_path?, top_n?) |
Git blame, file churn, or change coupling analysis |
suggest_docs(file_path?, symbol_name?) |
Find undocumented functions with context for doc generation |
get_file_skeleton,get_skeletons, andsearch_symbolsacceptformat="compact"for even fewer tokens.
Supported Languages
| Language | Extensions |
|---|---|
| Python | .py |
| JavaScript | .js, .jsx |
| TypeScript | .ts |
| TSX | .tsx |
| Go | .go |
| Rust | .rs |
| Java | .java |
| C | .c, .h |
| C++ | .cpp, .cc, .cxx, .hpp, .hh |
| Ruby | .rb |
| Kotlin | .kt |
Editor Setup
The --root flag tells codetree which project to analyze. Use . for the current directory, or a full path.
Claude Code
cd into your project, then:
claude mcp add codetree -- uvx --from mcp-server-codetree codetree --root .
Cursor
Add to .cursor/mcp.json in your project:
{
"mcpServers": {
"codetree": {
"command": "uvx",
"args": ["--from", "mcp-server-codetree", "codetree", "--root", "${workspaceFolder}"]
}
}
}
VS Code (Copilot)
Add to .vscode/mcp.json in your project:
{
"servers": {
"codetree": {
"command": "uvx",
"args": ["--from", "mcp-server-codetree", "codetree", "--root", "${workspaceFolder}"]
}
}
}
Windsurf
Add to ~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"codetree": {
"command": "uvx",
"args": ["--from", "mcp-server-codetree", "codetree", "--root", "${workspaceFolder}"]
}
}
}
Claude Desktop
Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"codetree": {
"command": "uvx",
"args": ["--from", "mcp-server-codetree", "codetree", "--root", "/path/to/your/project"]
}
}
}
Claude Desktop doesn't support
${workspaceFolder}, so use a full path here.
Why codetree?
| Alternative | Limitation | codetree |
|---|---|---|
| Reading files directly | Burns tokens, no structure, no relationships | 25x token reduction, structured output |
| grep / ripgrep | Text only, no AST awareness, no call graphs | Understands code structure, not just text |
| LSP servers | Heavyweight, stateful, language-specific setup | One command, 10 languages, stateless MCP |
| SCIP / LSIF indexers | Slow builds, complex setup, huge indexes | ~1s startup, JSON cache, zero config |
| AST-only tools | Raw trees are verbose and hard for agents | Pre-structured output designed for agents |
What Gets Indexed
- Git repositories: every file
git ls-filesreports — tracked files plus untracked files that.gitignoredoes not exclude. Tracked directories are indexed even if namedbuild/,dist/orenv/; untracked.venv/,node_modules/,__pycache__/and similar are skipped even when nobody ignored them. Nested worktrees (e.g..claude/worktrees/), nested repositories and submodules are not indexed. - Without git (not a repository,
gitmissing, or git refusing the repository, e.g.safe.directory): the tree is walked, skipping.venv,node_modules,__pycache__,.git,dist,build, … and nested worktrees. .codetree/(codetree's own cache) is never indexed.
The MCP handshake is answered immediately and indexing runs in the background.
Single-file tools answer right away; repo-wide and graph tools wait up to 20 s
for the index (set CODETREE_WAIT_TIMEOUT to change it), then report progress.
index_status() never blocks.
Architecture
Agent (Claude, Copilot, Cursor, etc.)
│ MCP (stdio)
▼
codetree server (FastMCP)
│
├── Indexer → LanguagePlugin → tree-sitter → structured results
│ Cache (.codetree/index.json, mtime-based)
│
└── Graph Layer → SQLite (.codetree/graph.db)
Persistent symbols + edges, incremental updates
Change impact, dataflow, taint analysis
| Module | Responsibility |
|---|---|
server.py |
FastMCP server — defines all 23 tools |
index_state.py |
Index lifecycle: background indexing, readiness, progress for index_status |
indexer.py |
File discovery, plugin dispatch, definition index |
cache.py |
Skeleton cache with mtime invalidation |
registry.py |
Maps file extensions to language plugins |
languages/ |
One plugin per language (Python, JS, TS, Go, Rust, Java, C, C++, Ruby) |
graph/store.py |
SQLite persistence for symbols and edges |
graph/builder.py |
Incremental graph builder (sha256 change detection) |
graph/queries.py |
Repository map, symbol resolution, change impact, hot paths, dependency graph, doc suggestions |
graph/dataflow.py |
Intra- and cross-function dataflow and taint analysis |
graph/git_analysis.py |
Git blame, churn, change coupling analysis |
Adding a Language
pip install tree-sitter-LANGand add topyproject.toml- Copy
src/codetree/languages/_template.pytolanguages/yourlang.py - Implement the abstract methods
- Register extensions in
registry.py - Add tests
Development
git clone https://github.com/ThinkyMiner/codeTree.git
cd codeTree
python -m venv .venv
source .venv/bin/activate
pip install -e .
pip install pytest
# Run all tests (~1200 tests, ~20s)
pytest
# Run a single test file
pytest tests/languages/test_python.py -v
Contributing
Contributions welcome! See CONTRIBUTING.md for setup instructions and guidelines.
Preguntas sobre codeTree MCP
¿Cómo reduce codeTree el uso de tokens?
Permite que los agentes soliciten esqueletos de código (clases, métodos y docstrings) en lugar de leer archivos completos, lo que puede resultar en una reducción de hasta 25 veces en los tokens consumidos.
¿Requiere una base de datos vectorial o un modelo de embeddings?
No, no requiere una base de datos vectorial, un modelo de embeddings ni ninguna configuración adicional.