mcp-kr-g2b

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation5/5
Each tool targets a distinct module (bid, contract, statistics, user info, etc.) with no overlap. The support tools (get_g2b_operation_info, get_g2b_cache_data, list_g2b_services) have clearly separate purposes. An agent can easily differentiate them.
Naming Consistency5/5
All data retrieval tools follow the pattern get_<module>_data. Support tools use get_g2b_* and list_g2b_services, maintaining a consistent prefix. No mixed conventions or ambiguity.
Tool Count5/5
17 tools cover a comprehensive set of procurement data domains (bids, contracts, plans, prices, statistics, user info, etc.) without being excessive. Each tool serves a necessary function, well-scoped for the server's purpose.
Completeness5/5
The tool surface covers all major procurement lifecycle stages (pre-bid, bid, award, contract, statistics, user info) across public and private sectors. Support tools for metadata and caching fill gaps. No obvious missing operations for a read-only data API.
Average 4.4/5 across 17 of 17 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 5 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
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

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 of behavioral disclosure. It discloses that the tool calls an external API, that certain parameters are auto-processed, and that date-based queries are limited to 1-month ranges. However, it does not explicitly state that the tool is read-only, nor does it describe error handling, rate limits, or what happens if an invalid operation is provided.
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: an introductory sentence, clear instructions, a bullet list of operations, common parameters, and a warning. It is appropriately sized for the complexity, with no redundant sentences. A slightly more concise presentation without the extraneous 'PPSSrch' mention could improve it.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of an output schema, the description does not explain the return format or structure. It redirects users to get_g2b_operation_info for response fields, which is a reasonable workaround but leaves the description incomplete. It does cover pagination behavior (fetch_all) and the date range constraint, which is helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% description coverage for all 5 parameters. The tool description adds value by giving common query conditions for the 'params' parameter (e.g., inqryDiv, inqryBgnDt) with Korean explanations, and by clarifying that numOfRows, pageNo, type, serviceKey are auto-processed. This enhances understanding beyond the schema alone.
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 is for querying the '나라장터 공공데이터개방표준서비스' and lists three specific operations (getDataSetOpnStdBidPblancInfo, getDataSetOpnStdScsbidInfo, getDataSetOpnStdCntrctInfo) that correspond to distinct data categories (bids, successful bids, contracts). The verb '조회' (query) is specific, and the tool is differentiated from siblings by its focus on the 'data_standard' service.
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 detailed usage instructions: specifying operation and params, noting that some parameters are auto-handled, and directing users to get_g2b_operation_info for precise parameter/response fields. It also warns about date range limits (1 month) and suggests monthly splitting. However, it does not explicitly state when to use this tool versus its siblings (e.g., get_bid_data), nor does it list exclusion cases.
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 that numOfRows/pageNo/type/serviceKey are auto-handled, and includes a date range constraint. However, it lacks details on error handling, rate limits, or the full behavior of fetch_all beyond 'collect all pages'.
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 (few sentences) and well-structured: service definition, usage instructions, operation list, common parameters, and a warning. Every sentence adds value, though some redundancy exists with the schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and 5 parameters, the description covers usage and common constraints but does not explain the response structure or error scenarios. The reference to get_g2b_operation_info partially compensates, but the tool could benefit from more details on what to expect.
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 100% with clear descriptions for each parameter. The tool description adds value by listing common query keys and noting the date range limit, which goes beyond the schema. The mention of get_g2b_operation_info for exact parameters further aids understanding.
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 tool for querying industry data ('업종 및 근거법규정보 조회') from the Korea Public Procurement Service's open API. It specifies the single operation and resource, distinguishing itself from sibling tools focused on bids, contracts, 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 explains how to use the tool via operation and params, and provides common query conditions (e.g., inqryBgnDt, inqryEndDt). It includes a warning about date range limits (1 month). However, it does not explicitly state when not to use this tool or provide alternatives.
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 full burden. It discloses auto-handling of common parameters, fetch_all behavior (collects all pages vs single page), and the 1-month date limitation. It does not mention authentication, rate limits, or error handling, but for a data retrieval tool, the disclosed behaviors are adequate.
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: purpose statement, instructions, operation list, common params, and caution. It is slightly lengthy but every sentence adds useful information. Front-loaded with key operation list and instructions.
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?
No output schema exists, so the description should ideally explain return values. It does not, but offsets by suggesting get_g2b_operation_info for response fields. Given the tool's dependency on another tool for details, this is moderate completeness. Sibling tools and complexity (5 params, 5 operations) are handled adequately.
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 covers all 5 parameters with descriptions, so baseline is 3. The description adds significant value: it lists the exact operation names and their meanings, explains common param keys (inqryDiv, inqryBgnDt, etc.) with example values, notes the 1-month limit, and directs to another tool for full parameter details. This goes well beyond what the schema 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 explicitly states it is a query tool for '나라장터 사용자정보서비스' (user info service) and lists 5 specific operations, clearly distinguishing it from sibling tools like get_bid_data or get_contract_data which target different services.
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 instructions: specify operation in English, pass params as dict, auto-handles numOfRows/pageNo/type/serviceKey, references get_g2b_operation_info for exact parameters, and gives examples of commonly used parameters. It also warns about date range limits (1 month max). However, it does not explicitly compare to sibling tools or state when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full burden. It says it performs an inquiry ('조회합니다') but does not explicitly state read-only behavior, side effects, or authentication requirements. It lacks details on idempotency or potential caching, but is 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 a single, well-structured paragraph with no unnecessary words. It efficiently conveys purpose, usage, and next steps.
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 (1 boolean param, no output schema, 16 siblings), the description is fairly complete. It explains the tool's role as a discovery starting point and references sibling tools. Could optionally mention output format or pagination, but current content suffices.
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 a description for the single parameter 'include_operations'. The tool description adds no additional semantic value beyond the schema, meeting the baseline for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states that the tool lists 14 services and their operation overviews provided by the G2B MCP. It distinguishes itself as the starting point to decide which service to call, and references sibling tools like get_<module>_data and get_g2b_operation_info.
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?
Explicitly states it is the starting point to decide which service/operation to invoke. While it does not explicitly mention when not to use, it implies that after identifying the service, users should call the appropriate get_<module>_data tool or get_g2b_operation_info for details.
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 provided. The description discloses that date-based queries typically allow only 1-month ranges and need splitting, and that fetch_all collects all pages. However, it doesn't cover rate limits, authentication, or error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is fairly long but well-structured and front-loaded with the main usage pattern. It could be slightly more concise, but every sentence contributes 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?
The description covers the 5 parameters thoroughly and provides usage context including a companion tool for exact parameter details. However, it lacks information about the response format, though this is partially mitigated by the companion 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%, but the description adds meaningful context: explains the operation parameter with examples, lists common fields for params, and warns about date range limitations. This goes beyond the 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 the tool is for querying the Korean Public Procurement Service OpenAPI for private contract data from the Nuri marketplace. It lists four specific operations, distinguishing it from sibling tools like get_bid_data and get_contract_data.
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 explicit instructions: specify an operation, pass query conditions in params, and notes that numOfRows/pageNo/type/serviceKey are auto-handled. It suggests using get_g2b_operation_info for exact parameters and lists common query fields with a date range warning. However, it doesn't explicitly state when not to use this tool.
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 provided. Description indicates read-only operation on cache file. Does not disclose error handling, authentication needs, or rate limits, but for a simple query tool it's minimally adequate.
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 concise sentences. Front-loaded with main action and usage context. No extraneous 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 5 parameters and no output schema/annotations, description provides adequate purpose and usage context. Missing details on return format or errors, but overall sufficient for a query 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 parameter descriptions. Tool description adds context by mentioning 'field filter/page unit', reinforcing parameter roles. Adds value beyond schema but does not extensively 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?
Description clearly states the tool queries cached files from get_<module>_data calls with field filters and pagination. It distinguishes from sibling get_*_data tools which generate the cache.
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?
Explicitly says 'used for detailed exploration after previewing large query results', providing clear context. Lacks explicit when-not-to-use or alternatives, but sibling relationship implies correct usage.
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 that serviceKey, numOfRows, pageNo, type are auto-handled, that fetch_all controls full collection, and that date ranges are limited to 1 month. It lacks explicit statement that the operation is read-only, but that is implied by '조회' (inquiry).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear first sentence defining the service, followed by explicit instructions, a list of operations, common params, and a warning. It is somewhat lengthy but all information is pertinent and organized logically.
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 (multiple operations, no output schema), the description provides essential context: how to use operations, where to find exact parameters, pagination options, and date range limitations. It directs to get_g2b_operation_info for detailed field info, thus covering its interactivity well.
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?
All 5 parameters have schema descriptions (100% coverage). The description adds value by explaining the role of operation (one of 10 listed), the params dict, the fetch_all behavior, and providing a warning about date range limits. It enhances understanding 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 identifies the tool as a query for 조달청 나라장터 OpenAPI to retrieve private bid announcements (민간입찰공고). It distinguishes itself from siblings by being specifically for bid data (not contracts, plans, etc.) and lists all 10 operations with their purposes.
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 explains how to use the tool: specify operation and params, use get_g2b_operation_info for details, and warns that date range queries are limited to 1 month. It does not explicitly say when not to use it versus other tools, but it provides enough context for correct invocation.
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 that numOfRows/pageNo/type/serviceKey are auto-handled, date queries have a 1-month limit, and fetch_all controls pagination. It does not mention authentication, rate limits, or error responses, but the main behaviors 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 fairly long but well-organized: purpose, usage instruction, operation list, common params, warnings. All information is relevant and necessary. Slight redundancy in listing operations with both English and Korean, but it aids clarity. Could be slightly more concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite lacking an output schema, the description does not explain the response structure or return values. It directs to another tool (get_g2b_operation_info) for response fields, which helps, but the agent still lacks a high-level understanding of what data is returned. The fetch_all description hints at totalCount, but more detail would improve completeness.
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 100%, and the description adds significant value beyond schema. It explains operation with examples, lists common param keys (inqryDiv, inqryBgnDt, etc.) with semantics, and provides important usage notes like the date range limit and the special PPSSrch operation. This helps the agent build correct queries.
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: querying the Korean public procurement statistics service (공공조달통계정보서비스) via OpenAPI. It lists 14 specific operations with Korean descriptions, distinguishing it from sibling tools like get_bid_data or get_contract_data which are for different data 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 explains how to use the tool (specify operation, pass params, auto-handled keys), and points to get_g2b_operation_info for detailed parameter info. It also warns about date range limitations. However, it lacks explicit guidance on when to use this tool versus other sibling tools (e.g., 'for statistics, use this; for bids, use get_bid_data').
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 full transparency burden. It discloses that it queries an API, automatically handles some parameters (numOfRows, pageNo, type, serviceKey), supports pagination via fetch_all, and imposes a 1-month date range limit. It does not describe mutability or auth needs, but the overall behavior is well-explained.
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: it starts with overall purpose, then instructions, a complete list of operations (necessary for this complex tool), common parameters, and warnings. While lengthy, it avoids redundancy and every sentence provides useful information. The list of operations could be more concise, but it helps the agent understand available sub-functions.
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 (21 operations, multiple optional parameters, no output schema, no annotations), the description is fairly complete. It explains how to use the tool, pagination behavior, date constraints, and directs users to get_g2b_operation_info for detailed parameter/response fields. Rate limits or exact return structure could be added, but overall it provides sufficient context for an AI agent.
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?
Although the schema already describes all parameters (100% coverage), the description adds significant value: it lists common query conditions (inqryDiv, inqryBgnDt, etc.), explains that numOfRows/type/serviceKey are auto-handled, describes the meaning of fetch_all, and provides context for each of the 21 operations. This goes well beyond the 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 it is a tool for querying the Korea Procurement Service OpenAPI for contract data, and lists 21 specific sub-operations. The verb 'get' and resource 'contract data' are explicit, distinguishing it from sibling tools that handle different data types like bid or industry data.
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 detailed usage instructions: specify an operation, pass parameters as a dict, use get_g2b_operation_info for exact fields, and handle pagination. It warns about date range limits (1 month) and explains automatic param handling. However, it does not explicitly contrast with sibling tools or state when not to use this 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 interfaces with an external OpenAPI, auto-fills certain parameters, supports pagination via fetch_all, and imposes a date range constraint. It does not explicitly state that the tool is read-only (no side effects) or describe error handling, but the behavior is largely transparent. The reference to get_g2b_operation_info for response fields is helpful.
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: opening sentence identifies the tool, followed by usage instructions, a bullet-like list of operations, common parameters, and a warning. It is front-loaded with the main purpose. While it is relatively long (around 15 lines), each sentence adds useful information, so it is efficient rather than wasteful.
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 (7 operations, many parameters, external API), the description provides essential context: how to construct calls, where to find detailed schemas, common parameters, and limitations. It does not explain return values, but this is mitigated by referencing get_g2b_operation_info for response fields. The tool's place among siblings is partially clear, but more explicit differentiation would improve completeness.
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?
With 100% schema description coverage, the schema already describes each parameter. However, the description adds substantial value: it explains the purpose of each operation (in Korean), lists commonly used query parameters (inqryDiv, inqryBgnDt, etc.) with examples, and provides critical constraints (date range limits, differences between normal and PPSSrch operations). This goes well beyond the schema.
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 is for querying the 'Minm private subcontract award information service' via the Public Procurement Service's KONEPS OpenAPI. It lists 7 specific operations with Korean descriptions, making the purpose concrete. However, it does not explicitly contrast with sibling tools like get_bid_data or get_scsbid_data, leaving some ambiguity about when to use this specific tool.
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 instructions: specify 'operation' and 'params', explains that numOfRows/pageNo/type/serviceKey are auto-handled, advises using get_g2b_operation_info for exact parameters, lists commonly used parameters, and warns about date range limits (1 month) with guidance to split calls. This covers when and how to use the tool effectively.
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 auto-handling of pagination and service key, date range restrictions (1 month limit), and fetch_all behavior (collects all pages). However, it does not explicitly state read-only nature or auth requirements, though these are inferable from context.
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 organized with paragraphs, bullet lists, and visual separators. While lengthy, every sentence adds value; the list of 20 operations is necessary for clarity. Could be slightly more compact, but well-structured for the complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (many operations, no output schema, no annotations), the description is quite complete: covers usage, parameters, limitations, and points to a companion tool for details. Lacks explicit response format but that is delegated to get_g2b_operation_info.
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% (baseline 3). The description adds substantial value by explaining operation choices, providing common param keys, clarifying fetch_all, and noting num_of_rows max (999). It also directs users to a companion tool for exact parameter details, which is contextually helpful.
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?
Explicitly states the tool queries '나라장터 사전규격정보서비스' and lists 20 specific operations with Korean descriptions, making the purpose unmistakable and fully differentiated from siblings.
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?
Provides comprehensive usage guidance: how to specify operation and params, notes auto-handling of common parameters, recommends using get_g2b_operation_info for exact details, lists common query parameters, warns about date range limitations, and distinguishes PPSSrch operations for advanced search.
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 key behaviors: pagination via 'fetch_all' and 'page_no' parameters, auto-handling of certain parameters, and the 1-month date range restriction. It implies read-only behavior (조회). While it doesn't explicitly state 'read-only', the context is clear. The description adds significant value 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is somewhat lengthy due to the 23-operation list, but it is well-structured and front-loaded with purpose. Each section earns its place: purpose, usage instruction, operation list, common params, and warnings. Minimal redundancy; could be slightly more concise, but overall efficient for the information density.
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 (5 parameters, 1 required, 23 operations with varying params), the description covers essentials: operation choices, parameter usage, pagination, and date limitations. It appropriately directs users to get_g2b_operation_info for detailed parameter/response info. No output schema, but that is compensated by the cross-reference. The description is complete enough for effective use.
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%, but the description adds substantial context: it lists all 23 operation values (schema only has a generic example), provides concrete example keys for 'params' (e.g., inqryDiv, inqryBgnDt), and explains differences for PPSSrch operations. This enriches understanding beyond the parameter descriptions alone.
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 tool for querying the Korean Public Procurement Service (나라장터) OpenAPI for successful bid (scsbid) data. It lists all 23 available operations with Korean descriptions, making the purpose explicit and distinguishing it from sibling tools like get_bid_data or get_contract_data, which target different data types.
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 instructions: specify operation in the 'operation' parameter, pass query conditions via 'params', and notes that numOfRows/pageNo/type/serviceKey are auto-handled. It advises using get_g2b_operation_info for exact parameters/response fields, lists commonly used query keys, and warns about the 1-month limit on date ranges. This comprehensive guidance clarifies when and how to use the tool versus 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?
No annotations are provided, so the description must disclose behavioral traits. It explains that the tool is a query interface to an external API, automatically handles common parameters (numOfRows, pageNo, type, serviceKey), and notes date range restrictions. It does not explicitly state it is read-only, but the query nature is evident. A more explicit statement about side effects would raise the score.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized for a complex tool with 25 operations. It is well-structured: purpose overview, operation list, common parameters, and a warning. Every sentence adds necessary information, and the most critical guidance (how to use operations and params) is 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 complexity (25 operations, no output schema), the description provides a good starting point. It explains how to set up queries and points to another tool for detailed parameter/response info. It lacks explicit error handling or rate limit information, but the core usage is well-covered.
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 input schema covers all 5 parameters with descriptions. The description adds significant value by listing all 25 possible 'operation' values, giving common query condition keys (inqryDiv, inqryBgnDt, etc.), and providing a crucial warning about 1-month date range limits. It also directs users to another tool for exact parameter/response details, compensating for the lack of param enums.
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's a tool for querying the Korea Public Procurement Service (나라장터) OpenAPI for bid announcements. It lists all 25 specific operations, distinguishing it from sibling tools that handle other data types (contracts, industry, etc.). The verb 'get' and resource 'bid_data' are well-defined.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides explicit guidance on how to use the tool: specify an operation in the 'operation' parameter and pass query conditions in 'params'. It warns about date range limitations (1 month per call) and recommends using 'get_g2b_operation_info' for exact parameter details. Alternatives among siblings are implied by context (other get_*_data 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 fully explains the tool's read behavior and dual mode. However, it does not explicitly state it is read-only or mention any side effects, though likely safe.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences: purpose/result, usage guidance, optional behavior. Every sentence adds essential information without redundancy.
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 low complexity, no output schema, and no annotations, the description covers purpose, inputs, output types, and usage flow. It is sufficient for an agent to select and use correctly.
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%, but the description adds value: for module it references list_g2b_services to check available names; for operation it explains the list-all behavior when omitted.
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 retrieves detailed specifications (request parameters, required fields, response fields, example URL) for a service operation. It distinguishes between two behaviors: with an operation returns its spec, without returns all operations. This differentiates it from sibling get_data tools which fetch actual data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says to use this tool before calling get_<module>_data to verify parameter names. Provides clear context and a dependency relationship, leaving no ambiguity about when to invoke.
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 full burden. It discloses auto-handling of certain parameters (numOfRows/pageNo/type/serviceKey), pagination behavior via fetch_all and page_no, max rows per page (999), and the 1-month date range constraint. It doesn't explicitly state read-only nature, but it's implied. Minor gaps: no mention of error handling or rate limits, but overall sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear opening statement, then usage pattern, operation list, common parameters, and warnings. It is front-loaded with the service name. However, listing all 8 operations verbatim is somewhat lengthy; could be shortened by referencing the sibling tool. Still, it remains organized and easy to follow.
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 5 parameters, no output schema, no annotations, and many similar sibling tools, the description covers all essential aspects: how to use, what operations exist, common parameters, limitations, and how to get further details. It is self-contained and provides enough context for an agent to use the tool correctly.
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 100%, but the description adds significant value beyond schema: explains that 'operation' selects among 8 sub-functions, 'params' are operation-specific and can be verified via another tool, 'fetch_all' controls full data retrieval, and 'num_of_rows' has a max of 999. It also lists common query conditions and notes auto-handled parameters not in schema. This enriches parameter understanding.
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 the '조달청 나라장터 OpenAPI' for order plan data (발주계획현황서비스), and distinguishes itself from siblings by specifying the data domain. It includes specific verbs like '조회' and lists 8 sub-operations, making purpose precise.
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 instructions: specify 'operation' from the list, pass query conditions in 'params', and notes that some parameters are auto-handled. It advises using 'get_g2b_operation_info' for exact parameter details, warns about 1-month date range limits, and differentiates PPSSrch operations for detailed search. This is comprehensive guidance for proper usage.
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 provided, so description carries full burden. It explains the tool queries an external API, auto-handles some parameters, and imposes a date range limitation. Does not explicitly state read-only or authentication, but it is a query tool. The information is sufficient for safe usage.
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 well-organized: starts with purpose, then step-by-step instructions, list of operations, common parameters, and a warning. Every sentence adds value, and it is not excessively long.
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 no output schema, the description compensates by directing users to get_g2b_operation_info for response fields. It covers pagination (fetch_all, num_of_rows, page_no), date range limitation, and operation-specific guidance. The tool is complex, but the description provides enough context for effective 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?
While schema coverage is 100%, the description adds critical operational context: explains auto-handling of numOfRows/pageNo/type/serviceKey, lists common query conditions, warns about date range limits, and directs user to another tool for exact parameter details. This greatly enhances understanding 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 queries the Korean procurement system's contract process integrated disclosure service. It lists four specific operations (foreign goods, goods, services, construction) and includes the Korean name. The purpose is distinct from sibling tools (e.g., get_bid_data, get_contract_data).
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?
Provides explicit instructions: set 'operation', pass 'params' dict, notes auto-handled parameters, advises checking exact fields via get_g2b_operation_info, lists common query conditions, warns about 1-month date range limit and suggests splitting, mentions PPSSrch for detailed search.
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?
The description discloses that certain parameters are auto-handled, warns that date-based queries are limited to 1-month ranges, and explains pagination behavior (fetch_all, page_no). It does not mention any destructive actions, and since no annotations are provided, the description fully covers behavioral expectations.
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 relatively long but well-structured: it starts with the core usage pattern, lists all operations clearly, provides common parameters, and includes warnings. While verbose, every sentence adds value for a complex tool with 11 operations. Minor reduction for length.
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 complexity of the tool (11 operations, many parameters, pagination), the description is remarkably complete. It explains the purpose, usage pattern, parameter details, and limitations. There is no output schema, but the description directs users to get_g2b_operation_info for response fields, which compensates.
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?
Input schema provides descriptions for all 5 parameters (100% coverage). The description adds additional context by listing common query parameters (inqryDiv, inqryBgnDt, etc.) and explaining their typical usage, as well as how fetch_all and page_no work. It also directs users to get_g2b_operation_info for detailed parameter keys.
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 tool for querying price information from the Korean government procurement OpenAPI (나라장터). It lists 11 specific operations with Korean names and descriptions, distinguishing it from other sibling tools like get_bid_data, get_contract_data, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on how to use the tool: set 'operation' to one of the listed operation names, pass query parameters in 'params' as a dict, notes that numOfRows/pageNo/type/serviceKey are auto-handled, and directs to get_g2b_operation_info for exact parameters. It also includes warnings about date range limitations and suggests splitting into monthly intervals.
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-kr-g2b MCP server](https://glama.ai/mcp/servers/ChangooLee/mcp-kr-g2b/badges/card.svg)](https://glama.ai/mcp/servers/ChangooLee/mcp-kr-g2b)

Score Badge

Copy to your README.md:

[![mcp-kr-g2b MCP server](https://glama.ai/mcp/servers/ChangooLee/mcp-kr-g2b/badges/score.svg)](https://glama.ai/mcp/servers/ChangooLee/mcp-kr-g2b)

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/ChangooLee/mcp-kr-g2b'

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