@ansvar/ch-livestock-mcp 0.1.0

package/src/db.ts

@@ -0,0 +1,268 @@
+import BetterSqlite3 from 'better-sqlite3';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+export interface Database {
+  get<T>(sql: string, params?: unknown[]): T | undefined;
+  all<T>(sql: string, params?: unknown[]): T[];
+  run(sql: string, params?: unknown[]): void;
+  close(): void;
+  readonly instance: BetterSqlite3.Database;
+}
+
+export function createDatabase(dbPath?: string): Database {
+  const resolvedPath =
+    dbPath ??
+    join(dirname(fileURLToPath(import.meta.url)), '..', 'data', 'database.db');
+  const db = new BetterSqlite3(resolvedPath);
+
+  db.pragma('journal_mode = DELETE');
+  db.pragma('foreign_keys = ON');
+
+  initSchema(db);
+
+  return {
+    get<T>(sql: string, params: unknown[] = []): T | undefined {
+      return db.prepare(sql).get(...params) as T | undefined;
+    },
+    all<T>(sql: string, params: unknown[] = []): T[] {
+      return db.prepare(sql).all(...params) as T[];
+    },
+    run(sql: string, params: unknown[] = []): void {
+      db.prepare(sql).run(...params);
+    },
+    close(): void {
+      db.close();
+    },
+    get instance() {
+      return db;
+    },
+  };
+}
+
+function initSchema(db: BetterSqlite3.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS welfare_standards (
+      id INTEGER PRIMARY KEY,
+      species TEXT NOT NULL,
+      production_system TEXT NOT NULL,
+      requirement TEXT NOT NULL,
+      min_space_m2 REAL,
+      details TEXT,
+      language TEXT NOT NULL DEFAULT 'DE',
+      jurisdiction TEXT NOT NULL DEFAULT 'CH'
+    );
+
+    CREATE TABLE IF NOT EXISTS stocking_densities (
+      id INTEGER PRIMARY KEY,
+      species TEXT NOT NULL,
+      age_class TEXT NOT NULL,
+      housing_type TEXT NOT NULL,
+      animals_per_m2 REAL,
+      regulatory_minimum TEXT,
+      language TEXT NOT NULL DEFAULT 'DE',
+      jurisdiction TEXT NOT NULL DEFAULT 'CH'
+    );
+
+    CREATE TABLE IF NOT EXISTS housing_requirements (
+      id INTEGER PRIMARY KEY,
+      species TEXT NOT NULL,
+      age_class TEXT NOT NULL,
+      system TEXT NOT NULL,
+      space TEXT,
+      ventilation TEXT,
+      flooring TEXT,
+      temperature TEXT,
+      language TEXT NOT NULL DEFAULT 'DE',
+      jurisdiction TEXT NOT NULL DEFAULT 'CH'
+    );
+
+    CREATE TABLE IF NOT EXISTS movement_rules (
+      id INTEGER PRIMARY KEY,
+      species TEXT NOT NULL,
+      rule_type TEXT NOT NULL,
+      description TEXT NOT NULL,
+      language TEXT NOT NULL DEFAULT 'DE',
+      jurisdiction TEXT NOT NULL DEFAULT 'CH'
+    );
+
+    CREATE TABLE IF NOT EXISTS breeds (
+      id INTEGER PRIMARY KEY,
+      species TEXT NOT NULL,
+      name TEXT NOT NULL,
+      purpose TEXT,
+      notes TEXT,
+      language TEXT NOT NULL DEFAULT 'DE',
+      jurisdiction TEXT NOT NULL DEFAULT 'CH'
+    );
+
+    CREATE TABLE IF NOT EXISTS feed_requirements (
+      id INTEGER PRIMARY KEY,
+      species TEXT NOT NULL,
+      age_class TEXT NOT NULL,
+      production_stage TEXT,
+      feed_type TEXT,
+      quantity_kg_day REAL,
+      energy_mj REAL,
+      protein_g REAL,
+      notes TEXT,
+      language TEXT NOT NULL DEFAULT 'DE',
+      jurisdiction TEXT NOT NULL DEFAULT 'CH'
+    );
+
+    CREATE TABLE IF NOT EXISTS animal_health (
+      id INTEGER PRIMARY KEY,
+      species TEXT NOT NULL,
+      condition TEXT NOT NULL,
+      symptoms TEXT,
+      prevention TEXT,
+      regulatory_status TEXT,
+      details TEXT,
+      language TEXT NOT NULL DEFAULT 'DE',
+      jurisdiction TEXT NOT NULL DEFAULT 'CH'
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS search_index USING fts5(
+      title, body, species, category, jurisdiction
+    );
+
+    CREATE TABLE IF NOT EXISTS db_metadata (
+      key TEXT PRIMARY KEY,
+      value TEXT
+    );
+
+    INSERT OR IGNORE INTO db_metadata (key, value) VALUES ('schema_version', '1.0');
+    INSERT OR IGNORE INTO db_metadata (key, value) VALUES ('mcp_name', 'Switzerland Livestock MCP');
+    INSERT OR IGNORE INTO db_metadata (key, value) VALUES ('jurisdiction', 'CH');
+  `);
+}
+
+const FTS_COLUMNS = ['title', 'body', 'species', 'category', 'jurisdiction'];
+
+export function ftsSearch(
+  db: Database,
+  query: string,
+  limit: number = 20,
+  species?: string
+): { title: string; body: string; species: string; category: string; jurisdiction: string; rank: number }[] {
+  const { results } = tieredFtsSearch(db, 'search_index', FTS_COLUMNS, query, limit, species);
+  return results as { title: string; body: string; species: string; category: string; jurisdiction: string; rank: number }[];
+}
+
+/**
+ * Tiered FTS5 search with automatic fallback.
+ * Tiers: exact phrase -> AND -> prefix -> stemmed prefix -> OR -> LIKE
+ */
+export function tieredFtsSearch(
+  db: Database,
+  table: string,
+  columns: string[],
+  query: string,
+  limit: number = 20,
+  species?: string
+): { tier: string; results: Record<string, unknown>[] } {
+  const sanitized = sanitizeFtsInput(query);
+  if (!sanitized.trim()) return { tier: 'empty', results: [] };
+
+  const columnList = columns.join(', ');
+  const select = `SELECT ${columnList}, rank FROM ${table}`;
+  const order = `ORDER BY rank LIMIT ?`;
+
+  // Tier 1: Exact phrase
+  const phrase = `"${sanitized}"`;
+  let results = tryFts(db, select, table, order, phrase, limit, species);
+  if (results.length > 0) return { tier: 'phrase', results };
+
+  // Tier 2: AND
+  const words = sanitized.split(/\s+/).filter(w => w.length > 1);
+  if (words.length > 1) {
+    const andQuery = words.join(' AND ');
+    results = tryFts(db, select, table, order, andQuery, limit, species);
+    if (results.length > 0) return { tier: 'and', results };
+  }
+
+  // Tier 3: Prefix
+  const prefixQuery = words.map(w => `${w}*`).join(' AND ');
+  results = tryFts(db, select, table, order, prefixQuery, limit, species);
+  if (results.length > 0) return { tier: 'prefix', results };
+
+  // Tier 4: Stemmed prefix
+  const stemmed = words.map(w => stemWord(w) + '*');
+  const stemmedQuery = stemmed.join(' AND ');
+  if (stemmedQuery !== prefixQuery) {
+    results = tryFts(db, select, table, order, stemmedQuery, limit, species);
+    if (results.length > 0) return { tier: 'stemmed', results };
+  }
+
+  // Tier 5: OR
+  if (words.length > 1) {
+    const orQuery = words.join(' OR ');
+    results = tryFts(db, select, table, order, orQuery, limit, species);
+    if (results.length > 0) return { tier: 'or', results };
+  }
+
+  // Tier 6: LIKE fallback on search_index content
+  const likeConditions = words.map(() =>
+    `(title LIKE ? OR body LIKE ? OR species LIKE ?)`
+  ).join(' AND ');
+  const likeParams = words.flatMap(w => [`%${w}%`, `%${w}%`, `%${w}%`]);
+  if (species) {
+    try {
+      const likeResults = db.all<Record<string, unknown>>(
+        `SELECT title, body, species, category, jurisdiction FROM search_index WHERE ${likeConditions} AND species LIKE ? LIMIT ?`,
+        [...likeParams, `%${species}%`, limit]
+      );
+      if (likeResults.length > 0) return { tier: 'like', results: likeResults };
+    } catch {
+      // LIKE fallback failed
+    }
+  }
+  try {
+    const likeResults = db.all<Record<string, unknown>>(
+      `SELECT title, body, species, category, jurisdiction FROM search_index WHERE ${likeConditions} LIMIT ?`,
+      [...likeParams, limit]
+    );
+    if (likeResults.length > 0) return { tier: 'like', results: likeResults };
+  } catch {
+    // LIKE fallback failed
+  }
+
+  return { tier: 'none', results: [] };
+}
+
+function tryFts(
+  db: Database, select: string, table: string,
+  order: string, matchExpr: string, limit: number,
+  species?: string
+): Record<string, unknown>[] {
+  try {
+    if (species) {
+      const filtered = db.all(
+        `${select} WHERE ${table} MATCH ? ${order}`,
+        [matchExpr, limit * 3]
+      );
+      return (filtered as Record<string, unknown>[]).filter(
+        r => (r.species as string || '').toLowerCase().includes(species.toLowerCase())
+      ).slice(0, limit);
+    }
+    return db.all(
+      `${select} WHERE ${table} MATCH ? ${order}`,
+      [matchExpr, limit]
+    );
+  } catch {
+    return [];
+  }
+}
+
+function sanitizeFtsInput(query: string): string {
+  return query
+    .replace(/["\u201C\u201D\u2018\u2019\uFF0C\u3001\uFF1B\u3002]/g, '"')
+    .replace(/[^a-zA-Z0-9\s*"_\u00C0-\u024F-]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function stemWord(word: string): string {
+  return word
+    .replace(/(ung|heit|keit|lich|isch|ieren|tion|ment|ness|able|ible|ous|ive|ing|ers|ed|es|er|en|ly|s)$/i, '');
+}

package/src/http-server.ts

@@ -0,0 +1,327 @@
+import { createServer, type IncomingMessage, type ServerResponse } from 'http';
+import { randomUUID } from 'crypto';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { createDatabase, type Database } from './db.js';
+import { handleAbout } from './tools/about.js';
+import { handleListSources } from './tools/list-sources.js';
+import { handleCheckFreshness } from './tools/check-freshness.js';
+import { handleSearchLivestockGuidance } from './tools/search-livestock-guidance.js';
+import { handleGetWelfareStandards } from './tools/get-welfare-standards.js';
+import { handleGetStockingDensity } from './tools/get-stocking-density.js';
+import { handleGetFeedRequirements } from './tools/get-feed-requirements.js';
+import { handleSearchAnimalHealth } from './tools/search-animal-health.js';
+import { handleGetHousingRequirements } from './tools/get-housing-requirements.js';
+import { handleGetMovementRules } from './tools/get-movement-rules.js';
+import { handleGetBreedingGuidance } from './tools/get-breeding-guidance.js';
+
+const SERVER_NAME = 'ch-livestock-mcp';
+const SERVER_VERSION = '0.1.0';
+const PORT = parseInt(process.env.PORT ?? '3000', 10);
+
+const SearchArgsSchema = z.object({
+  query: z.string(),
+  species: z.string().optional(),
+  jurisdiction: z.string().optional(),
+  limit: z.number().optional(),
+});
+
+const WelfareArgsSchema = z.object({
+  species: z.string(),
+  production_system: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const StockingArgsSchema = z.object({
+  species: z.string(),
+  age_class: z.string().optional(),
+  housing_type: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const FeedArgsSchema = z.object({
+  species: z.string(),
+  age_class: z.string().optional(),
+  production_stage: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const HealthSearchArgsSchema = z.object({
+  query: z.string(),
+  species: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const HousingArgsSchema = z.object({
+  species: z.string(),
+  age_class: z.string().optional(),
+  system: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const MovementArgsSchema = z.object({
+  species: z.string(),
+  rule_type: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const BreedingArgsSchema = z.object({
+  species: z.string(),
+  topic: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+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_livestock_guidance',
+    description: 'Search across all Swiss livestock topics: welfare, housing, feeding, health, transport, breeds.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: { type: 'string', description: 'Free-text search query (German or English)' },
+        species: { type: 'string', description: 'Filter by species (e.g. Rinder, Schweine, Gefluegel, Schafe, Ziegen, Pferde)' },
+        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_welfare_standards',
+    description: 'Get legal minimum welfare requirements and RAUS/BTS programme standards for a species.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        species: { type: 'string', description: 'Species: Rinder, Schweine, Gefluegel, Schafe, Ziegen, Pferde' },
+        production_system: { type: 'string', description: 'Production system (e.g. TSchV-Minimum, RAUS, BTS)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['species'],
+    },
+  },
+  {
+    name: 'get_stocking_density',
+    description: 'Get animals per m2 and space requirements by species, age class, and housing type.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        species: { type: 'string', description: 'Species: Rinder, Schweine, Gefluegel, Schafe, Ziegen, Pferde' },
+        age_class: { type: 'string', description: 'Age/weight class (e.g. Milchkuh, Kalb, Mastschwein >60kg)' },
+        housing_type: { type: 'string', description: 'Housing type (e.g. Laufstall, Anbindestall, Voliere)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['species'],
+    },
+  },
+  {
+    name: 'get_feed_requirements',
+    description: 'Get nutritional requirements per species and production stage. Includes GMF programme details.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        species: { type: 'string', description: 'Species: Rinder, Schweine, Gefluegel, Schafe, Ziegen, Pferde' },
+        age_class: { type: 'string', description: 'Age class (e.g. Milchkuh, Mastschwein, Legehenne)' },
+        production_stage: { type: 'string', description: 'Production stage (e.g. Laktation, Mast, Aufzucht)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['species'],
+    },
+  },
+  {
+    name: 'search_animal_health',
+    description: 'Search animal health topics: diseases, symptoms, prevention, regulatory reporting requirements.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: { type: 'string', description: 'Search query (e.g. Salmonellen, BVD, Moderhinke)' },
+        species: { type: 'string', description: 'Filter by species' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'get_housing_requirements',
+    description: 'Get detailed housing specs: space, ventilation, flooring, temperature. TSchV minimum vs. BTS.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        species: { type: 'string', description: 'Species: Rinder, Schweine, Gefluegel, Schafe, Ziegen, Pferde' },
+        age_class: { type: 'string', description: 'Age class (e.g. Milchkuh, Mastschwein, Legehenne)' },
+        system: { type: 'string', description: 'Housing system (e.g. Laufstall, Anbindestall, BTS)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['species'],
+    },
+  },
+  {
+    name: 'get_movement_rules',
+    description: 'Get TVD registration, transport rules, standstill, and Soemmerung requirements per species.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        species: { type: 'string', description: 'Species: Rinder, Schweine, Gefluegel, Schafe, Ziegen, Pferde' },
+        rule_type: { type: 'string', description: 'Rule type: TVD, Transport, Soemmerung, Schlachtung' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['species'],
+    },
+  },
+  {
+    name: 'get_breeding_guidance',
+    description: 'Get Swiss breed info, breeding calendars, AI (kuenstliche Besamung), genetics, Soemmerung guidance.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        species: { type: 'string', description: 'Species: Rinder, Schweine, Schafe, Ziegen, Pferde' },
+        topic: { type: 'string', description: 'Topic filter (e.g. Zweinutzung, Milch, Fleisch, Alp)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['species'],
+    },
+  },
+];
+
+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 };
+}
+
+function registerTools(server: Server, db: Database): void {
+  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_livestock_guidance':
+          return textResult(handleSearchLivestockGuidance(db, SearchArgsSchema.parse(args)));
+        case 'get_welfare_standards':
+          return textResult(handleGetWelfareStandards(db, WelfareArgsSchema.parse(args)));
+        case 'get_stocking_density':
+          return textResult(handleGetStockingDensity(db, StockingArgsSchema.parse(args)));
+        case 'get_feed_requirements':
+          return textResult(handleGetFeedRequirements(db, FeedArgsSchema.parse(args)));
+        case 'search_animal_health':
+          return textResult(handleSearchAnimalHealth(db, HealthSearchArgsSchema.parse(args)));
+        case 'get_housing_requirements':
+          return textResult(handleGetHousingRequirements(db, HousingArgsSchema.parse(args)));
+        case 'get_movement_rules':
+          return textResult(handleGetMovementRules(db, MovementArgsSchema.parse(args)));
+        case 'get_breeding_guidance':
+          return textResult(handleGetBreedingGuidance(db, BreedingArgsSchema.parse(args)));
+        default:
+          return errorResult(`Unknown tool: ${name}`);
+      }
+    } catch (err) {
+      return errorResult(err instanceof Error ? err.message : String(err));
+    }
+  });
+}
+
+const db = createDatabase();
+const sessions = new Map<string, { transport: StreamableHTTPServerTransport; server: Server }>();
+
+function createMcpServer(): Server {
+  const mcpServer = new Server(
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    { capabilities: { tools: {} } }
+  );
+  registerTools(mcpServer, db);
+  return mcpServer;
+}
+
+async function handleMCPRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  const sessionId = req.headers['mcp-session-id'] as string | undefined;
+
+  if (sessionId && sessions.has(sessionId)) {
+    const session = sessions.get(sessionId)!;
+    await session.transport.handleRequest(req, res);
+    return;
+  }
+
+  if (req.method === 'GET' || req.method === 'DELETE') {
+    res.writeHead(400, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Invalid or missing session ID' }));
+    return;
+  }
+
+  const mcpServer = createMcpServer();
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: () => randomUUID(),
+  });
+
+  await mcpServer.connect(transport);
+
+  transport.onclose = () => {
+    if (transport.sessionId) {
+      sessions.delete(transport.sessionId);
+    }
+    mcpServer.close().catch(() => {});
+  };
+
+  await transport.handleRequest(req, res);
+
+  if (transport.sessionId) {
+    sessions.set(transport.sessionId, { transport, server: mcpServer });
+  }
+}
+
+const httpServer = createServer(async (req, res) => {
+  const url = new URL(req.url || '/', `http://localhost:${PORT}`);
+
+  if (url.pathname === '/health' && req.method === 'GET') {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ status: 'healthy', server: SERVER_NAME, version: SERVER_VERSION }));
+    return;
+  }
+
+  if (url.pathname === '/mcp' || url.pathname === '/') {
+    try {
+      await handleMCPRequest(req, res);
+    } catch (err) {
+      if (!res.headersSent) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err instanceof Error ? err.message : 'Internal server error' }));
+      }
+    }
+    return;
+  }
+
+  res.writeHead(404, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify({ error: 'Not found' }));
+});
+
+httpServer.listen(PORT, () => {
+  console.log(`${SERVER_NAME} v${SERVER_VERSION} listening on port ${PORT}`);
+});

package/src/jurisdiction.ts

@@ -0,0 +1,30 @@
+export const SUPPORTED_JURISDICTIONS = ['CH'] as const;
+export type Jurisdiction = (typeof SUPPORTED_JURISDICTIONS)[number];
+
+type ValidationSuccess = { valid: true; jurisdiction: Jurisdiction };
+type ValidationFailure = {
+  valid: false;
+  error: {
+    error: string;
+    supported: readonly string[];
+    message: string;
+  };
+};
+type ValidationResult = ValidationSuccess | ValidationFailure;
+
+export function validateJurisdiction(input: string | undefined): ValidationResult {
+  const normalised = (input ?? 'CH').toUpperCase();
+
+  if (SUPPORTED_JURISDICTIONS.includes(normalised as Jurisdiction)) {
+    return { valid: true, jurisdiction: normalised as Jurisdiction };
+  }
+
+  return {
+    valid: false,
+    error: {
+      error: 'jurisdiction_not_supported',
+      supported: SUPPORTED_JURISDICTIONS,
+      message: 'This server currently covers Switzerland. More jurisdictions are planned.',
+    },
+  };
+}

package/src/metadata.ts

@@ -0,0 +1,31 @@
+export interface Meta {
+  disclaimer: string;
+  data_age: string;
+  source_url: string;
+  copyright: string;
+  server: string;
+  version: string;
+}
+
+const DISCLAIMER =
+  'Diese Daten dienen ausschliesslich der Information und stellen keine Rechtsberatung oder ' +
+  'veterinaermedizinische Beratung dar. Massgebend sind die Tierschutzverordnung (TSchV, SR 455.1), ' +
+  'die Tierschutzgesetzgebung (TSchG, SR 455) sowie die Weisungen des BLV und BLW. Vor Entscheidungen ' +
+  'zur Tierhaltung ist stets die zustaendige kantonale Veterinaerbehoerde oder eine anerkannte ' +
+  'Fachberatung zu konsultieren. / ' +
+  'This data is provided for informational purposes only and does not constitute legal or veterinary ' +
+  'advice. The authoritative sources are the Swiss Animal Welfare Ordinance (TSchV), the Animal Welfare ' +
+  'Act (TSchG), and guidance from BLV and BLW. Always consult the cantonal veterinary authority before ' +
+  'making livestock management decisions.';
+
+export function buildMeta(overrides?: Partial<Meta>): Meta {
+  return {
+    disclaimer: DISCLAIMER,
+    data_age: overrides?.data_age ?? 'unknown',
+    source_url: overrides?.source_url ?? 'https://www.blv.admin.ch/blv/de/home/tiere/tierschutz.html',
+    copyright: 'Data: BLV, BLW, Agroscope, Zuchtorganisationen — used under public-sector information principles. Server: Apache-2.0 Ansvar Systems.',
+    server: 'ch-livestock-mcp',
+    version: '0.1.0',
+    ...overrides,
+  };
+}