swiss-courts-mcp
This server provides read-only access to Swiss court decisions (federal and cantonal) with full-text search, structured filters, and an offline fallback โ no API key required.
Search all Swiss court decisions (
search_court_decisions): Full-text search across federal and all 26 cantonal courts, with filters for canton, court level, date range, and language (German, French, Italian). Returns up to 50 results.Retrieve a specific decision (
get_court_decision): Fetch detailed info using a decision's unique signature.Search Federal Supreme Court decisions (
search_bger_decisions): Targeted search within BGer/BGE rulings, with optional chamber filter.Find decisions citing a law article (
search_by_law_reference): Multi-stage search for case law referencing a legal norm (e.g., "Art. 8 BV", "Art. 328 OR", "Art. 25 DSG").List indexed courts (
list_courts): Browse all courts, optionally filtered by canton.Get recent decisions (
get_recent_decisions): Retrieve the latest decisions, filterable by canton and court level.Get decision statistics (
get_decision_statistics): Aggregated statistics on indexed decisions by canton and/or year.Check offline fallback status (
get_fallback_status): Inspect the offline dump cache state (coverage, version, pre-warming) for transparency when the live source is unreachable.
Offline fallback provides limited coverage (Federal Supreme Court only, metadata/regesten, 2007โ2024) when entscheidsuche.ch is unavailable; every response declares its origin (source: live | dump). Pairs well with fedlex-mcp for combined legislation + case law research.
Provides access to Swiss court decision metadata from the Zenodo SCD dump as an offline fallback when the primary source (entscheidsuche.ch) is unavailable.
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., "@swiss-courts-mcpSearch Swiss Federal Supreme Court decisions on data protection from 2023"
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-courts-mcp
MCP Server for Swiss court decisions โ Federal Supreme Court (BGer), Federal Administrative Court (BVGer), Federal Criminal Court (BStGer), and all 26 cantonal courts via entscheidsuche.ch
Overview
Access Swiss court decisions from all judicial levels through a single MCP interface. Combines full-text search with structured filters for canton, court level, date range, and law references.
๐ฏ Anchor demo query: "Find Federal Supreme Court case law on data protection (Art. 25 DSG) since 2020 โ and if entscheidsuche.ch is down, still answer from the offline dump, clearly flagged."
Source | Coverage | Data |
entscheidsuche.ch (live, default) | Federal + 26 cantons | Court decisions since ~2000 |
SCD dump (offline fallback) | Federal Supreme Court only, 2007โ2024 | Metadata/regesten, no full text |
Synergy with fedlex-mcp: Legislation (SR) + case law = complete legal research.
Availability: entscheidsuche.ch is non-profit infrastructure without an SLA. When it is unreachable, the server transparently falls back to a cached public dump (see Offline fallback). Every response declares its origin (source: "live" | "dump"), and dump answers carry a coverage_note โ the fallback is partial, not equivalent.
Related MCP server: Entscheidsuche MCP Server
Features
Full-text search across all Swiss court decisions
Multi-stage law reference search with regex parser and Elasticsearch boost scoring
Dedicated Federal Supreme Court search with chamber filter
Canton and court level filtering
Recent decisions feed
Court taxonomy listing
Decision statistics with aggregations
Trilingual support (German, French, Italian)
Offline fallback to a cached public dump when entscheidsuche.ch is unreachable โ with explicit provenance on every response
No API key required
Prerequisites
Python 3.11 or higher
An MCP-compatible client (Claude Desktop, Cursor, Windsurf, etc.)
Installation
pip install swiss-courts-mcpOr install from source:
git clone https://github.com/malkreide/swiss-courts-mcp.git
cd swiss-courts-mcp
pip install -e ".[dev]"Quickstart
# Run directly
swiss-courts-mcp
# Or via Python module
python -m swiss_courts_mcpConfiguration
Claude Desktop
Add to your claude_desktop_config.json:
{
"mcpServers": {
"swiss-courts": {
"command": "python",
"args": ["-m", "swiss_courts_mcp"]
}
}
}Cloud Deployment (HTTP transport)
The HTTP transport is off by default. The default bind host is 127.0.0.1
(loopback only) โ 0.0.0.0 must be opted into explicitly (the Dockerfile does
this). Running HTTP without authentication logs a warning; only do so behind an
authenticating reverse proxy.
# Local HTTP (loopback), no auth โ development only
swiss-courts-mcp --http --port 8000
# Container (binds 0.0.0.0, auth enabled) โ see Dockerfile
docker build -t swiss-courts-mcp .
docker run -p 8000:8000 -e MCP_AUTH_SECRET="$(openssl rand -hex 32)" swiss-courts-mcpRelevant environment variables (see .env.example):
Variable | Default | Purpose |
|
| Bind host. Set to |
|
| Bind port. |
|
| Suppress the |
|
| Stateless HTTP โ horizontal scaling without sticky sessions. |
|
| Enable bearer-token auth for HTTP. |
| โ | HS256 signing key (dev). |
| โ | JWKS URL for RS256 validation (production). |
| โ | Comma-separated required scopes. |
| โ | Comma-separated allowed origins (no wildcard in prod). |
Authentication validates the user identity from the JWT sub claim only; see
ADR 0001.
Offline fallback (env)
Variable | Default | Purpose |
|
| Master switch. |
|
| Force the dump path (skip live) โ for pre-warming the cache or offline testing. |
|
| Override the cache directory for the downloaded dump. |
|
| Zenodo record id of the SCD dump to use. |
Pre-warm the cache (downloads the ~120 MB SCD CSV once, so the first real outage does not pay the download cost):
SWISS_COURTS_FORCE_DUMP=1 python -m swiss_courts_mcp # then issue one searchMCP Protocol Version
This server pins MCP protocol version 2025-11-25 (constant
PROTOCOL_VERSION in server.py). A regression test detects drift against the
installed SDK so a protocol bump is a conscious change (version + CHANGELOG +
this section). SDK updates land monthly via Dependabot.
Project Phase
Phase 1 โ read-only (see ROADMAP.md). All tools are
readOnlyHint: true; there are no writing or destructive operations. A move to
Phase 2 (write) requires a clean re-audit and the gates listed in the roadmap.
Available Tools
Court Decision Search
Tool | Description |
| Full-text search across all court decisions with canton, court level, and date filters |
| Retrieve a single decision by its unique signature |
| Search Federal Supreme Court decisions with optional chamber filter |
| Find decisions citing a specific law article (e.g., "Art. 8 BV") |
Court Information
Tool | Description |
| List all indexed courts, optionally filtered by canton |
| Latest decisions, filterable by canton and court level |
| Statistics on indexed decisions by canton and year |
| Offline-dump cache state, coverage, version, pre-warming (read-only) |
Tool Annotations
All eight tools share the same hints โ they are read-only, idempotent, non-destructive, and reach an external system:
Annotation | Value |
|
|
|
|
|
|
|
|
A rechtsrecherche prompt is also provided (a second MCP primitive
alongside tools).
Example Use Cases
Use Case | Tool Chain |
Research case law on data protection |
|
Find practice on a constitutional right |
|
Latest Federal Supreme Court rulings |
|
Combined: Law text + case law |
|
โ More use cases by audience โ
Architecture
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ MCP Client (LLM) โ
โ Claude / Cursor / Windsurf โ
โโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโ
โ MCP Protocol
โโโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ swiss-courts-mcp โ
โ 8 tools ยท Pydantic validation โ
โ Elasticsearch query builder โ
โ Provenance envelope: source = live | dump โ
โโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฌโโโโโโโ
โ โ live (default) โ โก fallback
โ HTTPS POST/GET โ on bot-block / 5xx / 429 /
โ โ timeout, or SWISS_COURTS_FORCE_DUMP=1
โโโโโโโโโผโโโโโโโโโโโโโโโโโโโ โโโโโโโโโผโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ entscheidsuche.ch โ โ SCD dump โ Zenodo 14867950 (CC BY) โ
โ Elasticsearch backend โ โ lazy download โ platformdirs cache โ
โ Federal + 26 cantons โ โ โ local SQLite search โ
โ no auth ยท no SLA โ โ BGer only ยท 2007โ2024 ยท no full text โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโLive-first, always: the offline dump only engages on an availability failure
(bot-block, HTTP 5xx/429, timeout) or when forced. It is a behaviour of the
existing tools, not a separate search tool โ why this source and not the
full-text one is in ADR 0002; what it does
and does not cover is under Known Limitations. Inspect
the cache at any time with get_fallback_status.
Safety & Limits
Aspect | Details |
Access | Read-only ( |
Personal data | No personal data โ all decisions are public court rulings |
Rate limits | Built-in per-query caps (max 50 results per search, 50 aggregation buckets) |
Timeout | 30 seconds per API call |
Data source auth | No API keys required โ entscheidsuche.ch is publicly accessible |
HTTP transport auth | Optional bearer-token auth (JWT, |
Egress | Code-layer allow-lists ( |
Error masking | Internal exceptions are logged server-side only; clients receive friendly messages |
Secrets | No secrets in code/logs; |
Licenses | Court decisions are public domain under Swiss law (BGG Art. 27) |
Terms of Service | Subject to entscheidsuche.ch usage terms โ please be kind to the server |
Known Limitations
Search is limited to decisions indexed by entscheidsuche.ch (not all decisions are publicly available)
Full-text document content is not returned โ only metadata, title, and abstract
Statistics depend on Elasticsearch aggregation support of the backend
The court taxonomy structure from
Facetten_alle.jsonmay vary
Offline fallback (partial coverage โ read this): the fallback is a safety net for availability, not an equivalent mirror of the live source:
Court scope: Federal Supreme Court only (BGer/BGE). Bundesverwaltungsgericht, Bundesstrafgericht and all 26 cantonal courts are not covered.
Time span: 2007 โ December 2024 (the SCD dump's range). Decisions outside this window are not in the dump.
Content: metadata/regesten only โ no full text offline.
Update latency: the SCD dump is refreshed roughly quarterly on Zenodo, so the offline data lags the live index.
get_fallback_statusreports the cached version and can check Zenodo for a newer one.Law-reference search offline only matches references named in the decision's subject/regest (
topic/issue) โ there is no offline cited-law index.get_court_decisionis best-effort offline: SCD case ids (docref, e.g.1C_517/2016) differ from entscheidsuche signatures, so some lookups are honestly reported as non-resolvable.Responses always disclose their origin via
source(live/dump) and acoverage_note; the server never silently narrows coverage โ an uncovered query gets an explicit "not covered" answer, never a silent empty result.
Testing
Unit tests mock all HTTP with respx. Run from the project root. The five
gates CI runs โ check_gate_docs.py holds this list against ci.yml, so it
cannot quietly fall behind:
PYTHONPATH=src pytest tests/ -m "not live"
python scripts/check_ruff_pin.py
ruff check src/ tests/ scripts/
ruff format --check src/ tests/ scripts/
python scripts/check_version_sync.py
python scripts/check_gate_docs.pyThe live tests are not a gate โ they hit the real source and run on a schedule
(live.yml), not on pull requests:
PYTHONPATH=src pytest tests/ -v -m liveEditing live.yml is a special case: GitHub only honours schedule on the
default branch, so changes take effect after the merge โ trigger it by hand
(workflow_dispatch) to test them before that.
The offline-fallback tests mock the Zenodo download with respx and use a
small committed fixture โ the ~120 MB dump is never downloaded in CI.
Changelog
See CHANGELOG.md.
Contributing
See CONTRIBUTING.md.
Security
See SECURITY.md for the security posture and how to report a vulnerability.
License
Author
Hayal Oezkan ยท malkreide
Credits & Related Projects
entscheidsuche.ch โ Swiss court decision search engine (live source)
Swiss Federal Supreme Court Dataset (SCD) โ offline fallback source, CC BY 4.0: Geering, F. & Merane, J. (2025). Swiss Federal Supreme Court Dataset (SCD), Version 2024-3. Zenodo. https://doi.org/10.5281/zenodo.14867950
fedlex-mcp โ MCP Server for Swiss federal law (legislation synergy)
zurich-opendata-mcp โ MCP Server for Zurich open data
Model Context Protocol โ Open protocol for AI tool integration
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-courts-mcp": {
"command": "uvx",
"args": [
"swiss-courts-mcp"
]
}
}
}Available Tools
8 toolsget_court_decisionARead-onlyIdempotent
Ruft einen einzelnen Gerichtsentscheid anhand seiner Signatur ab.
Use-Case: Detail-Ansicht eines konkreten Urteils (Signatur aus search_court_decisions). Exakter Lookup ohne Fuzzy-Fallback.
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint, destructiveHint, idempotentHint. The description adds the key behavioral trait of 'exakter Lookup ohne Fuzzy-Fallback', which clarifies the exact-match nature and absence of fuzzy search behavior. 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 extremely concise: two sentences plus a use-case line, front-loaded with the core action. Every sentence serves a purpose 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?
For a simple tool with one required parameter and no output schema, the description covers the main behavior (exact lookup, use-case). Minor gaps: does not mention return format or error handling for invalid signatures, but overall adequate.
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 already provides descriptions for both parameters (signature and language). The tool description does not add new parameter semantics beyond what the schema offers. With high schema coverage, baseline 3 is appropriate.
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 retrieves a single court decision by signature, with a specific use-case (detail view) and exact lookup without fuzzy fallback. It distinguishes from sibling search_court_decisions which would return multiple results.
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 guides when to use: for a detail view of a specific judgment using a signature obtained from search_court_decisions. It explicitly says it's an exact lookup without fuzzy fallback, implying when not to use. However, it does not explicitly exclude other siblings like search_by_law_reference or list_courts.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_decision_statisticsARead-onlyIdempotent
Gibt Statistiken รผber die Anzahl indexierter Gerichtsentscheide zurรผck.
Use-Case: Mengengerรผst und Verteilung nach Kanton/Jahr.
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. The description adds that it returns statistics, but does not disclose additional behavioral traits like rate limits or data freshness. This is adequate given 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 two sentences, front-loaded with the core purpose, and contains no extraneous information. Every sentence adds 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 clearly explains the purpose and use case, which is sufficient for a simple statistics tool with two optional parameters. The return value is not described, but the annotations (openWorldHint) and the nature of statistics make this 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 top-level 'params' parameter has no schema description (0% coverage), and the description does not explain the parameters at all. The inner properties have descriptions, but the description fails to compensate for the top-level lack of documentation.
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 statistics on the number of indexed court decisions, specifying the use case for volume and distribution by canton/year. This differentiates it from sibling tools that deal with individual decisions or searches.
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 the use case 'Mengengerรผst und Verteilung nach Kanton/Jahr', which tells the agent when to use the tool. However, it does not provide explicit when-not-to-use guidance or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_fallback_statusARead-onlyIdempotent
Zeigt Zustand und Abdeckung des Offline-Fallbacks (SCD-Dump).
Use-Case: Transparenz โ ist der lokale Dump-Cache vorhanden, welche Version,
was deckt er ab (nur Bundesgericht 2007โ2024, kein Volltext) und wie erzwingt
man ihn (ENV SWISS_COURTS_FORCE_DUMP=1). Read-only; lรคdt selbst NICHTS
herunter. check_updates=True fragt optional die Zenodo-Versions-API ab.
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnly/idempotent hints, the description adds valuable behavioral details: it does not download anything, it can optionally query the Zenodo API, and it explains the ENV variable to force the dump. This is non-obvious and useful for an agent.
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, well-structured with a 'Use-Case' section, and front-loaded with the primary purpose. Every sentence adds useful context 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?
Since there is no output schema, the description provides high-level output details (state, version, coverage) but could be more explicit about return format. However, for a status tool with one optional parameter, 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 only parameter, check_updates, is explained both in the schema and the description, with the description adding that it queries the Zenodo version API when true. Despite the 0% schema coverage signal (which appears inconsistent with the schema having a description), the description compensates adequately for a single boolean.
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 shows the state and coverage of the offline fallback (SCD dump), specifying what it checks (presence, version, coverage, force method). It contrasts with sibling tools focused on searching/retrieving decisions, making it 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 provides a clear use-case (transparency) and explicitly notes what the tool does NOT do (downloads nothing), which helps avoid misuse. It does not name alternative tools, but the use-case is self-explanatory and distinct from siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_recent_decisionsBRead-onlyIdempotent
Gibt die neuesten Gerichtsentscheide zurรผck.
Use-Case: aktuelle Rechtsprechungsentwicklungen verfolgen. Chronologisch sortiert, filterbar nach Kanton und Gerichtsebene.
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds that results are sorted chronologically and filterable, which is beyond annotations. But it omits details like pagination (though a limit parameter exists) or the structure of returned data.
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 with two sentences, no redundancy. It front-loads the main purpose and then provides use-case and filtering options. However, it could be slightly more structured to separate use-case from parameters.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only list tool with no output schema, the description covers core functionality and use-case. However, it lacks details on result format, pagination behavior, and how it differs from similar search tools, which may leave some 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 already describes each parameter (e.g., 'Kanton filtern') with enumerations and defaults. The description only restates that filters are available, adding no new meaning beyond the schema. With 0% schema description coverage in the tool definition, but full descriptions in the schema itself, the baseline is 3.
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 newest court decisions and includes a use-case for tracking legal developments. It implies a difference from sibling tools like search_court_decisions by focusing on recent, chronologically sorted results, but does not explicitly differentiate.
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 use-case ('aktuelle Rechtsprechungsentwicklungen verfolgen') and mentions filtering options, which helps understand when to use it. However, it does not mention when not to use this tool or suggest alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_courtsARead-onlyIdempotent
Listet alle in entscheidsuche.ch indexierten Gerichte auf.
Use-Case: รberblick รผber verfรผgbare Bundes- und Kantonsgerichte, optional nach Kanton gefiltert.
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds context beyond annotations by specifying the data source (entscheidsuche.ch) and scope (federal and cantonal courts). Annotations already declare readOnlyHint, destructiveHint, and idempotentHint, so the description complements them well without contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences that are front-loaded with the core action. Every word adds value, with no redundant or vague phrasing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with rich annotations and a clear use case, the description is fully adequate. It covers purpose, scope, and filtering without needing to detail return format or additional behaviors.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% (based on context signals), so the description must compensate. It mentions the optional canton filter, which mirrors the schema's own description. No additional semantic detail is added, so baseline 3 is appropriate.
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 courts indexed in entscheidsuche.ch and mentions optional canton filtering. It distinguishes itself from sibling tools which all deal with court decisions, making the purpose 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 provides a clear use case ('รberblick รผber verfรผgbare Bundes- und Kantonsgerichte') and indicates when to use the canton parameter. It does not explicitly state when not to use the tool, but the context with siblings makes it obvious.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_bger_decisionsARead-onlyIdempotent
Sucht gezielt in Bundesgerichtsentscheiden (BGer/BGE).
Use-Case: hรถchstrichterliche Rechtsprechung mit optionalem Abteilungsfilter.
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. The description adds that it searches BGer decisions with optional filter, which is consistent but does not provide additional behavioral context beyond what annotations already convey.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short lines in German, front-loaded with key information. Every sentence is necessary and there is 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?
For a search tool with one required parameter and no output schema, the description adequately covers the domain and main filter. It could mention the other optional parameters (date, language, limit) but they are documented in the schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already provides descriptions for all parameters (query, chamber, date_from, date_to, language, limit). The description adds the domain context and emphasizes the chamber filter, but does not add new meaning 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 searches specifically in Swiss Federal Supreme Court decisions (BGer/BGE), with an optional chamber filter. This is a specific verb+resource combination that distinguishes it from siblings like search_court_decisions or get_court_decision.
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 the use-case 'hรถchstrichterliche Rechtsprechung' (highest court rulings) and optional chamber filter, providing context for when to use. However, it does not explicitly state when not to use this tool or suggest alternatives among the siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_by_law_referenceBRead-onlyIdempotent
Sucht Gerichtsentscheide die einen bestimmten Gesetzesartikel zitieren.
Use-Case: Praxis zu einer Norm finden. Mehrstufige Suche: exakte Phrase (hรถchste Relevanz) + Artikelnummer/Kรผrzel (breitere Abdeckung). Synergie mit fedlex-mcp: zuerst Gesetz nachschlagen, dann Praxis dazu finden. Beispiele: 'Art. 8 BV', 'Art. 328 OR', 'Art. 25 DSG'.
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already indicate read-only and idempotent behavior. The description adds the multi-step search approach and examples, but does not detail other behaviors like pagination or error handling.
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 no fluff, front-loaded with the main action, and includes helpful examples. Every sentence adds 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 covers the core purpose and use-case but lacks details on output format, pagination, or full parameter usage. Given the absence of an output schema, more completeness would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is low (0% per context). The description does not explain parameters like date_from, date_to, language, or limit beyond examples for law_reference. It fails to compensate for missing parameter explanations.
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 searches for court decisions citing a specific legal article. It gives context and examples, but does not explicitly distinguish from sibling search tools like search_bger_decisions.
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 use-case (finding practice to a norm) and suggests synergy with fedlex-mcp, but does not specify when to use this tool versus alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_court_decisionsARead-onlyIdempotent
Volltextsuche in Schweizer Gerichtsentscheiden.
Use-Case: juristische Recherche รผber alle Schweizer Gerichte (Bund + Kantone) via entscheidsuche.ch. Unterstรผtzt Filter nach Kanton, Gerichtsebene und Datumsbereich. Liefert abgeschlossene Treffer inkl. Titel, Abstract und Volltext-Link, kuratiertes Markdown sowie einen maschinenlesbaren Response-Envelope (source, license, match_type, count, total, results).
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare read-only, non-destructive, idempotent, and open-world behavior. The description adds value by detailing the response structure (title, abstract, link, curated Markdown, and machine-readable envelope with source, license, match_type, count, total, results), which goes 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 composed of two short, focused sentences followed by a bulleted list of response components. It is efficiently front-loaded with the core purpose and provides all necessary information 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 rich annotations and detailed input schema, the description sufficiently covers the tool's purpose, usage context, and output structure. It compensates for the lack of an output schema by enumerating response fields, making the tool fully understandable for selection and invocation.
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 already provides thorough descriptions for all parameters (query, filters, limit, etc.) with examples. The description adds no new parameter-level information beyond mentioning the supported filter types, so it provides minimal added value over 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 performs full-text search of Swiss court decisions via entscheidsuche.ch, covering federal and cantonal courts. This verb+resource+scope effectively distinguishes it from siblings like get_court_decision (single retrieval) or search_bger_decisions (limited to federal court).
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 use-case is explicitly described as legal research across all Swiss courts with filter support. However, it does not specify when to avoid this tool in favor of siblings (e.g., for narrower searches use search_bger_decisions), so it misses explicit alternatives.
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.
1 tool update
v0.3.0- Added
get_fallback_status
7 tool updates
v0.2.3- First observed
get_court_decision - First observed
get_decision_statistics - First observed
get_recent_decisions - First observed
list_courts - First observed
search_bger_decisions - First observed
search_by_law_reference - First observed
search_court_decisions
TDQS
Scored across 8 tools
Most tools have clearly distinct purposes, but search_bger_decisions overlaps with search_court_decisions since the general search can likely filter by court. However, the specialized nature of BGer search is well-documented, so confusion is minimal.
All tool names follow a consistent verb_noun pattern in snake_case (e.g., search_court_decisions, get_court_decision, list_courts). The minor variation in search_by_law_reference is still readable and does not break the overall pattern.
8 tools is well within the ideal 3-15 range and each tool addresses a distinct aspect of legal research (search, retrieval, recent updates, statistics, and system status). No tool feels superfluous.
The set covers the core workflows: searching across courts, retrieving specific decisions, searching by law reference, listing courts, and accessing recent/statistical data. Minor gaps like missing full-text retrieval (only links provided) are acceptable given the API's design, but the inclusion of search_bger_decisions does not add fundamental new capability.
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
MCP for CourtListener: US federal and state opinions, dockets, judges, plus eCFR regulations.
MCP for CanLII: Canadian case law and legislation metadata (federal, provincial, territorial).
- LegalizeOAuthdev.legalize
Official MCP connector for Legalize: read and search its whole open corpus, at any point in time.
Related MCP Servers
- FlicenseBqualityFmaintenanceAn MCP server providing standardized access to Swiss court decisions through the entscheidsuche.ch API, allowing LLMs to search, retrieve, and analyze legal documents from Swiss jurisdictions.35-
- AlicenseNot gradedqualityNot gradedmaintenanceProvides access to Swiss court decisions through the entscheidsuche.ch API, enabling search, retrieval, and analysis of legal documents across different cantons and courts using natural language queries.-
- AlicenseAqualityAmaintenanceMCP Server for Swiss federal law โ search the SR, monitor legal changes, and query BBl/treaties via Claude Desktop or Claude.ai.125MIT
- AlicenseAqualityAmaintenanceMCP server for querying Swiss intellectual property data (trademarks, patents, supplementary protection certificates) from the Swissreg register via natural language.11MIT