Proporciona a tu asistente de programación por IA acceso instantáneo e inteligente a la estructura, dependencias y relaciones de toda tu base de código sin transmitir ningún código fuente. Constellation ofrece inteligencia de código como servicio para herramientas de asistencia de programación por IA.
Añade el servidor MCP de Constellation a la configuración a nivel de proyecto de tu asistente de IA (o a nivel de sistema si tu herramienta no admite configuración a nivel de proyecto):
{
"mcpServers": {
"constellation": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@constellationdev/mcp@latest"],
"env": {
"CONSTELLATION_ACCESS_KEY": "${CONSTELLATION_ACCESS_KEY}"
}
}
}
}[!NOTE] El ejemplo anterior es un formato genérico para el archivo
.mcp.jsonutilizado por algunas herramientas como VSCode y Claude Code.En lugar de configurar directamente el servidor MCP, se recomienda instalar y utilizar los plugins oficiales de Constellation para obtener un rendimiento y comportamiento óptimos.
Para obtener información sobre cómo configurar otros asistentes de IA, consulta la documentación de instalación del servidor MCP.
Para obtener más instrucciones sobre la autenticación, la configuración del proyecto y la configuración, consulta la documentación oficial.
Related MCP server: NOMIK
%%{init: {'theme': 'dark', 'themeVariables': { 'primaryColor': '#4A90E2', 'primaryTextColor': '#EEEEEE', 'primaryBorderColor': '#2B2C34', 'lineColor': '#4A90E2', 'secondaryColor': '#1F1F28', 'tertiaryColor': '#0B0C10', 'edgeLabelBackground': '#1F1F28' }}}%%
flowchart LR
subgraph local["💻 Your Environment"]
direction TB
code["📂 Source Code"]
cli["⚙️ Constellation CLI"]
ai["🤖 AI Coding Assistant"]
mcp["🧩 Constellation MCP"]
code --> cli
end
subgraph cloud["✨ Constellation Service"]
direction TB
api["🔌 API"]
graphdb[("🧠 Knowledge Graph")]
api <--> graphdb
end
cli a1@-->|"Metadata Upload"| api
ai <-->|"Tool Calls"| mcp
mcp a2@<-->|"Queries"| api
a1@{ animation: fast }
a2@{ animation: fast }
style local fill:#1F1F28
style cloud fill:#1F1F28,stroke:#4A90E2
style cli stroke:#4A90E2
style mcp stroke:#4A90E2
style api stroke:#4A90E2
style graphdb stroke:#4A90E2Analizar y procesar: La herramienta CLI analiza el código fuente en tu entorno, extrayendo metadatos estructurales (funciones, clases, variables, importaciones, llamadas, referencias, etc.)
Subir: Solo los metadatos se envían de forma segura a Constellation, nunca el código fuente sin procesar
Consultar: Los asistentes de IA utilizan la herramienta MCP de Constellation para enviar consultas complejas y obtener respuestas rápidas derivadas del grafo de conocimiento
Encuentra la documentación completa y detallada en docs.constellationdev.io/mcp/
Instalación y configuración - Configuración para Claude Code, Cursor, GitHub Copilot y más
Referencia de herramientas - API de modo de código y métodos disponibles
Solución de problemas - Problemas comunes y soluciones
Sin transmisión de código fuente - Solo metadatos y relaciones
Control de acceso - Se requieren claves API para todas las solicitudes
Aislamiento de ramas - Cada rama de git mantiene una inteligencia de código discreta
Para obtener información completa sobre privacidad y seguridad, consulta la documentación oficial de Privacidad y Seguridad.
Documentación: docs.constellationdev.io
Informar de problemas: GitHub Issues
AGPL-3.0 - Consulta LICENSE para más detalles.
Copyright © 2026 ShiftinBits Inc.
DECISION RULE: Structure questions → this tool. Text search → Grep.
Before using Grep, ask: Is this a STRUCTURE question (definitions, callers, impact) or a TEXT question (strings, config)?
QUICK START: return await api.searchSymbols({query: "AuthService"}) — simple queries are one-liners.
Run api.listMethods() for full API reference with signatures and descriptions.
Run api.help("methodName") for inline TypeScript type definitions — no resource reads needed.
Compose: const [impact, deps] = await Promise.all([api.impactAnalysis({symbolId}), api.getDependents({filePath})]);
WHY THIS TOOL: Graph-backed intelligence finds indirect relationships, transitive dependencies, and breaking change risks that text search cannot detect.
"What uses X?" disambiguation: getDependents (file imports) vs getCallGraph (call chain) vs traceSymbolUsage (all usages).
USE IMMEDIATELY WHEN: • BEFORE using Edit on a function/class → run impactAnalysis({symbolId}) first • BEFORE exploring an unfamiliar codebase → run getArchitectureOverview() • BEFORE refactoring → trace getDependencies + getDependents for blast radius • Running 3+ Grep calls for structure? STOP → use code_intel instead
TOP 5 QUESTIONS (query is case-insensitive substring match): • "Where is X defined?" / "Find function Y" → searchSymbols({query}) • "What calls X?" / "What imports this?" → getDependents({filePath}) or getCallGraph({symbolId}) • "What does X depend on?" → getDependencies({filePath}) • "Safe to modify X?" / "Blast radius?" → impactAnalysis({symbolId}) • "Find dead code" / "Unused exports?" → findOrphanedCode() • "Complex functions?" / "Refactoring targets?" → searchSymbols results include complexity.cyclomaticComplexity + complexityRisk per function
NOT FOR: literal string search, log messages, config values, or reading source code. Use Grep/Glob/Read for those.
Supports TypeScript, JavaScript, Python, and more — run api.getCapabilities() to check your project.
File-path-scoped methods (getDependencies, getDependents, getCallGraph, traceSymbolUsage, impactAnalysis) reject calls whose filePath extension is not in the project's configured languages with UNSUPPORTED_LANGUAGE — check api.getCapabilities() first.
WRONG TOOL SIGNAL: If you've run 3+ Grep calls for structure (callers, dependencies, impact), STOP and use code_intel instead. Typical workflow: code_intel to find (results include source snippets) → Edit to modify
Sandbox limits: 50 api.* calls per execution, 128 MB memory, 100 KB max code size, limit max 100 on any method with a limit param. Pure JS only — no require/import/fs/net/process (see constellation://docs/guide for full restrictions).
IMPORTANT: The cwd parameter is required — always set it to the target project directory path.
| Name | Required | Description | Default |
|---|---|---|---|
| cwd | Yes | Absolute path to the project directory being queried. Used to locate the correct constellation.json by finding the git repository root. Set this to the root of the repository or workspace folder you are working in. | |
| code | Yes | JavaScript code to execute. Can use top-level await. Available API methods: searchSymbols, getSymbolDetails, getDependencies, getDependents, findCircularDependencies, traceSymbolUsage, getCallGraph, impactAnalysis, findOrphanedCode, getArchitectureOverview | |
| timeout | No | Optional execution-time override in milliseconds. When omitted, the sandbox derives the timeout from the static complexity of your code (heavier api.* methods raise the budget) and clamps the result to [1000, 60000]. The breakdown is returned in the response so you can see what was applied. Explicit values still win and are clamped to the same range. |
| Name | Required | Description |
|---|---|---|
| logs | No | |
| time | No | |
| error | No | |
| result | No | |
| success | Yes | |
| asOfCommit | No | |
| lastIndexedAt | No | |
| resultContext | No | |
| timeoutBreakdown | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral context: sandbox limits (50 api calls, 128 MB memory, 100 KB code), timeout derivation, UNSUPPORTED_LANGUAGE rejection, and requirement for cwd to locate constellation.json. These reveal important constraints and behaviors beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is thorough but verbose. It uses headings, bullet points, and code examples effectively, and front-loads with the decision rule. However, some sections (e.g., sandbox limits, top 5 questions) are longer than necessary. A slightly more concise version would maintain completeness while improving scanability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (multiple API methods, sandbox restrictions, dynamic timeouts, language support), the description covers all essential aspects: when to use, how to compose calls, error conditions (UNSUPPORTED_LANGUAGE), and limitations. Output schema exists, so return value documentation is not needed. Complete for its context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but description adds meaning: for 'code', it lists available API methods; for 'timeout', explains dynamic derivation and clamping; for 'cwd', explains its role in locating configuration. This enriches the agent's understanding beyond the schema, though the schema already covers parameter types and descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool is for structure questions (definitions, callers, impact) versus text search (Grep). It uses specific verbs like 'find', 'trace', 'search' and explicitly distinguishes from sibling tools (Grep, Glob, Read) even though no siblings are listed. The 'WRONG TOOL SIGNAL' and 'NOT FOR' sections reinforce purpose clarity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Excellent guidelines: 'DECISION RULE' distinguishes structure vs text; 'USE IMMEDIATELY WHEN' lists specific scenarios before editing, exploring, refactoring; 'TOP 5 QUESTIONS' maps common intents to methods; 'NOT FOR' lists exclusions. Also provides workflow examples and wrong-tool signals.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.2.4code_intel2 fields changedOutput schema / properties / timeoutBreakdown / properties / coldStartGraceMsAdded value: +{
+ "type": "number"
+}Output schema / properties / timeoutBreakdown / requiredPrevious value: -[
- "baseMs",
- "calls",
- "parallelismFactor",
- "estimatedMs",
- "appliedMs",
- "warnings"
-]New value: +[
+ "baseMs",
+ "calls",
+ "parallelismFactor",
+ "estimatedMs",
+ "coldStartGraceMs",
+ "appliedMs",
+ "warnings"
+]v1.2.1code_intelv1.2.0code_intelScored across 1 tool
With only one tool, there is no ambiguity; the tool's purpose is clearly defined and distinct from any other.
A single tool name ensures perfect naming consistency; there are no naming conflicts or inconsistencies.
The server attempts to cover a broad range of code intelligence operations (symbol search, dependency analysis, impact analysis, etc.) but condenses them into a single tool, which is insufficient for discoverability and typical MCP expectations.
The tool's API covers many code intelligence operations (symbols, dependencies, impact, dead code), with minor gaps like source reading explicitly delegated elsewhere, making it fairly complete for its stated purpose.
Code intelligence platform for AI agents. 20 tools for architecture, security & impact analysis.
Codebase intelligence for AI agents — dead code, blast radius, ownership.
Code intelligence for coding agents: semantic, AST, graph, and full-text search. 279+ languages.
Codebase intelligence for agents: 152 structured artifacts across 21 programs, one call.
