just fork codes from deepagent repo

Author: ks6088ts

template_langgraph/agents/demo_agents/deep_agent_core/__init__.py

@@ -0,0 +1,4 @@
+from deepagents.graph import create_deep_agent
+from deepagents.model import get_default_model
+from deepagents.state import DeepAgentState
+from deepagents.sub_agent import SubAgent

template_langgraph/agents/demo_agents/deep_agent_core/graph.py

@@ -0,0 +1,72 @@
+from collections.abc import Callable, Sequence
+from typing import Any, TypeVar
+
+from deepagents.model import get_default_model
+from deepagents.state import DeepAgentState
+from deepagents.sub_agent import SubAgent, _create_task_tool
+from deepagents.tools import edit_file, ls, read_file, write_file, write_todos
+from langchain_core.language_models import LanguageModelLike
+from langchain_core.tools import BaseTool
+from langgraph.prebuilt import create_react_agent
+from langgraph.types import Checkpointer
+
+StateSchema = TypeVar("StateSchema", bound=DeepAgentState)
+StateSchemaType = type[StateSchema]
+
+base_prompt = """You have access to a number of standard tools
+
+## `write_todos`
+
+You have access to the `write_todos` tools to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
+These tools are also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable.
+
+It is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.
+## `task`
+
+- When doing web search, prefer to use the `task` tool in order to reduce context usage."""
+
+
+def create_deep_agent(
+    tools: Sequence[BaseTool | Callable | dict[str, Any]],
+    instructions: str,
+    model: str | LanguageModelLike | None = None,
+    subagents: list[SubAgent] = None,
+    state_schema: StateSchemaType | None = None,
+    config_schema: type[Any] | None = None,
+    checkpointer: Checkpointer | None = None,
+):
+    """Create a deep agent.
+
+    This agent will by default have access to a tool to write todos (write_todos),
+    and then four file editing tools: write_file, ls, read_file, edit_file.
+
+    Args:
+        tools: The additional tools the agent should have access to.
+        instructions: The additional instructions the agent should have. Will go in
+            the system prompt.
+        model: The model to use.
+        subagents: The subagents to use. Each subagent should be a dictionary with the
+            following keys:
+                - `name`
+                - `description` (used by the main agent to decide whether to call the sub agent)
+                - `prompt` (used as the system prompt in the subagent)
+                - (optional) `tools`
+        state_schema: The schema of the deep agent. Should subclass from DeepAgentState
+        config_schema: The schema of the deep agent.
+        checkpointer: Optional checkpointer for persisting agent state between runs.
+    """
+    prompt = instructions + base_prompt
+    built_in_tools = [write_todos, write_file, read_file, ls, edit_file]
+    if model is None:
+        model = get_default_model()
+    state_schema = state_schema or DeepAgentState
+    task_tool = _create_task_tool(list(tools) + built_in_tools, instructions, subagents or [], model, state_schema)
+    all_tools = built_in_tools + list(tools) + [task_tool]
+    return create_react_agent(
+        model,
+        prompt=prompt,
+        tools=all_tools,
+        state_schema=state_schema,
+        config_schema=config_schema,
+        checkpointer=checkpointer,
+    )

template_langgraph/agents/demo_agents/deep_agent_core/model.py

@@ -0,0 +1,5 @@
+from langchain_anthropic import ChatAnthropic
+
+
+def get_default_model():
+    return ChatAnthropic(model_name="claude-sonnet-4-20250514", max_tokens=64000)

template_langgraph/agents/demo_agents/deep_agent_core/prompts.py

@@ -0,0 +1,165 @@
+import os
+from typing import Literal
+
+from deepagents import create_deep_agent
+from tavily import TavilyClient
+
+# It's best practice to initialize the client once and reuse it.
+tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
+
+
+# Search tool to use to do research
+def internet_search(
+    query: str,
+    max_results: int = 5,
+    topic: Literal["general", "news", "finance"] = "general",
+    include_raw_content: bool = False,
+):
+    """Run a web search"""
+    search_docs = tavily_client.search(
+        query,
+        max_results=max_results,
+        include_raw_content=include_raw_content,
+        topic=topic,
+    )
+    return search_docs
+
+
+sub_research_prompt = """You are a dedicated researcher. Your job is to conduct research based on the users questions.
+
+Conduct thorough research and then reply to the user with a detailed answer to their question
+
+only your FINAL answer will be passed on to the user. They will have NO knowledge of anything except your final message, so your final report should be your final message!"""
+
+research_sub_agent = {
+    "name": "research-agent",
+    "description": "Used to research more in depth questions. Only give this researcher one topic at a time. Do not pass multiple sub questions to this researcher. Instead, you should break down a large topic into the necessary components, and then call multiple research agents in parallel, one for each sub question.",
+    "prompt": sub_research_prompt,
+    "tools": ["internet_search"],
+}
+
+sub_critique_prompt = """You are a dedicated editor. You are being tasked to critique a report.
+
+You can find the report at `final_report.md`.
+
+You can find the question/topic for this report at `question.txt`.
+
+The user may ask for specific areas to critique the report in. Respond to the user with a detailed critique of the report. Things that could be improved.
+
+You can use the search tool to search for information, if that will help you critique the report
+
+Do not write to the `final_report.md` yourself.
+
+Things to check:
+- Check that each section is appropriately named
+- Check that the report is written as you would find in an essay or a textbook - it should be text heavy, do not let it just be a list of bullet points!
+- Check that the report is comprehensive. If any paragraphs or sections are short, or missing important details, point it out.
+- Check that the article covers key areas of the industry, ensures overall understanding, and does not omit important parts.
+- Check that the article deeply analyzes causes, impacts, and trends, providing valuable insights
+- Check that the article closely follows the research topic and directly answers questions
+- Check that the article has a clear structure, fluent language, and is easy to understand.
+"""
+
+critique_sub_agent = {
+    "name": "critique-agent",
+    "description": "Used to critique the final report. Give this agent some infomration about how you want it to critique the report.",
+    "prompt": sub_critique_prompt,
+}
+
+
+# Prompt prefix to steer the agent to be an expert researcher
+research_instructions = """You are an expert researcher. Your job is to conduct thorough research, and then write a polished report.
+
+The first thing you should do is to write the original user question to `question.txt` so you have a record of it.
+
+Use the research-agent to conduct deep research. It will respond to your questions/topics with a detailed answer.
+
+When you think you enough information to write a final report, write it to `final_report.md`
+
+You can call the critique-agent to get a critique of the final report. After that (if needed) you can do more research and edit the `final_report.md`
+You can do this however many times you want until are you satisfied with the result.
+
+Only edit the file once at a time (if you call this tool in parallel, there may be conflicts).
+
+Here are instructions for writing the final report:
+
+<report_instructions>
+
+CRITICAL: Make sure the answer is written in the same language as the human messages! If you make a todo plan - you should note in the plan what language the report should be in so you dont forget!
+Note: the language the report should be in is the language the QUESTION is in, not the language/country that the question is ABOUT.
+
+Please create a detailed answer to the overall research brief that:
+1. Is well-organized with proper headings (# for title, ## for sections, ### for subsections)
+2. Includes specific facts and insights from the research
+3. References relevant sources using [Title](URL) format
+4. Provides a balanced, thorough analysis. Be as comprehensive as possible, and include all information that is relevant to the overall research question. People are using you for deep research and will expect detailed, comprehensive answers.
+5. Includes a "Sources" section at the end with all referenced links
+
+You can structure your report in a number of different ways. Here are some examples:
+
+To answer a question that asks you to compare two things, you might structure your report like this:
+1/ intro
+2/ overview of topic A
+3/ overview of topic B
+4/ comparison between A and B
+5/ conclusion
+
+To answer a question that asks you to return a list of things, you might only need a single section which is the entire list.
+1/ list of things or table of things
+Or, you could choose to make each item in the list a separate section in the report. When asked for lists, you don't need an introduction or conclusion.
+1/ item 1
+2/ item 2
+3/ item 3
+
+To answer a question that asks you to summarize a topic, give a report, or give an overview, you might structure your report like this:
+1/ overview of topic
+2/ concept 1
+3/ concept 2
+4/ concept 3
+5/ conclusion
+
+If you think you can answer the question with a single section, you can do that too!
+1/ answer
+
+REMEMBER: Section is a VERY fluid and loose concept. You can structure your report however you think is best, including in ways that are not listed above!
+Make sure that your sections are cohesive, and make sense for the reader.
+
+For each section of the report, do the following:
+- Use simple, clear language
+- Use ## for section title (Markdown format) for each section of the report
+- Do NOT ever refer to yourself as the writer of the report. This should be a professional report without any self-referential language.
+- Do not say what you are doing in the report. Just write the report without any commentary from yourself.
+- Each section should be as long as necessary to deeply answer the question with the information you have gathered. It is expected that sections will be fairly long and verbose. You are writing a deep research report, and users will expect a thorough answer.
+- Use bullet points to list out information when appropriate, but by default, write in paragraph form.
+
+REMEMBER:
+The brief and research may be in English, but you need to translate this information to the right language when writing the final answer.
+Make sure the final answer report is in the SAME language as the human messages in the message history.
+
+Format the report in clear markdown with proper structure and include source references where appropriate.
+
+<Citation Rules>
+- Assign each unique URL a single citation number in your text
+- End with ### Sources that lists each source with corresponding numbers
+- IMPORTANT: Number sources sequentially without gaps (1,2,3,4...) in the final list regardless of which sources you choose
+- Each source should be a separate line item in a list, so that in markdown it is rendered as a list.
+- Example format:
+  [1] Source Title: URL
+  [2] Source Title: URL
+- Citations are extremely important. Make sure to include these, and pay a lot of attention to getting these right. Users will often use these citations to look into more information.
+</Citation Rules>
+</report_instructions>
+
+You have access to a few tools.
+
+## `internet_search`
+
+Use this to run an internet search for a given query. You can specify the number of results, the topic, and whether raw content should be included.
+"""
+
+# Create the agent
+agent = create_deep_agent(
+    [internet_search],
+    research_instructions,
+    subagents=[critique_sub_agent, research_sub_agent],
+).with_config({"recursion_limit": 1000})

template_langgraph/agents/demo_agents/deep_agent_core/research_agent.py

@@ -0,0 +1,25 @@
+from typing import Annotated, Literal, NotRequired
+
+from langgraph.prebuilt.chat_agent_executor import AgentState
+from typing_extensions import TypedDict
+
+
+class Todo(TypedDict):
+    """Todo to track."""
+
+    content: str
+    status: Literal["pending", "in_progress", "completed"]
+
+
+def file_reducer(l, r):
+    if l is None:
+        return r
+    elif r is None:
+        return l
+    else:
+        return {**l, **r}
+
+
+class DeepAgentState(AgentState):
+    todos: NotRequired[list[Todo]]
+    files: Annotated[NotRequired[dict[str, str]], file_reducer]

template_langgraph/agents/demo_agents/deep_agent_core/state.py

@@ -0,0 +1,68 @@
+from typing import Annotated, Any, NotRequired
+
+from deepagents.prompts import TASK_DESCRIPTION_PREFIX, TASK_DESCRIPTION_SUFFIX
+from deepagents.state import DeepAgentState
+from langchain.chat_models import init_chat_model
+from langchain_core.messages import ToolMessage
+from langchain_core.tools import BaseTool, InjectedToolCallId, tool
+from langgraph.prebuilt import InjectedState, create_react_agent
+from langgraph.types import Command
+from typing_extensions import TypedDict
+
+
+class SubAgent(TypedDict):
+    name: str
+    description: str
+    prompt: str
+    tools: NotRequired[list[str]]
+    # Optional per-subagent model configuration
+    model_settings: NotRequired[dict[str, Any]]
+
+
+def _create_task_tool(tools, instructions, subagents: list[SubAgent], model, state_schema):
+    agents = {"general-purpose": create_react_agent(model, prompt=instructions, tools=tools)}
+    tools_by_name = {}
+    for tool_ in tools:
+        if not isinstance(tool_, BaseTool):
+            tool_ = tool(tool_)
+        tools_by_name[tool_.name] = tool_
+    for _agent in subagents:
+        if "tools" in _agent:
+            _tools = [tools_by_name[t] for t in _agent["tools"]]
+        else:
+            _tools = tools
+        # Resolve per-subagent model if specified, else fallback to main model
+        if "model_settings" in _agent:
+            model_config = _agent["model_settings"]
+            # Always use get_default_model to ensure all settings are applied
+            sub_model = init_chat_model(**model_config)
+        else:
+            sub_model = model
+        agents[_agent["name"]] = create_react_agent(
+            sub_model, prompt=_agent["prompt"], tools=_tools, state_schema=state_schema
+        )
+
+    other_agents_string = [f"- {_agent['name']}: {_agent['description']}" for _agent in subagents]
+
+    @tool(description=TASK_DESCRIPTION_PREFIX.format(other_agents=other_agents_string) + TASK_DESCRIPTION_SUFFIX)
+    async def task(
+        description: str,
+        subagent_type: str,
+        state: Annotated[DeepAgentState, InjectedState],
+        tool_call_id: Annotated[str, InjectedToolCallId],
+    ):
+        if subagent_type not in agents:
+            return (
+                f"Error: invoked agent of type {subagent_type}, the only allowed types are {[f'`{k}`' for k in agents]}"
+            )
+        sub_agent = agents[subagent_type]
+        state["messages"] = [{"role": "user", "content": description}]
+        result = await sub_agent.ainvoke(state)
+        return Command(
+            update={
+                "files": result.get("files", {}),
+                "messages": [ToolMessage(result["messages"][-1].content, tool_call_id=tool_call_id)],
+            }
+        )
+
+    return task