QuickResearchTool

def __init__(
    self,
    *,
    llm_config: LLMConfig,
    tavily_api_key: str | None = None,
    num_results_per_query: int = 3,
) -> None:
    """Initialize the QuickResearchTool.

    Args:
        llm_config: LLM configuration for summarization. Supports any AG2-compatible provider.
        tavily_api_key: Tavily API key. Falls back to TAVILY_API_KEY env var.
        num_results_per_query: Number of search results to crawl per query. Defaults to 3.

    Raises:
        ValueError: If tavily_api_key is not provided or set in env vars.
    """
    self.tavily_api_key = tavily_api_key or os.getenv("TAVILY_API_KEY")
    self.llm_config = llm_config
    self.num_results_per_query = num_results_per_query

    # Extract config_list as list of dicts for OpenAIWrapper
    self._config_list = [c.model_dump() for c in llm_config.config_list]

    if self.tavily_api_key is None:
        raise ValueError("tavily_api_key must be provided either as an argument or via TAVILY_API_KEY env var")

    async def quick_research(
        queries: Annotated[list[str], "List of search queries to research (max 5)."],
        tavily_api_key: Annotated[str, Depends(on(self.tavily_api_key))],
        config_list: Annotated[list[dict[str, Any]], Depends(on(self._config_list))],
        num_results_per_query: Annotated[int, Depends(on(self.num_results_per_query))],
        chunk_prompt: Annotated[
            str, "Prompt for summarizing individual text chunks."
        ] = "Summarise the chunk, preserving all facts.",
        merger_prompt: Annotated[
            str, "Prompt for merging chunk summaries."
        ] = "Merge the partial summaries into one coherent overview.",
        full_prompt: Annotated[
            str, "Prompt for summarizing short texts in one pass."
        ] = "Provide a concise but complete summary.",
    ) -> str:
        """Research multiple queries in parallel and return summarized sources.

        For each query:
        1. Performs Tavily search to get top N results
        2. Crawls each result URL using crawl4ai
        3. Summarizes page content via LLM

        Args:
            queries: List of search queries (max 5).
            tavily_api_key: Tavily API key (injected dependency).
            config_list: LLM config list (injected dependency).
            num_results_per_query: Number of results per query (injected dependency).
            chunk_prompt: Prompt for summarizing individual text chunks.
            merger_prompt: Prompt for merging chunk summaries.
            full_prompt: Prompt for summarizing short texts in one pass.

        Returns:
            JSON string: list of objects with query and sources (title, url, summary).
        """
        if not queries:
            return "[]"

        queries = queries[:MAX_QUERIES]

        enc = tiktoken.get_encoding("cl100k_base")

        research_tasks = [
            _research_single_query(
                query,
                tavily_api_key=tavily_api_key,
                config_list=config_list,
                enc=enc,
                num_results=num_results_per_query,
                chunk_prompt=chunk_prompt,
                merger_prompt=merger_prompt,
                full_prompt=full_prompt,
            )
            for query in queries
        ]

        results = await asyncio.gather(*research_tasks, return_exceptions=True)

        output = []
        for result in results:
            if isinstance(result, Exception):
                continue
            output.append(result)

        return json.dumps(output)

    super().__init__(
        name="quick_research",
        description="Research multiple queries in parallel using web search, crawling, and LLM summarization.",
        func_or_tool=quick_research,
    )