diff --git a/src/agent/custom_agent.py b/src/agent/custom_agent.py index 10be78d..5ce7e0b 100644 --- a/src/agent/custom_agent.py +++ b/src/agent/custom_agent.py @@ -111,6 +111,8 @@ class CustomAgent(Agent): # record last actions self._last_actions = None + # record extract content + self.extracted_content = "" # custom new info self.add_infos = add_infos # agent_state for Stop @@ -261,9 +263,16 @@ class CustomAgent(Agent): if len(actions) == 0: # TODO: fix no action case result = [ActionResult(is_done=True, extracted_content=step_info.memory, include_in_memory=True)] + for ret_ in result: + if "Extracted page" in ret_.extracted_content: + # record every extracted page + self.extracted_content += ret_.extracted_content self._last_result = result self._last_actions = actions if len(result) > 0 and result[-1].is_done: + if not self.extracted_content: + self.extracted_content = step_info.memory + result[-1].extracted_content = self.extracted_content logger.info(f"📄 Result: {result[-1].extracted_content}") self.consecutive_failures = 0 @@ -338,6 +347,10 @@ class CustomAgent(Agent): break else: logger.info("❌ Failed to complete task in maximum steps") + if not self.extracted_content: + self.history.history[-1].result[-1].extracted_content = step_info.memory + else: + self.history.history[-1].result[-1].extracted_content = self.extracted_content return self.history diff --git a/src/agent/custom_prompts.py b/src/agent/custom_prompts.py index 5a8d069..fcb0721 100644 --- a/src/agent/custom_prompts.py +++ b/src/agent/custom_prompts.py @@ -5,6 +5,7 @@ from browser_use.agent.prompts import SystemPrompt, AgentMessagePrompt from browser_use.agent.views import ActionResult, ActionModel from browser_use.browser.views import BrowserState from langchain_core.messages import HumanMessage, SystemMessage +from datetime import datetime from .custom_views import CustomAgentStepInfo @@ -116,15 +117,11 @@ class CustomSystemPrompt(SystemPrompt): Returns: str: Formatted system prompt """ - time_str = self.current_date.strftime("%Y-%m-%d %H:%M") - AGENT_PROMPT = f"""You are a precise browser automation agent that interacts with websites through structured commands. Your role is to: 1. Analyze the provided webpage elements and structure 2. Plan a sequence of actions to accomplish the given task 3. Your final result MUST be a valid JSON as the **RESPONSE FORMAT** described, containing your action sequence and state assessment, No need extra content to expalin. - Current date and time: {time_str} - {self.input_format()} {self.important_rules()} @@ -159,6 +156,9 @@ class CustomAgentMessagePrompt(AgentMessagePrompt): step_info_description = f'Current step: {self.step_info.step_number}/{self.step_info.max_steps}\n' else: step_info_description = '' + + time_str = datetime.now().strftime("%Y-%m-%d %H:%M") + step_info_description += "Current date and time: {time_str}" elements_text = self.state.element_tree.clickable_elements_to_string(include_attributes=self.include_attributes) diff --git a/src/controller/custom_controller.py b/src/controller/custom_controller.py index 4e2ca0f..a042eb1 100644 --- a/src/controller/custom_controller.py +++ b/src/controller/custom_controller.py @@ -1,15 +1,33 @@ +import pdb + import pyperclip from typing import Optional, Type from pydantic import BaseModel from browser_use.agent.views import ActionResult from browser_use.browser.context import BrowserContext from browser_use.controller.service import Controller, DoneAction +from main_content_extractor import MainContentExtractor +from browser_use.controller.views import ( + ClickElementAction, + DoneAction, + ExtractPageContentAction, + GoToUrlAction, + InputTextAction, + OpenTabAction, + ScrollAction, + SearchGoogleAction, + SendKeysAction, + SwitchTabAction, +) +import logging + +logger = logging.getLogger(__name__) class CustomController(Controller): def __init__(self, exclude_actions: list[str] = [], - output_model: Optional[Type[BaseModel]] = None - ): + output_model: Optional[Type[BaseModel]] = None + ): super().__init__(exclude_actions=exclude_actions, output_model=output_model) self._register_custom_actions() @@ -29,3 +47,25 @@ class CustomController(Controller): await page.keyboard.type(text) return ActionResult(extracted_content=text) + + @self.registry.action( + 'Extract page content to get the pure text or markdown with links if include_links is set to true', + param_model=ExtractPageContentAction, + requires_browser=True, + ) + async def extract_content(params: ExtractPageContentAction, browser: BrowserContext): + page = await browser.get_current_page() + # use jina reader + url = page.url + jina_url = f"https://r.jina.ai/{url}" + await page.goto(jina_url) + output_format = 'markdown' if params.include_links else 'text' + content = MainContentExtractor.extract( # type: ignore + html=await page.content(), + output_format=output_format, + ) + # go back to org url + await page.go_back() + msg = f'📄 Extracted page content as {output_format}\n: {content}\n' + logger.info(msg) + return ActionResult(extracted_content=msg) diff --git a/src/utils/deep_research.py b/src/utils/deep_research.py new file mode 100644 index 0000000..5327aaf --- /dev/null +++ b/src/utils/deep_research.py @@ -0,0 +1,260 @@ + +import pdb + +from dotenv import load_dotenv + +load_dotenv() +import asyncio +import os +import sys +import logging +from pprint import pprint +from uuid import uuid4 +from src.utils import utils +from src.agent.custom_agent import CustomAgent +import json +from browser_use.agent.service import Agent +from browser_use.browser.browser import BrowserConfig, Browser +from langchain.schema import SystemMessage, HumanMessage +from json_repair import repair_json +from src.agent.custom_prompts import CustomSystemPrompt, CustomAgentMessagePrompt +from src.controller.custom_controller import CustomController + +logger = logging.getLogger(__name__) + +async def deep_research(task, llm, **kwargs): + task_id = str(uuid4()) + save_dir = kwargs.get("save_dir", os.path.join(f"./tmp/deep_research/{task_id}")) + logger.info(f"Save Deep Research at: {save_dir}") + os.makedirs(save_dir, exist_ok=True) + + # max qyery num per iteration + max_query_num = kwargs.get("max_query_num", 3) + search_system_prompt = f""" + You are a **Deep Researcher**, an AI agent specializing in in-depth information gathering and research using a web browser with **automated execution capabilities**. Your expertise lies in formulating comprehensive research plans and executing them meticulously to fulfill complex user requests. You will analyze user instructions, devise a detailed research plan, and determine the necessary search queries to gather the required information. + + **Your Task:** + + Given a user's research topic, you will: + + 1. **Develop a Research Plan:** Outline the key aspects and subtopics that need to be investigated to thoroughly address the user's request. This plan should be a high-level overview of the research direction. + 2. **Generate Search Queries:** Based on your research plan, generate a list of specific search queries to be executed in a web browser. These queries should be designed to efficiently gather relevant information for each aspect of your plan. + + **Output Format:** + + Your output will be a JSON object with the following structure: + + ```json + {{ + "plan": "A concise, high-level research plan outlining the key areas to investigate.", + "queries": [ + "search query 1", + "search query 2", + //... up to a maximum of {max_query_num} search queries + ] + }} + ``` + + **Important:** + + * Limit your output to a **maximum of {max_query_num}** search queries. + * Make the search queries to help the automated agent find the needed information. Consider what keywords are most likely to lead to useful results. + * If you have gathered for all the information you want and no further search queries are required, output queries with an empty list: `[]` + * Make sure output search queries are different from the history queries. + + **Inputs:** + + 1. **User Instruction:** The original instruction given by the user. + 2. **Previous Queries:** History Queries. + 3. **Previous Search Results:** Textual data gathered from prior search queries. If there are no previous search results this string will be empty. + """ + search_messages = [SystemMessage(content=search_system_prompt)] + + record_system_prompt = """ + You are an expert information recorder. Your role is to process user instructions, current search results, and previously recorded information to extract, summarize, and record new, useful information that helps fulfill the user's request. Your output will be a JSON formatted list, where each element represents a piece of extracted information and follows the structure: `{"url": "source_url", "title": "source_title", "summary_content": "concise_summary", "thinking": "reasoning"}`. + +**Important Considerations:** + +1. **Minimize Information Loss:** While concise, prioritize retaining important details and nuances from the sources. Aim for a summary that captures the essence of the information without over-simplification. **Crucially, ensure to preserve key data and figures within the `summary_content`. This is essential for later stages, such as generating tables and reports.** + +2. **Avoid Redundancy:** Do not record information that is already present in the Previous Recorded Information. Check for semantic similarity, not just exact matches. However, if the same information is expressed differently in a new source and this variation adds valuable context or clarity, it should be included. + +3. **Source Information:** Extract and include the source title and URL for each piece of information summarized. This is crucial for verification and context. **The Current Search Results are provided in a specific format, where each item starts with "Title:", followed by the title, then "URL Source:", followed by the URL, and finally "Markdown Content:", followed by the content. Please extract the title and URL from this structure.** If a piece of information cannot be attributed to a specific source from the provided search results, use `"url": "unknown"` and `"title": "unknown"`. + +4. **Thinking and Report Structure:** For each extracted piece of information, add a `"thinking"` key. This field should contain your assessment of how this information could be used in a report, which section it might belong to (e.g., introduction, background, analysis, conclusion, specific subtopics), and any other relevant thoughts about its significance or connection to other information. + +**Output Format:** + +Provide your output as a JSON formatted list. Each item in the list must adhere to the following format: + +```json +[ + { + "url": "source_url_1", + "title": "source_title_1", + "summary_content": "Concise summary of content. Remember to include key data and figures here.", + "thinking": "This could be used in the introduction to set the context. It also relates to the section on the history of the topic." + }, + // ... more entries + { + "url": "unknown", + "title": "unknown", + "summary_content": "concise_summary_of_content_without_clear_source", + "thinking": "This might be useful background information, but I need to verify its accuracy. Could be used in the methodology section to explain how data was collected." + } +] +``` + +**Inputs:** + +1. **User Instruction:** The original instruction given by the user. This helps you determine what kind of information will be useful and how to structure your thinking. +2. **Previous Recorded Information:** Textual data gathered and recorded from previous searches and processing, represented as a single text string. +3. **Current Search Results:** Textual data gathered from the most recent search query. + """ + record_messages = [SystemMessage(content=record_system_prompt)] + + browser = Browser( + config=BrowserConfig( + disable_security=True, + headless=kwargs.get("headless", False), # Set to False to see browser actions + ) + ) + controller = CustomController() + + search_iteration = 0 + max_search_iterations = kwargs.get("max_search_iterations", 10) # Limit search iterations to prevent infinite loop + use_vision = kwargs.get("use_vision", False) + + history_query = [] + history_infos = [] + try: + while search_iteration < max_search_iterations: + search_iteration += 1 + logger.info(f"Start {search_iteration}th Search...") + history_query_ = json.dumps(history_query, indent=4) + history_infos_ = json.dumps(history_infos, indent=4) + query_prompt = f"This is search {search_iteration} of {max_search_iterations} maximum searches allowed.\n User Instruction:{task} \n Previous Queries:\n {history_query_} \n Previous Search Results:\n {history_infos_}\n" + search_messages.append(HumanMessage(content=query_prompt)) + ai_query_msg = llm.invoke(search_messages[:1] + search_messages[1:][-1:]) + search_messages.append(ai_query_msg) + if hasattr(ai_query_msg, "reasoning_content"): + logger.info("🤯 Start Search Deep Thinking: ") + logger.info(ai_query_msg.reasoning_content) + logger.info("🤯 End Search Deep Thinking") + ai_query_content = ai_query_msg.content.replace("```json", "").replace("```", "") + ai_query_content = repair_json(ai_query_content) + ai_query_content = json.loads(ai_query_content) + query_plan = ai_query_content["plan"] + logger.info(f"Current Iteration {search_iteration} Planing:") + logger.info(query_plan) + query_tasks = ai_query_content["queries"] + if not query_tasks: + break + else: + history_query.extend(query_tasks) + logger.info("Query tasks:") + logger.info(query_tasks) + + # 2. Perform Web Search and Auto exec + # Paralle BU agents + add_infos = "1. Please click on the most relevant link to get information and go deeper, instead of just staying on the search page. \n" \ + "2. When opening a PDF file, please remember to extract the content using extract_content instead of simply opening it for the user to view." + agents = [CustomAgent( + task=task, + llm=llm, + add_infos=add_infos, + browser=browser, + use_vision=use_vision, + system_prompt_class=CustomSystemPrompt, + agent_prompt_class=CustomAgentMessagePrompt, + max_actions_per_step=5, + controller=controller + ) for task in query_tasks] + query_results = await asyncio.gather(*[agent.run(max_steps=kwargs.get("max_steps", 10)) for agent in agents]) + + # 3. Summarize Search Result + query_result_dir = os.path.join(save_dir, "query_results") + os.makedirs(query_result_dir, exist_ok=True) + for i in range(len(query_tasks)): + query_result = query_results[i].final_result() + querr_save_path = os.path.join(query_result_dir, f"{search_iteration}-{i}.md") + logger.info(f"save query: {query_tasks[i]} at {querr_save_path}") + with open(querr_save_path, "w", encoding="utf-8") as fw: + fw.write(f"Query: {query_tasks[i]}\n") + fw.write(query_result) + history_infos_ = json.dumps(history_infos, indent=4) + record_prompt = f"User Instruction:{task}. \nPrevious Recorded Information:\n {json.dumps(history_infos_)} \n Current Search Results: {query_result}\n " + record_messages.append(HumanMessage(content=record_prompt)) + ai_record_msg = llm.invoke(record_messages[:1] + record_messages[-1:]) + record_messages.append(ai_record_msg) + if hasattr(ai_record_msg, "reasoning_content"): + logger.info("🤯 Start Record Deep Thinking: ") + logger.info(ai_record_msg.reasoning_content) + logger.info("🤯 End Record Deep Thinking") + record_content = ai_record_msg.content + record_content = repair_json(record_content) + new_record_infos = json.loads(record_content) + history_infos.extend(new_record_infos) + + logger.info("\nFinish Searching, Start Generating Report...") + + # 5. Report Generation in Markdown (or JSON if you prefer) + writer_system_prompt = """ + You are a **Deep Researcher** and a professional report writer tasked with creating polished, high-quality reports that fully meet the user's needs, based on the user's instructions and the relevant information provided. You will write the report using Markdown format, ensuring it is both informative and visually appealing. + +**Specific Instructions:** + +* **Structure for Impact:** The report must have a clear, logical, and impactful structure. Begin with a compelling introduction that immediately grabs the reader's attention. Develop well-structured body paragraphs that flow smoothly and logically, and conclude with a concise and memorable conclusion that summarizes key takeaways and leaves a lasting impression. +* **Engaging and Vivid Language:** Employ precise, vivid, and descriptive language to make the report captivating and enjoyable to read. Use stylistic techniques to enhance engagement. Tailor your tone, vocabulary, and writing style to perfectly suit the subject matter and the intended audience to maximize impact and readability. +* **Accuracy, Credibility, and Citations:** Ensure that all information presented is meticulously accurate, rigorously truthful, and robustly supported by the available data. **Cite sources exclusively using bracketed sequential numbers within the text (e.g., [1], [2], etc.). If no references are used, omit citations entirely.** These numbers must correspond to a numbered list of references at the end of the report. +* **Publication-Ready Formatting:** Adhere strictly to Markdown formatting for excellent readability and a clean, highly professional visual appearance. Pay close attention to formatting details like headings, lists, emphasis, and spacing to optimize the visual presentation and reader experience. The report should be ready for immediate publication upon completion, requiring minimal to no further editing for style or format. +* **Conciseness and Clarity (Unless Specified Otherwise):** When the user does not provide a specific length, prioritize concise and to-the-point writing, maximizing information density while maintaining clarity. +* **Data-Driven Comparisons with Tables:** **When appropriate and beneficial for enhancing clarity and impact, present data comparisons in well-structured Markdown tables. This is especially encouraged when dealing with numerical data or when a visual comparison can significantly improve the reader's understanding.** +* **Length Adherence:** When the user specifies a length constraint, meticulously stay within reasonable bounds of that specification, ensuring the content is appropriately scaled without sacrificing quality or completeness. +* **Comprehensive Instruction Following:** Pay meticulous attention to all details and nuances provided in the user instructions. Strive to fulfill every aspect of the user's request with the highest degree of accuracy and attention to detail, creating a report that not only meets but exceeds expectations for quality and professionalism. +* **Reference List Formatting:** The reference list at the end must be formatted as follows: + `[1] Title (URL, if available)` + **Each reference must be separated by a blank line to ensure proper spacing.** For example: + + ``` + [1] Title 1 (URL1, if available) + + [2] Title 2 (URL2, if available) + ``` + **Furthermore, ensure that the reference list is free of duplicates. Each unique source should be listed only once, regardless of how many times it is cited in the text.** +* **ABSOLUTE FINAL OUTPUT RESTRICTION:** **Your output must contain ONLY the finished, publication-ready Markdown report. Do not include ANY extraneous text, phrases, preambles, meta-commentary, or markdown code indicators (e.g., "```markdown```"). The report should begin directly with the title and introductory paragraph, and end directly after the conclusion and the reference list (if applicable).** **Your response will be deemed a failure if this instruction is not followed precisely.** + +**Inputs:** + +1. **User Instruction:** The original instruction given by the user. This helps you determine what kind of information will be useful and how to structure your thinking. +2. **Search Information:** Information gathered from the search queries. + """ + + history_infos_ = json.dumps(history_infos, indent=4) + record_json_path = os.path.join(save_dir, "record_infos.json") + logger.info(f"save All recorded information at {record_json_path}") + with open(record_json_path, "w") as fw: + json.dump(history_infos, fw, indent=4) + report_prompt = f"User Instruction:{task} \n Search Information:\n {history_infos_}" + report_messages = [SystemMessage(content=writer_system_prompt), + HumanMessage(content=report_prompt)] # New context for report generation + ai_report_msg = llm.invoke(report_messages) + if hasattr(ai_report_msg, "reasoning_content"): + logger.info("🤯 Start Report Deep Thinking: ") + logger.info(ai_report_msg.reasoning_content) + logger.info("🤯 End Report Deep Thinking") + report_content = ai_report_msg.content + + report_file_path = os.path.join(save_dir, "final_report.md") + with open(report_file_path, "w", encoding="utf-8") as f: + f.write(report_content) + logger.info(f"Save Report at: {report_file_path}") + return report_content, report_file_path + + except Exception as e: + logger.error(f"Deep research Error: {e}") + return "", None + finally: + if browser: + await browser.close() + logger.info("Browser closed.") \ No newline at end of file diff --git a/src/utils/utils.py b/src/utils/utils.py index 277df24..09dedf8 100644 --- a/src/utils/utils.py +++ b/src/utils/utils.py @@ -3,6 +3,7 @@ import os import time from pathlib import Path from typing import Dict, Optional +import requests from langchain_anthropic import ChatAnthropic from langchain_mistralai import ChatMistralAI @@ -142,7 +143,7 @@ model_names = { "anthropic": ["claude-3-5-sonnet-20240620", "claude-3-opus-20240229"], "openai": ["gpt-4o", "gpt-4", "gpt-3.5-turbo", "o3-mini"], "deepseek": ["deepseek-chat", "deepseek-reasoner"], - "gemini": ["gemini-2.0-flash-exp", "gemini-2.0-flash-thinking-exp", "gemini-1.5-flash-latest", "gemini-1.5-flash-8b-latest", "gemini-2.0-flash-thinking-exp-1219" ], + "gemini": ["gemini-2.0-flash-exp", "gemini-2.0-flash-thinking-exp", "gemini-1.5-flash-latest", "gemini-1.5-flash-8b-latest", "gemini-2.0-flash-thinking-exp-01-21"], "ollama": ["qwen2.5:7b", "llama2:7b", "deepseek-r1:14b", "deepseek-r1:32b"], "azure_openai": ["gpt-4o", "gpt-4", "gpt-3.5-turbo"], "mistral": ["pixtral-large-latest", "mistral-large-latest", "mistral-small-latest", "ministral-8b-latest"] diff --git a/tests/test_browser_use.py b/tests/test_browser_use.py index c9d1129..c467c35 100644 --- a/tests/test_browser_use.py +++ b/tests/test_browser_use.py @@ -233,7 +233,129 @@ async def test_browser_use_custom(): await playwright.stop() if browser: await browser.close() + +async def test_browser_use_parallel(): + from browser_use.browser.context import BrowserContextWindowSize + from browser_use.browser.browser import BrowserConfig + from playwright.async_api import async_playwright + from browser_use.browser.browser import Browser + from src.agent.custom_agent import CustomAgent + from src.agent.custom_prompts import CustomSystemPrompt, CustomAgentMessagePrompt + from src.browser.custom_browser import CustomBrowser + from src.browser.custom_context import BrowserContextConfig + from src.controller.custom_controller import CustomController + + window_w, window_h = 1920, 1080 + + # llm = utils.get_llm_model( + # provider="openai", + # model_name="gpt-4o", + # temperature=0.8, + # base_url=os.getenv("OPENAI_ENDPOINT", ""), + # api_key=os.getenv("OPENAI_API_KEY", ""), + # ) + + # llm = utils.get_llm_model( + # provider="azure_openai", + # model_name="gpt-4o", + # temperature=0.8, + # base_url=os.getenv("AZURE_OPENAI_ENDPOINT", ""), + # api_key=os.getenv("AZURE_OPENAI_API_KEY", ""), + # ) + + llm = utils.get_llm_model( + provider="gemini", + model_name="gemini-2.0-flash-exp", + temperature=1.0, + api_key=os.getenv("GOOGLE_API_KEY", "") + ) + + # llm = utils.get_llm_model( + # provider="deepseek", + # model_name="deepseek-reasoner", + # temperature=0.8 + # ) + + # llm = utils.get_llm_model( + # provider="deepseek", + # model_name="deepseek-chat", + # temperature=0.8 + # ) + + # llm = utils.get_llm_model( + # provider="ollama", model_name="qwen2.5:7b", temperature=0.5 + # ) + + # llm = utils.get_llm_model( + # provider="ollama", model_name="deepseek-r1:14b", temperature=0.5 + # ) + + controller = CustomController() + use_own_browser = True + disable_security = True + use_vision = True # Set to False when using DeepSeek + + max_actions_per_step = 1 + playwright = None + browser = None + browser_context = None + + browser = Browser( + config=BrowserConfig( + disable_security=True, + headless=False, + new_context_config=BrowserContextConfig(save_recording_path='./tmp/recordings'), + ) + ) + + try: + agents = [ + Agent(task=task, llm=llm, browser=browser) + for task in [ + 'Search Google for weather in Tokyo', + 'Check Reddit front page title', + '大S去世', + 'Find NASA image of the day', + # 'Check top story on CNN', + # 'Search latest SpaceX launch date', + # 'Look up population of Paris', + # 'Find current time in Sydney', + # 'Check who won last Super Bowl', + # 'Search trending topics on Twitter', + ] + ] + + history = await asyncio.gather(*[agent.run() for agent in agents]) + pdb.set_trace() + print("Final Result:") + pprint(history.final_result(), indent=4) + + print("\nErrors:") + pprint(history.errors(), indent=4) + + # e.g. xPaths the model clicked on + print("\nModel Outputs:") + pprint(history.model_actions(), indent=4) + + print("\nThoughts:") + pprint(history.model_thoughts(), indent=4) + # close browser + except Exception: + import traceback + + traceback.print_exc() + finally: + # 显式关闭持久化上下文 + if browser_context: + await browser_context.close() + + # 关闭 Playwright 对象 + if playwright: + await playwright.stop() + if browser: + await browser.close() if __name__ == "__main__": # asyncio.run(test_browser_use_org()) - asyncio.run(test_browser_use_custom()) + asyncio.run(test_browser_use_parallel()) + # asyncio.run(test_browser_use_custom()) diff --git a/tests/test_llm_api.py b/tests/test_llm_api.py index b81bb5c..cf6bad6 100644 --- a/tests/test_llm_api.py +++ b/tests/test_llm_api.py @@ -127,6 +127,6 @@ if __name__ == "__main__": # test_azure_openai_model() #test_deepseek_model() # test_ollama_model() - # test_deepseek_r1_model() + test_deepseek_r1_model() # test_deepseek_r1_ollama_model() - test_mistral_model() + # test_mistral_model() diff --git a/webui.py b/webui.py index fa8b0b4..a825b6a 100644 --- a/webui.py +++ b/webui.py @@ -597,6 +597,24 @@ async def close_global_browser(): if _global_browser: await _global_browser.close() _global_browser = None + +async def run_deep_search(research_task, max_search_iteration_input, max_query_per_iter_input, llm_provider, llm_model_name, llm_temperature, llm_base_url, llm_api_key, use_vision, headless): + from src.utils.deep_research import deep_research + + llm = utils.get_llm_model( + provider=llm_provider, + model_name=llm_model_name, + temperature=llm_temperature, + base_url=llm_base_url, + api_key=llm_api_key, + ) + markdown_content, file_path = await deep_research(research_task, llm, + max_search_iterations=max_search_iteration_input, + max_query_num=max_query_per_iter_input, + use_vision=use_vision, + headless=headless) + return markdown_content, file_path + def create_ui(config, theme_name="Ocean"): css = """ @@ -796,6 +814,17 @@ def create_ui(config, theme_name="Ocean"): value="

Waiting for browser session...

", label="Live Browser View", ) + + with gr.TabItem("🧐 Deep Research"): + with gr.Group(): + research_task_input = gr.Textbox(label="Research Task", lines=5, value="Compose a report on the use of Reinforcement Learning for training Large Language Models, encompassing its origins, current advancements, and future prospects, substantiated with examples of relevant models and techniques. The report should reflect original insights and analysis, moving beyond mere summarization of existing literature.") + with gr.Row(): + max_search_iteration_input = gr.Number(label="Max Search Iteration", value=20, precision=0) # precision=0 确保是整数 + max_query_per_iter_input = gr.Number(label="Max Query per Iteration", value=5, precision=0) # precision=0 确保是整数 + research_button = gr.Button("Run Deep Research") + markdown_output_display = gr.Markdown(label="Research Report") + markdown_download = gr.File(label="Download Research Report") + with gr.TabItem("📁 Configuration", id=5): with gr.Group(): @@ -896,6 +925,13 @@ def create_ui(config, theme_name="Ocean"): run_button # Run button ], ) + + # Run Deep Research + research_button.click( + fn=run_deep_search, + inputs=[research_task_input, max_search_iteration_input, max_query_per_iter_input, llm_provider, llm_model_name, llm_temperature, llm_base_url, llm_api_key, use_vision, headless], + outputs=[markdown_output_display, markdown_download] + ) with gr.TabItem("🎥 Recordings", id=7): def list_recordings(save_recording_path):