Ein MCP-Server zur Nutzung der umfangreichen Softwareabhängigkeitsdaten von Codelogic in Ihrem KI-Programmierassistenten.
Der Server implementiert zwei Tools:
codelogic-method-impact : Ruft eine Auswirkungsbewertung aus den APIs des CodeLogic-Servers für Ihren Code ab.
Nimmt die gegebene „Methode“, an der Sie arbeiten, und die zugehörige „Klasse“.
codelogic-database-impact : Analysiert Auswirkungen zwischen Code und Datenbankeinheiten.
Übernimmt den Datenbankentitätstyp (Spalte, Tabelle oder Ansicht) und seinen Namen.
Der MCP-Server ist auf Astral UV angewiesen. Bitte installieren Sie
Es gibt ein bekanntes Problem mit uvx unter MacOS , bei dem der CodeLogic MCP-Server in bestimmten IDEs (wie Cursor) möglicherweise nicht gestartet werden kann, was zu Fehlern wie diesen führt: Siehe Problem Nr. 11
Failed to connect client closedDies scheint ein Problem mit Astral uvx unter macOS zu sein. Folgendes kann als Workaround verwendet werden:
Klonen Sie dieses Projekt lokal.
Konfigurieren Sie Ihre mcp.json so, dass uv anstelle von uvx verwendet wird. Beispiel:
{
"mcpServers": {
"codelogic-mcp-server": {
"type": "stdio",
"command": "<PATH_TO_UV>/uv",
"args": [
"--directory",
"<PATH_TO_THIS_REPO>/codelogic-mcp-server-main",
"run",
"codelogic-mcp-server"
],
"env": {
"CODELOGIC_SERVER_HOST": "<url to the server e.g. https://myco.app.codelogic.com>",
"CODELOGIC_USERNAME": "<my username>",
"CODELOGIC_PASSWORD": "<my password>",
"CODELOGIC_MV_NAME": "<my workspace>",
"CODELOGIC_DEBUG_MODE": "true"
}
}
}
}Cursor neu starten.
Stellen Sie sicher, dass die globale Cursorregel für CodeLogic vorhanden ist.
Öffnen Sie die Registerkarte MCP im Cursor und aktualisieren Sie den codelogic-mcp-server .
Bitten Sie Cursor, eine Codeänderung in einer vorhandenen Klasse vorzunehmen. Der MCP-Server sollte nun die Auswirkungsanalyse erfolgreich ausführen.
Related MCP server: NOMIK
So konfigurieren Sie diesen MCP-Server in VS Code:
Stellen Sie zunächst sicher, dass der GitHub Copilot-Agentmodus in VS Code aktiviert ist.
Erstellen Sie in Ihrem Arbeitsbereich eine .vscode/mcp.json -Datei mit der folgenden Konfiguration:
{
"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"
}
}
}
}Hinweis: Auf manchen Systemen müssen Sie möglicherweise den vollständigen Pfad zur uvx-Programmdatei anstelle von „uvx“ verwenden. Beispiel:
/home/user/.local/bin/uvxunter Linux/Mac oderC:\Users\username\AppData\Local\astral\uvx.exeunter Windows.
Alternativ können Sie den Befehl MCP: Add Server aus der Befehlspalette ausführen und die Serverinformationen angeben.
Verwenden Sie zum Verwalten Ihrer MCP-Server den Befehl MCP: List Servers aus der Befehlspalette.
Nach der Konfiguration stehen die Server-Tools im Copilot-Agentenmodus zur Verfügung. Sie können bestimmte Tools nach Bedarf ein- und ausschalten, indem Sie im Agentenmodus in der Chat-Ansicht auf die Schaltfläche „Tools“ klicken.
Um die Codelogic-Tools im Agentenmodus zu verwenden, können Sie gezielt nach Codeauswirkungen oder Datenbankbeziehungen fragen, und der Agent verwendet die entsprechenden Tools.
Konfigurieren Sie Claude Desktop, indem Sie die Konfigurationsdatei bearbeiten:
Unter MacOS: ~/Library/Application\ Support/Claude/claude_desktop_config.json
Unter Windows: %APPDATA%/Claude/claude_desktop_config.json
Unter Linux: ~/.config/Claude/claude_desktop_config.json
Fügen Sie Ihrer Konfigurationsdatei Folgendes hinzu:
"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>"
}
}
}Hinweis: Auf manchen Systemen müssen Sie möglicherweise den vollständigen Pfad zur uvx-Programmdatei anstelle von „uvx“ verwenden. Beispiel:
/home/user/.local/bin/uvxunter Linux/Mac oderC:\Users\username\AppData\Local\astral\uvx.exeunter Windows.
Starten Sie Claude Desktop nach dem Hinzufügen der Konfiguration neu, um die Änderungen zu übernehmen.
So führen Sie diesen MCP-Server mit Windsurf IDE aus:
Windsurf IDE konfigurieren :
Um Windsurf IDE zu konfigurieren, müssen Sie die Konfigurationsdatei ~/.codeium/windsurf/mcp_config.json erstellen oder ändern.
Fügen Sie Ihrer Datei die folgende Konfiguration hinzu:
"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>"
}
}
}Hinweis: Auf manchen Systemen müssen Sie möglicherweise den vollständigen Pfad zur uvx-Programmdatei anstelle von „uvx“ verwenden. Beispiel:
/home/user/.local/bin/uvxunter Linux/Mac oderC:\Users\username\AppData\Local\astral\uvx.exeunter Windows.
Starten Sie Windsurf IDE nach dem Hinzufügen der Konfiguration neu oder aktualisieren Sie die Tools, um die Änderungen anzuwenden.
So konfigurieren Sie den CodeLogic MCP-Server in Cursor:
Konfigurieren Sie den MCP-Server, indem Sie eine .cursor/mcp.json Datei erstellen:
{
"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"
}
}
}
}Hinweis: Auf manchen Systemen müssen Sie möglicherweise den vollständigen Pfad zur uvx-Programmdatei anstelle von „uvx“ verwenden. Beispiel:
/home/user/.local/bin/uvxunter Linux/Mac oderC:\Users\username\AppData\Local\astral\uvx.exeunter Windows.
Starten Sie Cursor neu, um die Änderungen zu übernehmen.
Die CodeLogic MCP-Servertools sind jetzt in Ihrem Cursor-Arbeitsbereich verfügbar.
Damit der KI-Assistent die CodeLogic-Tools effektiv nutzen kann, können Sie die folgenden Anweisungen/Regeln zur Konfiguration Ihres Clients hinzufügen. Wir empfehlen, diese Anweisungen an die spezifischen Codierungsstandards, Best Practices und Workflow-Anforderungen Ihres Teams anzupassen:
Erstellen Sie eine .vscode/copilot-instructions.md -Datei mit folgendem Inhalt:
# 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 impactsErstellen Sie eine Datei ~/.claude/instructions.md mit folgendem Inhalt:
# 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 impactsErstellen oder ändern Sie die Markdown-Datei ~/.codeium/windsurf/memories/global_rules.md mit dem folgenden Inhalt:
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 impactsSo konfigurieren Sie CodeLogic-Regeln in Cursor:
Cursoreinstellungen öffnen
Navigieren Sie zum Abschnitt „Regeln“
Fügen Sie den „Benutzerregeln“ den folgenden Inhalt hinzu:
# 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 impactsDie folgenden Umgebungsvariablen können konfiguriert werden, um das Verhalten des Servers anzupassen:
CODELOGIC_SERVER_HOST : Die URL des CodeLogic-Servers.
CODELOGIC_USERNAME : Ihr CodeLogic-Benutzername.
CODELOGIC_PASSWORD : Ihr CodeLogic-Passwort.
CODELOGIC_WORKSPACE_NAME : Der Name des zu verwendenden Arbeitsbereichs.
CODELOGIC_DEBUG_MODE : Auf true setzen, um den Debug-Modus zu aktivieren. Wenn aktiviert, werden zusätzliche Debug-Dateien wie timing_log.txt und impact_data*.json generiert. Standardmäßig auf false gesetzt.
"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"
}Anstatt die neueste Version des Servers zu verwenden, können Sie eine bestimmte Version festlegen, indem Sie das Argumentfeld so ändern, dass es der Version in pypi entspricht, z. B.
"args": [
"codelogic-mcp-server@0.2.2"
],Für diesen MCP-Server gelten die folgenden Versionskompatibilitätsanforderungen:
Version 0.3.1 und darunter: Kompatibel mit allen CodeLogic API-Versionen
Version 0.4.0 und höher: Erfordert CodeLogic API Version 25.10.0 oder höher
Stellen Sie beim Upgrade sicher, dass Ihr CodeLogic-Server die Mindestanforderungen an die API-Version erfüllt.
Das Projekt verwendet unittest zum Testen. Sie können Unit-Tests ohne externe Abhängigkeiten ausführen:
python -m unittest discover -s test -p "unit_*.py"Unit-Tests verwenden simulierte Daten und erfordern keine Verbindung zu einem CodeLogic-Server.
Wenn Sie Integrationstests ausführen möchten, die eine Verbindung zu einem echten CodeLogic-Server herstellen:
Kopieren Sie test/.env.test.example nach test/.env.test und füllen Sie es mit Ihren CodeLogic-Serverdetails
Führen Sie die Integrationstests aus:
python -m unittest discover -s test -p "integration_*.py"Hinweis: Integrationstests erfordern Zugriff auf eine CodeLogic-Serverinstanz.
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
