Click on "Install 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., "@memoria-codigo-local Where is SafeMarkdown defined?"
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.
Servidor MCP mínimo para indexar, solo en memoria, los símbolos exportados de un proyecto TypeScript/React. Permite a un agente localizar definiciones, referencias, relaciones y estructura sin abrir ni recorrer repetidamente todo el repositorio. Incluye también un panel visual local y opcional.
Este proyecto existe como alternativa auditable a un MCP de terceros que motivó preocupación por incluir comportamiento de descarga, red y procesos hijo no acorde con sus garantías documentadas. Aquí no hay llamadas de red salientes, telemetría, actualizador, binarios, base de datos, scripts de instalación ni procesos hijo: se instala con npm install y se ejecuta con node.
No todas las herramientas ahorran lo mismo, y el ahorro depende del tamaño del proyecto indexado. Esto es lo que se ha comprobado de verdad, no una promesa genérica:
buscar_referencias es más preciso que grep. Al basarse en el árbol de sintaxis (ts-morph), no en texto, no devuelve como resultado un comentario que menciona el nombre o una variable distinta que se llama igual por coincidencia. Evita la ronda de "espera, eso no es un uso real" que sí aparece buscando por texto.
trazar_camino resuelve en una llamada lo que a mano son varias rondas de búsqueda encadenada. Rastrear "qué depende de qué depende de qué" a través de varios saltos, buscando y leyendo cada eslabón, es exactamente el tipo de tarea que se vuelve lenta y cara a mano y barata con el grafo ya construido.
resumen_arquitectura da una orientación inicial rápida en un proyecto que no se conoce, en vez de varias exploraciones de carpetas y ficheros para hacerse una idea de la estructura.
El ahorro crece con el tamaño del proyecto y con cuántas veces se repite este tipo de búsqueda en una sesión, no es un número fijo. En un proyecto pequeño la diferencia frente a buscar a mano es modesta; en un árbol grande, o reutilizando este mismo índice entre varios proyectos, el coste de haberlo construido una vez se amortiza mucho mejor.
Related MCP server: code-dev-intel
Node.js 20 o posterior.
Una ruta local que contenga ficheros .ts o .tsx.
npm install
npm run build
node dist/servidor.js /ruta/al/proyecto-o-srcTambién se puede indicar la raíz con la variable RAIZ_PROYECTO. El servidor escribe exclusivamente el protocolo MCP en stdout; los errores de arranque van a stderr.
El índice se reconstruye al arrancar. Usa el tsconfig.json y .gitignore más cercanos hacia arriba para comprender aliases y exclusiones, pero solo indexa declaraciones ubicadas bajo la raíz indicada. Además excluye siempre .git, node_modules, dist, build y coverage.
Estas herramientas no se invocan escribiendo JSON a mano. MCP es un
protocolo entre un agente (Claude Code, u otro cliente MCP) y este
servidor: tú hablas en lenguaje normal con el agente, y es el agente
quien decide llamar a una herramienta y con qué argumentos, sin que tú
veas ese paso intermedio. Por ejemplo, si le preguntas a Claude Code
"¿dónde está definido SafeMarkdown?" estando este servidor
registrado, el agente llama por su cuenta a buscar_simbolo con
{ "nombre": "SafeMarkdown" } y te devuelve la respuesta ya traducida a
una frase. El bloque JSON de cada herramienta de abajo es la forma de
esos argumentos, documentada para quien programe o audite el
servidor — no algo que tengas que teclear tú.
Si quieres probar una herramienta directamente, sin ningún agente de
por medio, existe el Inspector oficial de MCP: abre un panel web con
un formulario por cada herramienta, para llamarla a mano y ver la
respuesta real. Se descarga por npx la primera vez que se ejecuta —
es la única vez que este proyecto toca la red, y es una acción tuya
explícita, no algo que el servidor haga solo.
npm run build
npx @modelcontextprotocol/inspector node dist/servidor.js /ruta/al/proyectoVerificado tal cual (con Node 22.12): imprime en la terminal una URL
del tipo http://localhost:6274/?MCP_PROXY_AUTH_TOKEN=... y abre esa
página en el navegador automáticamente. Ese token en la URL es normal
— es la autenticación local del propio Inspector contra su servidor
proxy, no una fuga de nada. Elige una herramienta de la lista de la
izquierda, rellena sus campos (o déjalos vacíos si no tiene, como
reindexar) y pulsa "Run" — verás la respuesta JSON tal cual la
generaría este servidor. Es la forma más rápida de entender qué hace
cada una antes de registrarlo en Claude Code.
Existe una v2 del Inspector (npx @modelcontextprotocol/inspector@latest)
con más funciones, pero pide Node ≥ 22.19; con versiones de Node
anteriores arranca igualmente con un aviso de compatibilidad. Si tu
Node es más antiguo, usa el comando sin @latest — resuelve a la v1,
que solo recibe parches de seguridad pero funciona sin avisos.
Referencia de las diez herramientas: qué hace cada una y la forma exacta de sus argumentos. Las respuestas son JSON dentro del contenido textual MCP. Las rutas siempre son relativas a la raíz indexada.
buscar_simboloEncuentra todas las definiciones exportadas con el nombre exacto. Los nombres duplicados producen varios resultados.
Argumentos:
{ "nombre": "SafeMarkdown" }buscar_textoBusca palabras en el nombre del símbolo —separando camelCase y PascalCase— y en la primera línea de su JSDoc. Tolera erratas pequeñas mediante distancia de Levenshtein, pero no entiende sinónimos ni relaciones entre conceptos.
Argumentos:
{ "consulta": "markdown seguro" }buscar_referenciasDevuelve cada línea donde el símbolo se importa o usa, ordenada por fichero y línea.
Argumentos:
{ "nombre": "useAuth" }listar_exportsLista lo exportado directamente o reexportado por el fichero indicado.
Argumentos:
{ "ruta_relativa": "src/components/content/SafeMarkdown.tsx" }reindexarFuerza una reconstrucción completa tras cambiar el código, sin reiniciar el servidor. No necesita argumentos — en el Inspector, se llama con el formulario vacío.
resumen_arquitecturaDevuelve el árbol de carpetas que contienen ficheros indexados. Cada carpeta incluye el total de símbolos exportados de su subárbol y su agrupación por tipo. No necesita argumentos.
obtener_fragmentoDevuelve literalmente un intervalo de líneas de un fichero indexado. Solo acepta rutas relativas, no permite salir de la raíz y limita cada respuesta a 200 líneas.
Argumentos:
{ "ruta_relativa": "src/indexador.ts", "linea_inicio": 1, "linea_fin": 40 }cobertura_indexadoCuenta todos los ficheros .ts y .tsx bajo la raíz, indica cuántos entraron en el índice y enumera cada exclusión con su motivo: .gitignore, directorio excluido, fichero .d.ts u otra causa explícita. No necesita argumentos.
trazar_caminoBusca en anchura un camino de referencias de hasta 6 saltos. Una arista A → B significa que el símbolo exportado B referencia a A; por tanto, el camino avanza desde un símbolo hacia los símbolos que dependen de él. Si no existe un camino, la respuesta lo dice expresamente y devuelve encontrado: false.
Argumentos:
{ "desde": "useAuth", "hasta": "App" }buscar_por_tipoLista todos los símbolos de uno de estos tipos: función, componente React, clase, interfaz, tipo, constante o enum.
Argumentos:
{ "tipo": "componente React" }Un símbolo o fichero inexistente devuelve un error MCP legible, no una excepción sin controlar. Un símbolo existente sin referencias devuelve correctamente una lista vacía.
El panel es un proceso separado del servidor MCP. Tras compilar, se puede lanzar explícitamente sobre la raíz completa de un proyecto:
npm run dashboard -- /ruta/al/proyectoReindexa al arrancar, sirve la página en http://127.0.0.1:8420 y publica los datos en GET /grafo con la forma { "nodos": [...], "aristas": [...] }. El puerto se puede cambiar con un segundo argumento o con PUERTO_DASHBOARD:
npm run dashboard -- /ruta/al/proyecto 9123
PUERTO_DASHBOARD=9123 RAIZ_PROYECTO=/ruta/al/proyecto npm run dashboardEl servidor usa node:http y escucha exclusivamente en 127.0.0.1, nunca en 0.0.0.0. La página, el CSS y el JavaScript son locales y no cargan fuentes, scripts, imágenes ni bibliotecas desde CDN o desde Internet. Escuchar en localhost para que el navegador del propio usuario abra un panel solicitado explícitamente no contradice la regla de cero llamadas salientes: escuchar localmente y llamar hacia fuera son categorías distintas, y el panel nunca envía datos a otro servidor.
La visualización está escrita con Canvas y JavaScript vainilla. La disposición aplica en las tres dimensiones repulsión entre nodos, atracción en cada referencia, gravedad suave hacia el centro y amortiguación. Una cámara orbital y una proyección en perspectiva convierten ese espacio 3D en la imagen 2D; el tamaño de los nodos representa su número de conexiones y la profundidad modifica tamaño, brillo y aristas.
Arrastrar con el botón izquierdo sobre el fondo rota la cámara; la rueda hace zoom hacia el punto bajo el cursor; el botón derecho, o Mayús más arrastre, desplaza la vista. El botón Restablecer vista recupera la orientación, el zoom y el desplazamiento iniciales. Al pasar el ratón o hacer clic en un nodo se muestran nombre, tipo, fichero, línea y métricas de conexiones contra su posición proyectada actual.
Añade este bloque a la configuración MCP de Claude Code. Las dos rutas son absolutas porque Claude Code puede iniciar el servidor desde cualquier directorio:
{
"mcpServers": {
"memoria-codigo-local": {
"command": "node",
"args": [
"/Users/pedroleridanieto/Desktop/Proyectos IA/codebase-memory-local/dist/servidor.js",
"/Users/pedroleridanieto/Desktop/Proyectos IA/tech-study-tracker"
]
}
}
}Si solo interesa el código fuente, el segundo argumento puede terminar en /src; las rutas devueltas serán entonces relativas a src.
src/indexador.ts: recorrido local, análisis con ts-morph e índice en memoria.
src/servidor.ts: adaptación del índice a diez herramientas MCP por stdio.
src/dashboard.ts: servidor HTTP local separado y visualización Canvas autocontenida.
src/indexador.test.ts: proyecto sintético y aserciones exactas con node:test.
Las funciones o constantes exportadas cuyo nombre comienza en mayúscula y están en .tsx se clasifican como componentes React. Es una heurística pequeña y explícita; no intenta inferir el tipo de retorno.
Las referencias que caen en la misma línea se deduplican para que una línea de importación con varias apariciones no consuma resultados repetidos.
El grafo solo enlaza símbolos cuando la referencia está dentro de la declaración de otro símbolo exportado. Un import a nivel de fichero continúa apareciendo en buscar_referencias, pero no se inventa un nodo de fichero para representarlo.
npm run build
npm testLos tests fabrican proyectos temporales con exports e imports conocidos y comprueban valores completos de definiciones, referencias, arquitectura, fragmentos, cobertura, caminos y filtros por tipo.
Lista símbolos exportados de un tipo concreto sin usar un lenguaje de consulta de grafos.
| Name | Required | Description | Default |
|---|---|---|---|
| tipo | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It only states the listing action and the no-graph-query constraint, without disclosing output format, pagination, or any side effects. 'Lista' implies a read-only operation, but that is not explicit.
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 one short sentence with no filler. It front-loads the action and scope immediately, making it easy for an agent to parse.
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?
The tool is simple, with one enum parameter and no output schema, so the description is not grossly incomplete. However, with overlapping siblings and no behavioral annotations, an agent would benefit from knowing the return format and when to choose this over listar_exports or buscar_simbolo.
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?
The schema has one required parameter 'tipo' with 0% description coverage, so the description must compensate. It references 'un tipo concreto' but does not enumerate or explain the accepted values, leaving the enum to do the semantic work.
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 uses the verb 'Lista' and names the resource 'símbolos exportados', scoped by 'tipo concreto'. It is clear and specific, but it does not explicitly distinguish itself from siblings like 'listar_exports' or 'buscar_simbolo'.
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?
The phrase 'sin usar un lenguaje de consulta de grafos' implies a simpler alternative to graph-query approaches, but no sibling tool is named and no explicit when-to-use or when-not-to-use conditions are given. Overlapping siblings make this gap noticeable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Lista los lugares donde un símbolo exportado se importa o se usa.
| Name | Required | Description | Default |
|---|---|---|---|
| nombre | Yes | Nombre exacto del símbolo |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It communicates that the operation is a read-only listing and constrains it to imported/used locations of an exported symbol. Still, it does not disclose the output shape, whether an index must be up to date, or how unknown/non-exported symbols are handled.
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 a single front-loaded sentence with no filler, which is appropriately concise for a simple one-parameter query tool. It loses a point only because the brevity leaves no room for usage caveats or output expectations, though those are partially captured by other dimensions.
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?
For a one-parameter read-only search tool, the description is adequate: it states the input type (exact exported symbol name) and a high-level result (a list of places). However, there is no output schema, and the description does not clarify what a 'place' is (file path, line number, snippet) or whether the index must be current, so completeness is only partial.
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?
The schema already documents 'nombre' as the exact symbol name with 100% coverage. The description adds meaningful context by specifying that the symbol must be exported and that matches are places where it is imported or used, helping the agent choose a valid argument.
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 uses a specific verb ('Lista') and a precise object ('los lugares donde un símbolo exportado se importa o se usa'), clearly identifying the tool as a reference/usage finder. This semantically distinguishes it from siblings like buscar_simbolo (definition lookup) or buscar_texto (raw text search), even without naming them explicitly.
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?
The description implies the use case: find all import/use locations of an exported symbol. However, it does not explicitly state when to choose this tool over buscar_simbolo, trazar_camino, or listar_exports, nor does it give exclusion criteria or mention any needed preconditions beyond the symbol being exported.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Encuentra dónde se define un símbolo exportado TypeScript/React.
| Name | Required | Description | Default |
|---|---|---|---|
| nombre | Yes | Nombre exacto del símbolo |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure, but it only states the tool's purpose. It does not reveal whether it returns a file path, line number, multiple locations, or what happens for missing symbols, leaving the agent to guess at the tool's runtime behavior.
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 a single, front-loaded sentence that wastes no words. It clearly conveys the operation without over-explaining.
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?
For a one-parameter, no-output-schema tool, the description is adequate but lacks detail about the return format and edge cases. It doesn't explain the result structure (e.g., file path, line number), which an agent would need to correctly consume the output, but the simplicity keeps this from being a major gap.
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?
The input schema already documents the single parameter 'nombre' as the exact symbol name (100% coverage). The description adds context by specifying the symbol is an exported TypeScript/React symbol, which clarifies the parameter's domain, but this is nominal added value beyond the schema.
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 a specific action and resource: it finds where an exported TypeScript/React symbol is defined. This distinguishes it from sibling tools like buscar_texto (text search) and buscar_referencias (references) by its focus on definition location, though it doesn't explicitly name those alternatives.
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?
The intended use is implied by the description: use it when you need to locate the definition of an exported symbol. However, there is no explicit guidance about when not to use it or which sibling tool to choose instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Busca símbolos exportados por palabras del nombre o del JSDoc y tolera erratas pequeñas; no es búsqueda semántica.
| Name | Required | Description | Default |
|---|---|---|---|
| consulta | Yes | Texto o palabras que buscar |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No hay anotaciones, así que la descripción asume toda la carga. Informa sobre el alcance (símbolos exportados), el modo de coincidencia (palabras del nombre o JSDoc), la tolerancia a erratas y una limitación clave (no es semántica). No detalla formato de salida ni estado de indexación, pero el comportamiento esencial del buscador queda bien delimitado.
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?
Es una única frase compacta y bien organizada: primero la acción y el objeto, luego la tolerancia a erratas y finalmente la exclusión de búsqueda semántica. No hay relleno ni información redundante con el esquema.
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?
Para una herramienta con un solo parámetro, sin esquema de salida y sin anotaciones, la descripción es suficiente para invocarla correctamente: define qué se busca, sobre qué campos y con qué tipo de coincidencia. Sería más completa si aclarara el comportamiento con múltiples palabras, mayúsculas o la dependencia del índice, pero estos son detalles secundarios.
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?
El esquema ya cubre al 100% el parámetro 'consulta' con 'Texto o palabras que buscar'. La descripción añade significado extra al explicar contra qué se compara ese texto: palabras del nombre o del JSDoc, y que admite erratas pequeñas. Eso va más allá de la definición del esquema.
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?
La descripción comienza con un verbo concreto ('Busca'), especifica el recurso ('símbolos exportados') y define el criterio de búsqueda ('por palabras del nombre o del JSDoc'). Además, la aclaración 'no es búsqueda semántica' ayuda a distinguirla de otras herramientas de búsqueda del mismo grupo.
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?
Queda claro que la herramienta sirve para búsquedas textuales aproximadas con tolerancia a erratas y que no debe usarse para búsqueda semántica. Sin embargo, no menciona explícitamente alternativas como buscar_simbolo o cuándo preferirlas, por lo que no hay un enrutamiento completo entre herramientas hermanas.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Compara todos los ficheros .ts/.tsx bajo la raíz con los indexados y explica cada exclusión.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the behavioral burden. It clearly conveys a read-only comparison and explains exclusions, but it does not disclose whether an index must already exist, whether the comparison triggers any side effects, or what 'exclusion' precisely means. This is adequate but not rich behavioral context.
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 a single, efficient sentence that front-loads the core action ('Compara todos los ficheros .ts/.tsx bajo la raíz con los indexados') and immediately states the value-add ('explica cada exclusión'). No wasted words.
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?
For a zero-parameter tool, the description is mostly adequate: it explains what is compared and what the output will explain. However, without an output schema or annotations, it leaves gaps around output format, the meaning of 'exclusion', and whether an index must already exist before calling. These are clear but not critical omissions for such a simple tool.
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?
The tool has zero parameters, so the schema provides all necessary parameter information. The description adds meaning by defining the tool's operation, and there are no parameter semantics that need further explanation. Baseline 4 is appropriate.
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 states a specific verb ('Compara'), a clear resource (all .ts/.tsx files under the root), and an explicit outcome (explains each exclusion). This clearly distinguishes the tool from siblings like reindexar, which would rebuild the index rather than audit it.
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?
The intended use is implied: the agent should call this when there is a need to compare indexed files against the actual file tree and understand exclusions. However, the description does not explicitly state when to use this tool instead of alternatives, nor does it mention any prerequisites such as having an existing index.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Lista los símbolos exportados por un fichero concreto de la raíz indexada.
| Name | Required | Description | Default |
|---|---|---|---|
| ruta_relativa | Yes | Ruta relativa, por ejemplo src/api.ts |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the core function and does not mention that it works only on indexed files, what happens if the path is invalid, whether it requires a recent reindex, or what the output looks like.
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 a single efficient sentence with no wasted words, begins with the verb, and clearly states the operation and scope. It is appropriately front-loaded.
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?
For a one-parameter tool with no output schema, the description is adequate but sparse. It does not specify return format, error behavior, or constraints on the path. Given the minimal complexity, it mostly suffices, but leaves edge cases unmanaged.
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?
The input schema fully documents ruta_relativa with an example, so the baseline is 3. The description adds the notion of 'fichero concreto' but no additional semantic detail about the parameter beyond what the schema already provides.
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 operation: it lists exported symbols from a specific file in the indexed root, using the verb 'Lista' and a concrete resource. It does not explicitly differentiate from sibling tools like buscar_simbolo, but the scoping to 'un fichero concreto' makes its purpose reasonably distinct.
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?
There is no guidance on when to use this tool versus alternatives, and no mention of sibling tools or exclusions. The usage is only implied by the description's purpose, which is not enough for an agent deciding between listar_exports and tools like buscar_simbolo or buscar_referencias.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Devuelve líneas literales de un fichero indexado, con un máximo de 200 líneas.
| Name | Required | Description | Default |
|---|---|---|---|
| linea_fin | Yes | Última línea, incluida | |
| linea_inicio | Yes | Primera línea, empezando en 1 | |
| ruta_relativa | Yes | Ruta relativa dentro de la raíz indexada |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the key 200-line limit and the 'literal lines' behavior, which is useful, but it does not explain what happens when the requested range exceeds the file or the cap, nor any error behavior.
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?
A single, front-loaded sentence conveys the action, object, and a critical constraint with no wasted words. Every element earns its place.
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?
The schema fully documents parameters, but there is no output schema and no annotations. The description covers the basic purpose and line limit, yet it omits details about return formatting, handling of oversized ranges, or errors, leaving the agent to infer these behaviors.
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%: all three parameters have detailed descriptions in the schema (e.g., inclusivity of line_fin, 1-based line_inicio). The description adds no additional parameter meaning, so baseline 3 is appropriate.
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 uses a specific verb ('Devuelve') and resource ('líneas literales de un fichero indexado'), making the core function clear. It is reasonably distinct from sibling search/reference tools, though it does not explicitly name a differentiating sibling.
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?
No guidance is given about when to use this tool versus the sibling tools. There are no explicit alternatives, exclusions, or contextual conditions beyond the inherent implication that it retrieves literal file lines.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Reconstruye explícitamente el índice en memoria tras editar el proyecto.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the behavioral burden. It does disclose that the rebuild is explicit and confined to the in-memory index, which is meaningful context. However, it does not mention side effects, idempotency, duration, or whether this is required before using sibling search tools.
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 a single sentence with no filler. It front-loads the action and includes only the necessary scope ('en memoria') and timing ('tras editar el proyecto').
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?
For a zero-parameter maintenance command with no output schema, the description covers the essential facts: what is rebuilt, where it is rebuilt, and when to call it. Missing return/status details are a minor gap given the tool's simplicity and lack of structured output.
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?
The input schema has zero properties and 100% description coverage, so there are no parameters to document. The description adds no parameter-level detail, but none is needed; the zero-parameter baseline applies.
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 uses a specific verb ('Reconstruye') and a specific resource ('el índice en memoria'), and adds a clear trigger ('tras editar el proyecto'). It does not explicitly name or contrast a sibling tool, so differentiation relies on the action itself rather than a direct comparison.
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?
The description gives a clear usage context: run it after editing the project. It does not state when-not-to-use it or name alternatives, but the trigger condition is concrete enough for an agent to understand when this tool is relevant.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Resume el árbol de carpetas indexadas y sus símbolos exportados, agrupados por tipo.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the summarizing action; it does not mention that this is a read-only operation, whether it depends on the index being built, or what the result looks like beyond grouping by type.
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 a single, tightly written sentence that puts the action first and includes the key scope and grouping detail. There is no filler, redundant phrasing, or irrelevant background.
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?
For a zero-parameter read-only overview tool, the description is mostly complete: it states the input domain, the grouping behavior, and the nature of the result. It falls slightly short by not mentioning prerequisites such as requiring an existing index or clarifying the exact output shape, but no output schema exists to fill that gap.
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?
The input schema has zero properties, so there are no parameters needing clarification. The baseline of 4 applies because the parameter surface is empty and the description does not need to compensate for missing parameter documentation.
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 uses a specific verb ('Resume') and identifies a concrete resource: the indexed folder tree plus exported symbols grouped by type. This grouping and the mention of the folder tree distinguish it from siblings like listar_exports or cobertura_indexado without needing to inspect other schemas.
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?
No explicit guidance is given about when to prefer this tool over siblings such as listar_exports or buscar_por_tipo. The intended usage is only implied by the word 'Resume', leaving the agent to infer when a high-level architecture summary is the right choice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Busca en anchura un camino entre símbolos a través de sus referencias, hasta 6 saltos.
| Name | Required | Description | Default |
|---|---|---|---|
| desde | Yes | Símbolo exportado inicial | |
| hasta | Yes | Símbolo exportado final |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It discloses the algorithm ('en anchura' / breadth-first), the traversal relation ('a través de sus referencias'), and the depth limit ('hasta 6 saltos'). However, it does not disclose the return format or behavior when no path exists within the hop limit.
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?
A single, focused sentence that front-loads the action ('Busca en anchura') and packs all key constraints (reference traversal, 6-hop limit) with no filler. Every word contributes to the definition.
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?
The absence of an output schema makes the description responsible for specifying return values, but it does not state whether the tool returns an ordered path, a boolean, or null when no path exists. The inputs and search algorithm are clear, yet the missing output semantics is a significant gap for correct result interpretation.
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%: 'desde' and 'hasta' are already documented as initial and final exported symbols. The description adds relational meaning by clarifying that the tool seeks a path through references between these two endpoints, which the schema parameter descriptions alone do not convey.
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 states a specific operation: breadth-first search for a path between symbols through their references, up to 6 hops. This clearly distinguishes it from sibling search tools like buscar_referencias or buscar_simbolo, which handle single-symbol or reference lookups rather than endpoint-to-endpoint path tracing.
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?
The description is a functional statement and does not explicitly say when to use this tool instead of alternatives such as buscar_referencias or buscar_simbolo. The intended use case (finding a connection between two exported symbols) is implied by the semantics but no exclusions or alternative-selection guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool has a specific role: exact symbol lookup, fuzzy text search, references, type listing, and path traversal are conceptually distinct. The only mild ambiguity is between buscar_simbolo and buscar_texto, since both return exported symbols, though one is exact and the other is word-based.
Most tools follow a clear Spanish verb_noun pattern, especially the buscar_* family. A few names are noun phrases (resumen_arquitectura, cobertura_indexado) or bare verbs (reindexar), so the pattern is not perfectly uniform, but it remains readable and predictable.
Ten tools is a well-scoped size for a local TypeScript/React symbol indexing server. Each tool covers a distinct operation in the indexing/querying workflow without redundancy.
The set covers indexing (reindexar), index health (cobertura_indexado), export enumeration (listar_exports, resumen_arquitectura), symbol lookup (buscar_simbolo), text search (buscar_texto), references (buscar_referencias), type queries (buscar_por_tipo), path analysis (trazar_camino), and source retrieval (obtener_fragmento). This is a complete exploration surface for the stated domain.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
An MCP server that gives your AI access to the source code and docs of all public github repos
The Cortex MCP server provides read-only access to real-time engineering context from the Cortex developer portal, allowing AI coding assistants to answer natural language questions about your organization's catalog (microservices, libraries, domains, teams, infrastructure), scorecards (engineering standards and best practices), initiatives (goals and deadlines), and Engineering Intelligence metrics. It includes tools for querying documentation, tracking personal entities, and accessing AI-assisted insights across the entire Cortex ecosystem.
Agent-native MCP server over the public saagarpatel.dev corpus. Read-only, stateless.
Capability registry for the agentic economy. Semantic search over verified MCP server listings.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/pedroleni/code-memory-MCP'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
