wsl-envidat-mcp
The WSL EnviDat MCP server provides read-only access to Swiss environmental research data (forests, snow, avalanches, natural hazards, biodiversity) via EnviDat's CKAN API β no API key required. It covers 815+ open datasets with time series going back to 1890.
Search & Discovery
Search the catalog by keyword, research domain (
forest,biodiversity,natural hazards,snow/ice,landscape), organization, or geographic bounding boxBrowse tags/keywords to discover effective search terms
Get catalog statistics β domain coverage, organizations, and dataset counts
Find recently updated datasets for monitoring workflows
Dataset Access
Retrieve full dataset metadata (DOI, authors, license, download URLs) by ID or slug
Access curated thematic data:
Avalanche & snow data (SLF): fatal accident records since 1936/37, long-term snow series
Forest data: National Forest Inventory (LFI), Sanasilva monitoring, bark beetle data
Natural hazards: landslides, rockfall, debris flows, floods
Organizations
List WSL research units with dataset counts
Get organization details including description, contact info, and associated datasets
Key Characteristics
All tools are read-only (no data modification)
Results available in Markdown or JSON format
Compatible with Claude Desktop, GPT-4, and any MCP-enabled client
Supports local (
stdio) and cloud (streamable-http) deployment with pre-built Docker images
Click on "Install 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., "@wsl-envidat-mcpSearch for forest inventory data in the canton of Zurich"
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
wsl-envidat-mcp π²βοΈβ°οΈ
MCP server connecting AI models to Swiss environmental research data from WSL via EnviDat β forest, snow, avalanches, natural hazards and biodiversity, no API key required.
Phase
This server is in Phase 1: Read-only Wrapper.
Property | Status |
Read tools | β
10 tools, all |
Write tools | β none (EnviDat is read-only public data) |
Semantic Layer | β οΈ partial β three domain tools curate Solr queries |
OAuth / Auth Gateway | β not required (Public Open Data, no API key) |
Container hardening | β multi-stage Dockerfile, non-root |
Test suite | β 38 offline unit tests + 31 live integration tests |
Audit run | β 2026-05-27 (mcp-audit-skill v1.0.0) |
Phase-2 ideas (caching layer, semantic aggregation tool combining forest +
snow + hazard data into a "Lage-Γbersicht"): tracked under docs/.
Related MCP server: swisstopo-mcp
Overview
The WSL (EidgenΓΆssische Forschungsanstalt fΓΌr Wald, Schnee und Landschaft / Swiss Federal Research Institute for Forest, Snow and Landscape) is one of Europe's leading environmental research institutes. Its open data platform EnviDat provides access to 1,000+ research datasets, time series of up to 130 years, and data from 6,000+ monitoring stations.
This MCP server exposes the EnviDat CKAN API as 10 tools and 2 resources, enabling AI assistants to search, filter and retrieve WSL research data by keyword, domain, or geographic bounding box β all without an API key.
Anchor demo query: "How was air quality and forest health around Schulhaus Leutschenbach in Zurich β and what does the WSL say about the current forest condition in the canton?"
Demo
Features
10 tools covering full-text search, domain-specific queries, spatial search, and curated thematic tools (avalanche, forest, natural hazards)
2 MCP resources for organizations and research domains
5 research domains: Forest Β· Biodiversity Β· Natural Hazards Β· Snow & Ice Β· Landscape
815+ datasets, time series since 1890, data from the SLF avalanche research institute
No API key required β all data publicly accessible via open licenses
Dual transport: stdio (Claude Desktop / local) + Streamable HTTP (cloud deployment)
Model-agnostic: works with Claude, GPT-4, and any MCP-compatible client
Prerequisites
Python 3.11+
piporuv/uvxInternet connection (live API calls to envidat.ch)
Installation
# Recommended: uvx (no installation needed)
uvx wsl-envidat-mcp
# Or with pip
pip install wsl-envidat-mcp
# Development
git clone https://github.com/malkreide/wsl-envidat-mcp.git
cd wsl-envidat-mcp
pip install -e ".[dev]"Quickstart
Claude Desktop
Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"wsl-envidat": {
"command": "uvx",
"args": ["wsl-envidat-mcp"]
}
}
}Restart Claude Desktop, then ask:
"What WSL datasets exist on fatal avalanche accidents in Switzerland?"
"Show me forest inventory data from the LFI for the canton of Zurich."
"Which natural hazard research data does the SLF publish on EnviDat?"
"Are there WSL datasets on drought conditions in summer 2022?"
"What biodiversity data is available for alpine ecosystems?"
Configuration
No API key required. Optional environment variables:
Variable | Default | Description |
|
| Transport mode: |
|
| Bind address for |
|
| Port for Streamable HTTP mode |
Cloud Deployment (Streamable HTTP)
For use via claude.ai in the browser (e.g. on managed workstations without local software):
# Local: keep MCP_HOST at its default 127.0.0.1
MCP_TRANSPORT=streamable-http PORT=8000 python -m wsl_envidat_mcp.server
# Container: bind to all interfaces inside the container only
MCP_TRANSPORT=streamable-http MCP_HOST=0.0.0.0 PORT=8000 python -m wsl_envidat_mcp.serverπ‘ "stdio for the developer laptop, streamable-http for the browser."
β οΈ Multi-Replica Cloud Deployments: Session state lives in the server. Run a single replica or enable sticky sessions (Railway/Render setting, or
sessionAffinity: ClientIPon Kubernetes Services).
β οΈ Multi-Tenant / Unauthenticated Streamable HTTP: This server has no auth layer (
auth_model: none). Streamable HTTP without a reverse-proxy + OAuth/API-Gateway is intended only for single-user deployments (e.g. one user's claude.ai browser session). For multi-tenant use, front the server with an authenticating gateway.
Container image (recommended for cloud)
A hardened multi-stage image is published to GitHub Container Registry on
every main push and semver tag. Runs as non-root (uid=1000), no build
tools in the runtime layer, multi-arch (linux/amd64 + linux/arm64).
The publishing workflow is .github/workflows/container.yml β
not publish.yml, which only uploads the Python package to PyPI on a
release. container.yml is delivery, not a gate: it does not gate a pull
request, and a red run there means the image is missing, not that the code
is broken.
docker run --rm -p 8000:8000 \
--read-only --tmpfs /tmp \
--cap-drop=ALL --security-opt=no-new-privileges \
ghcr.io/malkreide/wsl-envidat-mcp:latestKubernetes hardening (excerpt):
securityContext:
runAsNonRoot: true
runAsUser: 1000
readOnlyRootFilesystem: true
allowPrivilegeEscalation: false
capabilities: { drop: ["ALL"] }Available Tools
Tool | Description |
| Unified search β combine |
| Full metadata, DOI, download URLs for a specific dataset |
| List all WSL research units on EnviDat |
| Details of a specific research unit incl. datasets |
| Browse available tags/keywords |
| Most recently updated datasets |
| SLF avalanche & snow data (incl. fatal accidents since 1936) |
| Forest data incl. National Forest Inventory (LFI) & Sanasilva |
| Natural hazard datasets (landslides, rockfall, floods) |
| Catalog overview and statistics |
Example Use Cases
Query | Tool |
"Fatal avalanche accidents in Valais since 2000?" |
|
"Forest health data for canton Zurich?" |
|
"Landslide risk datasets near Brienz?" |
|
"Most recent WSL publications on biodiversity?" |
|
"Which datasets cover the area around Lake Constance?" |
|
"How many datasets does SLF publish?" |
|
Resources
URI | Description |
| Research unit (e.g. |
| Domain overview with top datasets |
Valid domain values: wald, biodiversitaet, naturgefahren, schnee_eis, landschaft
Architecture
βββββββββββββββββββ βββββββββββββββββββββββββββββ ββββββββββββββββββββββββββββ
β Claude / AI ββββββΆβ WSL EnviDat MCP ββββββΆβ envidat.ch β
β (MCP Host) βββββββ (MCP Server) βββββββ β
βββββββββββββββββββ β β β CKAN API (REST/JSON) β
β 10 Tools Β· 2 Resources β β Solr full-text search β
β Stdio | Streamable HTTP β β 1,000+ research datasetsβ
β β β 815+ open datasets β
β server.py β β Time series since 1890 β
β api_client.py β ββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββInfrastructure Components
Component | Metaphor | Function |
| Librarian | Handles all HTTP requests to EnviDat CKAN API |
| Reception desk | Registers all 10 tools and 2 resources with FastMCP |
Domain filters | Filing cabinet | Pre-configured keyword sets per research domain |
Bounding box search | Map overlay | Spatial filtering via lat/lon coordinates |
Project Structure
wsl-envidat-mcp/
βββ src/wsl_envidat_mcp/
β βββ __init__.py # Package
β βββ server.py # MCP server β 10 tools, 2 resources
β βββ api_client.py # HTTP client for EnviDat CKAN API
βββ tests/
β βββ test_integration.py # 11 live API integration tests
βββ .github/workflows/
β βββ ci.yml # Gates: lint, format, syntax, import, tests, version sync
β βββ live.yml # Scheduled live tests against envidat.ch (cron 05:47 UTC)
β βββ container.yml # Builds & pushes the ghcr.io image (delivery, not a gate)
β βββ publish.yml # Uploads the Python package to PyPI on a release
βββ pyproject.toml # Project config (hatchling build backend)
βββ 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 # MIT
βββ README.md # This file (English)
βββ README.de.md # German versionCombination with Other MCP Servers
This server is part of the Swiss Open Data MCP Portfolio and integrates well with:
Combination | Use Case |
+ | Urban climate + forest condition around Zurich |
+ | Population data + environmental quality |
+ | Avalanche risk + public transport connections |
+ | Forest protection law + actual LFI forest condition |
+ | Compare environmental education data internationally |
Known Limitations
Solr search:
ORis treated as a stopword β use single, specific search terms per queryDomain search: Results depend on WSL's internal keyword tagging β not all datasets are tagged consistently
Spatial search: Bounding box filtering is approximate; verify coordinates with individual dataset metadata
Live API: All tools make live calls to envidat.ch β results depend on availability of the public API
Languages: Dataset metadata is primarily in English and German; some older entries may be in German only
Safety & Limits
Read-only: All tools perform HTTP GET requests only β no data is written, modified, or deleted on EnviDat.
No personal data: The API returns research metadata, dataset descriptions, and download URLs. No personally identifiable information (PII) is processed or stored by this server.
Rate limits: The EnviDat CKAN API is public without documented rate limits. Use
limitandrowsparameters conservatively. The server enforces a 30-second timeout per request.Data freshness: All tools make live API calls β results reflect the current state of the EnviDat catalog at query time. No caching is performed by this server.
Terms of service: Data is subject to the EnviDat Terms of Use. Individual datasets are published under various open licenses (Creative Commons, CC0) β see dataset metadata.
No guarantees: This is a community project, not affiliated with WSL or EnviDat. Availability depends on the upstream EnviDat API.
For the full security posture (egress allow-list, redirect handling, accepted risks) see SECURITY.md.
MCP 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. This server builds no ASGI app to send an initialize through, so
the gate asserts the SDK constants rather than a measured response β the
weaker form, named rather than left unsaid.
SUPPORTED_MCP_PROTOCOL_VERSION in
server.py names the modern era; a
mismatch against the SDK logs a warning at startup. A warning is not a gate β
that is what the test file is for.
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.
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 β offline, no network access, all CKAN responses mocked via respx
PYTHONPATH=src pytest -m "not live"
# Live integration tests β actual HTTP calls to envidat.ch
PYTHONPATH=src pytest -m live
# Linting
ruff check src/
ruff format --check src/CI runs the offline suite on every PR. The live suite runs only on main
pushes and manual workflow_dispatch triggers, so build status is not
coupled to upstream availability.
Changelog
See CHANGELOG.md
Contributing
See CONTRIBUTING.md
Security
See SECURITY.md (Deutsch) for the security posture and how to report a vulnerability.
License
MIT License β see LICENSE
Data on EnviDat is published under various open licenses (Creative Commons, CC0) β see individual dataset metadata.
Author
Hayal Oezkan Β· malkreide
Credits & Related Projects
Data: EnviDat β WSL Swiss Federal Research Institute for Forest, Snow and Landscape
Protocol: Model Context Protocol β Anthropic / Linux Foundation
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": {
"wsl-envidat-mcp": {
"command": "uvx",
"args": [
"wsl-envidat-mcp"
]
}
}
}Available Tools
10 toolswsl_catalog_statsARead-onlyIdempotent
Gibt eine Γbersicht ΓΌber den EnviDat-Katalog zurΓΌck: DomΓ€nen, Organisationen, Datenmenge.
NΓΌtzlich als Einstiegspunkt: zeigt was im Katalog verfΓΌgbar ist, welche WSL-ForschungsdomΓ€nen besonders viele DatensΓ€tze haben, und wie der Katalog strukturiert ist.
Returns: str: Statistiken und Struktur des EnviDat-Katalogs
| 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 indicate the tool is read-only, non-destructive, and idempotent. The description adds that it returns a string of statistics, but provides no further behavioral details beyond what annotations convey, so the description adds moderate value.
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 short and front-loaded with the core purpose. However, it includes both German and English text, which is slightly redundant. Each sentence earns its place, but could be made more concise by using one language.
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 has no parameters, an output schema, and low complexity, the description fully covers what the tool does, what it returns (a string of statistics), and its use case. No additional information is needed.
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 description does not need to add parameter details. The baseline for zero-parameter tools is 4, and the description clearly explains what the tool returns, which is sufficient.
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 returns an overview of the EnviDat catalog, listing domains, organizations, and data volume. It is explicitly described as an entry point, distinguishing it from sibling tools that focus on specific data types 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 notes the tool is useful as an entry point to see what's available and how the catalog is structured, implying it should be used before more specific queries. However, it does not explicitly mention when not to use it or provide alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
wsl_get_avalanche_dataARead-onlyIdempotent
Lawinen- und Schneedaten vom WSL-Institut fuer Schnee- und Lawinenforschung (SLF).
EnthΓ€lt u.a.:
TΓΆdliche LawinenunfΓ€lle in der Schweiz seit 1936/37
LangjΓ€hrige Schneemessreihen (Station Stillberg Davos, 2090 m)
Meteorologische Langzeitdaten Hochgebirge
Schneephysik-Forschungsdaten
Args: params (SimpleQueryInput): Anzahl Ergebnisse und Format
Returns: str: Lawinen- und SchneedatensΓ€tze des SLF
| 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 mark it as read-only and safe. Description adds value by listing the specific data types included, providing context 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?
Bullet list and args/returns section are efficient, but there is some redundancy with the title. Overall good structure.
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 data types and content well. Output schema exists, so missing return structure details are compensated.
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%, description only says 'Anzahl Ergebnisse und Format' which is minimal. Does not explain limit range or response_format options.
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 it retrieves avalanche and snow data from SLF, listing specific contents. It distinguishes itself from siblings like wsl_get_forest_data by topic.
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?
Implied usage for avalanche/snow data, but no explicit guidance on when to use versus alternatives or 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.
wsl_get_datasetARead-onlyIdempotent
Gibt vollstΓ€ndige Metadaten und Ressourcen (Download-URLs) eines EnviDat-Datensatzes zurΓΌck.
Detail-Ansicht eines konkreten Datensatzes mit DOI, Lizenz, Autoren, Download-Links und rΓ€umlicher Ausdehnung. Folge-Schritt nach wsl_search.
id_or_slug ist entweder die UUID oder der URL-Slug aus dem Suchergebnis (Feld 'name'). Liefert auch nicht-ΓΆffentliche Resource-Metadaten wenn vorhanden.
id_or_slug='fatal-avalanche-accidents-in-switzerland-since-1936-37' β vollstΓ€ndige Lawinen-Datenbankbeschreibung mit CSV-Download-Link.
| 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 value by noting that it returns non-public resource metadata if present, which is an important behavioral detail 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 concise with a clear structure: a main sentence, followed by use_case, important_notes, and example sections. Every sentence adds value without 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 tool has an output schema and the description explains the return type (metadata and resources including download URLs) and includes an example, the description is complete for an agent to understand what the tool does and what it returns.
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?
Although the schema description coverage is reported as 0%, the schema actually includes descriptions for both parameters. The tool description adds context by linking id_or_slug to search results and providing an example, which enhances understanding beyond the schema alone.
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 complete metadata and resources of an EnviDat dataset, specifies the use case as a detail view after search, and lists outputs like DOI, license, authors, and download links. It distinguishes itself from sibling tools like wsl_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?
Explicitly states it's a follow-up step after wsl_search and provides important notes on how to obtain the id_or_slug parameter from search results (field 'name') and that it returns non-public resource metadata if available, giving clear when-to-use and how-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
wsl_get_forest_dataARead-onlyIdempotent
Gibt DatensΓ€tze zum Schweizer Wald zurΓΌck, inkl. Landesforstinventar LFI.
EnthΓ€lt u.a.:
Schweizerisches Landesforstinventar (LFI) β Waldzustand, VorrΓ€te, BiodiversitΓ€t
Sanasilva-Programm (Waldschadensmonitoring seit 1983)
LangzeitforschungsflΓ€chen LWF
Walddynamik und Waldentwicklung seit 1840
BorkenkΓ€fer-Monitoring
BodenlΓΆsung und NΓ€hrstoffhaushalt im Wald
Args: params (SimpleQueryInput): Anzahl Ergebnisse und Format
Returns: str: WalddatensΓ€tze der WSL
| 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. The description adds value by listing specific data sources and monitoring programs, giving behavioral context beyond safety flags.
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 concise but includes a bullet list of specific datasets. It is front-loaded with the primary purpose but could be trimmed without losing critical 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?
Given the low complexity (1 parameter) and presence of an output schema, the description provides a good overview of the data domains covered, helping the agent decide relevance.
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%, and the description only restates the parameter name and basic purpose ('Anzahl Ergebnisse und Format') with no additional semantics. The enum values and constraints in the schema are not explained in the description.
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 returns Swiss forest data and enumerates specific datasets (e.g., Landesforstinventar, Sanasilva). The name and sibling tools (e.g., wsl_get_avalanche_data) make the domain 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?
No explicit when-to-use or alternative guidance. However, the tool name and sibling list imply it is for forest-related queries, providing implicit context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
wsl_get_naturgefahren_dataARead-onlyIdempotent
Gibt DatensΓ€tze zu Naturgefahren in der Schweiz zurΓΌck.
EnthΓ€lt u.a.:
TΓΆdliche LawinenunfΓ€lle seit 1936/37
Murgang- und Rutschungsereignisse
Steinschlag- und Felssturzdaten
Schwemmkegel-Morphologie
Sedimenttransport in GebirgsbΓ€chen
Hochwasserereignisse
Relevant fΓΌr: Raumplanung, Schulhausstandort-Bewertungen, Katastrophenschutz, KlimafolgenabschΓ€tzung.
Args: params (SimpleQueryInput): Anzahl Ergebnisse und Format
Returns: str: Naturgefahren-DatensΓ€tze der WSL
| 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=true, destructiveHint=false, idempotentHint=true, openWorldHint=true. The description adds no behavioral context beyond stating it returns data, which is already obvious from the purpose. No contradiction, but no additional value.
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 opening sentence, bullet lists for content, and separate usage notes. It is not overly long and each section adds value. However, the usage guidelines could be integrated more concisely.
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 (so return values need not be detailed), the description adequately covers purpose, parameter semantics, and application context. It does not mention pagination or data limits, but for a single-parameter query tool, 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?
The description explains that the 'params' parameter controls 'Anzahl Ergebnisse und Format' (number of results and format), which adds meaning beyond the schema (which only has a generic description for SimpleQueryInput). However, it does not detail constraints like the maximum limit of 20, so compensation is partial.
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 returns datasets on natural hazards in Switzerland, listing specific types (avalanches, landslides, etc.). It distinguishes from more specific siblings like wsl_get_avalanche_data by covering multiple hazard types. However, it could be more precise about the exact nature of the returned data (e.g., events with date/location).
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 usage context by listing relevant applications (Raumplanung, Katastrophenschutz, etc.), which helps the agent decide when to use it. However, it does not explicitly state when not to use it or compare with specific sibling tools for disambiguation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
wsl_get_organizationARead-onlyIdempotent
Gibt Details einer WSL-Forschungseinheit inklusive ihrer DatensΓ€tze zurΓΌck.
Liefert Beschreibung, Kontakt und Datensatz-Γbersicht einer Organisation. Das SLF (Institut fΓΌr Schnee- und Lawinenforschung) ist als 'slf' abrufbar.
Args: params (GetOrganizationInput): Mit: - name (str): Organisations-Slug (z.B. 'wsl', 'slf') - include_datasets (bool): DatensΓ€tze mitausgeben
Returns: str: Organisation-Details mit optionaler Datensatz-Liste
| 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, destructiveHint=false, and idempotentHint=true, already clarifying the operation is safe. The description adds value by specifying the returned content (description, contact, dataset overview) and providing an example, which enriches understanding beyond the annotation's simple 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a purpose sentence, what it provides, an example, and parameter explanations. It is slightly verbose but each sentence adds value, and the docstring format 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 output schema exists, the description need not detail return values. It covers purpose, parameters, and an example. However, it does not mention any error conditions (e.g., invalid slug) or specify the output format, nor does it reference siblings. Slightly more completeness would be ideal.
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?
Although schema description coverage is 0% at the top level, the description explicitly lists and explains both parameters (name and include_datasets) with examples and clear German labels, compensating for the lack of inline schema descriptions. The docstring format adds clarity 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 returns details of a WSL research unit including its datasets, with specific verb 'gibt ... zurΓΌck' and resource 'Forschungseinheit'. It distinguishes from sibling tools like wsl_list_organizations by focusing on details of a single organization, and provides a concrete example ('slf').
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 use when needing details of a specific organization via slug, but does not explicitly state when to use this versus alternatives like wsl_list_organizations for listing all organizations or wsl_get_dataset for a single dataset. No when-not or direct comparisons to siblings are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
wsl_get_recent_datasetsARead-only
Gibt die zuletzt publizierten oder aktualisierten EnviDat-DatensΓ€tze zurΓΌck.
NΓΌtzlich fΓΌr regelmΓ€ssige Monitoring-Workflows und um neue WSL-Forschungsdaten zu entdecken.
Args: params (GetRecentDatasetsInput): Mit limit und response_format
Returns: str: Zuletzt aktualisierte DatensΓ€tze
| 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, so the description's claim of returning data is consistent. It adds no additional behavioral details beyond the annotations, which is acceptable given the annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short and front-loaded with the main purpose. The additional 'Args' and 'Returns' sections provide structure, though some words are unnecessary. No wasted sentences.
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) and presence of an output schema, the description could be more complete about the return format. It only says 'string of recent datasets' without details on structure or fields, leaving gaps for the agent.
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 0% schema description coverage, the description should provide meaningful parameter details. It only lists 'limit' and 'response_format' without explaining their purpose (e.g., limit controls count, response_format chooses output type). This adds minimal value beyond the schema names.
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 the most recently published or updated EnviDat datasets, which is a specific verb+resource. Sibling tools like wsl_get_dataset focus on a single dataset, making this distinct.
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 says it's useful for regular monitoring workflows and discovering new research data, providing context for use. However, it does not mention when not to use or alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
wsl_list_organizationsARead-onlyIdempotent
Listet alle WSL-Forschungseinheiten und deren Datensatz-Anzahl auf.
Gibt einen Γberblick ΓΌber die Forschungsgruppen der WSL, die Daten auf EnviDat publiziert haben. NΓΌtzlich zur Identifikation relevanter Organisationen fΓΌr nachfolgende Abfragen mit wsl_get_organization.
Returns: str: Liste aller WSL-Forschungseinheiten mit Slug und Datensatz-Anzahl
| 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 declare readOnlyHint and idempotentHint, indicating safe, non-destructive behavior. The description adds value by specifying the return format (slug and dataset count) and the return type (str), complementing 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 concise and front-loaded with the main action. The returns line partially repeats the purpose, but overall it is efficient and well-structured.
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 detail return values. It covers the purpose, use case, and output summary completely, making it fully informative for the tool's complexity.
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 input schema has no parameters, so schema description coverage is 100%. The description adds meaning by explaining the return value and use case, which suffices for a parameterless tool.
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 lists all WSL research units with their dataset count, and explicitly differentiates from the sibling tool wsl_get_organization by positioning it as a preliminary overview for identifying relevant organizations.
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 explicit usage guidance by stating it is useful for identifying relevant organizations for subsequent queries with wsl_get_organization. It does not mention when not to use it, 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.
wsl_list_tagsARead-onlyIdempotent
Listet verfΓΌgbare SchlagwΓΆrter (Tags) im EnviDat-Katalog auf.
NΓΌtzlich um herauszufinden, welche Suchbegriffe in wsl_search prΓ€zise Ergebnisse liefern. UnterstΓΌtzt PrΓ€fix-Suche.
Args: params (ListTagsInput): Mit: - query (str): Optionaler Suchbegriff fΓΌr Tags - limit (int): Maximale Anzahl Tags
Returns: str: Liste verfΓΌgbarer Tags/SchlagwΓΆrter
| 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=true and idempotentHint=true, so the description only adds that it supports prefix search. No contradictions with 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 and well-structured, with a brief purpose statement, usage hint, and parameter/return documentation. It could be slightly more compact but 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 simple input schema and the presence of an output schema, the description fully covers what the tool does, when to use it, and what parameters are needed. No gaps remain.
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 the function of each parameter (query and limit) beyond what the schema provides, compensating for the 0% schema description coverage. It adds clarity on usage and constraints.
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 lists tags in the EnviDat catalog, using a specific verb and resource. It is distinct from sibling tools like wsl_search, which searches for datasets, not tags.
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 it is useful for finding search terms to use in wsl_search, providing clear usage context. However, it does not specify when not to use it or mention alternatives beyond wsl_search.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
wsl_searchARead-onlyIdempotent
Unifizierte Suche im EnviDat-Katalog der WSL (Eidg. Forschungsanstalt fΓΌr Wald, Schnee und Landschaft). Kombiniert frei wΓ€hlbar Stichwort, kuratierte ForschungsdomΓ€ne, Organisation und Bounding-Box.
Schweizer Umweltforschung, Schulhaus-Umgebungsanalysen, Klimafolgen-Recherche, kantonale Umweltberichte, Lawinendaten, Waldzustand, BiodiversitΓ€t, Naturgefahren.
Mindestens einer der Filter (query/domain/organization/bbox) muss gesetzt sein. Solr-Syntax ist mΓΆglich, 'OR' ist aber Stopwort. Bei leerem Resultat liefert das Tool verwandte Tags als Vorschlag.
query='snow avalanche' β SLF-Lawinendaten. domain='wald' β kuratierte LFI-/Sanasilva-Suche. bbox=[8.35,47.15,8.98,47.72] β Kanton ZΓΌrich. query='forest', organization='wsl' β WSL-WalddatensΓ€tze.
| 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 the tool read-only, non-destructive, idempotent, and open-world. The description adds valuable behavioral context: empty results return related tags as suggestions, and 'OR' is a stop word in Solr syntax. No contradiction with 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 with separate sections for use case, important notes, and example. Every sentence is informative, no fluff, and front-loaded with the core purpose. Excellent balance of detail and brevity.
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 covers purpose, usage guidelines, behavioral traits, constraints, and examples. It mentions empty result fallback and response format options. However, it does not describe the structure of returned results (e.g., fields in output), which would be helpful for an agent. Given the schema covers input well and annotations provide safety, it's still quite 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?
The input schema itself contains detailed descriptions for all subfields (query, domain, organization, bbox, limit, offset, response_format), providing high coverage. The tool description only gives a high-level summary of the filters, adding minimal extra value beyond the schema. The constraint that at least one filter must be set is already in 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 performs a unified search in the WSL EnviDat catalog, combining keyword, curated research domain, organization, and bounding box. It distinguishes from sibling tools by being the general search across all EnviDat, while siblings like wsl_get_avalanche_data are more specific.
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 includes a <use_case> section listing specific scenarios (e.g., Swiss environmental research, climate impact research) and <important_notes> requiring at least one filter and explaining Solr syntax and empty result behavior. However, it does not explicitly state when to use this tool versus the more specific sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Several thematic tools (wsl_get_avalanche_data, wsl_get_naturgefahren_data, wsl_get_forest_data) overlap significantly, as avalanche data is also part of natural hazards. Additionally, wsl_search can replicate these queries, creating multiple ambiguous paths to similar data.
Most names follow a clear verb_noun pattern (get_*, list_*, search). However, 'wsl_catalog_stats' breaks the pattern (noun_noun), and there is a mix of English verbs with German nouns (e.g., 'get_naturgefahren_data'), which is a minor inconsistency.
With 10 tools, the server is well-scoped for a data catalog. It covers catalog overview, thematic queries, search, metadata retrieval, and organization listingβno unnecessary bloat or insufficiency.
The tool surface covers core read operations: search, metadata retrieval, organization listing, and thematic filters. Minor gaps exist (e.g., no explicit biodiversity query), but these are covered by the flexible search tool, making it functionally complete.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
opendata.swiss MCP β Switzerland's federal open-data portal (CKAN catalogue).
This MCP server provides seamless access to Malaysia's government open data, including datasets, wβ¦
MCP server for Brazilian Federal Senate open data (legislative, administrative, e-Cidadania).
Hosted MCP server for finding authoritative primary data sources and official portals.
Related MCP Servers
- AlicenseAqualityDmaintenanceSwiss open data MCP server β transport, weather, geodata, companies, etc,. Zero API keys.7622722MIT
- AlicenseAqualityBmaintenanceMCP server for Swiss federal geodata -- maps, elevation, geocoding, cadastral extracts, and downloadable datasets via Swisstopo APIs.208MIT
- AlicenseAqualityAmaintenanceMCP server for Switzerland's national metadata catalogue, enabling AI agents to discover datasets, APIs, public services, and publishers through free-text search and structured queries.13MIT
- AlicenseNot gradedqualityAmaintenanceMCP server for querying MeteoSwiss open weather data, providing access to station data, forecasts, radar composites, and more via natural language.44MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/malkreide/wsl-envidat-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server