weather-agent-mcp 0.1.0

package/.env.example

@@ -0,0 +1,21 @@
+# Optional: OpenAI-compatible API (OpenAI, OpenRouter, Groq, DeepSeek, Ollama, vLLM)
+OPENAI_API_KEY=
+OPENAI_BASE_URL=https://api.openai.com/v1
+OPENAI_MODEL=gpt-4o-mini
+
+# Optional: Anthropic Messages API
+ANTHROPIC_API_KEY=
+ANTHROPIC_MODEL=claude-3-5-haiku-latest
+
+# Open-Meteo base URLs (override in tests with fake server)
+OPEN_METEO_FORECAST_URL=https://api.open-meteo.com
+OPEN_METEO_GEOCODING_URL=https://geocoding-api.open-meteo.com
+
+# Agent defaults
+AGENT_MAX_ITERATIONS=10
+AGENT_MAX_TOOL_CALLS=20
+AGENT_MAX_TOKENS=8000
+AGENT_TIMEOUT_MS=30000
+
+# Provider for CLI: mock | openai | anthropic
+LLM_PROVIDER=mock

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 weather-agent-mcp contributors
+
+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,156 @@
+# Weather Agent MCP
+
+Model-agnostic AI-агент на TypeScript: собственный Agent Runtime, MCP-инструменты над Open-Meteo, Tool Contracts, Policy Engine, observability и eval-харнесс из 12 golden-сценариев.
+
+Демонстрирует путь **AI Engineer → Agent Engineer → AI Architect**.
+
+## Быстрый старт
+
+```bash
+npm install
+cp .env.example .env
+
+# Вопрос через детерминированный Mock LLM (без API key)
+npm run ask -- "Какая погода будет в Москве завтра?"
+
+# Юнит- и интеграционные тесты
+npm test
+
+# 12 golden eval-сценариев
+npm run eval
+
+# Проверка типов
+npm run typecheck
+```
+
+Опционально — реальные провайдеры (ключи в `.env`):
+
+```bash
+npm run ask -- --provider=openai "Сравни погоду в Москве и Санкт-Петербурге на 5 дней"
+npm run ask -- --provider=claude "Стоит ли брать дождевик в Казань на следующую неделю?"
+```
+
+## MCP в Cursor / Copilot (PoC)
+
+Хост использует **tools** этого пакета; loop остаётся у Cursor/Copilot.
+
+### Через npm (`npx`) — предпочтительно
+
+После публикации пакета `weather-agent-mcp@0.1.0`:
+
+```json
+{
+  "mcpServers": {
+    "open-meteo-weather": {
+      "command": "npx",
+      "args": ["-y", "weather-agent-mcp"]
+    }
+  }
+}
+```
+
+То же для Copilot / VS Code (поле `servers` + `"type": "stdio"`):
+
+```json
+{
+  "servers": {
+    "open-meteo-weather": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "weather-agent-mcp"]
+    }
+  }
+}
+```
+
+### Из клона (dev)
+
+```bash
+npm install && npm run build
+```
+
+```json
+{
+  "mcpServers": {
+    "open-meteo-weather": {
+      "command": "node",
+      "args": ["dist/weather-mcp.js"],
+      "cwd": "/ABS/PATH/TO/REPO"
+    }
+  }
+}
+```
+
+Dev без сборки: `npm run mcp` или `"args": ["src/mcp-server/index.ts"]` (нужен Node ≥20 с type-stripping).
+
+### Publish (maintainer)
+
+Нужен аккаунт npm с 2FA (или granular access token с bypass 2fa):
+
+```bash
+npm login          # при необходимости
+npm run build
+npm publish --access public
+npm view weather-agent-mcp version   # ожидаем 0.1.0
+```
+
+Cursor / Copilot после publish: `"command": "npx", "args": ["-y", "weather-agent-mcp"]`.
+
+Подробности: [`docs/13-poc-readiness.md`](docs/13-poc-readiness.md).
+
+## Архитектура
+
+```
+CLI / Eval
+    → Agent Runtime (свой loop: budget, policy, repair)
+        → LLMProvider (mock | openai | anthropic)
+        → Tool Registry (ToolDefinition + metadata)
+            → McpToolSource (discovery + типизированные ошибки)
+                → MCP Client (stdio)
+                    → процесс MCP Server
+                        → домен weather/
+                            → Open-Meteo HTTP
+```
+
+Подробный разбор — в [docs/](docs/) (контракты, security, масштабирование, защита MCP, 10-минутная презентация).
+
+## AI stewardship
+
+| Артефакт | Зачем |
+|----------|-------|
+| [`AGENTS.md`](AGENTS.md) | Конституция coding-агента |
+| [`MEMORY.md`](MEMORY.md) | Долговременные решения |
+| [`openspec/`](openspec/) | Spec-driven workflow ([openspec.dev](https://openspec.dev/)) |
+| [`graphify-out/COMPASS.md`](graphify-out/COMPASS.md) | Карта архитектуры для агентов |
+| [`docs/12-ai-stewardship.md`](docs/12-ai-stewardship.md) | Как демонстрировать навык управления ИИ |
+| [`docs/13-poc-readiness.md`](docs/13-poc-readiness.md) | PoC MCP hosts + вердикт npm |
+
+Команды OpenSpec в Cursor: `/opsx-explore`, `/opsx-propose`, `/opsx-apply`, `/opsx-archive`.
+
+## Скрипты
+
+| Скрипт | Назначение |
+|--------|------------|
+| `npm run ask` | Интерактивный CLI-агент |
+| `npm run mcp` | MCP-сервер на stdio |
+| `npm test` | Юнит + интеграция |
+| `npm run eval` | 12 golden-сценариев (Mock LLM) |
+| `npm run compare-models` | Mock vs реальный провайдер (если есть ключ) |
+| `npm run typecheck` | `tsc --noEmit` |
+| `npm run build` | Бандл MCP → `dist/weather-mcp.js` |
+
+## Структура
+
+```
+src/
+  weather/        Бизнес-логика (без MCP и LLM)
+  mcp-server/     MCP-адаптер (stdio, Zod-схемы)
+  tools/          Tool Contracts над MCP
+  llm/            Model-agnostic провайдеры
+  agent/          Собственный Agent Runtime
+  policy/         Policy Engine
+  observability/  Трейсы → traces/runs.jsonl
+  eval/           Golden-сценарии + FakeOpenMeteo
+  cli/            ask.ts
+docs/             Архитектурные ответы (01–13)
+```

package/dist/weather-mcp.js

@@ -0,0 +1,567 @@
+#!/usr/bin/env node
+
+// src/mcp-server/index.ts
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+
+// src/mcp-server/server.ts
+import { McpServer } from "@modelcontextprotocol/server";
+
+// src/shared/errors.ts
+var AppError = class extends Error {
+  code;
+  retryable;
+  details;
+  constructor(code, message, retryable, details) {
+    super(message);
+    this.name = new.target.name;
+    this.code = code;
+    this.retryable = retryable;
+    this.details = details;
+  }
+  toEnvelope() {
+    return {
+      code: this.code,
+      message: this.message,
+      retryable: this.retryable,
+      details: this.details
+    };
+  }
+};
+var ToolError = class _ToolError extends AppError {
+  constructor(code, message, retryable, details) {
+    super(code, message, retryable, details);
+  }
+  static fromEnvelope(env) {
+    return new _ToolError(env.code, env.message, env.retryable, env.details);
+  }
+};
+function isAppError(err) {
+  return err instanceof AppError;
+}
+
+// src/shared/http.ts
+function mergeSignals(a, b) {
+  if (!a && !b) return void 0;
+  if (!a) return b;
+  if (!b) return a;
+  const controller = new AbortController();
+  const onAbort = () => controller.abort();
+  if (a.aborted || b.aborted) {
+    controller.abort();
+    return controller.signal;
+  }
+  a.addEventListener("abort", onAbort, { once: true });
+  b.addEventListener("abort", onAbort, { once: true });
+  return controller.signal;
+}
+async function sleep(ms, signal) {
+  if (ms <= 0) return;
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new ToolError("UPSTREAM_TIMEOUT", "Request aborted during backoff", true));
+    };
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function httpJson(url, options = {}) {
+  const {
+    method = "GET",
+    headers = {},
+    body,
+    signal,
+    timeoutMs = 1e4,
+    retries = 0,
+    retryBackoffMs = 200
+  } = options;
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const combined = mergeSignals(signal, timeoutSignal);
+    try {
+      const res = await fetch(url, {
+        method,
+        headers: { Accept: "application/json", ...headers },
+        body,
+        signal: combined
+      });
+      const rawText = await res.text();
+      if (res.status === 429) {
+        const retryAfter = Number(res.headers.get("retry-after") ?? "1");
+        const err = new ToolError("RATE_LIMITED", `Rate limited: ${rawText}`, true, {
+          status: 429,
+          retryAfter
+        });
+        if (attempt < retries) {
+          await sleep(Math.max(retryAfter * 1e3, retryBackoffMs * 2 ** attempt), signal);
+          lastError = err;
+          continue;
+        }
+        throw err;
+      }
+      if (res.status >= 500) {
+        const err = new ToolError(
+          "UPSTREAM_5XX",
+          `Upstream ${res.status}: ${rawText.slice(0, 200)}`,
+          true,
+          { status: res.status }
+        );
+        if (attempt < retries) {
+          await sleep(retryBackoffMs * 2 ** attempt, signal);
+          lastError = err;
+          continue;
+        }
+        throw err;
+      }
+      let data;
+      try {
+        data = rawText ? JSON.parse(rawText) : {};
+      } catch {
+        throw new ToolError("MALFORMED_RESPONSE", "Response is not valid JSON", true, {
+          status: res.status,
+          rawText: rawText.slice(0, 200)
+        });
+      }
+      return { status: res.status, headers: res.headers, data, rawText };
+    } catch (err) {
+      if (err instanceof ToolError) {
+        lastError = err;
+        if (err.retryable && attempt < retries) {
+          await sleep(retryBackoffMs * 2 ** attempt, signal);
+          continue;
+        }
+        throw err;
+      }
+      const isAbort = err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError" || err.message.includes("aborted"));
+      if (isAbort) {
+        const te = new ToolError("UPSTREAM_TIMEOUT", "Upstream request timed out or aborted", true);
+        lastError = te;
+        if (attempt < retries) {
+          await sleep(retryBackoffMs * 2 ** attempt, signal);
+          continue;
+        }
+        throw te;
+      }
+      throw new ToolError(
+        "INTERNAL",
+        err instanceof Error ? err.message : String(err),
+        false,
+        { cause: err }
+      );
+    }
+  }
+  throw lastError instanceof Error ? lastError : new ToolError("INTERNAL", "HTTP request failed", false);
+}
+
+// src/weather/open-meteo-client.ts
+function defaultConfig(overrides = {}) {
+  return {
+    forecastBaseUrl: process.env.OPEN_METEO_FORECAST_URL ?? "https://api.open-meteo.com",
+    geocodingBaseUrl: process.env.OPEN_METEO_GEOCODING_URL ?? "https://geocoding-api.open-meteo.com",
+    timeoutMs: 1e4,
+    retries: 1,
+    ...overrides
+  };
+}
+async function meteoGet(baseUrl, path, params, config) {
+  const url = new URL(path, baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0) url.searchParams.set(k, String(v));
+  }
+  const res = await httpJson(url.toString(), {
+    signal: config.signal,
+    timeoutMs: config.timeoutMs,
+    retries: config.retries
+  });
+  if (res.status >= 400 || res.data && typeof res.data === "object" && "error" in res.data && res.data.error) {
+    const reason = res.data.reason ?? res.rawText.slice(0, 200);
+    const lower = reason.toLowerCase();
+    if (lower.includes("latitude") || lower.includes("longitude")) {
+      throw new ToolError("INVALID_COORDINATES", reason, false, { status: res.status });
+    }
+    if (lower.includes("date") || lower.includes("bad request")) {
+      throw new ToolError("INVALID_DATE_RANGE", reason, false, { status: res.status });
+    }
+    throw new ToolError("INTERNAL", `Open-Meteo error: ${reason}`, false, { status: res.status });
+  }
+  return res.data;
+}
+
+// src/weather/geocode.ts
+async function geocode(city, config = {}) {
+  const cfg = defaultConfig(config);
+  const data = await meteoGet(
+    cfg.geocodingBaseUrl,
+    "/v1/search",
+    { name: city, count: 5, language: "en", format: "json" },
+    cfg
+  );
+  if (!data.results || data.results.length === 0) {
+    throw new ToolError("CITY_NOT_FOUND", `No location found for city: ${city}`, false, { city });
+  }
+  const sorted = [...data.results].sort(
+    (a, b) => (b.population ?? 0) - (a.population ?? 0)
+  );
+  const best = sorted[0];
+  return {
+    name: best.name,
+    latitude: best.latitude,
+    longitude: best.longitude,
+    country: best.country ?? best.country_code ?? "Unknown",
+    admin1: best.admin1,
+    population: best.population,
+    timezone: best.timezone
+  };
+}
+
+// src/weather/wmo-codes.ts
+var WMO = {
+  0: "Clear sky",
+  1: "Mainly clear",
+  2: "Partly cloudy",
+  3: "Overcast",
+  45: "Fog",
+  48: "Depositing rime fog",
+  51: "Light drizzle",
+  53: "Moderate drizzle",
+  55: "Dense drizzle",
+  61: "Slight rain",
+  63: "Moderate rain",
+  65: "Heavy rain",
+  71: "Slight snow",
+  73: "Moderate snow",
+  75: "Heavy snow",
+  80: "Slight rain showers",
+  81: "Moderate rain showers",
+  82: "Violent rain showers",
+  95: "Thunderstorm",
+  96: "Thunderstorm with slight hail",
+  99: "Thunderstorm with heavy hail"
+};
+function describeWmo(code) {
+  return WMO[code] ?? `Unknown weather code ${code}`;
+}
+
+// src/weather/current.ts
+async function getCurrentWeather(latitude, longitude, config = {}) {
+  const cfg = defaultConfig(config);
+  const data = await meteoGet(
+    cfg.forecastBaseUrl,
+    "/v1/forecast",
+    {
+      latitude,
+      longitude,
+      current: "temperature_2m,relative_humidity_2m,precipitation,weather_code,wind_speed_10m",
+      timezone: "auto"
+    },
+    cfg
+  );
+  const c = data.current;
+  return {
+    latitude: data.latitude,
+    longitude: data.longitude,
+    timezone: data.timezone,
+    temperatureC: c.temperature_2m,
+    humidityPercent: c.relative_humidity_2m,
+    precipitationMm: c.precipitation,
+    weatherCode: c.weather_code,
+    weatherDescription: describeWmo(c.weather_code),
+    windSpeedKmh: c.wind_speed_10m,
+    observedAt: c.time
+  };
+}
+
+// src/weather/forecast.ts
+var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+function assertDateRange(startDate, endDate) {
+  if (!DATE_RE.test(startDate) || !DATE_RE.test(endDate)) {
+    throw new ToolError(
+      "INVALID_DATE_RANGE",
+      `Dates must be YYYY-MM-DD. Got start=${startDate}, end=${endDate}`,
+      false
+    );
+  }
+  if (!isValidCalendarDate(startDate) || !isValidCalendarDate(endDate)) {
+    throw new ToolError(
+      "INVALID_DATE_RANGE",
+      `Dates must be valid calendar dates. Got start=${startDate}, end=${endDate}`,
+      false
+    );
+  }
+  if (startDate > endDate) {
+    throw new ToolError(
+      "INVALID_DATE_RANGE",
+      `startDate (${startDate}) must be <= endDate (${endDate})`,
+      false
+    );
+  }
+}
+function isValidCalendarDate(iso) {
+  const [y, m, d] = iso.split("-").map(Number);
+  if (m < 1 || m > 12 || d < 1 || d > 31) return false;
+  const dt = new Date(Date.UTC(y, m - 1, d));
+  return dt.getUTCFullYear() === y && dt.getUTCMonth() === m - 1 && dt.getUTCDate() === d;
+}
+async function getForecast(latitude, longitude, startDate, endDate, config = {}) {
+  assertDateRange(startDate, endDate);
+  const cfg = defaultConfig(config);
+  const data = await meteoGet(
+    cfg.forecastBaseUrl,
+    "/v1/forecast",
+    {
+      latitude,
+      longitude,
+      daily: "temperature_2m_max,temperature_2m_min,precipitation_sum,precipitation_probability_max,weather_code",
+      timezone: "auto",
+      start_date: startDate,
+      end_date: endDate
+    },
+    cfg
+  );
+  const days = data.daily.time.map((date, i) => ({
+    date,
+    tempMaxC: data.daily.temperature_2m_max[i],
+    tempMinC: data.daily.temperature_2m_min[i],
+    precipitationMm: data.daily.precipitation_sum[i],
+    precipitationProbabilityPercent: data.daily.precipitation_probability_max[i],
+    weatherCode: data.daily.weather_code[i],
+    weatherDescription: describeWmo(data.daily.weather_code[i])
+  }));
+  return {
+    latitude: data.latitude,
+    longitude: data.longitude,
+    timezone: data.timezone,
+    startDate,
+    endDate,
+    days
+  };
+}
+
+// src/weather/compare.ts
+function summarize(forecast) {
+  const n = forecast.days.length || 1;
+  const avgTempMaxC = forecast.days.reduce((s, d) => s + d.tempMaxC, 0) / n;
+  const avgTempMinC = forecast.days.reduce((s, d) => s + d.tempMinC, 0) / n;
+  const totalPrecipitationMm = forecast.days.reduce(
+    (s, d) => s + d.precipitationMm,
+    0
+  );
+  const rainyDays = forecast.days.filter((d) => d.precipitationMm > 0.1).length;
+  return {
+    avgTempMaxC: Math.round(avgTempMaxC * 10) / 10,
+    avgTempMinC: Math.round(avgTempMinC * 10) / 10,
+    totalPrecipitationMm: Math.round(totalPrecipitationMm * 10) / 10,
+    rainyDays
+  };
+}
+async function compareWeather(locations, startDate, endDate, config = {}) {
+  const results = await Promise.all(
+    locations.map(async (loc) => {
+      const forecast = await getForecast(
+        loc.latitude,
+        loc.longitude,
+        startDate,
+        endDate,
+        config
+      );
+      return {
+        name: loc.name,
+        forecast,
+        summary: summarize(forecast)
+      };
+    })
+  );
+  return { startDate, endDate, locations: results };
+}
+
+// src/mcp-server/error-envelope.ts
+function toErrorText(err) {
+  const envelope = isAppError(err) ? err.toEnvelope() : {
+    code: "INTERNAL",
+    message: err instanceof Error ? err.message : String(err),
+    retryable: false
+  };
+  return JSON.stringify(envelope);
+}
+function okResult(output) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(output) }],
+    structuredContent: output
+  };
+}
+function errResult(err) {
+  return {
+    content: [{ type: "text", text: toErrorText(err) }],
+    isError: true
+  };
+}
+
+// src/mcp-server/schemas.ts
+import { z } from "zod";
+var LocationSchema = z.object({
+  name: z.string(),
+  latitude: z.number(),
+  longitude: z.number()
+});
+var GeocodeInputSchema = z.object({
+  city: z.string().min(1).describe("City name to geocode, e.g. Moscow")
+});
+var GeocodeOutputSchema = z.object({
+  name: z.string(),
+  latitude: z.number(),
+  longitude: z.number(),
+  country: z.string(),
+  admin1: z.string().optional(),
+  population: z.number().optional(),
+  timezone: z.string().optional()
+});
+var CurrentWeatherInputSchema = z.object({
+  latitude: z.number().min(-90).max(90),
+  longitude: z.number().min(-180).max(180)
+});
+var CurrentWeatherOutputSchema = z.object({
+  latitude: z.number(),
+  longitude: z.number(),
+  timezone: z.string(),
+  temperatureC: z.number(),
+  humidityPercent: z.number(),
+  precipitationMm: z.number(),
+  weatherCode: z.number(),
+  weatherDescription: z.string(),
+  windSpeedKmh: z.number(),
+  observedAt: z.string()
+});
+var ForecastInputSchema = z.object({
+  latitude: z.number().min(-90).max(90),
+  longitude: z.number().min(-180).max(180),
+  startDate: z.string().describe("Start date YYYY-MM-DD"),
+  endDate: z.string().describe("End date YYYY-MM-DD")
+});
+var DailyForecastSchema = z.object({
+  date: z.string(),
+  tempMaxC: z.number(),
+  tempMinC: z.number(),
+  precipitationMm: z.number(),
+  precipitationProbabilityPercent: z.number(),
+  weatherCode: z.number(),
+  weatherDescription: z.string()
+});
+var ForecastOutputSchema = z.object({
+  latitude: z.number(),
+  longitude: z.number(),
+  timezone: z.string(),
+  startDate: z.string(),
+  endDate: z.string(),
+  days: z.array(DailyForecastSchema)
+});
+var CompareWeatherInputSchema = z.object({
+  locations: z.array(LocationSchema).min(2).describe("Locations to compare"),
+  startDate: z.string().describe("Start date YYYY-MM-DD"),
+  endDate: z.string().describe("End date YYYY-MM-DD")
+});
+var CompareWeatherOutputSchema = z.object({
+  startDate: z.string(),
+  endDate: z.string(),
+  locations: z.array(
+    z.object({
+      name: z.string(),
+      forecast: ForecastOutputSchema,
+      summary: z.object({
+        avgTempMaxC: z.number(),
+        avgTempMinC: z.number(),
+        totalPrecipitationMm: z.number(),
+        rainyDays: z.number()
+      })
+    })
+  )
+});
+
+// src/mcp-server/server.ts
+function createWeatherMcpServer() {
+  const server = new McpServer(
+    { name: "open-meteo-weather", version: "1.0.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.registerTool(
+    "geocode",
+    {
+      title: "Geocode city",
+      description: "Resolve a city name to geographic coordinates (latitude, longitude, country). Prefer the most populous match when multiple cities share a name.",
+      inputSchema: GeocodeInputSchema,
+      outputSchema: GeocodeOutputSchema
+    },
+    async ({ city }) => {
+      try {
+        const result = await geocode(city);
+        return okResult(result);
+      } catch (err) {
+        return errResult(err);
+      }
+    }
+  );
+  server.registerTool(
+    "getCurrentWeather",
+    {
+      title: "Current weather",
+      description: "Get current weather conditions for the given coordinates: temperature, humidity, precipitation, wind, and WMO weather description.",
+      inputSchema: CurrentWeatherInputSchema,
+      outputSchema: CurrentWeatherOutputSchema
+    },
+    async ({ latitude, longitude }) => {
+      try {
+        const result = await getCurrentWeather(latitude, longitude);
+        return okResult(result);
+      } catch (err) {
+        return errResult(err);
+      }
+    }
+  );
+  server.registerTool(
+    "getForecast",
+    {
+      title: "Weather forecast",
+      description: "Get daily weather forecast between startDate and endDate (YYYY-MM-DD) for the given coordinates. Returns max/min temperature, precipitation, probability, and weather description per day.",
+      inputSchema: ForecastInputSchema,
+      outputSchema: ForecastOutputSchema
+    },
+    async ({ latitude, longitude, startDate, endDate }) => {
+      try {
+        const result = await getForecast(latitude, longitude, startDate, endDate);
+        return okResult(result);
+      } catch (err) {
+        return errResult(err);
+      }
+    }
+  );
+  server.registerTool(
+    "compareWeather",
+    {
+      title: "Compare weather",
+      description: "Compare weather forecasts across multiple locations for the same date range. Each location needs name, latitude, and longitude. Returns per-location forecast plus summary stats (avg temps, total precipitation, rainy days).",
+      inputSchema: CompareWeatherInputSchema,
+      outputSchema: CompareWeatherOutputSchema
+    },
+    async ({ locations, startDate, endDate }) => {
+      try {
+        const result = await compareWeather(locations, startDate, endDate);
+        return okResult(result);
+      } catch (err) {
+        return errResult(err);
+      }
+    }
+  );
+  return server;
+}
+
+// src/mcp-server/index.ts
+void serveStdio(() => createWeatherMcpServer(), {
+  onerror: (err) => {
+    console.error("[mcp-server]", err.message);
+  }
+});
+console.error("open-meteo-weather MCP server running on stdio");

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "weather-agent-mcp",
+  "version": "0.1.0",
+  "description": "Model-agnostic AI agent with MCP tools over Open-Meteo",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "weather-mcp": "dist/weather-mcp.js",
+    "weather-agent-mcp": "dist/weather-mcp.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE",
+    ".env.example"
+  ],
+  "scripts": {
+    "ask": "node --env-file-if-exists=.env src/cli/ask.ts",
+    "mcp": "node --env-file-if-exists=.env src/mcp-server/index.ts",
+    "build": "esbuild src/mcp-server/index.ts --bundle --platform=node --format=esm --outfile=dist/weather-mcp.js --packages=external",
+    "prepublishOnly": "npm run build",
+    "test": "node --test --test-reporter=spec test/unit/*.test.ts test/integration/*.test.ts",
+    "test:unit": "node --test --test-reporter=spec test/unit/*.test.ts",
+    "test:integration": "node --test --test-reporter=spec test/integration/*.test.ts",
+    "eval": "node --env-file-if-exists=.env src/eval/harness.ts",
+    "typecheck": "tsc --noEmit",
+    "compare-models": "node --env-file-if-exists=.env src/eval/harness.ts --compare",
+    "openspec": "openspec",
+    "openspec:list": "openspec list"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/client": "2.1.0",
+    "@modelcontextprotocol/server": "2.1.0",
+    "zod": "^4.2.0"
+  },
+  "devDependencies": {
+    "@fission-ai/openspec": "^1.13.2",
+    "@types/node": "^22.13.10",
+    "esbuild": "^0.25.0",
+    "typescript": "^5.8.2"
+  }
+}