tlc-portal-mcp

by mingovvv

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: v0.1.0
Disambiguation5/5
All tools have distinct, non-overlapping purposes. Auth tools cover distinct lifecycle stages (login, import, status check, clear), while leave tools cleanly separate queries (balances, types, history) from the submission workflow (prepare, submit, cancel) with no ambiguity between operations.
Naming Consistency4/5
The leave.* namespace follows strict verb_noun convention perfectly. The auth.* namespace mostly follows this but has minor deviations: auth.status uses a noun instead of get_status, and auth.clear lacks an object (should be clear_session), making the pattern slightly inconsistent across domains.
Tool Count5/5
Ten tools is well-scoped for an employee portal covering authentication and leave management. Four auth tools handle the session lifecycle appropriately, while six leave tools cover type discovery, balance checking, submission workflow, and cancellation without bloat or gaps.
Completeness4/5
The surface covers core employee workflows well: full auth lifecycle and leave submission/cancellation. Minor gaps exist—such as updating a pending request (requiring cancel+resubmit) and retrieving a specific request by ID—but agents can work around these using list_requests.
Average 3.2/5 across 8 of 10 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses critical interactive traits absent from annotations: requires browser opening, user intervention, and JWT persistence side-effects. However, fails to specify timeout expiration behavior, return values, or whether existing sessions are overwritten—significant gaps for a mutation tool with no annotation safety hints.
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?
Single Korean sentence is appropriately front-loaded and efficient, with no redundant words. Conciseness is technically good, though excessive brevity contributes to informational deficits in other scoring dimensions.
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?
Insufficient for an interactive authentication tool with no output schema or annotations. Missing: return value contract, error handling on timeout, browser requirements, and idempotency characteristics (can this be called multiple times?).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% (timeout_seconds lacks description field). Description provides zero compensation for this gap—does not mention the parameter, its units (seconds), or behavior when timeout is reached. Falls below minimum viable threshold.
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?
Clear verb+resource combination ('로그인'/'login') and distinguishes from siblings (auth.clear, auth.status, auth.import_vuex). Explicitly identifies browser-based interactive flow, though could clarify scope regarding session overwrite behavior.
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 explicit when-to-use guidance or prerequisites (e.g., 'use when not authenticated'). No comparison to auth.import_vuex for importing existing tokens versus fresh browser authentication. Usage is only implied by the mechanistic description.
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. While '조회' implies read-only access, the description fails to mention pagination behavior (limit/offset), filtering capabilities (date ranges, status filtering), or what the returned structure contains.
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 single-sentence description is efficient and front-loaded with the action verb, containing no wasted words. However, it arguably errs on the side of under-specification for a tool supporting complex filtering and pagination.
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 presence of 5 parameters, pagination support, and absence of both annotations and output schema, the description is insufficient. It omits critical operational context such as the default pagination limits, the fact that date ranges filter application dates, and the structure of returned request objects.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 60% (limit and offset lack descriptions). The description provides no additional semantics to compensate for the undocumented pagination parameters or to explain the date filtering behavior, meeting the baseline expectation for moderate schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description '휴가 신청 내역을 조회한다' uses a specific verb (조회한다/retrieve) with a clear resource (휴가 신청 내역/leave request records). It implicitly distinguishes from siblings like cancel_request, submit_prepared_request, and get_balances by describing a read operation on request history rather than mutations or balance inquiries.
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 provided on when to use this tool versus alternatives (e.g., when to filter by status vs. using cancel_request), nor mention that all parameters are optional with defaults. The description merely states what the tool does, not when to invoke it.
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 provided, so the description carries full burden. It fails to disclose what 'status' entails (boolean, user object, token details?), error behavior when unauthenticated, or whether this is a safe read-only 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?
Single sentence is appropriately concise, though given the lack of annotations and output schema, it is arguably too brief rather than efficiently structured. No redundancy or filler present.
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?
No output schema exists and no annotations are provided. For an authentication utility, the description should compensate by describing the return value structure (fields, types, error states), but it provides only a high-level verb without payload details.
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?
Zero parameters with 100% schema coverage (vacuously true). Baseline score applies as there are no parameters requiring semantic clarification beyond the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action (returns) and resource (current authentication status). It implicitly distinguishes from sibling auth.login and auth.clear by being a read operation, though it does not explicitly contrast with them.
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 provided on when to use this tool versus auth.login or auth.clear. Missing prerequisites (e.g., whether valid credentials must exist to call this) and no mention of alternative approaches.
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 must carry the full burden of behavioral disclosure. It fails to mention whether this overwrites existing sessions, validates the payload format, or what errors occur on invalid input. The mutation risk (importing state) is implied but not explicitly disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single efficient sentence with no redundancy. However, given the lack of annotations and schema descriptions, it is slightly too terse—additional context about behavioral implications would improve utility without being verbose.
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 single-parameter authentication tool, the description covers the core mechanism adequately but leaves gaps typical of mutation operations. Without annotations or output schema, it should disclose side effects (session replacement) and validation behavior to be complete.
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?
With 0% schema description coverage, the description compensates by explicitly identifying the vuex_payload as the value from 'browser localStorage['vuex']'. This gives the agent clear semantic context for sourcing the parameter, though it could specify expected format (JSON string, encoded object, etc.).
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 imports authentication state by pasting the browser's localStorage['vuex'] value. It uses a specific verb (붙여넣어/paste) and resource (인증 상태/authentication state), distinguishing it from sibling auth.login (fresh authentication) and auth.clear (removal).
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 explicit guidance on when to use this tool versus auth.login or auth.status. While it implies this is for restoring existing sessions rather than new logins, it does not state prerequisites (e.g., 'use when you have exported Vuex data') or warn against using it with invalid payloads.
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 full disclosure burden. It only states the action ('cancel') without describing side effects (leave balance restoration, notification triggers), reversibility, or required request states (pending vs. approved). Critical behavioral traits for a mutative operation are missing.
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 single-sentence description is appropriately front-loaded with zero redundancy. However, given the lack of annotations and behavioral detail, extreme brevity here contributes to informational gaps rather than efficient communication.
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 cancellation operation (moderate business logic complexity) with zero annotations, no output schema, and mutative side effects, the description is insufficient. It omits expected outcomes, status change semantics, and balance implications that an agent needs to invoke this safely.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema description coverage, the input schema fully documents the 'request_id' parameter. The description adds no param-specific syntax or format details, but baseline 3 is appropriate when schema coverage is complete and the description doesn't introduce ambiguity.
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 '기존 휴가 신청을 취소한다' (Cancels an existing leave request) provides a specific verb (cancel) and resource (leave request). The term '기존' (existing) clearly distinguishes this from sibling tools like leave.submit_prepared_request (creating new) and leave.prepare_request (drafting), making the scope distinct.
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 states what the tool does but provides no guidance on when to use it versus alternatives, prerequisites (e.g., only cancelable states), or ownership restrictions (self vs. others). No exclusion criteria or alternative approaches are mentioned.
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. While it mentions this is a verification step, it fails to disclose what state gets created (e.g., a draft request), whether the operation is idempotent, what validation occurs, or most critically, what the return value contains (likely a prepared request ID needed for submit_prepared_request).
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 two-sentence structure is appropriately front-loaded with the core action in the first sentence and the workflow stage in the second. While extremely terse given the tool's complexity, there is no wasted language or 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 7 parameters, multi-step workflow (prepare→submit), and absence of an output schema, the description is incomplete. It fails to explain what this tool returns (critical for the agent to know how to invoke submit_prepared_request) and omits behavioral details necessary for stateful workflow coordination.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 86% schema description coverage, the structured schema already comprehensively documents parameters including date formats, enum values, and field purposes in Korean. The description adds no specific parameter guidance, but the baseline of 3 is appropriate given the schema's completeness.
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 Korean description clearly states it prepares a vacation request and identifies it as a 'pre-submission verification step', which distinguishes it from the sibling submit_prepared_request tool. However, it does not explicitly name the sibling or clarify that this tool likely returns a prepared request identifier required for the next step.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It implies workflow order by stating this is the 'pre-submission' stage, suggesting it should be used before final submission. However, it lacks explicit guidance on when to use this versus direct submission (if available) or prerequisites, and does not explain the two-step prepare-then-submit pattern explicitly.
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. While 'portal' implies an external system, the description lacks details on side effects, idempotency, or whether submission is reversible via leave.cancel_request.
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 single-sentence description is efficiently front-loaded with no extraneous information, conveying the essential action and target system immediately.
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?
While adequate for a single-parameter tool, the description is incomplete regarding the two-step workflow (prepare then submit) implied by the sibling tools, which is critical information for successful invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description compensates effectively by referencing 'prepared vacation request' (준비된 휴가 신청), which clarifies that the prepared_request_id parameter refers to a request prepared via the prepare_request sibling.
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 submits a prepared leave request to a portal, using specific verbs and resources. While it distinguishes from siblings like leave.prepare_request by specifying the submission action, it could further clarify what 'prepared' entails.
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, and critically fails to mention that leave.prepare_request must be called first to generate the prepared_request_id required by this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Verb '조회' (query/retrieve) implies read-only behavior, but description lacks disclosure of return format, whether balances are per-user or aggregate, temporal scope of 'current', or pagination behavior. No mention of rate limits or caching.
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?
Single sentence of 5 words, front-loaded with no redundancy. Appropriate length for a simple read-only getter with no parameters. Every element earns its place.
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?
Minimal but functional for low complexity. Missing output description (no output schema exists to compensate), doesn't clarify if balances are for authenticated user only or include breakdown by leave type. Adequate but clear gaps given lack of structured metadata.
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?
Zero parameters per input schema (empty object). With 0 params, baseline score is 4 as per rubric. Description correctly implies no filtering capabilities are needed for this operation.
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?
Description uses specific verb (조회하다/ retrieves) and resource (잔여 휴가/ remaining leave balance), clearly identifying this as a balance query operation. Implicitly distinguishes from sibling request-management tools (list_requests, cancel_request) by targeting 'balances' rather than 'requests', though explicit differentiation is absent.
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?
Provides no guidance on when to use versus alternatives (e.g., vs. list_requests for history), no prerequisites mentioned (e.g., authentication requirements implied by auth.* siblings but not stated), and no exclusion criteria.
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 identifies the operation as read-only via the word 'returns,' but fails to describe what constitutes a 'type' object, whether the list is user-specific or global, caching behavior, or the structure/format of the returned data (critical given no output schema exists).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence consisting of six words in Korean. It is immediately front-loaded with the core action and resource, containing zero redundant or wasted clauses.
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 zero-parameter tool, the description is minimally sufficient to invoke the tool. However, given the absence of an output schema and annotations, the description should ideally describe the return structure (e.g., array of type objects with IDs and labels) or behavioral constraints to be fully complete.
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 contains zero parameters, which establishes a baseline score of 4 per the evaluation rules. The description correctly implies no filtering parameters are needed to retrieve the full catalog of types.
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 (반환한다/returns) and resource (휴가 유형 목록/list of leave types) that clearly identifies the tool's function. It effectively distinguishes from sibling leave.list_requests (which returns request instances, not type definitions) and other mutation operations like leave.submit_prepared_request.
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, nor does it mention prerequisites such as authentication (despite the presence of auth.* siblings) or when this data should be fetched relative to leave.prepare_request. No explicit when-not or alternative selection criteria are present.
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 correctly identifies the destructive operation (deletion of sessions) but lacks critical context such as whether this affects only local state or server-side sessions, idempotency, or side effects on subsequent tool calls.
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 consists of a single efficient sentence that immediately conveys the action and target. No redundancy or extraneous information present; front-loaded with the core operation.
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?
While adequate for a zero-parameter tool, the description lacks safety context expected for a destructive authentication operation given the absence of annotations and output schema. Should specify scope (local vs remote) and immediate consequences for user state.
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 contains zero parameters (empty properties object), establishing baseline 4. The description appropriately requires no parameter explanation since the tool operates without inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description provides a specific verb (삭제한다/deletes) and resource (저장된 인증 세션/saved authentication session). It clearly distinguishes this tool from sibling auth.login (which creates sessions) and auth.status (which checks sessions) by specifying the destructive clearing action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
While the destructive nature implies use for logout or credential reset scenarios, the description provides no explicit guidance on when to invoke this versus auth.login, nor does it mention prerequisites like requiring an active session or the consequences of clearing.
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:

[![tlc-portal-mcp MCP server](https://glama.ai/mcp/servers/mingovvv/tlc-portal-mcp/badges/card.svg)](https://glama.ai/mcp/servers/mingovvv/tlc-portal-mcp)

Score Badge

Copy to your README.md:

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

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