kiwoom-mcp

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation5/5
Each tool has a clearly distinct purpose with no overlap: cancel_order cancels orders, get_account_balance retrieves account holdings, get_deposit_detail gets deposit details, get_portfolio_summary provides portfolio analysis, get_stock_chart fetches chart data, get_stock_price retrieves current stock metrics, get_trade_history shows trade history, get_unfilled_orders lists unfilled orders, place_buy_order executes buy orders, place_sell_order executes sell orders, and search_stock searches for stock information. The descriptions clearly differentiate their functions, eliminating any ambiguity.
Naming Consistency5/5
All tool names follow a consistent verb_noun pattern using snake_case: get_account_balance, get_deposit_detail, get_portfolio_summary, get_stock_chart, get_stock_price, get_trade_history, get_unfilled_orders, place_buy_order, place_sell_order, search_stock, and cancel_order. The verbs (get, place, search, cancel) are appropriately matched to the nouns, creating a predictable and readable naming convention throughout the set.
Tool Count5/5
With 11 tools, the count is well-scoped for a stock trading server, covering essential operations like account management, order placement, market data retrieval, and portfolio analysis. Each tool serves a specific, necessary function without redundancy, making the set comprehensive yet manageable for typical trading workflows.
Completeness5/5
The tool set provides complete coverage for stock trading and portfolio management: it includes CRUD-like operations (place/cancel orders, get trade history), account and portfolio analysis (balance, deposit, summary), market data access (stock price, chart, search), and order management (unfilled orders). There are no obvious gaps, as all core workflows from research to execution and monitoring are supported.
Average 3.4/5 across 11 of 11 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
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?
The annotations indicate readOnlyHint=true, which the description aligns with by using '조회합니다' (retrieves/views). The description adds value by specifying the types of deposit details retrieved (예수금, 증거금, 미수확보금), but does not disclose additional behavioral traits like rate limits, authentication needs, or response format, relying on annotations for basic safety.
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, efficient sentence in Korean that directly states the tool's function. It is front-loaded with the core purpose and avoids unnecessary words, though it could be slightly more structured for clarity in English contexts.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one optional parameter, read-only annotation, no output schema), the description is adequate but minimal. It covers the purpose but lacks context on output format, error handling, or integration with sibling tools, leaving gaps for an agent to fully understand usage in a financial system.
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 the parameter 'account_no' fully documented in the schema. The description does not add any parameter-specific information beyond what the schema provides, such as format examples or constraints, so it meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: retrieving detailed deposit information including deposit money, margin, and unsecured loan collateral. It uses specific financial terms (예수금, 증거금, 미수확보금) that define the scope, though it doesn't explicitly differentiate from sibling tools like 'get_account_balance' or 'get_portfolio_summary' which might overlap in financial data retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description does not mention any prerequisites, exclusions, or comparisons to sibling tools such as 'get_account_balance' or 'get_portfolio_summary', leaving the agent to infer usage context from tool names alone.
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?
The description adds some behavioral context beyond annotations: it specifies that data is sorted in descending order by recent data and that base_date filters for data before that date. The annotation (readOnlyHint: true) already indicates this is a safe read operation, so the description doesn't need to reiterate safety. However, it doesn't disclose other behavioral traits like rate limits, authentication needs, or what happens if no data exists for the given parameters.
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, efficient sentence that conveys the core functionality without unnecessary words. It's front-loaded with the main purpose and includes key details (sorting order and date filtering). However, it could be slightly improved by explicitly mentioning the tool's scope relative to siblings.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (2 parameters, read-only operation), the description is adequate but has gaps. It covers the basic purpose and data ordering, but lacks output details (no output schema is provided, so the description doesn't explain return values like OHLCV structure or pagination). With annotations covering safety, it's minimally viable but could benefit from more context on usage and results.
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 description coverage is 100%, meaning both parameters (stock_code and base_date) are fully documented in the schema with descriptions and patterns. The description adds minimal value beyond the schema: it clarifies that base_date is used to retrieve data before that date ('이 날짜 이전 데이터 조회'), which is somewhat redundant with the schema's description. No additional parameter semantics are provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: retrieving daily OHLCV chart data for a stock, sorted by recent data first. It specifies the verb ('조회합니다' - retrieves/checks) and resource ('일봉 OHLCV 차트 데이터' - daily OHLCV chart data). However, it doesn't explicitly differentiate from sibling tools like 'get_stock_price' or 'search_stock', which might offer similar or overlapping functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It mentions the base_date parameter for filtering data before a specific date, but doesn't explain how this differs from other stock-related tools like 'get_stock_price' (which might provide current price) or 'search_stock' (which might search for stocks). There are no explicit when-to-use or when-not-to-use instructions.
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?
Annotations already indicate this is a non-readOnly, non-idempotent operation (write/mutation). The description adds that it supports both market and limit orders, which is useful behavioral context beyond annotations. However, it doesn't disclose other important traits like authentication requirements, rate limits, or what happens on failure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with two short sentences that convey the core functionality. It's front-loaded with the primary purpose. No wasted words, though it could potentially benefit from slightly more detail given the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a financial transaction tool with no output schema and annotations only covering read/write/idempotency, the description is minimally adequate. It covers what the tool does but lacks important context about return values, error conditions, authentication requirements, and relationship to sibling tools.
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?
With 100% schema description coverage, the schema already documents all 5 parameters thoroughly. The description mentions market vs limit order support (relating to 'order_type' and 'price'), but adds minimal semantic value beyond what's in the schema descriptions. Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('주식 매수 주문을 실행합니다' - executes stock buy orders) and resource (stocks), making the purpose evident. It distinguishes from sibling 'place_sell_order' by specifying 'buy' but doesn't explicitly differentiate from other trading-related tools like 'cancel_order' or 'get_unfilled_orders'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (like needing an authenticated account), when not to use it, or how it relates to sibling tools like 'place_sell_order' or 'cancel_order'.
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?
Annotations indicate this is a non-readOnly, non-idempotent tool (mutation with side effects), which the description aligns with by implying execution of orders. The description adds minimal behavioral context beyond annotations—it mentions support for market/limit orders but doesn't cover critical aspects like confirmation mechanisms, error handling, or execution guarantees. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with the core action ('주식 매도 주문을 실행합니다'), followed by a brief feature note. It avoids redundancy and wastes no words, though it could be slightly more informative without losing efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no output schema and minimal annotations, the description is somewhat incomplete. It covers the basic action and order types but lacks details on return values, error cases, or dependencies (e.g., account authentication). Given the complexity of financial transactions, more context would be beneficial, but it meets a minimum viable threshold.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with each parameter well-documented in the schema (e.g., stock_code pattern, price default for market orders). The description adds no additional parameter semantics beyond what the schema provides, such as explaining interactions between order_type and price. Baseline score of 3 is appropriate given high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as '주식 매도 주문을 실행합니다' (executes stock sell orders) and specifies it supports market or limit orders. It distinguishes from sibling tools like place_buy_order by focusing on selling, but doesn't explicitly differentiate from other order-related tools like cancel_order beyond the action type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., needing sufficient holdings), compare with market vs. limit order scenarios, or reference sibling tools like cancel_order for order management. Usage context is implied but not stated.
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?
The description adds some behavioral context beyond the readOnlyHint annotation. It specifies what data is returned (stock holdings, current prices, purchase prices, purchase amounts), which helps the agent understand the scope of information retrieved. However, it doesn't mention important behavioral aspects like whether this requires authentication, rate limits, response format, or error conditions. The annotation correctly indicates read-only operation, and the description doesn't contradict this.
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 - a single sentence that efficiently communicates the core functionality. It's front-loaded with the key information (what data is retrieved) without unnecessary elaboration. Every word earns its place in this minimal description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (financial data retrieval), the presence of readOnlyHint annotation, and 100% schema coverage, the description is adequate but has gaps. It explains what data is returned but doesn't cover output format, authentication requirements, or error handling. Without an output schema, the description should ideally provide more detail about the return structure. It meets minimum viable standards but could be more 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?
With 100% schema description coverage, the input schema already fully documents the single optional parameter (account_no with default behavior). The description adds no parameter-specific information beyond what's in the schema. According to scoring rules, when schema_description_coverage is high (>80%), the baseline is 3 even with no parameter info in the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: retrieving account balance information including stock holdings, current prices, purchase prices, and purchase amounts. It uses specific verbs ('조회합니다' - retrieves/queries) and resources ('계좌 잔고' - account balance). However, it doesn't explicitly differentiate from sibling tools like 'get_portfolio_summary' or 'get_deposit_detail', which might provide overlapping or related financial information.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_portfolio_summary' (which might provide summary vs detailed balance), 'get_deposit_detail' (which might focus on cash deposits), or 'get_trade_history' (which shows transactions rather than current holdings). There are no explicit when/when-not instructions or prerequisites mentioned.
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?
Annotations declare readOnlyHint=true, indicating a safe read operation. The description adds minimal behavioral context beyond this, as it doesn't specify details like response format, pagination, or error handling. However, it doesn't contradict the annotations, and the tool's name ('get') aligns with read-only behavior. With annotations covering safety, the description adds little extra value.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It's front-loaded with the core purpose, making it easy to understand quickly. Every part of the sentence earns its place by conveying essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 optional parameter, read-only annotation, no output schema), the description is minimally adequate. It covers the basic purpose but lacks details on output (e.g., what data is returned) and usage context. With annotations handling safety, it's complete enough for a simple query tool but could be improved with more behavioral or output information.
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 the parameter 'account_no' documented as '계좌번호 (미입력시 기본 계좌 사용)' meaning 'account number (uses default account if not input).' The description doesn't add any meaning beyond this schema information, so it meets the baseline of 3 for high schema coverage without extra param details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: '미체결 주문 목록을 조회합니다' translates to 'Retrieves a list of unfilled orders.' This specifies the verb (retrieve/query) and resource (unfilled orders). However, it doesn't explicitly differentiate from sibling tools like 'get_trade_history' or 'cancel_order,' which could handle related but distinct operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an account), exclusions (e.g., not for filled orders), or comparisons to siblings like 'get_trade_history' for past trades or 'cancel_order' for modifying orders. Usage is implied but not articulated.
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?
Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds context about what information is retrieved (name, market, industry, listing date), which is useful beyond annotations. However, it doesn't disclose behavioral traits like rate limits, authentication needs, or response format details, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in Korean that directly states the tool's function. It's front-loaded with the core purpose and lists key data points without unnecessary elaboration. However, it could be slightly more structured for clarity in English contexts.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (1 parameter, read-only, no output schema), the description is adequate but minimal. It covers the basic purpose and data retrieved, but lacks details on output format, error handling, or integration with sibling tools, leaving room for improvement in completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'stock_code' fully documented in the schema (type, pattern, example). The description doesn't add any parameter-specific details beyond what the schema provides, so it meets the baseline for high coverage without extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: '조회합니다' (to retrieve) basic stock information by stock code, specifying the resource (stock basic information) and key data points (name, market classification, industry, listing date). It distinguishes from siblings like get_stock_price (price only) or get_stock_chart (chart data), but 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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context: when you need basic stock info by code. However, it doesn't explicitly state when to use this versus alternatives (e.g., get_stock_price for price, get_stock_chart for charts) or any prerequisites. The guidance is implied but not detailed.
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?
The annotations already declare readOnlyHint=true, indicating this is a safe read operation. The description adds useful context about what gets analyzed (portfolio valuation, profit/loss, returns), which helps the agent understand the scope of data returned. However, it doesn't disclose additional behavioral traits like rate limits, authentication needs beyond the account_no parameter, or whether it requires specific permissions. No contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized for a simple read operation and front-loaded with key information (what gets analyzed). Every part of the sentence contributes value by specifying the analysis scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 optional parameter, read-only operation), no output schema, and rich annotations (readOnlyHint), the description is adequate but has gaps. It explains what data is analyzed but doesn't cover return format details, error conditions, or how the analysis is presented (e.g., aggregated values vs. breakdowns). For a portfolio summary tool, more context on output structure would be helpful despite the annotations.
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 the single parameter 'account_no' clearly documented in the schema ('계좌번호 (미입력시 기본 계좌 사용)' - account number, uses default if not input). The description doesn't add any parameter-specific information beyond what the schema provides, so it meets the baseline score of 3 for high schema coverage without compensating value.
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 what the tool does ('분석합니다' - analyzes) and specifies the resources it analyzes ('총평가금액, 총손익, 수익률 등 포트폴리오 전체 현황' - total valuation, total profit/loss, rate of return, and overall portfolio status). It distinguishes from siblings like get_account_balance (specific balance) or get_trade_history (transaction history) by focusing on comprehensive portfolio analysis. However, it doesn't explicitly name the sibling alternatives for comparison.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by specifying it analyzes '포트폴리오 전체 현황' (overall portfolio status), suggesting it's for summary views rather than detailed transactions or specific stock data. However, it doesn't provide explicit guidance on when to use this tool versus alternatives like get_account_balance (for balance only) or get_trade_history (for transaction details), nor does it mention any prerequisites or exclusions.
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?
The annotation 'readOnlyHint': true already indicates this is a safe read operation. The description adds useful behavioral context: it specifies the time constraint ('최근 2개월까지' - up to last 2 months) and clarifies that it retrieves detailed trade records including profit/loss. However, it doesn't mention other behavioral aspects like response format, pagination, or authentication requirements beyond what annotations provide.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in Korean that front-loads the core purpose and includes key constraints. Every element earns its place: the action (조회합니다), the resource (매매일지), the content details (매수/매도 내역, 손익), the scope (당일 또는 특정 날짜), and the limit (최근 2개월까지). There's no wasted verbiage.
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 (2 optional parameters, read-only operation), the description provides sufficient context. The annotation covers safety (readOnlyHint: true), and the schema fully documents parameters. The description adds meaningful constraints (2-month limit, profit/loss inclusion) and clarifies default behaviors (today's date, default account). However, without an output schema, some details about return values (e.g., structure of trade records) are missing, though not critically for a retrieval 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?
Schema description coverage is 100%, with both parameters ('base_date', 'account_no') fully documented in the schema. The description mentions date and account aspects generally ('당일 또는 특정 날짜', '계좌번호') but doesn't add specific semantic details beyond what the schema already provides (e.g., format 'YYYYMMDD', default behaviors). Baseline 3 is appropriate since the schema carries the parameter documentation burden.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: '조회합니다' (retrieve/query) for '매매일지' (trade history) including '매수/매도 내역, 손익' (buy/sell records, profit/loss). It specifies the scope ('당일 또는 특정 날짜', '최근 2개월까지' - today or specific date, up to last 2 months), which is helpful. However, it doesn't explicitly differentiate from sibling tools like 'get_account_balance' or 'get_portfolio_summary' in terms of data granularity or time range.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by mentioning date ranges and optional parameters, but doesn't provide explicit guidance on when to use this tool versus alternatives. For example, it doesn't compare to 'get_portfolio_summary' for aggregated data or 'get_unfilled_orders' for pending trades. The context is clear (retrieve trade history), but no when-not-to-use or alternative tool references are included.
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?
Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds value by specifying the exact metrics returned (current price, PER, etc.), which goes beyond the annotation. However, it doesn't mention rate limits, authentication needs, or response format details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in Korean that lists all key data points without unnecessary words. It's front-loaded with the core purpose and provides complete information in minimal space.
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 read-only tool with one well-documented parameter and no output schema, the description effectively covers what data is returned. It could be more complete by specifying the return format or units (e.g., currency), but given the annotations and simple schema, it's largely adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'stock_code' fully documented in the schema (including pattern and example). The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('조회합니다' - 'retrieves' or 'queries') and lists the exact data points returned (current price, day-over-day change, open/high/low prices, 250-day high/low, PER/PBR/EPS). It distinguishes from siblings like get_stock_chart (visual data) or search_stock (finding stocks).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving detailed stock price metrics, but doesn't explicitly state when to use this versus alternatives like get_stock_chart (for chart data) or search_stock (for finding stocks by name). No explicit exclusions or prerequisites are mentioned.
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?
The description adds valuable behavioral context beyond what annotations provide. While annotations already indicate this is a destructive, non-idempotent write operation, the description explains the special case for quantity parameter ('수량을 0으로 입력하면 잔량 전부 취소' - entering 0 cancels all remaining quantity), which is crucial operational knowledge not captured in the structured annotations.
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 with just two sentences that both earn their place. The first sentence states the core purpose, and the second provides crucial behavioral nuance about the quantity parameter. There's zero wasted language or 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 destructive order cancellation tool with good annotations but no output schema, the description provides adequate context. It explains the core operation and the special quantity behavior. However, it doesn't mention potential side effects, error conditions, or what happens after successful cancellation, which would be helpful given the destructive nature.
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?
With 100% schema description coverage, the input schema already documents all parameters thoroughly. The description adds minimal additional semantics by reinforcing the quantity parameter's special behavior (0 = cancel all), but doesn't provide meaningful context beyond what's already in 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 specific action ('취소합니다' - cancels) and target resource ('미체결 주문' - unfilled orders) using the identifier '원주문번호' (original order number). It distinguishes itself from sibling tools like place_buy_order and place_sell_order by focusing on cancellation rather than order placement.
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 ('미체결 주문을 취소합니다' - cancels unfilled orders), implying it should be used for pending orders rather than completed trades. However, it doesn't explicitly mention when NOT to use it or name specific alternatives among the sibling tools.
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:

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

Score Badge

Copy to your README.md:

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

Latest Blog Posts

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

MCP directory API

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

curl -X GET 'https://glama.ai/api/mcp/v1/servers/kwonsw812/kiwoom-mcp'

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