@ansvar/ch-organic-regen-mcp 0.1.0

package/src/server.ts

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { createDatabase } from './db.js';
+import { handleAbout } from './tools/about.js';
+import { handleListSources } from './tools/list-sources.js';
+import { handleCheckFreshness } from './tools/check-freshness.js';
+import { handleSearchOrganicRules } from './tools/search-organic-rules.js';
+import { handleGetConversionRequirements } from './tools/get-conversion-requirements.js';
+import { handleGetOrganicStandards } from './tools/get-organic-standards.js';
+import { handleGetApprovedInputs } from './tools/get-approved-inputs.js';
+import { handleGetOrganicSubsidies } from './tools/get-organic-subsidies.js';
+import { handleGetSoilHealthGuidance } from './tools/get-soil-health-guidance.js';
+import { handleSearchCertificationGuidance } from './tools/search-certification-guidance.js';
+
+const SERVER_NAME = 'ch-organic-regen-mcp';
+const SERVER_VERSION = '0.1.0';
+
+const TOOLS = [
+  {
+    name: 'about',
+    description: 'Get server metadata: name, version, coverage, data sources, and links.',
+    inputSchema: { type: 'object' as const, properties: {} },
+  },
+  {
+    name: 'list_sources',
+    description: 'List all data sources with authority, URL, license, and freshness info.',
+    inputSchema: { type: 'object' as const, properties: {} },
+  },
+  {
+    name: 'check_data_freshness',
+    description: 'Check when data was last ingested, staleness status, and how to trigger a refresh.',
+    inputSchema: { type: 'object' as const, properties: {} },
+  },
+  {
+    name: 'search_organic_rules',
+    description:
+      'Volltextsuche ueber Bio-Richtlinien, Umstellung, Bodenfruchtbarkeit und regenerative Landwirtschaft. ' +
+      'Search organic farming rules, conversion guidance, soil health, and regenerative agriculture topics.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: { type: 'string', description: 'Suchbegriff / free-text search query (German or English)' },
+        topic: { type: 'string', description: 'Filter by topic (e.g. knospe, demeter, umstellung, bodenfruchtbarkeit)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+        limit: { type: 'number', description: 'Max results (default: 20, max: 50)' },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'get_conversion_requirements',
+    description:
+      'Umstellungsanforderungen fuer den Biobetrieb: Zeitrahmen, Voraussetzungen, Unterstuetzungsmassnahmen. ' +
+      'Get organic conversion timeline, requirements, and support measures by farm type.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        farm_type: { type: 'string', description: 'Betriebstyp (e.g. ackerbau, milchwirtschaft, obstbau, rebbau, gemuese)' },
+        current_system: { type: 'string', description: 'Aktuelles System (e.g. oeln, konventionell, ip)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'get_organic_standards',
+    description:
+      'Bio-Richtlinien nach Standard (Knospe, Bio-Verordnung, Demeter) und Produktionsbereich. ' +
+      'Get organic production rules comparing Bio Suisse Knospe, federal Bio-Verordnung, and Demeter standards.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        production_type: { type: 'string', description: 'Produktionsbereich (e.g. tierhaltung, pflanzenbau, verarbeitung, futtermittel)' },
+        standard: { type: 'string', description: 'Standard: bio_verordnung, knospe, demeter' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'get_approved_inputs',
+    description:
+      'Zugelassene Betriebsmittel fuer Biolandbau (FiBL-Liste): Duenger, Pflanzenschutz, Futtermittel. ' +
+      'Get approved inputs for organic farming from the FiBL Betriebsmittelliste.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        input_type: { type: 'string', description: 'Betriebsmitteltyp: duenger, pflanzenschutz, futtermittel' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'get_organic_subsidies',
+    description:
+      'Bio-Beitrag und weitere Direktzahlungen fuer Biobetriebe: Beitragshoehe, Bedingungen, Kumulierung. ' +
+      'Get organic farming subsidies (Bio-Beitrag) rates, conditions, and stacking rules.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        subsidy_type: { type: 'string', description: 'Beitragstyp (e.g. bio_beitrag, extenso, bff, tierwohl)' },
+        zone: { type: 'string', description: 'Zone: talzone, huegelzone, bergzone_i, bergzone_ii, bergzone_iii, bergzone_iv' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'get_soil_health_guidance',
+    description:
+      'Bodenfruchtbarkeit und regenerative Methoden: Kompost, Gruenduengung, Fruchtfolge, Conservation Agriculture. ' +
+      'Get soil health and regenerative agriculture guidance: composting, cover crops, rotation, agroforestry.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        topic: { type: 'string', description: 'Thema (e.g. kompost, gruenduengung, fruchtfolge, agroforstwirtschaft, untersaat, direktsaat)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'search_certification_guidance',
+    description:
+      'Zertifizierungsprozess Bio Suisse Knospe: Schritte, Inspektionsstellen, Kosten, Haeufigkeit. ' +
+      'Search organic certification guidance: bio.inspecta, Bio Test Agro process, Knospe application steps.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: { type: 'string', description: 'Suchbegriff (e.g. anmeldung, kontrolle, kosten, inspektion)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['query'],
+    },
+  },
+];
+
+const SearchOrganicRulesSchema = z.object({
+  query: z.string(),
+  topic: z.string().optional(),
+  jurisdiction: z.string().optional(),
+  limit: z.number().optional(),
+});
+
+const ConversionArgsSchema = z.object({
+  farm_type: z.string().optional(),
+  current_system: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const StandardsArgsSchema = z.object({
+  production_type: z.string().optional(),
+  standard: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const InputsArgsSchema = z.object({
+  input_type: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const SubsidiesArgsSchema = z.object({
+  subsidy_type: z.string().optional(),
+  zone: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const SoilHealthArgsSchema = z.object({
+  topic: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const CertArgsSchema = z.object({
+  query: z.string(),
+  jurisdiction: z.string().optional(),
+});
+
+function textResult(data: unknown) {
+  return { content: [{ type: 'text' as const, text: JSON.stringify(data, null, 2) }] };
+}
+
+function errorResult(message: string) {
+  return { content: [{ type: 'text' as const, text: JSON.stringify({ error: message }) }], isError: true };
+}
+
+const db = createDatabase();
+
+const server = new Server(
+  { name: SERVER_NAME, version: SERVER_VERSION },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args = {} } = request.params;
+
+  try {
+    switch (name) {
+      case 'about':
+        return textResult(handleAbout());
+      case 'list_sources':
+        return textResult(handleListSources(db));
+      case 'check_data_freshness':
+        return textResult(handleCheckFreshness(db));
+      case 'search_organic_rules':
+        return textResult(handleSearchOrganicRules(db, SearchOrganicRulesSchema.parse(args)));
+      case 'get_conversion_requirements':
+        return textResult(handleGetConversionRequirements(db, ConversionArgsSchema.parse(args)));
+      case 'get_organic_standards':
+        return textResult(handleGetOrganicStandards(db, StandardsArgsSchema.parse(args)));
+      case 'get_approved_inputs':
+        return textResult(handleGetApprovedInputs(db, InputsArgsSchema.parse(args)));
+      case 'get_organic_subsidies':
+        return textResult(handleGetOrganicSubsidies(db, SubsidiesArgsSchema.parse(args)));
+      case 'get_soil_health_guidance':
+        return textResult(handleGetSoilHealthGuidance(db, SoilHealthArgsSchema.parse(args)));
+      case 'search_certification_guidance':
+        return textResult(handleSearchCertificationGuidance(db, CertArgsSchema.parse(args)));
+      default:
+        return errorResult(`Unknown tool: ${name}`);
+    }
+  } catch (err) {
+    return errorResult(err instanceof Error ? err.message : String(err));
+  }
+});
+
+async function main(): Promise<void> {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  process.stderr.write(`Fatal error: ${err.message}\n`);
+  process.exit(1);
+});

package/src/tools/about.ts

@@ -0,0 +1,28 @@
+import { buildMeta } from '../metadata.js';
+import { SUPPORTED_JURISDICTIONS } from '../jurisdiction.js';
+
+export function handleAbout() {
+  return {
+    name: 'Switzerland Organic & Regenerative Farming MCP',
+    description:
+      'Swiss organic and regenerative agriculture data: Bio Suisse Knospe standards, Bio-Verordnung (SR 910.18), ' +
+      'Demeter biodynamic rules, FiBL Betriebsmittelliste (approved inputs), conversion requirements, ' +
+      'organic subsidies (Bio-Beitrag), soil health guidance, and certification processes (bio.inspecta, Bio Test Agro).',
+    version: '0.1.0',
+    jurisdiction: [...SUPPORTED_JURISDICTIONS],
+    data_sources: [
+      'Bio Suisse Richtlinien (Knospe)',
+      'Bio-Verordnung SR 910.18 (BLW)',
+      'FiBL Betriebsmittelliste',
+      'Demeter Schweiz Richtlinien',
+      'AGRIDEA Umstellungsberatung',
+    ],
+    tools_count: 10,
+    links: {
+      homepage: 'https://ansvar.eu/open-agriculture',
+      repository: 'https://github.com/ansvar-systems/ch-organic-regen-mcp',
+      mcp_network: 'https://ansvar.ai/mcp',
+    },
+    _meta: buildMeta(),
+  };
+}

package/src/tools/check-freshness.ts

@@ -0,0 +1,42 @@
+import { buildMeta } from '../metadata.js';
+import type { Database } from '../db.js';
+
+interface FreshnessResult {
+  status: 'fresh' | 'stale' | 'unknown';
+  last_ingest: string | null;
+  build_date: string | null;
+  schema_version: string | null;
+  days_since_ingest: number | null;
+  staleness_threshold_days: number;
+  refresh_command: string;
+  _meta: ReturnType<typeof buildMeta>;
+}
+
+const STALENESS_THRESHOLD_DAYS = 90;
+
+export function handleCheckFreshness(db: Database): FreshnessResult {
+  const lastIngest = db.get<{ value: string }>('SELECT value FROM db_metadata WHERE key = ?', ['last_ingest']);
+  const buildDate = db.get<{ value: string }>('SELECT value FROM db_metadata WHERE key = ?', ['build_date']);
+  const schemaVersion = db.get<{ value: string }>('SELECT value FROM db_metadata WHERE key = ?', ['schema_version']);
+
+  let status: 'fresh' | 'stale' | 'unknown' = 'unknown';
+  let daysSinceIngest: number | null = null;
+
+  if (lastIngest?.value) {
+    const ingestDate = new Date(lastIngest.value);
+    const now = new Date();
+    daysSinceIngest = Math.floor((now.getTime() - ingestDate.getTime()) / (1000 * 60 * 60 * 24));
+    status = daysSinceIngest <= STALENESS_THRESHOLD_DAYS ? 'fresh' : 'stale';
+  }
+
+  return {
+    status,
+    last_ingest: lastIngest?.value ?? null,
+    build_date: buildDate?.value ?? null,
+    schema_version: schemaVersion?.value ?? null,
+    days_since_ingest: daysSinceIngest,
+    staleness_threshold_days: STALENESS_THRESHOLD_DAYS,
+    refresh_command: 'gh workflow run ingest.yml -R ansvar-systems/ch-organic-regen-mcp',
+    _meta: buildMeta(),
+  };
+}

package/src/tools/get-approved-inputs.ts

@@ -0,0 +1,44 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface InputsArgs {
+  input_type?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetApprovedInputs(db: Database, args: InputsArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT * FROM approved_inputs WHERE jurisdiction = ?';
+  const params: unknown[] = [jv.jurisdiction];
+
+  if (args.input_type) {
+    sql += ' AND LOWER(input_type) LIKE LOWER(?)';
+    params.push(`%${args.input_type}%`);
+  }
+
+  const rows = db.all<{
+    id: number;
+    input_type: string;
+    product_name: string;
+    description: string;
+    restrictions: string;
+    source: string;
+  }>(sql, params);
+
+  return {
+    jurisdiction: jv.jurisdiction,
+    filters: { input_type: args.input_type },
+    results_count: rows.length,
+    results: rows.map(r => ({
+      input_type: r.input_type,
+      product_name: r.product_name,
+      description: r.description,
+      restrictions: r.restrictions,
+      source: r.source,
+    })),
+    _meta: buildMeta({ source_url: 'https://www.betriebsmittelliste.ch' }),
+  };
+}

package/src/tools/get-conversion-requirements.ts

@@ -0,0 +1,50 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface ConversionArgs {
+  farm_type?: string;
+  current_system?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetConversionRequirements(db: Database, args: ConversionArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT * FROM conversion_requirements WHERE jurisdiction = ?';
+  const params: unknown[] = [jv.jurisdiction];
+
+  if (args.farm_type) {
+    sql += ' AND LOWER(farm_type) LIKE LOWER(?)';
+    params.push(`%${args.farm_type}%`);
+  }
+
+  if (args.current_system) {
+    sql += ' AND LOWER(current_system) LIKE LOWER(?)';
+    params.push(`%${args.current_system}%`);
+  }
+
+  const rows = db.all<{
+    id: number;
+    farm_type: string;
+    current_system: string;
+    timeline_years: number;
+    requirements: string;
+    support_measures: string;
+  }>(sql, params);
+
+  return {
+    jurisdiction: jv.jurisdiction,
+    filters: { farm_type: args.farm_type, current_system: args.current_system },
+    results_count: rows.length,
+    results: rows.map(r => ({
+      farm_type: r.farm_type,
+      current_system: r.current_system,
+      timeline_years: r.timeline_years,
+      requirements: r.requirements,
+      support_measures: r.support_measures,
+    })),
+    _meta: buildMeta({ source_url: 'https://www.bio-suisse.ch/de/umstellung' }),
+  };
+}

package/src/tools/get-organic-standards.ts

@@ -0,0 +1,48 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface StandardsArgs {
+  production_type?: string;
+  standard?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetOrganicStandards(db: Database, args: StandardsArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT * FROM organic_standards WHERE jurisdiction = ?';
+  const params: unknown[] = [jv.jurisdiction];
+
+  if (args.production_type) {
+    sql += ' AND LOWER(production_type) LIKE LOWER(?)';
+    params.push(`%${args.production_type}%`);
+  }
+
+  if (args.standard) {
+    sql += ' AND LOWER(standard) LIKE LOWER(?)';
+    params.push(`%${args.standard}%`);
+  }
+
+  const rows = db.all<{
+    id: number;
+    production_type: string;
+    standard: string;
+    rule: string;
+    description: string;
+  }>(sql, params);
+
+  return {
+    jurisdiction: jv.jurisdiction,
+    filters: { production_type: args.production_type, standard: args.standard },
+    results_count: rows.length,
+    results: rows.map(r => ({
+      production_type: r.production_type,
+      standard: r.standard,
+      rule: r.rule,
+      description: r.description,
+    })),
+    _meta: buildMeta({ source_url: 'https://www.bio-suisse.ch/de/richtlinien' }),
+  };
+}

package/src/tools/get-organic-subsidies.ts

@@ -0,0 +1,50 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface SubsidiesArgs {
+  subsidy_type?: string;
+  zone?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetOrganicSubsidies(db: Database, args: SubsidiesArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT * FROM organic_subsidies WHERE jurisdiction = ?';
+  const params: unknown[] = [jv.jurisdiction];
+
+  if (args.subsidy_type) {
+    sql += ' AND LOWER(subsidy_type) LIKE LOWER(?)';
+    params.push(`%${args.subsidy_type}%`);
+  }
+
+  if (args.zone) {
+    sql += ' AND (LOWER(zone) LIKE LOWER(?) OR zone IS NULL)';
+    params.push(`%${args.zone}%`);
+  }
+
+  const rows = db.all<{
+    id: number;
+    subsidy_type: string;
+    zone: string;
+    rate_chf_ha: number;
+    conditions: string;
+    stacking_rules: string;
+  }>(sql, params);
+
+  return {
+    jurisdiction: jv.jurisdiction,
+    filters: { subsidy_type: args.subsidy_type, zone: args.zone },
+    results_count: rows.length,
+    results: rows.map(r => ({
+      subsidy_type: r.subsidy_type,
+      zone: r.zone,
+      rate_chf_ha: r.rate_chf_ha,
+      conditions: r.conditions,
+      stacking_rules: r.stacking_rules,
+    })),
+    _meta: buildMeta({ source_url: 'https://www.blw.admin.ch/blw/de/home/instrumente/direktzahlungen/produktionssystembeitraege.html' }),
+  };
+}

package/src/tools/get-soil-health-guidance.ts

@@ -0,0 +1,42 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface SoilHealthArgs {
+  topic?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetSoilHealthGuidance(db: Database, args: SoilHealthArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT * FROM soil_health WHERE jurisdiction = ?';
+  const params: unknown[] = [jv.jurisdiction];
+
+  if (args.topic) {
+    sql += ' AND LOWER(topic) LIKE LOWER(?)';
+    params.push(`%${args.topic}%`);
+  }
+
+  const rows = db.all<{
+    id: number;
+    topic: string;
+    guidance: string;
+    technique: string;
+    benefits: string;
+  }>(sql, params);
+
+  return {
+    jurisdiction: jv.jurisdiction,
+    filters: { topic: args.topic },
+    results_count: rows.length,
+    results: rows.map(r => ({
+      topic: r.topic,
+      guidance: r.guidance,
+      technique: r.technique,
+      benefits: r.benefits,
+    })),
+    _meta: buildMeta({ source_url: 'https://www.fibl.org/de/themen/bodenfruchtbarkeit' }),
+  };
+}

package/src/tools/list-sources.ts

@@ -0,0 +1,75 @@
+import { buildMeta } from '../metadata.js';
+import type { Database } from '../db.js';
+
+interface Source {
+  name: string;
+  authority: string;
+  official_url: string;
+  retrieval_method: string;
+  update_frequency: string;
+  license: string;
+  coverage: string;
+  last_retrieved?: string;
+}
+
+export function handleListSources(db: Database): { sources: Source[]; _meta: ReturnType<typeof buildMeta> } {
+  const lastIngest = db.get<{ value: string }>('SELECT value FROM db_metadata WHERE key = ?', ['last_ingest']);
+
+  const sources: Source[] = [
+    {
+      name: 'Bio Suisse Richtlinien (Knospe)',
+      authority: 'Bio Suisse',
+      official_url: 'https://www.bio-suisse.ch/de/richtlinien',
+      retrieval_method: 'PDF_EXTRACT',
+      update_frequency: 'annual (Delegiertenversammlung)',
+      license: 'Bio Suisse — public standards document',
+      coverage: 'Knospe production rules: feed, animal welfare, processing, BFF, imports',
+      last_retrieved: lastIngest?.value,
+    },
+    {
+      name: 'Bio-Verordnung (SR 910.18)',
+      authority: 'Bundesamt fuer Landwirtschaft (BLW)',
+      official_url: 'https://www.fedlex.admin.ch/eli/cc/1997/2498_2498_2498/de',
+      retrieval_method: 'PDF_EXTRACT',
+      update_frequency: 'periodic (with ordinance revisions)',
+      license: 'Swiss Federal Administration — free reuse',
+      coverage: 'Federal organic farming regulation: minimum standards, conversion, labelling',
+      last_retrieved: lastIngest?.value,
+    },
+    {
+      name: 'FiBL Betriebsmittelliste',
+      authority: 'Forschungsinstitut fuer biologischen Landbau (FiBL)',
+      official_url: 'https://www.betriebsmittelliste.ch',
+      retrieval_method: 'ONLINE_REGISTER',
+      update_frequency: 'annual',
+      license: 'FiBL — public reference list',
+      coverage: 'Approved inputs for Swiss organic farming: fertilisers, plant protection, feed',
+      last_retrieved: lastIngest?.value,
+    },
+    {
+      name: 'Demeter Schweiz Richtlinien',
+      authority: 'Demeter Schweiz',
+      official_url: 'https://www.demeter.ch/richtlinien',
+      retrieval_method: 'PDF_EXTRACT',
+      update_frequency: 'periodic',
+      license: 'Demeter — public standards document',
+      coverage: 'Biodynamic farming rules: preparations 500-508, composting, livestock integration',
+      last_retrieved: lastIngest?.value,
+    },
+    {
+      name: 'Direktzahlungsverordnung (DZV) — Bio-Beitrag',
+      authority: 'Bundesamt fuer Landwirtschaft (BLW)',
+      official_url: 'https://www.blw.admin.ch/blw/de/home/instrumente/direktzahlungen/produktionssystembeitraege.html',
+      retrieval_method: 'PDF_EXTRACT',
+      update_frequency: 'annual (DZV updates)',
+      license: 'Swiss Federal Administration — free reuse',
+      coverage: 'Bio-Beitrag rates per land use type and altitude zone',
+      last_retrieved: lastIngest?.value,
+    },
+  ];
+
+  return {
+    sources,
+    _meta: buildMeta(),
+  };
+}

package/src/tools/search-certification-guidance.ts

@@ -0,0 +1,41 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface CertArgs {
+  query: string;
+  jurisdiction?: string;
+}
+
+export function handleSearchCertificationGuidance(db: Database, args: CertArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  const searchTerm = `%${args.query}%`;
+  const rows = db.all<{
+    id: number;
+    step: string;
+    description: string;
+    inspector: string;
+    frequency: string;
+    cost_notes: string;
+  }>(
+    `SELECT * FROM certification_guidance WHERE jurisdiction = ?
+     AND (LOWER(step) LIKE LOWER(?) OR LOWER(description) LIKE LOWER(?))`,
+    [jv.jurisdiction, searchTerm, searchTerm]
+  );
+
+  return {
+    query: args.query,
+    jurisdiction: jv.jurisdiction,
+    results_count: rows.length,
+    results: rows.map(r => ({
+      step: r.step,
+      description: r.description,
+      inspector: r.inspector,
+      frequency: r.frequency,
+      cost_notes: r.cost_notes,
+    })),
+    _meta: buildMeta({ source_url: 'https://www.bio-inspecta.ch' }),
+  };
+}