MCP 服务器可在您的 AI 编程助手中利用 Codelogic 丰富的软件依赖数据。
服务器实现了两个工具：
codelogic-method-impact ：从 CodeLogic 服务器的 API 中提取对您的代码的影响评估。
采用您正在处理的给定“方法”及其相关的“类”。
codelogic-database-impact ：分析代码和数据库实体之间的影响。
采用数据库实体类型（列、表或视图）及其名称。
MCP 服务器依赖 Astral UV 运行，请安装
Related MCP server: NOMIK
要在 VS Code 中配置此 MCP 服务器：
首先，确保您已在 VS Code 中启用 GitHub Copilot 代理模式。
在您的工作区中创建一个.vscode/mcp.json文件，并配置如下：
{
"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"
}
}
}
}**注意：**在某些系统上，您可能需要使用 uvx 可执行文件的完整路径，而不仅仅是“uvx”。例如：Linux/Mac 上的
/home/user/.local/bin/uvx或 Windows 上的C:\Users\username\AppData\Local\astral\uvx.exe。
或者，您可以从命令面板运行MCP: Add Server命令并提供服务器信息。
要管理您的 MCP 服务器，请使用命令面板中的MCP: List Servers命令。
配置完成后，服务器的工具将可供 Copilot 代理模式使用。在代理模式下，您可以根据需要点击聊天视图中的“工具”按钮来启用/禁用特定工具。
要以代理模式使用 Codelogic 工具，您可以具体询问代码影响或数据库关系，代理将使用适当的工具。
通过编辑配置文件来配置Claude Desktop：
在 MacOS 上： ~/Library/Application\ Support/Claude/claude_desktop_config.json
在 Windows 上： %APPDATA%/Claude/claude_desktop_config.json
在 Linux 上： ~/.config/Claude/claude_desktop_config.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>"
}
}
}**注意：**在某些系统上，您可能需要使用 uvx 可执行文件的完整路径，而不仅仅是“uvx”。例如：Linux/Mac 上的
/home/user/.local/bin/uvx或 Windows 上的C:\Users\username\AppData\Local\astral\uvx.exe。
添加配置后，重新启动 Claude Desktop 以应用更改。
要使用Windsurf IDE运行此 MCP 服务器：
配置 Windsurf IDE ：
要配置 Windsurf IDE，您需要创建或修改~/.codeium/windsurf/mcp_config.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>"
}
}
}**注意：**在某些系统上，您可能需要使用 uvx 可执行文件的完整路径，而不仅仅是“uvx”。例如：Linux/Mac 上的
/home/user/.local/bin/uvx或 Windows 上的C:\Users\username\AppData\Local\astral\uvx.exe。
添加配置后，重新启动 Windsurf IDE 或刷新工具以应用更改。
要在 Cursor 中配置 CodeLogic MCP 服务器：
通过创建.cursor/mcp.json文件来配置 MCP 服务器：
{
"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"
}
}
}
}**注意：**在某些系统上，您可能需要使用 uvx 可执行文件的完整路径，而不仅仅是“uvx”。例如：Linux/Mac 上的
/home/user/.local/bin/uvx或 Windows 上的C:\Users\username\AppData\Local\astral\uvx.exe。
重新启动 Cursor 以应用更改。
CodeLogic MCP 服务器工具现在将在您的 Cursor 工作区中可用。
为了帮助AI助手有效地使用CodeLogic工具，您可以在客户端的配置中添加以下说明/规则。我们建议您自定义这些说明，以符合您团队的特定编码标准、最佳实践和工作流程要求：
创建一个.vscode/copilot-instructions.md文件，其中包含以下内容：
# 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 impacts创建一个文件~/.claude/instructions.md其中包含以下内容：
# 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 impacts创建或修改~/.codeium/windsurf/memories/global_rules.md markdown 文件，内容如下：
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 impacts要在 Cursor 中配置 CodeLogic 规则：
打开游标设置
导航至“规则”部分
在“用户规则”中添加以下内容：
# 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 impacts可以配置以下环境变量来定制服务器的行为：
CODELOGIC_SERVER_HOST ：CodeLogic 服务器的 URL。
CODELOGIC_USERNAME ：您的 CodeLogic 用户名。
CODELOGIC_PASSWORD ：您的 CodeLogic 密码。
CODELOGIC_WORKSPACE_NAME ：要使用的工作区的名称。
CODELOGIC_DEBUG_MODE ：设置为true以启用调试模式。启用后，将生成其他调试文件，例如timing_log.txt和impact_data*.json 。默认为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"
}您无需使用服务器的最新版本，而是可以通过更改args字段来匹配pypi中的版本，从而固定到特定版本，例如
"args": [
"codelogic-mcp-server@0.2.2"
],此 MCP 服务器具有以下版本兼容性要求：
版本 0.3.1 及以下：兼容所有 CodeLogic API 版本
版本 0.4.0 及以上：需要 CodeLogic API 版本 25.10.0 或更高版本
如果您正在升级，请确保您的 CodeLogic 服务器满足最低 API 版本要求。
该项目使用 unittest 进行测试。您可以运行单元测试而无需任何外部依赖项：
python -m unittest discover -s test -p "unit_*.py"单元测试使用模拟数据，不需要连接到 CodeLogic 服务器。
如果您想运行连接到真实 CodeLogic 服务器的集成测试：
将test/.env.test.example复制到test/.env.test并填充您的 CodeLogic 服务器详细信息
运行集成测试：
python -m unittest discover -s test -p "integration_*.py"注意：集成测试需要访问 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
