Brave Search MCP Server for Research Automation

#!/usr/bin/env node

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
import axios from 'axios';

const BRAVE_API_KEY = process.env.BRAVE_SEARCH_API_KEY;

const server = new Server({
  name: 'brave-search-mcp',
  version: '1.0.0'
}, {
  capabilities: {
    tools: {}
  }
});

server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: 'brave_web_search',
        description: 'Search the web using Brave Search API',
        inputSchema: {
          type: 'object',
          properties: {
            query: { type: 'string', description: 'Search query' },
            count: { type: 'number', description: 'Number of results (default 10)', default: 10 },
            offset: { type: 'number', description: 'Result offset for pagination', default: 0 }
          },
          required: ['query']
        }
      },
      {
        name: 'brave_news_search',
        description: 'Search news using Brave Search API',
        inputSchema: {
          type: 'object',
          properties: {
            query: { type: 'string', description: 'News search query' },
            count: { type: 'number', description: 'Number of results', default: 10 }
          },
          required: ['query']
        }
      }
    ]
  };
});

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  try {
    if (name === 'brave_web_search') {
      const response = await axios.get('https://api.search.brave.com/res/v1/web/search', {
        headers: {
          'Accept': 'application/json',
          'X-Subscription-Token': BRAVE_API_KEY
        },
        params: {
          q: args.query,
          count: args.count || 10,
          offset: args.offset || 0
        }
      });

      return {
        content: [{
          type: 'text',
          text: JSON.stringify(response.data, null, 2)
        }]
      };
    }

    if (name === 'brave_news_search') {
      const response = await axios.get('https://api.search.brave.com/res/v1/news/search', {
        headers: {
          'Accept': 'application/json',
          'X-Subscription-Token': BRAVE_API_KEY
        },
        params: {
          q: args.query,
          count: args.count || 10
        }
      });

      return {
        content: [{
          type: 'text',
          text: JSON.stringify(response.data, null, 2)
        }]
      };
    }

    throw new Error(`Unknown tool: ${name}`);
  } catch (error) {
    return {
      content: [{
        type: 'text',
        text: `Error: ${error.message}`
      }]
    };
  }
});

const transport = new StdioServerTransport();
await server.connect(transport);

// research-pipeline.md
# Research Pipeline Skill

You help execute multi-step research workflows using Brave Search MCP.

## Process

1. **Initial Discovery**: Search broadly to map out the topic
2. **Deep Focus**: Query specific aspects identified in discovery
3. **Synthesis**: Combine findings into actionable insights

## Tools

- Use `brave_web_search` for general research
- Use `brave_news_search` for recent developments
- Use `tdd` skill to validate technical claims with tests
- Use `frontend-design` skill to review UI/UX research findings

const searchCache = new Map();

async function cachedSearch(query, type = 'web') {
  const cacheKey = `${type}:${query}`;
  
  if (searchCache.has(cacheKey)) {
    const cached = searchCache.get(cacheKey);
    if (Date.now() - cached.timestamp < 3600000) { // 1 hour cache
      return cached.results;
    }
  }

  const results = await braveSearch(query, type);
  searchCache.set(cacheKey, { results, timestamp: Date.now() });
  return results;
}