@aborruso/ckan-mcp-server 0.4.121 → 0.4.123

package/LOG.md

@@ -2,6 +2,113 @@
 
 ## 2026-09-05
 
+### v0.4.123 - relevance scoring and shared parser probe
+
+Ships #536: field scoring by share of matched terms, Italian stopwords with acronyms preserved, Unicode-aware term matching, a wider candidate window, the parser probe shared with `ckan_find_relevant_datasets`, and accent-safe filters in `ckan_organization_search` and `ckan_tag_list`. `openspec/specs/ckan-search/spec.md` rewritten around the query-building path.
+
+### Relevance scoring: three defects that only became visible once search worked
+
+Testing v0.4.122 through an MCP client, not curl, showed `ckan_find_relevant_datasets`
+answering its own documented example badly. `defibrillatori Comune di Lecce` on
+dati.gov.it used to return the catalog's only Lecce dataset — because the search
+returned exactly one result. With recall restored it returns 679, and the top three
+became Trento, Martina Franca and Desio while the Lecce dataset fell out of the window.
+
+The wrapping fix did not cause this; it removed the cover. Three defects, all older:
+
+- `scoreTextField` awarded the **whole** field weight when **any** query term matched.
+  "Comune di Martina Franca" and "Comune di Lecce" both scored a full holder match, so
+  the right dataset could not outrank the wrong ones. It now scores the share of terms
+  the field carries.
+- the stopword list was English-only, so `di` counted as a term: "Provincia Autonoma
+  **di** Trento" earned a full holder match on a query asking for Lecce. Italian
+  stopwords added.
+- `\b` is ASCII-only in JavaScript, so a term ending in an accented letter never found
+  its word boundary: `mobilità` scored 0 against "mobilità urbana", `qualità` against
+  "qualità dell'aria". On a catalog that is mostly not in English this silently sank
+  every accented query. Replaced with Unicode lookarounds.
+
+Looking for more of the same family turned up three more, all cases of a local filter
+running over a truncated or wrongly-normalised set:
+
+- `ckan_find_relevant_datasets` never called the parser probe. `portals.json` used to
+  cover it; removing `force_text_field` left it sending boolean queries to the parser that
+  ignores them. On dati.comune.milano.it `aria OR acqua` returned 0 there against 87 from
+  `ckan_package_search`. Same probe now applies to both.
+- `ckan_organization_search` builds a Solr wildcard, which bypasses the analysis chain, so
+  the pattern must be pre-normalised the way CKAN builds a name slug. It lowercased but did
+  not fold accents: `città` returned 0 while `citta` matched 135 datasets.
+- `ckan_tag_list` applied `tag_query` after faceting, with `facet.limit` set to the
+  caller's `limit`. On dati.gov.it 53 tags contain "citta" and none is in the top 100, so
+  the filter answered "no tags" while they existed. The facet is now widened when a filter
+  is given.
+
+`openspec/specs/ckan-search/spec.md` described the parser as a property of
+`ckan_package_search` alone, which is what let the second caller go unnoticed — and after
+yesterday it was also wrong, still describing the per-portal default that was removed.
+Rewritten as a property of the query-building path, naming every tool that shares it.
+
+Also raised the candidate window to at least 50: the local ranking only sees what Solr
+returns first, and `limit: 3` shrank it to 15 — enough when a search returned a handful
+of results, not enough now.
+
+`defibrillatori Comune di Lecce` puts the Lecce dataset first again. 532 tests, 5 added.
+
+How it was missed: yesterday's verification checked result **counts** through
+`ckan_package_search`, never the ranked output of `ckan_find_relevant_datasets` — the
+third most used tool in the telemetry, and the second caller of `resolveSearchQuery`.
+Counting results proves recall, not usefulness.
+
+### v0.4.122 - Solr parser fix
+
+Ships #534: the `text:(...)` wrapper is reserved for the queries dismax cannot serve, the escaping preserves unary operators and balanced grouping, and the parser probe measures two terms taken from the catalog on every portal. `force_text_field` is gone from `portals.json`.
+
+### Solr: wrap only boolean queries, and measure every portal instead of storing a verdict
+
+The usage review surfaced an LLM client reformulating the same request against
+`www.dati.gov.it/opendata` for three hours on 29 July. The data was there from the first
+attempt: `bonifica siti contaminati Piemonte` returns 22 datasets on that portal, the
+Piedmont contaminated-sites registry first. Our `text:(...)` rewrite was returning 5.
+
+`package_search` hands a colon-free query to Solr's dismax parser with `q.op=AND`,
+`mm='2<-1 5<80%'` and `qf='name^4 title^4 tags^2 groups^2 text'` (`ckan/lib/search/query.py`).
+dismax has no boolean syntax, so `A OR B` collapses into `A AND B`: on dati.gov.it
+`aria OR Milano` returns 59, exactly what `aria AND Milano` returns. A colon takes the query
+off dismax, which is what the wrapper exploits — the wrapped form returns 3421. The same
+switch is why it hurts everything else: it drops the `qf` boosts that rank titles and tags
+first, searches the catch-all `text` field alone, and ANDs every term instead of applying
+`mm`. This is CKAN's own default, not a per-portal defect, which is why the same pattern
+showed up on Milano, Toscana, Sicilia, Ucraina and open.canada.ca.
+
+Measured on dati.gov.it: `defibrillatori Comune di Lecce` 678 -> 1, `qualità aria Milano`
+650 -> 51, `musei roma arte opere catalogo` 9 -> 0 — the second most repeated query of the
+semester, answered with an empty page while nine datasets existed. On 40 real queries from
+telemetry the separation is clean: with a boolean operator the wrapper helped 8 times and
+hurt none; without one it helped none and hurt 10, six of them down to zero.
+
+So the wrapper now applies only to queries carrying a boolean operator. The shape that an
+LLM client generates from a user's request — a run of keywords, no operators — is left to
+the portal's own parser, boosts and `mm` included.
+
+`probePortalParser` was rewritten and now runs for every portal, configured ones included;
+`force_text_field` is gone from `portals.json` (8 entries) so there is one source of truth.
+The old probe asked `data OR dati`, two words common enough to saturate: on Milano `data`
+alone and `data OR dati` both return 2564, so it read the portal as healthy while
+`aria OR acqua` returned 0 against 54 and 33 for the single terms. It now picks two terms
+from the catalog itself — single-word tag facets between 0.5% and 30%, falling back to
+frequent title words — and compares `A`, `B`, `A OR B`, `text:(A OR B)`. An OR returning
+fewer hits than either operand is not being honoured, and the wrapper is the answer only if
+the wrapped form returns more. `data.stadt-zuerich.ch`, where the `text` field returns 0 for
+every query, is correctly left alone.
+
+Cost: a plain query pays nothing, since nothing but a boolean query can be wrapped. The
+probe costs 5 extra `rows=0` calls the first time a boolean query reaches a portal in a
+session, then nothing.
+
+Verified e2e against live portals: dati.gov.it 5 -> 22 and 0 -> 9 on the two queries from
+the telemetry, Milano `aria OR acqua` 0 -> 87, Zurich unchanged at 10 and 172. 516 tests
+pass, 18 added.
+
 ### v0.4.121 - clearer 404 on datastore_search_sql
 
 Patch release for the fix in #532: a 404 on `datastore_search_sql` now says the portal does not expose the SQL endpoint, instead of sending the caller to `ckan_package_show` for a resource_id that was already valid. Also ships the telemetry pipeline fixes and the DEPLOYMENT.md/CLAUDE.md realignment from earlier today.

package/dist/index.js

@@ -33,9 +33,6 @@ var portals_default = {
         "https://dati.gov.it",
         "https://www.dati.gov.it"
       ],
-      search: {
-        force_text_field: true
-      },
       hvd: {
         category_field: "hvd_category"
       },
@@ -52,10 +49,7 @@ var portals_default = {
       api_url: "https://dati.arpae.it",
       api_url_aliases: [
         "http://dati.arpae.it"
-      ],
-      search: {
-        force_text_field: true
-      }
+      ]
     },
     {
       id: "anac-opendata",
@@ -77,9 +71,6 @@ var portals_default = {
         "http://www.data.gov.uk"
       ],
       api_path: "/api/action",
-      search: {
-        force_text_field: true
-      },
       dataset_view_url: "https://www.data.gov.uk/dataset/{id}/{name}",
       organization_view_url: "https://www.data.gov.uk/organization/{name}"
     },
@@ -89,10 +80,7 @@ var portals_default = {
       api_url: "https://catalog.data.gov",
       api_url_aliases: [
         "http://catalog.data.gov"
-      ],
-      search: {
-        force_text_field: true
-      }
+      ]
     },
     {
       id: "open-canada",
@@ -102,10 +90,7 @@ var portals_default = {
         "http://open.canada.ca/data",
         "https://open.canada.ca",
         "http://open.canada.ca"
-      ],
-      search: {
-        force_text_field: true
-      }
+      ]
     },
     {
       id: "data-gov-au",
@@ -147,10 +132,7 @@ var portals_default = {
       api_url: "https://data.gov.ua",
       api_url_aliases: [
         "http://data.gov.ua"
-      ],
-      search: {
-        force_text_field: false
-      }
+      ]
     },
     {
       id: "dati-regione-sicilia",
@@ -158,10 +140,7 @@ var portals_default = {
       api_url: "https://dati.regione.sicilia.it",
       api_url_aliases: [
         "http://dati.regione.sicilia.it"
-      ],
-      search: {
-        force_text_field: false
-      }
+      ]
     },
     {
       id: "bdap-rgs-mef",
@@ -190,10 +169,7 @@ var portals_default = {
   ],
   defaults: {
     dataset_view_url: "{server_url}/dataset/{name}",
-    organization_view_url: "{server_url}/organization/{name}",
-    search: {
-      force_text_field: false
-    }
+    organization_view_url: "{server_url}/organization/{name}"
   }
 };
 
@@ -224,10 +200,6 @@ function getPortalSearchConfig(serverUrl) {
     force_text_field: portal?.search?.force_text_field ?? defaults.force_text_field ?? false
   };
 }
-function isPortalSearchExplicitlyConfigured(serverUrl) {
-  const portal = getPortalConfig(serverUrl);
-  return portal?.search?.force_text_field !== void 0;
-}
 function normalizePortalUrl(serverUrl) {
   return normalizeUrl(serverUrl);
 }
@@ -1222,12 +1194,51 @@ function getOrganizationViewUrl(serverUrl, org) {
 // src/utils/search.ts
 var DEFAULT_SEARCH_QUERY = "*:*";
 var FIELD_QUERY_PATTERN = /\b[a-zA-Z_][\w-]*:/;
+var EXPLICIT_BOOL_PATTERN = /\b(AND|OR|NOT)\b|[+\-!]/;
+var BOOL_KEYWORD_PATTERN = /\b(AND|OR|NOT)\b/;
+var INTRAWORD_PUNCT_PATTERN = /\S[+\-!]\S/;
 var SOLR_SPECIAL_CHARS = /[+\-!(){}[\]^~*?:\\/|&]/g;
 function isFieldedQuery(query) {
   return FIELD_QUERY_PATTERN.test(query);
 }
-function escapeSolrQuery(query) {
-  return query.replace(SOLR_SPECIAL_CHARS, "\\$&");
+function hasExplicitBooleanOperator(query) {
+  const trimmed = query.trim();
+  if (BOOL_KEYWORD_PATTERN.test(trimmed)) return true;
+  return INTRAWORD_PUNCT_PATTERN.test(trimmed);
+}
+function mayNeedTextWrapping(query) {
+  const trimmed = query.trim();
+  return trimmed !== DEFAULT_SEARCH_QUERY && !isFieldedQuery(trimmed) && hasExplicitBooleanOperator(trimmed);
+}
+function isEscaped(query, offset) {
+  let backslashes = 0;
+  for (let i = offset - 1; i >= 0 && query[i] === "\\"; i--) backslashes++;
+  return backslashes % 2 === 1;
+}
+function hasBalancedParens(query) {
+  let depth = 0;
+  for (let i = 0; i < query.length; i++) {
+    if (isEscaped(query, i)) continue;
+    if (query[i] === "(") depth++;
+    else if (query[i] === ")" && --depth < 0) return false;
+  }
+  return depth === 0;
+}
+function escapeForTextWrapping(query) {
+  const keepGroups = hasBalancedParens(query);
+  return query.replace(
+    SOLR_SPECIAL_CHARS,
+    (char, offset, whole) => {
+      if (keepGroups && (char === "(" || char === ")") && !isEscaped(whole, offset)) {
+        return char;
+      }
+      const isUnary = char === "+" || char === "-" || char === "!";
+      const previous = offset === 0 ? "" : whole[offset - 1];
+      const atTermStart = offset === 0 || /\s/.test(previous) || keepGroups && previous === "(";
+      const followedByTerm = offset + 1 < whole.length && !/\s/.test(whole[offset + 1]);
+      return isUnary && atTermStart && followedByTerm ? char : `\\${char}`;
+    }
+  );
 }
 function convertDateMathForUnsupportedFields(query) {
   const now = /* @__PURE__ */ new Date();
@@ -1254,7 +1265,6 @@ function convertDateMathForUnsupportedFields(query) {
     return `${field}:[${startIso} TO ${nowIso}]`;
   });
 }
-var EXPLICIT_BOOL_PATTERN = /\b(AND|OR|NOT)\b|[+\-!]/;
 function isPlainMultiTermQuery(query) {
   const trimmed = query.trim();
   if (trimmed === "*:*" || trimmed === "") return false;
@@ -1283,27 +1293,69 @@ function resolveSearchQuery(serverUrl, query, parserOverride) {
     forceTextField = false;
   } else if (portalForce) {
     const trimmedQuery = query.trim();
-    forceTextField = trimmedQuery !== DEFAULT_SEARCH_QUERY && !isFieldedQuery(trimmedQuery);
+    forceTextField = trimmedQuery !== DEFAULT_SEARCH_QUERY && !isFieldedQuery(trimmedQuery) && hasExplicitBooleanOperator(trimmedQuery);
   }
-  let effectiveQuery = forceTextField ? `text:(${escapeSolrQuery(query)})` : query;
+  let effectiveQuery = forceTextField ? `text:(${escapeForTextWrapping(query)})` : query;
   effectiveQuery = convertDateMathForUnsupportedFields(effectiveQuery);
   return { effectiveQuery, forcedTextField: forceTextField };
 }
 
 // src/tools/package.ts
 var _portalParserCache = /* @__PURE__ */ new Map();
+var LITERAL_TERM = /^[\p{L}\p{N}_]+$/u;
+async function pickProbeTerms(serverUrl) {
+  const facetRes = await makeCkanRequest(serverUrl, "package_search", {
+    q: "*:*",
+    rows: 0,
+    "facet.field": '["tags"]',
+    "facet.limit": 100
+  }).catch(() => null);
+  const total = facetRes?.count ?? 0;
+  if (!total) return null;
+  const items = facetRes?.search_facets?.tags?.items ?? [];
+  const usable = items.filter((i) => typeof i.name === "string" && LITERAL_TERM.test(i.name)).filter((i) => (i.count ?? 0) >= total * 5e-3 && (i.count ?? 0) <= total * 0.3).sort((a, b) => (b.count ?? 0) - (a.count ?? 0));
+  if (usable.length >= 2) return [usable[0].name, usable[1].name];
+  const sampleRes = await makeCkanRequest(serverUrl, "package_search", {
+    q: "*:*",
+    rows: 25
+  }).catch(() => null);
+  const titles = (sampleRes?.results ?? []).map((r) => r?.title ?? "");
+  const words = titles.map((t) => new Set(t.toLowerCase().split(/[^\p{L}\p{N}_]+/u).filter((w) => w.length > 4)));
+  const freq = /* @__PURE__ */ new Map();
+  for (const set of words) for (const w of set) freq.set(w, (freq.get(w) ?? 0) + 1);
+  const ranked = [...freq.entries()].filter(([w]) => LITERAL_TERM.test(w)).sort((a, b) => b[1] - a[1]);
+  const first = ranked[0]?.[0];
+  if (!first) return null;
+  const independent = ranked.slice(1).find(([w]) => words.some((set) => set.has(w) && !set.has(first)));
+  const second = independent?.[0] ?? ranked[1]?.[0];
+  return second ? [first, second] : null;
+}
 async function probePortalParser(serverUrl) {
   const key = serverUrl.replace(/\/$/, "").toLowerCase();
   if (_portalParserCache.has(key)) return _portalParserCache.get(key);
-  const probe = "data OR dati";
-  const [defaultRes, textRes] = await Promise.allSettled([
-    makeCkanRequest(serverUrl, "package_search", { q: probe, rows: 0 }),
-    makeCkanRequest(serverUrl, "package_search", { q: `text:(${probe})`, rows: 0 })
-  ]);
-  const defaultCount = defaultRes.status === "fulfilled" ? defaultRes.value.count ?? 0 : 0;
-  const textCount = textRes.status === "fulfilled" ? textRes.value.count ?? 0 : 0;
-  const needsText = textCount > 0 && (defaultCount === 0 || textCount > defaultCount * 2);
-  _portalParserCache.set(key, needsText);
+  const terms = await pickProbeTerms(serverUrl).catch(() => null);
+  if (!terms) return false;
+  let needsText = false;
+  let measured = false;
+  {
+    const [a, b] = terms;
+    const count = async (q) => {
+      const res = await makeCkanRequest(serverUrl, "package_search", { q, rows: 0 }).catch(() => null);
+      return typeof res?.count === "number" ? res.count : null;
+    };
+    const [ca, cb, cOr, cText] = await Promise.all([
+      count(a),
+      count(b),
+      count(`${a} OR ${b}`),
+      count(`text:(${a} OR ${b})`)
+    ]);
+    if (ca !== null && cb !== null && cOr !== null && cText !== null) {
+      const booleanIgnored = cOr < Math.max(ca, cb);
+      needsText = booleanIgnored && cText > cOr;
+      measured = true;
+    }
+  }
+  if (measured) _portalParserCache.set(key, needsText);
   return needsText;
 }
 var DEFAULT_RELEVANCE_WEIGHTS = {
@@ -1315,6 +1367,41 @@ var DEFAULT_RELEVANCE_WEIGHTS = {
   publisher: 2
 };
 var QUERY_STOPWORDS = /* @__PURE__ */ new Set([
+  // Italian: without these, `defibrillatori Comune di Lecce` scored a full holder
+  // match against "Provincia Autonoma di Trento" on the strength of "di" alone.
+  "di",
+  "del",
+  "dello",
+  "della",
+  "dei",
+  "degli",
+  "delle",
+  "il",
+  "lo",
+  "la",
+  "i",
+  "gli",
+  "le",
+  "un",
+  "uno",
+  "una",
+  "e",
+  "ed",
+  "per",
+  "con",
+  "su",
+  "da",
+  "dal",
+  "dalla",
+  "nel",
+  "nella",
+  "al",
+  "alla",
+  "che",
+  "non",
+  "come",
+  "dove",
+  "sono",
   "a",
   "an",
   "the",
@@ -1358,18 +1445,32 @@ var QUERY_STOPWORDS = /* @__PURE__ */ new Set([
   "those"
 ]);
 var extractQueryTerms = (query) => {
-  const matches = query.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
-  const terms = matches.filter((term) => term.length > 1 && !QUERY_STOPWORDS.has(term));
+  const raw = query.normalize("NFC").match(/[\p{L}\p{N}]+/gu) ?? [];
+  const terms = raw.filter((token) => {
+    const term = token.toLowerCase();
+    if (term.length <= 1) return false;
+    if (!QUERY_STOPWORDS.has(term)) return true;
+    return token.length > 1 && token === token.toUpperCase() && token !== term;
+  }).map((token) => token.toLowerCase());
   return Array.from(new Set(terms));
 };
 var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var termPattern = (term) => new RegExp(`(?<![\\p{L}\\p{N}])${escapeRegExp(term.normalize("NFC"))}(?![\\p{L}\\p{N}])`, "iu");
+var normalizeForMatch = (text) => text.normalize("NFC").toLowerCase().replace(/_/g, " ");
 var textMatchesTerms = (text, terms) => {
   if (!text || terms.length === 0) return false;
-  const normalized = text.toLowerCase().replace(/_/g, " ");
-  return terms.some((term) => new RegExp(`\\b${escapeRegExp(term)}\\b`, "i").test(normalized));
+  const normalized = normalizeForMatch(text);
+  return terms.some((term) => termPattern(term).test(normalized));
+};
+var countMatchingTerms = (text, terms) => {
+  if (!text || terms.length === 0) return 0;
+  const normalized = normalizeForMatch(text);
+  return terms.filter((term) => termPattern(term).test(normalized)).length;
 };
 var scoreTextField = (text, terms, weight) => {
-  return textMatchesTerms(text, terms) ? weight : 0;
+  const matched = countMatchingTerms(text, terms);
+  if (matched === 0) return 0;
+  return Math.round(weight * matched / terms.length * 10) / 10;
 };
 var readDcatExtra = (dataset, key) => {
   const extras = Array.isArray(dataset.extras) ? dataset.extras : [];
@@ -1934,7 +2035,7 @@ Typical workflow: ckan_status_show (check locale) \u2192 ckan_package_search (qu
           if (!effectiveSort) effectiveSort = "issued desc, metadata_created desc";
         }
         let parserOverride = params.query_parser;
-        if (!parserOverride && !isPortalSearchExplicitlyConfigured(params.server_url)) {
+        if (!parserOverride && mayNeedTextWrapping(query)) {
           const needsText = await probePortalParser(params.server_url);
           if (needsText) parserOverride = "text";
         }
@@ -1967,7 +2068,10 @@ Typical workflow: ckan_status_show (check locale) \u2192 ckan_package_search (qu
           const { effectiveQuery: strippedEffective } = resolveSearchQuery(
             params.server_url,
             strippedQuery,
-            params.query_parser
+            // parserOverride, not params.query_parser: the probe's verdict must
+            // survive the retry, or an accented boolean query is re-sent to the
+            // parser that ignores booleans.
+            parserOverride
           );
           const fallbackResult = await makeCkanRequest(
             params.server_url,
@@ -2092,7 +2196,7 @@ Note: showing top ${sorted.length} only. Use \`response_format: json\` for full
 `;
           if (isPlainMultiTermQuery(params.q)) {
             markdown += `
-> **Tip**: Multi-term queries use AND by default (all terms must match). Try OR to broaden the search:
+> **Tip**: With several terms the portal requires most of them to match. Spelling out OR broadens the search:
 `;
             markdown += `> \`q: "${buildOrQuery(params.q)}"\`
 `;
@@ -2187,11 +2291,16 @@ Typical workflow: ckan_find_relevant_datasets \u2192 ckan_package_show (inspect
           ...DEFAULT_RELEVANCE_WEIGHTS,
           ...params.weights ?? {}
         };
-        const rows = Math.min(Math.max(params.limit * 5, params.limit), 100);
+        const rows = Math.min(Math.max(params.limit * 5, 50), 100);
+        let parserOverride = params.query_parser;
+        if (!parserOverride && mayNeedTextWrapping(params.query)) {
+          const needsText = await probePortalParser(params.server_url);
+          if (needsText) parserOverride = "text";
+        }
         const { effectiveQuery } = resolveSearchQuery(
           params.server_url,
           params.query,
-          params.query_parser
+          parserOverride
         );
         const searchResult = await makeCkanRequest(
           params.server_url,
@@ -2932,7 +3041,7 @@ Typical workflow: ckan_organization_search \u2192 ckan_organization_show (get de
     },
     async (params) => {
       try {
-        const query = `organization:*${params.pattern.toLowerCase()}*`;
+        const query = `organization:*${stripAccents(params.pattern.toLowerCase())}*`;
         const result = await makeCkanRequest(
           params.server_url,
           "package_search",
@@ -3436,7 +3545,13 @@ Typical workflow: ckan_tag_list \u2192 ckan_package_search with fq="tags:tag_nam
           q: params.q,
           rows: 0,
           "facet.field": JSON.stringify(["tags"]),
-          "facet.limit": params.limit
+          // The filter runs on whatever the facet returned, so with a tag_query the
+          // facet has to be wider than the caller's limit: on dati.gov.it 53 tags
+          // contain "citta" and none is in the top 100, so asking for 100 answered
+          // "no tags" while they existed. CKAN rejects Solr's own `facet.contains`
+          // ("Invalid search parameters"), so the filtering cannot move server-side;
+          // this window is the compromise, and WIDE_FACET below is the escape hatch.
+          "facet.limit": params.tag_query ? Math.max(params.limit * 20, 500) : params.limit
         };
         if (params.fq) apiParams.fq = params.fq;
         const result = await makeCkanRequest(
@@ -3446,8 +3561,18 @@ Typical workflow: ckan_tag_list \u2192 ckan_package_search with fq="tags:tag_nam
         );
         let tags = normalizeTagFacets(result);
         if (params.tag_query) {
-          const needle = params.tag_query.toLowerCase();
-          tags = tags.filter((tag) => tag.name.toLowerCase().includes(needle));
+          const needle = stripAccents(params.tag_query.toLowerCase());
+          const matching = (candidates) => candidates.filter((tag) => stripAccents(tag.name.toLowerCase()).includes(needle));
+          tags = matching(tags);
+          if (tags.length < params.limit) {
+            const wide = await makeCkanRequest(
+              params.server_url,
+              "package_search",
+              { ...apiParams, "facet.limit": -1 }
+            );
+            tags = matching(normalizeTagFacets(wide));
+          }
+          tags = tags.sort((a, b) => b.count - a.count).slice(0, params.limit);
         }
         tags = tags.sort((a, b) => b.count - a.count || a.name.localeCompare(b.name)).slice(0, params.limit);
         if (params.response_format === "json" /* JSON */) {
@@ -5802,7 +5927,7 @@ var registerAllPrompts = (server) => {
 function createServer() {
   return new McpServer({
     name: "ckan-mcp-server",
-    version: "0.4.121"
+    version: "0.4.123"
   });
 }
 function registerAll(server) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aborruso/ckan-mcp-server",
-  "version": "0.4.121",
+  "version": "0.4.123",
   "mcpName": "io.github.aborruso/ckan-mcp-server",
   "description": "MCP server for interacting with CKAN open data portals",
   "repository": {