Was ist MCP? Demo-Server

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The readOnlyHint/openWorldHint annotations already cover the safety profile, and the description adds genuinely non-obvious context: the data is not persisted anywhere on the site and only exists at connection time, plus the output language is German. Return shape is covered by the output schema, so nothing major is left undisclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The core claim ('was beim Verbinden geschehen ist') is front-loaded with concrete sub-items. It is somewhat verbose for a zero-param tool — the sentence about the data only arising at connection time restates the opening premise — and the brief English gloss at the end is the only concession to non-German readers.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a parameterless, read-only tool with an output schema, the description supplies everything an agent needs: what is returned, why it cannot be obtained from any page tool, and that the response is in German. Nothing relevant to correct invocation is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so the baseline is 4. The description correctly describes a call-and-read operation with no input semantics to explain, and there is no misleading implication of configurable input.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb (reports) and a specific resource: what was negotiated during the client-server connection, broken out into MCP version, client name, and client self-registration. The clause 'Diese Angaben stehen nirgends auf der Seite' implicitly separates it from page-oriented siblings like get_page and list_pages, though no sibling is named explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied: an agent infers it should call this when it wants to know what was negotiated on connect. There is no explicit 'use this when...' statement and no named alternative such as server_info, which is the nearest sibling an agent might confuse it with.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and openWorldHint=false, and the description adds real value on top: it discloses that the passage is returned 'vollständig, so wie sie auf der Seite steht' and that a slug switches the behavior to returning the entire page. It does not say what happens on an invalid or stale id, but the read-only contract is unambiguous.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded with the retrieval behavior and then the parameter modes, with no wasted clauses. The parenthetical English restatement is duplicative but cheap and aids matching.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a one-parameter read tool with an output schema that covers return structure, the description supplies everything needed to call it: both accepted id forms and the resulting scope of content. The missing piece is sibling disambiguation against get_page, plus any guidance on invalid ids.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description carries the full burden for the single 'id' parameter — and it does: the value is either the Kennung from a search result or a page short name, with a worked example. Only minor gaps remain, such as whether an id and a slug are ever ambiguous or need a prefix.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource (fetch a passage or an entire page) and explains the two modes clearly, including a concrete example slug ('sicherheit'). It does not, however, distinguish itself from the sibling get_page, which appears to serve the same whole-page retrieval purpose.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It says where the id comes from (a search hit) and that a page short name can be supplied instead, which gives usable when-to-use context. But the sibling get_page is never mentioned, so an agent has no basis for choosing between fetch with a page slug and get_page — the one ambiguity that matters most here.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered; the description adds that the response is readable markdown text and that output can be narrowed, which is real behavioral value. It does not mention error behavior for an unknown slug or whether content is cached, so it stops short of full disclosure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The core behavior and the slug source are front-loaded, and each clause carries information. The German text is then repeated as an English parenthetical, which is useful for disambiguation but does duplicate content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, return values need no explanation, and the description covers all three parameters at a workable level. The remaining gap is the accepted value space for 'section' on a tool whose schema gives it no description at all.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description carries the burden and does explain the two non-obvious parameters: slug origin with a concrete example, and format='outline' meaning headings-only. The 'section' parameter is only described as 'only one section,' without saying what values it accepts (heading name? id?).

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (return/read) and resource (one page of was-ist-mcp.ch) along with the three output modes (full page, single section, outline). It also points at the sibling 'list_pages' as the source of slugs, so an agent can place it relative to its siblings without opening the schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explains where the required slug comes from ('list_pages', with the example 'sicherheit') and when to use the 'section' and format='outline' variants. It does not state when to prefer a sibling such as 'search' or 'fetch' instead, so an explicit exclusion is missing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered structurally. The description adds useful content scope, namely the service overview and Swiss coverage, but does not disclose filter behavior, error cases, or completeness guarantees beyond what annotations provide.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded and the description is short enough for a low-complexity list tool. The English parenthetical largely repeats the German sentence, which is a minor redundancy but not a major structural flaw.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple, has an output schema, and both parameters are optional, so an agent can call it without filters. However, the description leaves filter values and usage guidance unspecified, which is a meaningful gap for correct use of 'kategorie' and 'status'.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and both parameters are undocumented strings. The description names 'kategorie' and 'status' and says they restrict the list, but does not explain allowed values, format, or what each filter actually selects.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: it returns the MCP service list from was-ist-mcp.ch as structured rows, including which services exist, what AI can read/change, and what is missing in Switzerland. This is clearly distinct from sibling tools like list_pages, get_page, or search.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explains that 'kategorie' and 'status' restrict the list, but gives no explicit when-to-use guidance, no exclusions, and no comparison with alternatives such as search or list_pages. The use case is only inferable from the stated purpose.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description's added behavior is limited to enumerating return fields, which the existing output schema already documents, and it says nothing about result size, ordering, or what happens when the site grows.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences, front-loaded with the resource and scope, then the usage hint. The parenthetical English translation restates the same content, which is mild duplication but useful for language matching rather than filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With zero parameters, a full output schema, and annotations covering the safety profile, the description only needs to convey purpose and sequencing, which it does. A brief note on ordering or expected result count would have closed the last gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes no parameters, so the baseline of 4 applies. The description correctly makes no parameter claims that would need reconciling with the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Listet alle Seiten von was-ist-mcp.ch auf') plus the returned fields, so the scope is unambiguous. It implicitly separates itself from get_page ('bevor Sie gezielt eine Seite holen') without naming the sibling directly, which keeps it at a 4.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly positions itself as the first call to make before fetching an individual page, which is a clear usage cue for an agent orienting itself. It never names get_page or search as the alternatives, so routing is implied rather than stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=false and destructiveHint=false; the description adds genuinely non-obvious context — the credentials are public, shared by all readers, and grant no real protection. Token lifetime, expiry, and failure behavior are not disclosed, keeping it below a 5.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The behavioral facts (token return, credential source, security caveat) are front-loaded and each clause earns its place. The trailing English gloss duplicates the German sentence rather than adding information, costing a point.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists, so return values need no explanation, and the description covers the auth source, the purpose, and the security caveat. Missing only edge details — what a failed login looks like and whether the token persists across calls — for full completeness on a login tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0% (both username and password are bare strings with no descriptions), so the description must carry the load. It partially compensates by pointing to the published credentials page, but gives no format, case, or value hints for either parameter.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Meldet sich am Demo-Server an') plus the return value ('gibt einen Token zurück') and its consumer role (the two protected tools). It stops short of naming those two tools, so an agent must infer from the sibling list which ones need the token.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Tells the agent where the credentials come from (was-ist-mcp.ch/mcp-ausprobieren) and clarifies that the login protects nothing and only demonstrates an approval step, which is effectively a 'don't over-estimate this' caveat. It never states explicitly that this must be called before the protected tools, leaving that sequencing to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already state that this is read-only and closed-world, and the description adds useful domain scope plus the shape of matching results. It does not disclose ranking, pagination, or how limit affects results; with an output schema present, this is adequate but not rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description front-loads the purpose and then compactly explains query style and filters. The parenthetical English translation is slightly redundant, but overall it is appropriately sized with no padding.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The output schema covers return structure and annotations cover the safety profile, so the description does not need to explain those. It provides enough context to call search with query, kind, and slug correctly, though missing limit semantics and sibling routing keep it from being fully complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must carry parameter meaning. It explains slug, kind categories, and query style well, but it leaves limit undocumented and does not clarify the 'alle' default or expected slug format.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

It states a specific verb, resource, and return elements: 'Durchsucht die Inhalte von was-ist-mcp.ch' and returns matching passages with title, link, and snippet. It is clear what the tool does, but it does not explicitly distinguish itself from siblings such as get_page, list_pages, or fetch.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives query phrasing guidance ('Fragen Sie in ganzen Sätzen, auf Deutsch') and explains how slug and kind narrow the search. However, it does not say when to use this tool instead of get_page, list_pages, or fetch, nor does it give exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is clear. The description adds the specific status fields it reports, but the output schema likely covers return details, and no extra auth or rate-limit context is provided.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences and front-loads the core purpose. The German text is followed by an English translation, which is slightly redundant but still compact.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter, read-only status tool with annotations and an output schema, the description is complete: it tells the agent exactly what server state is reported.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

There are zero parameters, so there is no parameter semantics to clarify. The schema is empty and the description does not need to compensate for undocumented inputs.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb and resource set: it reports this server's version, index build time, and readiness. It is clear what the tool does, though it does not explicitly distinguish itself from the sibling site_statistics.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied by the purpose: checking server version and search readiness. However, it does not state when to use this instead of siblings or any explicit alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and openWorldHint=false, and the description adds genuinely new behavioral context: authentication is mandatory, a login link may be returned instead of data, and the auth is a demonstration of an approval step with no confidentiality implications. It doesn't mention pagination or failure modes for an invalid token.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the metric list before the auth detail, which is the right order. The trailing English parenthetical partly duplicates the German text, costing some space without adding new information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a single-optional-param, read-only stats tool with an output schema present, the description covers purpose, metrics, and the full auth path, which is more than adequate. Return-shape explanation isn't needed given the output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description has to carry the `token` parameter, and it does: it explains where a token comes from (`login` tool, demo credentials) and that a login-link flow is an alternative. It doesn't state that the parameter is optional/defaults to null, which the schema carries implicitly.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Gibt Betriebszahlen ... aus') and enumerates exactly which metrics: word count and reading time per page, sections, entries, and count of searchable text passages. That is enough to distinguish it from siblings like list_pages or get_page, which return content rather than aggregates.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly names the prerequisite (anmeldung) and routes the agent to the alternative 'token' source from the `login` tool or the demo credentials URL, plus a login-link path. It doesn't say when to prefer this over list_pages/get_page when an agent just wants page content, so it falls short of full when/when-not guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Goes well beyond the annotations (readOnlyHint=false, destructiveHint=false) by disclosing that the login is shared by all readers, that feedback is not private, that the operator reads it, and that it may be published as a public example — with an explicit instruction not to include personal data. This is exactly the kind of consequence-level disclosure annotations cannot carry.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Purpose and the privacy warning are front-loaded, and the auth details follow in logical order. The appended English parenthetical partially duplicates the German text, costing some tightness but aiding clarity for non-German agents.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists so return values need not be described, and the auth flow plus the privacy consequence are covered. The only real gap is the unexplained `page` parameter and any indication of what happens after submission (e.g., whether a confirmation or link is returned).

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must compensate. It explains `token` well (source: login window connection, `login` tool, or demo credentials) and implicitly characterizes `message` as free text with a privacy caveat, but the `page` parameter is never mentioned, leaving one of three params undocumented.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (send) and resource (feedback) plus the recipient (the operator of was-ist-mcp.ch), which no sibling tool covers. An agent can distinguish it from `login` or `get_page` at a glance.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explains the prerequisite clearly: a login is required, and the token can come either from a connection initiated in the login window or from the `login` tool, or from the demo page credentials. It names the sibling that supplies the token, though it does not state explicit when-not-to-use conditions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.