Un servidor MCP para utilizar los ricos datos de dependencia de software de Codelogic en su asistente de programación de IA.
El servidor implementa dos herramientas:
codelogic-method-impact : extrae una evaluación de impacto de las API del servidor CodeLogic para su código.
Toma el "método" dado en el que estás trabajando y su "clase" asociada.
codelogic-database-impact : analiza los impactos entre el código y las entidades de la base de datos.
Toma el tipo de entidad de la base de datos (columna, tabla o vista) y su nombre.
El servidor MCP depende de Astral UV para funcionar, instálelo
Related MCP server: NOMIK
Para configurar este servidor MCP en VS Code:
Primero, asegúrese de tener habilitado el modo de agente GitHub Copilot en VS Code.
Cree un archivo .vscode/mcp.json en su espacio de trabajo con la siguiente configuración:
{
"servers": {
"codelogic-mcp-server": {
"type": "stdio",
"command": "uvx",
"args": [
"codelogic-mcp-server@latest"
],
"env": {
"CODELOGIC_SERVER_HOST": "<url to the server e.g. https://myco.app.codelogic.com>",
"CODELOGIC_USERNAME": "<my username>",
"CODELOGIC_PASSWORD": "<my password>",
"CODELOGIC_WORKSPACE_NAME": "<my workspace>",
"CODELOGIC_DEBUG_MODE": "true"
}
}
}
}Nota: En algunos sistemas, es posible que deba usar la ruta completa del ejecutable uvx en lugar de solo "uvx". Por ejemplo:
/home/user/.local/bin/uvxen Linux/Mac oC:\Users\username\AppData\Local\astral\uvx.exeen Windows.
Alternativamente, puede ejecutar el comando MCP: Add Server desde la Paleta de comandos y proporcionar la información del servidor.
Para administrar sus servidores MCP, utilice el comando MCP: List Servers de la Paleta de comandos.
Una vez configurado, las herramientas del servidor estarán disponibles en el modo agente de Copilot. Puede activar o desactivar herramientas específicas según sea necesario haciendo clic en el botón Herramientas en la vista de chat en el modo agente.
Para utilizar las herramientas de Codelogic en modo agente, puede preguntar específicamente sobre los impactos del código o las relaciones de la base de datos, y el agente utilizará las herramientas adecuadas.
Configure Claude Desktop editando el archivo de configuración:
En MacOS: ~/Library/Application\ Support/Claude/claude_desktop_config.json
En Windows: %APPDATA%/Claude/claude_desktop_config.json
En Linux: ~/.config/Claude/claude_desktop_config.json
Agregue lo siguiente a su archivo de configuración:
"mcpServers": {
"codelogic-mcp-server": {
"command": "uvx",
"args": [
"codelogic-mcp-server@latest"
],
"env": {
"CODELOGIC_SERVER_HOST": "<url to the server e.g. https://myco.app.codelogic.com>",
"CODELOGIC_USERNAME": "<my username>",
"CODELOGIC_PASSWORD": "<my password>",
"CODELOGIC_WORKSPACE_NAME": "<my workspace>"
}
}
}Nota: En algunos sistemas, es posible que deba usar la ruta completa del ejecutable uvx en lugar de solo "uvx". Por ejemplo:
/home/user/.local/bin/uvxen Linux/Mac oC:\Users\username\AppData\Local\astral\uvx.exeen Windows.
Después de agregar la configuración, reinicie Claude Desktop para aplicar los cambios.
Para ejecutar este servidor MCP con Windsurf IDE :
Configurar Windsurf IDE :
Para configurar Windsurf IDE, debe crear o modificar el archivo de configuración ~/.codeium/windsurf/mcp_config.json .
Agregue la siguiente configuración a su archivo:
"mcpServers": {
"codelogic-mcp-server": {
"command": "uvx",
"args": [
"codelogic-mcp-server@latest"
],
"env": {
"CODELOGIC_SERVER_HOST": "<url to the server e.g. https://myco.app.codelogic.com>",
"CODELOGIC_USERNAME": "<my username>",
"CODELOGIC_PASSWORD": "<my password>",
"CODELOGIC_WORKSPACE_NAME": "<my workspace>"
}
}
}Nota: En algunos sistemas, es posible que deba usar la ruta completa del ejecutable uvx en lugar de solo "uvx". Por ejemplo:
/home/user/.local/bin/uvxen Linux/Mac oC:\Users\username\AppData\Local\astral\uvx.exeen Windows.
Después de agregar la configuración, reinicie Windsurf IDE o actualice las herramientas para aplicar los cambios.
Para configurar el servidor CodeLogic MCP en Cursor:
Configure el servidor MCP creando un archivo .cursor/mcp.json :
{
"mcpServers": {
"codelogic-mcp-server": {
"command": "uvx",
"args": [
"codelogic-mcp-server@latest"
],
"env": {
"CODELOGIC_SERVER_HOST": "<url to the server e.g. https://myco.app.codelogic.com>",
"CODELOGIC_USERNAME": "<my username>",
"CODELOGIC_PASSWORD": "<my password>",
"CODELOGIC_WORKSPACE_NAME": "<my workspace>",
"CODELOGIC_DEBUG_MODE": "true"
}
}
}
}Nota: En algunos sistemas, es posible que deba usar la ruta completa del ejecutable uvx en lugar de solo "uvx". Por ejemplo:
/home/user/.local/bin/uvxen Linux/Mac oC:\Users\username\AppData\Local\astral\uvx.exeen Windows.
Reinicie el cursor para aplicar los cambios.
Las herramientas del servidor CodeLogic MCP ahora estarán disponibles en su espacio de trabajo del Cursor.
Para ayudar al asistente de IA a usar las herramientas de CodeLogic eficazmente, puede agregar las siguientes instrucciones/reglas a la configuración de su cliente. Recomendamos personalizar estas instrucciones para que se ajusten a los estándares de codificación, las mejores prácticas y los requisitos de flujo de trabajo específicos de su equipo:
Cree un archivo .vscode/copilot-instructions.md con el siguiente contenido:
# CodeLogic MCP Server Instructions
When modifying existing code methods:
- Use codelogic-method-impact to analyze code changes
- Use codelogic-database-impact for database modifications
- Highlight impact results for the modified methods
When modifying SQL code or database entities:
- Always use codelogic-database-impact to analyze potential impacts
- Highlight impact results for the modified database entities
To use the CodeLogic tools effectively:
- For code impacts: Ask about specific methods or functions
- For database relationships: Ask about tables, views, or columns
- Review the impact results before making changes
- Consider both direct and indirect impactsCrea un archivo ~/.claude/instructions.md con el siguiente contenido:
# CodeLogic MCP Server Instructions
When modifying existing code methods:
- Use codelogic-method-impact to analyze code changes
- Use codelogic-database-impact for database modifications
- Highlight impact results for the modified methods
When modifying SQL code or database entities:
- Always use codelogic-database-impact to analyze potential impacts
- Highlight impact results for the modified database entities
To use the CodeLogic tools effectively:
- For code impacts: Ask about specific methods or functions
- For database relationships: Ask about tables, views, or columns
- Review the impact results before making changes
- Consider both direct and indirect impactsCree o modifique el archivo markdown ~/.codeium/windsurf/memories/global_rules.md con el siguiente contenido:
When modifying existing code methods:
- Use codelogic-method-impact to analyze code changes
- Use codelogic-database-impact for database modifications
- Highlight impact results for the modified methods
When modifying SQL code or database entities:
- Always use codelogic-database-impact to analyze potential impacts
- Highlight impact results for the modified database entities
To use the CodeLogic tools effectively:
- For code impacts: Ask about specific methods or functions
- For database relationships: Ask about tables, views, or columns
- Review the impact results before making changes
- Consider both direct and indirect impactsPara configurar las reglas de CodeLogic en Cursor:
Abrir configuración del cursor
Vaya a la sección "Reglas"
Añade el siguiente contenido a "Reglas de usuario":
# CodeLogic MCP Server Rules
## Codebase
- The CodeLogic MCP Server is for java, javascript, typescript, and C# dotnet codebases
- don't run the tools on python or other non supported codebases
## AI Assistant Behavior
- When modifying existing code methods:
- Use codelogic-method-impact to analyze code changes
- Use codelogic-database-impact for database modifications
- Highlight impact results for the modified methods
- When modifying SQL code or database entities:
- Always use codelogic-database-impact to analyze potential impacts
- Highlight impact results for the modified database entities
- To use the CodeLogic tools effectively:
- For code impacts: Ask about specific methods or functions
- For database relationships: Ask about tables, views, or columns
- Review the impact results before making changes
- Consider both direct and indirect impactsLas siguientes variables de entorno se pueden configurar para personalizar el comportamiento del servidor:
CODELOGIC_SERVER_HOST : La URL del servidor CodeLogic.
CODELOGIC_USERNAME : Su nombre de usuario de CodeLogic.
CODELOGIC_PASSWORD : Su contraseña de CodeLogic.
CODELOGIC_WORKSPACE_NAME : El nombre del espacio de trabajo a utilizar.
CODELOGIC_DEBUG_MODE : Establézcalo en true para habilitar el modo de depuración. Al habilitarlo, se generarán archivos de depuración adicionales, como timing_log.txt e impact_data*.json . El valor predeterminado es false .
"env": {
"CODELOGIC_SERVER_HOST": "<url to the server e.g. https://myco.app.codelogic.com>",
"CODELOGIC_USERNAME": "<my username>",
"CODELOGIC_PASSWORD": "<my password>",
"CODELOGIC_WORKSPACE_NAME": "<my workspace>",
"CODELOGIC_DEBUG_MODE": "true"
}En lugar de usar la última versión del servidor, puede fijar una versión específica cambiando el campo args para que coincida con la versión en pypi , por ejemplo:
"args": [
"codelogic-mcp-server@0.2.2"
],Este servidor MCP tiene los siguientes requisitos de compatibilidad de versiones:
Versión 0.3.1 y anteriores: compatible con todas las versiones de API de CodeLogic
Versión 0.4.0 y superior: Requiere la versión 25.10.0 o superior de la API de CodeLogic
Si está actualizando, asegúrese de que su servidor CodeLogic cumpla con el requisito mínimo de versión de API.
El proyecto utiliza unittest para realizar pruebas. Puedes ejecutar pruebas unitarias sin dependencias externas:
python -m unittest discover -s test -p "unit_*.py"Las pruebas unitarias utilizan datos simulados y no requieren una conexión a un servidor CodeLogic.
Si desea ejecutar pruebas de integración que se conecten a un servidor CodeLogic real:
Copie test/.env.test.example en test/.env.test y complételo con los detalles de su servidor CodeLogic
Ejecute las pruebas de integración:
python -m unittest discover -s test -p "integration_*.py"Nota: Las pruebas de integración requieren acceso a una instancia de servidor CodeLogic.
Analyze impacts between code and database entities. Uses CODELOGIC_WORKSPACE_NAME environment variable to determine the target workspace. Recommended workflow:
Use this tool before implementing code or database changes
Search for the relevant database entity
Review the impact analysis to understand which code depends on this database object and vice versa Particularly crucial when AI-suggested modifications are being considered or when modifying SQL code.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Name of the database entity to search for | |
| entity_type | Yes | Type of database entity to search for (column, table, or view) | |
| table_or_view | No | Name of the table or view containing the column (required for columns only) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses use of environment variable CODELOGIC_WORKSPACE_NAME and mentions the tool is read-only in nature (analysis, no mutations). But with no annotations, it fails to describe output format, performance, authentication needs, or rate limits. The description is partially transparent but lacks critical behavioral details.
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?
Description is concise (4 sentences) and front-loaded with purpose. Numbered workflow improves structure. Every sentence contributes value, though the workflow could be more compact.
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 no output schema and no annotations, the description partially compensates by explaining the workflow and environment variable. However, it lacks details on the output format (e.g., list of dependencies, JSON structure), limiting the agent's ability to use results effectively.
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% with clear descriptions for each parameter. The tool description adds minimal extra context beyond what the schema already provides (e.g., entity types). Baseline score of 3 is appropriate as description does not significantly enhance parameter understanding.
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?
Clearly states it analyzes impacts between code and database entities, with specific verb 'Analyze' and resource 'impacts'. Tool name and parameters (entity_type: column/table/view) reinforce database focus, distinguishing it from siblings like codelogic-method-impact and codelogic-graph-impact.
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?
Provides a recommended workflow (use before changes, search entity, review impacts) and emphasizes relevance for AI-suggested or SQL modifications. However, it does not explicitly contrast with sibling tools or state when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch graph API capabilities/manifest from the CodeLogic server (GET). Returns label and relationship metadata when the graph tier is deployed; otherwise explains missing routes. Uses CODELOGIC_WORKSPACE_NAME for MV id unless materialized_view_id is set.
| Name | Required | Description | Default |
|---|---|---|---|
| materialized_view_id | No | Optional materialized view id; default from workspace name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses the GET method, conditional returns (metadata vs missing routes), and default parameter behavior. It lacks statements on auth or side effects, but for a read-only fetch, this is adequate.
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?
Two sentences with no redundancy. The first sentence states the core action and why, the second adds parameter detail. Every word contributes value.
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 simple tool with one optional parameter and no output schema, the description covers purpose, behavior, and default logic. It could mention if the endpoint requires authentication or if there are rate limits, but overall it is sufficient.
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 only parameter is optional and well described in both schema and description. The description adds context about defaulting from the CODELOGIC_WORKSPACE_NAME environment variable, which is valuable 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 the tool fetches graph API capabilities/manifest, specifies HTTP method (GET), and distinguishes return content based on deployment status. This sets it apart from siblings like search or impact, which focus on different operations.
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 usage context by mentioning deployment-dependent behavior and default from workspace, but does not explicitly state when to use this tool over alternatives like codelogic-graph-search. No when-not guidelines provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Bounded graph impact from seed node ids (curated HTTP API). Optional direction (upstream|downstream|both), depth, scan_space, materialized_view_id.
| Name | Required | Description | Default |
|---|---|---|---|
| depth | No | ||
| direction | No | ||
| scan_space | No | ||
| seed_node_ids | Yes | Graph node ids to expand from | |
| materialized_view_id | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must cover behavioral traits. It mentions 'bounded' (by depth/scan_space) and optional parameters, but omits details on defaults, idempotency, authentication, rate limits, or whether the operation is read-only. The description is insufficient for safe invocation.
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 that front-loads the core purpose. It lists optional parameters succinctly without redundancy. Could be slightly improved with structured bullet points for parameter details.
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 (5 parameters, no output schema) and the sparse schema descriptions, the description is incomplete. It fails to explain the return value format, how 'impact' is computed, or provide examples. Sibling tools exist, but no comparative context is given.
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 only 20% (only seed_node_ids has a description). The description lists parameter names and direction enum values but adds no meaningful semantics for depth, scan_space, or materialized_view_id. It does not explain the purpose or constraints of these parameters.
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 it performs 'graph impact' from seed node ids, using a 'curated HTTP API'. It distinguishes from siblings like codelogic-database-impact and codelogic-method-impact by specifying 'graph'. However, it does not define what 'impact' means (e.g., affected nodes/edges).
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 on when to use this tool versus alternatives like codelogic-graph-search or codelogic-graph-validate-change-scope. The agent must infer usage from the name and description alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Look up owners/reviewers for a graph node (curated HTTP API). Provide node_id or identity_prefix.
| Name | Required | Description | Default |
|---|---|---|---|
| node_id | No | ||
| scan_space | No | ||
| identity_prefix | No | ||
| materialized_view_id | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'curated HTTP API' but does not disclose read-only behavior, error conditions, rate limits, or side effects. The behavioral profile is largely opaque.
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 extremely concise (two sentences) and front-loaded with the core purpose. Every sentence adds value without repetition.
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 has 4 parameters and no output schema, yet the description does not explain return values or the role of unspecified parameters. It is insufficient for fully informed usage.
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 0%, so description must compensate. It only explains node_id and identity_prefix, ignoring scan_space and materialized_view_id. Users are left guessing about these parameters.
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 action (look up owners/reviewers) and resource (graph node), distinguishing it from sibling tools that focus on impact, search, or capabilities. However, 'graph node' could be more precisely defined.
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 hints at parameter usage ('Provide node_id or identity_prefix') but does not specify when to use this tool versus siblings like codelogic-graph-search or codelogic-graph-impact. No exclusions or context are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Explain bounded paths between two graph nodes (curated HTTP API). Requires from_node_id, to_node_id; optional max_depth, scan_space, materialized_view_id.
| Name | Required | Description | Default |
|---|---|---|---|
| max_depth | No | ||
| scan_space | No | ||
| to_node_id | Yes | ||
| from_node_id | Yes | ||
| materialized_view_id | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavioral traits. It only mentions 'curated HTTP API' but does not indicate whether the operation is read-only, destructive, or has side effects. There is no information about performance, rate limits, or permissions.
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 of 20 words, efficiently conveying the tool's purpose and key parameters. It is front-loaded with the primary action and resource.
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 has 5 parameters, no output schema, and no annotations, the description covers the purpose and parameters but does not explain what the tool returns or any error conditions. The sibling tools list provides some context, but the description itself leaves gaps in completeness for an agent to use correctly.
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 0%, yet the description lists all five parameters by name and distinguishes required from optional ones. This adds meaningful context beyond the raw schema, which only defines types and requirements. However, it lacks detailed semantics like allowed values for 'scan_space' or format constraints.
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's purpose: 'Explain bounded paths between two graph nodes'. It uses a specific verb ('Explain') and resource ('bounded paths between two graph nodes'), and distinguishes itself from sibling tools like codelogic-graph-search or codelogic-graph-impact.
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 specifies required and optional parameters, giving clear context on what inputs are needed. However, it does not explicitly state when to use this tool versus alternatives or when not to use it, which would improve guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the CodeLogic knowledge graph (curated HTTP API). Provide query or identity_prefix; optional scan_space, materialized_view_id, limit. Requires server route POST .../ai-retrieval/graph/search.
| Name | Required | Description | Default |
|---|---|---|---|
| q | No | Alias for query | |
| limit | No | Suggested max hits (server may cap) | |
| query | No | Symbol or text query (alias: q) | |
| scan_space | No | Optional scan-space / branch filter | |
| identity_prefix | No | Prefix of stable graph identity | |
| prefer_latest_scan | No | ||
| materialized_view_id | No | Override MV id; default from workspace name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Mentions HTTP route and limit cap, but fails to disclose read-only nature, side effects, return format, or error handling.
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?
Single sentence with front-loaded core action, efficient listing of parameters, no redundancy.
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?
Adequate for a search tool but lacks output format details, explicit required parameters, and clearer differentiation from siblings. With 7 parameters and no annotations, more context would be beneficial.
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 description coverage is high (86%). Description adds value by indicating alternatives (query or identity_prefix) and grouping optional parameters, but adds little 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?
Clearly states 'Search the CodeLogic knowledge graph' with specific verb and resource, but does not differentiate from sibling tools like codelogic-graph-impact or codelogic-graph-path-explain.
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?
Provides minimal guidance on providing query or identity_prefix with optional parameters, but lacks explicit when-to-use or when-not-to-use instructions and does not mention alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Validate whether a proposed change scope is safe given seed graph nodes (curated HTTP API).
| Name | Required | Description | Default |
|---|---|---|---|
| scan_space | No | ||
| seed_node_ids | Yes | ||
| materialized_view_id | No | ||
| proposed_change_summary | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It says 'validate whether...safe' but does not disclose if the tool is read-only, modifies state, requires authentication, or what 'safe' means. Minimal behavioral context beyond the core action.
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, concise and front-loaded with the core purpose. However, it could be more structured (e.g., listing parameters or usage context) to compensate for missing schema descriptions.
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 4 parameters, no output schema, and no annotations, the description is grossly incomplete. It fails to explain return values, parameter formats, safety criteria, or any preconditions, leaving the agent unable to use the tool reliably.
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 description coverage is 0%, yet the description adds no parameter explanations. Only 'seed graph nodes' hints at seed_node_ids, but scan_space, materialized_view_id, and proposed_change_summary remain entirely opaque, severely limiting correct invocation.
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 the tool validates safety of a proposed change scope, which is a specific verb+resource. It differentiates from sibling tools like 'codelogic-graph-impact' by focusing on validation vs. impact analysis, though no explicit alternative guidance is given.
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 on when to use this tool vs alternatives. It mentions 'seed graph nodes' and 'curated HTTP API' but does not specify prerequisites or exclusions, leaving the agent to infer context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Analyze impacts of modifying a specific method within a given class or type. Uses CODELOGIC_WORKSPACE_NAME environment variable to determine the target workspace. Recommended workflow:
Use this tool before implementing code changes
Run the tool against methods or functions that are being modified
Carefully review the impact analysis results to understand potential downstream effects Particularly crucial when AI-suggested modifications are being considered.
| Name | Required | Description | Default |
|---|---|---|---|
| class | Yes | Name of the class containing the method | |
| method | Yes | Name of the method being analyzed |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must cover behavioral traits. It states the tool 'analyzes impacts' (implying read-only) and uses an environment variable, but does not disclose specific behaviors like whether it mutates data, auth requirements, or rate limits. It also omits details on what the results contain, which is important given no output schema.
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 concise, with a clear front-loaded purpose and a numbered workflow list. Every sentence adds value, though the workflow could be slightly shortened without losing meaning.
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 tool with only two parameters, the description covers purpose, workflow, and environment variable. However, it lacks information about the output format or how to interpret results, which would be helpful for an impact analysis tool. The absence of an output schema increases the need for description completeness.
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?
Input schema has 100% coverage with descriptions for both required parameters ('Name of the class containing the method' and 'Name of the method being analyzed'). The description adds minimal extra meaning ('within a given class or type') but does not significantly enrich parameter understanding 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 the tool's purpose: analyzing impacts of modifying a specific method within a class or type. It uses a specific verb ('Analyze impacts') and resource ('method within class'), distinguishing it from sibling tools like codelogic-database-impact or codelogic-graph-impact.
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 provides a recommended workflow with three steps, including when to use (before implementing changes) and context (when AI-suggested modifications are considered). It also mentions the environment variable requirement, but lacks explicit exclusion of alternatives or when-not-to-use.
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. Dates show when Glama detected each change.
v1.3.0codelogic-civ1.2.0codelogic-cicodelogic-graph-capabilitiescodelogic-graph-impactcodelogic-graph-ownerscodelogic-graph-path-explaincodelogic-graph-searchcodelogic-graph-validate-change-scopev1.0.0codelogic-database-impactcodelogic-method-impactEach tool targets a distinct aspect of CodeLogic: CI integration, database impact, graph capabilities, graph impact, owners, path explanation, search, change scope validation, and method impact. There is no overlap even among impact tools as they operate on different entities (database, graph, methods).
All tools use a consistent 'codelogic-<domain>-<action>' pattern in snake_case (e.g., codelogic-database-impact, codelogic-graph-search). The naming is uniform and descriptive.
With 9 tools, the set is well-scoped for a code intelligence and impact analysis server. Each tool covers a necessary functionality without being excessive or minimal.
The tool set covers core workflows: CI integration, impact analysis on multiple levels (database, graph, methods), search, path explanation, and validation. Minor gaps exist (e.g., no explicit workspace management), but the environment variable approach mitigates this.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Code intelligence platform for AI agents. 20 tools for architecture, security & impact analysis.
Read-only AI coding tools for change verification, release readiness, capacity, and guidance.
AI Agent with Architectural Memory. Impact analysis (free), tests and code from the graph (pro).
Ground-truth code graph for your codebase: exact callers, callees, symbols & dependencies.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/lineai-intelligence/lineai-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
