MCP Deep Web Research Server

Instructions

Implementation Reference

• src/index.ts:125-147 (registration)

  Registration of the 'parallel_search' tool in the MCP server, including name, description, and input schema definition.
  { name: 'parallel_search', description: 'Perform multiple Google searches in parallel', inputSchema: { type: 'object', properties: { queries: { type: 'array', items: { type: 'string' }, description: 'Array of search queries to execute in parallel' }, maxParallel: { type: 'number', description: 'Maximum number of parallel searches', minimum: 1, maximum: 5 } }, required: ['queries'] } },
• src/index.ts:317-335 (handler)

  MCP server handler for 'parallel_search' tool call: validates input, limits queries, delegates to DeepResearch.parallelSearch.parallelSearch(), and returns JSON result.
  case 'parallel_search': { const args = request.params.arguments as unknown as ParallelSearchArgs; if (!args?.queries) { throw new McpError(ErrorCode.InvalidParams, 'Queries array is required'); } const limitedQueries = args.queries.slice(0, 5); console.log(`Starting parallel search with ${limitedQueries.length} queries`); const result = await deepResearch.parallelSearch.parallelSearch(limitedQueries); return { content: [ { type: 'text', text: JSON.stringify(result, null, 2) } ] }; }
• src/parallel-search.ts:196-266 (handler)

  Core handler function: performs parallel Google searches by launching browser contexts, executing searches on google.com, extracting results with relevance scoring, saving to files, and returning structured results with summary.
  public async parallelSearch(queries: string[]): Promise<{ results: ParallelSearchResult[]; summary: { totalQueries: number; successful: number; failed: number; totalExecutionTime?: number; averageExecutionTime?: number; }; }> { const startTime = this.options.includeTimings ? Date.now() : undefined; await this.initialize(); const results: ParallelSearchResult[] = []; const chunks: string[][] = []; // Split queries into chunks of maxParallel size for (let i = 0; i < queries.length; i += this.options.maxParallel) { chunks.push(queries.slice(i, i + this.options.maxParallel)); } // Process each chunk for (const chunk of chunks) { const chunkPromises = chunk.map((query, index) => { const searchId = `search_${Date.now()}_${index + 1}_of_${chunk.length}`; // Stagger the searches return new Promise<ParallelSearchResult>(async (resolve) => { await new Promise(r => setTimeout(r, index * this.options.delayBetweenSearches)); const result = await this.singleSearch( this.contexts[index % this.contexts.length], query, searchId ); resolve(result); }); }); const chunkResults = await Promise.all(chunkPromises); results.push(...chunkResults); // Add a small delay between chunks if (chunks.indexOf(chunk) < chunks.length - 1) { await new Promise(r => setTimeout(r, 1000)); } } const endTime = Date.now(); const successful = results.filter(r => !r.error).length; const failed = results.filter(r => r.error).length; const summary = { totalQueries: queries.length, successful, failed, ...(this.options.includeTimings && startTime ? { totalExecutionTime: endTime - startTime, averageExecutionTime: Math.round((endTime - startTime) / queries.length) } : {}) }; // Add individual execution times to results if timing is enabled const timedResults = this.options.includeTimings ? results.map(r => ({ ...r, executionTime: r.executionTime || 0 })) : results; return { results: timedResults, summary }; }
• src/index.ts:23-26 (schema)

  TypeScript interface defining input arguments for parallel_search tool.
  interface ParallelSearchArgs { queries: string[]; maxParallel?: number; }
• src/types.ts:1-14 (schema)

  Type definitions for SearchResult (single search result) and ParallelSearchResult (result per query), used as output schema for parallel_search.
  export interface SearchResult { title: string; url: string; snippet: string; relevanceScore: number; } export interface ParallelSearchResult { searchId: string; query: string; results: SearchResult[]; error?: string; executionTime?: number; }