swiss-culture-mcp
This MCP server exposes Swiss cultural heritage data (ISOS townscapes, living traditions, cultural prizes, news, open data) to AI assistants via 10 read-only tools, with dual stdio/HTTP transport and no API key required.
Search ISOS protected townscapes by name, canton, or settlement type (e.g.,
bak_search_isos,bak_isos_by_kanton,bak_isos_by_kategorie)Retrieve detailed ISOS object info and inventory statistics (
bak_get_isos_detail,bak_isos_statistics)Get current BAK press releases and cultural prize information (
bak_get_news,bak_get_kulturpreise)List BAK open-data datasets on opendata.swiss (
bak_get_opendata)Browse and fetch details on 228 Living Traditions of intangible cultural heritage (
bak_list_traditions,bak_get_tradition_detail)Access 3 MCP resources: ISOS kantone, ISOS kategorien, and cultural prize overview
Deploy via stdio (Claude Desktop) or Streamable HTTP (cloud), with security controls for public binding
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@swiss-culture-mcpShow ISOS townscapes in Vaud"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
π¨π Part of the Swiss Public Data MCP Portfolio
ποΈ swiss-culture-mcp
MCP server for Swiss cultural heritage data from the Federal Office of Culture (BAK) β ISOS townscapes, Living Traditions, cultural prizes, press releases. No API key required.
π English | Deutsch
Overview
swiss-culture-mcp makes Swiss cultural data accessible to AI assistants. The server connects LLMs like Claude with Switzerland's national cultural heritage: from protected townscapes (ISOS) to living traditions of intangible cultural heritage and current cultural awards.
Sources: geo.admin.ch REST API Β· news.admin.ch RSS Β· opendata.swiss CKAN Β· lebendige-traditionen.ch
No API key required. All data sources are publicly available (Open Government Data).
Anchor demo query: "Which protected townscapes are there in the school districts of the city of Zurich, and what living traditions are practised there?"
Related MCP server: swiss-cultural-heritage-mcp
Features
ποΈ ISOS search β Federal Inventory of Swiss Townscapes Worth Protecting by name, canton or settlement type
π Living Traditions β 228 entries of Swiss intangible cultural heritage
π Cultural prizes β Swiss Film Prize, Grand Prix Literature, Music Prize and more
π° BAK press releases β current news from the Federal Office of Culture
π¦ Open data catalogue β BAK datasets on opendata.swiss
βοΈ Dual transport β stdio for Claude Desktop, Streamable HTTP for cloud deployment
# | Tool | Description |
1 |
| Search ISOS townscapes by place name |
2 |
| List all ISOS objects in a canton |
3 |
| Get full details of an ISOS object |
4 |
| Filter ISOS by settlement type (Stadt, Dorf, etc.) |
5 |
| ISOS inventory statistics (sampled by canton) |
6 |
| Current BAK press releases |
7 |
| Swiss cultural prizes (Film Prize, Grand Prix Literature, etc.) |
8 |
| BAK datasets on opendata.swiss |
9 |
| List Switzerland's Living Traditions |
10 |
| Get detailed description of a tradition |
3 Resources: bak://isos/kantone Β· bak://isos/kategorien Β· bak://kulturpreise/uebersicht
Data Sources
Source | API Type | Content |
geo.admin.ch | REST MapServer | ISOS (Federal Inventory of Swiss Townscapes) |
news.admin.ch | RSS Feed | BAK press releases, cultural prizes |
opendata.swiss | CKAN REST API | BAK open data datasets |
lebendige-traditionen.ch | HTML Fetch | 228 entries of intangible cultural heritage |
Prerequisites
Python 3.11+
uvorpipNo API keys required
Installation
# Recommended: uvx (no install step needed)
uvx swiss-culture-mcp
# Alternative: pip
pip install swiss-culture-mcpQuickstart
# Start the server (stdio mode for Claude Desktop)
uvx swiss-culture-mcpTry it immediately in Claude Desktop:
"Show me all protected townscapes in the canton of GraubΓΌnden" "Which living traditions are practised in canton Appenzell?" "Which Swiss cultural prizes were awarded in 2026?"
Configuration
Environment Variables
Variable | Default | Description |
|
| Transport: |
|
| Bind host for HTTP transport (loopback by default) |
|
| Port for HTTP transport |
|
| If |
| (empty) | Comma-separated hostnames this server answers to, without a scheme ( |
| (empty) | Comma-separated CORS origins, with scheme ( |
|
|
|
Claude Desktop Configuration
{
"mcpServers": {
"swiss-culture": {
"command": "uvx",
"args": ["swiss-culture-mcp"]
}
}
}Config file locations:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.json
After restarting Claude Desktop, all tools are available. Example queries:
"Show me all protected townscapes in the canton of GraubΓΌnden"
"What is the Alphorn and BΓΌchelspiel tradition?"
"Which Swiss cultural prizes were awarded in 2026?"
"Is the old town of Stein am Rhein in the ISOS inventory?"
"Which living traditions are practised in canton Appenzell?"
Cloud Deployment (Streamable HTTP)
For use via claude.ai in the browser (e.g. on managed workstations without local software):
The connector URL is always the deployment's host plus the transport path:
https://<host>/mcp. Add it in claude.ai under Settings β MCP Servers.
Render.com (recommended):
Push/fork the repository to GitHub
On render.com: New Web Service β connect GitHub repo
Set environment variables in the Render dashboard β including
MCP_ALLOWED_HOSTS=your-app.onrender.comand, for a browser-based client,ALLOWED_ORIGINS=https://claude.aiIn claude.ai under Settings β MCP Servers, add:
https://your-app.onrender.com/mcp
Docker. The repository ships a multi-stage Dockerfile
(python:3.13-slim, non-root, TCP health check). It presets the transport, a
0.0.0.0 bind and MCP_ALLOW_PUBLIC_BIND=true, because inside a container the
platform's edge proxy is the only way in. MCP_ALLOWED_HOSTS is deliberately
left unset in the image β the hostname depends on where you deploy, and a
guessed one would reject every real request with HTTP 421:
docker build -t swiss-culture-mcp .
docker run -p 8000:8000 \
-e MCP_ALLOWED_HOSTS=mcp.example.ch \
-e ALLOWED_ORIGINS=https://claude.ai \
swiss-culture-mcpThe two variables guard different things β one does not stand in for the other. Measured against this server on a
0.0.0.0bind, with a request carryingOrigin: https://claude.ai:
MCP_ALLOWED_HOSTS
ALLOWED_ORIGINSHost/Origin check
POST
Preflight
set
set
active
200allowed
set
β
active
403refused
β
set
off
200allowed
β
β
off
200refused
Read it column by column, because the two failures are not the same kind.
ALLOWED_ORIGINSdecides whether a browser client works at all: without it the request is refused (403from the transport when the Host allow-list is active β a rejectedOrigin; a rejectedHostwould be421) or the browser cannot read the response.MCP_ALLOWED_HOSTSdecides whether the deployment is safe: without itbuild_transport_security()returnsNoneand theHostandOriginheaders are not checked at all. Row three is the trap β a browser client connects and everything looks fine, through a deployment open to DNS rebinding. Set both on a public bind; leaveALLOWED_ORIGINSunset only when no browser-based client is meant to reach the server, and never leaveMCP_ALLOWED_HOSTSunset there.
# Local HTTP mode (loopback only β safe default, no allow-list needed)
MCP_TRANSPORT=streamable_http MCP_PORT=8000 python -m swiss_culture_mcp.server
# Public bind (DANGEROUS β only behind an authenticating reverse proxy)
MCP_TRANSPORT=streamable_http MCP_HOST=0.0.0.0 MCP_ALLOW_PUBLIC_BIND=true \
MCP_ALLOWED_HOSTS=mcp.example.ch python -m swiss_culture_mcp.serverβ οΈ Security: The server itself has no authentication. Binding to a public interface without an upstream auth layer turns it into an open proxy for the federal data sources. Always run an authenticating reverse proxy (Cloudflare Access, oauth2-proxy, nginx + auth_request) in front of
0.0.0.0deployments.
β οΈ Set
MCP_ALLOWED_HOSTSon a public bind. Without it theHostandOriginheaders are not checked at all, which leaves the server open to DNS rebinding: an attacker points a victim's browser at it and talks to it under a foreignHost. The server logsdns_rebinding_protection_offon every such start β that line is the symptom, not a formality. A loopback bind needs no allow-list; the SDK derives one from the bind host itself.
Architecture
βββββββββββββββββββ ββββββββββββββββββββββββββββ ββββββββββββββββββββββββββββ
β Claude / AI ββββββΆβ Swiss Culture MCP ββββββΆβ geo.admin.ch REST β
β (MCP Host) βββββββ (MCP Server) βββββββ news.admin.ch RSS β
βββββββββββββββββββ β β β opendata.swiss CKAN β
β 10 Tools Β· 3 Resources β β lebendige-traditionen β
β Stdio | Streamable HTTP β ββββββββββββββββββββββββββββ
ββββββββββββββββββββββββββββProject Structure
swiss-culture-mcp/
βββ src/
β βββ swiss_culture_mcp/
β βββ __init__.py
β βββ server.py # All 10 tools, 3 resources
βββ tests/
β βββ conftest.py # pytest configuration
β βββ test_server.py # 36 tests (unit + live)
βββ pyproject.toml
βββ CHANGELOG.md
βββ CONTRIBUTING.md # Contribution guide (English)
βββ CONTRIBUTING.de.md # Contribution guide (German)
βββ SECURITY.md # Security policy & posture (English)
βββ SECURITY.de.md # Security policy & posture (German)
βββ LICENSE
βββ README.md # This file (English)
βββ README.de.md # German versionMCP Protocol Version
This server speaks two protocol eras over the same endpoint. The client's first request on a connection decides which one applies; a later claim from the other era is refused.
Era | Revision | Who reaches it |
|
| What today's clients speak. The server answers with the revision asked for, or with the |
Per-request envelope |
| A request carrying the |
Both revisions are pinned in
tests/test_protocol_version.py and asserted
against the installed SDK, so a Dependabot bump of mcp cannot move either one
silently.
Note that the SDK's LATEST_PROTOCOL_VERSION is an alias for the modern
era, not for the handshake era β pinning against it alone would leave the era
that current clients actually negotiate free to drift.
The modern era is measured, not inferred.
tests/test_modern_era.py builds the server's real
ASGI app and sends requests through it: a 2026-07-28 envelope, an
initialize handshake, and each of the malformed variants. It asserts that a
modern request is answered, that the two eras stay separate (initialize is
not a method on the modern wire; the handshake caps at 2025-11-25 instead of
handing out 2026-07-28), that server/discover names exactly the pinned
revision, that a foreign revision is refused with -32022 naming both the
requested and the supported one, and that ttlMs/cacheScope and
serverInfo arrive as wire fields.
This matters because the modern era exists only on the streamable-HTTP
entry β stdio and the in-process clients speak the initialize handshake and
nothing else. Testing the spec through an in-process client tests the handlers,
not the era. That gap hid a one-character defect: main() started the HTTP
transport as streamable_http, where the SDK's run() takes
streamable-http, so the transport aborted with ValueError and the server
did not serve the spec at all. Every test stayed green, because they mocked
mcp.run and compared the string against a hand-written copy of the same
typo.
Server identity. Spec 2026-07-28 carries serverInfo in the _meta of
every response, not once per session as the handshake era does. This server
fills it with name, title, description, website URL and the version from the
package metadata (importlib.metadata, the same source as the outbound
User-Agent); a hand-maintained literal is rejected by
scripts/check_version_sync.py.
The name is swiss-culture-mcp β the same spelling as the distribution, the
console script, the registry entry and the outbound User-Agent. It read
swiss_culture_mcp until 2026-09-20; an identity spelled differently depending
on where you look is not one. tests/test_servername.py holds the sources
together rather than checking a literal against itself. The Python logger
keeps the underscore on purpose: that is a logger name, not a server identity,
and renaming it would break every operator's logging config without aligning
anything.
Update policy. When the gate fails, do not edit the constant blindly: read
the spec changelog between the two revisions, verify the server still behaves,
then move the constant, this section, README.de.md and
CHANGELOG.md together.
Testing
# Unit tests (no API key required)
PYTHONPATH=src pytest tests/ -m "not live"
# Integration tests (live API calls)
PYTHONPATH=src pytest tests/ -m "live"Example Use Cases
Schools / Education
"Which protected townscapes are there in the school districts of the city of Zurich?"
β bak_isos_by_kanton(kanton="ZH") + bak_get_isos_detail(...)
"Find living traditions for a project week on the theme of cultural heritage"
β bak_list_traditions() + bak_get_tradition_detail(slug="...")
"Which UNESCO World Heritage Sites are also in ISOS?"
β bak_search_isos(query="...") + bak_get_opendata(query="UNESCO")City Administration / Spatial Planning
"Is the building at address X within an ISOS perimeter?"
β bak_search_isos(query="community/place name")
"Which BAK datasets are available for GIS integration?"
β bak_get_opendata() β WMS/WFS URLs for GIS softwareAI Working Group / Demos
"Show current cultural policy of the federal government"
β bak_get_news() + bak_get_kulturpreise()
β More use cases by audience βSafety & Limits
Aspect | Details |
Access | Read-only β the server cannot modify or delete any data |
Personal data | No personal data β all sources are aggregated, public cultural heritage data |
Rate limits | Built-in per-query caps (e.g. max 100 ISOS results, 50 news items, 200 category entries) |
Timeout | 20 seconds per API call |
Authentication | No API keys required β all 4 data sources are publicly accessible |
Licenses | All data under open licenses (Open Government Data): geo.admin.ch, opendata.swiss, news.admin.ch |
Terms of Service | Subject to ToS of the respective data sources: geo.admin.ch, opendata.swiss, news.admin.ch, lebendige-traditionen.ch |
Known Limitations
ISOS statistics: Sample-based per canton (not exhaustive for all cantons)
Living Traditions: HTML scraping β may break if lebendige-traditionen.ch changes its structure
BAK news/prizes: RSS feed limited to the most recent entries
opendata.swiss CKAN: Full-text search may return results from other publishers
The addresses this server hands out are measured, not assumed.
scripts/record_fixtures.pyre-checks every one on each run, together with four controls (an invented geo.admin.ch service, an invented BAK path, an invented news organisation number, an invented tradition slug). On 2026-08-08 one was dead:bak_isos_overviewpublished.../home/kulturerbe/baukultur.htmlas its BAK source β HTTP 404, as is the wholekulturerbebranch. It was replaced by the BAK root, which verifiably answers 200, not by a guessed replacement URL.Everything else held. geo.admin.ch, opendata.swiss, gisos, isos, the news feed with
org-nr=314and the tradition pages all return real content. That null result is recorded too: without it the next pass starts from nothing.
Synergies with Other MCP Servers
swiss-culture-mcp can be combined with other servers in the portfolio:
Combination | Use Case |
| Cultural tourism: day trips to traditions by public transport |
| Local cultural atlas: ISOS + Zurich city events |
| Cultural education in international comparison |
| Cultural property transfer act + BAK enforcement practice |
| Cultural expenditure by canton (BFS data) |
Changelog
See CHANGELOG.md
Contributing
Contributions are welcome β see CONTRIBUTING.md.
Security
Security posture, hardening details and the responsible-disclosure process are documented in SECURITY.md.
License
MIT License β see LICENSE
Author
Hayal Oezkan Β· malkreide
Credits & Related Projects
Data: Bundesamt fΓΌr Kultur (BAK) β Federal Office of Culture
ISOS: geo.admin.ch β Federal Office of Topography swisstopo
Traditions: lebendige-traditionen.ch β BAK living traditions registry
Protocol: Model Context Protocol β Anthropic / Linux Foundation
Related: zurich-opendata-mcp β MCP server for Zurich city open data
Portfolio: Swiss Public Data MCP Portfolio
Installation
Run via uv's uvx β no clone or manual install needed. Add to your MCP client config (mcpServers for Claude Desktop, Cursor and Windsurf; use a top-level servers key for VS Code in .vscode/mcp.json):
{
"mcpServers": {
"swiss-culture-mcp": {
"command": "uvx",
"args": [
"swiss-culture-mcp"
]
}
}
}Available Tools
10 toolsbak_get_isos_detailARead-onlyIdempotent
Ruft vollstΓ€ndige Details eines ISOS-Ortsbildes anhand der Feature-ID ab.
Die Feature-ID erhΓ€lt man aus den Resultaten von bak_search_isos oder bak_isos_by_kanton. Liefert alle verfΓΌgbaren Attribute des Objekts inkl. direktem Link zur GISOS-Dokumentationsseite des BAK.
Args: params (IsosDetailInput): Parameter mit: - feature_id (str): geo.admin.ch Feature-ID
Returns: str: JSON mit vollstΓ€ndigen Objekt-Attributen: - feature_id, isos_nummer, name, kantone, siedlungskategorie - teil_name, teil_nummer (falls vorhanden) - gisos_url: Link zur detaillierten BAK-Dokumentation - koordinaten: Lage im Schweizer Koordinatensystem (LV03)
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety and idempotency. The description adds that the tool returns a JSON with all attributes and a direct link to GISOS documentation, which provides some behavioral context but does not go beyond what annotations already imply.
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 moderately sized with two paragraphs. The main purpose is front-loaded in the first sentence. The Args/Returns section provides structured detail. Minor redundancy in restating the feature_id description. Overall, every sentence contributes value.
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 description is complete for a simple tool with one required parameter. It explains input source, return format, and key attributes. The output schema exists (not shown but noted true) and is supplemented by the description. Sibling tools are listed, providing context. No gaps evident.
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?
With only one parameter (params) containing one property (feature_id), the description explains where the feature_id comes from and what the return fields include. This compensates for the schema's minimal description (0% coverage). The description adds meaningful guidance beyond the schema structure.
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 explicitly states the tool's purpose: retrieving complete details of an ISOS Ortbild using a feature ID. It uses a specific verb ('ruft ab') and resource ('vollstΓ€ndige Details eines ISOS-Ortsbildes'), clearly distinguishing it from siblings like bak_search_isos (search) and bak_isos_by_kanton (list by canton).
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 provides a clear usage guideline by specifying that the feature_id comes from results of bak_search_isos or bak_isos_by_kanton. This tells the agent how to obtain the required input. However, it does not explicitly state when not to use the tool or mention alternatives within the same family.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
bak_get_kulturpreiseARead-only
Ruft Informationen zu Schweizer Kulturpreisen ab.
Kombiniert aktuelle PreistrΓ€ger-Meldungen aus dem BAK-RSS-Feed mit strukturierten Informationen zu den wichtigsten Kulturpreisen. Preise umfassen: Schweizer Filmpreis, Grand Prix Literatur, Grand Prix Design, Grand Prix Musik, Prix Meret Oppenheim und weitere.
Args: params (KulturpreiseInput): Parameter mit: - sparte (str, optional): 'Film', 'Literatur', 'Design', 'Musik' etc. - limit (int): Maximale Anzahl Resultate
Returns: str: JSON mit: - aktuelle_preise: PreistrΓ€ger aus aktuellem/letztem Jahr (aus RSS) - preisuebersicht: Statische Γbersicht aller BAK-Kulturpreise mit Links
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint=true and openWorldHint=true. The description adds behavioral context by explaining the combination of RSS and structured data, and the output JSON structure. No contradictions.
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 well-structured with bullet points but contains redundant information (e.g., repeating parameter details already in schema). It could be more concise without losing clarity.
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?
Given the read-only nature and no output schema provided, the description sufficiently covers inputs and output structure. Missing error handling details, but acceptable for a simple retrieval 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?
The schema has high coverage for 'limit' and 'sparte', but the description adds clarity on the purpose of 'sparte' (e.g., filtering categories like 'Film', 'Literatur') and the default/max for 'limit'. This adds value beyond 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?
The description clearly states the tool retrieves Swiss culture prizes, combining current winners from an RSS feed with structured info. It lists specific prizes and distinguishes itself from sibling tools that focus on ISOS, news, or traditions.
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 what the tool does but does not explicitly state when to use it versus alternatives, nor does it provide exclusions or prerequisites. Usage context is implied but not directly guided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
bak_get_newsARead-only
Ruft aktuelle Medienmitteilungen des Bundesamts fΓΌr Kultur (BAK) ab.
Datenquelle ist der offizielle RSS-Feed des News Service Bund (NSB). EnthΓ€lt Meldungen zu Kulturpreisen, Kulturpolitik, Bundesinventaren, FilmfΓΆrderung, KulturgΓΌtertransfer und weiteren BAK-Themen.
Args: params (NewsInput): Parameter mit: - limit (int): Anzahl Meldungen (Standard: 10, max. 50) - keyword (str, optional): Stichwort zur Filterung (z.B. 'Filmpreis')
Returns: str: JSON mit Medienmitteilungen, je mit: - title: Titel der Meldung - description: Kurzbeschreibung - pubDate: Datum der Meldung - link: URL zur vollstΓ€ndigen Meldung
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false. Description adds that it fetches from an RSS feed and returns structured JSON. Does not mention rate limits or auth, but incremental value exists.
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?
Description is well-structured with purpose first, then data source, topics, and structured Args/Returns. Each sentence adds value; no fluff.
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?
Covers purpose, data source, topics, input parameters, and output structure. For a read-only news tool with annotations, it is sufficiently 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?
Input schema has 0% description coverage per context signal, but description compensates by explaining limit (default 10, max 50) and keyword with examples (e.g., 'Filmpreis'). Adds meaning beyond 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?
Description clearly states the tool retrieves current press releases from BAK, specifies data source (RSS feed), and lists covered topics (culture prizes, cultural policy, etc.). Distinguishes from sibling tools that focus on ISOS, traditions, or open data.
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?
Implies usage for general BAK news, and sibling names suggest other specialized data (e.g., kulturpreise, isos). No explicit when-not-to-use or alternatives, but context is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
bak_get_opendataARead-onlyIdempotent
Listet Open-Data-DatensΓ€tze des Bundesamts fΓΌr Kultur auf opendata.swiss auf.
Gibt Metadaten zu BAK-DatensΓ€tzen zurΓΌck, inkl. verfΓΌgbare Formate (WMS, WFS, API, HTML) und Download-URLs. Relevant fΓΌr GIS-Integration, Datenanalysen und weiterfΓΌhrende Auswertungen.
Args: params (OpendataInput): Parameter mit: - query (str, optional): Suchbegriff fΓΌr DatensΓ€tze
Returns: str: JSON mit Datensatz-Metadaten, je mit: - name, title, beschreibung - formate: VerfΓΌgbare Dateiformate - ressourcen: URLs fΓΌr Direktzugriff - organisation: BAK
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint and idempotentHint, confirming safe read behavior. The description adds that it returns metadata with formats and download URLs, providing more detail than annotations alone.
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 well-structured with 'Args' and 'Returns' sections, front-loading the main purpose. It is concise but could be slightly shorter without losing clarity.
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?
Given the output schema exists, the description still provides a clear return structure and use cases. It covers purpose, parameters, and return format comprehensively for a read-only query 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?
The parameter 'query' is documented in both the schema and the description with a clear description. The description outlines the return structure, adding value beyond the schema, though schema coverage is actually good.
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 clearly states it lists open data datasets from the Federal Office of Culture on opendata.swiss, including metadata and download URLs. This distinguishes it from sibling tools that focus on ISOS or other categories.
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 mentions relevance for GIS integration and data analysis, implying usage context but does not explicitly state when to use or not use this tool versus alternatives. No exclusions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
bak_get_tradition_detailARead-onlyIdempotent
Ruft die Detailbeschreibung einer lebendigen Tradition vom BAK-Inventar ab.
Holt die offizielle Beschreibung einer Tradition von lebendige-traditionen.ch. Den Slug erhΓ€lt man aus bak_list_traditions oder als bekannte Kurzbezeichnung.
Bekannte Slugs (Auswahl):
'fasnacht-basel' β Basler Fasnacht
'schwingen' β Schwingen
'alphorn--und-buechelspiel' β Alphorn- und BΓΌchelspiel
'sgrafitto' β Sgrafitto-Technik (GR)
'winzerfest-vevey' β FΓͺte des Vignerons
'appenzeller-silvesterklaus' β Appenzeller Silvesterklaus
Args: params (TraditionDetailInput): Parameter mit: - slug (str): URL-Slug der Tradition
Returns: str: JSON mit: - titel: Offizieller Name der Tradition - beschreibung: Volltext-Beschreibung - kantone_mention: Im Text erwΓ€hnte Kantone (heuristisch) - url: Direktlink zur BAK-Seite
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate idempotent, read-only, and non-destructive behavior. The description adds transparency by detailing the output fields (titel, beschreibung, kantone_mention, url) and the source of the data, which complements the annotations well.
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 structured into clear sections: action, source, slug retrieval, examples, and input/output. It is slightly verbose but every sentence adds value, and the structure aids readability.
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?
Given the simple interface (one parameter, with output schema) and the annotations, the description comprehensively covers what the tool does, how to use it, and what to expect in the response. No obvious gaps.
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 schema provides a description for the slug parameter, and the description supplements it with practical examples of known slugs, adding value beyond 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?
The description clearly states it fetches the detail description of a living tradition from the BAK inventory, specifies the source (lebendige-traditionen.ch), and distinguishes from siblings like bak_list_traditions by explaining how to obtain the slug.
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 explicitly mentions that the slug can be obtained from bak_list_traditions or as a known short name, guiding the user on when to use this tool. It does not explicitly state when not to use, but the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
bak_isos_by_kantonARead-onlyIdempotent
Listet alle ISOS-Ortsbilder eines Schweizer Kantons auf.
Gibt alle im Bundesinventar erfassten schΓΌtzenswerten Ortsbilder des angegebenen Kantons zurΓΌck. KantonskΓΌrzel-Format: ZH, BE, GR etc.
Args: params (IsosKantonInput): Parameter mit: - kanton (str): KantonskΓΌrzel (z.B. 'ZH', 'GR', 'VS') - limit (int): Maximale Anzahl (Standard: 50, max. 500)
Returns:
str: JSON mit ISOS-Objekten des Kantons, sortiert nach Name, mit:
- kanton_name: VollstΓ€ndiger Kantonsname
- count: Anzahl zurΓΌckgegebener Objekte (durch limit begrenzt)
- total_in_kanton: Ortsbilder des Kantons im Bundesinventar,
gezΓ€hlt nach ISOS-Nummer. Nicht nach Features: Die Quelle
liefert je Ortsbild mehrere, in GR bis zu 51.
- results: Liste mit feature_id, isos_nummer, name, siedlungskategorie
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds meaningful context: it explains that the count field counts ISOS numbers, not features, and highlights that a source can return multiple features per site (up to 51 in GR). This clarifies a potential misinterpretation, which is valuable beyond the annotations.
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 well-structured, front-loaded with the core purpose, and contains detailed but necessary information about parameters and return format. It uses clear German language with a logical flow from purpose, to parameters, to return values. No fluff.
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?
Given the tool's simplicity (1 parameter, annotated as read-only) and the existence of an output schema, the description is complete. It explains the counting nuance and the return structure, leaving nothing critical for an agent to infer. The notes about source behavior (multiple features per site) are essential for correct interpretation of results.
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 schema provides minimal descriptions for parameters, but the description compensates by detailing the 'kanton' format (uppercase, examples) and explaining the 'limit' parameter's default and maximum, as well as the implications of limiting. Given that schema description coverage is 0%, the description effectively covers the parameters.
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 clearly states the verb 'listet auf' (lists) and the resource 'ISOS-Ortsbilder eines Schweizer Kantons'. It provides the unique context of Swiss cantons and differentiates from siblings by focusing on canton-based listing. The scope is specific and unambiguous.
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 it lists all ISOS sites for a canton and specifies the input format ('ZH', 'BE', 'GR etc.'). Although it does not explicitly mention when not to use it, the tool's purpose is clearly stated, and sibling differentiation is implied by the tool's name and focused resource. The return format and limit behavior are also clearly explained.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
bak_isos_by_kategorieARead-onlyIdempotent
Filtert ISOS-Ortsbilder nach Siedlungskategorie (optional kombiniert mit Kanton).
ErmΓΆglicht die Suche nach spezifischen Siedlungstypen im ISOS-Inventar. Kategorien: 'Stadt', 'Kleinstadt/Flecken', 'Dorf', 'Weiler/Einzelsiedlung', 'Spezialfall'. Optional kann die Suche auf einen Kanton eingeschrΓ€nkt werden.
Args: params (IsosKategorieInput): Parameter mit: - kategorie (str): Siedlungskategorie - kanton (str, optional): KantonskΓΌrzel zur EinschrΓ€nkung - limit (int): Max. Resultate (Standard: 50)
Returns: str: JSON mit gefilterten ISOS-Objekten.
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds context about return format (JSON string) and parameter defaults (limit: 50). It is consistent and provides additional useful behavioral details beyond annotations.
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 concise with a clear structure: purpose sentence, explanation, then Args and Returns sections. 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.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the output schema exists (not shown), the description adequately covers input parameters and return format. It could provide more detail about the returned JSON structure, but with output schema this is acceptable.
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 description explains each parameter (kategorie, kanton, limit) with their meanings, defaults, and valid values for kategorie. The schema already has descriptions for some parameters, but the description adds clarity like default limit and optionality of kanton.
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 clearly states the tool filters ISOS townscapes by settlement category, optionally with canton. It lists the valid categories and distinguishes from siblings like bak_isos_by_kanton by focusing on category filtering.
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 implies usage context (filtering by category) but does not explicitly state when to use this tool versus alternatives like bak_isos_by_kanton or bak_search_isos. No when-not-to-use guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
bak_isos_statisticsARead-onlyIdempotent
Gibt Γbersichtsstatistiken zum ISOS-Bundesinventar zurΓΌck.
Zeigt Anzahl ISOS-Objekte pro Kanton sowie Informationen ΓΌber das Inventar. NΓΌtzlich fΓΌr einen schnellen Γberblick ΓΌber den Umfang des Bundesinventars der schΓΌtzenswerten Ortsbilder der Schweiz.
Returns: str: JSON mit: - total: GeschΓ€tzte Gesamtzahl ISOS-Objekte - per_kanton: Objekte pro Kanton (aus reprΓ€sentativer Stichprobe) - kategorien: Γberblick ΓΌber Siedlungskategorien - quellen: Informationen zu Datenquellen und weiterfΓΌhrenden Links
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the tool as read-only, idempotent, and non-destructive. The description adds valuable context: the returned counts are estimated and based on a representative sample, which informs the agent about data accuracy.
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 very concise: two short paragraphs. The first gives a clear purpose, and the second outlines the return structure. Every sentence is necessary and informative.
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 no parameters and good annotations, the description provides a complete picture of what the tool does and what it returns. The output structure is described in detail, covering the JSON keys and their meaning.
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 no parameters, so the schema has 100% coverage. The description adds no parameter information, but none is needed. Baseline of 4 is appropriate for zero-parameter tools.
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 clearly states it returns overview statistics of the ISOS inventory, with specific details like number of objects per canton. It is distinct from sibling tools such as bak_search_isos (search) and bak_isos_by_kanton (list by canton).
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 says it is useful for a quick overview of the inventory scope, implying when to use it. It does not explicitly mention when not to use it or list alternatives, but the context is clear given the sibling tool names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
bak_list_traditionsARead-onlyIdempotent
Listet lebendige Traditionen der Schweiz vom offiziellen BAK-Inventar auf.
Die Β«Liste der lebendigen Traditionen der SchweizΒ» umfasst 228 EintrΓ€ge (Stand 2023) des immateriellen Kulturerbes: BrΓ€uche, Feste, Handwerk, Musik, Sprache und weiteres. Optional nach Anfangsbuchstabe filtern.
Args: params (TraditionListInput): Parameter mit: - buchstabe (str, optional): Anfangsbuchstabe filtern (AβZ)
Returns: str: JSON mit Liste der Traditionen, je mit: - name: Bezeichnung der Tradition - slug: URL-Slug fΓΌr bak_get_tradition_detail - url: Direktlink zur BAK-Seite
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds context about the return format (JSON with name, slug, url) and the scope (228 entries). No contradictions.
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 well-structured with a main sentence, context, and clear Args/Returns sections. It is slightly verbose but front-loaded and efficient.
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?
Given the simple tool (1 parameter, read-only list), the description adequately explains the input and output. An output schema exists but is not shown; the description fills in the return structure.
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 single parameter buchstabe is described in the input schema, but the tool description repeats its purpose and adds context about filtering. The description adds value beyond 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?
The description clearly states it lists living traditions from the official BAK inventory, with details on content and optional filtering. It is distinct from sibling tools like bak_get_tradition_detail which retrieves a single tradition.
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 does not explicitly state when to use this tool versus alternatives, but the optional filter parameter implies it is for broad listing. No guidance on when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
bak_search_isosARead-onlyIdempotent
Sucht ISOS-Ortsbilder (Bundesinventar der schΓΌtzenswerten Ortsbilder der Schweiz) nach Ortsname.
Das ISOS ist das nationale Inventar bedeutender Ortsbilder der Schweiz. Es umfasst StΓ€dte, KleinstΓ€dte, DΓΆrfer und Weiler von nationaler Bedeutung. Die Daten stammen vom Bundesamt fΓΌr Kultur (BAK) und werden via geo.admin.ch bereitgestellt.
Args: params (IsosSearchInput): Suchparameter mit: - query (str): Ortsname oder Teilname - limit (int): Maximale Anzahl Resultate (Standard: 20)
Returns: str: JSON mit Liste der gefundenen ISOS-Objekte, je mit: - feature_id: ID fΓΌr bak_get_isos_detail - isos_nummer: ISOS-Inventarnummer - name: Ortsname - kantone: Liste der KantonskΓΌrzel - siedlungskategorie: Stadt/Dorf/etc. - gisos_url: Link zur GISOS-Detailseite des BAK
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint, idempotentHint, and destructiveHint=false. The description adds behavioral context by explaining the search operation, data source (BAK via geo.admin.ch), and return format. It does not contradict annotations and provides sufficient transparency for a safe read-only query.
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 well-structured with a clear introduction, background context, and formatted Args/Returns sections. It is slightly verbose (e.g., the ISOS background), but every part serves a purpose. The front-loading of the main purpose is effective.
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?
Given the presence of an output schema, the description does not need to explain return values exhaustively, but it does list key fields. The tool's input and output are well-covered. However, it lacks comparison with siblings and could mention query constraints (e.g., minimum length, which is in schema but not in description).
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 description lists both parameters (query and limit) with their types and meanings, adding a default value for limit (20) and an example query value. While the schema also provides descriptions, the tool description's structured 'Args' section adds clarity and compensates for the 0% schema coverage signal.
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 clearly states that the tool searches for ISOS townscapes by place name. It specifies the resource (ISOS-Ortsbilder) and the action (search). Compared to siblings like 'bak_isos_by_kanton' (filter by canton) and 'bak_get_isos_detail' (get detail), this tool's purpose of searching by name is distinct and well-defined.
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 does not provide any guidance on when to use this tool versus alternatives. It neither mentions conditions for use nor advises when to use other tools like 'bak_isos_by_kanton' for canton-based filtering. The user must infer usage context from the tool's name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
10 tool updates
v1.1.3- First observed
bak_get_isos_detail - First observed
bak_get_kulturpreise - First observed
bak_get_news - First observed
bak_get_opendata - First observed
bak_get_tradition_detail - First observed
bak_isos_by_kanton - First observed
bak_isos_by_kategorie - First observed
bak_isos_statistics - First observed
bak_list_traditions - First observed
bak_search_isos
TDQS
Scored across 10 tools
The ISOS-related tools are mostly distinct: search by name, list by canton, filter by category, get detail by ID, and statistics each have clear roles. The main ambiguity is between bak_isos_by_kanton and bak_isos_by_kategorie, which are structurally similar but differ by filter dimension; descriptions clarify this.
Most tools follow a bak_<verb>_<domain> pattern, e.g. bak_search_isos, bak_get_isos_detail, bak_list_traditions. However, bak_isos_statistics, bak_isos_by_kanton, and bak_isos_by_kategorie drop the leading verb, making the pattern inconsistent across the set.
Ten tools is a well-scoped size for a Swiss culture/Bundesamt fΓΌr Kultur data server. The count covers the main ISOS inventory workflows, traditions list/detail, news, prizes, and open data without unnecessary bloat.
For a read-only cultural data server, the surface is largely complete: ISOS search, filtering, detail, and statistics are covered, along with traditions list/detail and related BAK information. Minor gaps exist, such as no keyword search across traditions and no direct lookup by ISOS number, but these are not likely to cause major agent failures.
Maintenance
Related MCP Connectors
opendata.swiss MCP β Switzerland's federal open-data portal (CKAN catalogue).
simap MCP β Swiss public procurement tenders and awards (keyless).
Hosted MCP server for finding authoritative primary data sources and official portals.
MCP server for Brazilian Federal Senate open data (legislative, administrative, e-Cidadania).
Related MCP Servers
- AlicenseAqualityDmaintenanceSwiss open data MCP server β transport, weather, geodata, companies, etc,. Zero API keys.76275 npm22MIT
- AlicenseAqualityAmaintenanceEnables AI-native access to Swiss cultural heritage data from SIK-ISEA (artists), Nationalmuseum (collections), and Nationalbibliothek (bibliography) via MCP tools, without authentication.11MIT
- AlicenseAqualityBmaintenanceMCP server for Swiss federal geodata -- maps, elevation, geocoding, cadastral extracts, and downloadable datasets via Swisstopo APIs.2028 PyPI9MIT
- AlicenseAqualityDmaintenanceAn unofficial MCP server for accessing Swiss Federal Statistical Office (BFS) data.81MIT