data-aggregator-mcp 1.0.0

package/src/index.ts

@@ -0,0 +1,461 @@
+#!/usr/bin/env node
+
+/**
+ * Data Aggregator MCP Server
+ *
+ * A unified data server that replaces 5-10 separate MCP servers.
+ * Provides stocks, weather, news, web scraping, exchange rates,
+ * and public data queries through a single installation.
+ *
+ * Transports:
+ *   - stdio (default): for Claude Desktop, CLI tools
+ *   - HTTP/SSE (--sse or --http flag): for remote deployments
+ */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+import { queryStocks } from "./tools/stocks.js";
+import { fetchWebpage } from "./tools/scraper.js";
+import { searchNews } from "./tools/news.js";
+import { queryWeather } from "./tools/weather.js";
+import { queryExchangeRates } from "./tools/exchange.js";
+import { queryPublicData } from "./tools/public-data.js";
+import { cache } from "./utils/cache.js";
+
+// ─── Server Setup ──────────────────────────────────────────────────────────
+
+const server = new McpServer(
+  {
+    name: "data-aggregator",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      logging: {},
+    },
+  }
+);
+
+// ─── Tool Registration ────────────────────────────────────────────────────
+
+// 1. query_stocks
+server.tool(
+  "query_stocks",
+  "Fetch real-time stock and cryptocurrency market data. Supports major stocks (AAPL, MSFT, GOOGL) and crypto (BTC, ETH, SOL). Returns price, daily change, volume, and market cap. Data from Yahoo Finance (stocks) and CoinGecko (crypto).",
+  {
+    symbol: z
+      .string()
+      .describe(
+        "Ticker symbol (e.g., AAPL, MSFT, GOOGL for stocks; BTC, ETH, SOL for crypto)"
+      ),
+    type: z
+      .enum(["stock", "crypto", "auto"])
+      .optional()
+      .default("auto")
+      .describe(
+        'Asset type. "auto" detects based on symbol. Use "stock" or "crypto" to force.'
+      ),
+  },
+  async (args) => queryStocks(args)
+);
+
+// 2. fetch_webpage
+server.tool(
+  "fetch_webpage",
+  "Scrape and extract structured data from any web page. Returns title, meta description, headings, main text content, and links. Optionally extract specific content using a CSS selector (#id, .class, or tag name).",
+  {
+    url: z.string().url().describe("The URL to scrape"),
+    selector: z
+      .string()
+      .optional()
+      .describe(
+        'Optional CSS-like selector to extract specific content (e.g., "#main", ".article-body", "article")'
+      ),
+  },
+  async (args) => fetchWebpage(args)
+);
+
+// 3. search_news
+server.tool(
+  "search_news",
+  "Search and aggregate news articles from multiple sources. Uses NewsAPI.org (if API key configured) or Google News RSS (free, no key). Filter by keyword, category, source, date range, and language.",
+  {
+    query: z
+      .string()
+      .optional()
+      .describe("Search keyword or phrase (e.g., 'artificial intelligence', 'climate change')"),
+    category: z
+      .enum([
+        "business",
+        "entertainment",
+        "general",
+        "health",
+        "science",
+        "sports",
+        "technology",
+      ])
+      .optional()
+      .describe("News category (only with NewsAPI key, ignored with Google News RSS)"),
+    source: z
+      .string()
+      .optional()
+      .describe('Specific news source ID (e.g., "bbc-news", "cnn", "the-verge")'),
+    language: z
+      .string()
+      .optional()
+      .default("en")
+      .describe("Language code (default: en)"),
+    from: z
+      .string()
+      .optional()
+      .describe("Start date for articles (YYYY-MM-DD format, NewsAPI only)"),
+    to: z
+      .string()
+      .optional()
+      .describe("End date for articles (YYYY-MM-DD format, NewsAPI only)"),
+    maxResults: z
+      .number()
+      .int()
+      .min(1)
+      .max(100)
+      .optional()
+      .default(10)
+      .describe("Maximum number of articles to return (1-100, default: 10)"),
+  },
+  async (args) => searchNews(args)
+);
+
+// 4. query_weather
+server.tool(
+  "query_weather",
+  "Get current weather conditions and 7-day forecast. Uses Open-Meteo API (free, no API key required). Accepts city name or coordinates. Returns temperature, humidity, wind, precipitation, and daily forecasts.",
+  {
+    city: z
+      .string()
+      .optional()
+      .describe('City name (e.g., "London", "New York", "Tokyo")'),
+    latitude: z
+      .number()
+      .min(-90)
+      .max(90)
+      .optional()
+      .describe("Latitude (-90 to 90). Use with longitude as alternative to city name."),
+    longitude: z
+      .number()
+      .min(-180)
+      .max(180)
+      .optional()
+      .describe("Longitude (-180 to 180). Use with latitude as alternative to city name."),
+    units: z
+      .enum(["celsius", "fahrenheit"])
+      .optional()
+      .default("celsius")
+      .describe("Temperature units (default: celsius)"),
+  },
+  async (args) => queryWeather(args)
+);
+
+// 5. query_exchange_rates
+server.tool(
+  "query_exchange_rates",
+  "Get currency exchange rates and perform conversions. Supports all major fiat currencies (USD, EUR, GBP, JPY, etc.) and popular cryptocurrencies (BTC, ETH, SOL, etc.). Can fetch historical rates by date.",
+  {
+    base: z
+      .string()
+      .describe(
+        'Base currency code (e.g., "USD", "EUR", "BTC")'
+      ),
+    target: z
+      .string()
+      .describe(
+        'Target currency code (e.g., "GBP", "JPY", "ETH")'
+      ),
+    amount: z
+      .number()
+      .positive()
+      .optional()
+      .default(1)
+      .describe("Amount to convert (default: 1)"),
+    date: z
+      .string()
+      .optional()
+      .describe(
+        "Historical date in YYYY-MM-DD format (fiat only). Omit for current rates."
+      ),
+  },
+  async (args) => queryExchangeRates(args)
+);
+
+// 6. query_public_data
+server.tool(
+  "query_public_data",
+  "Access miscellaneous public data APIs: Wikipedia summaries, IP geolocation, DNS lookups, and URL expansion. Select the sub-command and provide the relevant parameters.",
+  {
+    command: z
+      .enum(["wikipedia", "ip_geolocation", "dns_lookup", "expand_url"])
+      .describe(
+        "Sub-command to run: wikipedia (article summary), ip_geolocation (IP location), dns_lookup (DNS records), expand_url (follow redirects)"
+      ),
+    query: z
+      .string()
+      .optional()
+      .describe('Search term for Wikipedia (e.g., "Theory of relativity")'),
+    ip: z
+      .string()
+      .optional()
+      .describe(
+        'IP address for geolocation (e.g., "8.8.8.8"). Omit to look up your own IP.'
+      ),
+    domain: z
+      .string()
+      .optional()
+      .describe('Domain for DNS lookup (e.g., "example.com")'),
+    recordType: z
+      .enum(["A", "AAAA", "MX", "TXT", "NS", "CNAME", "SOA"])
+      .optional()
+      .default("A")
+      .describe("DNS record type (default: A)"),
+    url: z
+      .string()
+      .optional()
+      .describe('Shortened URL to expand (e.g., "https://bit.ly/xyz")'),
+    language: z
+      .string()
+      .optional()
+      .default("en")
+      .describe("Language code for Wikipedia (default: en)"),
+  },
+  async (args) => queryPublicData(args)
+);
+
+// ─── Transport Selection & Startup ─────────────────────────────────────────
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const useHttp = args.includes("--sse") || args.includes("--http");
+
+  if (useHttp) {
+    // HTTP / SSE transport for remote deployments
+    const portArg = args.find((a) => a.startsWith("--port="));
+    const port = portArg ? parseInt(portArg.split("=")[1]!, 10) : 3000;
+
+    try {
+      const { StreamableHTTPServerTransport } = await import(
+        "@modelcontextprotocol/sdk/server/streamableHttp.js"
+      );
+      const { createServer } = await import("node:http");
+      const { randomUUID } = await import("node:crypto");
+
+      const transports: Record<string, InstanceType<typeof StreamableHTTPServerTransport>> = {};
+
+      const httpServer = createServer(async (req, res) => {
+        // CORS headers
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type, mcp-session-id");
+
+        if (req.method === "OPTIONS") {
+          res.writeHead(204);
+          res.end();
+          return;
+        }
+
+        // Health check endpoint
+        if (req.url === "/health") {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ status: "ok", server: "data-aggregator", version: "1.0.0" }));
+          return;
+        }
+
+        if (req.url !== "/mcp") {
+          res.writeHead(404);
+          res.end("Not found");
+          return;
+        }
+
+        const sessionId = req.headers["mcp-session-id"] as string | undefined;
+
+        // Parse body for POST requests
+        let body: any = undefined;
+        if (req.method === "POST") {
+          const chunks: Buffer[] = [];
+          for await (const chunk of req) {
+            chunks.push(chunk as Buffer);
+          }
+          try {
+            body = JSON.parse(Buffer.concat(chunks).toString());
+          } catch {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Invalid JSON" }));
+            return;
+          }
+        }
+
+        if (req.method === "GET" && sessionId && transports[sessionId]) {
+          await transports[sessionId]!.handleRequest(req, res);
+          return;
+        }
+
+        if (req.method === "POST" && sessionId && transports[sessionId]) {
+          await transports[sessionId]!.handleRequest(req, res, body);
+          return;
+        }
+
+        if (req.method === "POST" && !sessionId) {
+          // New session
+          const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            onsessioninitialized: (id: string) => {
+              transports[id] = transport;
+            },
+          });
+
+          transport.onclose = () => {
+            if (transport.sessionId) {
+              delete transports[transport.sessionId];
+            }
+          };
+
+          const sessionServer = new McpServer(
+            { name: "data-aggregator", version: "1.0.0" },
+            { capabilities: { logging: {} } }
+          );
+
+          // Re-register tools for this session's server
+          registerTools(sessionServer);
+
+          await sessionServer.connect(transport);
+          await transport.handleRequest(req, res, body);
+          return;
+        }
+
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: { code: -32000, message: "Invalid request or session" },
+            id: null,
+          })
+        );
+      });
+
+      httpServer.listen(port, "0.0.0.0", () => {
+        console.error(`Data Aggregator MCP server (HTTP) listening on http://0.0.0.0:${port}/mcp`);
+        console.error(`Health check: http://0.0.0.0:${port}/health`);
+      });
+    } catch (err) {
+      console.error(
+        "Failed to start HTTP transport. Make sure @modelcontextprotocol/node is installed.",
+        err
+      );
+      process.exit(1);
+    }
+  } else {
+    // stdio transport (default) for Claude Desktop, CLI
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Data Aggregator MCP server started (stdio transport)");
+  }
+}
+
+/**
+ * Register all tools on a given McpServer instance.
+ * Used for per-session servers in HTTP mode.
+ */
+function registerTools(s: McpServer): void {
+  s.tool(
+    "query_stocks",
+    "Fetch real-time stock and cryptocurrency market data.",
+    {
+      symbol: z.string().describe("Ticker symbol (e.g., AAPL, BTC)"),
+      type: z.enum(["stock", "crypto", "auto"]).optional().default("auto")
+        .describe('Asset type. "auto" detects based on symbol.'),
+    },
+    async (args) => queryStocks(args)
+  );
+
+  s.tool(
+    "fetch_webpage",
+    "Scrape and extract structured data from any web page.",
+    {
+      url: z.string().url().describe("The URL to scrape"),
+      selector: z.string().optional()
+        .describe("Optional CSS-like selector to extract specific content"),
+    },
+    async (args) => fetchWebpage(args)
+  );
+
+  s.tool(
+    "search_news",
+    "Search and aggregate news articles from multiple sources.",
+    {
+      query: z.string().optional().describe("Search keyword or phrase"),
+      category: z.enum(["business", "entertainment", "general", "health", "science", "sports", "technology"]).optional(),
+      source: z.string().optional().describe("Specific news source ID"),
+      language: z.string().optional().default("en"),
+      from: z.string().optional().describe("Start date (YYYY-MM-DD)"),
+      to: z.string().optional().describe("End date (YYYY-MM-DD)"),
+      maxResults: z.number().int().min(1).max(100).optional().default(10),
+    },
+    async (args) => searchNews(args)
+  );
+
+  s.tool(
+    "query_weather",
+    "Get current weather conditions and 7-day forecast via Open-Meteo.",
+    {
+      city: z.string().optional().describe("City name"),
+      latitude: z.number().min(-90).max(90).optional(),
+      longitude: z.number().min(-180).max(180).optional(),
+      units: z.enum(["celsius", "fahrenheit"]).optional().default("celsius"),
+    },
+    async (args) => queryWeather(args)
+  );
+
+  s.tool(
+    "query_exchange_rates",
+    "Get currency exchange rates and perform conversions.",
+    {
+      base: z.string().describe("Base currency code"),
+      target: z.string().describe("Target currency code"),
+      amount: z.number().positive().optional().default(1),
+      date: z.string().optional().describe("Historical date (YYYY-MM-DD)"),
+    },
+    async (args) => queryExchangeRates(args)
+  );
+
+  s.tool(
+    "query_public_data",
+    "Access Wikipedia, IP geolocation, DNS lookup, and URL expansion.",
+    {
+      command: z.enum(["wikipedia", "ip_geolocation", "dns_lookup", "expand_url"]),
+      query: z.string().optional(),
+      ip: z.string().optional(),
+      domain: z.string().optional(),
+      recordType: z.enum(["A", "AAAA", "MX", "TXT", "NS", "CNAME", "SOA"]).optional().default("A"),
+      url: z.string().optional(),
+      language: z.string().optional().default("en"),
+    },
+    async (args) => queryPublicData(args)
+  );
+}
+
+// ─── Graceful shutdown ─────────────────────────────────────────────────────
+
+function shutdown(): void {
+  console.error("Shutting down Data Aggregator MCP server...");
+  cache.destroy();
+  process.exit(0);
+}
+
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+
+// ─── Start ─────────────────────────────────────────────────────────────────
+
+main().catch((err) => {
+  console.error("Fatal error starting server:", err);
+  process.exit(1);
+});

package/src/tools/exchange.ts

@@ -0,0 +1,241 @@
+/**
+ * query_exchange_rates - Currency exchange rates and conversion.
+ *
+ * Data sources:
+ *   - Open Exchange Rates / frankfurter.app (free, no key required)
+ *   - CoinGecko for crypto-to-fiat rates (free, no key required)
+ */
+
+import { cache, TTL } from "../utils/cache.js";
+import { rateLimiter } from "../utils/rate-limiter.js";
+import { httpGetJson, formatError } from "../utils/http.js";
+import type { ExchangeRate, CurrencyConversion, ToolResult } from "../types.js";
+
+// ─── Common crypto symbols ─────────────────────────────────────────────────
+
+const CRYPTO_IDS: Record<string, string> = {
+  BTC: "bitcoin",
+  ETH: "ethereum",
+  SOL: "solana",
+  XRP: "ripple",
+  ADA: "cardano",
+  DOT: "polkadot",
+  DOGE: "dogecoin",
+  LTC: "litecoin",
+  BNB: "binancecoin",
+  AVAX: "avalanche-2",
+  LINK: "chainlink",
+  MATIC: "matic-network",
+  UNI: "uniswap",
+};
+
+function isCryptoSymbol(sym: string): boolean {
+  return sym.toUpperCase() in CRYPTO_IDS;
+}
+
+// ─── Fiat rates via frankfurter.app ────────────────────────────────────────
+
+async function fetchFiatRate(base: string, target: string): Promise<ExchangeRate> {
+  const b = base.toUpperCase();
+  const t = target.toUpperCase();
+
+  const url = `https://api.frankfurter.app/latest?from=${b}&to=${t}`;
+  await rateLimiter.acquire("exchangerate");
+
+  const data: any = await httpGetJson(url);
+  const rate = data.rates?.[t];
+
+  if (rate === undefined) {
+    throw new Error(`No exchange rate found for ${b} -> ${t}`);
+  }
+
+  return {
+    base: b,
+    target: t,
+    rate,
+    timestamp: data.date ?? new Date().toISOString(),
+    source: "Frankfurter (ECB)",
+  };
+}
+
+async function fetchFiatRatesMultiple(
+  base: string,
+  targets: string[]
+): Promise<ExchangeRate[]> {
+  const b = base.toUpperCase();
+  const t = targets.map((s) => s.toUpperCase()).join(",");
+
+  const url = `https://api.frankfurter.app/latest?from=${b}&to=${t}`;
+  await rateLimiter.acquire("exchangerate");
+
+  const data: any = await httpGetJson(url);
+  const rates: ExchangeRate[] = [];
+
+  for (const [sym, rate] of Object.entries(data.rates ?? {})) {
+    rates.push({
+      base: b,
+      target: sym,
+      rate: rate as number,
+      timestamp: data.date ?? new Date().toISOString(),
+      source: "Frankfurter (ECB)",
+    });
+  }
+
+  return rates;
+}
+
+// ─── Historical fiat rates ─────────────────────────────────────────────────
+
+async function fetchHistoricalRate(
+  base: string,
+  target: string,
+  date: string
+): Promise<ExchangeRate> {
+  const b = base.toUpperCase();
+  const t = target.toUpperCase();
+
+  const url = `https://api.frankfurter.app/${date}?from=${b}&to=${t}`;
+  await rateLimiter.acquire("exchangerate");
+
+  const data: any = await httpGetJson(url);
+  const rate = data.rates?.[t];
+
+  if (rate === undefined) {
+    throw new Error(`No historical rate found for ${b} -> ${t} on ${date}`);
+  }
+
+  return {
+    base: b,
+    target: t,
+    rate,
+    timestamp: data.date ?? date,
+    source: "Frankfurter (ECB)",
+  };
+}
+
+// ─── Crypto-to-fiat via CoinGecko ─────────────────────────────────────────
+
+async function fetchCryptoRate(crypto: string, fiat: string): Promise<ExchangeRate> {
+  const c = crypto.toUpperCase();
+  const coinId = CRYPTO_IDS[c];
+  if (!coinId) {
+    throw new Error(`Unknown crypto symbol: ${c}. Supported: ${Object.keys(CRYPTO_IDS).join(", ")}`);
+  }
+
+  const f = fiat.toLowerCase();
+  const url = `https://api.coingecko.com/api/v3/simple/price?ids=${coinId}&vs_currencies=${f}`;
+  await rateLimiter.acquire("coingecko");
+
+  const data: any = await httpGetJson(url);
+  const rate = data[coinId]?.[f];
+
+  if (rate === undefined) {
+    throw new Error(`No rate found for ${c} -> ${fiat.toUpperCase()}`);
+  }
+
+  return {
+    base: c,
+    target: fiat.toUpperCase(),
+    rate,
+    timestamp: new Date().toISOString(),
+    source: "CoinGecko",
+  };
+}
+
+// ─── Public handler ────────────────────────────────────────────────────────
+
+export async function queryExchangeRates(args: {
+  base: string;
+  target: string;
+  amount?: number;
+  date?: string;
+}): Promise<ToolResult> {
+  try {
+    const base = args.base.trim().toUpperCase();
+    const target = args.target.trim().toUpperCase();
+    const amount = args.amount ?? 1;
+    const date = args.date?.trim();
+
+    // Determine if this involves crypto
+    const baseCrypto = isCryptoSymbol(base);
+    const targetCrypto = isCryptoSymbol(target);
+
+    const cacheKey = `exchange:${base}:${target}:${date ?? "latest"}`;
+    const cached = cache.get<ExchangeRate>(cacheKey);
+
+    let exchangeRate: ExchangeRate;
+
+    if (cached) {
+      exchangeRate = cached;
+    } else if (baseCrypto && !targetCrypto) {
+      // Crypto -> Fiat
+      exchangeRate = await fetchCryptoRate(base, target);
+    } else if (!baseCrypto && targetCrypto) {
+      // Fiat -> Crypto (invert crypto -> fiat)
+      const inverse = await fetchCryptoRate(target, base);
+      exchangeRate = {
+        base,
+        target,
+        rate: inverse.rate > 0 ? 1 / inverse.rate : 0,
+        timestamp: inverse.timestamp,
+        source: inverse.source,
+      };
+    } else if (baseCrypto && targetCrypto) {
+      // Crypto -> Crypto (go through USD)
+      const baseToUsd = await fetchCryptoRate(base, "USD");
+      const targetToUsd = await fetchCryptoRate(target, "USD");
+      exchangeRate = {
+        base,
+        target,
+        rate: targetToUsd.rate > 0 ? baseToUsd.rate / targetToUsd.rate : 0,
+        timestamp: new Date().toISOString(),
+        source: "CoinGecko",
+      };
+    } else if (date) {
+      // Historical fiat rate
+      exchangeRate = await fetchHistoricalRate(base, target, date);
+    } else {
+      // Current fiat rate
+      exchangeRate = await fetchFiatRate(base, target);
+    }
+
+    cache.set(cacheKey, exchangeRate, TTL.EXCHANGE);
+
+    // Build conversion result
+    const conversion: CurrencyConversion = {
+      from: base,
+      to: target,
+      amount,
+      convertedAmount: +(amount * exchangeRate.rate).toFixed(6),
+      rate: exchangeRate.rate,
+      timestamp: exchangeRate.timestamp,
+    };
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              exchangeRate,
+              conversion,
+              cached: !!cached,
+            },
+            null,
+            2
+          ),
+        },
+      ],
+    };
+  } catch (err) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error fetching exchange rates: ${formatError(err)}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+}