ipgeolocation-io-mcp 1.0.0

package/dist/tools/geolocation.js

@@ -0,0 +1,261 @@
+import { z } from "zod";
+import { getIpGeolocation, getIpGeolocationBulk, getMyIp } from "../client.js";
+export function registerGeolocationTools(server) {
+    server.registerTool("lookup_ip", {
+        title: "IP Geolocation Lookup",
+        annotations: {
+            readOnlyHint: true,
+        },
+        description: `Look up geolocation data for a single IP address or domain using ipgeolocation.io's unified endpoint (GET /v3/ipgeo). Costs 1 credit per request on all plans.
+
+FREE PLAN returns: ip, location (continent, country, state, district, city, zipcode, latitude, longitude, is_eu, country_flag, country_emoji, geoname_id), country_metadata (calling_code, tld, languages), currency (code, name, symbol), time_zone (name, offset, DST info, current_time), and basic ASN (as_number, organization, country). The fields and excludes parameters work on the free plan. Domain lookups and the include parameter are not available on the free plan. The lang parameter returns a 401 error on the free plan for any language other than en.
+
+PAID PLANS return everything above plus: network (connection_type, route, is_anycast), company (name, type, domain), and extended ASN (as_number, organization, country, type, domain, date_allocated, rir). The ASN object identifies the organization that holds the IP block allocation from a Regional Internet Registry (ARIN, RIPE, APNIC, etc.). The company object identifies the organization actually using the IP address. These are often the same, but differ when the ASN holder subleases IP space to another organization. For example, the ASN holder might be a cloud provider like Amazon while the company is a business running its infrastructure on that cloud. Paid plans also enable the include parameter to add extra modules: security (+2 credits, 3 total), abuse (+1 credit, 2 total), hostname (+0), liveHostname (+0), hostnameFallbackLive (+0), user_agent (+0), geo_accuracy (+0), dma_code (+0), or * for all (4 credits total). Paid plans support the lang parameter for non-English responses and can look up domains in addition to IPs. Tip: use include=security&fields=security to get only security data for 2 credits instead of 3.
+
+If no IP is provided, returns data for the caller's IP. For basic ASN info on the free plan, use this tool. For detailed ASN data (peers, routes, WHOIS), use lookup_asn instead (paid only). For standalone security checks at 2 credits each, use check_security instead. For standalone abuse lookups at 1 credit, use get_abuse_contact instead.`,
+        inputSchema: {
+            ip: z
+                .string()
+                .optional()
+                .describe("IPv4 address, IPv6 address, or domain name to look up. Domain lookups require a paid plan. Omit to use the caller's IP."),
+            lang: z
+                .string()
+                .optional()
+                .describe("Response language code (en, de, ru, ja, fr, cn, es, cs, it, ko, fa, pt). Paid plans only. Free plan returns a 401 error if you pass any value other than en. Defaults to en."),
+            include: z
+                .string()
+                .optional()
+                .describe("Comma-separated extra modules to include in the response. Paid plans only. Options: security (+2 credits), abuse (+1 credit), hostname, liveHostname, hostnameFallbackLive, user_agent, geo_accuracy, dma_code, or * for all (4 credits total). Free plan cannot use this parameter."),
+            fields: z
+                .string()
+                .optional()
+                .describe("Comma-separated dot-path fields to return (e.g. location.city,asn.organization). Works on all plans including free. Reduces response size and can reduce credit cost when combined with include."),
+            excludes: z
+                .string()
+                .optional()
+                .describe("Comma-separated dot-path fields to exclude from response (e.g. currency,location.continent_code). Works on all plans including free."),
+        },
+    }, async (params) => {
+        try {
+            const result = await getIpGeolocation(params);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("bulk_lookup_ip", {
+        title: "Bulk IP Geolocation",
+        annotations: {
+            readOnlyHint: true,
+        },
+        description: `Look up geolocation data for multiple IP addresses in a single request using ipgeolocation.io's bulk endpoint (POST /v3/ipgeo-bulk). Accepts up to 50,000 IPs per request. Paid plans only. Free plan returns 401 Unauthorized.
+
+Costs 1 credit per IP for base geolocation data. Each IP in the response contains the same fields as a single lookup_ip call on a paid plan: ip, location, country_metadata, currency, time_zone, network, company, and extended ASN (as_number, organization, country, type, domain, date_allocated, rir).
+
+Optional include modules add credits per IP: security (+2 per IP), abuse (+1 per IP), hostname (+0), liveHostname (+0), hostnameFallbackLive (+0), user_agent (+0), geo_accuracy (+0), dma_code (+0), or * for all (4 credits per IP total).
+
+Returns a JSON array with one geolocation object per IP. Use this tool when you need to look up more than one IP at a time. For a single IP lookup, use lookup_ip instead. For bulk security-only checks, use bulk_security_check instead (2 credits per IP).`,
+        inputSchema: {
+            ips: z
+                .array(z.string())
+                .min(1)
+                .max(50000)
+                .describe("Array of IPv4 and/or IPv6 addresses to look up. Minimum 1, maximum 50,000. Domain names are also accepted."),
+            lang: z
+                .string()
+                .optional()
+                .describe("Response language code (en, de, ru, ja, fr, cn, es, cs, it, ko, fa, pt). Defaults to en."),
+            include: z
+                .string()
+                .optional()
+                .describe("Comma-separated extra modules to include per IP. Options: security (+2 credits/IP), abuse (+1 credit/IP), hostname, liveHostname, hostnameFallbackLive, user_agent, geo_accuracy, dma_code, or * for all (4 credits/IP total)."),
+            fields: z
+                .string()
+                .optional()
+                .describe("Comma-separated dot-path fields to return per IP (e.g. location.city,asn.organization). Reduces response size and can reduce credit cost when combined with include."),
+            excludes: z
+                .string()
+                .optional()
+                .describe("Comma-separated dot-path fields to exclude per IP (e.g. currency,time_zone)."),
+        },
+    }, async (params) => {
+        try {
+            const result = await getIpGeolocationBulk(params);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("get_my_ip", {
+        title: "Get My IP Address",
+        annotations: {
+            readOnlyHint: true,
+        },
+        description: "Get the public IP address of the machine running this MCP server. No API key required. No credits charged. Uses the /v3/getip endpoint. Useful for discovering the server's own IP before doing a geolocation lookup with lookup_ip.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            const ip = await getMyIp();
+            return {
+                content: [{ type: "text", text: ip }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("lookup_company", {
+        title: "Company/Organization Lookup",
+        annotations: {
+            readOnlyHint: true,
+        },
+        description: `Identify the organization using a specific IP address. Uses ipgeolocation.io's unified endpoint (GET /v3/ipgeo) with fields filtered to company and ASN data. Paid plans only. Free plan does not return company data. Costs 1 credit.
+
+Returns two objects: company (name, type, domain) and asn (as_number, organization, country, type, domain, date_allocated, rir). The ASN object identifies the organization that holds the IP block allocation from a Regional Internet Registry (ARIN, RIPE, APNIC, etc.). The company object identifies the organization actually using the IP address. These are often the same, but differ when the ASN holder subleases IP space to another organization. For example, 1.1.1.1 has ASN organization "Cloudflare, Inc." (who routes it) but company "APNIC Research and Development" (who owns the block).
+
+Use this tool when you need to know which company or organization is behind an IP address. For full geolocation data including company, use lookup_ip instead. For detailed ASN data (peers, routes, WHOIS), use lookup_asn instead.`,
+        inputSchema: {
+            ip: z
+                .string()
+                .optional()
+                .describe("IPv4 or IPv6 address to look up. Omit to check the caller's IP."),
+        },
+    }, async (params) => {
+        try {
+            const result = await getIpGeolocation({
+                ip: params.ip,
+                fields: "company,asn",
+            });
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("lookup_currency", {
+        title: "Currency and Country Metadata",
+        annotations: {
+            readOnlyHint: true,
+        },
+        description: `Get the local currency and country metadata for any IP address. Uses ipgeolocation.io's unified endpoint (GET /v3/ipgeo) with fields filtered to currency and country_metadata. Works on all plans including free. Costs 1 credit.
+
+Returns two objects: currency (code, name, symbol) and country_metadata (calling_code, tld, languages). For example, a Japanese IP returns currency {code: "JPY", name: "Japanese Yen", symbol: "¥"} and country_metadata {calling_code: "+81", tld: ".jp", languages: ["ja"]}.
+
+Use this tool when you need to know the currency, international calling code, country TLD, or spoken languages for an IP's country. For full geolocation data, use lookup_ip instead.`,
+        inputSchema: {
+            ip: z
+                .string()
+                .optional()
+                .describe("IPv4 or IPv6 address to look up. Omit to check the caller's IP."),
+        },
+    }, async (params) => {
+        try {
+            const result = await getIpGeolocation({
+                ip: params.ip,
+                fields: "currency,country_metadata",
+            });
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("lookup_network", {
+        title: "Network/Routing Info",
+        annotations: {
+            readOnlyHint: true,
+        },
+        description: `Get network routing information for any IP address, including whether it uses anycast. Uses ipgeolocation.io's unified endpoint (GET /v3/ipgeo) with fields filtered to network data. Paid plans only. Free plan does not return network data. Costs 1 credit.
+
+Returns: network (connection_type, route, is_anycast). The route field shows the announced BGP prefix (e.g. "1.1.1.0/24"). The is_anycast field indicates whether the IP is served from multiple geographic locations using anycast routing. The connection_type field identifies the type of network connection when available.
+
+Use this tool when you need to check if an IP is anycast, find its BGP route prefix, or identify its connection type. For full geolocation data including network, use lookup_ip instead.`,
+        inputSchema: {
+            ip: z
+                .string()
+                .optional()
+                .describe("IPv4 or IPv6 address to look up. Omit to check the caller's IP."),
+        },
+    }, async (params) => {
+        try {
+            const result = await getIpGeolocation({
+                ip: params.ip,
+                fields: "network",
+            });
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/security.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerSecurityTools(server: McpServer): void;

package/dist/tools/security.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { getSecurity, getSecurityBulk } from "../client.js";
+export function registerSecurityTools(server) {
+    server.registerTool("check_security", {
+        title: "VPN/Proxy/Threat Detection",
+        annotations: {
+            readOnlyHint: true,
+        },
+        description: `Check if an IP address is a VPN, proxy, Tor node, bot, or known attacker using ipgeolocation.io's dedicated security endpoint (GET /v3/security). Paid plans only. Free plan returns 401 Unauthorized. Costs 2 credits per lookup.
+
+Returns: threat_score (0-100), is_tor, is_proxy, proxy_provider_names, proxy_confidence_score (0-100), proxy_last_seen, is_residential_proxy, is_vpn, vpn_provider_names, vpn_confidence_score (0-100), vpn_last_seen, is_relay, relay_provider_name, is_anonymous, is_known_attacker, is_bot, is_spam, is_cloud_provider, cloud_provider_name.
+
+This is the same security data you get from lookup_ip with include=security, but using this dedicated endpoint costs 2 credits instead of 3 (because you skip the base geolocation). If you need both geolocation and security data together, use lookup_ip with include=security (3 credits) instead. If you only need security data, this tool is cheaper. For checking multiple IPs at once, use bulk_security_check instead.`,
+        inputSchema: {
+            ip: z
+                .string()
+                .optional()
+                .describe("IPv4 or IPv6 address to check. Omit to check the caller's IP."),
+            fields: z
+                .string()
+                .optional()
+                .describe("Comma-separated dot-path fields to return (e.g. security.threat_score,security.is_vpn). Reduces response size."),
+            excludes: z
+                .string()
+                .optional()
+                .describe("Comma-separated dot-path fields to exclude (e.g. security.is_tor,security.is_cloud_provider)."),
+        },
+    }, async (params) => {
+        try {
+            const result = await getSecurity(params);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("bulk_security_check", {
+        title: "Bulk Security Check",
+        annotations: {
+            readOnlyHint: true,
+        },
+        description: `Check up to 50,000 IP addresses for VPN, proxy, Tor, bot, and threat indicators in a single request using ipgeolocation.io's bulk security endpoint (POST /v3/security-bulk). Paid plans only. Free plan returns 401 Unauthorized. Costs 2 credits per valid IP in the request.
+
+Returns a JSON array of security assessment objects, one per IP. Each object contains the same fields as check_security: threat_score, is_tor, is_proxy, proxy_provider_names, proxy_confidence_score, is_vpn, vpn_provider_names, vpn_confidence_score, is_bot, is_spam, is_known_attacker, is_anonymous, is_cloud_provider, and more.
+
+Use this tool when you need security checks on multiple IPs at once. For a single IP, use check_security instead. If you also need geolocation data with security, use bulk_lookup_ip with include=security instead (but that costs 3 credits per IP vs 2 credits per IP here).`,
+        inputSchema: {
+            ips: z
+                .array(z.string())
+                .min(1)
+                .max(50000)
+                .describe("Array of IPv4 and/or IPv6 addresses to check. Minimum 1, maximum 50,000."),
+            fields: z
+                .string()
+                .optional()
+                .describe("Comma-separated dot-path fields to return per IP (e.g. security.threat_score,security.is_vpn). Reduces response size."),
+            excludes: z
+                .string()
+                .optional()
+                .describe("Comma-separated dot-path fields to exclude per IP (e.g. security.is_tor,security.is_cloud_provider)."),
+        },
+    }, async (params) => {
+        try {
+            const result = await getSecurityBulk(params);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/timezone.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerTimezoneTools(server: McpServer): void;

package/dist/tools/timezone.js

@@ -0,0 +1,168 @@
+import { z } from "zod";
+import { getTimezone, convertTimezone } from "../client.js";
+export function registerTimezoneTools(server) {
+    server.registerTool("get_timezone", {
+        title: "Timezone Lookup",
+        annotations: {
+            readOnlyHint: true,
+        },
+        description: `Get current time and timezone details for any location using ipgeolocation.io (GET /v3/timezone). Works on all plans including free. Costs 1 credit per request.
+
+Look up by IANA timezone name, coordinates, city/address, IP address, IATA airport code, ICAO airport code, or UN/LOCODE. All lookup modes work on both free and paid plans. If no parameters are provided, returns timezone data for the caller's IP.
+
+Returns: timezone name, UTC offset, offset with DST, current_time, current_time_unix, timezone abbreviations (standard and DST), is_dst flag, dst_savings, dst_exists, dst_start, dst_end. Airport code lookups also return airport name, city, elevation, and coordinates.
+
+The lang parameter for non-English responses is available on paid plans only. Free plan returns English responses regardless of the lang value.`,
+        inputSchema: {
+            tz: z
+                .string()
+                .optional()
+                .describe("IANA timezone name (e.g. America/New_York, Europe/London). Highest priority if multiple params provided."),
+            lat: z
+                .string()
+                .optional()
+                .describe("Latitude coordinate. Must be used together with long."),
+            long: z
+                .string()
+                .optional()
+                .describe("Longitude coordinate. Must be used together with lat."),
+            location: z
+                .string()
+                .optional()
+                .describe("City or address string (e.g. London, UK)."),
+            ip: z
+                .string()
+                .optional()
+                .describe("IPv4 or IPv6 address to get timezone for."),
+            iata_code: z
+                .string()
+                .optional()
+                .describe("3-letter IATA airport code (e.g. JFK, LHR). Returns airport details in the response."),
+            icao_code: z
+                .string()
+                .optional()
+                .describe("4-letter ICAO airport code (e.g. KJFK, EGLL). Returns airport details in the response."),
+            lo_code: z
+                .string()
+                .optional()
+                .describe("5-character UN/LOCODE (e.g. DEBER, USNYC)."),
+            lang: z
+                .string()
+                .optional()
+                .describe("Response language for location fields in IP-based lookups (en, de, ru, ja, fr, cn, es, cs, it, ko, fa, pt). Paid plans only. Free plan returns English."),
+        },
+    }, async (params) => {
+        try {
+            const result = await getTimezone(params);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("convert_timezone", {
+        title: "Timezone Conversion",
+        annotations: {
+            readOnlyHint: true,
+        },
+        description: `Convert time between two locations using ipgeolocation.io (GET /v3/timezone/convert). Works on all plans including free. Costs 1 credit per request.
+
+Specify source and destination by IANA timezone name, coordinates, city/address, IATA airport code, ICAO airport code, or UN/LOCODE. All location modes work on both free and paid plans.
+
+Returns: original time, converted time, diff_hour, and diff_min between the two locations. If no time is specified, converts the current time.`,
+        inputSchema: {
+            time: z
+                .string()
+                .optional()
+                .describe("Time to convert in yyyy-MM-dd HH:mm or yyyy-MM-dd HH:mm:ss format. Defaults to current time."),
+            tz_from: z
+                .string()
+                .optional()
+                .describe("Source IANA timezone name (e.g. America/New_York)."),
+            tz_to: z
+                .string()
+                .optional()
+                .describe("Destination IANA timezone name (e.g. Asia/Tokyo)."),
+            lat_from: z
+                .string()
+                .optional()
+                .describe("Source latitude. Use with long_from."),
+            long_from: z
+                .string()
+                .optional()
+                .describe("Source longitude. Use with lat_from."),
+            lat_to: z
+                .string()
+                .optional()
+                .describe("Destination latitude. Use with long_to."),
+            long_to: z
+                .string()
+                .optional()
+                .describe("Destination longitude. Use with lat_to."),
+            location_from: z
+                .string()
+                .optional()
+                .describe("Source city or address string."),
+            location_to: z
+                .string()
+                .optional()
+                .describe("Destination city or address string."),
+            iata_from: z
+                .string()
+                .optional()
+                .describe("Source 3-letter IATA airport code."),
+            iata_to: z
+                .string()
+                .optional()
+                .describe("Destination 3-letter IATA airport code."),
+            icao_from: z
+                .string()
+                .optional()
+                .describe("Source 4-letter ICAO airport code."),
+            icao_to: z
+                .string()
+                .optional()
+                .describe("Destination 4-letter ICAO airport code."),
+            locode_from: z
+                .string()
+                .optional()
+                .describe("Source 5-character UN/LOCODE."),
+            locode_to: z
+                .string()
+                .optional()
+                .describe("Destination 5-character UN/LOCODE."),
+        },
+    }, async (params) => {
+        try {
+            const result = await convertTimezone(params);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/useragent.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerUserAgentTools(server: McpServer): void;

package/dist/tools/useragent.js

@@ -0,0 +1,78 @@
+import { z } from "zod";
+import { parseUserAgent, parseUserAgentBulk } from "../client.js";
+export function registerUserAgentTools(server) {
+    server.registerTool("parse_user_agent", {
+        title: "User-Agent Parser",
+        annotations: {
+            readOnlyHint: true,
+        },
+        description: `Parse a user-agent string into structured device, browser, OS, and engine details using ipgeolocation.io's dedicated User-Agent endpoint (POST /v3/user-agent). Paid plans only. Free plan returns 401 Unauthorized. Costs 1 credit per request.
+
+Returns: user_agent_string, name (browser/bot name), type (Browser, Crawler, etc.), version, version_major, device (name, type, brand, cpu), engine (name, type, version, version_major), operating_system (name, type, version, version_major, build).
+
+This is the same user-agent data you can get from lookup_ip with include=user_agent, but that always parses the caller's User-Agent header and costs 1 credit for base geolocation plus 0 for the UA module. This dedicated endpoint lets you parse any arbitrary user-agent string you supply without doing an IP lookup. For parsing multiple UA strings at once, use bulk_parse_user_agent instead.`,
+        inputSchema: {
+            uaString: z
+                .string()
+                .describe("The user-agent string to parse (e.g. Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36)."),
+        },
+    }, async (params) => {
+        try {
+            const result = await parseUserAgent(params);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("bulk_parse_user_agent", {
+        title: "Bulk User-Agent Parser",
+        annotations: {
+            readOnlyHint: true,
+        },
+        description: `Parse up to 50,000 user-agent strings in a single request using ipgeolocation.io's bulk User-Agent endpoint (POST /v3/user-agent-bulk). Paid plans only. Free plan returns 401 Unauthorized. Costs 1 credit per user-agent string.
+
+Returns a JSON array of parsed user-agent objects. Each object contains the same fields as parse_user_agent: user_agent_string, name, type, version, version_major, device (name, type, brand, cpu), engine (name, type, version, version_major), operating_system (name, type, version, version_major, build).
+
+Use this tool when you need to parse multiple user-agent strings at once. For a single UA string, use parse_user_agent instead.`,
+        inputSchema: {
+            uaStrings: z
+                .array(z.string())
+                .min(1)
+                .max(50000)
+                .describe("Array of user-agent strings to parse. Minimum 1, maximum 50,000."),
+        },
+    }, async (params) => {
+        try {
+            const result = await parseUserAgentBulk(params);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}