PureScript MCP Server

by avi892nash

Overview Schema Related Servers Score Discussions

JavaScript

Local

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes, but there is some overlap between getTopLevelDeclarationNames and getTopLevelDeclarations, where the latter is a more detailed version of the former, which could cause confusion. Other tools like getFunctionNames and getTopLevelDeclarationNames also have overlapping scopes, but descriptions help clarify differences.
Naming Consistency2/5
Naming is inconsistent with mixed conventions: snake_case (e.g., get_server_status, start_purs_ide_server), camelCase (e.g., getFunctionNames, pursIdeCwd), and verb_noun patterns vary (e.g., generate_dependency_graph vs. pursIdeList). This lack of a predictable pattern makes the tool set harder to navigate.
Tool Count3/5
With 19 tools, the count is borderline high for a PureScript server, leaning towards heavy but not extreme. It covers both IDE server management and code analysis, which justifies some bulk, but it could be streamlined for better coherence.
Completeness5/5
The tool set provides comprehensive coverage for PureScript development, including IDE server lifecycle management (start, stop, status), code analysis (dependencies, imports, types, usages), and module operations (load, rebuild, reset). No obvious gaps exist for the stated domain.
Average 4.1/5 across 19 of 19 tools scored. Lowest: 3.3/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues 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 status not available
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 of behavioral disclosure. It states what the tool does (finds 'where' clauses) and their purpose (contain local helper functions and variables), but doesn't describe the return format, error handling, performance characteristics, or whether it requires specific code formatting. For a code analysis tool with zero annotation coverage, this leaves significant behavioral gaps.
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 extremely concise (two sentences) and front-loaded with the core purpose in the first sentence. Every word earns its place: the first sentence defines the action and target, the second explains the utility. No redundant information 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 the tool's moderate complexity (code analysis with one parameter), 100% schema coverage, but no annotations or output schema, the description is minimally adequate. It explains what the tool does and why, but doesn't address return format, error cases, or detailed behavioral expectations. For a tool without output schema, more information about what gets returned would be 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?
The input schema has 100% description coverage with one parameter ('code') clearly documented as 'PureScript code snippet.' The description adds minimal value beyond this, mentioning 'PureScript functions' which aligns with the schema but doesn't provide additional context about code format expectations, size limitations, or preprocessing requirements. With complete schema coverage, the baseline score of 3 is appropriate.
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: 'Find 'where' clauses in PureScript functions' with the specific resource being PureScript code. It distinguishes from siblings by focusing on 'where' clauses rather than imports, module names, or other code analysis tasks. However, it doesn't explicitly differentiate from tools like 'getTopLevelDeclarations' which might also analyze code structure.
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 implied usage context: 'Useful for understanding function implementation details' suggests this tool is for code analysis rather than execution or transformation. However, it doesn't explicitly state when to use this tool versus alternatives like 'getFunctionNames' or 'getTopLevelDeclarations', 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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions prerequisites ('IDE server running and modules loaded') and a high-level benefit ('Helps understand project structure and dependencies'), but it lacks details on behavioral traits such as error handling, performance characteristics, or what the output looks like (e.g., format, pagination). 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, with the core purpose stated first, followed by prerequisites and a benefit. It uses three concise sentences without unnecessary fluff, making it efficient. However, it could be slightly more structured by explicitly separating usage guidelines from the purpose, preventing a perfect score.
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 (2 parameters, no output schema, no annotations), the description is adequate but has clear gaps. It covers the purpose and prerequisites but lacks details on output format, error cases, or how it interacts with sibling tools. Without an output schema, the description should ideally explain return values, which it doesn't, making it minimally viable but incomplete.
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 100% description coverage, providing clear details for both parameters ('file' and 'listType'). The description adds minimal value beyond the schema, only implying the parameter usage in the opening sentence. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description doesn't significantly enhance 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: 'List available modules in the project or imports in a specific file.' It specifies the verb ('List') and resources ('modules' or 'imports'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'getImports' or 'getModuleName', which offer similar functionality, keeping it from 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 Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool: 'PREREQUISITES: IDE server running and modules loaded.' It also implies usage based on the 'listType' parameter (e.g., 'availableModules' vs. 'import'), but it doesn't explicitly state when to choose this tool over alternatives like 'getImports' or 'getModuleName', or specify exclusions, so it's not a full 5.
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?
No annotations are provided, so the description carries the full burden. It discloses prerequisites (IDE server running, modules loaded) and the tool's purpose, but lacks details on behavioral traits like rate limits, error handling, output format, or whether it's read-only or mutating. The description doesn't contradict annotations (none exist), but it's incomplete for a tool with no annotation coverage.
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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by prerequisites and usage context. Every sentence earns its place with no wasted words, making it efficient and easy to parse.
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 no annotations, no output schema, and 2 parameters with full schema coverage, the description is moderately complete. It covers purpose, prerequisites, and usage context but lacks details on output format, error cases, or behavioral constraints. For a tool with no structured safety or output info, it should do more to compensate.
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 100%, so the schema already documents both parameters (target_modules and max_concurrent_requests). The description doesn't add any meaning beyond what the schema provides—it doesn't explain parameter usage, constraints, or examples. Baseline 3 is appropriate when the schema does the heavy lifting.
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: 'Create a dependency graph showing which functions/types use which others in PureScript modules.' It specifies the verb ('Create'), resource ('dependency graph'), and scope ('PureScript modules'), distinguishing it from siblings like getImports or pursIdeUsages. However, it doesn't explicitly differentiate from all siblings (e.g., getTopLevelDeclarations might overlap in code analysis).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool: 'Useful for understanding code relationships and refactoring impact.' It includes prerequisites: 'IDE server must be running and modules must be loaded.' This gives explicit guidance on necessary conditions. However, it doesn't specify when not to use it or name alternatives among siblings.
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 of behavioral disclosure. It adds useful context about prerequisites (IDE server running) and the tool's value (understanding function expectations/returns), but doesn't describe behavioral traits like error handling, performance characteristics, or what happens when the search fails. The description doesn't contradict any annotations since none exist.
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 in two sentences: the first states the core purpose, the second provides prerequisites and value. Every element earns its place with no redundant information, making it appropriately sized and 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?
For a read-only lookup tool with 3 parameters, 100% schema coverage, and no output schema, the description is adequate but has gaps. It covers purpose and prerequisites well, but doesn't address what the tool returns (type signatures in what format?) or how it behaves with partial matches. Given the complexity and lack of output schema, more detail about return values 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 100%, so the schema already documents all three parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema (e.g., it doesn't explain how 'search' interacts with 'currentModule' or what 'filters' objects contain). This meets the baseline expectation when schema coverage is high.
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: 'Look up the type signature of functions, variables, or values in PureScript code.' It specifies the verb ('look up'), resource ('type signature'), and target ('functions, variables, or values'), but doesn't explicitly differentiate from sibling tools like 'getFunctionNames' or 'getTopLevelDeclarations' that might retrieve different information about PureScript code.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context with prerequisites ('IDE server running and modules loaded') and a usage scenario ('Helpful for understanding what a function expects and returns'). However, it doesn't explicitly state when to use this tool versus alternatives like 'getFunctionNames' or 'getTopLevelDeclarations', which could help with sibling differentiation.
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?
No annotations are provided, so the description carries the full burden. It discloses a prerequisite (IDE server must be running) and a use case (understanding project context), but does not cover other behavioral aspects like error handling, response format, or performance. This is adequate but has gaps, fitting a baseline 3.
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 two concise sentences with zero waste: the first states the purpose and prerequisite, the second adds value with the use case. It is front-loaded and every sentence earns its place.
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 simplicity (0 params, no output schema, no annotations), the description is reasonably complete for a read-only utility. However, it lacks details on return values or error cases, which could be helpful despite the low complexity. This meets minimum viability with clear gaps.
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 no parameter information is needed. The description does not add param details, which is appropriate. Baseline for 0 params is 4, as it avoids unnecessary repetition.
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: 'Get the current working directory that the IDE server is using.' It specifies the verb ('Get') and resource ('current working directory'), but does not explicitly differentiate it from siblings like 'get_server_status' or 'pursIdeList', which is why it's not a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for usage with 'PREREQUISITE: IDE server must be running' and 'Useful for understanding the project context.' However, it does not explicitly state when not to use this tool or name alternatives among siblings, so it falls short of a 5.
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 describes the tool's focus (functions only) and purpose (quick analysis), but lacks details on error handling, output format, or performance characteristics like speed or limitations. It adds some behavioral context but is incomplete.
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 two sentences, front-loaded with the core purpose, and every sentence adds value: the first defines the action and scope, the second provides usage context. There is no wasted text, making it highly efficient.
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 (extracting function names from code), no annotations, and no output schema, the description is adequate but has gaps. It explains what the tool does and its focus, but lacks details on return values, error cases, or edge behaviors, making it minimally viable but not fully complete.
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 100%, with the parameter 'code' documented as 'PureScript code snippet.' The description adds no additional parameter details beyond what the schema provides, such as examples or constraints, so it meets the baseline for high schema coverage without extra value.
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 ('Extract only function names') and resource ('from PureScript code snippets'), distinguishing it from siblings like getTopLevelDeclarationNames or getImports by focusing exclusively on functions while ignoring data types and classes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('Quick analysis for code understanding' and focusing on functions only), but does not explicitly state when not to use it or name alternatives among siblings, such as getTopLevelDeclarationNames for broader extraction.
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 full burden. It discloses the key behavioral trait of working 'without the IDE server', which is valuable operational context. However, it doesn't describe output format, error conditions, performance characteristics, or what happens with malformed code - leaving gaps for a tool with 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tightly focused sentences with zero waste. First sentence states core functionality with examples, second explains the purpose, third provides crucial operational context. Every sentence earns its place.
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?
For a tool with no annotations and no output schema, the description provides good purpose and operational context but leaves significant gaps. It doesn't describe what the output looks like (list format, structure), error handling, or edge cases. Given the complexity of code analysis, more completeness would be 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 100%, so the schema already documents both parameters thoroughly. The description adds no additional parameter information beyond what's in the schema. Baseline 3 is appropriate when the schema does all the parameter documentation work.
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 import statements'), the resource ('PureScript code'), and provides concrete examples ('import Data.List', 'import Prelude'). It explicitly distinguishes this tool from siblings by stating it 'Works without the IDE server' (unlike pursIde* tools).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('Shows what external modules the code depends on') and distinguishes it from IDE-dependent tools. However, it doesn't explicitly state when NOT to use it or mention specific alternatives among the siblings (e.g., when to use getModuleName instead).
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 that the tool performs 'Fast analysis' and works 'without needing IDE server', which are useful behavioral traits. However, it doesn't mention potential limitations like file size constraints, error handling, or performance characteristics beyond speed.
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 in two sentences that each earn their place: the first states the core functionality and scope, the second adds important behavioral context about speed and server requirements. No wasted words.
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?
For a read-only analysis tool with no annotations and no output schema, the description provides adequate but minimal context. It explains what the tool does and some behavioral aspects, but doesn't describe the return format (e.g., array of strings) or potential edge cases, leaving gaps for the agent 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 schema has 100% description coverage, so the baseline is 3. The description doesn't add any parameter-specific information beyond what's in the schema (which already explains the 'filePath' and 'code' parameters and their mutual exclusivity).
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 ('List all main definitions'), resource ('PureScript code'), and scope ('just the names'). It distinguishes from sibling tools like 'getTopLevelDeclarations' by specifying it only returns names, not full declarations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('Fast analysis without needing IDE server'), but doesn't explicitly state when not to use it or name specific alternatives. It implies usage for quick name extraction versus more detailed analysis tools.
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 full burden. It discloses that it works on files or code snippets without needing the IDE server, which is useful behavioral context. However, it doesn't mention error handling, performance characteristics, or what happens with malformed input. The description doesn't contradict any annotations since none exist.
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?
Two sentences, zero waste. First sentence states purpose and scope, second sentence provides usage context. Every word earns its place with no redundancy or unnecessary elaboration.
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?
For a relatively simple extraction tool with 100% schema coverage but no output schema or annotations, the description provides good context about what it does and when to use it. It could be more complete by mentioning what the output looks like (since no output schema exists) or error conditions, but it covers the essential purpose well.
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 100%, so the schema already fully documents both parameters. The description mentions 'files or code snippets' which aligns with the filePath/code parameters but doesn't add meaningful semantics beyond what the schema provides. Baseline 3 is appropriate when the schema does the heavy lifting.
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 ('extract'), resource ('module name from PureScript code'), and scope ('files or code snippets without needing the IDE server'). It distinguishes from siblings like getFunctionNames or getImports by focusing specifically on module names.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('useful for understanding code structure') and mentions it works without the IDE server, which differentiates it from some sibling tools. However, it doesn't explicitly state when NOT to use it or name specific alternatives for related tasks.
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 describes what information is returned (detailed info including names, types, full source code) and mentions filtering capabilities, but doesn't disclose important behavioral aspects like whether this is a read-only operation, potential performance implications, error conditions, or response format. The description adds some value but leaves significant gaps.
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 concise with two sentences that each serve distinct purposes: the first states the core functionality, the second adds comparative context. No wasted words, though it could be slightly more front-loaded by mentioning filtering earlier.
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?
For a tool with 3 parameters, no annotations, and no output schema, the description provides adequate but incomplete context. It covers the purpose and distinguishes from one sibling, but doesn't address the response format, error handling, or performance characteristics that would be helpful given the lack of structured metadata.
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 100%, so the schema already documents all parameters thoroughly. The description mentions 'filtering options' but doesn't add meaningful semantic context beyond what's in the schema. It doesn't explain when to use filePath vs code, or provide examples of filter usage. Baseline 3 is appropriate when the schema does the heavy lifting.
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: 'Get detailed information about all main definitions in PureScript code' with specific details about what information is returned (names, types, full source code). It explicitly distinguishes from sibling tool 'getTopLevelDeclarationNames' by stating it's 'more comprehensive'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides excellent usage guidance by explicitly comparing to the sibling tool 'getTopLevelDeclarationNames' and stating this tool is 'more comprehensive.' This tells the agent when to choose this tool over that specific alternative, though it doesn't mention other siblings.
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 of behavioral disclosure. It effectively describes the tool's purpose and speed advantage, but lacks details on error handling, output format, or potential side effects (e.g., whether it modifies files or only reports errors). The mention of prerequisites adds some context, but more behavioral traits would enhance transparency.
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 three sentences: the first states the core purpose, the second lists prerequisites, and the third provides usage context and comparison. Every sentence adds value without redundancy, making it front-loaded and appropriately sized for the tool's complexity.
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 output schema, no annotations), the description is mostly complete. It covers purpose, prerequisites, and usage context well, but lacks details on return values or error behavior. Since there's no output schema, some additional information about what the tool returns would improve completeness, though the current description is sufficient for basic understanding.
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 100%, providing complete parameter documentation. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't explain 'data:' format details or codegen options further). This meets the baseline score of 3 since the schema adequately covers parameter meanings.
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 ('recompile a single PureScript module and check for errors'), identifies the resource ('PureScript module'), and distinguishes it from sibling tools by emphasizing speed ('Much faster than full project rebuild') and context ('when editing code to get immediate feedback'). This provides precise differentiation from tools like 'pursIdeLoad' or 'start_purs_ide_server'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('Use when editing code to get immediate feedback'), provides prerequisites ('IDE server running and modules loaded'), and contrasts it with alternatives ('Much faster than full project rebuild'), giving clear guidance on its appropriate context versus other rebuild or IDE operations.
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 of behavioral disclosure. It effectively indicates this is a read-only analysis tool ('Find everywhere... is used') and adds useful context about prerequisites and refactoring workflow. However, it lacks details on output format, error handling, or performance characteristics that would enhance transparency.
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 three sentences that each serve distinct purposes: stating the core functionality, listing prerequisites, and providing usage guidance. There's no wasted text, and the information is front-loaded with the main purpose immediately clear.
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?
For a tool with no annotations and no output schema, the description does well in covering purpose, prerequisites, and usage context. It could be more complete by describing the return format or what constitutes a 'usage' result, but given the schema's thorough parameter documentation and the clear behavioral context provided, it's largely adequate.
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 100%, so the schema already documents all three parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema, maintaining the baseline score. It doesn't compensate but doesn't need to given the comprehensive schema coverage.
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 a specific verb ('Find') and resource ('usages of a specific function, type, or value across the project'). It distinguishes itself from siblings like 'getFunctionNames' or 'getTopLevelDeclarations' by focusing on cross-project usage analysis rather than listing or querying definitions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool ('Essential for refactoring - shows impact of changes') and when to invoke it ('If you plan to refactor, get usages before refactoring'). It also mentions prerequisites ('IDE server running and modules loaded'), offering clear context for proper usage.
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?
No annotations are provided, so the description carries the full burden. It describes the core behavior ('echoes back your input') and purpose ('test tool'), but doesn't disclose potential behavioral traits like whether it modifies data, has rate limits, or requires specific permissions. For a simple test tool with no annotations, this is adequate but not comprehensive.
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?
Perfectly concise with two sentences that each earn their place: the first explains what the tool does, the second explains when to use it. No wasted words, and the information is front-loaded appropriately.
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 simplicity (one parameter, no output schema, no annotations), the description is nearly complete. It explains the purpose, usage, and parameter semantics effectively. The only minor gap is the lack of explicit behavioral details like whether it's read-only or has side effects, but for a test tool, this is acceptable.
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 and only one parameter ('message'), the description adds meaningful context by explaining that the tool 'echoes back your input,' which clarifies that the 'message' parameter is the content to be returned. This compensates well for the lack of schema documentation.
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 a specific verb ('echoes back') and resource ('your input'), and distinguishes it from siblings by specifying it's a 'test tool' for verification purposes. It goes beyond the name 'echo' by explaining the testing context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use this tool: 'Use to verify the MCP server is responding correctly.' This provides clear guidance on the tool's intended purpose versus its sibling tools, which appear to be IDE/server management functions.
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?
No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: it's a prerequisite action that enables other tools, implying it's a setup/initialization step. However, it doesn't mention potential side effects (e.g., loading time, memory usage), error handling, or what happens if modules fail to load. For a tool with no annotations, this is adequate but lacks depth.
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 front-loaded with the core purpose, followed by prerequisite and usage guidance in clear, imperative sentences. Every sentence earns its place: the first explains what it does, the second states prerequisites, and the third gives timing instructions. No wasted words.
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 complexity (initialization step for an IDE server), no annotations, and no output schema, the description is fairly complete. It covers purpose, prerequisites, and usage sequence, which are critical for an agent. However, it lacks details on expected outcomes (e.g., success indicators) or error cases, leaving some gaps.
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 input schema has 100% description coverage, so the baseline is 3. The description adds value by explaining the tool's purpose and prerequisites, which helps contextualize the 'modules' parameter (e.g., why loading modules is needed). However, it doesn't provide additional semantic details about the parameter beyond what the schema says (e.g., module naming conventions).
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 ('Load PureScript modules into the IDE server') and the purpose ('for type checking and completions'), distinguishing it from siblings like 'pursIdeList' (which likely lists modules) or 'pursIdeType' (which likely checks types). It uses precise verbs and resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides explicit usage instructions: 'PREREQUISITE: IDE server must be running' and 'ALWAYS run this first after starting the IDE server before using other pursIde* tools.' This clearly indicates when to use it (after server start, before other IDE tools) and distinguishes it from alternatives like 'start_purs_ide_server' (which starts the server).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and effectively discloses key behavioral traits: it's a read-only check (implied by 'Check' and 'Shows'), it helps avoid conflicts, and it monitors specific processes. However, it lacks details on output format or error handling, which could be useful for an agent.
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 front-loaded with the main purpose, followed by specific details and usage instructions in two concise sentences, with no wasted words—every sentence adds value to the agent's understanding.
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 complexity (simple status check with no parameters), no annotations, and no output schema, the description is mostly complete—it covers purpose, usage, and behavioral context. However, it doesn't specify what the status output looks like (e.g., success/failure indicators), leaving a minor gap.
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?
Since there are 0 parameters and schema coverage is 100%, the baseline is 4. The description adds context by explaining the tool's purpose and usage, which compensates for the lack of parameters, making it clear that no inputs are needed for this status check.
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 verbs ('Check', 'Shows') and resources ('IDE server processes', 'Tree-sitter parser', 'purs IDE server'), distinguishing it from siblings like 'start_purs_ide_server' or 'stop_purs_ide_server' by focusing on status checking rather than control operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides explicit guidance on when to use the tool ('ALWAYS use this before starting new IDE servers') and why ('to avoid resource conflicts', 'to prevent running multiple processes simultaneously'), with clear context for its application relative to other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/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 effectively describes the tool's behavior ('Gracefully shut down... and free up resources'), prerequisite condition, and how it differs from an alternative tool. However, it doesn't mention potential side effects like whether unsaved work might be lost or if there's a confirmation step, leaving some behavioral aspects unclear.
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 perfectly concise with two sentences that each earn their place: the first states the core action and resource, the second provides prerequisite and sibling comparison. There's no wasted language, and information is front-loaded effectively.
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 this is a shutdown tool with 0 parameters and no annotations or output schema, the description provides good contextual completeness by explaining the action, prerequisite, and sibling relationship. However, it doesn't mention what happens after shutdown (e.g., confirmation message, error handling), which would make it more complete for a server control tool.
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 with 100% schema description coverage, so the baseline is 4. The description appropriately doesn't discuss parameters since none exist, maintaining focus on the tool's core functionality without unnecessary details.
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 a specific verb ('Gracefully shut down') and resource ('the IDE server'), and explicitly distinguishes it from its sibling tool 'stop_purs_ide_server' by noting it uses the server's built-in quit command first. This provides clear differentiation and avoids tautology.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('PREREQUISITE: IDE server must be running') and provides a direct alternative ('Same effect as stop_purs_ide_server but uses the server's built-in quit command first'), giving clear guidance on when to choose this tool over its sibling.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/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 effectively describes the destructive nature ('Clear all loaded modules'), the prerequisite state ('IDE server must be running'), and the post-action requirement ('run pursIdeLoad again'). However, it doesn't mention potential side effects like loss of unsaved state or performance impact, which could be relevant for a memory-clearing operation.
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 perfectly front-loaded with the core purpose in the first sentence, followed by prerequisite and usage guidance. Every sentence adds essential information with zero waste, making it highly efficient and well-structured for an AI agent.
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?
For a 0-parameter tool with no annotations and no output schema, the description provides excellent context about purpose, prerequisites, usage timing, and follow-up actions. The only minor gap is the lack of explicit mention about what 'clearing memory' entails operationally (e.g., whether it affects server stability or requires reinitialization), but overall it's highly complete for its complexity level.
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 with 100% schema description coverage, so the baseline is 4. The description appropriately doesn't discuss parameters since none exist, focusing instead on contextual information about when and how to use the tool.
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 ('Clear all loaded modules') and the target resource ('IDE server's memory'), distinguishing it from siblings like pursIdeLoad (loads modules) or pursIdeList (lists modules). It uses precise language that leaves no ambiguity about what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly provides when to use ('when switching projects or after major code changes'), prerequisites ('IDE server must be running'), and a named alternative action ('You'll need to run pursIdeLoad again after this'). This gives comprehensive guidance on context and sequencing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/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 effectively describes several important behaviors: the automatic stopping of existing servers, the single-instance constraint, the random port selection with return value, and the absolute path requirement. It doesn't mention error handling, timeouts, or resource consumption, but covers the most critical operational aspects.
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 five concise sentences, each delivering essential information. It's front-loaded with the primary purpose, followed by operational constraints, prerequisites, port behavior, and path requirements. There's no redundant or unnecessary content - every sentence earns its place.
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?
For a server initialization tool with no annotations and no output schema, the description provides strong coverage of the critical behaviors and constraints. It explains the prerequisite relationship with other tools, the singleton nature of the server, the automatic conflict resolution, and the port selection behavior. The main gap is the lack of information about what the response contains beyond the port number.
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 only 25% schema description coverage (only 'project_path' has a description), the description compensates by emphasizing the absolute path requirement for the critical 'project_path' parameter. While it doesn't detail the other three parameters, it establishes the core constraint that applies to the most important required parameter, adding meaningful context beyond the sparse schema documentation.
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 ('Start the PureScript IDE server') and its primary functions ('type checking, auto-completion, and error detection'). It distinguishes this tool from its sibling 'stop_purs_ide_server' by being the complementary start operation, and from other pursIde* tools by being the prerequisite server initialization.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool: 'Required for all pursIde* tools to work' establishes it as a prerequisite. It also specifies when-not scenarios: 'Only run one at a time' and 'Automatically stops any existing server to prevent conflicts' tells the agent to avoid redundant invocations. The context of sibling tools reinforces this positioning.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/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 effectively communicates that this is a destructive action (server stops, other tools become unavailable) and implies it's a system resource management operation. However, it doesn't mention potential side effects like unsaved state loss or restart procedures.
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 perfectly concise with three tightly focused sentences: purpose statement, usage guidance, and consequence disclosure. Every sentence earns its place with no wasted words, and the information is front-loaded with the core action.
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?
For a zero-parameter tool with no annotations or output schema, the description provides excellent context about purpose, usage scenarios, and consequences. It could potentially mention restart procedures or confirmatory feedback, but covers the essential information needed for safe invocation.
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 zero parameters with 100% schema description coverage, so the baseline is 4. The description appropriately doesn't discuss parameters since none exist, maintaining focus on the tool's purpose and 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 ('Stop') and target resource ('PureScript IDE server'), distinguishing it from siblings like 'start_purs_ide_server' and 'get_server_status'. It explicitly mentions the purpose of freeing system resources, which adds meaningful context beyond just the tool name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool ('when you're done with type checking or want to switch projects') and clearly states the consequences ('All pursIde* tools will stop working after this'), helping the agent understand the trade-offs and when alternatives might be appropriate.
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:

[![purescript-mcp-tools MCP server](https://glama.ai/mcp/servers/avi892nash/purescript-mcp-tools/badges/card.svg)](https://glama.ai/mcp/servers/avi892nash/purescript-mcp-tools)

Score Badge

Copy to your README.md:

[![purescript-mcp-tools MCP server](https://glama.ai/mcp/servers/avi892nash/purescript-mcp-tools/badges/score.svg)](https://glama.ai/mcp/servers/avi892nash/purescript-mcp-tools)

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/avi892nash/purescript-mcp-tools'

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