AlgoKit-mcp

by itsme-shawn

Overview Schema Related Servers Score Discussions

TypeScript

Local

Server Quality Checklist

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

Latest release: v1.0.5
Disambiguation4/5
Each tool has a clear platform suffix (_boj/_programmers) and a distinct verb (search, get, analyze, fetch, etc.). However, analyze_problem and generate_hint both provide hint-related data and could be confused, and get_problem vs fetch_problem_content have overlapping purposes (metadata vs full content), though descriptions help.
Naming Consistency4/5
The vast majority follow a consistent verb_noun_platform pattern (e.g., search_problems_boj, generate_hint_programmers). The sole outlier is health_check, which breaks the verb_noun pattern but is a standard utility and acceptable.
Tool Count4/5
16 tools is on the higher side but justified by covering two distinct platforms (BOJ and Programmers) with nearly parallel feature sets. Each tool serves a specific purpose, and the count is not excessive for the broader competitive-programming assistance domain.
Completeness5/5
The tool surface covers the full problem-solving lifecycle for both platforms: search, retrieve metadata/content, analyze with hints, generate review templates, and analyze code submissions. No obvious dead ends; the only minor gap is platform-specific extras like tag search only existing for BOJ, but that's a platform limitation.
Average 4.3/5 across 16 of 16 tools scored. Lowest: 3.1/5.
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 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?
No annotations are provided, so the description must disclose side effects and return behavior. It only states 'check server status' without explaining whether it performs safe read-only operations, requires authentication, or what the output format looks like. 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 one short sentence, heavily front-loaded with the core action. It contains no unnecessary words or repeated information.
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 there is no output schema or annotations, the description should explain what a successful response contains. It only says 'check status' without specifying the return type, possible values, or any side effects. For a minimal health-check tool, this may be acceptable, but it leaves the agent guessing about the tool's behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema is empty. The description doesn't add parameter details because none exist. Per the baseline for zero-parameter tools, a score of 4 is appropriate.
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 tool name and description clearly indicate it checks the MCP server status. This distinguishes it from sibling tools that focus on problem search/analysis. However, 'status' is somewhat generic and doesn't specify what aspect is checked.
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 others. It neither mentions alternatives nor excludes scenarios. The context signals show it's a standalone health check, but that's not explicitly stated.
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?
Discloses a critical output behavior: results are returned as a markdown table with mandatory links to BOJ problem pages that must be preserved. Since no annotations exist, this is valuable beyond structured fields. It does not cover all behaviors (e.g., pagination), but the key user-facing behavior is transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is moderately concise and structured, with the main sentence, link warning, and example all earning their place. However, the final line about platform unspecified is confusing and redundant for a BOJ-specific tool, adding noise and reducing clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers purpose, filter dimensions, output format, and examples, which is adequate for basic use. Given 7 optional parameters and no output schema, it could benefit from clarifying tag combination semantics (AND/OR) or result limits. The confusing platform line also detracts from 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?
The input schema already describes all 7 parameters with detailed descriptions and 100% coverage. The description summarizes the main filter dimensions and gives an example, but adds little beyond the schema. The baseline of 3 is appropriate.
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 searches BOJ problems with filters for keyword, difficulty level, and algorithm tags. It distinguishes from sibling tools by scope (get_problem for single problems, search_tags for tags) though not explicitly; the final line about unspecified platform introduces slight ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Concrete examples ('Gold tier DP problem search', 'Silver or lower greedy problem search') illustrate when to use the tool. The platform reminder, though oddly placed, suggests clarifying the platform when unspecified, which is relevant given the sibling search_problems_programmers tool. No explicit exclusions are provided, but the context is adequate.
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 behavioral disclosure burden. It discloses the platform ambiguity warning and the kind of data returned (difficulty, tags, stats), but it does not mention potential error cases, response format, or any side effects. For a simple getter, this is adequate but incomplete.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with the core action in the first sentence and a critical platform warning in the second. Every sentence earns its place, and the information 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?
For a single-parameter getter with no output schema, the description covers the purpose, the key data returned (difficulty, tags, statistics), and a real usage caveat (platform ambiguity). It does not document edge cases or full return structure, but that is not critical for a tool of this simplicity.
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% and the schema already clearly describes problem_id as 'BOJ 문제 번호 (양의 정수)'. The description adds minimal parameter-level meaning beyond the schema; the platform-confirmation note relates to usage context rather than the parameter definition itself. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool 'retrieves detailed information about a specific BOJ problem' and lists the details (difficulty, tags, statistics). It distinguishes itself from siblings by explicitly targeting BOJ and by the platform-confirmation note, which differentiates it from get_problem_programmers.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit guidance on when to use this tool versus other platform-specific tools: if only a problem number is provided, determine the platform from context or ask the user for confirmation. It does not explicitly name alternative tools or state when not to use this one, but it provides clear contextual guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses a significant behavioral trait: the tool may prompt the user to confirm the platform if it cannot be inferred from context. It also describes the content of the returned hint data. It stops short of stating side effects (e.g., read-only nature) but for an analysis tool this is 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 front-loaded with the primary purpose in the first sentence, followed by a necessary usage warning. The two sentences are dense with information and contain no filler. Slight verbosity in the warning is justified by the potential ambiguity.
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 tool's purpose, included hint components, and an important usage condition. Given there is no output schema and no annotations, it provides enough context for an agent to understand what this tool does and when to invoke it. It does not explain return format or error handling, but those are not essential for this tool's simplicity.
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% and both parameter descriptions in the schema are clear. The description's mention of '유사 문제 추천' aligns with the include_similar parameter but adds no additional semantics beyond what the schema already provides. Therefore, baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb '분석하여 제공합니다' (analyzes and provides), names the resource '백준(BOJ) 문제', and enumerates output components (알고리즘 패턴, 난이도 컨텍스트, 3단계 힌트 포인트, 유사 문제 추천). The BOJ prefix and platform warning clearly distinguish it from analyze_problem_programmers.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives an explicit conditional usage guideline: if only a problem number is given, determine the platform from context, or if context is missing, verify with the user before calling. However, it does not name specific alternative tools for similar tasks (e.g., generate_hint_boj), so it lacks explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 the tool analyzes code and problem text, may require platform clarification, and includes specific output components. However, it does not explain how it obtains the user's code, side effects, failure modes, or whether it fetches external data, leaving behavioral ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose and followed by a necessary warning. Every sentence adds value; no redundant content or excessive detail.
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 generation tool with no output schema, the description provides a solid overview of expected outputs (markdown template, analysis, related problems, prompt) and critical platform guidance. It lacks details on prerequisites like whether code submission is required, but is otherwise sufficiently complete for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds meaningful context beyond the schema by warning about platform ambiguity for problem_id and clarifying that user_notes is an optional memo. This helps the agent understand the practical implications of the parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool analyzes the user's submitted code and problem text to generate a personalized review guide for BOJ problems. It includes a specific verb ('제공합니다'), target resource ('백준(BOJ) 문제'), and output components, distinguishing it from platform-specific siblings like generate_review_template_programmers.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit platform-disambiguation guidance: if only a problem number is given, determine the platform from context or ask the user whether it is BOJ or Programmers. This helps the agent select the correct platform-specific tool, but it does not explicitly contrast with other BOJ tools like analyze_code_submission_boj or generate_hint_boj.
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 adds behavioral context via examples and the platform-confirmation warning, but it does not disclose return format, empty-result behavior, or any access requirements. For a read-only search tool, this is adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded: it states the purpose, gives examples, and adds a warning in just two sentences. Every sentence adds value with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter search tool with no output schema, the description covers purpose, examples, parameter usage, and a platform-confirmation note. It could be more explicit about BOJ-specific scope, but the tool name and sibling list supply that context.
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 already documents the single required query parameter with 100% coverage. The description goes beyond by specifying that both Korean and English keywords are supported and providing concrete examples, which enriches the parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches algorithm tags using Korean or English keywords, with specific examples. This distinguishes it from sibling tools like search_problems_boj, which search problems rather than tags.
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: use this tool when you need to find algorithm tags by keyword. It also gives a practical usage warning to confirm the platform if unspecified, but does not explicitly name alternative tools or exclusion scenarios.
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 generates an LLM analysis prompt by combining problem text and user code, lists the response structure (problemInfo, codeMetadata, analysisPrompts, suggestedQuestions), and warns about the platform ambiguity requiring user confirmation. This goes beyond a simple 'analyzes code' statement, though it does not detail edge cases like input validation or rate limits.
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 for analysis types, response structure, supported languages, and a platform note. It is somewhat longer than necessary but each sentence contributes useful information, and the front-loaded purpose statement helps agents quickly understand the tool's role.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 4 parameters, 3 required, and no output schema, the description is fairly complete. It provides the response structure, analysis type semantics, and platform resolution guidance. It does not provide an example invocation or specify the exact JSON shape of the generated prompt, but the given fields and the schema cover the essential needs for selecting and calling the tool 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%, so baseline is 3. The description adds value by explaining the meaning of each analysis_type (full, hint, debug, review) with one-line definitions, and lists supported languages that align with the language enum. It also clarifies that 'problem_id' can be a Programmers problem ID or URL. This enhances the schema descriptions, which merely name the fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: '프로그래머스 문제에 대한 사용자 코드를 분석하여 피드백을 제공합니다' (analyzes user code for Programmers problems and provides feedback). It differentiates from siblings by specifying the Programmers platform and detailing distinct analysis types (full, hint, debug, review), which is unique to this tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for Programmers problems and includes an explicit platform identification guideline: if only a problem number is given, the agent must determine the platform from context or ask the user whether it is BOJ or Programmers. It does not explicitly say 'use BOJ tool for BOJ problems', but the sibling list and the platform note make the intended usage clear.
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?
With no annotations, the description fully discloses operational behavior: web scraping via fetch + cheerio, target URL, 10-second timeout, max 2 retries, 1 request/second rate limit, and that tags field is empty for Programmers. This goes well beyond a simple getter and gives the agent critical 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-organized with labeled sections (usage scenarios, limitations, notes). Every section contributes necessary operational detail for a scraping tool, although it could be tightened slightly without losing value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite no output schema, the description lists the full response structure (problemId, title, level, category, description, constraints, examples, tags). It also covers rate limiting, retries, timeout, platform-specific behavior, and the platform disambiguation requirement, making it complete for an agent to invoke 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?
The schema already covers the single problem_id parameter with examples and 100% coverage. The description adds valuable disambiguation guidance: when only a problem number is given, the agent must determine the platform from context or ask the user. This extra semantic helps correct invocation.
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 function: '프로그래머스 문제 상세 정보 조회 (웹 스크래핑)' and lists the returned fields (problemId, title, level, etc.), distinguishing it from BOJ tools. However, it does not explicitly differentiate from the sibling fetch_problem_content_programmers, which may overlap.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit usage scenarios (before solving, during review, code analysis) and clear guidance for platform disambiguation when only a problem number is given. It does not, however, list when not to use this tool or mention alternative siblings such as fetch_problem_content_programmers.
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 behavioral burden. It discloses that the tool combines problem text and user code to generate an LLM analysis prompt, and it specifies the response structure (problemInfo, codeMetadata, analysisPrompts, suggestedQuestions). It does not mention side effects, auth requirements, or rate limits, but the LLM-prompt nature is transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and well-structured, with short sections for analysis types, response structure, usage scenarios, supported languages, and a platform-verification warning. It front-loads the core purpose and every sentence contributes meaningful guidance, with no redundant filler.
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?
The description fully compensates for the lack of an output schema by listing the response fields. It also covers analysis types, languages, and the critical platform-ambiguity rule. For a tool with 4 parameters, 2 enums, and no output schema, this description is remarkably complete for an agent to invoke 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?
The input schema covers all parameters with descriptions (100% coverage), so the baseline is 3. The description adds value by explaining each analysis_type in detail (full, hint, debug, review) and listing supported languages, which goes beyond the schema's enum labels. It does not add syntax details for problem_id or code, but those are straightforward.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action: '백준(BOJ) 문제에 대한 사용자 코드를 분석하여 피드백을 제공합니다' (analyze user code for BOJ problems and provide feedback). It clearly distinguishes from sibling tools by naming BOJ and including a platform-verification note that separates it from the Programmers variant.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a '사용 시나리오' section listing concrete use cases (code improvement, debugging, code review) and explicitly instructs the agent to confirm the platform with the user if only a problem number is given. It does not name alternative tools or explicitly state when not to use it, which prevents a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses important behaviors: scraping target URL, 10-second timeout, up to 2 retries, 30-day cache, and the fact that hints are excluded. It also reveals the response structure. While it doesn't explicitly state read-only semantics or auth requirements, the disclosed operational details are substantial and go well beyond minimal 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 well-structured with clear sections (purpose, response structure, usage scenarios, limitations, platform warning). While it is relatively lengthy, every section adds practical information. It is not redundant or bloated, though the phrase '힌트 제외' appears both in the opening and in the hint warning, which is a minor duplication.
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 no output schema and no annotations, the description compensates well by listing the response fields and constraints. It covers usage context, technical limits, and platform ambiguity. It does not detail possible failure modes or error handling, but for a scraping tool of moderate complexity, the provided information is sufficient for an agent to invoke it 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?
The input schema already documents problem_id with type and description, giving 100% coverage. The description adds valuable context beyond the schema: the exact URL pattern (https://www.acmicpc.net/problem/{problem_id}) and the platform-disambiguation logic, which helps clarify how the parameter value should be interpreted and used.
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 a specific verb and resource: it scrapes the BOJ problem statement (title, description, I/O format, examples, limits) and explicitly excludes hints. It distinguishes itself from the hint-generation sibling by directing users to generate_hint_boj when hints are needed.
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 '사용 시나리오' section explicitly lists when to use the tool (before solving, during review, for code analysis). It also provides a critical platform-disambiguation warning, instructing the agent to confirm whether the platform is BOJ or Programmers when only a problem number is given. This is clear, actionable guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral burden. It discloses what the tool returns (structured hint data with difficulty context and 3-step hint guide) and highlights a key behavioral caveat about platform ambiguity. It does not mention side effects or authorization, but for an analysis tool this is acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: one stating the tool's purpose and components, and one providing a critical usage warning. It is concise, front-loaded with the core purpose, and contains no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given there is no output schema, the description adequately communicates the main return content (structured hint data, difficulty context, 3-step guide). It also addresses the key context of platform ambiguity. Minor omissions like error handling are not critical for this simple two-parameter 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?
The input schema already provides descriptions for both parameters (problem_id as ID/URL, include_similar as boolean), giving a baseline of 3. The description adds valuable context for problem_id by warning that a bare number could be ambiguous between platforms, thereby enriching the meaning supplied by 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 analyzes Programmers problems and provides structured hint data, mentioning specific components like difficulty context and a 3-step hint guide. This distinguishes it from sibling tools such as analyze_problem_boj and generate_hint_programmers by explicitly naming the platform (Programmers) and the unique output format.
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 includes an explicit warning about platform determination: if only a problem number is provided, the agent must infer the platform from context or ask the user before invoking the tool. This effectively guides when to use this tool versus BOJ-specific siblings, even though no sibling is explicitly named.
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?
With no annotations provided, the description carries the full burden and does well: it discloses the target URL, timeout, retry limit, cache duration, and a critical platform-disambiguation warning. This is rich behavioral context beyond the tool name and 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 well-structured with clear sections and front-loaded main purpose. It includes useful details without excessive fluff, though a few lines could be trimmed without losing important guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having no output schema, the description lists the response structure and key behavioral constraints (timeout, retries, cache). The single parameter is adequately explained, and the platform ambiguity warning addresses a real contextual risk.
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%, and the description adds that the parameter accepts either a problem ID or a URL. It also clarifies the meaning of the problem_id parameter in the context of the scraping target, going beyond the schema's generic type definition.
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 scrapes Programmers problem content including title, description, constraints, and examples. It identifies the specific resource and targets the Programmers platform, distinguishing it from sibling BOJ tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives explicit use scenarios (before solving, during code analysis) and importantly instructs to verify the platform when only a problem ID is given. It doesn't explicitly name sibling alternatives, but the platform verification guidance effectively prevents misuse.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses that the tool generates a guide with specific components and includes a critical behavioral caveat (checking platform before calling). However, it does not detail side effects, authentication needs, or what happens on invalid input, though for a generation tool this is less critical.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two compact sentences and a warning; the first sentence states purpose and deliverables, the second provides a crucial usage hint. No fluff, front-loaded, every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 2 parameters and no output schema, the description sufficiently describes what the tool does, what it produces (template, analysis, prompt), and the key edge case (platform ambiguity). The agent has enough to invoke it correctly without additional missing context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds semantic value to the problem_id parameter by warning about ambiguity when only a number is supplied, implying the tool may need platform clarification. This goes beyond the schema's simple 'ID or URL' description.
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 uses a specific verb ('제공합니다' - provides) and a clear resource ('프로그래머스 문제에 대한 복기용 가이드'), listing concrete deliverables (markdown template, problem analysis, writing prompts). It clearly distinguishes from the BOJ sibling by specifying the platform, and the warning about platform discrimination further clarifies its scope.
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 gives explicit when-to-use guidance: for Programmers problems, and crucially instructs the agent to confirm the platform if only a problem number is given without context. This is direct, actionable usage guidance that prevents incorrect tool selection across the BOJ/Programmers sibling pair.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations were provided, so the description carries full responsibility. It discloses key behavioral rules: only one hint level is provided at a time, the response structure contains hint_levels[0-2], and the answer policy (full solution only when explicitly requested). These details help the agent anticipate interactions.
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 headings, emojis, and numbered lists, making it scannable despite length. Each section adds value, though some repetition occurs in usage versus policy sections. Still, every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (multi-level hint selection, platform ambiguity, answer policy), the description is exceptionally complete. It covers all operational aspects, references a complementary tool for hard problems, and offers clear decision rules for the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already fully describes problem_id (100% coverage), so baseline is 3. The description adds useful context about platform disambiguation and that the hint depends on problem_id, enhancing the schema but not contradicting it.
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 generates Baekjoon (BOJ) problem hints using a 3-stage guide prompt. It distinguishes this tool from siblings like get_problem_boj and fetch_problem_content_boj by focusing on hint generation rather than retrieval or analysis.
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 when-to-use conditions for each hint level based on user context, recommends fetch_problem_content for difficult problems, and instructs to verify platform ambiguity when only problem_id is given. This goes beyond simple guidance by including exclusions and alternatives.
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?
With no annotations, the description carries the full burden and does exceptionally well: it reveals Puppeteer-based scraping, response latency, page size, return format (markdown table with specific columns), and the reason for slowness (JavaScript rendering). This adds meaningful behavioral context beyond the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (intro, examples, limitations, response format, warnings). It is slightly redundant as the '중요' warning repeats the 3-5 second latency already stated in limitations, but overall every section serves a purpose and the front-loaded intro is effective.
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 detailing the response format (markdown table with columns). It also covers platform-specific behavior, constraints, and usage examples, making it complete for a moderately complex search tool with 5 optional parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds value by providing concrete usage examples for levels, order, query, and page, and by clarifying the levels range (0-5). This goes beyond the plain schema descriptions, though it doesn't detail every parameter's syntax.
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: '프로그래머스 문제를 검색합니다' (searches Programmers problems) and mentions filtering by difficulty, sort, and keyword. It distinguishes from the BOJ sibling by explicitly referencing BOJ's speed and advising platform confirmation.
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 usage examples for various parameter combinations (levels, order, query, page) and clearly states when to use this tool by instructing to confirm the platform when unspecified. It also mentions limitations like 3-5 second response time, helping users decide if this is appropriate.
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?
With no annotations, the description carries the full burden of behavioral disclosure. It explains the response structure (hint_levels array with prompts), enforces a strict 'one level at a time' policy, and states the answer policy ('정답 정책') that full solutions are only provided on explicit request. This goes well beyond typical descriptions.
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?
Though lengthy, the description is exceptionally well-structured with emojis, numbered lists, and clear sections. Every sentence provides operational guidance, and the key rule—'provide only one hint level at a time'—is front-loaded. There is no filler or 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 the lack of output schema and annotations, the description fully specifies the response format (hint_levels[0..2].prompt), the situation-based selection algorithm, the answer policy, and integration with fetch_problem_content_programmers. It leaves no critical behavioral or usage aspect unexplained.
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 already covers the single problem_id parameter at 100%, so the baseline is 3. The description adds meaningful extra context by warning that a bare problem number may be ambiguous between BOJ and Programmers, and instructs asking the user for platform if context is missing. It also advises fetching problem content for high-difficulty problems, enriching the parameter's usage semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states '프로그래머스 문제 힌트 생성' (Programmers problem hint generation) and '3단계 가이드 프롬프트 제공' (provides a 3-step guide prompt). It specifies both the action (generating hints) and the resource (Programmers problems), distinguishing it from the sibling generate_hint_boj 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 a detailed decision tree for when to present each of the three hint levels (Level 1 when stuck, Level 2 on re-request/partial implementation, Level 3 on explicit solution request). It also recommends using fetch_problem_content_programmers for difficult problems and includes platform disambiguation rules when only a bare number is provided.
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:

[![algoKit-mcp MCP server](https://glama.ai/mcp/servers/itsme-shawn/algoKit-mcp/badges/card.svg)](https://glama.ai/mcp/servers/itsme-shawn/algoKit-mcp)

Score Badge

Copy to your README.md:

[![algoKit-mcp MCP server](https://glama.ai/mcp/servers/itsme-shawn/algoKit-mcp/badges/score.svg)](https://glama.ai/mcp/servers/itsme-shawn/algoKit-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/itsme-shawn/algoKit-mcp'

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