@brave/brave-search-mcp-server 1.3.3 → 1.3.5

package/README.md

@@ -102,6 +102,7 @@ The server supports the following environment variables:
 - `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")
+- `BRAVE_MCP_LOG_LEVEL`: Desired logging level("debug", "info", "notice", "warning", "error", "critical", "alert", or "emergency", default: "info")
 
 ### Command Line Options
 

package/dist/BraveAPI/index.js

@@ -1,5 +1,6 @@
 import config from '../config.js';
-import { log, stringify } from '../utils.js';
+import { stringify } from '../utils.js';
+import ClientLogger from '../ClientLogger.js';
 const typeToPathMap = {
     images: '/res/v1/images/search',
     localPois: '/res/v1/local/pois',
@@ -22,7 +23,7 @@ requestHeaders = {}) {
     // 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()}`);
+    await ClientLogger.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
@@ -64,12 +65,12 @@ requestHeaders = {}) {
             queryParams.set(key === 'query' ? 'q' : key, value.toString());
         }
     }
-    await log('debug', `Using parameters: ${queryParams.toString()}`);
+    await ClientLogger.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}`);
+    await ClientLogger.log('debug', `Received response from ${urlWithParams}`);
     // Handle Error
     if (!response.ok) {
         let errorMessage = `${response.status} ${response.statusText}`;
@@ -80,13 +81,13 @@ requestHeaders = {}) {
         catch (error) {
             errorMessage += `\n${await response.text()}`;
         }
-        await log('error', errorMessage);
+        await ClientLogger.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)}`);
+    await ClientLogger.log('debug', `Returning response: ${stringify(responseBody, true)}`);
     return responseBody;
 }
 export default {

package/dist/ClientLogger.js

@@ -0,0 +1,63 @@
+import { LoggingLevelSchema, SetLevelRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import config from './config.js';
+let mcpServer;
+const setServer = (server) => {
+    mcpServer = server;
+};
+let customLogger;
+let currentLevel = LoggingLevelSchema.options.indexOf(config.loggingLevel);
+/**
+ * Attempt to register a custom set level request handler.
+ * If the method is already handled by the SDK/Server, we'll ignore the error.
+ * @see https://github.com/modelcontextprotocol/typescript-sdk/issues/871
+ * @param server {Server} The server to register the handler on.
+ */
+export const maybeRegisterCustomSetLevelRequestHandler = (server) => {
+    try {
+        server.assertCanSetRequestHandler(SetLevelRequestSchema.shape.method.value);
+        server.setRequestHandler(SetLevelRequestSchema, async (request) => {
+            await log('info', `Setting logging level to ${request.params.level}`);
+            currentLevel = LoggingLevelSchema.options.indexOf(request.params.level);
+            return {};
+        });
+    }
+    catch (error) {
+        console.error(`Failed to register custom SetLevelRequest handler. The SDK may now provide its own handler. See https://github.com/modelcontextprotocol/typescript-sdk/issues/871 for more information.`, error);
+    }
+};
+const log = async (level, message) => {
+    // If a custom logger exists, call it, and let it handle it's own log-level filtering
+    if (customLogger) {
+        await customLogger(level, message);
+        return;
+    }
+    // If the log-level is less than the current log-level, skip it
+    if (LoggingLevelSchema.options.indexOf(level) < currentLevel) {
+        return;
+    }
+    // Fall back to default logger if no custom logger is set
+    const time = new Date().toISOString();
+    if (!mcpServer?.isConnected()) {
+        console.error(`${time} [${level}] ${message}`);
+        return;
+    }
+    try {
+        await mcpServer.server.sendLoggingMessage({ level, data: { message, time } });
+    }
+    catch (error) {
+        console.error(`Error sending logging message: ${error}`);
+    }
+};
+const setLogger = (logger) => {
+    customLogger = logger;
+};
+const setLoggingLevel = (desiredLevel) => {
+    const desiredLevelIndex = LoggingLevelSchema.options.indexOf(desiredLevel);
+    if (desiredLevelIndex === -1) {
+        console.error(`Invalid logging level: ${desiredLevel}. Must be one of: ${LoggingLevelSchema.options.join(', ')}`);
+        return;
+    }
+    currentLevel = desiredLevelIndex;
+};
+const getLoggingLevel = () => LoggingLevelSchema.options[currentLevel];
+export default { log, setServer, setLogger, setLoggingLevel, getLoggingLevel };

package/dist/config.js

@@ -1,16 +1,19 @@
+import { LoggingLevelSchema } from '@modelcontextprotocol/sdk/types.js';
 import { Command } from 'commander';
 import dotenv from 'dotenv';
-dotenv.config();
+dotenv.config({ debug: false, quiet: true });
 const state = {
     transport: 'http',
     port: 8080,
     host: '0.0.0.0',
     braveApiKey: process.env.BRAVE_API_KEY ?? '',
+    loggingLevel: 'info',
     ready: false,
 };
 export function getOptions() {
     const program = new Command()
         .option('--brave-api-key <string>', 'Brave API key', process.env.BRAVE_API_KEY ?? '')
+        .option('--logging-level <string>', 'Logging level', process.env.BRAVE_MCP_LOG_LEVEL ?? 'info')
         .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')
@@ -21,6 +24,10 @@ export function getOptions() {
         console.error(`Invalid --transport value: '${options.transport}'. Must be one of: stdio, http.`);
         return false;
     }
+    if (!LoggingLevelSchema.options.includes(options.loggingLevel)) {
+        console.error(`Invalid --logging-level value: '${options.loggingLevel}'. Must be one of: ${LoggingLevelSchema.options.join(', ')}`);
+        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;
@@ -40,6 +47,7 @@ export function getOptions() {
     state.transport = options.transport;
     state.port = options.port;
     state.host = options.host;
+    state.loggingLevel = options.loggingLevel;
     state.ready = true;
     return options;
 }

package/dist/protocols/http.js

@@ -1,7 +1,9 @@
+import { randomUUID } from 'node:crypto';
 import express from 'express';
 import config from '../config.js';
-import { server } from '../server.js';
+import { mcpServer } from '../server.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { isInitializeRequest, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 const yieldGenericServerError = (res) => {
     res.status(500).json({
         id: null,
@@ -9,23 +11,44 @@ const yieldGenericServerError = (res) => {
         error: { code: -32603, message: 'Internal server error' },
     });
 };
-export const start = () => {
-    if (!config.ready) {
-        console.error('Invalid configuration');
-        process.exit(1);
+const transports = new Map();
+export const getTransport = async (request) => {
+    // Check for an existing session
+    const sessionId = request.headers['mcp-session-id'];
+    if (sessionId && transports.has(sessionId)) {
+        return transports.get(sessionId);
     }
+    // Is the client attempting to initialize a new session?
+    if (isInitializeRequest(request.body)) {
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            onsessioninitialized: (sessionId) => {
+                transports.set(sessionId, transport);
+            },
+        });
+        await mcpServer.connect(transport);
+        return transport;
+    }
+    // We have a special case where we'll permit ListToolsRequest w/o a session ID
+    if (request.body.method === ListToolsRequestSchema.shape.method.value) {
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: undefined,
+        });
+        await mcpServer.connect(transport);
+        return transport;
+    }
+    throw new Error('Invalid request: must be an initialization request, include a valid session ID, or be a ListTools method request');
+};
+export const createApp = () => {
     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);
+            const transport = await getTransport(req);
             await transport.handleRequest(req, res, req.body);
         }
         catch (error) {
+            console.error(error);
             if (!res.headersSent) {
                 yieldGenericServerError(res);
             }
@@ -34,8 +57,16 @@ export const start = () => {
     app.all('/ping', (req, res) => {
         res.status(200).json({ message: 'pong' });
     });
+    return app;
+};
+export const start = () => {
+    if (!config.ready) {
+        console.error('Invalid configuration');
+        process.exit(1);
+    }
+    const app = createApp();
     app.listen(config.port, config.host, () => {
         console.error(`Server is running on http://${config.host}:${config.port}/mcp`);
     });
 };
-export default { start };
+export default { start, createApp };

package/dist/protocols/stdio.js

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

package/dist/server.js

@@ -1,6 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import tools from './tools/index.js';
-export const server = new McpServer({
+import ClientLogger, { maybeRegisterCustomSetLevelRequestHandler } from './ClientLogger.js';
+export const mcpServer = new McpServer({
     version: '0.1.0',
     name: 'brave-search-mcp-server',
     title: 'Brave Search MCP Server',
@@ -9,8 +10,11 @@ export const server = new McpServer({
         logging: {},
         tools: { listChanged: false },
     },
-    instructions: 'Use this server to search the Web for various types of data ' + 'via the Brave Search API.',
+    instructions: `Use this server to search the Web for various types of data via the Brave Search API.`,
 });
+ClientLogger.setServer(mcpServer);
+// https://github.com/modelcontextprotocol/typescript-sdk/issues/871
+maybeRegisterCustomSetLevelRequestHandler(mcpServer.server);
 for (const tool of Object.values(tools)) {
-    server.tool(tool.name, tool.description, tool.inputSchema, tool.annotations, tool.execute);
+    mcpServer.tool(tool.name, tool.description, tool.inputSchema, tool.annotations, tool.execute);
 }

package/dist/tools/images/index.js

@@ -1,6 +1,7 @@
 import params from './params.js';
 import API from '../../BraveAPI/index.js';
-import { log, stringify } from '../../utils.js';
+import { stringify } from '../../utils.js';
+import ClientLogger from '../../ClientLogger.js';
 export const name = 'brave_image_search';
 export const annotations = {
     title: 'Brave Image Search',
@@ -27,7 +28,7 @@ export const execute = async (params) => {
     return { content, isError: false };
 };
 async function fetchImage(url) {
-    await log('info', `Fetching image data from ${url}`);
+    await ClientLogger.log('info', `Fetching image data from ${url}`);
     try {
         const response = await fetch(url);
         const buffer = await response.arrayBuffer();
@@ -37,7 +38,7 @@ async function fetchImage(url) {
         };
     }
     catch (error) {
-        await log('error', `Error fetching image data from ${url}: ${error}`);
+        await ClientLogger.log('error', `Error fetching image data from ${url}: ${error}`);
         return null;
     }
 }

package/dist/tools/summarizer/index.js

@@ -1,6 +1,6 @@
 import { summarizerQueryParams } from './params.js';
 import API from '../../BraveAPI/index.js';
-import { log } from '../../utils.js';
+import ClientLogger from '../../ClientLogger.js';
 export const name = 'brave_summarizer';
 export const annotations = {
     title: 'Brave Summarizer',
@@ -70,7 +70,7 @@ const pollForSummary = async (params, pollInterval = 50, attempts = 20) => {
             }
         }
         catch (error) {
-            await log('error', `Error polling for summarizer results: ${error}`);
+            await ClientLogger.log('error', `Error polling for summarizer results: ${error}`);
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
         }
         attempts--;

package/dist/utils.js

@@ -1,14 +1,9 @@
 import { RATE_LIMIT } from './constants.js';
-import { server } from './server.js';
 let requestCount = {
     second: 0,
     month: 0,
     lastReset: Date.now(),
 };
-export async function log(level, message) {
-    const time = new Date().toISOString();
-    await server.server.sendLoggingMessage({ level, data: { message, time } });
-}
 export function checkRateLimit() {
     const now = Date.now();
     if (now - requestCount.lastReset > 1000) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brave/brave-search-mcp-server",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "MCP server for Brave Search. Uses the Brave Search API to return results from the web, including ranked links, images, and videos, as well as AI summaries of pages, rich results, and more.",
   "keywords": [
     "api",
@@ -29,10 +29,11 @@
     "watch": "tsc --watch",
     "format": "prettier --write \"src/**/*.ts\"",
     "format:check": "prettier --check \"src/**/*.ts\"",
-    "inspector": "npx @modelcontextprotocol/inspector"
+    "inspector": "npx @modelcontextprotocol/inspector",
+    "inspector:stdio": "npx @modelcontextprotocol/inspector --transport stdio"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.16.0",
+    "@modelcontextprotocol/sdk": "1.17.2",
     "commander": "14.0.0",
     "dotenv": "^17.2.1",
     "express": "5.1.0",
@@ -40,9 +41,9 @@
   },
   "devDependencies": {
     "@types/express": "5.0.3",
-    "@types/node": "24.1.0",
+    "@types/node": "24.2.0",
     "prettier": "3.6.2",
     "shx": "0.4.0",
-    "typescript": "5.8.3"
+    "typescript": "5.9.2"
   }
 }