@brave/brave-search-mcp-server 1.3.1

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Anthropic, PBC
+Copyright (c) 2025 Brave Software, Inc
+
+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,305 @@
+# Brave Search MCP Server
+
+An MCP server implementation that integrates the Brave Search API, providing comprehensive search capabilities including web search, local business search, image search, video search, news search, and AI-powered summarization. This project supports both HTTP and STDIO transports, with HTTP as the default mode.
+
+## Tools
+
+### Web Search (`brave_web_search`)
+Performs comprehensive web searches with rich result types and advanced filtering options.
+
+**Parameters:**
+- `query` (string, required): Search terms (max 400 chars, 50 words)
+- `country` (string, optional): Country code (default: "US")
+- `search_lang` (string, optional): Search language (default: "en")
+- `ui_lang` (string, optional): UI language (default: "en-US")
+- `count` (number, optional): Results per page (1-20, default: 10)
+- `offset` (number, optional): Pagination offset (max 9, default: 0)
+- `safesearch` (string, optional): Content filtering ("off", "moderate", "strict", default: "moderate")
+- `freshness` (string, optional): Time filter ("pd", "pw", "pm", "py", or date range)
+- `text_decorations` (boolean, optional): Include highlighting markers (default: true)
+- `spellcheck` (boolean, optional): Enable spell checking (default: true)
+- `result_filter` (array, optional): Filter result types (default: ["web", "query"])
+- `goggles` (array, optional): Custom re-ranking definitions
+- `units` (string, optional): Measurement units ("metric" or "imperial")
+- `extra_snippets` (boolean, optional): Get additional excerpts (Pro plans only)
+- `summary` (boolean, optional): Enable summary key generation for AI summarization
+
+### Local Search (`brave_local_search`)
+Searches for local businesses and places with detailed information including ratings, hours, and AI-generated descriptions.
+
+**Parameters:**
+- Same as `brave_web_search` with automatic location filtering
+- Automatically includes "web" and "locations" in result_filter
+
+**Note:** Requires Pro plan for full local search capabilities. Falls back to web search otherwise.
+
+### Video Search (`brave_video_search`)
+Searches for videos with comprehensive metadata and thumbnail information.
+
+**Parameters:**
+- `query` (string, required): Search terms (max 400 chars, 50 words)
+- `country` (string, optional): Country code (default: "US")
+- `search_lang` (string, optional): Search language (default: "en")
+- `ui_lang` (string, optional): UI language (default: "en-US")
+- `count` (number, optional): Results per page (1-50, default: 20)
+- `offset` (number, optional): Pagination offset (max 9, default: 0)
+- `spellcheck` (boolean, optional): Enable spell checking (default: true)
+- `safesearch` (string, optional): Content filtering ("off", "moderate", "strict", default: "moderate")
+- `freshness` (string, optional): Time filter ("pd", "pw", "pm", "py", or date range)
+
+### Image Search (`brave_image_search`)
+Searches for images with automatic fetching and base64 encoding for direct display.
+
+**Parameters:**
+- `query` (string, required): Search terms (max 400 chars, 50 words)
+- `country` (string, optional): Country code (default: "US")
+- `search_lang` (string, optional): Search language (default: "en")
+- `count` (number, optional): Results per page (1-200, default: 50)
+- `safesearch` (string, optional): Content filtering ("off", "strict", default: "strict")
+- `spellcheck` (boolean, optional): Enable spell checking (default: true)
+
+### News Search (`brave_news_search`)
+Searches for current news articles with freshness controls and breaking news indicators.
+
+**Parameters:**
+- `query` (string, required): Search terms (max 400 chars, 50 words)
+- `country` (string, optional): Country code (default: "US")
+- `search_lang` (string, optional): Search language (default: "en")
+- `ui_lang` (string, optional): UI language (default: "en-US")
+- `count` (number, optional): Results per page (1-50, default: 20)
+- `offset` (number, optional): Pagination offset (max 9, default: 0)
+- `spellcheck` (boolean, optional): Enable spell checking (default: true)
+- `safesearch` (string, optional): Content filtering ("off", "moderate", "strict", default: "moderate")
+- `freshness` (string, optional): Time filter (default: "pd" for last 24 hours)
+- `extra_snippets` (boolean, optional): Get additional excerpts (Pro plans only)
+- `goggles` (array, optional): Custom re-ranking definitions
+
+### Summarizer Search (`brave_summarizer`)
+Generates AI-powered summaries from web search results using Brave's summarization API.
+
+**Parameters:**
+- `key` (string, required): Summary key from web search results (use `summary: true` in web search)
+- `entity_info` (boolean, optional): Include entity information (default: false)
+- `inline_references` (boolean, optional): Add source URL references (default: false)
+
+**Usage:** First perform a web search with `summary: true`, then use the returned summary key with this tool.
+
+## Configuration
+
+### Getting an API Key
+
+1. Sign up for a [Brave Search API account](https://brave.com/search/api/)
+2. Choose a plan:
+   - **Free**: 2,000 queries/month, basic web search
+   - **Pro**: Enhanced features including local search, AI summaries, extra snippets
+3. Generate your API key from the [developer dashboard](https://api-dashboard.search.brave.com/app/keys)
+
+### Environment Variables
+
+The server supports the following environment variables:
+
+- `BRAVE_API_KEY`: Your Brave Search API key (required)
+- `BRAVE_MCP_TRANSPORT`: Transport mode ("http" or "stdio", default: "http")
+- `BRAVE_MCP_PORT`: HTTP server port (default: 8080)
+- `BRAVE_MCP_HOST`: HTTP server host (default: "0.0.0.0")
+
+### Command Line Options
+
+```bash
+node dist/index.js [options]
+
+Options:
+  --brave-api-key <string>    Brave API key
+  --transport <stdio|http>    Transport type (default: http)
+  --port <number>             HTTP server port (default: 8080)
+  --host <string>             HTTP server host (default: 0.0.0.0)
+```
+
+## Installation
+
+### Usage with Claude Desktop
+
+Add this to your `claude_desktop_config.json`:
+
+#### Docker
+
+```json
+{
+  "mcpServers": {
+    "brave-search": {
+      "command": "docker",
+      "args": ["run", "-i", "--rm", "-e", "BRAVE_API_KEY", "mcp/brave-search"],
+      "env": {
+        "BRAVE_API_KEY": "YOUR_API_KEY_HERE"
+      }
+    }
+  }
+}
+```
+
+#### NPX
+
+```json
+{
+  "mcpServers": {
+    "brave-search": {
+      "command": "npx",
+      "args": ["-y", "@brave/brave-search-mcp-server"],
+      "env": {
+        "BRAVE_API_KEY": "YOUR_API_KEY_HERE"
+      }
+    }
+  }
+}
+```
+
+### Usage with VS Code
+
+For quick installation, use the one-click installation buttons below:
+
+[![Install with NPX in VS Code](https://img.shields.io/badge/VS_Code-NPM-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=brave-search&inputs=%5B%7B%22password%22%3Atrue%2C%22id%22%3A%22brave-api-key%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Brave+Search+API+Key%22%7D%5D&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40brave%2Fbrave-search-mcp-server%22%5D%2C%22env%22%3A%7B%22BRAVE_API_KEY%22%3A%22%24%7Binput%3Abrave-api-key%7D%22%7D%7D) [![Install with NPX in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-NPM-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=brave-search&inputs=%5B%7B%22password%22%3Atrue%2C%22id%22%3A%22brave-api-key%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Brave+Search+API+Key%22%7D%5D&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40brave%2Fbrave-search-mcp-server%22%5D%2C%22env%22%3A%7B%22BRAVE_API_KEY%22%3A%22%24%7Binput%3Abrave-api-key%7D%22%7D%7D&quality=insiders)  
+[![Install with Docker in VS Code](https://img.shields.io/badge/VS_Code-Docker-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=brave-search&inputs=%5B%7B%22password%22%3Atrue%2C%22id%22%3A%22brave-api-key%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Brave+Search+API+Key%22%7D%5D&config=%7B%22command%22%3A%22docker%22%2C%22args%22%3A%5B%22run%22%2C%22-i%22%2C%22--rm%22%2C%22-e%22%2C%22BRAVE_API_KEY%22%2C%22mcp%2Fbrave-search%22%5D%2C%22env%22%3A%7B%22BRAVE_API_KEY%22%3A%22%24%7Binput%3Abrave-api-key%7D%22%7D%7D) [![Install with Docker in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Docker-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=brave-search&inputs=%5B%7B%22password%22%3Atrue%2C%22id%22%3A%22brave-api-key%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Brave+Search+API+Key%22%7D%5D&config=%7B%22command%22%3A%22docker%22%2C%22args%22%3A%5B%22run%22%2C%22-i%22%2C%22--rm%22%2C%22-e%22%2C%22BRAVE_API_KEY%22%2C%22mcp%2Fbrave-search%22%5D%2C%22env%22%3A%7B%22BRAVE_API_KEY%22%3A%22%24%7Binput%3Abrave-api-key%7D%22%7D%7D&quality=insiders)
+
+For manual installation, add the following to your User Settings (JSON) or `.vscode/mcp.json`:
+
+#### Docker
+
+```json
+{
+  "inputs": [
+    {
+      "password": true,
+      "id": "brave-api-key",
+      "type": "promptString",
+      "description": "Brave Search API Key",
+    }
+  ],
+  "servers": {
+    "brave-search": {
+      "command": "docker",
+      "args": ["run", "-i", "--rm", "-e", "BRAVE_API_KEY", "mcp/brave-search"],
+      "env": {
+        "BRAVE_API_KEY": "${input:brave-api-key}"
+      }
+    }
+  }
+}
+```
+
+#### NPX
+
+```json
+{
+  "inputs": [
+    {
+      "password": true,
+      "id": "brave-api-key",
+      "type": "promptString",
+      "description": "Brave Search API Key",
+    }
+  ],
+  "servers": {
+    "brave-search-mcp-server": {
+      "command": "npx",
+      "args": ["-y", "@brave/brave-search-mcp-server"],
+      "env": {
+        "BRAVE_API_KEY": "${input:brave-api-key}"
+      }
+    }
+  }
+}
+```
+
+## Build
+
+### Docker
+
+```bash
+docker build -t mcp/brave-search:latest .
+```
+
+### Local Build
+
+```bash
+npm install
+npm run build
+```
+
+## Development
+
+### Prerequisites
+
+- Node.js 22.x or higher
+- npm
+- Brave Search API key
+
+### Setup
+
+1. Clone the repository:
+```bash
+git clone https://github.com/brave/brave-search-mcp-server.git
+cd brave-search-mcp-server
+```
+
+2. Install dependencies:
+```bash
+npm install
+```
+
+3. Build the project:
+```bash
+npm run build
+```
+
+### Testing via Claude Desktop
+
+Add a reference to your local build in `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "brave-search-dev": {
+      "command": "node",
+      "args": ["C:\\GitHub\\brave-search-mcp-server\\dist\\index.js"], // Verify your path
+      "env": {
+        "BRAVE_API_KEY": "YOUR_API_KEY_HERE"
+      }
+    }
+  }
+}
+```
+
+### Testing via MCP Inspector
+
+1. Build and start the server:
+```bash
+npm run build
+node dist/index.js
+```
+
+2. In another terminal, start the MCP Inspector:
+```bash
+npx @modelcontextprotocol/inspector node dist/index.js
+```
+
+For STDIO mode testing, add `--transport stdio` to the arguments in the Inspector UI.
+
+### Available Scripts
+
+- `npm run build`: Build the TypeScript project
+- `npm run watch`: Watch for changes and rebuild
+- `npm run format`: Format code with Prettier
+- `npm run format:check`: Check code formatting
+- `npm run prepare`: Format and build (runs automatically on npm install)
+
+### Docker Compose
+
+For local development with Docker:
+
+```bash
+docker-compose up --build
+```
+
+## License
+
+This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.

package/dist/BraveAPI/index.js

@@ -0,0 +1,94 @@
+import config from '../config.js';
+import { log, stringify } from '../utils.js';
+const typeToPathMap = {
+    images: '/res/v1/images/search',
+    localPois: '/res/v1/local/pois',
+    localDescriptions: '/res/v1/local/descriptions',
+    news: '/res/v1/news/search',
+    videos: '/res/v1/videos/search',
+    web: '/res/v1/web/search',
+    summarizer: '/res/v1/summarizer/search',
+};
+const defaultRequestHeaders = {
+    Accept: 'application/json',
+    'Accept-Encoding': 'gzip',
+    'X-Subscription-Token': config.braveApiKey,
+};
+async function issueRequest(endpoint, parameters, 
+// TODO (Sampson): Implement support for custom request headers (helpful for POIs, etc.)
+requestHeaders = {}) {
+    // TODO (Sampson): Improve rate-limit logic to support self-throttling and n-keys
+    // checkRateLimit();
+    // Determine URL, and setup parameters
+    const url = new URL(`https://api.search.brave.com${typeToPathMap[endpoint]}`);
+    const queryParams = new URLSearchParams();
+    await log('info', `Preparing to issue request to ${url.toString()}`);
+    // TODO (Sampson): Move param-construction/validation to modules
+    for (const [key, value] of Object.entries(parameters)) {
+        // The 'ids' parameter is expected to appear multiple times for multiple IDs
+        if (['localPois', 'localDescriptions'].includes(endpoint)) {
+            if (key === 'ids') {
+                if (Array.isArray(value) && value.length > 0) {
+                    value.forEach((id) => queryParams.append(key, id));
+                }
+                else if (typeof value === 'string') {
+                    queryParams.set(key, value);
+                }
+                continue;
+            }
+        }
+        // Handle result_filter parameter
+        if (key === 'result_filter') {
+            // Handle special behavior of 'summary' parameter:
+            // Requires `result_filter` to be empty, or only contain 'summarizer'
+            // see: https://bravesoftware.slack.com/archives/C01NNFM9XMM/p1751654841090929
+            if ('summary' in parameters && parameters.summary === true) {
+                queryParams.set(key, 'summarizer');
+            }
+            else if (Array.isArray(value) && value.length > 0) {
+                queryParams.set(key, value.join(','));
+            }
+            continue;
+        }
+        // Handle goggles parameters
+        if (key === 'goggles') {
+            if (typeof value === 'string') {
+                queryParams.set(key, value);
+            }
+            else if (Array.isArray(value) && value.length > 0) {
+                queryParams.set(key, value.join(','));
+            }
+            continue;
+        }
+        if (value !== undefined) {
+            queryParams.set(key === 'query' ? 'q' : key, value.toString());
+        }
+    }
+    await log('debug', `Using parameters: ${queryParams.toString()}`);
+    // Issue Request
+    const urlWithParams = url.toString() + '?' + queryParams.toString();
+    const headers = { ...defaultRequestHeaders, ...requestHeaders };
+    const response = await fetch(urlWithParams, { headers });
+    await log('debug', `Received response from ${urlWithParams}`);
+    // Handle Error
+    if (!response.ok) {
+        let errorMessage = `${response.status} ${response.statusText}`;
+        try {
+            const responseBody = await response.json();
+            errorMessage += `\n${stringify(responseBody, true)}`;
+        }
+        catch (error) {
+            errorMessage += `\n${await response.text()}`;
+        }
+        await log('error', errorMessage);
+        // TODO (Sampson): Setup proper error handling, updating state, etc.
+        throw new Error(errorMessage);
+    }
+    // Return Response
+    const responseBody = await response.json();
+    await log('debug', `Returning response: ${stringify(responseBody, true)}`);
+    return responseBody;
+}
+export default {
+    issueRequest,
+};

package/dist/BraveAPI/types.js

@@ -0,0 +1 @@
+export {};

package/dist/config.js

@@ -0,0 +1,44 @@
+import { Command } from 'commander';
+const state = {
+    transport: 'http',
+    port: 8080,
+    host: '0.0.0.0',
+    braveApiKey: process.env.BRAVE_API_KEY ?? '',
+    ready: false,
+};
+export function getOptions() {
+    const program = new Command()
+        .option('--brave-api-key <string>', 'Brave API key', process.env.BRAVE_API_KEY ?? '')
+        .option('--transport <stdio|http>', 'transport type', process.env.BRAVE_MCP_TRANSPORT ?? 'http')
+        .option('--port <number>', 'desired port for HTTP transport', process.env.BRAVE_MCP_PORT ?? '8080')
+        .option('--host <string>', 'desired host for HTTP transport', process.env.BRAVE_MCP_HOST ?? '0.0.0.0')
+        .allowUnknownOption()
+        .parse(process.argv);
+    const options = program.opts();
+    if (!['stdio', 'http'].includes(options.transport)) {
+        console.error(`Invalid --transport value: '${options.transport}'. Must be one of: stdio, http.`);
+        return false;
+    }
+    if (!options.braveApiKey) {
+        console.error('Error: --brave-api-key is required. You can get one at https://brave.com/search/api/.');
+        return false;
+    }
+    if (options.transport === 'http') {
+        if (options.port < 1 || options.port > 65535) {
+            console.error(`Invalid --port value: '${options.port}'. Must be a valid port number between 1 and 65535.`);
+            return false;
+        }
+        if (!options.host) {
+            console.error('Error: --host is required');
+            return false;
+        }
+    }
+    // Update state
+    state.braveApiKey = options.braveApiKey;
+    state.transport = options.transport;
+    state.port = options.port;
+    state.host = options.host;
+    state.ready = true;
+    return options;
+}
+export default state;

package/dist/constants.js

@@ -0,0 +1,4 @@
+export const RATE_LIMIT = {
+    perSecond: 1,
+    perMonth: 15000,
+};

package/dist/helpers.js

@@ -0,0 +1,10 @@
+export function registerSigIntHandler(transports) {
+    process.on('SIGINT', async () => {
+        for (const sessionID of transports.keys()) {
+            await transports.get(sessionID)?.close();
+            transports.delete(sessionID);
+        }
+        console.error('Server shut down.');
+        process.exit(0);
+    });
+}

package/dist/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { getOptions } from './config.js';
+import { stdioServer, httpServer } from './protocols/index.js';
+async function main() {
+    const options = getOptions();
+    if (!options) {
+        console.error('Invalid configuration');
+        process.exit(1);
+    }
+    // default to http server
+    if (!options.transport || options.transport === 'http') {
+        httpServer.start();
+        return;
+    }
+    // stdio requires explicit request
+    if (options.transport === 'stdio') {
+        await stdioServer.start();
+        return;
+    }
+    console.error('Invalid transport');
+    process.exit(1);
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/protocols/http.js

@@ -0,0 +1,41 @@
+import express from 'express';
+import config from '../config.js';
+import { server } from '../server.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+const yieldGenericServerError = (res) => {
+    res.status(500).json({
+        id: null,
+        jsonrpc: '2.0',
+        error: { code: -32603, message: 'Internal server error' },
+    });
+};
+export const start = () => {
+    if (!config.ready) {
+        console.error('Invalid configuration');
+        process.exit(1);
+    }
+    const app = express();
+    app.use(express.json());
+    app.all('/mcp', async (req, res) => {
+        try {
+            const transport = new StreamableHTTPServerTransport({
+                // Setting to undefined will opt-out of session-id generation
+                sessionIdGenerator: undefined,
+            });
+            await server.connect(transport);
+            await transport.handleRequest(req, res, req.body);
+        }
+        catch (error) {
+            if (!res.headersSent) {
+                yieldGenericServerError(res);
+            }
+        }
+    });
+    app.all('/ping', (req, res) => {
+        res.status(200).json({ message: 'pong' });
+    });
+    app.listen(config.port, config.host, () => {
+        console.error(`Server is running on http://${config.host}:${config.port}/mcp`);
+    });
+};
+export default { start };

package/dist/protocols/index.js

@@ -0,0 +1,2 @@
+export { default as stdioServer } from './stdio.js';
+export { default as httpServer } from './http.js';

package/dist/protocols/stdio.js

@@ -0,0 +1,8 @@
+import { server } from '../server.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+export const start = async () => {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Stdio server started');
+};
+export default { start };

package/dist/server.js

@@ -0,0 +1,16 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import tools from './tools/index.js';
+export const server = new McpServer({
+    version: '0.1.0',
+    name: 'brave-search-mcp-server',
+    title: 'Brave Search MCP Server',
+}, {
+    capabilities: {
+        logging: {},
+        tools: { listChanged: false },
+    },
+    instructions: 'Use this server to search the Web for various types of data ' + 'via the Brave Search API.',
+});
+for (const tool of Object.values(tools)) {
+    server.tool(tool.name, tool.description, tool.inputSchema, tool.annotations, tool.execute);
+}

package/dist/tools/images/index.js

@@ -0,0 +1,50 @@
+import params from './params.js';
+import API from '../../BraveAPI/index.js';
+import { log, stringify } from '../../utils.js';
+export const name = 'brave_image_search';
+export const annotations = {
+    title: 'Brave Image Search',
+    openWorldHint: true,
+};
+export const description = `
+    Performs an image search using the Brave Search API. Helpful for when you need pictures of people, places, or things, ideas for graphic design, inspiration for art, or anything else where images are useful. When relaying the results in a markdown-supporting environment, it is helpful to include some/all of the images in the results. Example: ![Image Description](image_url).
+`;
+export const execute = async (params) => {
+    const content = [];
+    const response = await API.issueRequest('images', params);
+    for (const { url: page_url, title, thumbnail, properties } of response.results) {
+        // Skip results without an image
+        if (!thumbnail?.src)
+            continue;
+        // Prefer property URL as it is the shortest-possible URL
+        const image_url = properties?.url ?? thumbnail.src;
+        const fetched_image = await fetchImage(image_url);
+        if (fetched_image) {
+            const { mimeType, data } = fetched_image;
+            content.push({ type: 'text', text: stringify({ title, page_url, image_url }) }, { type: 'image', mimeType, data });
+        }
+    }
+    return { content, isError: false };
+};
+async function fetchImage(url) {
+    await log('info', `Fetching image data from ${url}`);
+    try {
+        const response = await fetch(url);
+        const buffer = await response.arrayBuffer();
+        return {
+            data: Buffer.from(buffer).toString('base64'),
+            mimeType: response.headers.get('content-type') ?? 'image/jpeg',
+        };
+    }
+    catch (error) {
+        await log('error', `Error fetching image data from ${url}: ${error}`);
+        return null;
+    }
+}
+export default {
+    name,
+    description,
+    annotations,
+    inputSchema: params.shape,
+    execute,
+};

package/dist/tools/images/params.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export const params = z.object({
+    query: z
+        .string()
+        .min(1)
+        .max(400)
+        .refine((str) => str.split(/\s+/).length <= 50, 'Query cannot exceed 50 words')
+        .describe("The user's search query. Query cannot be empty. Limited to 400 characters and 50 words."),
+    country: z
+        .string()
+        .default('US')
+        .describe('Search query country, where the results come from. The country string is limited to 2 character country codes of supported countries.')
+        .optional(),
+    search_lang: z
+        .string()
+        .default('en')
+        .describe('Search language preference. The 2 or more character language code for which the search results are provided.')
+        .optional(),
+    count: z
+        .number()
+        .int()
+        .min(1)
+        .max(200)
+        .default(50)
+        .describe('Number of results (1-200, default 50). Combine this parameter with `offset` to paginate search results.')
+        .optional(),
+    safesearch: z
+        .union([z.literal('off'), z.literal('strict')])
+        .default('strict')
+        .describe("Filters search results for adult content. The following values are supported: 'off' - No filtering. 'strict' - Drops all adult content from search results.")
+        .optional(),
+    spellcheck: z
+        .boolean()
+        .default(true)
+        .describe('Whether to spellcheck provided query.')
+        .optional(),
+});
+export default params;