KiCad MCP Server

by lamaalrajih

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation3/5
There is significant overlap between several tools, particularly in the analysis and extraction categories. For example, analyze_schematic_connections and find_component_connections both deal with connections, while extract_project_netlist and extract_schematic_netlist have unclear boundaries. However, the descriptions help clarify some distinctions, preventing complete confusion.
Naming Consistency4/5
Most tools follow a consistent verb_noun pattern (e.g., analyze_bom, export_bom_csv, list_projects), which is clear and predictable. There are minor deviations like get_drc_history_tool (redundant 'tool' suffix) and generate_pcb_thumbnail (slightly different structure), but overall the naming is coherent and readable.
Tool Count4/5
With 16 tools, the count is slightly high but reasonable for a KiCad server covering project management, analysis, and export functions. It feels comprehensive rather than bloated, though some consolidation might improve focus. The scope justifies most tools, but it borders on being heavy.
Completeness4/5
The toolset covers key areas like project listing, validation, analysis, and export, with good lifecycle coverage for KiCad workflows. Minor gaps exist, such as no direct PCB editing or schematic modification tools, but agents can likely work around these with the provided analysis and validation tools for a complete design process.
Average 3.1/5 across 16 of 16 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- 1 of 3 community issues answered or closed in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is failing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It does not disclose behavioral traits such as whether opening a project requires specific permissions, if it modifies the project, what happens on failure, or if it has side effects like locking files. The description is minimal and lacks critical operational details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with a single sentence, 'Open a KiCad project in KiCad.', which is efficient. However, it is under-specified rather than optimally concise, as it lacks necessary details for a tool with no annotations and low schema coverage.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (simple operation with one parameter), no annotations, and an output schema present, the description is incomplete. It does not explain what 'open' means operationally or what the output might contain, relying on the output schema. For a tool with no annotations, more context is needed to be fully helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate, but it adds no meaning beyond the schema. The parameter 'project_path' is not explained in the description—no details on format, valid paths, or examples. With one parameter and no schema descriptions, the baseline is 3 as it does not add value but also does not mislead.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Open a KiCad project in KiCad' states the verb ('Open') and resource ('KiCad project'), but is vague about what 'open' entails—whether it loads for editing, viewing, or analysis. It does not distinguish from siblings like 'list_projects' or 'get_project_structure', which are related but different operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. For example, it does not specify if this should be used before analysis tools like 'analyze_project_circuit_patterns' or if 'list_projects' is a prerequisite. The description lacks context about prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'basic validation' but doesn't clarify what that involves (e.g., syntax checks, file integrity, error reporting), whether it's read-only or has side effects, or any performance considerations. This leaves key behavioral traits unspecified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for a simple tool, avoiding redundancy or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 1 parameter, no annotations, and an output schema (which handles return values), the description is minimally complete. It states the tool's purpose but lacks details on validation scope, behavioral traits, and usage context, making it adequate but with clear gaps for informed tool selection.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 0% description coverage, so the description must compensate. It implies validation of a 'KiCad project' via 'project_path,' adding minimal context about the parameter's purpose. However, it doesn't detail path format, constraints, or examples, resulting in baseline adequacy without full compensation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool performs 'basic validation of a KiCad project,' which provides a clear verb ('validate') and resource ('KiCad project'). However, it's vague about what 'basic validation' entails compared to siblings like 'run_drc_check' or 'analyze_project_circuit_patterns,' lacking specific differentiation in scope or depth.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description offers no guidance on when to use this tool versus alternatives. With siblings like 'run_drc_check' (likely more detailed checks) and 'analyze_project_circuit_patterns' (pattern analysis), it fails to specify scenarios, prerequisites, or exclusions, leaving usage ambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. While it mentions 'MCP context for progress reporting' for the ctx parameter, it doesn't disclose important behavioral traits: whether this is a read-only operation, computational complexity, expected runtime, what types of patterns are identified, or how results are structured beyond 'Dictionary with identified circuit patterns.' For a pattern analysis tool with no annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the core purpose in the first sentence. The Args/Returns sections are structured clearly. While efficient, the 'ctx' parameter explanation could be more concise since the schema already contains extensive Context documentation that the agent can access separately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 2 parameters with 0% schema coverage and no annotations, the description provides basic parameter semantics but lacks behavioral context. The output schema exists (though not shown), so the description doesn't need to detail return values. However, for a pattern analysis tool in a domain with multiple similar siblings, more context about what constitutes 'circuit patterns' and differentiation from other tools would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the schema provides no parameter documentation. The description adds basic semantics: 'project_path: Path to the KiCad project file (.kicad_pro)' and 'ctx: MCP context for progress reporting.' This covers both parameters but doesn't provide format details for project_path (absolute vs relative, file existence requirements) or comprehensive ctx usage guidance beyond progress reporting. With 0% schema coverage, this is adequate but minimal compensation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Identify circuit patterns in a KiCad project's schematic.' It specifies the verb ('identify'), resource ('circuit patterns'), and domain context ('KiCad project's schematic'). However, it doesn't distinguish this tool from the sibling 'identify_circuit_patterns' tool, which appears to have a very similar purpose based on name alone.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'analyze_schematic_connections', 'find_component_connections', and 'identify_circuit_patterns' that might serve related purposes, there's no indication of what differentiates this tool or when it should be preferred over others.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states what the tool does but doesn't describe important behavioral aspects: whether this is a read-only operation, what permissions are needed, whether it modifies files, error handling, performance characteristics, or what specific netlist information is returned. The mention of 'progress reporting' via ctx hints at potentially long-running operations, but this isn't elaborated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably concise with clear sections: purpose statement, brief explanation, Args section, and Returns section. The front-loaded purpose statement is effective. The Args section could be more integrated with the flow, but overall the structure is logical with minimal wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema (returns a dictionary with netlist information), the description doesn't need to detail return values. However, with no annotations, 0% schema description coverage, and a mutation-adjacent operation ('extract' could imply file reading or processing), the description should provide more behavioral context about what 'extract' entails and how it differs from similar tools. The current description is minimally adequate but leaves important questions unanswered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the schema provides no parameter documentation. The description adds basic semantics for 'project_path' (path to .kicad_pro file) and mentions 'ctx' is for 'progress reporting,' which provides some value beyond the bare schema. However, it doesn't explain parameter constraints, formats, or examples, leaving significant gaps in parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Extract netlist from a KiCad project's schematic' and 'extracts its netlist information.' It specifies the verb ('extract'), resource ('netlist'), and source ('KiCad project's schematic'). However, it doesn't explicitly differentiate from sibling tools like 'extract_schematic_netlist' or 'analyze_schematic_connections,' which appears to be a closely related operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It mentions finding the schematic associated with a project, but doesn't clarify when to choose this over 'extract_schematic_netlist' (which might work directly on schematic files) or other analysis tools. No prerequisites, exclusions, or comparison with sibling tools are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions that the tool 'returns thumbnail image of the PCB or None if generation failed,' which gives basic output behavior. However, it doesn't disclose important traits: whether this is a read-only operation, what permissions are needed, potential side effects (e.g., temporary file creation), performance characteristics, or error conditions beyond failure. For a tool that presumably reads and processes project files, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, Args, Returns) and uses minimal sentences. Each section adds value: the opening sentence states the core function, Args explains parameters, Returns clarifies output behavior. There's no redundant information, though the ctx explanation could be more concise given its detailed schema definition. Overall, it's appropriately sized and front-loaded with the main purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (generating images from PCB layouts), lack of annotations, and no output schema, the description is moderately complete. It covers the basic purpose, parameters, and return behavior. However, it misses important context: what the thumbnail looks like (e.g., image format, dimensions), how failures manifest, dependencies on kicad-cli availability, or interaction with sibling tools. For a tool with 2 parameters and no annotation coverage, this is adequate but leaves gaps an agent would need to infer.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides parameter documentation in an 'Args' section, explaining that 'project_path' is the 'Path to the KiCad project file (.kicad_pro)' and 'ctx' is 'Context for MCP communication.' With 0% schema description coverage, this adds meaningful context beyond the bare schema. However, it doesn't elaborate on format requirements for project_path (e.g., absolute vs. relative paths, file existence) or practical usage of ctx beyond its definition. The baseline is 3 since the description compensates somewhat for the schema gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Generate a thumbnail image of a KiCad PCB layout using kicad-cli.' It specifies the verb ('generate'), resource ('thumbnail image'), and technology ('KiCad PCB layout using kicad-cli'). However, it doesn't explicitly differentiate from sibling tools like 'generate_project_thumbnail' which might serve a similar purpose for different project aspects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid KiCad project), compare it to 'generate_project_thumbnail', or indicate scenarios where thumbnail generation is appropriate versus other analysis tools. The only contextual hint is the technology stack (kicad-cli), but no usage boundaries are defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the tool generates a thumbnail but doesn't disclose behavioral traits such as what format the thumbnail is in (image type, dimensions), whether it's saved to disk or returned as data, performance characteristics, error conditions, or any side effects. The description is minimal and lacks necessary operational context for a mutation tool (generation implies creation).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise—a single sentence that efficiently states the tool's purpose and alias relationship. It's front-loaded with the core functionality. However, the brevity comes at the cost of completeness, as it omits important details needed for effective use.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (generation implies mutation), lack of annotations, no output schema, and 0% schema description coverage, the description is incomplete. It doesn't cover what the tool returns (e.g., image data, file path), error handling, or usage constraints. For a tool with two required parameters and no structured documentation, this leaves significant gaps for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the schema provides no parameter documentation. The description mentions 'project_path' implicitly through 'KiCad project' but doesn't explain what this path should be (file path, project name, etc.) or the purpose of 'ctx'. It adds minimal semantic value beyond what's inferable from the tool name, failing to compensate for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Generate a thumbnail of a KiCad project's PCB layout.' It specifies the verb ('generate'), resource ('thumbnail'), and domain context ('KiCad project's PCB layout'). However, it doesn't distinguish this tool from its sibling 'generate_pcb_thumbnail' beyond noting it's an alias, which is helpful but not a true functional differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by specifying 'KiCad project's PCB layout' and mentions it's an 'Alias for generate_pcb_thumbnail,' which provides some guidance about tool relationships. However, it doesn't explicitly state when to use this tool versus alternatives (e.g., other thumbnail generation methods or when to use the aliased tool directly), nor does it mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the tool will 'look for BOM files' and 'provide analysis', but doesn't specify whether this is read-only or has side effects, what permissions are needed, error handling for missing files, or performance characteristics. For a tool that reads and analyzes project files, this leaves significant behavioral questions unanswered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately sized. It opens with a clear purpose statement, provides specific details about what the analysis includes, and has separate sections for Args and Returns. Every sentence adds value, though the 'ctx' explanation could be slightly more specific about what progress gets reported.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (analyzing BOM files), no annotations, and the existence of an output schema (which handles return values), the description is minimally adequate. It covers the basic purpose and parameters but lacks important context about behavioral traits, error conditions, and differentiation from sibling tools. The output schema existence prevents a lower score, but the description should do more given the tool's analytical nature.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for both parameters beyond the schema's 0% coverage. It explains that 'project_path' should point to a '.kicad_pro' file and that 'ctx' is for 'progress reporting'. This provides practical guidance that the schema lacks, though it doesn't detail what specific progress information gets reported or format requirements for the path.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 a KiCad project's Bill of Materials. It specifies the action ('analyze'), resource ('KiCad project's Bill of Materials'), and scope (component counts, categories, cost estimates). However, it doesn't explicitly differentiate from sibling tools like 'export_bom_csv' or 'extract_project_netlist', which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools related to BOMs and project analysis (export_bom_csv, extract_project_netlist, analyze_project_circuit_patterns, etc.), there's no indication of when this analysis tool is preferred over exporting or extracting tools. The description only states what it does, not when to choose it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'detailed analysis' and 'potential issues' but lacks specifics on permissions needed, performance characteristics, side effects, or error handling. It doesn't clarify if this is a read-only analysis or has any mutative effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with clear sections: purpose statement, parameter explanations, and return value description. It's front-loaded with the core functionality. The Args/Returns formatting is helpful, though the ctx explanation could be more concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 2 parameters with 0% schema coverage and no annotations, the description provides basic parameter semantics but lacks behavioral context for a tool that performs complex schematic analysis. The existence of an output schema reduces the need to explain return values, but more operational guidance would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains 'schematic_path' as 'Path to the KiCad schematic file (.kicad_sch)' and 'ctx' as 'MCP context for progress reporting', adding meaningful context beyond the bare schema. However, it doesn't detail format requirements for the path or how progress reporting works.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool analyzes connections in a KiCad schematic, specifying the resource (KiCad schematic) and action (analyze connections). It distinguishes from siblings like 'find_component_connections' by mentioning detailed analysis including power nets, signal paths, and potential issues, though not explicitly contrasting with that sibling.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'find_component_connections' or 'extract_schematic_netlist'. The description mentions what the tool does but offers no context about appropriate use cases or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions parsing and extracting information, it doesn't describe error conditions, performance characteristics, file format requirements beyond the extension, or what happens with malformed schematics. The mention of 'progress reporting' via ctx is helpful but insufficient for comprehensive behavioral understanding.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections: purpose statement, parameter explanations, and return value description. It's appropriately sized at 6 sentences with no redundant information. The Args/Returns formatting helps readability, though the purpose statement could be slightly more front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (file parsing operation), no annotations, and the presence of an output schema, the description is minimally adequate. It explains what the tool does and its parameters but lacks important context about error handling, performance, and differentiation from similar tools. The output schema existence reduces the need to detail return values, but more behavioral context would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description compensates well by explaining both parameters: 'schematic_path' is clearly described as 'Path to the KiCad schematic file (.kicad_sch)' and 'ctx' is explained as 'MCP context for progress reporting'. This provides meaningful semantic information beyond the bare schema, though it doesn't elaborate on path format requirements or ctx usage details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Extract netlist information from a KiCad schematic' with specific details about what it extracts (components, connections, labels). It distinguishes from some siblings like 'analyze_bom' or 'export_bom_csv' but doesn't explicitly differentiate from the closely related 'extract_project_netlist' tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when this tool is appropriate versus 'extract_project_netlist' or 'analyze_schematic_connections', nor does it provide any prerequisites or exclusions for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states 'Get the structure and files', implying a read-only operation, but doesn't disclose behavioral traits such as whether it requires specific permissions, what format the output is in, if there are rate limits, or how it handles errors. This leaves significant gaps for a tool with an 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no wasted words. It's appropriately sized and front-loaded, making it easy to understand at a glance without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema, the description doesn't need to explain return values. However, with no annotations and a simple input schema, the description is minimal and doesn't cover usage context or behavioral aspects, making it adequate but with clear gaps for a tool that likely returns project data.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds no meaning beyond the input schema, which has 0% description coverage. It doesn't explain what 'project_path' entails (e.g., file path format, relative vs. absolute). With one parameter and low schema coverage, the baseline is 3 as the schema provides the structure but lacks semantic details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'structure and files of a KiCad project', making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_projects' or 'open_project', which might also involve project access, so it misses full sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'list_projects' (likely listing project names) and 'open_project' (possibly loading a project), there's no indication of how this tool differs in usage context or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 returning a dictionary with entries, which adds some behavioral context, but fails to disclose critical traits like whether this is a read-only operation, if it requires specific permissions, or any rate limits. For a tool with no annotations, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, starting with the core purpose followed by structured sections for args and returns. Every sentence adds value, though it could be slightly more streamlined by integrating the args/returns into a single paragraph.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (one parameter) and the presence of an output schema (which handles return values), the description is mostly complete. It covers the purpose and parameter semantics adequately, but lacks usage guidelines and behavioral details, which holds it back from a perfect score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context beyond the input schema, which has 0% description coverage. It specifies that 'project_path' refers to a 'KiCad project file (.kicad_pro)', clarifying the file type and format, which compensates well for the schema's lack of details. With only one parameter, this is effective.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('DRC check history for a KiCad project'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'run_drc_check' or 'validate_project', which might also relate to DRC functionality, so it doesn't reach the highest score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. With siblings like 'run_drc_check' and 'validate_project' available, the description lacks context on whether this tool retrieves past results, complements real-time checks, or serves a distinct purpose, leaving usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'Find and list all KiCad projects on this system,' which implies a read-only operation, but doesn't specify details like whether it searches recursively, includes hidden files, returns metadata, or has performance considerations. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that efficiently conveys the core action and resource without any wasted words. It's front-loaded with the key information ('Find and list all KiCad projects'), making it easy to grasp quickly, and every part of the sentence serves a purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 0 parameters, 100% schema coverage, and an output schema exists, the description doesn't need to cover parameters or return values. However, as a read operation with no annotations, it lacks details on behavioral aspects like search scope or output format. It's minimally adequate but could benefit from more context to fully guide usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%, so there's no need for parameter details in the description. The description appropriately doesn't discuss parameters, focusing on the tool's purpose instead. A baseline of 4 is applied since no parameters exist, and it avoids unnecessary repetition of schema information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Find and list') and resource ('all KiCad projects on this system'), making it easy to understand what it does. However, it doesn't explicitly differentiate from sibling tools like 'get_project_structure' or 'open_project', which might also involve project-related operations, so it doesn't reach the highest score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'get_project_structure' and 'open_project' that might overlap in project-related contexts, there's no indication of when this listing tool is preferred or what its specific scope (e.g., system-wide vs. workspace) entails, leaving usage ambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool 'attempts' to generate a CSV, hinting at potential failure modes, and notes KiCad installation requirements, which adds some context. However, it lacks details on error handling, file output location, permissions needed, or what the 'export results' dictionary contains, leaving significant gaps for a mutation tool (export implies file creation).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear opening sentence, followed by additional context and a parameter/return section. It's appropriately sized without unnecessary fluff, though the parameter explanations could be more detailed. Every sentence contributes to understanding the tool's functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema (returns a dictionary), the description doesn't need to explain return values in detail. However, with no annotations and a mutation operation (exporting files), the description should provide more behavioral context, such as error conditions or output file handling. It covers basics but leaves gaps for a tool that interacts with external systems (KiCad).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description explicitly lists and briefly explains both parameters: 'project_path' as the path to the KiCad project file and 'ctx' for MCP context in progress reporting. With 0% schema description coverage, this adds substantial value beyond the schema, which only provides titles without descriptions. However, it doesn't detail the format or constraints for 'project_path' (e.g., file extensions, absolute vs. relative paths).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool exports a Bill of Materials (BOM) for a KiCad project as a CSV file, which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'analyze_bom' or 'extract_project_netlist', which might have overlapping functionality with BOM-related operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some context about when to use this tool by mentioning it requires KiCad installation with command-line tools, which implies a prerequisite. However, it doesn't offer explicit guidance on when to choose this tool versus alternatives like 'analyze_bom' or 'extract_project_netlist', nor does it specify exclusions or complementary tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool runs a DRC check but doesn't describe what happens during execution (e.g., whether it modifies files, requires specific permissions, has side effects, or handles errors). It mentions progress reporting via 'ctx' but lacks details on rate limits, performance, or output format beyond a generic 'dictionary'.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, with the core purpose stated first in a clear sentence. The Args and Returns sections are structured efficiently, though the 'ctx' explanation could be more concise. Overall, it avoids unnecessary verbosity while conveying essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (running DRC checks on PCB files) and the presence of an output schema, the description is moderately complete. It covers the purpose and parameters adequately but lacks behavioral details (e.g., mutation risks, error handling) and doesn't fully leverage the output schema to explain return values. For a tool with no annotations, it should provide more operational context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for both parameters beyond the schema's 0% coverage. It specifies that 'project_path' is a 'Path to the KiCad project file (.kicad_pro)', clarifying the expected file type, and explains that 'ctx' is for 'MCP context for progress reporting', detailing its purpose. This compensates well for the low schema coverage, though it doesn't cover all possible parameter nuances.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verb ('Run') and resource ('Design Rule Check on a KiCad PCB file'), distinguishing it from sibling tools like 'get_drc_history_tool' (which retrieves history) and 'validate_project' (which may be more general). It precisely identifies what the tool does without being tautological.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over 'validate_project' or 'get_drc_history_tool', nor does it specify prerequisites or exclusions. The only implied usage is for KiCad PCB files, but no explicit context is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but provides minimal behavioral information. It mentions 'analyzes a schematic' and 'recognizes common circuit blocks' but doesn't disclose performance characteristics, error conditions, what happens with invalid inputs, or whether this is a read-only operation. The mention of 'ctx: MCP context for progress reporting' hints at potentially long-running analysis but doesn't elaborate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections: purpose statement, examples of recognized patterns, parameter explanations, and return value description. It's appropriately sized with no redundant information, though the bulleted list of circuit patterns could be slightly condensed.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (pattern recognition in schematics), no annotations, and the presence of an output schema (which handles return value documentation), the description provides adequate context. It explains what the tool does, what it analyzes, and what parameters it needs, though more behavioral transparency would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description compensates well by explaining both parameters: 'schematic_path: Path to the KiCad schematic file (.kicad_sch)' and 'ctx: MCP context for progress reporting'. This adds meaningful context beyond the bare schema, though it doesn't specify file path format requirements or constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Identify common circuit patterns in a KiCad schematic' with specific examples of what it recognizes (power supply circuits, amplifier circuits, etc.). It distinguishes itself from siblings like 'analyze_schematic_connections' or 'find_component_connections' by focusing on pattern recognition rather than connection analysis.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context through the parameter description (requires a KiCad schematic file) but doesn't explicitly state when to use this tool versus alternatives like 'analyze_project_circuit_patterns' or 'analyze_schematic_connections'. No explicit guidance on prerequisites or exclusions is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the tool's purpose (extracting connection information) and mentions progress reporting via the context parameter, which adds some behavioral context. However, it doesn't describe important traits like whether this is a read-only operation, potential performance characteristics, error conditions, or what specific information the dictionary contains.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with a clear purpose statement followed by dedicated sections for Args and Returns. Every sentence adds value: the first establishes scope, the second elaborates on what information is extracted, and the parameter explanations provide essential usage details without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no annotations, but has output schema), the description provides good coverage. It explains all parameters meaningfully and states the return type (dictionary with component connection information). The output schema existence means the description doesn't need to detail return values. However, more behavioral context would improve completeness for a tool with no annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides meaningful explanations for all three parameters beyond their schema titles: 'project_path' is clarified as 'Path to the KiCad project file (.kicad_pro)', 'component_ref' gets an example ('e.g., "R1", "U3"'), and 'ctx' is explained as 'MCP context for progress reporting'. With 0% schema description coverage, this significantly compensates by adding practical usage context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('find all connections'), target resource ('for a specific component in a KiCad project'), and scope ('how a specific component is connected to other components'). It distinguishes itself from siblings like 'analyze_schematic_connections' (which appears broader) by focusing on a single component's connections.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context through the parameter explanations (needs a project file and component reference), but doesn't explicitly state when to use this tool versus alternatives like 'extract_schematic_netlist' or 'analyze_schematic_connections'. No explicit guidance on prerequisites or exclusions is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![kicad-mcp MCP server](https://glama.ai/mcp/servers/lamaalrajih/kicad-mcp/badges/card.svg)](https://glama.ai/mcp/servers/lamaalrajih/kicad-mcp)

Score Badge

Copy to your README.md:

[![kicad-mcp MCP server](https://glama.ai/mcp/servers/lamaalrajih/kicad-mcp/badges/score.svg)](https://glama.ai/mcp/servers/lamaalrajih/kicad-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/lamaalrajih/kicad-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server