Upbit MCP Server

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 targeting specific resources and actions in the Upbit cryptocurrency exchange domain. For example, create_order, cancel_order, get_order, and get_orders handle different aspects of order management without overlap, while get_accounts, get_deposits_withdrawals, get_market_summary, get_orderbook, get_ticker, and get_trades each focus on unique data retrieval functions. No tools appear to do the same thing, making selection unambiguous for an agent.
Naming Consistency5/5
All tool names follow a consistent verb_noun pattern using snake_case, such as get_accounts, create_order, and cancel_order. This predictable naming convention enhances readability and usability, with no deviations or mixed styles observed across the toolset. The consistency supports easy identification and reduces cognitive load for agents.
Tool Count5/5
With 10 tools, the server is well-scoped for its purpose of interacting with the Upbit cryptocurrency exchange. Each tool earns its place by covering essential operations like account management, order handling, and market data retrieval. This count aligns with typical server sizes (3-15 tools) and avoids being too thin or heavy, providing comprehensive functionality without unnecessary complexity.
Completeness4/5
The tool surface offers near-complete coverage for the cryptocurrency exchange domain, including CRUD operations for orders (create, get, cancel, list), account and transaction management, and market data access. Minor gaps exist, such as the lack of tools for modifying orders or handling advanced trading features like stop-loss orders, but agents can work around these with the available tools. Overall, the set supports core workflows effectively.
Average 3/5 across 10 of 10 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- 1 of 1 community issues answered or closed 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 is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but only states basic functionality. It doesn't disclose behavioral traits like rate limits, authentication needs, pagination, or what 'recent' means (e.g., time window). This leaves significant gaps for a tool that likely returns time-sensitive data.
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 with zero waste. It's appropriately sized and front-loaded, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (likely returning time-series trade data), no annotations, no output schema, and low parameter coverage, the description is incomplete. It lacks details on return format (e.g., list of ticks with timestamps), error handling, or prerequisites, making it insufficient for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate but adds minimal meaning. It mentions 'symbol' as the parameter but doesn't explain format (e.g., trading pair like BTC-USD) or constraints. This is inadequate for a single required parameter with no schema documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Get recent trade ticks for a symbol' clearly states the verb ('Get') and resource ('recent trade ticks'), but it's vague about scope (e.g., time range, limit) and doesn't distinguish from siblings like get_orderbook or get_ticker. It avoids tautology but lacks specificity.
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 such as get_orderbook (for market depth) or get_ticker (for price summaries). The description implies usage for trade history but offers no explicit context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'snapshot,' implying a read-only operation, but doesn't specify if it's real-time or cached, rate limits, authentication needs, or what the output format looks like. This leaves significant gaps for an agent to understand how to handle the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's function without any wasted words. It is appropriately sized and front-loaded, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of market data tools, no annotations, no output schema, and low parameter coverage, the description is incomplete. It lacks details on output format, behavioral traits like latency or limits, and differentiation from siblings, making it inadequate for reliable agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for the undocumented parameter. It adds meaning by specifying that the 'symbol' parameter is used to identify the market for the orderbook, but doesn't explain format (e.g., 'BTC/USD'), constraints, or examples, leaving the agent with incomplete information.
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 ('Get orderbook snapshot') and resource ('for a given symbol'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get_ticker' or 'get_market_summary' that also provide market data, leaving some ambiguity about when this specific tool is preferred.
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 like 'get_ticker' or 'get_market_summary' for market data, nor does it mention prerequisites or exclusions. It only states what the tool does, not when it should be selected.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states it 'gets' data, implying a read-only operation, but doesn't cover critical aspects like rate limits, authentication needs, response format, or potential errors. This is a significant gap for a tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It is appropriately sized and front-loaded, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of financial data retrieval, no annotations, no output schema, and low parameter coverage, the description is incomplete. It lacks details on behavior, output, and parameter meaning, making it inadequate for effective tool use in this context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, and the description adds no information about the 'symbol' parameter beyond what the schema provides (a required string). It doesn't explain what 'symbol' represents (e.g., a trading pair like 'BTC-KRW'), format expectations, or examples, failing to compensate for the low 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 verb ('Get') and resource ('latest ticker data from Upbit'), making the purpose immediately understandable. It doesn't explicitly distinguish from sibling tools like 'get_market_summary' or 'get_orderbook', which likely provide different financial data, so it misses full sibling differentiation.
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 what 'ticker data' includes compared to other data retrieval tools in the sibling list, such as 'get_market_summary' or 'get_orderbook', leaving the agent without context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states the tool cancels an order but doesn't disclose critical traits: whether cancellation is immediate or queued, if it requires specific permissions, potential side effects (e.g., partial fills), rate limits, or error responses. The return value is vaguely described as '취소 결과' (cancellation result) without 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with three sentences: purpose statement, parameter explanation, and return value note. Each sentence adds value, and the structure with 'Args' and 'Returns' sections is clear. However, the Korean-only text might limit accessibility in multilingual contexts.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool (order cancellation) with no annotations and no output schema, the description is insufficient. It lacks details on behavioral implications (e.g., irreversible action, confirmation requirements), error handling, response format, and integration with sibling tools like 'get_order' to verify cancellation. The agent has inadequate context for safe and effective use.
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 description explicitly documents the single parameter 'uuid' as '취소할 주문의 UUID' (UUID of the order to cancel), adding meaningful context beyond the schema's 0% coverage. This fully compensates for the schema gap for this one parameter, establishing a clear baseline. No additional parameter insights are needed since there's only one parameter.
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 ('cancel_order') and target resource ('주문' - order) with specific context ('업비트에서' - on Upbit). It distinguishes from siblings like 'create_order' by specifying cancellation rather than creation. However, it doesn't explicitly differentiate from other potential order modifications beyond the name.
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 existing order UUID), error conditions, or when other tools like 'get_order' might be needed first. The agent must infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a retrieval operation ('조회합니다'), which implies read-only behavior, but doesn't mention authentication requirements, rate limits, error conditions, or what happens when parameters are omitted. The description adds minimal behavioral context beyond the basic operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with a clear purpose statement followed by Args and Returns sections. It's appropriately sized for a simple lookup tool, though the parameter documentation could be more detailed given the lack of schema coverage. Every sentence serves a purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a financial API tool with no annotations, no output schema, and 0% schema description coverage, the description is insufficient. It doesn't explain the return format beyond 'dict: 주문 정보' (dictionary: order information), doesn't mention authentication requirements for the Upbit platform, and provides minimal guidance on parameter usage. Given the complexity of financial APIs, more context is needed.
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 description provides parameter information in the Args section, explaining that 'uuid' is the order UUID and 'identifier' is a user-defined value for lookup. However, with 0% schema description coverage, the schema provides no parameter documentation. The description adds meaningful semantics but doesn't fully compensate for the complete lack of schema documentation, especially regarding the relationship between the two optional parameters.
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: '업비트에서 특정 주문의 정보를 조회합니다' (Retrieves information about a specific order from Upbit). It specifies the verb ('조회합니다' - retrieves/checks) and resource ('특정 주문' - specific order), but doesn't explicitly differentiate from sibling tools like 'get_orders' (plural) which might retrieve multiple 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 sibling tools like 'get_orders' (for multiple orders) or 'cancel_order' (for order management), nor does it specify prerequisites or appropriate contexts for using this specific order lookup tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It only states what the tool returns ('주요 암호화폐 시장 요약 정보') without describing what that summary contains, how current the data is, whether it's cached or real-time, rate limits, authentication requirements, or error conditions. For a market data tool with zero annotation coverage, this is insufficient behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with two sentences that directly state the purpose and return type. The first sentence clearly states what the tool does, and the second specifies the return format. There's no unnecessary information or repetition. However, the Korean-to-English translation in the Returns section creates minor redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of market data tools and the absence of both annotations and output schema, the description is incomplete. It doesn't explain what 'summary information' includes (e.g., market caps, volumes, top gainers/losers, overall trends), the scope of 'major cryptocurrencies,' data freshness, or format details. For a tool that presumably returns structured market data, more context is needed about what the agent can 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?
The tool has 0 parameters with 100% schema description coverage, so the schema already fully documents the absence of parameters. The description appropriately doesn't discuss parameters since none exist. The baseline for 0 parameters with full schema coverage is 4, as there's nothing to compensate for and the description doesn't incorrectly mention parameters.
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: '주요 암호화폐 시장의 요약 정보를 제공합니다' (Provides summary information of major cryptocurrency markets). It specifies the verb '제공합니다' (provides) and the resource '주요 암호화폐 시장 요약 정보' (major cryptocurrency market summary information). However, it doesn't explicitly differentiate from sibling tools like get_ticker or get_orderbook, which also provide market-related 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 what makes this 'summary' different from other market data tools like get_ticker (single asset price), get_orderbook (depth data), or get_trades (recent transactions). There's no context about when this aggregated view is preferable to more detailed tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves balance information, implying a read-only operation, but doesn't specify any behavioral traits like authentication requirements, rate limits, error handling, or whether it returns real-time or cached data. For a tool with zero annotation coverage, this is a significant gap in transparency.
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 well-structured, with two sentences: one stating the purpose and another describing the return value. It's front-loaded with the core functionality and avoids unnecessary details. However, it could be slightly improved by integrating the return information more seamlessly, but overall it's efficient with minimal waste.
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 (0 parameters, no output schema, no annotations), the description is adequate but has clear gaps. It explains what the tool does and the return type, but without annotations or output schema, it lacks details on behavioral aspects like authentication or error handling. This makes it minimally viable but incomplete for optimal agent 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?
The tool has 0 parameters, and the input schema has 100% description coverage (though empty). The description doesn't need to add parameter semantics, as there are no parameters to document. This meets the baseline of 4 for tools with no parameters, as it appropriately doesn't waste text on non-existent inputs.
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: '업비트 계정의 잔고 정보를 조회합니다' (Retrieves balance information for Upbit accounts). It specifies the verb '조회합니다' (retrieves) and the resource '잔고 정보' (balance information). However, it doesn't explicitly differentiate from sibling tools like 'get_deposits_withdrawals' or 'get_orders', which might also retrieve account-related data, so it doesn't reach a score of 5.
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 any prerequisites, context for usage, or comparisons to sibling tools such as 'get_deposits_withdrawals' or 'get_orders', which could be relevant for account-related queries. This lack of usage instructions limits its effectiveness for an AI agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a retrieval operation ('조회합니다'), implying it's read-only, but doesn't confirm safety aspects like non-destructiveness. It mentions pagination (page/limit) but doesn't describe rate limits, authentication needs, error conditions, or what happens if parameters are invalid. For a financial data tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately sized. It starts with a clear purpose statement, followed by an 'Args' section with bullet-like parameter explanations, and ends with a 'Returns' section. Every sentence adds value—no fluff or repetition. However, the mix of Korean and English might slightly hinder readability for non-Korean agents, but the structure is efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (5 parameters, financial data retrieval) and no annotations or output schema, the description is partially complete. It covers parameters well but lacks behavioral context (e.g., safety, errors, auth). The return value is vaguely described as 'list[dict]: 입출금 내역' without detailing structure or fields. For a tool with no structured output schema, more return value specifics would improve completeness.
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 description adds substantial meaning beyond the input schema, which has 0% schema description coverage. It explains all 5 parameters in Korean with examples (e.g., '통화 코드 (예: BTC)') and clarifies transaction_type options (deposit/withdraw). It also specifies the limit constraint ('최대 100'/maximum 100). This effectively compensates for the schema's lack of descriptions, though it doesn't detail default behaviors for optional parameters beyond what the schema shows.
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 deposit/withdrawal history for Upbit account). It specifies the verb (조회/retrieve) and resource (입출금 내역/deposit-withdrawal history), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like get_accounts or get_orders, which might also retrieve financial data.
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_accounts (which might show balances) or get_orders (which might show trade history), nor does it specify prerequisites (e.g., authentication requirements) or contextual constraints. The usage is implied by the purpose statement but lacks explicit when/when-not instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While it correctly identifies this as a creation/mutation operation, it provides minimal information about what happens when invoked - no details about authentication requirements, rate limits, error handling, or what constitutes a successful order creation. The return value description ('dict: 주문 결과') is extremely vague.
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 clear sections (Args, Returns) and efficiently conveys necessary information. While slightly longer than minimal, every sentence adds value given the complex parameter dependencies. The Korean language doesn't affect conciseness scoring as it's appropriately translated and structured.
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 5-parameter order creation tool with no annotations and no output schema, the description provides adequate but incomplete coverage. The parameter documentation is excellent, but there's insufficient information about the tool's behavior, return format, error conditions, and integration context. The agent would need additional context to use this tool effectively in real trading scenarios.
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?
Given 0% schema description coverage, the description provides excellent parameter semantics. It explains each parameter's purpose, provides examples (KRW-BTC), clarifies enum meanings (bid=매수, ask=매도), and specifies conditional requirements (which parameters are mandatory for which order types). This fully compensates for the lack of 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 ('create order') and target resource ('Upbit'), distinguishing it from sibling tools like cancel_order or get_orders. It uses a precise verb ('create') and identifies the exact platform where the operation occurs.
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 like cancel_order or get_order. While the purpose is clear, there's no mention of prerequisites, error conditions, or contextual factors that would help an agent decide when this is the appropriate tool to invoke.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only operation ('조회합니다' - retrieve) and mentions pagination via 'page' and 'limit', which adds useful context. However, it lacks details on authentication requirements, rate limits, error handling, or response structure beyond 'list[dict]', leaving gaps for a tool with 4 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 well-structured and appropriately sized. It starts with a clear purpose statement, followed by organized sections for 'Args' and 'Returns', with bullet-like formatting. Every sentence adds value, though the Korean-only text might limit accessibility for non-Korean agents, slightly reducing 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?
Given no annotations and no output schema, the description is moderately complete. It covers the purpose and parameters well but lacks details on authentication, error cases, or the structure of the returned 'list[dict]'. For a tool with 4 parameters and no structured safety hints, more behavioral context would improve completeness, though it meets a baseline for a read operation.
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 description adds significant semantic value beyond the input schema, which has 0% description coverage. It explains each parameter in Korean with examples ('예: KRW-BTC'), clarifies 'state' options (wait, done, cancel), and specifies constraints like '최대 100' (maximum 100) for 'limit'. This fully compensates for the schema's lack of descriptions, making parameters clear and actionable.
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: '업비트에서 주문 내역을 조회합니다' (Retrieves order history from Upbit). It specifies the verb '조회합니다' (retrieve/query) and resource '주문 내역' (order history), which is specific and actionable. However, it doesn't explicitly differentiate from sibling tools like 'get_order' (singular) or 'get_trades', leaving some ambiguity about scope.
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_order' (for a single order) or 'get_trades' (for trade history), nor does it specify prerequisites or contexts where this tool is preferred. The agent must infer usage from the tool name and parameters alone.
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:

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

Score Badge

Copy to your README.md:

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

Latest Blog Posts

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

MCP directory API

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

curl -X GET 'https://glama.ai/api/mcp/v1/servers/solangii/upbit-mcp-server'

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