mcp-chilegob-dataset 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Gerard Bourguett
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,262 @@
+# mcp-chilegob-dataset
+
+Servidor MCP que expone el portal de datos abiertos del gobierno de Chile — [datos.gob.cl](https://datos.gob.cl) — como herramientas para asistentes de inteligencia artificial.
+
+Construido con [Hono](https://hono.dev) y el [SDK de TypeScript del Model Context Protocol](https://github.com/modelcontextprotocol/typescript-sdk).
+
+---
+
+## ¿Qué es MCP?
+
+El **Model Context Protocol (MCP)** es un estándar abierto que permite a los asistentes de IA (Claude, etc.) conectarse a herramientas y fuentes de datos externas de manera estructurada y segura. En lugar de copiar datos crudos en una conversación, el asistente llama a una herramienta y recibe resultados estructurados.
+
+## ¿Qué es datos.gob.cl?
+
+[datos.gob.cl](https://datos.gob.cl) es el portal oficial de datos abiertos del gobierno de Chile, impulsado por [CKAN](https://ckan.org). Contiene miles de datasets públicos de instituciones gubernamentales — salud, educación, transporte, medio ambiente, y más. Todos los datos son de acceso público, sin registro ni autenticación.
+
+---
+
+## Instalación y uso rápido
+
+### Con Claude Desktop (recomendado)
+
+**Paso 1** — Abrí la configuración de Claude Desktop.
+
+En Mac: `~/Library/Application Support/Claude/claude_desktop_config.json`
+En Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+
+**Paso 2** — Agregá estas líneas:
+
+```json
+{
+  "mcpServers": {
+    "chilegob": {
+      "command": "npx",
+      "args": ["-y", "mcp-chilegob-dataset"]
+    }
+  }
+}
+```
+
+**Paso 3** — Reiniciá Claude Desktop. La primera vez descarga el paquete automáticamente.
+
+Eso es todo. Podés pedirle a Claude cosas como:
+
+> *"Buscá datasets sobre educación en datos.gob.cl"*
+> *"Mostrá los datos del dataset de matrícula universitaria"*
+> *"¿Qué datasets de salud hay disponibles?"*
+
+---
+
+## Herramientas disponibles
+
+Este servidor expone tres herramientas que el asistente puede usar automáticamente.
+
+### `search_datasets`
+
+Busca datasets en datos.gob.cl por palabra clave. Devuelve una lista resumida.
+
+**Parámetros:**
+
+| Nombre | Tipo | Requerido | Por defecto | Descripción |
+|--------|------|-----------|-------------|-------------|
+| `query` | string | ✅ | — | Texto de búsqueda (en español o inglés) |
+| `limit` | number | ❌ | 10 | Máximo de resultados (1–100) |
+
+**Ejemplo de respuesta:**
+
+```json
+[
+  {
+    "id": "matricula-en-educacion-superior",
+    "title": "Matrícula en Educación Superior",
+    "description": "Bases de datos de matrícula en el sistema de educación superior...",
+    "organization": "Subsecretaría de Educación",
+    "resource_count": 1
+  }
+]
+```
+
+---
+
+### `get_dataset`
+
+Obtiene los metadatos completos de un dataset: descripción, recursos, etiquetas y licencia.
+
+**Parámetros:**
+
+| Nombre | Tipo | Requerido | Descripción |
+|--------|------|-----------|-------------|
+| `id` | string | ✅ | Slug o UUID del dataset (obtenido de `search_datasets`) |
+
+**Ejemplo de respuesta:**
+
+```json
+{
+  "id": "matricula-en-educacion-superior",
+  "title": "Matrícula en Educación Superior",
+  "organization": "Subsecretaría de Educación",
+  "license": "Creative Commons Non-Commercial (Any)",
+  "tags": ["educación", "educación superior", "matriculas"],
+  "resources": [
+    {
+      "id": "37377aff-6df8-4424-9228-2f44f3e67fcd",
+      "name": "Base de datos de matrícula",
+      "format": "CSV",
+      "url": "https://datosabiertos.mineduc.cl/...",
+      "datastore_available": true
+    }
+  ]
+}
+```
+
+> Verificá el campo `datastore_available` antes de usar `get_resource_data`. Los recursos sin datastore deben descargarse desde su `url`.
+
+---
+
+### `get_resource_data`
+
+Lee filas tabulares de un recurso con el datastore CKAN habilitado. Soporta paginación.
+
+**Parámetros:**
+
+| Nombre | Tipo | Requerido | Por defecto | Descripción |
+|--------|------|-----------|-------------|-------------|
+| `resource_id` | string | ✅ | — | UUID del recurso (obtenido de `get_dataset`) |
+| `limit` | number | ❌ | 50 | Filas a devolver (1–500) |
+| `offset` | number | ❌ | 0 | Desplazamiento para paginación |
+
+**Ejemplo de respuesta:**
+
+```json
+{
+  "total": 42,
+  "returned": 3,
+  "offset": 0,
+  "fields": [
+    { "id": "Region", "type": "text" },
+    { "id": "Provincia", "type": "text" },
+    { "id": "Comuna", "type": "text" }
+  ],
+  "records": [
+    { "Region": "COQUIMBO", "Provincia": "ELQUI", "Comuna": "LA SERENA" }
+  ]
+}
+```
+
+> Si el recurso no tiene datastore habilitado, la herramienta devuelve un mensaje descriptivo indicando cómo acceder al archivo directamente.
+
+---
+
+## Para desarrolladores
+
+### Requisitos
+
+- **Node.js 20 o superior**
+- **npm**
+
+### Instalación desde el código fuente
+
+```bash
+git clone https://github.com/gerardbourguett/mcp-chilegob-dataset.git
+cd mcp-chilegob-dataset
+npm install
+```
+
+### Scripts disponibles
+
+| Comando | Descripción |
+|---------|-------------|
+| `npm run dev` | Inicia el servidor HTTP en `http://localhost:3000/mcp` con recarga automática |
+| `npm run build` | Compila TypeScript a `dist/` |
+| `npm start` | Inicia el servidor HTTP desde `dist/` |
+| `npm run typecheck` | Verifica tipos sin compilar |
+
+### Probar localmente (MCP Inspector)
+
+Con el servidor corriendo (`npm run dev`), abrí otra terminal y ejecutá:
+
+```bash
+npx @modelcontextprotocol/inspector
+```
+
+Se abre una interfaz web en `http://localhost:6274`. Configurá:
+- **Transport type**: `Streamable HTTP`
+- **URL**: `http://localhost:3000/mcp`
+
+Desde ahí podés llamar a cualquier herramienta de forma interactiva y ver las respuestas.
+
+### Arquitectura
+
+```
+Cliente AI  →  Hono HTTP  →  McpServer  →  CKAN API v3 (datos.gob.cl)
+```
+
+```
+src/
+├── index.ts        # Servidor HTTP (para desarrollo y despliegue remoto)
+├── stdio.ts        # Transporte stdio (para npx y Claude Desktop)
+├── server.ts       # Instancia McpServer + registro de herramientas
+├── ckan.ts         # Cliente tipado para la API CKAN v3
+└── tools/
+    ├── search.ts   # search_datasets
+    ├── dataset.ts  # get_dataset
+    └── resource.ts # get_resource_data
+```
+
+### Cómo agregar nuevas herramientas
+
+1. Creá `src/tools/tu-herramienta.ts`
+2. Importala y registrala en `src/server.ts`
+
+```typescript
+// src/tools/tu-herramienta.ts
+import type { McpServer } from '@modelcontextprotocol/server'
+import { z } from 'zod'
+
+export function registerTuHerramienta(server: McpServer): void {
+  server.registerTool(
+    'nombre_herramienta',
+    {
+      title: 'Nombre visible en el cliente',
+      description: 'Descripción clara. El asistente la usa para decidir cuándo llamar esta herramienta.',
+      inputSchema: z.object({
+        parametro: z.string().describe('Descripción del parámetro'),
+      }),
+    },
+    async ({ parametro }) => {
+      // tu lógica acá
+      return {
+        content: [{ type: 'text', text: JSON.stringify({ resultado: parametro }) }],
+      }
+    }
+  )
+}
+```
+
+---
+
+## Limitaciones conocidas
+
+- **Disponibilidad del datastore** — No todos los recursos tienen datastore habilitado en CKAN. Los archivos (CSV, XLS, PDF) deben descargarse desde su URL directa.
+- **Sin caché** — Cada llamada hace una solicitud en vivo a datos.gob.cl. No hay límites de tasa documentados.
+- **Paquetes en alpha** — `@modelcontextprotocol/hono` y `@modelcontextprotocol/server` están en versión alpha.
+
+---
+
+## Contribuciones
+
+Las contribuciones son bienvenidas. Algunas ideas:
+
+- [ ] Herramienta `list_organizations` — listar instituciones disponibles
+- [ ] Herramienta `get_resource_schema` — tipos y descripciones de columnas
+- [ ] Caché en memoria para reducir llamadas a la API
+- [ ] MCP Resources con URI templates (`datos-gob-cl://dataset/{id}`)
+
+Por favor, abrí un issue antes de enviar un PR grande.
+
+---
+
+## Licencia
+
+MIT — ver [LICENSE](./LICENSE).

package/dist/ckan.js

@@ -0,0 +1,30 @@
+const CKAN_BASE = 'https://datos.gob.cl/api/3/action';
+async function ckanAction(action, params) {
+    const url = new URL(`${CKAN_BASE}/${action}`);
+    for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, String(value));
+    }
+    const response = await fetch(url.toString());
+    if (!response.ok) {
+        throw new Error(`CKAN API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!data.success) {
+        throw new Error(`CKAN error: ${data.error?.message ?? 'Unknown error'}`);
+    }
+    return data.result;
+}
+export async function searchDatasets(query, limit = 10) {
+    const result = await ckanAction('package_search', { q: query, rows: limit });
+    return result.results;
+}
+export async function getDataset(id) {
+    return ckanAction('package_show', { id });
+}
+export async function getResourceData(resourceId, limit = 50, offset = 0) {
+    return ckanAction('datastore_search', {
+        resource_id: resourceId,
+        limit,
+        offset,
+    });
+}

package/dist/index.js

@@ -0,0 +1,13 @@
+import { serve } from '@hono/node-server';
+import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/server';
+import { createMcpHonoApp } from '@modelcontextprotocol/hono';
+import { server } from './server.js';
+const transport = new WebStandardStreamableHTTPServerTransport({
+    sessionIdGenerator: undefined,
+});
+await server.connect(transport);
+const app = createMcpHonoApp();
+app.all('/mcp', c => transport.handleRequest(c.req.raw, { parsedBody: c.get('parsedBody') }));
+serve({ fetch: app.fetch, port: 3000 }, info => {
+    console.log(`MCP server running on http://localhost:${info.port}/mcp`);
+});

package/dist/server.js

@@ -0,0 +1,11 @@
+import { McpServer } from '@modelcontextprotocol/server';
+import { registerSearchTool } from './tools/search.js';
+import { registerDatasetTool } from './tools/dataset.js';
+import { registerResourceTool } from './tools/resource.js';
+export const server = new McpServer({
+    name: 'datos-gob-cl',
+    version: '1.0.0',
+});
+registerSearchTool(server);
+registerDatasetTool(server);
+registerResourceTool(server);

package/dist/stdio.js

@@ -0,0 +1,4 @@
+import { StdioServerTransport } from '@modelcontextprotocol/server';
+import { server } from './server.js';
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/tools/dataset.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { getDataset } from '../ckan.js';
+export function registerDatasetTool(server) {
+    server.registerTool('get_dataset', {
+        title: 'Get Dataset',
+        description: 'Get full metadata for a dataset from datos.gob.cl by its ID or slug. Use search_datasets first to find the ID.',
+        inputSchema: z.object({
+            id: z.string().describe('Dataset slug or UUID (e.g., "nombre-del-dataset" or a UUID from search results)'),
+        }),
+    }, async ({ id }) => {
+        try {
+            const dataset = await getDataset(id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            id: dataset.name,
+                            title: dataset.title,
+                            description: dataset.notes,
+                            organization: dataset.organization?.title ?? null,
+                            license: dataset.license_title,
+                            tags: dataset.tags.map(t => t.name),
+                            resources: dataset.resources.map(r => ({
+                                id: r.id,
+                                name: r.name,
+                                format: r.format,
+                                url: r.url,
+                                datastore_available: r.datastore_active,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const isNotFound = message.toLowerCase().includes('not found');
+            return {
+                content: [{ type: 'text', text: isNotFound ? `Dataset not found: ${id}` : `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/resource.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { getResourceData } from '../ckan.js';
+export function registerResourceTool(server) {
+    server.registerTool('get_resource_data', {
+        title: 'Get Resource Data',
+        description: 'Read tabular data from a CKAN resource. Only works for resources with datastore enabled (check datastore_available from get_dataset). Supports pagination via limit and offset.',
+        inputSchema: z.object({
+            resource_id: z.string().describe('Resource UUID from a dataset\'s resources list (use get_dataset to obtain it)'),
+            limit: z.number().int().min(1).max(500).default(50).optional().describe('Rows to return (default: 50, max: 500)'),
+            offset: z.number().int().min(0).default(0).optional().describe('Row offset for pagination (default: 0)'),
+        }),
+    }, async ({ resource_id, limit, offset }) => {
+        try {
+            const result = await getResourceData(resource_id, limit ?? 50, offset ?? 0);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            total: result.total,
+                            returned: result.records.length,
+                            offset: offset ?? 0,
+                            fields: result.fields,
+                            records: result.records,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const isNoDatastore = message.toLowerCase().includes('datastore') || message.includes('404') || message.includes('NOT FOUND');
+            return {
+                content: [{
+                        type: 'text',
+                        text: isNoDatastore
+                            ? `Datastore not available for resource "${resource_id}". This resource may be a file (CSV, XLS, PDF) without an activated datastore. Use the resource URL from get_dataset to download it directly.`
+                            : `Error: ${message}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/search.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { searchDatasets } from '../ckan.js';
+export function registerSearchTool(server) {
+    server.registerTool('search_datasets', {
+        title: 'Search Datasets',
+        description: 'Search for datasets in the Chilean government open data portal (datos.gob.cl). Returns a list of matching datasets with their IDs, titles, and resource counts.',
+        inputSchema: z.object({
+            query: z.string().describe('Search query in Spanish or English (e.g., "educación", "salud", "transporte")'),
+            limit: z.number().int().min(1).max(100).default(10).optional().describe('Max number of results (default: 10, max: 100)'),
+        }),
+    }, async ({ query, limit }) => {
+        try {
+            const datasets = await searchDatasets(query, limit ?? 10);
+            const formatted = datasets.map(d => ({
+                id: d.name,
+                title: d.title,
+                description: d.notes?.slice(0, 200) ?? '',
+                organization: d.organization?.title ?? 'N/A',
+                resource_count: d.num_resources,
+            }));
+            return {
+                content: [{ type: 'text', text: JSON.stringify(formatted, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
+    });
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "mcp-chilegob-dataset",
+  "version": "0.1.0",
+  "description": "MCP server exposing Chile's open government dataset portal (datos.gob.cl / CKAN API v3)",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gerardbourguett/mcp-chilegob-dataset.git"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "chile",
+    "open-data",
+    "datos-gob-cl",
+    "ckan",
+    "hono"
+  ],
+  "bin": {
+    "mcp-chilegob-dataset": "./dist/stdio.js"
+  },
+  "files": [
+    "dist/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "tsc"
+  },
+  "dependencies": {
+    "@cfworker/json-schema": "^4.1.1",
+    "@hono/node-server": "^1.19.13",
+    "@modelcontextprotocol/hono": "^2.0.0-alpha.2",
+    "@modelcontextprotocol/server": "^2.0.0-alpha.2",
+    "hono": "^4.12.12",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.17",
+    "tsx": "^4.7.1",
+    "typescript": "^5.8.3"
+  }
+}

package/src/ckan.ts

@@ -0,0 +1,67 @@
+const CKAN_BASE = 'https://datos.gob.cl/api/3/action'
+
+export interface CkanDataset {
+  id: string
+  name: string
+  title: string
+  notes: string
+  organization: { title: string } | null
+  resources: CkanResource[]
+  tags: { name: string }[]
+  license_title: string
+  num_resources: number
+}
+
+export interface CkanResource {
+  id: string
+  name: string
+  format: string
+  url: string
+  datastore_active: boolean
+}
+
+export interface CkanDatastoreResult {
+  fields: { id: string; type: string }[]
+  records: Record<string, unknown>[]
+  total: number
+}
+
+async function ckanAction<T>(action: string, params: Record<string, unknown>): Promise<T> {
+  const url = new URL(`${CKAN_BASE}/${action}`)
+  for (const [key, value] of Object.entries(params)) {
+    url.searchParams.set(key, String(value))
+  }
+
+  const response = await fetch(url.toString())
+  if (!response.ok) {
+    throw new Error(`CKAN API error: ${response.status} ${response.statusText}`)
+  }
+
+  const data = await response.json() as { success: boolean; result: T; error?: { message: string } }
+  if (!data.success) {
+    throw new Error(`CKAN error: ${data.error?.message ?? 'Unknown error'}`)
+  }
+
+  return data.result
+}
+
+export async function searchDatasets(query: string, limit: number = 10): Promise<CkanDataset[]> {
+  const result = await ckanAction<{ results: CkanDataset[] }>('package_search', { q: query, rows: limit })
+  return result.results
+}
+
+export async function getDataset(id: string): Promise<CkanDataset> {
+  return ckanAction<CkanDataset>('package_show', { id })
+}
+
+export async function getResourceData(
+  resourceId: string,
+  limit: number = 50,
+  offset: number = 0
+): Promise<CkanDatastoreResult> {
+  return ckanAction<CkanDatastoreResult>('datastore_search', {
+    resource_id: resourceId,
+    limit,
+    offset,
+  })
+}

package/src/index.ts

@@ -0,0 +1,19 @@
+import { serve } from '@hono/node-server'
+import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/server'
+import { createMcpHonoApp } from '@modelcontextprotocol/hono'
+import type { Hono } from 'hono'
+import { server } from './server.js'
+
+const transport = new WebStandardStreamableHTTPServerTransport({
+  sessionIdGenerator: undefined,
+})
+
+await server.connect(transport)
+
+type McpVars = { Variables: { parsedBody: unknown } }
+const app = createMcpHonoApp() as unknown as Hono<McpVars>
+app.all('/mcp', c => transport.handleRequest(c.req.raw, { parsedBody: c.get('parsedBody') }))
+
+serve({ fetch: app.fetch, port: 3000 }, info => {
+  console.log(`MCP server running on http://localhost:${info.port}/mcp`)
+})

package/src/server.ts

@@ -0,0 +1,13 @@
+import { McpServer } from '@modelcontextprotocol/server'
+import { registerSearchTool } from './tools/search.js'
+import { registerDatasetTool } from './tools/dataset.js'
+import { registerResourceTool } from './tools/resource.js'
+
+export const server = new McpServer({
+  name: 'datos-gob-cl',
+  version: '1.0.0',
+})
+
+registerSearchTool(server)
+registerDatasetTool(server)
+registerResourceTool(server)

package/src/stdio.ts

@@ -0,0 +1,5 @@
+import { StdioServerTransport } from '@modelcontextprotocol/server'
+import { server } from './server.js'
+
+const transport = new StdioServerTransport()
+await server.connect(transport)

package/src/tools/dataset.ts

@@ -0,0 +1,48 @@
+import type { McpServer } from '@modelcontextprotocol/server'
+import { z } from 'zod'
+import { getDataset } from '../ckan.js'
+
+export function registerDatasetTool(server: McpServer): void {
+  server.registerTool(
+    'get_dataset',
+    {
+      title: 'Get Dataset',
+      description: 'Get full metadata for a dataset from datos.gob.cl by its ID or slug. Use search_datasets first to find the ID.',
+      inputSchema: z.object({
+        id: z.string().describe('Dataset slug or UUID (e.g., "nombre-del-dataset" or a UUID from search results)'),
+      }),
+    },
+    async ({ id }) => {
+      try {
+        const dataset = await getDataset(id)
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              id: dataset.name,
+              title: dataset.title,
+              description: dataset.notes,
+              organization: dataset.organization?.title ?? null,
+              license: dataset.license_title,
+              tags: dataset.tags.map(t => t.name),
+              resources: dataset.resources.map(r => ({
+                id: r.id,
+                name: r.name,
+                format: r.format,
+                url: r.url,
+                datastore_available: r.datastore_active,
+              })),
+            }, null, 2),
+          }],
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        const isNotFound = message.toLowerCase().includes('not found')
+        return {
+          content: [{ type: 'text', text: isNotFound ? `Dataset not found: ${id}` : `Error: ${message}` }],
+          isError: true,
+        }
+      }
+    }
+  )
+}

package/src/tools/resource.ts

@@ -0,0 +1,47 @@
+import type { McpServer } from '@modelcontextprotocol/server'
+import { z } from 'zod'
+import { getResourceData } from '../ckan.js'
+
+export function registerResourceTool(server: McpServer): void {
+  server.registerTool(
+    'get_resource_data',
+    {
+      title: 'Get Resource Data',
+      description: 'Read tabular data from a CKAN resource. Only works for resources with datastore enabled (check datastore_available from get_dataset). Supports pagination via limit and offset.',
+      inputSchema: z.object({
+        resource_id: z.string().describe('Resource UUID from a dataset\'s resources list (use get_dataset to obtain it)'),
+        limit: z.number().int().min(1).max(500).default(50).optional().describe('Rows to return (default: 50, max: 500)'),
+        offset: z.number().int().min(0).default(0).optional().describe('Row offset for pagination (default: 0)'),
+      }),
+    },
+    async ({ resource_id, limit, offset }) => {
+      try {
+        const result = await getResourceData(resource_id, limit ?? 50, offset ?? 0)
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              total: result.total,
+              returned: result.records.length,
+              offset: offset ?? 0,
+              fields: result.fields,
+              records: result.records,
+            }, null, 2),
+          }],
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        const isNoDatastore = message.toLowerCase().includes('datastore') || message.includes('404') || message.includes('NOT FOUND')
+        return {
+          content: [{
+            type: 'text',
+            text: isNoDatastore
+              ? `Datastore not available for resource "${resource_id}". This resource may be a file (CSV, XLS, PDF) without an activated datastore. Use the resource URL from get_dataset to download it directly.`
+              : `Error: ${message}`,
+          }],
+          isError: true,
+        }
+      }
+    }
+  )
+}

package/src/tools/search.ts

@@ -0,0 +1,37 @@
+import type { McpServer } from '@modelcontextprotocol/server'
+import { z } from 'zod'
+import { searchDatasets } from '../ckan.js'
+
+export function registerSearchTool(server: McpServer): void {
+  server.registerTool(
+    'search_datasets',
+    {
+      title: 'Search Datasets',
+      description: 'Search for datasets in the Chilean government open data portal (datos.gob.cl). Returns a list of matching datasets with their IDs, titles, and resource counts.',
+      inputSchema: z.object({
+        query: z.string().describe('Search query in Spanish or English (e.g., "educación", "salud", "transporte")'),
+        limit: z.number().int().min(1).max(100).default(10).optional().describe('Max number of results (default: 10, max: 100)'),
+      }),
+    },
+    async ({ query, limit }) => {
+      try {
+        const datasets = await searchDatasets(query, limit ?? 10)
+        const formatted = datasets.map(d => ({
+          id: d.name,
+          title: d.title,
+          description: d.notes?.slice(0, 200) ?? '',
+          organization: d.organization?.title ?? 'N/A',
+          resource_count: d.num_resources,
+        }))
+        return {
+          content: [{ type: 'text', text: JSON.stringify(formatted, null, 2) }],
+        }
+      } catch (error) {
+        return {
+          content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true,
+        }
+      }
+    }
+  )
+}