AI プログラミング アシスタントで Codelogic の豊富なソフトウェア依存データを活用するためのMCP サーバー。
サーバーは 2 つのツールを実装します。
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の場合は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の場合はC:\Users\username\AppData\Local\astral\uvx.exe。
設定を追加したら、Claude Desktop を再起動して変更を適用します。
この MCP サーバーをWindsurf IDEで実行するには:
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の場合は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の場合はC:\Users\username\AppData\Local\astral\uvx.exe。
変更を適用するにはカーソルを再起動します。
CodeLogic MCP サーバー ツールがカーソル ワークスペースで使用できるようになります。
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マークダウン ファイルを作成または変更します。
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 impactsCursor で 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
