parallel_search

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;
  }