@ansvar/ch-environmental-compliance-mcp 0.1.0

package/src/server.ts

@@ -0,0 +1,244 @@
+#!/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 { handleSearchEnvironmentalRules } from './tools/search-environmental-rules.js';
+import { handleGetWaterProtectionZones } from './tools/get-water-protection-zones.js';
+import { handleGetBufferZoneRules } from './tools/get-buffer-zone-rules.js';
+import { handleGetAmmoniaRules } from './tools/get-ammonia-rules.js';
+import { handleGetBffRequirements } from './tools/get-bff-requirements.js';
+import { handleGetNutrientLossLimits } from './tools/get-nutrient-loss-limits.js';
+import { handleGetEipRequirements } from './tools/get-eip-requirements.js';
+import { handleCheckEnvironmentalCompliance } from './tools/check-environmental-compliance.js';
+
+const SERVER_NAME = 'ch-environmental-compliance-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_environmental_rules',
+    description: 'Search Swiss environmental compliance rules across all topics: Gewaesserschutz, Ammoniak, BFF, Pufferstreifen, VBBo, UVP. Use for broad queries.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: { type: 'string', description: 'Free-text search query (German or English)' },
+        topic: { type: 'string', description: 'Filter by topic (e.g. Gewaesserschutz, Ammoniak, BFF, UVP, VBBo)' },
+        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_water_protection_zones',
+    description: 'Get Grundwasserschutzzonen (S1, S2, S3, Sm, Zu) with restrictions and legal basis. Based on GSchG/GSchV.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        zone_type: { type: 'string', description: 'Zone type: S1, S2, S3, Sm, Zu (omit for all zones)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'get_buffer_zone_rules',
+    description: 'Get Pufferstreifen (buffer zone) distances and requirements along water bodies, hedges, and field boundaries. Based on OELN/ChemRRV.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        zone_type: { type: 'string', description: 'Buffer type filter (e.g. Gewaesser, Hecke, Nachbar, SPe)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'get_ammonia_rules',
+    description: 'Get Ammoniakemissionen rules: emission factors by technique, Schleppschlauch-Pflicht, Agrammon model parameters. Based on LRV.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        technique: { type: 'string', description: 'Application technique filter (e.g. Schleppschlauch, Prallteller, Injektion)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'get_bff_requirements',
+    description: 'Get Biodiversitaetsfoerderflaechen (BFF) types, QI/QII payment rates, minimum area requirements, and botanical criteria. Based on DZV.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        bff_type: { type: 'string', description: 'BFF type filter (e.g. extensiv-wiese, buntbrache, hecke)' },
+        quality_level: { type: 'string', description: 'Quality level: QI or QII' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'get_nutrient_loss_limits',
+    description: 'Get Pa.Iv. 19.475 nutrient loss reduction targets (Absenkpfad) for N and P through 2030. Yearly milestones and Suisse-Bilanz tolerance changes.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        nutrient: { type: 'string', description: 'Nutrient filter: N (Stickstoff) or P (Phosphor)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'get_eip_requirements',
+    description: 'Get UVP (Umweltvertraeglichkeitspruefung) thresholds for agricultural buildings and VBBo Richtwerte for soil contamination.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_type: { type: 'string', description: 'Project type filter (e.g. Stallbau, Biogasanlage, Schweinehaltung)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'check_environmental_compliance',
+    description: 'Check which environmental rules apply to a given agricultural operation: water protection, buffer zones, ammonia, BFF, UVP, nutrient loss limits.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        facility_type: { type: 'string', description: 'Type of operation (e.g. Milchwirtschaft, Schweinehaltung, Ackerbau, Gemuese)' },
+        animal_count: { type: 'number', description: 'Number of animals (GVE) — used for ammonia and UVP thresholds' },
+        area_ha: { type: 'number', description: 'Farm area in hectares — used for BFF minimum calculations' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['facility_type'],
+    },
+  },
+];
+
+const SearchArgsSchema = z.object({
+  query: z.string(),
+  topic: z.string().optional(),
+  jurisdiction: z.string().optional(),
+  limit: z.number().optional(),
+});
+
+const WaterProtectionArgsSchema = z.object({
+  zone_type: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const BufferZoneArgsSchema = z.object({
+  zone_type: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const AmmoniaArgsSchema = z.object({
+  technique: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const BffArgsSchema = z.object({
+  bff_type: z.string().optional(),
+  quality_level: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const NutrientLossArgsSchema = z.object({
+  nutrient: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const EipArgsSchema = z.object({
+  project_type: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const ComplianceArgsSchema = z.object({
+  facility_type: z.string(),
+  animal_count: z.number().optional(),
+  area_ha: z.number().optional(),
+  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_environmental_rules':
+        return textResult(handleSearchEnvironmentalRules(db, SearchArgsSchema.parse(args)));
+      case 'get_water_protection_zones':
+        return textResult(handleGetWaterProtectionZones(db, WaterProtectionArgsSchema.parse(args)));
+      case 'get_buffer_zone_rules':
+        return textResult(handleGetBufferZoneRules(db, BufferZoneArgsSchema.parse(args)));
+      case 'get_ammonia_rules':
+        return textResult(handleGetAmmoniaRules(db, AmmoniaArgsSchema.parse(args)));
+      case 'get_bff_requirements':
+        return textResult(handleGetBffRequirements(db, BffArgsSchema.parse(args)));
+      case 'get_nutrient_loss_limits':
+        return textResult(handleGetNutrientLossLimits(db, NutrientLossArgsSchema.parse(args)));
+      case 'get_eip_requirements':
+        return textResult(handleGetEipRequirements(db, EipArgsSchema.parse(args)));
+      case 'check_environmental_compliance':
+        return textResult(handleCheckEnvironmentalCompliance(db, ComplianceArgsSchema.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 Environmental Compliance MCP',
+    description:
+      'Swiss environmental compliance data for agriculture: Gewaesserschutz (GSchG), Grundwasserschutzzonen, ' +
+      'Pufferstreifen, Ammoniakemissionen (LRV, Agrammon), Biodiversitaetsfoerderflaechen (BFF), ' +
+      'Naehrstoffverlust-Absenkpfad (Pa.Iv. 19.475), UVP-Schwellenwerte, and Bodenbelastung (VBBo). ' +
+      'Covers federal regulations and cantonal implementation for Swiss agricultural operations.',
+    version: '0.1.0',
+    jurisdiction: [...SUPPORTED_JURISDICTIONS],
+    data_sources: [
+      'BAFU — Gewaesserschutz, Luftreinhaltung, Biodiversitaet',
+      'BLW — OELN-Auflagen, BFF-Typen, DZV',
+      'Agroscope — Agrammon Ammoniakemissionsfaktoren',
+      'Kantonale Umweltaemter — Grundwasserschutzzonen',
+    ],
+    tools_count: 11,
+    links: {
+      homepage: 'https://ansvar.eu/open-agriculture',
+      repository: 'https://github.com/ansvar-systems/ch-environmental-compliance-mcp',
+      mcp_network: 'https://ansvar.ai/mcp',
+    },
+    _meta: buildMeta(),
+  };
+}

package/src/tools/check-environmental-compliance.ts

@@ -0,0 +1,143 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface ComplianceArgs {
+  facility_type: string;
+  animal_count?: number;
+  area_ha?: number;
+  jurisdiction?: string;
+}
+
+export function handleCheckEnvironmentalCompliance(db: Database, args: ComplianceArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  const applicable: {
+    category: string;
+    rule: string;
+    requirement: string;
+    legal_basis: string;
+    applies: boolean;
+    reason: string;
+  }[] = [];
+
+  // Check water protection requirements
+  const waterZones = db.all<{ zone_type: string; restrictions: string; legal_basis: string }>(
+    'SELECT zone_type, restrictions, legal_basis FROM water_protection_zones WHERE jurisdiction = ?',
+    [jv.jurisdiction]
+  );
+  for (const z of waterZones) {
+    applicable.push({
+      category: 'Gewaesserschutz',
+      rule: `Grundwasserschutzzone ${z.zone_type}`,
+      requirement: z.restrictions,
+      legal_basis: z.legal_basis ?? 'GSchG Art. 20',
+      applies: true,
+      reason: 'Pruefen Sie, ob Ihr Standort in einer Schutzzone liegt (kantonaler Zonenplan).',
+    });
+  }
+
+  // Check buffer zone requirements
+  const buffers = db.all<{ type: string; distance_m: number; requirement: string; source_law: string }>(
+    'SELECT type, distance_m, requirement, source_law FROM buffer_zones WHERE jurisdiction = ?',
+    [jv.jurisdiction]
+  );
+  for (const b of buffers) {
+    applicable.push({
+      category: 'Pufferstreifen',
+      rule: `${b.type} — ${b.distance_m}m`,
+      requirement: b.requirement,
+      legal_basis: b.source_law,
+      applies: true,
+      reason: 'OELN-Pflicht fuer alle Direktzahlungsempfaenger.',
+    });
+  }
+
+  // Check ammonia rules
+  const ammoniaRules = db.all<{ technique: string; requirement: string; legal_basis: string }>(
+    'SELECT technique, requirement, legal_basis FROM ammonia_rules WHERE jurisdiction = ?',
+    [jv.jurisdiction]
+  );
+  const hasLivestock = args.animal_count !== undefined && args.animal_count > 0;
+  for (const a of ammoniaRules) {
+    applicable.push({
+      category: 'Ammoniakemissionen',
+      rule: a.technique,
+      requirement: a.requirement,
+      legal_basis: a.legal_basis ?? 'LRV Anhang 2',
+      applies: hasLivestock,
+      reason: hasLivestock
+        ? `Relevant bei ${args.animal_count} Tieren.`
+        : 'Nur relevant bei Tierhaltung.',
+    });
+  }
+
+  // Check BFF minimum
+  const bffMin = db.get<{ min_area_pct: number }>(
+    `SELECT min_area_pct FROM bff_types WHERE min_area_pct > 0 AND jurisdiction = ? ORDER BY min_area_pct DESC LIMIT 1`,
+    [jv.jurisdiction]
+  );
+  if (bffMin && args.area_ha) {
+    applicable.push({
+      category: 'Biodiversitaetsfoerderflaechen',
+      rule: 'Mindestanteil BFF',
+      requirement: `Mindestens ${bffMin.min_area_pct}% der LN als BFF (${(args.area_ha * bffMin.min_area_pct / 100).toFixed(2)} ha bei ${args.area_ha} ha LN)`,
+      legal_basis: 'DZV Art. 14',
+      applies: true,
+      reason: 'OELN-Pflicht fuer alle Direktzahlungsempfaenger.',
+    });
+  }
+
+  // Check UVP thresholds
+  const uvpRules = db.all<{ rule: string; threshold: string; legal_basis: string }>(
+    `SELECT rule, threshold, legal_basis FROM environmental_rules WHERE topic = 'UVP' AND jurisdiction = ?`,
+    [jv.jurisdiction]
+  );
+  for (const u of uvpRules) {
+    const uvpApplies = args.animal_count !== undefined && args.animal_count >= 150;
+    applicable.push({
+      category: 'UVP (Umweltvertraeglichkeitspruefung)',
+      rule: u.rule,
+      requirement: u.threshold ?? '',
+      legal_basis: u.legal_basis,
+      applies: uvpApplies,
+      reason: uvpApplies
+        ? `Bei ${args.animal_count} Tieren ist eine UVP-Pruefung wahrscheinlich erforderlich.`
+        : 'UVP-Schwellenwerte pruefen (kantonal, ab ca. 150 GVE).',
+    });
+  }
+
+  // Check Pa.Iv. 19.475 nutrient loss limits
+  const currentYear = new Date().getFullYear();
+  const limits = db.all<{ nutrient: string; limit_pct: number; target: string }>(
+    'SELECT nutrient, limit_pct, target FROM nutrient_loss_limits WHERE year <= ? AND jurisdiction = ? ORDER BY year DESC',
+    [currentYear, jv.jurisdiction]
+  );
+  const latestN = limits.find(l => l.nutrient === 'N');
+  const latestP = limits.find(l => l.nutrient === 'P');
+  if (latestN || latestP) {
+    applicable.push({
+      category: 'Naehrstoffverluste (Pa.Iv. 19.475)',
+      rule: 'Absenkpfad Stickstoff und Phosphor',
+      requirement: [
+        latestN ? `N: -${latestN.limit_pct}% (${latestN.target})` : '',
+        latestP ? `P: -${latestP.limit_pct}% (${latestP.target})` : '',
+      ].filter(Boolean).join('; '),
+      legal_basis: 'LwG Art. 6a (Pa.Iv. 19.475)',
+      applies: true,
+      reason: 'Betrifft alle Betriebe mit Direktzahlungen.',
+    });
+  }
+
+  return {
+    facility_type: args.facility_type,
+    animal_count: args.animal_count ?? null,
+    area_ha: args.area_ha ?? null,
+    jurisdiction: jv.jurisdiction,
+    applicable_rules: applicable.length,
+    rules: applicable,
+    note: 'Diese Zusammenstellung ist indikativ. Kantonale Auflagen und standortspezifische Anforderungen sind separat zu pruefen.',
+    _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-environmental-compliance-mcp',
+    _meta: buildMeta(),
+  };
+}

package/src/tools/get-ammonia-rules.ts

@@ -0,0 +1,44 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface AmmoniaArgs {
+  technique?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetAmmoniaRules(db: Database, args: AmmoniaArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT * FROM ammonia_rules WHERE jurisdiction = ?';
+  const params: unknown[] = [jv.jurisdiction];
+
+  if (args.technique) {
+    sql += ' AND LOWER(technique) LIKE LOWER(?)';
+    params.push(`%${args.technique}%`);
+  }
+
+  sql += ' ORDER BY technique';
+
+  const rules = db.all<{
+    technique: string; emission_factor: number; requirement: string;
+    legal_basis: string; effective_date: string; notes: string;
+  }>(sql, params);
+
+  return {
+    jurisdiction: jv.jurisdiction,
+    rules_count: rules.length,
+    rules: rules.map(r => ({
+      technique: r.technique,
+      emission_factor_pct: r.emission_factor,
+      requirement: r.requirement,
+      legal_basis: r.legal_basis,
+      effective_date: r.effective_date,
+      notes: r.notes,
+    })),
+    _meta: buildMeta({
+      source_url: 'https://www.bafu.admin.ch/bafu/de/home/themen/luft/fachinformationen/luftschadstoffquellen/emissionen-der-landwirtschaft.html',
+    }),
+  };
+}

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

@@ -0,0 +1,52 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface BffArgs {
+  bff_type?: string;
+  quality_level?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetBffRequirements(db: Database, args: BffArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT * FROM bff_types WHERE jurisdiction = ?';
+  const params: unknown[] = [jv.jurisdiction];
+
+  if (args.bff_type) {
+    sql += ' AND (LOWER(id) LIKE LOWER(?) OR LOWER(name) LIKE LOWER(?))';
+    params.push(`%${args.bff_type}%`, `%${args.bff_type}%`);
+  }
+
+  if (args.quality_level) {
+    sql += ' AND UPPER(quality_level) = UPPER(?)';
+    params.push(args.quality_level);
+  }
+
+  sql += ' ORDER BY name, quality_level';
+
+  const types = db.all<{
+    id: string; name: string; quality_level: string;
+    payment_chf_ha: number; min_area_pct: number;
+    botanical_criteria: string; notes: string;
+  }>(sql, params);
+
+  return {
+    jurisdiction: jv.jurisdiction,
+    types_count: types.length,
+    types: types.map(t => ({
+      id: t.id,
+      name: t.name,
+      quality_level: t.quality_level,
+      payment_chf_ha: t.payment_chf_ha,
+      min_area_pct: t.min_area_pct,
+      botanical_criteria: t.botanical_criteria,
+      notes: t.notes,
+    })),
+    _meta: buildMeta({
+      source_url: 'https://www.blw.admin.ch/blw/de/home/instrumente/direktzahlungen/biodiversitaetsbeitraege.html',
+    }),
+  };
+}

package/src/tools/get-buffer-zone-rules.ts

@@ -0,0 +1,43 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface BufferZoneArgs {
+  zone_type?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetBufferZoneRules(db: Database, args: BufferZoneArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT * FROM buffer_zones WHERE jurisdiction = ?';
+  const params: unknown[] = [jv.jurisdiction];
+
+  if (args.zone_type) {
+    sql += ' AND LOWER(type) LIKE LOWER(?)';
+    params.push(`%${args.zone_type}%`);
+  }
+
+  sql += ' ORDER BY distance_m DESC';
+
+  const zones = db.all<{
+    type: string; distance_m: number; requirement: string;
+    source_law: string; notes: string;
+  }>(sql, params);
+
+  return {
+    jurisdiction: jv.jurisdiction,
+    rules_count: zones.length,
+    rules: zones.map(z => ({
+      type: z.type,
+      distance_m: z.distance_m,
+      requirement: z.requirement,
+      source_law: z.source_law,
+      notes: z.notes,
+    })),
+    _meta: buildMeta({
+      source_url: 'https://www.blw.admin.ch/blw/de/home/instrumente/direktzahlungen/oekologischer-leistungsnachweis.html',
+    }),
+  };
+}

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

@@ -0,0 +1,57 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface EipArgs {
+  project_type?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetEipRequirements(db: Database, args: EipArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = `SELECT * FROM environmental_rules WHERE topic = 'UVP' AND jurisdiction = ?`;
+  const params: unknown[] = [jv.jurisdiction];
+
+  if (args.project_type) {
+    sql += ' AND LOWER(rule) LIKE LOWER(?)';
+    params.push(`%${args.project_type}%`);
+  }
+
+  sql += ' ORDER BY id';
+
+  const rules = db.all<{
+    topic: string; rule: string; authority: string;
+    legal_basis: string; threshold: string; notes: string;
+  }>(sql, params);
+
+  // Also get VBBo (soil contamination) rules
+  const vbbo = db.all<{
+    topic: string; rule: string; authority: string;
+    legal_basis: string; threshold: string; notes: string;
+  }>(`SELECT * FROM environmental_rules WHERE topic = 'VBBo' AND jurisdiction = ? ORDER BY id`, [jv.jurisdiction]);
+
+  return {
+    jurisdiction: jv.jurisdiction,
+    uvp_rules_count: rules.length,
+    uvp_rules: rules.map(r => ({
+      rule: r.rule,
+      authority: r.authority,
+      legal_basis: r.legal_basis,
+      threshold: r.threshold,
+      notes: r.notes,
+    })),
+    vbbo_rules_count: vbbo.length,
+    vbbo_rules: vbbo.map(r => ({
+      rule: r.rule,
+      authority: r.authority,
+      legal_basis: r.legal_basis,
+      threshold: r.threshold,
+      notes: r.notes,
+    })),
+    _meta: buildMeta({
+      source_url: 'https://www.bafu.admin.ch/bafu/de/home/themen/uvp.html',
+    }),
+  };
+}