alita-sdk 0.3.175__py3-none-any.whl → 0.3.177__py3-none-any.whl

alita_sdk/community/deep_researcher/api_wrapper.py

@@ -1,116 +0,0 @@
-from typing import Any, Optional, Dict
-import asyncio
-import json
-from pydantic import create_model, Field
-
-from alita_sdk.tools.elitea_base import BaseToolApiWrapper
-from .deep_research import DeepResearcher
-from .iterative_research import IterativeResearcher
-from .llm_config import LLMConfig, create_default_config
-from langchain_core.language_models.llms import BaseLLM
-from langchain_core.language_models.chat_models import BaseChatModel
-
-
-class DeepResearcherWrapper(BaseToolApiWrapper):
-    """Wrapper for deep_researcher module to be used as a LangChain toolkit."""
-    alita: Any = None
-    llm: Optional[BaseLLM | BaseChatModel] = None
-    max_iterations: int = 5
-    max_time_minutes: int = 10
-    verbose: bool = False
-    tracing: bool = False
-    config: Optional[LLMConfig] = None
-    
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        # Initialize the config if not provided
-        if not self.config:
-            self.config = create_default_config(langchain_llm=self.llm)
-        # Override llm in config if provided
-        elif self.llm and not self.config.langchain_llm:
-            # Create a new config with the langchain_llm
-            self.config = create_default_config(langchain_llm=self.llm)
-    
-    def _setup_deep_researcher(self) -> DeepResearcher:
-        """Initialize a DeepResearcher instance with current settings."""
-        return DeepResearcher(
-            max_iterations=self.max_iterations,
-            max_time_minutes=self.max_time_minutes,
-            verbose=self.verbose,
-            tracing=self.tracing,
-            config=self.config,
-            llm=self.llm,
-            alita=self.alita
-        )
-    
-    def _setup_iterative_researcher(self) -> IterativeResearcher:
-        """Initialize an IterativeResearcher instance with current settings."""
-        return IterativeResearcher(
-            max_iterations=self.max_iterations,
-            max_time_minutes=self.max_time_minutes,
-            verbose=self.verbose,
-            tracing=self.tracing,
-            config=self.config,
-            llm=self.llm,
-            alita=self.alita
-        )
-    
-    def run_deep_research(self, query: str) -> str:
-        """
-        Run deep research on a query, breaking it down into sections and iteratively researching each part.
-        
-        Args:
-            query: The research query
-            
-        Returns:
-            Comprehensive research report
-        """
-        researcher = self._setup_deep_researcher()
-        return asyncio.run(researcher.run(query))
-    
-    def run_iterative_research(self, query: str, output_length: str = "5 pages", output_instructions: str = "", background_context: str = "") -> str:
-        """
-        Run iterative research on a query, conducting multiple iterations to address knowledge gaps.
-        
-        Args:
-            query: The research query
-            output_length: Desired length of the output (e.g., "5 pages", "2 paragraphs")
-            output_instructions: Additional instructions for output formatting
-            background_context: Additional context to provide for the research
-            
-        Returns:
-            Research report based on iterative findings
-        """
-        researcher = self._setup_iterative_researcher()
-        return asyncio.run(researcher.run(
-            query=query,
-            output_length=output_length,
-            output_instructions=output_instructions,
-            background_context=background_context
-        ))
-    
-    def get_available_tools(self):
-        """Return the list of available tools."""
-        return [
-            {
-                "name": "run_deep_research",
-                "ref": self.run_deep_research,
-                "description": self.run_deep_research.__doc__,
-                "args_schema": create_model(
-                    "DeepResearchModel",
-                    query=(str, Field(description="The research query to investigate thoroughly"))
-                )
-            },
-            {
-                "name": "run_iterative_research",
-                "ref": self.run_iterative_research,
-                "description": self.run_iterative_research.__doc__,
-                "args_schema": create_model(
-                    "IterativeResearchModel",
-                    query=(str, Field(description="The research query to investigate")),
-                    output_length=(str, Field(description="Desired length of the output (e.g., '5 pages', '2 paragraphs')", default="5 pages")),
-                    output_instructions=(str, Field(description="Additional instructions for output formatting", default="")),
-                    background_context=(str, Field(description="Additional context to provide for the research", default=""))
-                )
-            }
-        ]

alita_sdk/community/deep_researcher/deep_research.py

@@ -1,185 +0,0 @@
-import asyncio
-import time
-from .iterative_research import IterativeResearcher
-from .agents.planner_agent import init_planner_agent, ReportPlan, ReportPlanSection
-from .agents.proofreader_agent import ReportDraftSection, ReportDraft, init_proofreader_agent
-from .agents.long_writer_agent import init_long_writer_agent, write_report
-from .agents.baseclass import ResearchRunner
-from typing import List, Optional, Any
-from agents.tracing import trace, gen_trace_id, custom_span
-from .llm_config import LLMConfig, create_default_config
-
-
-class DeepResearcher:
-    """
-    Manager for the deep research workflow that breaks down a query into a report plan with sections and then runs an iterative research loop for each section.
-    """
-    def __init__(
-            self, 
-            max_iterations: int = 5,
-            max_time_minutes: int = 10,
-            verbose: bool = True,
-            tracing: bool = False,
-            config: Optional[LLMConfig] = None,
-            llm: Optional[Any] = None,
-            alita: Optional[Any] = None
-        ):
-        self.max_iterations = max_iterations
-        self.max_time_minutes = max_time_minutes
-        self.verbose = verbose
-        self.tracing = tracing
-        self.alita = alita
-        
-        # Initialize config with langchain LLM if provided
-        if llm is not None:
-            self.config = create_default_config(langchain_llm=llm)
-        elif config is not None:
-            self.config = config
-        else:
-            self.config = create_default_config()
-            
-        self.planner_agent = init_planner_agent(self.config)
-        self.proofreader_agent = init_proofreader_agent(self.config)
-        self.long_writer_agent = init_long_writer_agent(self.config)
-
-    async def run(self, query: str) -> str:
-        """Run the deep research workflow"""
-        start_time = time.time()
-
-        if self.tracing:
-            trace_id = gen_trace_id()
-            workflow_trace = trace("deep_researcher", trace_id=trace_id)
-            print(f"View trace: https://platform.openai.com/traces/trace?trace_id={trace_id}")
-            workflow_trace.start(mark_as_current=True)
-
-        # First build the report plan which outlines the sections and compiles any relevant background context on the query
-        report_plan: ReportPlan = await self._build_report_plan(query)
-
-        # Run the independent research loops concurrently for each section and gather the results
-        research_results: List[str] = await self._run_research_loops(report_plan)
-
-        # Create the final report from the original report plan and the drafts of each section
-        final_report: str = await self._create_final_report(query, report_plan, research_results)
-
-        elapsed_time = time.time() - start_time
-        self._log_message(f"DeepResearcher completed in {int(elapsed_time // 60)} minutes and {int(elapsed_time % 60)} seconds")
-
-        if self.tracing:
-            workflow_trace.finish(reset_current=True)
-
-        return final_report
-
-    async def _build_report_plan(self, query: str) -> ReportPlan:
-        """Build the initial report plan including the report outline (sections and key questions) and background context"""
-        if self.tracing:
-            span = custom_span(name="build_report_plan")
-            span.start(mark_as_current=True)
-
-        self._log_message("=== Building Report Plan ===")
-        user_message = f"QUERY: {query}"
-        result = await ResearchRunner.run(
-            self.planner_agent,
-            user_message
-        )
-        report_plan = result.final_output_as(ReportPlan)
-
-        if self.verbose:
-            num_sections = len(report_plan.report_outline)
-            message_log = '\n\n'.join(f"Section: {section.title}\nKey question: {section.key_question}" for section in report_plan.report_outline)
-            if report_plan.background_context:
-                message_log += f"\n\nThe following background context has been included for the report build:\n{report_plan.background_context}"
-            else:
-                message_log += "\n\nNo background context was provided for the report build.\n"
-            self._log_message(f"Report plan created with {num_sections} sections:\n{message_log}")
-
-        if self.tracing:
-            span.finish(reset_current=True)
-
-        return report_plan
-
-    async def _run_research_loops(
-        self, 
-        report_plan: ReportPlan
-    ) -> List[str]:
-        """For a given ReportPlan, run a research loop concurrently for each section and gather the results"""
-        async def run_research_for_section(section: ReportPlanSection):
-            iterative_researcher = IterativeResearcher(
-                max_iterations=self.max_iterations,
-                max_time_minutes=self.max_time_minutes,
-                verbose=self.verbose,
-                tracing=False,  # Do not trace as this will conflict with the tracing we already have set up for the deep researcher
-                config=self.config
-            )
-            args = {
-                "query": section.key_question,
-                "output_length": "",
-                "output_instructions": "",
-                "background_context": report_plan.background_context,
-            }
-            
-            # Only use custom span if tracing is enabled
-            if self.tracing:
-                with custom_span(
-                    name=f"iterative_researcher:{section.title}", 
-                    data={"key_question": section.key_question}
-                ):
-                    return await iterative_researcher.run(**args)
-            else:
-                return await iterative_researcher.run(**args)
-        
-        self._log_message("=== Initializing Research Loops ===")
-        # Run all research loops concurrently in a single gather call
-        research_results = await asyncio.gather(
-            *(run_research_for_section(section) for section in report_plan.report_outline)
-        )
-        return research_results
-
-    async def _create_final_report(
-        self, 
-        query: str, 
-        report_plan: ReportPlan, 
-        section_drafts: List[str],
-        use_long_writer: bool = True
-    ) -> str:
-        """Create the final report from the original report plan and the drafts of each section"""
-        if self.tracing:
-            span = custom_span(name="create_final_report")
-            span.start(mark_as_current=True)
-
-        # Each section is a string containing the markdown for the section
-        # From this we need to build a ReportDraft object to feed to the final proofreader agent
-        report_draft = ReportDraft(
-            sections=[]
-        )
-        for i, section_draft in enumerate(section_drafts):
-            report_draft.sections.append(
-                ReportDraftSection(
-                    section_title=report_plan.report_outline[i].title,
-                    section_content=section_draft
-                )
-            )
-
-        self._log_message("\n=== Building Final Report ===")
-
-        if use_long_writer:
-            final_output = await write_report(self.long_writer_agent, query, report_plan.report_title, report_draft)
-        else:
-            user_prompt = f"QUERY:\n{query}\n\nREPORT DRAFT:\n{report_draft.model_dump_json()}"
-            # Run the proofreader agent to produce the final report
-            final_report = await ResearchRunner.run(
-                self.proofreader_agent,
-                user_prompt
-            )
-            final_output = final_report.final_output
-
-        self._log_message(f"Final report completed")
-
-        if self.tracing:
-            span.finish(reset_current=True)
-
-        return final_output
-
-    def _log_message(self, message: str) -> None:
-        """Log a message if verbose is True"""
-        if self.verbose:
-            print(message)

alita_sdk/community/deep_researcher/examples/deep_example.py

@@ -1,30 +0,0 @@
-"""
-Example usage of the DeepResearcher to produce a report.
-
-See deep_output.txt for the console output from running this script, and deep_output.pdf for the final report
-"""
-
-import asyncio
-import os
-import sys
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
-from deep_researcher import DeepResearcher
-
-manager = DeepResearcher(
-    max_iterations=3,
-    max_time_minutes=10,
-    verbose=True,
-    tracing=True
-)
-
-query = "Write a report on Plato - who was he, what were his main works " \
-        "and what are the main philosophical ideas he's known for"
-
-report = asyncio.run(
-    manager.run(
-        query
-    )
-)
-
-print("\n=== Final Report ===")
-print(report)

alita_sdk/community/deep_researcher/examples/iterative_example.py

@@ -1,34 +0,0 @@
-"""
-Example usage of the IterativeResearcher to produce a report.
-
-See iterative_output.txt for the console output from running this script, and iterative_output.pdf for the final report
-"""
-
-import asyncio
-import os
-import sys
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
-from deep_researcher import IterativeResearcher
-
-manager = IterativeResearcher(
-    max_iterations=5,
-    max_time_minutes=10,
-    verbose=True,
-    tracing=True
-)
-
-query = "Write a report on Plato - who was he, what were his main works " \
-        "and what are the main philosophical ideas he's known for"
-output_length = "5 pages"
-output_instructions = ""
-
-report = asyncio.run(
-    manager.run(
-        query, 
-        output_length=output_length, 
-        output_instructions=output_instructions
-    )
-)
-
-print("\n=== Final Report ===")
-print(report)

alita_sdk/community/deep_researcher/examples/report_plan_example.py

@@ -1,27 +0,0 @@
-import asyncio
-from deep_researcher.agents.planner_agent import planner_agent, ReportPlan
-from agents import gen_trace_id, trace
-from deep_researcher import ResearchRunner
-
-
-async def run_report_planner(query):
-    trace_id = gen_trace_id()
-
-    with trace("Deep Research trace", trace_id=trace_id):
-        print(f"View trace: https://platform.openai.com/traces/{trace_id}")
-        result = await ResearchRunner.run(planner_agent, query)
-        plan = result.final_output_as(ReportPlan)
-        return plan
-
-
-user_query = "Provide a detailed overview of the company Quantera (quantera.io) from an investor's perspective"
-
-plan = asyncio.run(run_report_planner(user_query))
-
-print(f"BACKGROUND CONTEXT:\n{plan.background_context if plan.background_context else 'No background context'}")
-
-print("\nREPORT OUTLINE:\n")
-for section in plan.report_outline:
-    print(f"Section: {section.title}")
-    print(f"Key question: {section.key_question}\n")
-