@brave/brave-search-mcp-server 2.0.80 → 2.0.81

package/README.md

@@ -1,6 +1,6 @@
 # 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 STDIO and HTTP transports, with STDIO as the default mode.
+An MCP server implementation that integrates the Brave Search API, providing comprehensive search capabilities including web search, local business search, place search, image search, video search, news search, LLM context, and AI-powered summarization. This project supports both STDIO and HTTP transports, with STDIO as the default mode.
 
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/brave/brave-search-mcp-server)
 
@@ -98,6 +98,63 @@ Generates AI-powered summaries from web search results using Brave's summarizati
 
 **Usage:** First perform a web search with `summary: true`, then use the returned summary key with this tool.
 
+### Place Search (`brave_place_search`)
+Searches for points of interest (POIs) in a specified geographic area using Brave's Place Search API. Returns rich, structured place data including name, address, opening hours, contact info, ratings, photos, categories, and timezone.
+
+**Parameters:**
+- `query` (string, optional): Query string used to refine the POI search (max 400 chars, 50 words). When omitted, returns general points of interest in the supplied area.
+- `latitude` (number, optional): Latitude of the search center (-90 to 90). Typically paired with `longitude`.
+- `longitude` (number, optional): Longitude of the search center (-180 to 180). Typically paired with `latitude`.
+- `location` (string, optional): Location string used as an alternative to `latitude`/`longitude`. For US locations prefer the form `<city> <state> <country name>` (e.g., `san francisco ca united states`); for non-US locations use `<city> <country name>` (e.g., `tokyo japan`).
+- `radius` (number, optional): Search radius around the supplied coordinates, in meters. If omitted, the search is performed globally.
+- `count` (number, optional): Number of results to return (1-50, default 20).
+- `country` (string, optional): Two-letter country code (default `US`).
+- `search_lang` (string, optional): Search language (default `en`).
+- `ui_lang` (string, optional): UI language (default `en-US`).
+- `units` (string, optional): Distance units (`metric` or `imperial`, default `metric`).
+- `safesearch` (string, optional): Safe search level (`off`, `moderate`, `strict`, default `strict`).
+- `spellcheck` (boolean, optional): Whether to spellcheck the query (default `true`).
+- `geoloc` (string, optional): Optional geolocation token used to refine results.
+
+**Optional request headers:**
+- `api-version` (string, optional): Brave API version (`YYYY-MM-DD`)
+- `accept` (string, optional): Response media type (`application/json` or `*/*`)
+- `cache-control` (string, optional): Use `no-cache` to request fresh content
+- `user-agent` (string, optional): User agent originating the request
+
+### LLM Context (`brave_llm_context`)
+Retrieves pre-extracted web content optimized for AI agents, LLM grounding, and RAG pipelines.
+
+**Parameters:**
+- `query` (string, required): Search query (max 400 chars, 50 words)
+- `country` (string, optional): Search country code
+- `search_lang` (string, optional): Search language code
+- `count` (number, optional): Maximum number of search results considered (1-50)
+- `spellcheck` (boolean, optional): Enable spell checking
+- `maximum_number_of_urls` (number, optional): Maximum number of URLs to include (1-50)
+- `maximum_number_of_tokens` (number, optional): Approximate maximum number of context tokens (1024-32768)
+- `maximum_number_of_snippets` (number, optional): Maximum number of snippets to include (1-256)
+- `context_threshold_mode` (string, optional): Threshold mode ("disabled", "strict", "lenient", "balanced")
+- `maximum_number_of_tokens_per_url` (number, optional): Maximum tokens per URL (512-8192)
+- `maximum_number_of_snippets_per_url` (number, optional): Maximum snippets per URL (1-100)
+- `goggles` (string or array, optional): Goggle URL or definition for custom re-ranking
+- `freshness` (string, optional): Time filter ("pd", "pw", "pm", "py", or date range)
+- `enable_local` (boolean, optional): Enable local recall
+- `enable_source_metadata` (boolean, optional): Include source metadata enrichment
+
+**Optional request headers:**
+- `x-loc-lat` (number, optional): Client latitude (-90 to 90)
+- `x-loc-long` (number, optional): Client longitude (-180 to 180)
+- `x-loc-city` (string, optional): Client city name
+- `x-loc-state` (string, optional): Client state or region code
+- `x-loc-state-name` (string, optional): Client state or region name
+- `x-loc-country` (string, optional): Client country code
+- `x-loc-postal-code` (string, optional): Client postal code
+- `api-version` (string, optional): Brave API version (`YYYY-MM-DD`)
+- `accept` (string, optional): Response media type ("application/json" or "*/*")
+- `cache-control` (string, optional): Use `no-cache` to request fresh content
+- `user-agent` (string, optional): User agent originating the request
+
 ## Configuration
 
 ### Getting an API Key
@@ -117,8 +174,8 @@ The server supports the following environment variables:
 - `BRAVE_MCP_PORT`: HTTP server port (default: 8000)
 - `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")
-- `BRAVE_MCP_ENABLED_TOOLS`: When used, specifies a whitelist for supported tools
-- `BRAVE_MCP_DISABLED_TOOLS`: When used, specifies a blacklist for supported tools
+- `BRAVE_MCP_ENABLED_TOOLS`: When used, specifies a space-separated whitelist for supported tools
+- `BRAVE_MCP_DISABLED_TOOLS`: When used, specifies a space-separated blacklist for supported tools
 - `BRAVE_MCP_STATELESS`: HTTP stateless mode (default: "true").  When running on Amazon Bedrock Agentcore, set to "true".
 
 ### Command Line Options
@@ -139,14 +196,6 @@ Options:
 
 ## Installation
 
-### Installing via Smithery
-
-To install Brave Search automatically via [Smithery](https://smithery.ai/server/brave):
-
-```bash
-npx -y @smithery/cli install brave
-```
-
 ### Usage with Claude Desktop
 
 Add this to your `claude_desktop_config.json`:
@@ -314,11 +363,6 @@ npx @modelcontextprotocol/inspector node dist/index.js
 
 STDIO is the default mode. For HTTP mode testing, add `--transport http` to the arguments in the Inspector UI.
 
-### Testing via Smithery.AI
-
-1. Establish and acquire a smithery.ai account and API key
-2. Run `npm run install`, `npm run smithery:build`, and lastly `npm run smithery:dev` to begin testing
-
 ### Available Scripts
 
 - `npm run build`: Build the TypeScript project
@@ -329,8 +373,6 @@ STDIO is the default mode. For HTTP mode testing, add `--transport http` to the
 
 - `npm run inspector`: Launch an instance of MCP Inspector
 - `npm run inspector:stdio`: Launch a instance of MCP Inspector, configured for STDIO
-- `npm run smithery:build`: Build the project for smithery.ai
-- `npm run smithery:dev`: Launch the development environment for smithery.ai
 
 ### Docker Compose
 

package/dist/BraveAPI/index.js

@@ -8,6 +8,8 @@ const typeToPathMap = {
     videos: '/res/v1/videos/search',
     web: '/res/v1/web/search',
     summarizer: '/res/v1/summarizer/search',
+    llmContext: '/res/v1/llm/context',
+    placeSearch: '/res/v1/local/place_search',
 };
 const getDefaultRequestHeaders = () => {
     return {
@@ -25,9 +27,18 @@ const isValidGoggleURL = (url) => {
         return false;
     }
 };
-async function issueRequest(endpoint, parameters, 
-// TODO (Sampson): Implement support for custom request headers (helpful for POIs, etc.)
-requestHeaders = {}) {
+const normalizeGoggle = (value) => {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return null;
+    if (/^https?:\/\//i.test(trimmed)) {
+        return isValidGoggleURL(trimmed) ? trimmed : null;
+    }
+    return trimmed;
+};
+async function issueRequest(endpoint, parameters, requestHeaders = {}) {
     // TODO (Sampson): Improve rate-limit logic to support self-throttling and n-keys
     // checkRateLimit();
     // Determine URL, and setup parameters
@@ -49,11 +60,18 @@ requestHeaders = {}) {
         }
         // 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
+            /**
+             * Handle special behavior of 'summary' parameter:
+             * When 'summary' is true, we need to either set result_filter to
+             * 'summarizer', or leave it excluded entirely. This is due to a known
+             * bug in the now-deprecated Summarizer endpoint. Setting it to
+             * 'summarizer' will result in no web results being returned, which is
+             * not ideal. As such, we skip the parameter entirely.
+             * See https://github.com/brave/brave-search-mcp-server/issues/272 and
+             * https://bravesoftware.slack.com/archives/C01NNFM9XMM/p1751654841090929
+             */
             if ('summary' in parameters && parameters.summary === true) {
-                queryParams.set(key, 'summarizer');
+                continue;
             }
             else if (Array.isArray(value) && value.length > 0) {
                 queryParams.set(key, value.join(','));
@@ -62,23 +80,27 @@ requestHeaders = {}) {
         }
         // Handle `goggles` parameter(s)
         if (key === 'goggles') {
-            if (typeof value === 'string') {
-                queryParams.set(key, value);
-            }
-            else if (Array.isArray(value)) {
-                for (const url of value.filter(isValidGoggleURL)) {
-                    queryParams.append(key, url);
+            const candidates = Array.isArray(value) ? value : [value];
+            for (const candidate of candidates) {
+                const normalized = normalizeGoggle(candidate);
+                if (normalized !== null) {
+                    queryParams.append(key, normalized);
                 }
             }
             continue;
         }
-        if (value !== undefined) {
+        if (value !== undefined && value !== null) {
             queryParams.set(key === 'query' ? 'q' : key, value.toString());
         }
     }
     // Issue Request
     const urlWithParams = url.toString() + '?' + queryParams.toString();
-    const headers = { ...getDefaultRequestHeaders(), ...requestHeaders };
+    const headers = new Headers(getDefaultRequestHeaders());
+    for (const [key, value] of Object.entries(requestHeaders)) {
+        if (value === undefined || value === null)
+            continue;
+        headers.set(key, String(value));
+    }
     const response = await fetch(urlWithParams, { headers });
     // Handle Error
     if (!response.ok) {

package/dist/config.js

@@ -1,43 +1,18 @@
 import { LoggingLevelSchema } from '@modelcontextprotocol/sdk/types.js';
 import { Command } from 'commander';
 import dotenv from 'dotenv';
-import { z } from 'zod';
 import tools from './tools/index.js';
 dotenv.config({ debug: false, quiet: true });
-// Config schema for Smithery.ai
-export const configSchema = z.object({
-    braveApiKey: z
-        .string()
-        .describe('Your API key')
-        .default(process.env.BRAVE_API_KEY ?? ''),
-    enabledTools: z
-        .array(z.string())
-        .describe('Enforces a tool whitelist (cannot be used with disabledTools)')
-        .optional(),
-    disabledTools: z
-        .array(z.string())
-        .describe('Enforces a tool blacklist (cannot be used with enabledTools)')
-        .optional(),
-    loggingLevel: z
-        .enum([
-        'debug',
-        'error',
-        'info',
-        'notice',
-        'warning',
-        'critical',
-        'alert',
-        'emergency',
-    ])
-        .default('info')
-        .describe('Desired logging level')
-        .optional(),
-    stateless: z
-        .boolean()
-        .default(false)
-        .describe('Whether the server should be stateless')
-        .optional(),
-});
+function parseToolNameList(value) {
+    if (value == null)
+        return [];
+    if (Array.isArray(value))
+        return value.map((t) => t.trim()).filter((t) => t.length > 0);
+    return value
+        .trim()
+        .split(/\s+/)
+        .filter((t) => t.length > 0);
+}
 const state = {
     transport: 'stdio',
     port: 8080,
@@ -69,14 +44,16 @@ export function getOptions() {
     const options = program.opts();
     const toolNames = Object.values(tools).map((tool) => tool.name);
     // Validate tool inclusion configuration
-    const enabledTools = options.enabledTools.filter((t) => t.trim().length > 0);
-    const disabledTools = options.disabledTools.filter((t) => t.trim().length > 0);
+    const enabledTools = parseToolNameList(options.enabledTools);
+    const disabledTools = parseToolNameList(options.disabledTools);
     if (enabledTools.length > 0 && disabledTools.length > 0) {
         console.error('Error: --enabled-tools and --disabled-tools cannot be used together');
         return false;
     }
-    if ([...enabledTools, ...disabledTools].some((t) => t.trim().length > 0 && !toolNames.includes(t.trim()))) {
-        console.error(`Invalid tool name used. Must be one of: ${toolNames.join(', ')}`);
+    const invalidToolNames = [...enabledTools, ...disabledTools].filter((t) => !toolNames.includes(t));
+    if (invalidToolNames.length > 0) {
+        console.error(`Invalid tool name(s) used: ${invalidToolNames.join(', ')}`);
+        console.error(`Valid tool names are: ${toolNames.join(', ')}`);
         return false;
     }
     // Validate all other options
@@ -110,13 +87,10 @@ export function getOptions() {
     state.port = options.port;
     state.host = options.host;
     state.loggingLevel = options.loggingLevel;
-    state.enabledTools = options.enabledTools;
-    state.disabledTools = options.disabledTools;
+    state.enabledTools = enabledTools;
+    state.disabledTools = disabledTools;
     state.stateless = options.stateless;
     state.ready = true;
     return options;
 }
-export function setOptions(options) {
-    return Object.assign(state, options);
-}
 export default state;

package/dist/server.js

@@ -2,11 +2,7 @@ import tools from './tools/index.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import pkg from '../package.json' with { type: 'json' };
 import { isToolPermittedByUser } from './config.js';
-import { setOptions } from './config.js';
-export { configSchema } from './config.js';
-export default function createMcpServer(options) {
-    if (options?.config)
-        setOptions(options.config);
+export default function createMcpServer() {
     const mcpServer = new McpServer({
         version: pkg.version,
         name: 'brave-search-mcp-server',

package/dist/tools/index.js

@@ -4,6 +4,8 @@ import VideoSearchTool from './videos/index.js';
 import ImageSearchTool from './images/index.js';
 import NewsSearchTool from './news/index.js';
 import SummarizerTool from './summarizer/index.js';
+import LlmContextTool from './llm_context/index.js';
+import PlaceSearchTool from './place_search/index.js';
 export default {
     WebSearchTool,
     LocalSearchTool,
@@ -11,4 +13,6 @@ export default {
     ImageSearchTool,
     NewsSearchTool,
     SummarizerTool,
+    LlmContextTool,
+    PlaceSearchTool,
 };

package/dist/tools/llm_context/index.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import API from '../../BraveAPI/index.js';
+import { RequestParamsSchema, RequestHeadersSchema, LlmContextInputSchema, } from './schemas/input.js';
+import { LlmContextSearchApiResponseSchema } from './schemas/output.js';
+export const name = 'brave_llm_context';
+export const annotations = {
+    title: 'Brave LLM Context',
+    openWorldHint: true,
+};
+export const description = `
+    Retrieves pre-extracted, relevance-ranked web content using Brave's LLM Context API, optimized for AI agents, LLM grounding, and RAG pipelines. Unlike a traditional web search that returns links and short descriptions, this tool returns the actual substance of matching pages — text chunks, tables, code blocks, and structured data — so the model can reason over it directly.
+
+    When to use:
+        - Grounding answers in fresh, relevant web content (RAG)
+        - Giving an AI agent ready-to-use page content from a single search call
+        - Question answering and fact-checking against current sources
+        - Gathering source material for research without manually fetching pages
+        - When you need the contents of pages, not just titles, descriptions, and URLs
+
+    When relaying results in markdown-supporting environments, cite the source URLs from the "sources" map.
+`.trim();
+export const execute = async (params) => {
+    const parsedParams = RequestParamsSchema.parse(params);
+    const parsedHeaders = RequestHeadersSchema.parse(params);
+    const response = await API.issueRequest('llmContext', parsedParams, parsedHeaders);
+    const { success, data, error } = LlmContextSearchApiResponseSchema.safeParse(response);
+    const payload = success ? data : z.treeifyError(error);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(payload) }],
+        isError: !success,
+        structuredContent: payload,
+    };
+};
+export const register = (mcpServer) => {
+    mcpServer.registerTool(name, {
+        title: name,
+        description: description,
+        inputSchema: LlmContextInputSchema.shape,
+        outputSchema: LlmContextSearchApiResponseSchema.shape,
+        annotations: annotations,
+    }, execute);
+};
+export default {
+    name,
+    description,
+    annotations,
+    inputSchema: LlmContextInputSchema.shape,
+    outputSchema: LlmContextSearchApiResponseSchema.shape,
+    execute,
+    register,
+};

package/dist/tools/llm_context/schemas/input.js

@@ -0,0 +1,228 @@
+import { z } from 'zod';
+/**
+ * Keep up-to-date with documentation:
+ * https://api-dashboard.search.brave.com/api-reference/summarizer/llm_context/get
+ */
+const CountryCodesSchema = z.enum([
+    'AR',
+    'AU',
+    'AT',
+    'BE',
+    'BR',
+    'CA',
+    'CL',
+    'DK',
+    'FI',
+    'FR',
+    'DE',
+    'GR',
+    'HK',
+    'IN',
+    'ID',
+    'IT',
+    'JP',
+    'KR',
+    'MY',
+    'MX',
+    'NL',
+    'NZ',
+    'NO',
+    'CN',
+    'PL',
+    'PT',
+    'PH',
+    'RU',
+    'SA',
+    'ZA',
+    'ES',
+    'SE',
+    'CH',
+    'TW',
+    'TR',
+    'GB',
+    'US',
+    'ALL',
+]);
+const SearchLangCodesSchema = z.enum([
+    'ar',
+    'eu',
+    'bn',
+    'bg',
+    'ca',
+    'zh-hans',
+    'zh-hant',
+    'hr',
+    'cs',
+    'da',
+    'nl',
+    'en',
+    'en-gb',
+    'et',
+    'fi',
+    'fr',
+    'gl',
+    'de',
+    'el',
+    'gu',
+    'he',
+    'hi',
+    'hu',
+    'is',
+    'it',
+    'jp',
+    'kn',
+    'ko',
+    'lv',
+    'lt',
+    'ms',
+    'ml',
+    'mr',
+    'nb',
+    'pl',
+    'pt-br',
+    'pt-pt',
+    'pa',
+    'ro',
+    'ru',
+    'sr',
+    'sk',
+    'sl',
+    'es',
+    'sv',
+    'ta',
+    'te',
+    'th',
+    'tr',
+    'uk',
+    'vi',
+]);
+const FreshnessSchema = z
+    .union([
+    z.enum(['pd', 'pw', 'pm', 'py']),
+    z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}to\d{4}-\d{2}-\d{2}$/, "Use 'pd', 'pw', 'pm', 'py', or a custom range as YYYY-MM-DDtoYYYY-MM-DD."),
+])
+    .describe("Filters search results by when they were discovered. The following values are supported: 'pd' - Discovered within the last 24 hours. 'pw' - Discovered within the last 7 days. 'pm' - Discovered within the last 31 days. 'py' - Discovered within the last 365 days. 'YYYY-MM-DDtoYYYY-MM-DD' - Timeframe is also supported by specifying the date range e.g. 2022-04-01to2022-07-30.");
+export const RequestParamsSchema = z.object({
+    query: z
+        .string()
+        .trim()
+        .min(1)
+        .max(400)
+        .refine((str) => str.split(/\s+/).length <= 50, 'Query cannot exceed 50 words')
+        .describe("The user's search query term. Query can not be empty. Maximum of 400 characters and 50 words in the query."),
+    country: CountryCodesSchema.describe('The search query country, where the results come from. The country string is limited to 2 character country codes of supported countries.').optional(),
+    search_lang: SearchLangCodesSchema.describe('The 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(50)
+        .describe('The maximum number of search results considered to select the LLM context data. The default is 20 and the maximum is 50.')
+        .optional(),
+    spellcheck: z.boolean().describe('Whether to enable spellcheck on the query.').optional(),
+    maximum_number_of_urls: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .describe('Maximum number of different URLs to include in LLM context.')
+        .optional(),
+    maximum_number_of_tokens: z
+        .number()
+        .int()
+        .min(1024)
+        .max(32768)
+        .describe('Approximate maximum number of tokens to include in context. The default is 8192 and maximum is 32768.')
+        .optional(),
+    maximum_number_of_snippets: z
+        .number()
+        .int()
+        .min(1)
+        .max(256)
+        .describe('Maximum number of different snippets (or chunks of text) to include in LLM context. The default is 50 and maximum is 256.')
+        .optional(),
+    context_threshold_mode: z
+        .enum(['disabled', 'strict', 'lenient', 'balanced'])
+        .describe('The mode to use to determine the threshold for including content in context. Default is balanced.')
+        .optional(),
+    maximum_number_of_tokens_per_url: z
+        .number()
+        .int()
+        .min(512)
+        .max(8192)
+        .describe('Maximum number of tokens to include per URL. The default is 4096 and maximum is 8192.')
+        .optional(),
+    maximum_number_of_snippets_per_url: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .describe('Maximum number of snippets to include per URL. The default is 50 and maximum is 100.')
+        .optional(),
+    goggles: z
+        .union([z.string(), z.array(z.string())])
+        .describe("Goggles act as a custom re-ranking on top of Brave's search index. The parameter supports both a url where the Goggle is hosted or the definition of the Goggle. Multiple goggle URLs and/or definitions can be provided in an array. For more details, refer to the Goggles repository (i.e., https://github.com/brave/goggles-quickstart).")
+        .optional(),
+    freshness: FreshnessSchema.optional(),
+    enable_local: z
+        .boolean()
+        .describe('Whether to enable local recall. Not setting this value means auto-detect and uses local recall if any of the localization headers are provided.')
+        .optional(),
+    enable_source_metadata: z
+        .boolean()
+        .describe('Enable source metadata enrichment (site_name, favicon) in the sources attribute of the response.')
+        .optional(),
+});
+export const RequestHeadersSchema = z.object({
+    'x-loc-lat': z
+        .number()
+        .min(-90)
+        .max(90)
+        .describe("The latitude of the client's geographical location in degrees, to provide relevant local results. The latitude must be greater than or equal to -90.0 degrees and less than or equal to +90.0 degrees.")
+        .optional(),
+    'x-loc-long': z
+        .number()
+        .min(-180)
+        .max(180)
+        .describe("The longitude of the client's geographical location in degrees, to provide relevant local results. The longitude must be greater than or equal to -180.0 and less than or equal to +180.0 degrees.")
+        .optional(),
+    'x-loc-city': z.string().describe('The generic name of the client city').optional(),
+    'x-loc-state': z
+        .string()
+        .max(3)
+        .describe("A code which could be up to three characters, that represent the client's state/region. The region is the first-level subdivision (the broadest or least specific) of the ISO 3166-2 code.")
+        .optional(),
+    'x-loc-state-name': z
+        .string()
+        .describe('The name of the client’s state/region. The region is the first-level subdivision (the broadest or least specific) of the ISO 3166-2 code.')
+        .optional(),
+    'x-loc-country': z
+        .string()
+        .length(2)
+        .describe('The two letter country code for the client’s country. For a list of country codes, see ISO 3166-1 alpha-2')
+        .optional(),
+    'x-loc-postal-code': z.string().describe('The client’s postal code').optional(),
+    'api-version': z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/)
+        .describe('The API version to use. This is denoted by the format YYYY-MM-DD. Default is the latest that is available. Read more about API versioning at https://api-dashboard.search.brave.com/documentation/guides/versioning.')
+        .optional(),
+    accept: z
+        .enum(['application/json', '*/*'])
+        .describe('The default supported media type is application/json.')
+        .optional(),
+    'cache-control': z
+        .literal('no-cache')
+        .describe('Brave Search will return cached content by default. To prevent caching set the Cache-Control header to no-cache. This is currently done as best effort.')
+        .optional(),
+    'user-agent': z
+        .string()
+        .describe('The user agent originating the request. Brave search can utilize the user agent to provide a different experience depending on the device as described by the string. The user agent should follow the commonly used browser agent strings on each platform. For more information on curating user agents, see RFC 9110.')
+        .optional(),
+});
+export const LlmContextInputSchema = z.object({
+    ...RequestParamsSchema.shape,
+    ...RequestHeadersSchema.shape,
+});