jzt-sepp-mcp-server

by zhengziha

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: v0.1.0
Disambiguation4/5
Most tools are distinct, but query_my_defects duplicates query_defects with default parameters, causing potential confusion about which to use. The monitor_* tools are clearly separated from query tools, but the redundant convenience wrapper slightly reduces clarity.
Naming Consistency4/5
The majority follow a verb_noun pattern (get_user_projects, query_defects, monitor_add, etc.), but login_status deviates by using a noun phrase instead of a verb action. This is a minor inconsistency, easily readable but not perfectly uniform.
Tool Count5/5
10 tools is well-scoped for the domain of user lookup, defect querying, and monitoring lifecycle. Each tool serves a clear purpose, and the count is neither too sparse nor excessive for the apparent functionality.
Completeness4/5
The tool surface covers user info retrieval, defect querying with filtering, and full monitoring lifecycle (add, list, remove, enable, run_once). A minor gap is the lack of an update/edit operation for monitoring tasks, but this can be worked around by delete/add, so it's not critical.
Average 3.8/5 across 10 of 10 tools scored. Lowest: 2.7/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 1 commit 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
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
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 only states the action without revealing side effects, permission requirements, or the impact on monitoring tasks (e.g., does enabling start immediate monitoring? Are changes reversible?). This is a significant gap for a state-changing operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, which is efficient, but it lacks content. While it doesn't waste words, it also doesn't earn its place by providing needed information. It is more under-specified than concise, so a moderate score is appropriate.
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?
With only two simple parameters and no annotations, the tool is not complex, but the description still fails to cover essential aspects: parameter meaning, usage context, and behavioral implications. The output schema exists but description does not clarify what the tool returns or any side effects. Sibling tools exist, but no guidance is given to distinguish them.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/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 by explaining parameters. The description does not mention 'name' or 'enabled' at all. An agent cannot infer that 'enabled' controls the enable/disable state or that 'name' identifies the task. This is a complete failure to add semantic 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 action ('启用/停用' = enable/disable) and the resource ('缺陷监控任务' = defect monitoring task). This differentiates it from sibling tools like monitor_add, monitor_remove, and monitor_run_once, which have distinct verbs and purposes.
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 gives no guidance on when to use this tool versus alternatives. It does not say 'use this to toggle the enabled state of an existing monitor' nor does it mention any prerequisites or exclusions. Agents are left to infer usage from the name alone.
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 only states 'delete', implying destructiveness, but does not describe permanence, reversibility, required permissions, or side effects (e.g., deleting associated runs or logs). This is a significant gap for a destructive operation without any annotation support.
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 a single, concise sentence with no fluff. It front-loads the verb and resource, making the core intent immediately clear. While extremely brief, it is appropriately sized for a simple delete operation and contains no redundant 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?
The tool is simple (one parameter, no enums, output schema present), but the description lacks crucial contextual details such as what the output represents, any error conditions, or how the 'name' parameter maps to the monitoring task. It provides the bare minimum and does not fully equip an agent to call it correctly, especially given the lack of parameter guidance and behavioral transparency.
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?
The schema has a single parameter 'name' with 0% description coverage, and the tool description does not explicitly clarify that 'name' refers to the monitoring task's name or how it is used for deletion. The description adds no semantic value beyond what the schema already shows (a string named 'name'), failing to compensate for the missing parameter 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 'Delete a defect monitoring task' states a specific verb (delete) and a clear resource (defect monitoring task), distinguishing it from sibling tools like monitor_add, monitor_list, and monitor_enable. The action and target are unmistakable, leaving 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 Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives. It does not mention preconditions, such as whether the task must exist, or any exclusions (e.g., do not use for disabling rather than deleting). The description provides no contextual direction for an agent choosing among the monitor 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 says 'view', which implies a read-only operation, but does not explicitly state that it has no side effects, nor does it mention authentication requirements, pagination, or any other behavioral characteristics. The implicit read-only nature is left to inference.
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, concise sentence with no unnecessary words. It is front-loaded with the primary action ('view') and resource, and the parenthetical detail about defect counts is efficiently included. There is zero fluff.
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 has no parameters and an output schema exists, the description is adequate for an agent to understand the tool's function. It clearly states what is being listed and what accompanies the status. It does not explain any optional behavior or edge cases, but given the simplicity of a parameter-less list operation, this is acceptable.
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 zero parameters, so schema coverage is effectively 100%. The description adds no parameter-level details because there are none to add. The baseline score of 3 applies since the schema already fully covers the (absent) parameters, and the description does not compensate with any clarification needed.
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 verb 'view' and the resource 'all defect monitoring tasks and status', including the specific detail of recorded defect counts. This is specific and distinguishes it from sibling tools like monitor_add or monitor_run_once which imply 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?
The description provides no guidance on when to use this tool versus alternatives. It does not mention when to use monitor_list vs query_defects or other monitoring tools, nor any conditions that would make this tool inappropriate. No exclusions or alternatives are named.
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 discloses that the tool executes a check and returns results (new/timeout counts), but it gives no information about side effects, permissions, idempotency, or whether the check mutates any state. For an action that triggers an immediate execution, this lack of detail is a notable 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 a single concise sentence that leads with the action and purpose. It contains no filler or redundancy. While it lacks structured formatting, it is efficient and front-loaded. It could be slightly more informative, but brevity is appropriate for a simple action.
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?
With an output schema present (though not shown), the return value is somewhat covered. The description explains the outcome (returns results) and the trigger. However, it does not mention possible error conditions (e.g., non-existent monitor), prerequisites, or side effects. Given the single-parameter simplicity and the presence of an output schema, the description is adequate but not thorough for a tool that executes an action.
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. It does add meaning by indicating that the parameter 'name' refers to the specific monitor to be checked ('指定监控'), which maps the parameter to the resource. However, it does not explicitly state that 'name' is the monitor identifier, nor does it give any format or validation hints. The minimal parameter makes this a moderate pass.
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 verb ('execute'), the resource ('monitor check'), and the immediate nature ('without waiting for the scheduled cycle'). It also indicates the output ('return results of this run'). This distinguishes it from sibling tools like monitor_add, monitor_list, monitor_remove, and monitor_enable, which manage monitors rather than execute a check.
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 phrase '不等定时周期' (does not await the scheduled cycle) implies the tool is for ad-hoc immediate checks, contrasting with the routine behavior of the monitor. However, it does not explicitly state when to prefer this over alternatives, nor does it mention any conditions or prerequisites. There is no explicit 'use when' or 'do not use when' guidance.
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 indicates a query operation (read-only implied) but does not explicitly state read-only, side effects, permissions, or pagination behavior. The equivalence to query_defects gives some behavioral context, but without knowing query_defects' full behavior, transparency is partial. Since it's a query, it's likely safe, but the disclosure is not explicit.
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 purpose and including a useful equivalence note. There is no fluff or redundant content; 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 simple query with an output schema, the description adequately covers the core purpose and default user. However, it omits parameter semantics and explicit behavioral transparency, which are needed given there are no annotations. The equivalence reference partially compensates but is not fully self-contained.
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%, and the description does not mention any of the three parameters (status, page_num, page_size). While the parameter names are self-explanatory, the description adds no meaning about how they affect the query or any constraints. It fails to compensate 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 queries a list of defects assigned to a specific default user (郑自航/1001967). It also explicitly notes the equivalence to query_defects with a specific parameter, distinguishing it from the generic sibling tool. This is a specific verb+resource+scope that leaves no ambiguity.
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 implies a clear use case: querying the current user's defects. The equivalence statement to query_defects helps an agent understand this is a convenience wrapper. However, it does not explicitly state when to use this versus the generic query_defects, nor does it mention any exclusions or alternatives beyond the equivalence.
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 must carry behavioral disclosure. It notes that the returned information is 'basically fixed' (该信息基本固定), conveying data stability. However, it does not mention side effects, authentication requirements, or any other behavioral traits. This is minimal but not misleading.
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 brief and front-loaded: a single sentence stating the purpose, followed by a concrete example. No redundant words or fluff; every element 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?
With no inputs and an output schema (though not shown here), the description provides an example of the output and notes that the data is stable. This is sufficient for an agent to call the tool correctly. The example compensates for any missing output schema details, and the 'basically fixed' note adds context about data volatility.
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 no parameters (schema defines none), and schema coverage is 100% since there is nothing to document. The baseline for zero parameters is 4, and the description does not need to add parameter details. It correctly focuses on the return 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 action (get) and resource (current logged-in user's project information on the energy efficiency platform) and provides a concrete example of the return structure. This distinguishes it from siblings like get_users, query_my_defects, and monitor_list, which target different resources.
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 does not explicitly state when to use this tool versus alternatives. While the purpose makes it obvious that it is for querying user projects, there is no mention of conditions, exclusions, or alternative tools. The context of siblings implies distinct resources, but no direct guidance.
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 disclosure burden. It adds value by stating the tool returns userId/userName/userAccount and supports fuzzy filtering — behavior not visible from the schema alone. However, it discloses no operational details such as pagination, whether an empty keyword returns all users, or authentication requirements. Given the read-only nature is implied rather than explicit, a 3 is appropriate.
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 compact sentences with zero filler. The first is front-loaded with the core purpose and returned fields; the second adds the downstream use case. Every clause earns its place, and the most important information appears first.
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?
An output schema exists, so return values need no explanation. The tool is a simple list query with one optional parameter, and the description covers purpose, filtering semantics, and the primary usage scenario. The only minor gap is not stating what an empty keyword returns, but the default '' implies it lists all users — a small omission against an otherwise complete definition.
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 does: '可按姓名或账号模糊过滤' explains that the keyword parameter matches fuzzily against both name and account fields — meaning the schema's bare 'keyword' string could not provide. This adds real semantic value beyond the input schema.
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 states a specific verb+resource: '查询能效平台用户列表' (query the energy platform user list), and names the returned fields (userId/userName/userAccount) plus the fuzzy filtering behavior. This is concrete and unambiguous, and the chained reference to query_defects further situates its role among siblings.
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 second sentence gives explicit usage context: use this tool to map an owner name/account to a userId, then pass that to query_defects for filtering. This tells the agent when the tool is the right choice. It doesn't name exclusions or when to prefer siblings like get_user_projects, but the stated use case is clear enough for a 4.
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 clearly states that the tool returns login status, account, sepp-auth expiry, and default user info, which gives the agent a concrete expectation of the output. It does not mention side effects (none expected for a read-only status check) and does not contradict any annotations (since none exist). The only minor gap is lack of explicit side-effect or permission notes, but the described behavior is unambiguous.
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, concise sentence that front-loads the primary action 'view current login status' and then enumerates the specific pieces of information returned. Every word adds value, with no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that the tool takes no parameters, has a provided output schema (so return format is covered), and the description explicitly lists the returned information, the description is complete for an agent to invoke it correctly. There are no missing operational details or ambiguities.
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, so the baseline is 4. The description adds no parameter information because none are needed; it correctly implies that no input is required. The schema already defines an empty object, so the description need not elaborate.
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 (查看/view) and resource (current login status), and includes specific details such as account, sepp-auth expiration time, and default user info. This distinguishes it clearly from sibling tools like get_users or query_my_defects, which target different resources.
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: use this when you need to check login status or retrieve default user information. However, it does not explicitly state when to use it versus alternatives, nor does it mention any exclusions or prerequisites. The intent is clear but not explicitly framed as a decision guide.
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, the description carries the burden. It discloses key behaviors: first execution is baseline (record-only), reminders start afterwards; notifications via webhook/email, logging otherwise. It also explains default assignee behavior. Missing details like persistence or immediate activation, but these are less critical for a creation tool.
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-organized with bullet points, front-loading the main purpose. It is reasonably concise but includes some redundant phrasing; still, every element adds value for a 9-parameter tool.
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 (9 params, no annotations) and that an output schema exists (though not shown), the description covers essential aspects: parameters, behavior, prerequisites, and suggestions. It doesn't explicitly address error cases or permissions, but these are not critical for initial use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides zero description coverage, so the description compensates fully. It explains fuzzy_responser, dev/test_responser_id, timeout_alert/hours, new_defect_alert, and interval_minutes, adding meaning beyond the schema's bare types and defaults.
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: creating a defect monitoring task with periodic polling and reminders. The verb 'add' is explicit, and it's distinguished from sibling tools like monitor_run_once, monitor_list, etc. by naming what it does.
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?
Provides a concrete usage suggestion: '建议先 monitor_run_once 建立基线' (recommends running monitor_run_once first to establish baseline). It also explains how to specify a responser using get_users. However, it doesn't explicitly state when not to use this tool or compare directly with all siblings, so it falls short of full guidance.
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. It discloses the crucial default behavior (all owner params empty → queries 'me'), the accepted input formats (userId/name/account for fuzzy_responser), and the raw JSON return (total/list). While it doesn't mention read-only nature or potential side effects, it's a query tool and the behavior is transparent enough.
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 parameter list, a default behavior paragraph, and return format note. It's a bit lengthy but each sentence adds value. The main purpose is front-loaded, and the parameter list is clearly formatted.
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 an 8-parameter tool with all optional parameters, the description provides sufficient context: default behaviors, parameter formats, and return structure. It could mention precedence when multiple owner filters are provided, but the tool can be called correctly based on the given information. The presence of an output schema (not shown) further reduces the need to detail returns.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate. It explains every parameter in detail: fuzzy_responser with examples, dev/test responser as userIds, status with default value, priority, summary, and pagination. It goes beyond the schema by providing the type of values (userId vs name) and default behaviors.
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 '查询缺陷列表' (queries a defect list) with owner-based filtering, which is a specific verb+resource. It also distinguishes itself from the sibling query_my_defects by explaining the default behavior falls back to the same query, making the tool's scope unambiguous.
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?
It explicitly explains when to use this tool versus query_my_defects: the default (no owner params) is equivalent to query_my_defects, and to query others you must pass fuzzy_responser. This gives clear conditional guidance, though it doesn't explicitly say 'use query_my_defects for your own defects' as a shortcut.
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:

[![jzt-sepp-mcp-server MCP server](https://glama.ai/mcp/servers/zhengziha/jzt-sepp-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/zhengziha/jzt-sepp-mcp-server)

Score Badge

Copy to your README.md:

[![jzt-sepp-mcp-server MCP server](https://glama.ai/mcp/servers/zhengziha/jzt-sepp-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/zhengziha/jzt-sepp-mcp-server)

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/zhengziha/jzt-sepp-mcp-server'

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