ECOUNT MCP Server

Server Quality Checklist

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

Latest release: v0.1.3
Disambiguation4/5
Most tools have clearly distinct purposes, but the four inventory tools and three diagnostic/status tools could be confused. Descriptions are detailed enough to disambiguate, keeping the set mostly clear.
Naming Consistency4/5
Tools follow a consistent 'ecount_<verb>_<noun>' pattern with get/create verbs. Minor deviations like 'ecount_server_status' (missing 'get' prefix) and compound names like 'ecount_create_clock_in_out' slightly break the pattern but are still readable.
Tool Count4/5
23 tools is on the heavier side, but the ERP domain naturally spans many modules. The count is justified, though it could be trimmed by consolidating the redundant inventory query tools.
Completeness3/5
The server heavily favors create operations for many document types but lacks corresponding get/update/delete for most of them (e.g., customers only have create, quotations/sales orders only have create, and only purchase orders have a get). This leaves notable gaps for a general ERP integration.
Average 4.2/5 across 23 of 23 tools scored.
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

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses a rate limit and provides a detailed response format with result messages and error conditions. However, it does not mention idempotency, authorization requirements, or what happens on partial failures, which would be valuable 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 efficient, with the main purpose in the first sentence and additional behavioral details in brackets. It includes rate limit and response information without excessive prose. The structure is clear, though it could be slightly more front-loaded.
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 complex nested orders array and no output schema, the response format description is essential and provided. The rate limit and mention of pre-registered code add operational context. It lacks explicit error handling or rollback information, but the response format covers result reporting.
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. The description adds value by explaining that openmarketCode must be pre-registered in ECOUNT and categorizes the order fields (product, orderer/receiver, shipping). This is useful context but does not compensate for the schema's already thorough descriptions.
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?
Purpose is explicitly stated: registering external shopping mall orders (Naver, Coupang) into ECOUNT. The verb '등록' and resource '쇼핑몰 주문' are specific. It clearly distinguishes from sibling tools like create_sale_order by specifying external order integration.
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?
States it is for automating shopping mall order integration, giving clear context. It implies this is for external orders rather than internal sales, but does not explicitly exclude alternatives or mention when to use other ECOUNT order-create 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, the description carries the burden. It reveals a rate limit (10min/1 call), response caching (10min), and details the response structure including fields. It also discloses that omitting prodCodes returns all items. However, it stops short of declaring read-only explicitly, though '조회' implies it.
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 well-organized paragraph with explicit sections for rate limit and response. It is concise and avoids filler, earning a 4.
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?
No output schema exists, so the description compensates by listing the response fields. It covers the key parameters, rate limit, and use case. It doesn't mention error conditions or pagination, but for a read-only list tool with this scope, coverage is 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?
The input schema already provides full descriptions for all six parameters, so the baseline is 3. The description adds minimal extra meaning, mostly restating that baseDate is required and prodCodes can be omitted to query all items, which the schema already says.
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 retrieves multi-item inventory status by warehouse ('창고별 재고현황 다건 조회'), specifying the resource and scope. It notes it queries all warehouses, which distinguishes it from potential single-warehouse or single-item siblings, though it doesn't explicitly name alternatives.
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 an explicit use case: '전체 창고의 재고 현황을 파악할 때 사용합니다' (used to grasp inventory across all warehouses). It also explains behavior for optional parameters, but does not mention when to prefer sibling tools like get_inventory_by_warehouse.
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, the description carries the transparency burden. It discloses rate limits (10 sec/1 request), required formats, and response structure (success/failed counts, details). However, it misses important behavioral aspects like permission requirements, duplicate handling, or side effects, leaving some uncertainty about the tool's full behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: a single main sentence with purpose, followed by brackets for rate limit and response. Every piece of information earns its place, providing high information density without bloat.
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 batch create tool with no output schema, the description covers required fields, datetime format, optional flags, rate limiting, and response shape. It omits batch size limits and doesn't address the schema's internal inconsistency where some fields are marked '필수' but not in the required list, but overall it is adequately 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 coverage is 100%, providing descriptions for all fields. The description adds the datetime format and clarifies which fields are required, which is useful but largely redundant with the schema. It does not significantly deepen understanding beyond the structured definitions.
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 function: registering employee clock-in/out times in ECOUNT. It uses specific verbs (등록/registers) and identifies the resource (attendance records), distinguishing it from sibling tools focused on products, customers, sales, etc.
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 (to input attendance records) and specifies required fields and format. It does not explicitly mention alternatives or exclusions, but the sibling domain differences make the intended use obvious.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the rate limit (10 seconds/1 request), response format (success/failed/slipNos/details), and batch limit (300). However, it does not explicitly state the mutating nature beyond '등록' (register) or describe error handling for duplicates/partial failures beyond the response counts.
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 concise, with three sentences covering purpose, required/optional fields, and batch capacity, followed by a structured rate limit and response section. It is front-loaded and every sentence provides necessary information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The schema fully describes the single parameter's nested structure and constraints, while the description covers the response format and rate limit. It lacks explicit usage guidance versus alternatives or detailed error semantics, but for a batch-create tool with full schema coverage, it is largely 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%, so all parameters have comprehensive descriptions with constraints. The tool description only adds a high-level summary of required vs optional fields, which is already contained in the schema. It provides no additional semantic depth beyond what the schema already offers.
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 '새로운 품목을 ECOUNT에 등록합니다' (registers new products to ECOUNT), specifying the action (register) and resource (products). This distinguishes it from sibling tools like create_customer or create_sale, and it also highlights required vs optional fields.
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 the tool is for creating new products, which clearly differentiates it from other creation tools. However, it does not explicitly mention when to use this over alternatives or any exclusions, but the context is clear enough for proper selection.
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 the rate limit (1초/1회) and the response structure in detail, which is helpful. However, it does not mention whether the operation is read-only, any permissions required, or behavior when no data is found. For a query tool, the response and rate limit add value, but missing edge-case behavior keeps it at a 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 compact and well-structured. It opens with the purpose, then usage context, then required parameters, followed by clearly tagged [Rate Limit] and [Response] sections. Every sentence adds value with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with low complexity, the description covers the main purpose, usage, required parameters, rate limit, and response format. The optional whCode parameter is not mentioned in the description, but the schema explains it. The description could be more complete by noting the effect of whCode, but the schema covers it, so this is not a critical gap.
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%, and the schema already documents each parameter with descriptions and format constraints. The description only repeats that baseDate and prodCode are required, which is already in the schema. It adds no additional semantics beyond what the schema provides, so the baseline 3 is appropriate.
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 it is a single-record inquiry of inventory by warehouse for a specific item (특정 품목의 각 창고별 재고 수량을 조회). The verb '조회' (inquiry) and resource '창고별 재고현황' are specific, and the scope (단건 조회) distinguishes it from list variants like ecount_get_inventory_by_warehouse_list.
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 explicitly states when to use: '여러 창고에 분산된 재고를 창고별로 확인할 때 사용합니다' (use when checking inventory distributed across multiple warehouses by warehouse). It does not explicitly mention alternatives or when not to use, but the context is clear for a single-item query.
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 transparency burden. It discloses the rate limit (10초/1회) and the response structure (data array with seq, result, error), which is valuable. It does not detail side effects like whether multiple posts are created atomically or any permission requirements, but it does communicate the mutating nature and error behavior.
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 compact and front-loaded with the purpose, followed by field usage, use case, rate limit, and response format. The opening '게시글 입력.' is slightly redundant with the next sentence but does not significantly hurt clarity; otherwise, every sentence adds useful information.
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?
The tool has no output schema or annotations, but the description compensates by defining the response format and rate limit. It also explains the board ID and typical usage, covering the essential aspects of a create operation. Minor gaps exist, such as not explicitly stating that multiple posts can be created in one call or requiring authentication, but overall it is sufficiently 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?
The input schema has 100% description coverage for all properties, including bizz_sid, title, body_ctt, cust, prod, pic, and progress_status. The description mostly restates schema information (e.g., bizz_sid as board ID, title/body_ctt as inputs, customer/item/manager links) without adding new semantics beyond the schema, so the baseline of 3 is appropriate.
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 registers a post to the ECOUNT ERP bulletin board ('ECOUNT ERP 게시판에 글을 등록합니다'), specifies the resource type (게시판), and provides board ID semantics. It also mentions the use case (사내 공지나 업무 기록), which distinguishes it from sibling tools that create products, customers, or sales orders.
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 explicitly says it is used for writing internal notices or work records ('사내 공지나 업무 기록을 남길 때 사용합니다'), providing clear context. However, it does not mention alternatives or when not to use it, 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.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of disclosing behavior. It adds rate limit (10초/1회), batch size (max 300), and a structured response summary (success/failed counts, slipNos, details with errors). It also clarifies it creates only new customers ('신규'), implying no overwriting. However, it does not mention authentication requirements or potential duplicate handling, which could be important for a write operation.
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 compact: three sentences plus bracketed rate limit and response info. It is front-loaded with the main purpose, then details requirements and limitations. No filler or repetition, though the rate limit and response format are arguably additional but valuable.
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 (single array parameter with 9 nested fields), the description covers the core aspects: what it does, required/optional fields, batch limit, rate limit, and response shape. The absence of an output schema is compensated by the explicit response description. It could be slightly more complete with details on prerequisites or error scenarios, but overall it provides enough context for an agent to select and invoke the tool correctly.
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 already provides 100% coverage for the single 'customers' parameter and all nested fields, so the baseline is 3. The description reiterates that CUST_CD and CUST_DES are required and groups optional fields (대표자/주소/연락처/사업자번호), but adds no new semantic details beyond what the schema already documents. It does not provide example values or dependencies beyond the 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 clearly states the tool's function: it registers a new customer (client/partner) in ECOUNT. The verb '등록' (register) and resource '거래처' (customer) are specific, and it distinguishes itself from sibling tools like ecount_create_product or ecount_create_sale_order by targeting customers. It also clarifies the required vs optional fields.
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: this is for registering new customers in ECOUNT, with batch capacity up to 300 and a rate limit. However, it does not explicitly mention when to use this tool over alternatives or any exclusions, though the tool's name and sibling differentiation make the use case obvious. No explicit 'when-not' guidance is given.
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?
No annotations are provided, so the description carries the burden. It discloses the rate limit (10초/1회) and response structure (success, failed, slipNos, details), which are useful behavioral traits. It does not discuss side effects beyond creation, but for a create operation this is acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably concise, with a brief purpose statement followed by usage and response details in bracketed sections. It is front-loaded and readable, though the opening '생산입고 I 입력' is slightly terse.
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 create tool with one parameter, the description plus schema covers the needed context: purpose, when to use, required field, and response format. Since there is no output schema, including response details in the description is helpful and complete enough.
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 fully documents each parameter. The description highlights PROD_CD as required and mentions that QTY/PRICE are specified, but adds little beyond what the schema already provides. Baseline 3 is appropriate.
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 it registers a slip for receiving finished goods from production ('생산 완료된 완제품을 입고하는 전표를 등록합니다'), using a specific verb and resource. It also distinguishes itself from siblings like ecount_create_goods_issued by explicitly focusing on production input.
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 clear when-to-use guidance: '생산이 완료되어 완제품이 창고에 입고될 때 사용합니다' (use when production is complete and finished goods are received into warehouse). It does not mention alternatives or exclusions, but the context of production receipt is unambiguous.
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?
No annotations are provided, so the description carries the full burden. It goes beyond a simple create statement by disclosing the rate limit (10초/1회), the response structure (success, failed, slipNos, details), and the conditional account selection behavior. This is substantive operational context, though it does not mention session prerequisites or idempotency.
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 dense paragraph with structured bracket sections for rate limit and response. Every sentence adds value—tax codes, account selection, input amounts, and response details—with no filler. Slightly long but appropriate 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?
For a create-invoice tool with no output schema, the description covers key operational aspects: rate limit, response format, tax type codes, and account code rules. It does not mention batch size limits (though schema has maxItems 300) or session/auth requirements, but these are partially covered by sibling connection tools and schema.
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 schema already has 100% parameter description coverage, but the description adds meaningful relational semantics: it explicitly links TAX_GUBUN to whether CR_CODE (매출) or DR_CODE (매입) should be used, and gives example account codes. This clarifies usage beyond the individual schema descriptions.
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 that this tool registers accounting vouchers (tax invoices) in ECOUNT with automatic journal posting ('매출·매입전표 II 자동분개'). It specifies the resource (회계 전표) and the action (등록), and the tax/accounting focus distinguishes it from sibling tools like product or customer creation.
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 internal guidance on when to use CR_CODE vs DR_CODE based on TAX_GUBUN, but does not explicitly state when to use this tool versus alternatives like ecount_create_sale or ecount_create_purchase. The usage context is implied by the term '회계 전표' but no exclusions or alternative recommendations are given.
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?
No annotations are provided, so the description carries the full burden. It discloses the rate limit (10 seconds per request) and the response structure (success/failed counts, slip numbers, details array with error info). This adds meaningful behavioral context beyond the schema, though it does not elaborate on partial failure handling or authorization requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and structured, starting with the core purpose, then adding parameter notes, and ending with rate limit and response format. Every sentence provides useful information, with no fluff. It is slightly longer than the two-sentence ideal but remains efficient.
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 (many object parameters) and lack of output schema, the description compensates by including the response format and rate limit. It does not repeat the detailed schema descriptions, which is appropriate. The combination of schema and description is sufficient for an agent to understand the tool's behavior, though it omits some edge-case information like the 300-item limit (which the schema covers).
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 already provides 100% coverage with descriptions for all parameters. The description adds only a brief mention that PROD_CD is required and that quantity/due date/BOM version can be specified, which does not meaningfully go beyond the schema. Baseline 3 applies.
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 function with a specific verb ('작업지시서 입력' / register production plan) and identifies the resource (work order in ECOUNT). It distinguishes itself from sibling tools like ecount_create_sale_order or ecount_create_goods_issued by explicitly focusing on job orders (생산 계획).
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: when you need to register a production plan or enter a work order in ECOUNT. It also mentions which fields can be specified (quantity, due date, BOM version), but it does not explicitly state when NOT to use it or mention alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/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 the rate limit (10초/1회), response structure (success, failed, slipNos, details), and the grouping behavior via UPLOAD_SER_NO. It does not mention idempotency or failure atomicity, but the core behavioral traits are covered.
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 compact and front-loaded with the purpose. The first two phrases '구매 입력' and '구매(입고) 전표를 ECOUNT에 등록합니다' are somewhat redundant, but the overall length is appropriate and includes rate limit and response info in brackets without bloat.
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 create tool with a nested array schema and no output schema, the description covers the essential context: when to use, required field (PROD_CD), grouping key, rate limit, and response format. It does not explain prerequisites like authentication or field validation, but the schema covers parameter details.
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. The description adds only a general statement about quantity/unit price/amount and reinforces the grouping rule, which is already in the schema. It does not add significant new meaning beyond the 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 ('등록', to register), a resource ('구매(입고) 전표', purchase/receiving slip), and a clear scenario ('협력사로부터 물품을 구매하여 입고받았을 때'). This distinguishes it from sibling create tools like ecount_create_sale or ecount_create_quotation.
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 says when to use it: when purchasing goods from a partner and receiving them into stock. It does not name alternative tools for exclusions, but the context is clear enough to guide selection among siblings.
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 burden of behavioral disclosure. It adds a rate limit ('[Rate Limit: 10초/1회]') and a detailed response format ('[Response: success(성공건수), failed(실패건수), slipNos(전표번호 배열 - YYYYMMDD-N 형식), details(상세결과 - IsSuccess, TotalError, Errors 배열)]'), providing valuable operational context beyond the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with the purpose. It provides required fields, rate limit, and response format in a structured, compact format without unnecessary verbosity. Every sentence adds useful information.
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 creation tool with nested items array, the description covers key operational aspects: rate limit, required fields, and response envelope. While it does not explain maxItems (300) or item grouping behaviors, those are covered in the schema, and the response format is described, making the tool usable.
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 each parameter documented (e.g., WH_CD_F '자재를 보내는 창고', UPLOAD_SER_NO '같은 순번의 항목들은 하나의 전표로 묶임'). The description only reiterates that PROD_CD, WH_CD_F, WH_CD_T, and QTY are required, which is already in the schema, adding no extra 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 tool's function: '생산불출 입력' (production issue input), registering a slip for issuing materials for production. It further clarifies the direction (warehouse to production factory) and distinguishes it from related tools like goods receipt or sales orders.
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 specifies when to use it: '창고에서 생산 공장으로 원자재를 불출할 때 사용합니다' (used when issuing raw materials from warehouse to production factory). It does not explicitly mention alternatives or when not to use, but the context is clear enough.
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 full burden. It discloses key behaviors: items with the same UPLOAD_SER_NO group into one quotation, a maximum of 300 items, a rate limit of one request per 10 seconds, and the response format including success/failure counts and slip numbers. It does not cover authorization or reversibility, but the disclosed details are substantial.
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 concise and well-structured, starting with the main purpose, followed by requirements, grouping, limits, and clearly bracketed meta info (rate limit and response). Every sentence adds meaningful information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of an array-based creation tool with many optional fields, the description explains the grouping mechanism, maximum items, rate limit, and response structure. The schema covers parameter semantics, so the description is sufficiently complete for correct invocation, though it does not mention potential error handling beyond the response details.
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 coverage is 100%, with all parameters described in the schema. The description adds only a high-level mention of required PROD_CD and grouping logic, both already present in the schema. Thus, the description adds minimal value beyond the schema, but the schema is fully descriptive.
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 registers quotations (견적서) for customers in ECOUNT, using a specific verb '등록합니다' and resource '견적서'. It distinguishes from sibling tools by emphasizing customer-facing quotation presentation rather than sales orders or other document types.
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 that this tool is for entering quotations to present to customers, implying its use for quotation creation. However, it does not explicitly name alternative tools or state when not to use it, so it lacks explicit exclusions.
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 full burden. It provides a rate limit (1 request per second), an explicit response structure (date, prodCode, warehouseCode, inventory array with PROD_CD and BAL_QTY), and behavior when whCode is omitted. It does not mention any error conditions or permission requirements, but for a read operation this is solid 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 highly concise: three sentences plus two brief bracketed notes. It delivers the purpose, required parameters, optional behavior, rate limit, and response format without any filler or redundancy. 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 single-item read tool with no output schema and no annotations, the description covers the essential context: how to call, what the optional parameter does, the rate limit, and the exact response shape. It is slightly incomplete in not addressing empty-result behavior or error cases, but overall it is quite 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% and each parameter already has a clear description. The tool description repeats the required nature of baseDate/prodCode and the whCode optional behavior, adding little beyond the schema. The provided response format is helpful but not parameter-specific.
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 '재고현황 단건 조회' (single inventory status inquiry) and specifies that it retrieves inventory quantity for a specific item on a specific date. This verb+resource pairing and '단건' (single) distinction effectively differentiates it from sibling tools like ecount_get_inventory_list or ecount_get_inventory_by_warehouse.
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 gives clear context by marking baseDate and prodCode as required and explaining how whCode changes the result (specific warehouse vs. all-warehouse total). However, it does not explicitly mention when to prefer this tool over the list/warehouse variants, leaving out exclusion criteria.
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?
No annotations are provided, so the description carries full burden. It discloses rate limiting (10분/1회), result caching (10분), and the response structure, which goes beyond schema and adds useful behavioral context.
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 compact and front-loaded with the core purpose, followed by essential parameter behavior and metadata. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no annotations and no output schema, the description compensates by including response format, rate limits, and caching. It covers the main behavior well, though it leaves some boolean flags to schema descriptions (which is acceptable given full schema coverage).
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 baseline is 3. The description reinforces key parameters (baseDate required, prodCodes optional, includeZeroStock) but doesn't add new semantic detail beyond what the schema already provides.
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 '재고현황 다건 조회' (multi-item inventory query) and explains it queries multiple or all items at once, distinguishing it from single-item siblings like ecount_get_inventory.
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 provides clear context for when to use: for multiple/all items, with baseDate required and prodCodes optional. It doesn't explicitly name alternatives, but the use case is unambiguous.
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 the tool checks Zone info, session validity, and expiration time, which implies a read-only operation. But it does not explicitly state that it has no side effects or describe error behavior (e.g., what happens if the session is already expired). The debugging hint adds some context, but it lacks detailed behavioral disclosure beyond the obvious.
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 three short sentences, front-loaded with the main purpose, followed by details and usage. It is concise with no filler or repetition; every sentence adds value.
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 read tool with no output schema, the description covers what the tool does, what it checks, when to use it, and how to call it. The listed checked items (Zone info, validity, expiration) partially imply the return content, but the exact response format is not described. Given the low complexity, the description is sufficiently complete, though it could be improved by specifying the returned structure.
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 zero parameters, and the baseline for no parameters is 4. The description reinforces this with '인자 없이 호출합니다' (call without arguments), aligning with the schema. There is no additional parameter information needed since there are no parameters.
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 starts with '현재 ECOUNT 세션 상태 조회' (retrieve current ECOUNT session status), clearly identifying the action and resource. It lists specific checked items (Zone info, validity, expiration time), making the purpose concrete. This tool is distinct from sibling tools like ecount_server_status or ecount_test_connection because it focuses specifically on session state, even without naming them.
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 states when to use: '세션이 만료되었는지 확인하거나 디버깅할 때 사용합니다' (use to check if session is expired or for debugging). It also notes '인자 없이 호출합니다' (call with no arguments), providing direct invocation guidance. However, it does not explicitly mention alternatives or when not to use this tool, 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.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the behavioral burden. It discloses the rate limit (10초/1회), response format (success, failed, slipNos, details), and grouping behavior (UPLOAD_SER_NO groups items into one order). It does not explicitly mention side effects like updating the quotation status, but the create operation's additive nature reduces the need. This is solid 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 concise, front-loaded with the primary purpose, and each sentence adds value: use case, required parameters, grouping logic, rate limit, and response structure. There is no fluff or redundant phrasing.
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?
For a complex tool with a single array parameter with many sub-fields, the description covers the essential operational context: what it does, when to use it, key constraints (PROD_CD required), grouping behavior, rate limiting, and response fields. The schema covers all parameter semantics, and the description provides the meta-information an agent needs to invoke it correctly.
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% parameter description coverage, so the baseline is 3. The description adds emphasis on PROD_CD being required and DUE_DATE being specifiable, and repeats the UPLOAD_SER_NO grouping semantics already present in the schema. It does not provide additional parameter-level detail beyond the schema, so the description's contribution is minimal but consistent.
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 function: '주문서 입력' (order entry) and '고객으로부터 받은 주문을 ECOUNT에 등록합니다' (registers customer orders in ECOUNT). It also distinguishes from siblings by specifying the use case: '견적서가 확정되어 주문으로 전환될 때 사용합니다' (used when a quotation is confirmed and converted to an order).
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 a clear context for when to use the tool ('견적서가 확정되어 주문으로 전환될 때'), but it does not explicitly name alternative tools or state when not to use it. The scenario is specific enough to guide selection, though it could be stronger with explicit exclusions.
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 full burden. It adds valuable behavioral context: rate limit (10초/1회), response structure (success, failed, slipNos, details), and grouping behavior for UPLOAD_SER_NO. It does not mention auth/session requirements or inventory side effects, but the 'actual sales (shipping)' phrasing implies such impacts. It is more transparent than typical.
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 compact and well-structured: it starts with the purpose, then the usage condition, then key requirements, and finally rate limit and response format in brackets. Every sentence adds value, with no redundancy or filler.
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?
The description covers the essential context: what it does, when to use it, required fields, grouping behavior, rate limit, and response format. It does not mention array size limits (1-300) or default UPLOAD_SER_NO, but those are in the schema. Given the rich schema and the description's inclusion of response details, it is sufficiently complete for a create 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?
Schema coverage is 100% with descriptions for every field, so the baseline is 3. The description adds meaning by emphasizing that PROD_CD is required, listing key inputs (quantity, unit price, amount), and explaining the UPLOAD_SER_NO grouping mechanism—information that goes beyond the schema's per-field descriptions and clarifies how multiple items form a single slip.
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 it registers actual sales (shipping) slips in ECOUNT, using the specific verb '등록합니다' and resource '판매(출고) 전표'. It distinguishes from sibling tools like ecount_create_sale_order by specifying the condition '주문이 출고되어 매출이 발생했을 때' (when an order is shipped and revenue occurs). This is specific and 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 states when to use: when an order has shipped and sales have occurred. This provides clear contextual guidance. However, it does not explicitly name alternative tools or state when not to use this tool, though the sibling names like ecount_create_sale_order imply the distinction.
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?
No annotations are provided, so the description must carry the full burden of behavioral disclosure. It adds a rate limit ('[Rate Limit: 1초/1회]') and a detailed response field list with meanings, which are not present in the schema. However, it does not explicitly state error behavior or read-only nature, though '조회' (inquiry) implies it. This goes beyond minimal but leaves minor 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 concise and well-structured: it leads with the purpose, then usage guidance, then rate limit and response fields. Every sentence provides useful information without waste. The formatting with brackets for rate limit and response is clear and scannable.
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 the tool's low complexity (single parameter, no output schema), the description is adequately complete. It covers purpose, usage, rate limiting, and provides a full response field mapping with meanings, which is essential since no output schema exists. The only omission is error scenarios, but this is acceptable for a simple lookup tool.
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% coverage for the sole parameter prodCode, with a detailed description specifying it is mandatory, must be an exact ECOUNT code, and includes an example. The tool description adds no new parameter semantics beyond restating '정확한 품목코드' (exact code), so it does not elevate beyond the schema baseline.
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 function: '품목 단건 조회' (single item lookup) and '특정 품목코드의 상세 정보를 조회합니다' (retrieve detailed info of a specific item code). It distinguishes itself from sibling tool ecount_get_products by explicitly mentioning the alternative for searching when the code is unknown.
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 when-to-use guidance: '정확한 품목코드를 알고 있을 때 사용하세요' (use when you know the exact item code) and when-not-to-use with alternatives: '품목코드를 모르면 ecount_get_products로 검색하거나 전체 목록을 조회하세요' (if you don't know the code, search with ecount_get_products or view the full list). This fully addresses usage context and alternatives.
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 rate limit and caching behavior, which are critical behavioral traits. It also specifies the response structure and fields, making the tool's output predictable. It does not mention authentication or error handling, but for a read operation this is sufficient, though not exhaustive.
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 concise, front-loaded with the core function, and efficiently organizes auxiliary info in bracketed sections (Rate Limit, Response). Every sentence carries useful information, and the structured presentation aids quick parsing.
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?
Despite lacking an output schema, the description provides a complete response specification including field names and meanings. It also covers all calling modes and constraints. Given the tool's simplicity (2 optional params), the description is comprehensive enough for an agent to invoke it correctly without further clarification.
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 coverage is 100%, so both parameters have descriptions. The tool description adds value by explaining the relationship between prodCodes and prodType ('or') and the no-argument behavior for full listing, which enhances the semantic understanding beyond the schema alone. This is more than baseline but not overly detailed.
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 it performs '품목 다건 조회' (multi-product inquiry) and explicitly distinguishes from the singular sibling 'ecount_get_product' by emphasizing multiple products at once. The verb and resource are specific, and the query variants (by prodCodes, by prodType, or all) are clearly outlined.
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 usage contexts: specific products via prodCodes, by product type via prodType, or all products with no arguments. It also notes the rate limit (10 minutes per call), which informs when to use it sparingly. However, it does not explicitly name alternatives like 'ecount_get_product' for single-item queries, so it doesn't fully meet the 'explicit when-not' bar.
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 that this is a read-only status query ('조회'), specifies the data it returns, and notes '인자 없이 호출합니다' (no arguments). While it doesn't explicitly state side effects, the nature of the tool implies no mutation, and the detail is sufficient for safe invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: four short sentences in Korean, each providing necessary information (purpose, content, usage context, no-arg requirement). No wasted words, and the main purpose is front-loaded.
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?
For a zero-parameter, no-output-schema tool, the description is complete. It tells the agent what the tool does, what data it exposes (rate limit, error counters, cache, version), when to use it, and that it requires no arguments. There is no missing information needed for correct 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, and the description explicitly states '인자 없이 호출합니다' (call with no arguments). This matches the baseline for 0 params and adds clarity by preempting any assumption of inputs.
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: 'MCP 서버 내부 상태 조회' (query MCP server internal status), and lists specific items (Rate Limit 현황, 에러 카운터, 캐시 상태, 서버 버전). This distinguishes it from sibling tools that handle business operations like products, sales, and inventory.
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 states when to use the tool: 'API 호출이 차단되거나 느린 원인을 파악할 때 사용합니다' (use when API calls are blocked or slow). This provides clear context, though it does not explicitly mention when not to use it, which is acceptable for a diagnostic tool.
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?
No annotations are provided, so the description carries the full burden. It discloses that the tool checks three specific aspects (auth info, Zone lookup, login) and that it takes no arguments. However, it does not describe return values or failure behavior, which could be expected for a test tool, but overall it is sufficiently transparent for a connection check.
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 concise with three sentences, each adding distinct value: what it does, what it verifies, and when to use it. It is front-loaded with the purpose and contains no redundant information.
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 (no parameters, no output schema), the description covers the essential aspects: purpose, verification steps, usage prerequisite, and invocation. It is missing explicit information about expected response format, but for a connection test with no schema, this is 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?
The schema has zero parameters, and the description explicitly states 'called with no arguments' (인자 없이 호출합니다), reinforcing the empty schema. This is a solid baseline for a no-parameter tool, adding clarity that the agent does not need to generate any arguments.
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: testing the ECOUNT ERP connection by verifying authentication info and checking Zone lookup and login success. It distinguishes itself from siblings by explicitly positioning as a prerequisite to run before other ECOUNT tools.
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 when-to-use guidance: 'Run this before using other ECOUNT tools.' It also states it is called with no arguments, which sets expectations for invocation. No alternative tools are named, but the directive is unambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses rate limit (1 request per 10 minutes), result caching (10 minutes), and detailed response structure including order fields and status meanings. This goes beyond schema and gives the agent clear expectations.
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 dense but every clause adds value: purpose, required params, format, max range, filters, rate limit, and response fields. It is well-structured and front-loaded with the primary purpose.
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?
With no output schema, the description fully documents the response structure (period, count, orders array with field details) and rate limiting. It covers usage constraints and filters, making it self-sufficient for an agent.
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 already provides per-parameter descriptions (100% coverage). The description adds the critical 30-day max query range constraint and clarifies required fields, supplementing schema with cross-parameter semantics.
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 '발주서 조회' (purchase order inquiry) and '특정 기간의 발주서 목록을 조회합니다' (retrieves list of purchase orders for a specific period), providing a specific verb and resource. It distinguishes from siblings like ecount_get_product(s) and ecount_create_purchase by focusing on purchase order list retrieval.
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 specifies required date fields, YYYYMMDD format, 30-day max range, and optional filters by customer or product code. It gives clear context for when to use this tool (querying purchase orders by period) but does not explicitly name alternatives or exclusions.
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:

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

Score Badge

Copy to your README.md:

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

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/storehausai/mcp-server-ecount'

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