deepagents 0.0.12rc2__py3-none-any.whl → 0.0.12rc3__py3-none-any.whl

deepagents/graph.py

@@ -9,6 +9,7 @@ from langchain.agents.middleware.summarization import SummarizationMiddleware
 from langchain.agents.middleware.types import AgentMiddleware
 from langchain.agents.structured_output import ResponseFormat
 from langchain_anthropic import ChatAnthropic
+from langchain_anthropic.middleware import AnthropicPromptCachingMiddleware
 from langchain_core.language_models import BaseChatModel
 from langchain_core.tools import BaseTool
 from langgraph.cache.base import BaseCache
@@ -29,8 +30,8 @@ def get_default_model() -> ChatAnthropic:
         ChatAnthropic instance configured with Claude Sonnet 4.
     """
     return ChatAnthropic(
-        model_name="claude-sonnet-4-20250514",
-        max_tokens=64000,
+        model_name="claude-sonnet-4-5-20250929",
+        max_tokens=20000,
     )
 
 
@@ -107,18 +108,20 @@ def create_deep_agent(
                 ),
                 SummarizationMiddleware(
                     model=model,
-                    max_tokens_before_summary=120000,
-                    messages_to_keep=20,
+                    max_tokens_before_summary=170000,
+                    messages_to_keep=6,
                 ),
+                AnthropicPromptCachingMiddleware(unsupported_model_behavior="ignore"),
             ],
             default_interrupt_on=interrupt_on,
             general_purpose_agent=True,
         ),
         SummarizationMiddleware(
             model=model,
-            max_tokens_before_summary=120000,
-            messages_to_keep=20,
+            max_tokens_before_summary=170000,
+            messages_to_keep=6,
         ),
+        AnthropicPromptCachingMiddleware(unsupported_model_behavior="ignore"),
     ]
     if interrupt_on is not None:
         deepagent_middleware.append(HumanInTheLoopMiddleware(interrupt_on=interrupt_on))
@@ -137,4 +140,4 @@ def create_deep_agent(
         debug=debug,
         name=name,
         cache=cache,
-    )
+    ).with_config({"recursion_limit": 1000})

deepagents/middleware/filesystem.py

@@ -17,11 +17,12 @@ from langchain.agents.middleware.types import (
     ModelRequest,
     ModelResponse,
 )
-from langchain.tools.tool_node import InjectedState, ToolCallRequest
+from langchain.tools import ToolRuntime
+from langchain.tools.tool_node import ToolCallRequest
 from langchain_core.messages import ToolMessage
-from langchain_core.tools import BaseTool, InjectedToolCallId, tool
+from langchain_core.tools import BaseTool, tool
 from langgraph.config import get_config
-from langgraph.runtime import Runtime, get_runtime
+from langgraph.runtime import Runtime
 from langgraph.store.base import BaseStore, Item
 from langgraph.types import Command
 from typing_extensions import TypedDict
@@ -569,10 +570,9 @@ def _ls_tool_generator(custom_description: str | None = None, *, long_term_memor
     if long_term_memory:
 
         @tool(description=tool_description)
-        def ls(state: Annotated[FilesystemState, InjectedState], path: str | None = None) -> list[str]:
-            files = _get_filenames_from_state(state)
+        def ls(runtime: ToolRuntime[None, FilesystemState], path: str | None = None) -> list[str]:
+            files = _get_filenames_from_state(runtime.state)
             # Add filenames from longterm memory
-            runtime = get_runtime()
             store = _get_store(runtime)
             namespace = _get_namespace()
             longterm_files = store.search(namespace)
@@ -582,8 +582,8 @@ def _ls_tool_generator(custom_description: str | None = None, *, long_term_memor
     else:
 
         @tool(description=tool_description)
-        def ls(state: Annotated[FilesystemState, InjectedState], path: str | None = None) -> list[str]:
-            files = _get_filenames_from_state(state)
+        def ls(runtime: ToolRuntime[None, FilesystemState], path: str | None = None) -> list[str]:
+            files = _get_filenames_from_state(runtime.state)
             return _filter_files_by_path(files, path)
 
     return ls
@@ -633,14 +633,13 @@ def _read_file_tool_generator(custom_description: str | None = None, *, long_ter
         @tool(description=tool_description)
         def read_file(
             file_path: str,
-            state: Annotated[FilesystemState, InjectedState],
+            runtime: ToolRuntime[None, FilesystemState],
             offset: int = DEFAULT_READ_OFFSET,
             limit: int = DEFAULT_READ_LIMIT,
         ) -> str:
             file_path = _validate_path(file_path)
             if _has_memories_prefix(file_path):
                 stripped_file_path = _strip_memories_prefix(file_path)
-                runtime = get_runtime()
                 store = _get_store(runtime)
                 namespace = _get_namespace()
                 item: Item | None = store.get(namespace, stripped_file_path)
@@ -649,7 +648,7 @@ def _read_file_tool_generator(custom_description: str | None = None, *, long_ter
                 file_data = _convert_store_item_to_file_data(item)
             else:
                 try:
-                    file_data = _get_file_data_from_state(state, file_path)
+                    file_data = _get_file_data_from_state(runtime.state, file_path)
                 except ValueError as e:
                     return str(e)
             return _read_file_data_content(file_data, offset, limit)
@@ -659,13 +658,13 @@ def _read_file_tool_generator(custom_description: str | None = None, *, long_ter
         @tool(description=tool_description)
         def read_file(
             file_path: str,
-            state: Annotated[FilesystemState, InjectedState],
+            runtime: ToolRuntime[None, FilesystemState],
             offset: int = DEFAULT_READ_OFFSET,
             limit: int = DEFAULT_READ_LIMIT,
         ) -> str:
             file_path = _validate_path(file_path)
             try:
-                file_data = _get_file_data_from_state(state, file_path)
+                file_data = _get_file_data_from_state(runtime.state, file_path)
             except ValueError as e:
                 return str(e)
             return _read_file_data_content(file_data, offset, limit)
@@ -719,13 +718,11 @@ def _write_file_tool_generator(custom_description: str | None = None, *, long_te
         def write_file(
             file_path: str,
             content: str,
-            state: Annotated[FilesystemState, InjectedState],
-            tool_call_id: Annotated[str, InjectedToolCallId],
+            runtime: ToolRuntime[None, FilesystemState],
         ) -> Command | str:
             file_path = _validate_path(file_path)
             if _has_memories_prefix(file_path):
                 stripped_file_path = _strip_memories_prefix(file_path)
-                runtime = get_runtime()
                 store = _get_store(runtime)
                 namespace = _get_namespace()
                 if store.get(namespace, stripped_file_path) is not None:
@@ -733,7 +730,7 @@ def _write_file_tool_generator(custom_description: str | None = None, *, long_te
                 new_file_data = _create_file_data(content)
                 store.put(namespace, stripped_file_path, _convert_file_data_to_store_item(new_file_data))
                 return f"Updated longterm memories file {file_path}"
-            return _write_file_to_state(state, tool_call_id, file_path, content)
+            return _write_file_to_state(runtime.state, runtime.tool_call_id, file_path, content)
 
     else:
 
@@ -741,11 +738,10 @@ def _write_file_tool_generator(custom_description: str | None = None, *, long_te
         def write_file(
             file_path: str,
             content: str,
-            state: Annotated[FilesystemState, InjectedState],
-            tool_call_id: Annotated[str, InjectedToolCallId],
+            runtime: ToolRuntime[None, FilesystemState],
         ) -> Command | str:
             file_path = _validate_path(file_path)
-            return _write_file_to_state(state, tool_call_id, file_path, content)
+            return _write_file_to_state(runtime.state, runtime.tool_call_id, file_path, content)
 
     return write_file
 
@@ -803,8 +799,7 @@ def _edit_file_tool_generator(custom_description: str | None = None, *, long_ter
             file_path: str,
             old_string: str,
             new_string: str,
-            state: Annotated[FilesystemState, InjectedState],
-            tool_call_id: Annotated[str, InjectedToolCallId],
+            runtime: ToolRuntime[None, FilesystemState],
             *,
             replace_all: bool = False,
         ) -> Command | str:
@@ -814,7 +809,6 @@ def _edit_file_tool_generator(custom_description: str | None = None, *, long_ter
             # Retrieve file data from appropriate storage
             if is_longterm_memory:
                 stripped_file_path = _strip_memories_prefix(file_path)
-                runtime = get_runtime()
                 store = _get_store(runtime)
                 namespace = _get_namespace()
                 item: Item | None = store.get(namespace, stripped_file_path)
@@ -823,7 +817,7 @@ def _edit_file_tool_generator(custom_description: str | None = None, *, long_ter
                 file_data = _convert_store_item_to_file_data(item)
             else:
                 try:
-                    file_data = _get_file_data_from_state(state, file_path)
+                    file_data = _get_file_data_from_state(runtime.state, file_path)
                 except ValueError as e:
                     return str(e)
 
@@ -843,7 +837,7 @@ def _edit_file_tool_generator(custom_description: str | None = None, *, long_ter
             return Command(
                 update={
                     "files": {file_path: new_file_data},
-                    "messages": [ToolMessage(full_msg, tool_call_id=tool_call_id)],
+                    "messages": [ToolMessage(full_msg, tool_call_id=runtime.tool_call_id)],
                 }
             )
     else:
@@ -853,8 +847,7 @@ def _edit_file_tool_generator(custom_description: str | None = None, *, long_ter
             file_path: str,
             old_string: str,
             new_string: str,
-            state: Annotated[FilesystemState, InjectedState],
-            tool_call_id: Annotated[str, InjectedToolCallId],
+            runtime: ToolRuntime[None, FilesystemState],
             *,
             replace_all: bool = False,
         ) -> Command | str:
@@ -862,7 +855,7 @@ def _edit_file_tool_generator(custom_description: str | None = None, *, long_ter
 
             # Retrieve file data from state
             try:
-                file_data = _get_file_data_from_state(state, file_path)
+                file_data = _get_file_data_from_state(runtime.state, file_path)
             except ValueError as e:
                 return str(e)
 
@@ -877,7 +870,7 @@ def _edit_file_tool_generator(custom_description: str | None = None, *, long_ter
             return Command(
                 update={
                     "files": {file_path: new_file_data},
-                    "messages": [ToolMessage(full_msg, tool_call_id=tool_call_id)],
+                    "messages": [ToolMessage(full_msg, tool_call_id=runtime.tool_call_id)],
                 }
             )
 
@@ -958,7 +951,7 @@ class FilesystemMiddleware(AgentMiddleware):
         long_term_memory: bool = False,
         system_prompt: str | None = None,
         custom_tool_descriptions: dict[str, str] | None = None,
-        tool_token_limit_before_evict: int | None = 50000,
+        tool_token_limit_before_evict: int | None = 20000,
     ) -> None:
         """Initialize the filesystem middleware.
 

deepagents/middleware/subagents.py

@@ -1,12 +1,12 @@
 """Middleware for providing subagents to an agent via a `task` tool."""
 
 from collections.abc import Awaitable, Callable, Sequence
-from typing import Annotated, Any, NotRequired, TypedDict, cast
+from typing import Any, NotRequired, TypedDict, cast
 
 from langchain.agents import create_agent
 from langchain.agents.middleware import HumanInTheLoopMiddleware, InterruptOnConfig
 from langchain.agents.middleware.types import AgentMiddleware, ModelRequest, ModelResponse
-from langchain.tools import BaseTool, InjectedState, InjectedToolCallId
+from langchain.tools import BaseTool, ToolRuntime
 from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import HumanMessage, ToolMessage
 from langchain_core.runnables import Runnable
@@ -327,14 +327,14 @@ def _create_task_tool(
             }
         )
 
-    def _validate_and_prepare_state(subagent_type: str, description: str, state: dict) -> tuple[Runnable, dict]:
+    def _validate_and_prepare_state(subagent_type: str, description: str, runtime: ToolRuntime) -> tuple[Runnable, dict]:
         """Validate subagent type and prepare state for invocation."""
         if subagent_type not in subagent_graphs:
             msg = f"Error: invoked agent of type {subagent_type}, the only allowed types are {[f'`{k}`' for k in subagent_graphs]}"
             raise ValueError(msg)
         subagent = subagent_graphs[subagent_type]
         # Create a new state dict to avoid mutating the original
-        subagent_state = {k: v for k, v in state.items() if k not in _EXCLUDED_STATE_KEYS}
+        subagent_state = {k: v for k, v in runtime.state.items() if k not in _EXCLUDED_STATE_KEYS}
         subagent_state["messages"] = [HumanMessage(content=description)]
         return subagent, subagent_state
 
@@ -348,22 +348,20 @@ def _create_task_tool(
     def task(
         description: str,
         subagent_type: str,
-        state: Annotated[dict, InjectedState],
-        tool_call_id: Annotated[str, InjectedToolCallId],
+        runtime: ToolRuntime,
     ) -> str | Command:
-        subagent, subagent_state = _validate_and_prepare_state(subagent_type, description, state)
+        subagent, subagent_state = _validate_and_prepare_state(subagent_type, description, runtime)
         result = subagent.invoke(subagent_state)
-        return _return_command_with_state_update(result, tool_call_id)
+        return _return_command_with_state_update(result, runtime.tool_call_id)
 
     async def atask(
         description: str,
         subagent_type: str,
-        state: Annotated[dict, InjectedState],
-        tool_call_id: Annotated[str, InjectedToolCallId],
+        runtime: ToolRuntime,
     ) -> str | Command:
-        subagent, subagent_state = _validate_and_prepare_state(subagent_type, description, state)
+        subagent, subagent_state = _validate_and_prepare_state(subagent_type, description, runtime)
         result = await subagent.ainvoke(subagent_state)
-        return _return_command_with_state_update(result, tool_call_id)
+        return _return_command_with_state_update(result, runtime.tool_call_id)
 
     return StructuredTool.from_function(
         name="task",

deepagents-0.0.12rc3.dist-info/METADATA

@@ -0,0 +1,533 @@
+Metadata-Version: 2.4
+Name: deepagents
+Version: 0.0.12rc3
+Summary: General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph.
+License: MIT
+Requires-Python: <4.0,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langgraph==1.0.0a4
+Requires-Dist: langchain-anthropic==1.0.0a5
+Requires-Dist: langchain==1.0.0rc2
+Requires-Dist: langgraph-prebuilt==0.7.0a2
+Requires-Dist: langchain-core==1.0.0rc3
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: langchain-openai; extra == "dev"
+Dynamic: license-file
+
+# 🧠🤖Deep Agents
+
+Using an LLM to call tools in a loop is the simplest form of an agent. 
+This architecture, however, can yield agents that are “shallow” and fail to plan and act over longer, more complex tasks. 
+
+Applications like “Deep Research”, "Manus", and “Claude Code” have gotten around this limitation by implementing a combination of four things:
+a **planning tool**, **sub agents**, access to a **file system**, and a **detailed prompt**.
+
+<img src="deep_agents.png" alt="deep agent" width="600"/>
+
+`deepagents` is a Python package that implements these in a general purpose way so that you can easily create a Deep Agent for your application.
+
+**Acknowledgements: This project was primarily inspired by Claude Code, and initially was largely an attempt to see what made Claude Code general purpose, and make it even more so.**
+
+## Installation
+
+```bash
+# pip
+pip install deepagents
+
+# uv
+uv add deepagents
+
+# poetry
+poetry add deepagents
+```
+
+## Usage
+
+(To run the example below, you will need to `pip install tavily-python`).
+
+Make sure to set `TAVILY_API_KEY` in your environment. You can generate one [here](https://www.tavily.com/).
+
+```python
+import os
+from typing import Literal
+from tavily import TavilyClient
+from deepagents import create_deep_agent
+
+tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
+
+# Web search tool
+def internet_search(
+    query: str,
+    max_results: int = 5,
+    topic: Literal["general", "news", "finance"] = "general",
+    include_raw_content: bool = False,
+):
+    """Run a web search"""
+    return tavily_client.search(
+        query,
+        max_results=max_results,
+        include_raw_content=include_raw_content,
+        topic=topic,
+    )
+
+
+# System prompt 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.
+
+You have access to an internet search tool as your primary means of gathering information.
+
+## `internet_search`
+
+Use this to run an internet search for a given query. You can specify the max number of results to return, the topic, and whether raw content should be included.
+"""
+
+# Create the deep agent
+agent = create_deep_agent(
+    tools=[internet_search],
+    system_prompt=research_instructions,
+)
+
+# Invoke the agent
+result = agent.invoke({"messages": [{"role": "user", "content": "What is langgraph?"}]})
+```
+
+See [examples/research/research_agent.py](examples/research/research_agent.py) for a more complex example.
+
+The agent created with `create_deep_agent` is just a LangGraph graph - so you can interact with it (streaming, human-in-the-loop, memory, studio)
+in the same way you would any LangGraph agent.
+
+## Core Capabilities
+**Planning & Task Decomposition**
+
+ Deep Agents include a built-in `write_todos` tool that enables agents to break down complex tasks into discrete steps, track progress, and adapt plans as new information emerges.
+
+**Context Management**
+
+ File system tools (`ls`, `read_file`, `write_file`, `edit_file`) allow agents to offload large context to memory, preventing context window overflow and enabling work with variable-length tool results.
+
+**Subagent Spawning**
+
+ A built-in `task` tool enables agents to spawn specialized subagents for context isolation. This keeps the main agent’s context clean while still going deep on specific subtasks.
+
+**Long-term Memory**
+
+ Extend agents with persistent memory across threads using LangGraph’s Store. Agents can save and retrieve information from previous conversations.
+
+## Customizing Deep Agents
+
+There are several parameters you can pass to `create_deep_agent` to create your own custom deep agent.
+
+### `model`
+
+By default, `deepagents` uses `"claude-sonnet-4-5-20250929"`. You can customize this by passing any [LangChain model object](https://python.langchain.com/docs/integrations/chat/).
+
+```python
+from langchain.chat_models import init_chat_model
+from deepagents import create_deep_agent
+
+model = init_chat_model(
+    model="openai:gpt-5",  
+)
+agent = create_deep_agent(
+    model=model,
+)
+```
+
+### `system_prompt`
+Deep Agents come with a built-in system prompt. This is relatively detailed prompt that is heavily based on and inspired by [attempts](https://github.com/kn1026/cc/blob/main/claudecode.md) to [replicate](https://github.com/asgeirtj/system_prompts_leaks/blob/main/Anthropic/claude-code.md)
+Claude Code's system prompt. It was made more general purpose than Claude Code's system prompt. The default prompt contains detailed instructions for how to use the built-in planning tool, file system tools, and sub agents.
+
+Each deep agent tailored to a use case should include a custom system prompt specific to that use case as well. The importance of prompting for creating a successful deep agent cannot be overstated.
+
+```python
+from deepagents import create_deep_agent
+
+research_instructions = """You are an expert researcher. Your job is to conduct thorough research, and then write a polished report.
+"""
+
+agent = create_deep_agent(
+    system_prompt=research_instructions,
+)
+```
+
+### `tools`
+
+Just like with tool-calling agents, you can provide a deep agent with a set of tools that it has access to.
+
+```python
+import os
+from typing import Literal
+from tavily import TavilyClient
+from deepagents import create_deep_agent
+
+tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
+
+def internet_search(
+    query: str,
+    max_results: int = 5,
+    topic: Literal["general", "news", "finance"] = "general",
+    include_raw_content: bool = False,
+):
+    """Run a web search"""
+    return tavily_client.search(
+        query,
+        max_results=max_results,
+        include_raw_content=include_raw_content,
+        topic=topic,
+    )
+
+agent = create_deep_agent(
+    tools=[internet_search]
+)
+```
+
+### `middleware`
+`create_deep_agent` is implemented with middleware that can be customized. You can provide additional middleware to extend functionality, add tools, or implement custom hooks. 
+
+```python
+from langchain_core.tools import tool
+from deepagents import create_deep_agent
+from langchain.agents.middleware import AgentMiddleware
+
+@tool
+def get_weather(city: str) -> str:
+    """Get the weather in a city."""
+    return f"The weather in {city} is sunny."
+
+@tool
+def get_temperature(city: str) -> str:
+    """Get the temperature in a city."""
+    return f"The temperature in {city} is 70 degrees Fahrenheit."
+
+class WeatherMiddleware(AgentMiddleware):
+  tools = [get_weather, get_temperature]
+
+agent = create_deep_agent(
+    model="anthropic:claude-sonnet-4-20250514",
+    middleware=[WeatherMiddleware()]
+)
+```
+
+### `subagents`
+
+A main feature of Deep Agents is their ability to spawn subagents. You can specify custom subagents that your agent can hand off work to in the subagents parameter. Sub agents are useful for context quarantine (to help not pollute the overall context of the main agent) as well as custom instructions.
+
+`subagents` should be a list of dictionaries, where each dictionary follow this schema:
+
+```python
+class SubAgent(TypedDict):
+    name: str
+    description: str
+    prompt: str
+    tools: Sequence[BaseTool | Callable | dict[str, Any]]
+    model: NotRequired[str | BaseChatModel]
+    middleware: NotRequired[list[AgentMiddleware]]
+    interrupt_on: NotRequired[dict[str, bool | InterruptOnConfig]]
+
+class CompiledSubAgent(TypedDict):
+    name: str
+    description: str
+    runnable: Runnable
+```
+
+**SubAgent fields:**
+- **name**: This is the name of the subagent, and how the main agent will call the subagent
+- **description**: This is the description of the subagent that is shown to the main agent
+- **prompt**: This is the prompt used for the subagent
+- **tools**: This is the list of tools that the subagent has access to.
+- **model**: Optional model name or model instance.
+- **middleware** Additional middleware to attach to the subagent. See [here](https://docs.langchain.com/oss/python/langchain/middleware) for an introduction into middleware and how it works with create_agent.
+- **interrupt_on** A custom interrupt config that specifies human-in-the-loop interactions for your tools.
+
+**CompiledSubAgent fields:**
+- **name**: This is the name of the subagent, and how the main agent will call the subagent
+- **description**: This is the description of the subagent that is shown to the main agent  
+- **runnable**: A pre-built LangGraph graph/agent that will be used as the subagent
+
+#### Using SubAgent
+
+```python
+import os
+from typing import Literal
+from tavily import TavilyClient
+from deepagents import create_deep_agent
+
+tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
+
+def internet_search(
+    query: str,
+    max_results: int = 5,
+    topic: Literal["general", "news", "finance"] = "general",
+    include_raw_content: bool = False,
+):
+    """Run a web search"""
+    return tavily_client.search(
+        query,
+        max_results=max_results,
+        include_raw_content=include_raw_content,
+        topic=topic,
+    )
+
+research_subagent = {
+    "name": "research-agent",
+    "description": "Used to research more in depth questions",
+    "system_prompt": "You are a great researcher",
+    "tools": [internet_search],
+    "model": "openai:gpt-4o",  # Optional override, defaults to main agent model
+}
+subagents = [research_subagent]
+
+agent = create_deep_agent(
+    model="anthropic:claude-sonnet-4-20250514",
+    subagents=subagents
+)
+```
+
+#### Using CustomSubAgent
+
+For more complex use cases, you can provide your own pre-built LangGraph graph as a subagent:
+
+```python
+# Create a custom agent graph
+custom_graph = create_agent(
+    model=your_model,
+    tools=specialized_tools,
+    prompt="You are a specialized agent for data analysis..."
+)
+
+# Use it as a custom subagent
+custom_subagent = CompiledSubAgent(
+    name="data-analyzer",
+    description="Specialized agent for complex data analysis tasks",
+    runnable=custom_graph
+)
+
+subagents = [custom_subagent]
+
+agent = create_deep_agent(
+    model="anthropic:claude-sonnet-4-20250514",
+    tools=[internet_search],
+    system_prompt=research_instructions,
+    subagents=subagents
+)
+```
+
+### `use_longterm_memory`
+Deep agents come with a local filesystem to offload memory to. This filesystem is stored in state, and is therefore transient to a single thread.
+
+You can extend deep agents with long-term memory by providing a Store and setting use_longterm_memory=True.
+
+```python
+from deepagents import create_deep_agent
+from langgraph.store.memory import InMemoryStore
+
+store = InMemoryStore()  # Or any other Store object
+agent = create_deep_agent(
+    store=store,
+    use_longterm_memory=True
+)
+```
+
+### `interrupt_on`
+A common reality for agents is that some tool operations may be sensitive and require human approval before execution. Deep Agents supports human-in-the-loop workflows through LangGraph’s interrupt capabilities. You can configure which tools require approval using a checkpointer.
+
+These tool configs are passed to our prebuilt [HITL middleware](https://docs.langchain.com/oss/python/langchain/middleware#human-in-the-loop) so that the agent pauses execution and waits for feedback from the user before executing configured tools.
+
+```python
+from langchain_core.tools import tool
+from deepagents import create_deep_agent
+
+@tool
+def get_weather(city: str) -> str:
+    """Get the weather in a city."""
+    return f"The weather in {city} is sunny."
+
+agent = create_deep_agent(
+    model="anthropic:claude-sonnet-4-20250514",
+    tools=[get_weather],
+    interrupt_on={
+        "get_weather": {
+            "allowed_decisions": ["approve", "edit", "reject"]
+        },
+    }
+)
+
+```
+
+## Deep Agents Middleware
+
+Deep Agents are built with a modular middleware architecture. As a reminder, Deep Agents have access to:
+- A planning tool
+- A filesystem for storing context and long-term memories
+- The ability to spawn subagents
+
+Each of these features is implemented as separate middleware. When you create a deep agent with `create_deep_agent`, we automatically attach **PlanningMiddleware**, **FilesystemMiddleware** and **SubAgentMiddleware** to your agent.
+
+Middleware is a composable concept, and you can choose to add as many or as few middleware to an agent depending on your use case. That means that you can also use any of the aforementioned middleware independently!
+
+### TodoListMiddleware
+
+Planning is integral to solving complex problems. If you’ve used claude code recently, you’ll notice how it writes out a To-Do list before tackling complex, multi-part tasks. You’ll also notice how it can adapt and update this To-Do list on the fly as more information comes in.
+
+**TodoListMiddleware** provides your agent with a tool specifically for updating this To-Do list. Before, and while it executes a multi-part task, the agent is prompted to use the write_todos tool to keep track of what its doing, and what still needs to be done.
+
+```python
+from langchain.agents import create_agent
+from langchain.agents.middleware import TodoListMiddleware
+
+# TodoListMiddleware is included by default in create_deep_agent
+# You can customize it if building a custom agent
+agent = create_agent(
+    model="anthropic:claude-sonnet-4-20250514",
+    # Custom planning instructions can be added via middleware
+    middleware=[
+        TodoListMiddleware(
+            system_prompt="Use the write_todos tool to..."  # Optional: Custom addition to the system prompt
+        ),
+    ],
+)
+```
+
+### FilesystemMiddleware
+
+Context engineering is one of the main challenges in building effective agents. This can be particularly hard when using tools that can return variable length results (ex. web_search, rag), as long ToolResults can quickly fill up your context window.
+**FilesystemMiddleware** provides four tools to your agent to interact with both short-term and long-term memory.
+- **ls**: List the files in your filesystem
+- **read_file**: Read an entire file, or a certain number of lines from a file
+- **write_file**: Write a new file to your filesystem
+- **edit_file**: Edit an existing file in your filesystem
+
+```python
+from langchain.agents import create_agent
+from deepagents.middleware.filesystem import FilesystemMiddleware
+
+# FilesystemMiddleware is included by default in create_deep_agent
+# You can customize it if building a custom agent
+agent = create_agent(
+    model="anthropic:claude-sonnet-4-20250514",
+    middleware=[
+        FilesystemMiddleware(
+            long_term_memory=False,  # Enables access to long-term memory, defaults to False. You must attach a store to use long-term memory.
+            system_prompt="Write to the filesystem when...",  # Optional custom addition to the system prompt
+            custom_tool_descriptions={
+                "ls": "Use the ls tool when...",
+                "read_file": "Use the read_file tool to..."
+            }  # Optional: Custom descriptions for filesystem tools
+        ),
+    ],
+)
+```
+
+### SubAgentMiddleware
+
+Handing off tasks to subagents is a great way to isolate context, keeping the context window of the main (supervisor) agent clean while still going deep on a task. The subagents middleware allows you supply subagents through a task tool.
+
+A subagent is defined with a name, description, system prompt, and tools. You can also provide a subagent with a custom model, or with additional middleware. This can be particularly useful when you want to give the subagent an additional state key to share with the main agent.
+
+```python
+from langchain_core.tools import tool
+from langchain.agents import create_agent
+from deepagents.middleware.subagents import SubAgentMiddleware
+
+
+@tool
+def get_weather(city: str) -> str:
+    """Get the weather in a city."""
+    return f"The weather in {city} is sunny."
+
+agent = create_agent(
+    model="claude-sonnet-4-20250514",
+    middleware=[
+        SubAgentMiddleware(
+            default_model="claude-sonnet-4-20250514",
+            default_tools=[],
+            subagents=[
+                {
+                    "name": "weather",
+                    "description": "This subagent can get weather in cities.",
+                    "system_prompt": "Use the get_weather tool to get the weather in a city.",
+                    "tools": [get_weather],
+                    "model": "gpt-4.1",
+                    "middleware": [],
+                }
+            ],
+        )
+    ],
+)
+```
+
+For more complex use cases, you can also provide your own pre-built LangGraph graph as a subagent.
+
+```python
+# Create a custom LangGraph graph
+def create_weather_graph():
+    workflow = StateGraph(...)
+    # Build your custom graph
+    return workflow.compile()
+
+weather_graph = create_weather_graph()
+
+# Wrap it in a CompiledSubAgent
+weather_subagent = CompiledSubAgent(
+    name="weather",
+    description="This subagent can get weather in cities.",
+    runnable=weather_graph
+)
+
+agent = create_agent(
+    model="anthropic:claude-sonnet-4-20250514",
+    middleware=[
+        SubAgentMiddleware(
+            default_model="claude-sonnet-4-20250514",
+            default_tools=[],
+            subagents=[weather_subagent],
+        )
+    ],
+)
+```
+
+## Sync vs Async
+
+Prior versions of deepagents separated sync and async agent factories. 
+
+`async_create_deep_agent` has been folded in to `create_deep_agent`.
+
+**You should use `create_deep_agent` as the factory for both sync and async agents**
+
+
+## MCP
+
+The `deepagents` library can be ran with MCP tools. This can be achieved by using the [Langchain MCP Adapter library](https://github.com/langchain-ai/langchain-mcp-adapters).
+
+**NOTE:** You will want to use `from deepagents import async_create_deep_agent` to use the async version of `deepagents`, since MCP tools are async
+
+(To run the example below, will need to `pip install langchain-mcp-adapters`)
+
+```python
+import asyncio
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from deepagents import create_deep_agent
+
+async def main():
+    # Collect MCP tools
+    mcp_client = MultiServerMCPClient(...)
+    mcp_tools = await mcp_client.get_tools()
+
+    # Create agent
+    agent = create_deep_agent(tools=mcp_tools, ....)
+
+    # Stream the agent
+    async for chunk in agent.astream(
+        {"messages": [{"role": "user", "content": "what is langgraph?"}]},
+        stream_mode="values"
+    ):
+        if "messages" in chunk:
+            chunk["messages"][-1].pretty_print()
+
+asyncio.run(main())
+```

deepagents-0.0.12rc3.dist-info/RECORD

@@ -0,0 +1,10 @@
+deepagents/__init__.py,sha256=9BVNn4lfF5N8l2KY8Ttxi82zO609I-fGqoSIF7DAxiU,342
+deepagents/graph.py,sha256=z2Vpdl_6WpWIJf6qibE87mHGinXpJA-bvm8IYjTOURk,5854
+deepagents/middleware/__init__.py,sha256=J7372TNGR27OU4C3uuQMryHHpXOBjFV_4aEZ_AoQ6n0,284
+deepagents/middleware/filesystem.py,sha256=mBx0845irJf7Lf558XCBf_ShqJT7YGepu2NmvjIZmeY,43739
+deepagents/middleware/subagents.py,sha256=pBJwBuOw6Y7L94hwOClVQ7msnEnom7U9qQH_xy9LoTY,23343
+deepagents-0.0.12rc3.dist-info/licenses/LICENSE,sha256=c__BaxUCK69leo2yEKynf8lWndu8iwYwge1CbyqAe-E,1071
+deepagents-0.0.12rc3.dist-info/METADATA,sha256=zPnVQ7lUHrkXqws4v_smGP66fRtQkPhDQQ1p5JSzrgQ,19161
+deepagents-0.0.12rc3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+deepagents-0.0.12rc3.dist-info/top_level.txt,sha256=drAzchOzPNePwpb3_pbPuvLuayXkN7SNqeIKMBWJoAo,11
+deepagents-0.0.12rc3.dist-info/RECORD,,

deepagents-0.0.12rc2.dist-info/METADATA

@@ -1,455 +0,0 @@
-Metadata-Version: 2.4
-Name: deepagents
-Version: 0.0.12rc2
-Summary: General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph.
-License: MIT
-Requires-Python: <4.0,>=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: langgraph>=1.0.0a4
-Requires-Dist: langchain-anthropic>=1.0.0a4
-Requires-Dist: langchain>=1.0.0a15
-Requires-Dist: langgraph-prebuilt>=0.7.0a2
-Requires-Dist: langchain-core>=1.0.0a6
-Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: build; extra == "dev"
-Requires-Dist: twine; extra == "dev"
-Requires-Dist: langchain-openai; extra == "dev"
-Dynamic: license-file
-
-# 🧠🤖Deep Agents
-
-Using an LLM to call tools in a loop is the simplest form of an agent. 
-This architecture, however, can yield agents that are “shallow” and fail to plan and act over longer, more complex tasks. 
-Applications like “Deep Research”, "Manus", and “Claude Code” have gotten around this limitation by implementing a combination of four things:
-a **planning tool**, **sub agents**, access to a **file system**, and a **detailed prompt**.
-
-<img src="deep_agents.png" alt="deep agent" width="600"/>
-
-`deepagents` is a Python package that implements these in a general purpose way so that you can easily create a Deep Agent for your application.
-
-**Acknowledgements: This project was primarily inspired by Claude Code, and initially was largely an attempt to see what made Claude Code general purpose, and make it even more so.**
-
-## Installation
-
-```bash
-pip install deepagents
-```
-
-## Usage
-
-(To run the example below, will need to `pip install tavily-python`)
-
-```python
-import os
-from typing import Literal
-from tavily import TavilyClient
-from deepagents import create_deep_agent
-
-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"""
-    return tavily_client.search(
-        query,
-        max_results=max_results,
-        include_raw_content=include_raw_content,
-        topic=topic,
-    )
-
-
-# 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.
-
-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(
-    tools=[internet_search],
-    system_prompt=research_instructions,
-)
-
-# Invoke the agent
-result = agent.invoke({"messages": [{"role": "user", "content": "what is langgraph?"}]})
-```
-
-See [examples/research/research_agent.py](examples/research/research_agent.py) for a more complex example.
-
-The agent created with `create_deep_agent` is just a LangGraph graph - so you can interact with it (streaming, human-in-the-loop, memory, studio)
-in the same way you would any LangGraph agent.
-
-## Creating a custom deep agent
-
-There are several parameters you can pass to `create_deep_agent` to create your own custom deep agent.
-
-### `tools` (Required)
-
-The first argument to `create_deep_agent` is `tools`.
-This should be a list of functions or LangChain `@tool` objects.
-The agent (and any subagents) will have access to these tools.
-
-### `instructions` (Required)
-
-The second argument to `create_deep_agent` is `instructions`.
-This will serve as part of the prompt of the deep agent.
-Note that our deep agent middleware appends further instructions to the deep agent regarding to-do list, filesystem, and subagent usage, so this is not the *entire* prompt the agent will see.
-
-### `subagents` (Optional)
-
-A keyword-only argument to `create_deep_agent` is `subagents`.
-This can be used to specify any custom subagents this deep agent will have access to.
-You can read more about why you would want to use subagents [here](#sub-agents)
-
-`subagents` should be a list of dictionaries, where each dictionary follow this schema:
-
-```python
-class SubAgent(TypedDict):
-    name: str
-    description: str
-    prompt: str
-    tools: NotRequired[list[str]]
-    model: NotRequired[Union[LanguageModelLike, dict[str, Any]]]
-    middleware: NotRequired[list[AgentMiddleware]]
-
-class CustomSubAgent(TypedDict):
-    name: str
-    description: str
-    graph: Runnable
-```
-
-**SubAgent fields:**
-- **name**: This is the name of the subagent, and how the main agent will call the subagent
-- **description**: This is the description of the subagent that is shown to the main agent
-- **prompt**: This is the prompt used for the subagent
-- **tools**: This is the list of tools that the subagent has access to. By default will have access to all tools passed in, as well as all built-in tools.
-- **model**: Optional model instance OR dictionary for per-subagent model configuration (inherits the main model when omitted).
-- **middleware** Additional middleware to attach to the subagent. See [here](https://docs.langchain.com/oss/python/langchain/middleware) for an introduction into middleware and how it works with create_agent.
-
-**CustomSubAgent fields:**
-- **name**: This is the name of the subagent, and how the main agent will call the subagent
-- **description**: This is the description of the subagent that is shown to the main agent  
-- **graph**: A pre-built LangGraph graph/agent that will be used as the subagent
-
-#### Using SubAgent
-
-```python
-research_subagent = {
-    "name": "research-agent",
-    "description": "Used to research more in depth questions",
-    "prompt": sub_research_prompt,
-    "tools": [internet_search]
-}
-subagents = [research_subagent]
-agent = create_deep_agent(
-    tools,
-    prompt,
-    subagents=subagents
-)
-```
-
-#### Using CustomSubAgent
-
-For more complex use cases, you can provide your own pre-built LangGraph graph as a subagent:
-
-```python
-from langchain.agents import create_agent
-
-# Create a custom agent graph
-custom_graph = create_agent(
-    model=your_model,
-    tools=specialized_tools,
-    prompt="You are a specialized agent for data analysis..."
-)
-
-# Use it as a custom subagent
-custom_subagent = {
-    "name": "data-analyzer",
-    "description": "Specialized agent for complex data analysis tasks",
-    "graph": custom_graph
-}
-
-subagents = [custom_subagent]
-agent = create_deep_agent(
-    tools,
-    prompt,
-    subagents=subagents
-)
-```
-
-### `model` (Optional)
-
-By default, `deepagents` uses `"claude-sonnet-4-20250514"`. You can customize this by passing any [LangChain model object](https://python.langchain.com/docs/integrations/chat/).
-
-#### Example: Using a Custom Model
-
-Here's how to use a custom model (like OpenAI's `gpt-oss` model via Ollama):
-
-(Requires `pip install langchain` and then `pip install langchain-ollama` for Ollama models)
-
-```python
-from deepagents import create_deep_agent
-
-# ... existing agent definitions ...
-
-model = init_chat_model(
-    model="ollama:gpt-oss:20b",  
-)
-agent = create_deep_agent(
-    tools=tools,
-    instructions=instructions,
-    model=model,
-    ...
-)
-```
-
-#### Example: Per-subagent model override (optional)
-
-Use a fast, deterministic model for a critique sub-agent, while keeping a different default model for the main agent and others:
-
-```python
-from deepagents import create_deep_agent
-
-critique_sub_agent = {
-    "name": "critique-agent",
-    "description": "Critique the final report",
-    "prompt": "You are a tough editor.",
-    "model_settings": {
-        "model": "claude-sonnet-4-202505142",
-        "temperature": 0,
-        "max_tokens": 8192
-    }
-}
-
-agent = create_deep_agent(
-    tools=[internet_search],
-    instructions="You are an expert researcher...",
-    model="claude-sonnet-4-20250514",  # default for main agent and other sub-agents
-    subagents=[critique_sub_agent],
-)
-```
-
-
-### `middleware` (Optional)
-Both the main agent and sub-agents can take additional custom AgentMiddleware. Middleware is the best supported approach for extending the state_schema, adding additional tools, and adding pre / post model hooks. See this [doc](https://docs.langchain.com/oss/python/langchain/middleware) to learn more about Middleware and how you can use it!
-
-### `interrupt_on` (Optional)
-Tool configs are used to specify how to handle Human In The Loop interactions on certain tools that require additional human oversight. 
-
-These tool configs are passed to our prebuilt [HITL middleware](https://docs.langchain.com/oss/python/langchain/middleware#human-in-the-loop) so that the agent pauses execution and waits for feedback from the user before executing configured tools.
-
-## Deep Agent Details
-
-The below components are built into `deepagents` and helps make it work for deep tasks off-the-shelf.
-
-### System Prompt
-
-`deepagents` comes with a [built-in system prompt](src/deepagents/prompts.py). This is relatively detailed prompt that is heavily based on and inspired by [attempts](https://github.com/kn1026/cc/blob/main/claudecode.md) to [replicate](https://github.com/asgeirtj/system_prompts_leaks/blob/main/Anthropic/claude-code.md)
-Claude Code's system prompt. It was made more general purpose than Claude Code's system prompt.
-This contains detailed instructions for how to use the built-in planning tool, file system tools, and sub agents.
-Note that part of this system prompt [can be customized](#instructions-required)
-
-Without this default system prompt - the agent would not be nearly as successful at going as it is.
-The importance of prompting for creating a "deep" agent cannot be understated.
-
-### Planning Tool
-
-`deepagents` comes with a built-in planning tool. This planning tool is very simple and is based on ClaudeCode's TodoWrite tool.
-This tool doesn't actually do anything - it is just a way for the agent to come up with a plan, and then have that in the context to help keep it on track.
-
-### File System Tools
-
-`deepagents` comes with four built-in file system tools: `ls`, `edit_file`, `read_file`, `write_file`.
-These do not actually use a file system - rather, they mock out a file system using LangGraph's State object.
-This means you can easily run many of these agents on the same machine without worrying that they will edit the same underlying files.
-
-Right now the "file system" will only be one level deep (no sub directories).
-
-These files can be passed in (and also retrieved) by using the `files` key in the LangGraph State object.
-
-```python
-agent = create_deep_agent(...)
-
-result = agent.invoke({
-    "messages": ...,
-    # Pass in files to the agent using this key
-    # "files": {"foo.txt": "foo", ...}
-})
-
-# Access any files afterwards like this
-result["files"]
-```
-
-### Sub Agents
-
-`deepagents` comes with the built-in ability to call sub agents (based on Claude Code).
-It has access to a `general-purpose` subagent at all times - this is a subagent with the same instructions as the main agent and all the tools that is has access to.
-You can also specify [custom sub agents](#subagents-optional) with their own instructions and tools.
-
-Sub agents are useful for ["context quarantine"](https://www.dbreunig.com/2025/06/26/how-to-fix-your-context.html#context-quarantine) (to help not pollute the overall context of the main agent)
-as well as custom instructions.
-
-### Built In Tools
-
-By default, deep agents come with five built-in tools:
-
-- `write_todos`: Tool for writing todos
-- `write_file`: Tool for writing to a file in the virtual filesystem
-- `read_file`: Tool for reading from a file in the virtual filesystem
-- `ls`: Tool for listing files in the virtual filesystem
-- `edit_file`: Tool for editing a file in the virtual filesystem
-
-If you want to omit some deepagents functionality, use specific middleware components directly!
-
-### Human-in-the-Loop
-
-`deepagents` supports human-in-the-loop approval for tool execution. You can configure specific tools to require human approval before execution using the `interrupt_on` parameter, which maps tool names to a `HumanInTheLoopConfig`.
-
-`HumanInTheLoopConfig` is how you specify what type of human in the loop patterns are supported. 
-It is a dictionary with four specific keys:
-
-- `allow_accept`: Whether the human can approve the current action without changes
-- `allow_respond`: Whether the human can reject the current action with feedback
-- `allow_edit`: Whether the human can approve the current action with edited content
-
-Instead of specifying a `HumanInTheLoopConfig` for a tool, you can also just set `True`. This will set `allow_ignore`, `allow_respond`, `allow_edit`, and `allow_accept` to be `True`.
-
-In order to use human in the loop, you need to have a checkpointer attached.
-Note: if you are using LangGraph Platform, this is automatically attached.
-
-Example usage:
-
-```python
-from deepagents import create_deep_agent
-from langgraph.checkpoint.memory import InMemorySaver
-
-# Create agent with file operations requiring approval
-agent = create_deep_agent(
-    tools=[your_tools],
-    instructions="Your instructions here",
-    interrupt_on={
-        # You can specify a dictionary for fine grained control over what interrupt options exist
-        "tool_1": {
-            "allow_respond": True,
-            "allow_edit": True,
-            "allow_accept":True,
-        },
-        # You can specify a boolean for shortcut
-        # This is a shortcut for the same functionality as above
-        "tool_2": True,
-    }
-)
-
-checkpointer= InMemorySaver()
-agent.checkpointer = checkpointer
-```
-
-#### Approve
-
-To "approve" a tool call means the agent will execute the tool call as is.
-
-This flow shows how to approve a tool call (assuming the tool requiring approval is called):
-
-```python
-config = {"configurable": {"thread_id": "1"}}
-for s in agent.stream({"messages": [{"role": "user", "content": message}]}, config=config):
-    print(s)
-# If this calls a tool with an interrupt, this will then return an interrupt
-for s in agent.stream(Command(resume=[{"type": "accept"}]), config=config):
-    print(s)
-
-```
-
-#### Edit
-
-To "edit" a tool call means the agent will execute the new tool with the new arguments. You can change both the tool to call or the arguments to pass to that tool.
-
-The `args` parameter you pass back should be a dictionary with two keys:
-
-- `action`: maps to a string which is the name of the tool to call
-- `args`: maps to a dictionary which is the arguments to pass to the tool
-
-This flow shows how to edit a tool call (assuming the tool requiring approval is called):
-
-```python
-config = {"configurable": {"thread_id": "1"}}
-for s in agent.stream({"messages": [{"role": "user", "content": message}]}, config=config):
-    print(s)
-# If this calls a tool with an interrupt, this will then return an interrupt
-# Replace the `...` with the tool name you want to call, and the arguments
-for s in agent.stream(Command(resume=[{"type": "edit", "args": {"action": "...", "args": {...}}}]), config=config):
-    print(s)
-
-```
-
-#### Respond
-
-To "respond" to a tool call means that tool is NOT called. Rather, a tool message is appended with the content you respond with, and the updated messages list is then sent back to the model.
-
-The `args` parameter you pass back should be a string with your response.
-
-This flow shows how to respond to a tool call (assuming the tool requiring approval is called):
-
-```python
-config = {"configurable": {"thread_id": "1"}}
-for s in agent.stream({"messages": [{"role": "user", "content": message}]}, config=config):
-    print(s)
-# If this calls a tool with an interrupt, this will then return an interrupt
-# Replace the `...` with the response to use all the ToolMessage content
-for s in agent.stream(Command(resume=[{"type": "response", "args": "..."}]), config=config):
-    print(s)
-
-```
-## Async
-
-If you are passing async tools to your agent, you will want to use `from deepagents import async_create_deep_agent`
-## MCP
-
-The `deepagents` library can be ran with MCP tools. This can be achieved by using the [Langchain MCP Adapter library](https://github.com/langchain-ai/langchain-mcp-adapters).
-
-**NOTE:** You will want to use `from deepagents import async_create_deep_agent` to use the async version of `deepagents`, since MCP tools are async
-
-(To run the example below, will need to `pip install langchain-mcp-adapters`)
-
-```python
-import asyncio
-from langchain_mcp_adapters.client import MultiServerMCPClient
-from deepagents import create_deep_agent
-
-async def main():
-    # Collect MCP tools
-    mcp_client = MultiServerMCPClient(...)
-    mcp_tools = await mcp_client.get_tools()
-
-    # Create agent
-    agent = async_create_deep_agent(tools=mcp_tools, ....)
-
-    # Stream the agent
-    async for chunk in agent.astream(
-        {"messages": [{"role": "user", "content": "what is langgraph?"}]},
-        stream_mode="values"
-    ):
-        if "messages" in chunk:
-            chunk["messages"][-1].pretty_print()
-
-asyncio.run(main())
-```
-
-## Roadmap
-- [ ] Allow users to customize full system prompt
-- [ ] Code cleanliness (type hinting, docstrings, formating)
-- [ ] Allow for more of a robust virtual filesystem
-- [ ] Create an example of a deep coding agent built on top of this
-- [ ] Benchmark the example of [deep research agent](examples/research/research_agent.py)

deepagents-0.0.12rc2.dist-info/RECORD

@@ -1,10 +0,0 @@
-deepagents/__init__.py,sha256=9BVNn4lfF5N8l2KY8Ttxi82zO609I-fGqoSIF7DAxiU,342
-deepagents/graph.py,sha256=V4l11BSR435w8taLTluqE9ej1C1qoE9L4KYKx4atcqM,5573
-deepagents/middleware/__init__.py,sha256=J7372TNGR27OU4C3uuQMryHHpXOBjFV_4aEZ_AoQ6n0,284
-deepagents/middleware/filesystem.py,sha256=9yVWCeKYNEdY4IRi2Ik_NcgKyRPtfrzWabHRWoLTP1c,44095
-deepagents/middleware/subagents.py,sha256=v1uxqVfunrFm1SDX_gTlNadFm2OmbvjjTpdE_DKGGzM,23489
-deepagents-0.0.12rc2.dist-info/licenses/LICENSE,sha256=c__BaxUCK69leo2yEKynf8lWndu8iwYwge1CbyqAe-E,1071
-deepagents-0.0.12rc2.dist-info/METADATA,sha256=PPxb1WF9HJf1aMn4vctkpYeBhtHQw1tZZEgZN-h0bOU,17393
-deepagents-0.0.12rc2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-deepagents-0.0.12rc2.dist-info/top_level.txt,sha256=drAzchOzPNePwpb3_pbPuvLuayXkN7SNqeIKMBWJoAo,11
-deepagents-0.0.12rc2.dist-info/RECORD,,