parallel_search

Instructions

Implementation Reference

• src/index.ts:317-335 (handler)

  MCP CallToolRequestSchema handler case for 'parallel_search' tool. Validates input arguments, limits queries to 5, delegates execution to DeepResearch.parallelSearch.parallelSearch(), and returns the results as JSON text content.

  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/index.ts:126-147 (registration)

  Registration of the 'parallel_search' tool in the MCP ListToolsRequestSchema handler, 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/parallel-search.ts:196-266 (helper)

  Core implementation of parallel search logic in ParallelSearch class. Launches browser contexts, performs Google searches in parallel chunks using Playwright, extracts results with relevance scoring, handles errors, and provides execution 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/deep-research.ts:54-59 (helper)

  DeepResearch class property and instantiation of ParallelSearch instance used by the tool handler.

  public parallelSearch: ParallelSearch;
  private searchQueue: SearchQueue;
  private activeSessions: Map<string, ResearchSession>;
  
  constructor() {
      this.parallelSearch = new ParallelSearch();