# ckan-mcp-server [Health: Active]

**Category:** 💻 Developer Tools  
**Repository:** https://github.com/ondata/ckan-mcp-server  
**GitHub Stars:** 80  
**npm Downloads (last month):** 8685  
**Views:** 4  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/ckan-mcp-server

## Description
MCP server for interacting with CKAN open data portals

## Tools
Capabilities this server exposes over MCP:

- **ckan_package_search** — Search for datasets (packages) on a CKAN server using Solr query syntax.

Supports full Solr search capabilities including filters, facets, and sorting.
Use this to discover datasets matching specific criteria.

Note on parser behavior:
Some CKAN portals use a restrictive default query parser that can break long OR queries.
For those portals, this tool may force the query into 'text:(...)' based on per-portal config.
You can override with 'query_parser' to force or disable this behavior per request.

Important - Date field semantics:
  - issued: publisher's content publish date when available (best proxy for "created/published")
  - modified: publisher's content update date when available
  - metadata_created: CKAN record creation timestamp (publish time on source portals,
    harvest time on aggregators; fallback for "created" if issued missing)
  - metadata_modified: CKAN record update timestamp (publish time on source portals,
    harvest time on aggregators; use for "updated/modified in last X")

Natural language mapping (important for tool callers):
  - "created"/"published" -> prefer issued; fallback to metadata_created
  - "updated"/"modified" -> prefer modified; fallback to metadata_modified
  - For "recent in last X", consider using content_recent (issued with metadata_created fallback)

Content-recent helper:
  - content_recent: if true, rewrites the query to use issued with a fallback to
    metadata_created when issued is missing.
  - content_recent_days: window for content_recent (default 30 days).

Args:
  - server_url (string): Base URL of CKAN server (e.g., "https://dati.gov.it/opendata")
  - q (string): Search query using Solr syntax (default: "*:*" for all)
  - fq (string): Filter query (e.g., "organization:comune-palermo")
    IMPORTANT — Solr fq syntax rules:
    1. OR inside a single field: use field:(val1 OR val2), NOT field:val1 OR field:val2.
       Wrong: fq=type:"A" OR type:"B"  → silently ignored, returns entire catalog.
       Right:  fq=type:("A" OR "B")
    2. CKAN extras fields are indexed as extras_fieldname, not fieldname.
       e.g. to filter on extra field "hvd_category" use fq=extras_hvd_category:"<value>"
  - rows (number): Number of results to return (default: 10, max: 1000)
  - start (number): Offset for pagination (default: 0)
  - page (number): Page number (1-based); alias for start. Overrides start if provided.
  - page_size (number): Results per page when using page (default: 10, max: 1000)
  - sort (string): Sort field and direction (e.g., "metadata_modified desc")
  - facet_field (array): Fields to facet on (e.g., ["organization", "tags"])
  - facet_limit (number): Max facet values per field (default: 50)
  - include_drafts (boolean): Include draft datasets (default: false)
  - query_parser ('default' | 'text'): Override search parser behavior
  - response_format ('markdown' | 'json'): Output format

Returns:
  Search results with:
  - count: Number of results found
  - results: Array of dataset objects
  - facets: Facet counts (if facet_field specified)
  - search_facets: Detailed facet information

Query Syntax (parameter q):
  Boolean operators:
    - AND / &&: "water AND climate"
    - OR / ||: "health OR sanità"
    - NOT / !: "data NOT personal"
    - +required -excluded: "+title:water -title:sea"
    - Grouping: "(title:water OR title:climate) AND tags:environment"

  Wildcards:
    - *: "title:environment*" (matches environmental, environments, etc.)
    - Note: Left truncation (*water) not supported

  Fuzzy search (edit distance):
    - ~: "title:rest~" or "title:rest~1" (finds "test", "best", "rest")

  Proximity search (words within N positions):
    - "phrase"~N: "title:"climate change"~5"

  Range queries:
    - Inclusive [a TO b]: "num_resources:[5 TO 10]"
    - Exclusive {a TO b}: "num_resources:{0 TO 100}"
    - One side open: "metadata_modified:[2024-01-01T00:00:00Z TO *]"

  Date math:
    - NOW-1YEAR, NOW-6MONTHS, NOW-7DAYS, NOW-1HOUR
    - NOW/DAY, NOW/MONTH (round down)
    - Combined: "metadata_modified:[NOW-2MONTHS TO NOW]"
    - Example: "metadata_created:[NOW-1YEAR TO *]"
    - IMPORTANT: NOW syntax works on metadata_modified and metadata_created fields
    - For 'modified' and 'issued' fields, NOW syntax is auto-converted to ISO dates
    - Manual ISO dates always work: "modified:[2026-01-15T00:00:00Z TO *]"

  Field existence:
    - Exists: "field:*" or "field:[* TO *]"
    - Not exists: "NOT field:*" or "-field:*"

  Boosting (relevance scoring):
    - Boost term: "title:water^2 OR notes:water" (title matches score higher)
    - Constant score: "title:water^=1.5"

Examples:
  - Search all: { q: "*:*" }
  - By tag: { q: "tags:sanità" }
  - Boolean: { q: "(title:water OR title:climate) AND NOT title:sea" }
  - Wildcard: { q: "title:environment*" }
  - Fuzzy: { q: "title:health~2" }
  - Proximity: { q: "notes:"open data"~3" }
  - Date range: { q: "metadata_modified:[2024-01-01T00:00:00Z TO 2024-12-31T23:59:59Z]" }
  - Date math: { q: "metadata_modified:[NOW-6MONTHS TO *]" }
  - Date math (auto-converted): { q: "modified:[NOW-30DAYS TO NOW]" }
  - Published in 2025 (content date): { fq: "issued:[2025-01-01T00:00:00Z TO 2025-12-31T23:59:59Z]" }
  - First appeared on portal in 2025: { fq: "metadata_created:[2025-01-01T00:00:00Z TO 2025-12-31T23:59:59Z]" }
  - Recent content (issued w/ fallback): { q: "*:*", content_recent: true, content_recent_days: 180 }
  - Field exists: { q: "organization:* AND num_resources:[1 TO *]" }
  - Boosting: { q: "title:climate^2 OR notes:climate" }
  - Filter org: { fq: "organization:regione-siciliana" }
  - Filter extras field (correct): { fq: "extras_hvd_category:"http://data.europa.eu/bna/c_ac64a52d"" }
  - Filter extras OR (correct): { fq: "extras_hvd_category:("http://data.europa.eu/bna/c_ac64a52d" OR "http://data.europa.eu/bna/c_dd313021")" }
  - Get facets: { facet_field: ["organization"], rows: 0 }

Query language:
  Before searching a portal, check its locale via ckan_status_show (field: "Portal Locale" / locale_default).
  Translate query terms to the portal's language — searching in English on a non-English portal returns 0 results.
  Examples: locale "it" → Italian terms; "uk_UA" → Ukrainian (Cyrillic); "fr_FR" → French.
  Exception: multilingual portals (e.g. data.europa.eu, open.canada.ca) accept EN + native terms joined with OR.

Typical workflow: ckan_status_show (check locale) → ckan_package_search (query in portal's language) → ckan_package_show (get full metadata + resource IDs) → ckan_datastore_search (query tabular data)
- **ckan_find_relevant_datasets** — Find and rank datasets by relevance to a query using weighted fields.

Use this instead of ckan_package_search when you want relevance-ranked results with
explicit scoring across title, notes, tags, and organization fields.
Use ckan_package_search instead when you need Solr filter syntax, facets, or pagination.

Uses package_search for discovery and applies a local scoring model.

Args:
  - server_url (string): Base URL of CKAN server (e.g., "https://dati.gov.it/opendata")
  - query (string): Natural language or keyword query (e.g., "mobilità urbana", "air quality")
  - limit (number): Number of datasets to return (default: 10)
  - weights (object): Field weights for scoring — higher weight = more influence on rank
    Default: title=4, tags=3, notes=2, organization=1, holder=4, publisher=2, coverage=4
    coverage: bonus for datasets the portal returned with every query term required
    (Solr mm=100%); these are fetched first, the rest fills in when they are fewer than limit
    Note on holder vs organization: on federated catalogs (e.g. dati.gov.it), `organization`
    is the harvesting catalog (e.g. Regione Puglia), while `holder` (DCAT-AP_IT dct:rightsHolder)
    is the actual data owner (e.g. Comune di Lecce). Queries like "datasets from a specific Comune"
    match `holder` correctly; matching only `organization` misses datasets harvested via
    aggregators. `publisher` (dct:publisher) is scored separately at lower weight as it can
    contain technical roles ("Redazione OD") rather than the institutional owner.
  - query_parser ('default' | 'text'): Override search parser behavior
  - response_format ('markdown' | 'json'): Output format

Returns:
  Ranked datasets with relevance scores and per-field score breakdowns

Examples:
  - { server_url: "https://dati.gov.it/opendata", query: "mobilità" }
  - { server_url: "...", query: "trasporti", limit: 5, weights: { title: 5, notes: 2 } }
  - { server_url: "...", query: "defibrillatori Comune di Lecce", weights: { holder: 5 } }

Typical workflow: ckan_find_relevant_datasets → ckan_package_show (inspect top results) → ckan_datastore_search (query data)
- **ckan_package_show** — Get complete metadata for a specific dataset (package).

Returns full details including resources, organization, tags, and all metadata fields.

Notes:
  - metadata_modified is a CKAN record timestamp (publish time on source portals,
    harvest time on aggregators), not the content date.
  - issued/modified are content dates when provided by the publisher.
  - JSON output adds metadata_harvested_at (same as metadata_modified).

Args:
  - server_url (string): Base URL of CKAN server
  - id (string): Dataset ID or name (machine-readable slug)
  - include_tracking (boolean): Include view/download statistics (default: false)
  - response_format ('markdown' | 'json'): Output format

On portals that use ckanext-scheming the schema's other root fields are added as "fields"
([{field, label, value}]), each with the label the schema gives it and the value as stored.
Portals without scheming are unaffected.

Returns (JSON format):
  id, name, title, notes, organization, tags, state, license_title,
  metadata_created, metadata_modified, issued, modified,
  author, maintainer,
  frequency, language, publisher_name, holder_name,
  hvd_category, applicable_legislation,
  temporal_coverage (array of {start, end, start_equals_issued} from dct:temporal; empty if absent;
    start_equals_issued=true when start = issued and no end: on dcatapit portals an export default, not a data period),
  resources (id, name, format, url, size, datastore_active, created, last_modified, api_json_url),
  view_url, api_json_url

Examples:
  - { server_url: "https://dati.gov.it/opendata", id: "dataset-name" }
  - { server_url: "...", id: "abc-123-def", include_tracking: true }

Typical workflow: ckan_package_show → pick a resource with datastore_active=true → ckan_datastore_search (query its data)
- **ckan_list_resources** — List all resources in a dataset with a compact summary.

Returns a focused table of resources showing format, size, DataStore availability, and download URL.
Use this to quickly assess what files a dataset contains before deciding how to access the data.

Args:
  - server_url (string): Base URL of CKAN server
  - id (string): Dataset ID or name
  - format_filter (string): Filter resources by format, case-insensitive (e.g., "CSV", "json", "XLSX")
  - response_format ('markdown' | 'json'): Output format

Returns:
  Compact resource summary with name, ID, format, size, DataStore flag, and URL

Examples:
  - { server_url: "https://dati.gov.it/opendata", id: "dataset-name" }
  - { server_url: "...", id: "dataset-name", format_filter: "CSV" }

Typical workflow: ckan_package_search → ckan_list_resources (assess available files) → ckan_datastore_search (for resources with DataStore=true)

When a resource has DataStore=false but its download URL belongs to a different (source) portal,
the tool can probe the source portal for DataStore availability and report
source_datastore_active and source_portal_url so you can query the data there instead.
This probing is OFF by default (it issues extra HTTP requests to hosts taken from the
dataset's own resource URLs); set check_source_portal=true to enable it.
- **ckan_organization_list** — List all organizations on a CKAN server.

Organizations are entities that publish and manage datasets.

Args:
  - server_url (string): Base URL of CKAN server
  - all_fields (boolean): Return full objects vs just names (default: false)
  - sort (string): Sort field (default: "name asc")
  - limit (number): Maximum results (default: 100). Use 0 to get only the count via faceting
  - offset (number): Pagination offset (default: 0)
  - response_format ('markdown' | 'json'): Output format

Returns:
  List of organizations with metadata. When limit=0, returns only the count of organizations with datasets.

Typical workflow: ckan_organization_list → ckan_organization_show (inspect one) → ckan_package_search with fq="organization:name" (browse its datasets)
- **ckan_organization_show** — Get details of a specific organization.

Args:
  - server_url (string): Base URL of CKAN server
  - id (string): Organization ID or name
  - include_datasets (boolean): Include list of datasets (default: true)
  - include_users (boolean): Include list of users (default: false)
  - response_format ('markdown' | 'json'): Output format

Returns:
  Organization details with optional datasets and users

Typical workflow: ckan_organization_show → ckan_package_show (inspect a dataset) → ckan_datastore_search (query its data)
- **ckan_organization_search** — Search for organizations by name pattern.

This tool provides a simpler interface than package_search for finding organizations.
Wildcards are automatically added around the search pattern.

Args:
  - server_url (string): Base URL of CKAN server
  - pattern (string): Search pattern (e.g., "toscana", "salute")
  - response_format ('markdown' | 'json'): Output format

Returns:
  List of matching organizations with dataset counts

Examples:
  - { server_url: "https://www.dati.gov.it/opendata", pattern: "toscana" }
  - { server_url: "https://open.canada.ca/data", pattern: "health" }

Typical workflow: ckan_organization_search → ckan_organization_show (get details) → ckan_package_search with fq="organization:name"
- **ckan_datastore_search** — Query data from a CKAN DataStore resource.

The DataStore allows SQL-like queries on tabular data. Not all resources have DataStore enabled.

The response always includes a Fields section listing all available column names and types.
Use limit=0 to discover column names without fetching data — do this before using filters
to avoid guessing column names and getting HTTP 400 errors.

Args:
  - server_url (string): Base URL of CKAN server
  - resource_id (string): ID of the DataStore resource
  - q (string): Full-text search query (optional)
  - filters (object): Key-value filters (e.g., { "anno": 2023 })
  - limit (number): Max rows to return (default: 100, max: 32000)
  - offset (number): Pagination offset (default: 0)
  - fields (array): Specific fields to return (optional)
  - sort (string): Sort field with direction (e.g., "anno desc")
  - distinct (boolean): Return distinct values (default: false)
  - response_format ('markdown' | 'json'): Output format

Returns:
  DataStore records matching query, always including available column names and types

Examples:
  - { server_url: "...", resource_id: "abc-123", limit: 0 }  ← discover columns first
  - { server_url: "...", resource_id: "abc-123", limit: 50 }
  - { server_url: "...", resource_id: "...", filters: { "regione": "Sicilia" } }
  - { server_url: "...", resource_id: "...", sort: "anno desc", limit: 100 }

Typical workflow: ckan_package_search → ckan_package_show (find resource_id with datastore_active=true) → ckan_datastore_search (limit=0 to get columns) → ckan_datastore_search (with filters)
- **ckan_datastore_search_sql** — Run SQL queries on a CKAN DataStore resource.

This endpoint is only available on CKAN portals with DataStore enabled and SQL access exposed.

Args:
  - server_url (string): Base URL of CKAN server
  - sql (string): SQL query (e.g., SELECT * FROM "resource_id" LIMIT 10)
  - response_format ('markdown' | 'json'): Output format

Returns:
  SQL query results from DataStore

Examples:
  - { server_url: "...", sql: "SELECT * FROM "abc-123" LIMIT 10" }
  - { server_url: "...", sql: "SELECT COUNT(*) AS total FROM "abc-123"" }

Typical workflow: ckan_package_show (get resource_id) → ckan_datastore_search_sql (run SQL on it)

Security note: SQL queries are forwarded directly to the CKAN DataStore API. The CKAN server enforces its own access controls and read-only permissions. No local database is exposed. Queries are limited to public DataStore resources on the target portal.
- **ckan_status_show** — Check if a CKAN server is available and get version information.

Useful to verify server accessibility before making other requests.
Also shows the count of High-Value Datasets (HVD) when the portal supports it.

Args:
  - server_url (string): Base URL of CKAN server

Returns:
  Server status, version information, and HVD dataset count (if available)

Typical workflow: ckan_status_show (verify server is up) → ckan_package_search (discover datasets)
- **ckan_tag_list** — List tags from a CKAN server using faceting.

This returns tag names with counts, optionally filtered by dataset query or tag substring.

Args:
  - server_url (string): Base URL of CKAN server
  - q (string): Dataset search query (default: "*:*")
  - fq (string): Filter query (optional)
  - tag_query (string): Filter tags by substring (optional)
  - limit (number): Max tags to return (default: 100, max: 1000)
  - response_format ('markdown' | 'json'): Output format

Returns:
  List of tags with counts (from faceting)

Typical workflow: ckan_tag_list → ckan_package_search with fq="tags:tag_name" (find datasets by tag) → ckan_package_show
- **ckan_group_list** — List all groups on a CKAN server.

Groups are thematic collections of datasets.

Args:
  - server_url (string): Base URL of CKAN server
  - all_fields (boolean): Return full objects vs just names (default: false)
  - sort (string): Sort field (default: "name asc")
  - limit (number): Maximum results (default: 100). Use 0 to get only the count via faceting
  - offset (number): Pagination offset (default: 0)
  - response_format ('markdown' | 'json'): Output format

Returns:
  List of groups with metadata. When limit=0, returns only the count of groups with datasets.

Typical workflow: ckan_group_list → ckan_group_show (inspect one) → ckan_package_search with fq="groups:name" (browse its datasets)
- **ckan_group_show** — Get details of a specific group.

Args:
  - server_url (string): Base URL of CKAN server
  - id (string): Group ID or name
  - include_datasets (boolean): Include list of datasets (default: true)
  - response_format ('markdown' | 'json'): Output format

Returns:
  Group details with optional datasets

Typical workflow: ckan_group_show → ckan_package_show (inspect a dataset) → ckan_datastore_search (query its data)
- **ckan_group_search** — Search for groups by name pattern.

This tool provides a simpler interface than package_search for finding groups.
Wildcards are automatically added around the search pattern.

Args:
  - server_url (string): Base URL of CKAN server
  - pattern (string): Search pattern (e.g., "energia", "salute")
  - response_format ('markdown' | 'json'): Output format

Returns:
  List of matching groups with dataset counts

Typical workflow: ckan_group_search → ckan_group_show (get details) → ckan_package_search with fq="groups:name"
- **ckan_get_mqa_quality** — Get MQA (Metadata Quality Assessment) quality score for a dataset on dati.gov.it from data.europa.eu. Returns the final score on the 0-7.5 scale of MQA methodology v2 with its band (Sufficient/Good/Excellent), dataset, distribution and data service scores, and the failing metrics with the largest gain. Datasets not yet re-evaluated fall back to the previous methodology (405 scale), labelled as such. Only works with dati.gov.it server. Typical workflow: ckan_package_show (get dataset ID) → ckan_get_mqa_quality → ckan_get_mqa_quality_details (full list of failing metrics)
- **ckan_get_mqa_quality_details** — Get detailed MQA (Metadata Quality Assessment) quality reasons for a dataset on dati.gov.it. Lists every failing metric grouped by FAIR dimension, with DCAT-AP property, weight, how many distributions fail it and its gain on the final score, plus the HTTP status of failing URL tests (e.g. 1100 timeout, 404) (methodology v2); previous-methodology datasets get non-max reasons. Only works with dati.gov.it server. Typical workflow: ckan_get_mqa_quality (get overview scores) → ckan_get_mqa_quality_details (inspect failing metrics)
- **ckan_analyze_datasets** — Search datasets and inspect the DataStore schema of queryable resources.

For each dataset found, lists all resources. For DataStore-enabled resources, fetches the full
field schema (name, type, and label/notes when available) plus total record count — all in one call.

Use this before ckan_datastore_search to understand what fields are available and what data to expect.

Args:
  - server_url (string): Base URL of CKAN server
  - q (string): Solr search query (e.g. "incidenti", "title:ambiente")
  - rows (number): Max datasets to analyze (default 5, max 20)
  - response_format ('markdown' | 'json'): Output format

Returns:
  For each dataset: title, ID, organization, and per DataStore resource: field schema with
  label/notes (when available from DataStore Dictionary) and record count.

Typical workflow: ckan_analyze_datasets → ckan_datastore_search (with known field names)
- **ckan_catalog_stats** — Get a statistical overview of a CKAN portal: total dataset count and breakdown by category, format, and organization.

Single CKAN call (package_search with rows=0 and facets). No query needed.

Args:
  - server_url (string): Base URL of the CKAN server
  - facet_limit (number): Max entries per facet section (default 20)
  - response_format ('markdown' | 'json'): Output format

Returns:
  Total dataset count, categories ranked by count, file formats ranked by count, organizations ranked by count.

Typical workflow: ckan_catalog_stats (understand the portal) → ckan_package_search (query specific data)
- **sparql_query** — Execute a SPARQL SELECT query against any public HTTPS SPARQL endpoint.

Useful for querying open data portals and knowledge graphs that expose SPARQL endpoints, including:
- data.europa.eu (European open data portal)
- publications.europa.eu (EU Publications Office)
- DBpedia, Wikidata
- Any DCAT-AP compliant data catalog

Only HTTPS endpoints are allowed. Queries timeout after 15 seconds.
Only SELECT queries are supported (read-only).

If the query does not contain a LIMIT clause, one is injected automatically (default: 25, max: 1000).

Args:
  - endpoint_url (string): HTTPS URL of the SPARQL endpoint
  - query (string): SPARQL SELECT query to execute
  - limit (number): Max rows to return (default: 25). Ignored if query already contains LIMIT.
  - response_format ('markdown' | 'json'): Output format

Examples:
  - Count Italian HVD datasets by publisher on data.europa.eu
  - Query Wikidata for entities related to a dataset topic
  - Explore EU controlled vocabularies on publications.europa.eu

Typical workflow: sparql_query (explore schema) → sparql_query (targeted query) → ckan_package_search (get dataset details)
- **ckan_find_portals** — Search the live datashades.info registry of ~950 CKAN portals worldwide.

Use this tool to discover which CKAN portals exist for a country, language, or topic
before querying them with other CKAN tools.

**IMPORTANT — country parameter**: always pass country name in English.
If the user writes in another language (e.g. "Italia", "España", "Brasil"),
translate to English ("Italy", "Spain", "Brazil") before calling this tool.

Args:
  - country (string): Country name in English (e.g. "Italy", "Brazil", "France")
  - query (string): Keyword to match against portal title (e.g. "transport", "health")
  - min_datasets (number): Minimum number of datasets (e.g. 100)
  - language (string): Portal default locale code (e.g. "it", "en", "pt_BR", "fr")
  - has_datastore (boolean): If true, return only portals with DataStore enabled (supports SQL queries)
  - limit (number): Max results to return (default 10, max 50)

Returns:
  Ranked list of matching portals with URL, country, CKAN version, dataset count, and DataStore status.

Typical workflow: ckan_find_portals (discover portal URL) → ckan_status_show (verify) → ckan_package_search (search datasets)

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "ckan-mcp-server": {
    "command": "npx",
    "args": ["-y","@aborruso/ckan-mcp-server@latest"]
  }
}
```

## Documentation

## What ckan-mcp-server does

ckan-mcp-server gives MCP-compatible clients access to CKAN catalogs and their public APIs. It can search datasets with Solr syntax, rank results using weighted metadata fields, retrieve complete package metadata, and summarize the resources attached to a dataset. Dataset searches can use Boolean expressions, wildcards, fuzzy matching, proximity searches, range filters, facets, sorting, pagination, and date expressions.

The server also covers catalog structure and data access. Agents can list or search organizations, groups, and tags; inspect individual organizations or groups; obtain portal status and catalog statistics; and query CKAN DataStore resources with filters, selected fields, sorting, distinct values, or SQL. A separate SPARQL tool handles read-only SELECT queries against public HTTPS endpoints such as data.europa.eu, DBpedia, and Wikidata. Portal discovery uses the live datashades.info registry, while MQA tools provide quality scores and failing metrics for datasets on dati.gov.it.

## How it works

Each CKAN operation accepts a `server_url`, allowing one configured server to work with different public portals. A typical workflow verifies the portal with `ckan_status_show`, checks its locale, searches in the portal's language, inspects a selected package, and then queries a resource whose `datastore_active` value is true. `ckan_analyze_datasets` can combine discovery with DataStore schema and record-count inspection before a row query.

For recent or historical searches, distinguish content dates from CKAN record timestamps. `issued` and `modified` represent publisher content dates when available; `metadata_created` and `metadata_modified` describe CKAN record activity and may reflect harvesting on aggregators. The `content_recent` option applies an issued-date search with a metadata-created fallback.

## Setup and configuration

Install the local server with npm and expose it through an MCP client's stdio configuration:

```json
{
  "mcpServers": {
    "ckan": {
      "command": "npx",
      "args": ["@aborruso/ckan-mcp-server@latest"]
    }
  }
}
```

A hosted streamable-HTTP endpoint is available at `https://ckan-mcp-server.andy-pr.workers.dev/mcp`, so clients that support remote MCP connections can use it without a local installation. Claude Desktop can configure either transport; Claude Code supports both the hosted HTTP command and the local `npx` command.

## Tools and capabilities

- Search and relevance-rank CKAN datasets, with facets, filters, pagination, and weighted field scoring.
- Retrieve package metadata, resource details, download URLs, tracking data, and DataStore availability.
- Query DataStore tables directly or submit read-only SQL to portals that expose SQL access.
- Browse organizations, groups, tags, portal status, catalog statistics, and registered CKAN portals.
- Inspect DataStore schemas and record counts before selecting fields for a query.
- Run read-only SPARQL SELECT queries over HTTPS with automatic limits when a query has none.

## Limitations and notes

Not every CKAN resource has DataStore enabled, and SQL access depends on the target portal. SPARQL accepts only HTTPS endpoints and SELECT queries. Local and hosted use share a 50,000-character tool-output cap. Dataset search returns up to 1,000 results per page, DataStore row queries allow up to 32,000 rows, and automatic SPARQL limits range up to 1,000 rows when the query does not supply its own `LIMIT`. Oversized responses are truncated; JSON responses include truncation indicators.

The hosted endpoint has a shared quota of 100,000 requests per day. Local Node.js deployments can configure response-body limits with `CKAN_MAX_RESPONSE_BYTES` and `CKAN_MAX_DECOMPRESSED_BYTES`. Source-portal probing for unavailable DataStore resources is disabled by default and can issue additional requests when enabled.

_Full upstream README: https://allmcps.com/mcp/ckan-mcp-server/readme_

