Deep Agents

https://docs.langchain.com/oss/python/deepagents
Admin
Deep Agents is a standalone library for building intelligent agents that can plan, manage context...
Tokens:259,437
Snippets:1,659
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Install Runloop

Source: https://docs.langchain.com/oss/python/deepagents/sandboxes

Install the Runloop integration using pip or uv.

```bash
pip install langchain-runloop

```

```bash
uv add langchain-runloop

```

--------------------------------

### Install E2B

Source: https://docs.langchain.com/oss/python/deepagents/sandboxes

Install the E2B integration using pip or uv.

```bash
pip install langchain-e2b

```

```bash
uv add langchain-e2b

```

--------------------------------

### Install NVIDIA OpenShell

Source: https://docs.langchain.com/oss/python/deepagents/sandboxes

Install the NVIDIA OpenShell integration using pip or uv.

```bash
pip install langchain-nvidia-openshell

```

```bash
uv add langchain-nvidia-openshell

```

--------------------------------

### Create deep agent with StateBackend and Baseten model

Source: https://docs.langchain.com/oss/python/deepagents/skills

Same StateBackend setup as the Fireworks example but uses the Baseten model 'baseten:zai-org/GLM-5.2'. Seeds the skill file into the in-state filesystem and invokes the agent with a thread_id.

```python
from urllib.request import urlopen
from deepagents import create_deep_agent
from deepagents.backends import StateBackend
from deepagents.backends.utils import create_file_data
from langgraph.checkpoint.memory import MemorySaver

checkpointer = MemorySaver()
backend = StateBackend()

skill_url = "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/libs/code/examples/skills/langgraph-docs/SKILL.md"
with urlopen(skill_url) as response:
    skill_content = response.read().decode('utf-8')

skills_files = {
    "/skills/langgraph-docs/SKILL.md": create_file_data(skill_content),
}

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    backend=backend,
    skills=["/skills/"],
    checkpointer=checkpointer,
)

result = agent.invoke(
    {
        "messages": [{"role": "user", "content": "What is langgraph?"}],
        # Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
        "files": skills_files,
    },
    config={"configurable": {"thread_id": "12345"}},
)
```

--------------------------------

### Install langchain-vercel-sandbox with pip or uv

Source: https://docs.langchain.com/oss/python/deepagents/sandboxes

Install the langchain-vercel-sandbox package using pip or uv.

```bash
pip install langchain-vercel-sandbox
```

```bash
uv add langchain-vercel-sandbox
```

--------------------------------

### Install Daytona

Source: https://docs.langchain.com/oss/python/deepagents/sandboxes

Install the Daytona integration using pip or uv.

```bash
pip install langchain-daytona

```

```bash
uv add langchain-daytona

```

--------------------------------

### Install langchain-daytona with pip or uv

Source: https://docs.langchain.com/oss/python/deepagents/sandboxes

Install the langchain-daytona package using pip or uv.

```bash
pip install langchain-daytona
```

```bash
uv add langchain-daytona
```

--------------------------------

### Install Vercel Sandbox

Source: https://docs.langchain.com/oss/python/deepagents/sandboxes

Install the Vercel Sandbox integration using pip or uv.

```bash
pip install langchain-vercel-sandbox

```

```bash
uv add langchain-vercel-sandbox

```

--------------------------------

### Install langchain-daytona with pip

Source: https://docs.langchain.com/oss/python/deepagents/sandboxes

Install the langchain-daytona package using pip.

```bash
pip install langchain-daytona
```

--------------------------------

### Install and use NVIDIAEmbeddings

Source: https://docs.langchain.com/oss/python/deepagents/rag

Install the langchain-nvidia-ai-endpoints package and set up NVIDIAEmbeddings with the NV-Embed-QA model. Prompts for an NVIDIA API key if not already set.

```bash
pip install -qU langchain-nvidia-ai-endpoints

```

```python
import getpass
import os

if not os.environ.get("NVIDIA_API_KEY"):
    os.environ["NVIDIA_API_KEY"] = getpass.getpass("Enter API key for NVIDIA: ")

from langchain_nvidia_ai_endpoints import NVIDIAEmbeddings

embeddings = NVIDIAEmbeddings(model="NV-Embed-QA")

```

--------------------------------

### Install langchain-agentcore-codeinterpreter with pip or uv

Source: https://docs.langchain.com/oss/python/deepagents/sandboxes

Install the langchain-agentcore-codeinterpreter package using pip or uv.

```bash
pip install langchain-agentcore-codeinterpreter
```

```bash
uv add langchain-agentcore-codeinterpreter
```

--------------------------------

### Install langchain[google-genai] with pip or uv

Source: https://docs.langchain.com/oss/python/deepagents/customization

Install the LangChain Google GenAI integration package using pip or uv.

```bash
pip install -U "langchain[google-genai]"

```

```bash
uv add "langchain[google-genai]"

```

--------------------------------

### Install langchain-runloop with pip or uv

Source: https://docs.langchain.com/oss/python/deepagents/sandboxes

Install the langchain-runloop package using pip or uv.

```bash
pip install langchain-runloop
```

```bash
uv add langchain-runloop
```

--------------------------------

### Install and use DeterministicFakeEmbedding

Source: https://docs.langchain.com/oss/python/deepagents/rag

Install the langchain-core package and create a DeterministicFakeEmbedding with size 4096. Useful for testing without a real embedding provider.

```bash
pip install -qU langchain-core

```

```python
from langchain_core.embeddings import DeterministicFakeEmbedding

embeddings = DeterministicFakeEmbedding(size=4096)

```

--------------------------------

### Install AgentCore code interpreter

Source: https://docs.langchain.com/oss/python/deepagents/sandboxes

Install the AgentCore code interpreter integration using pip or uv.

```bash
pip install langchain-agentcore-codeinterpreter

```

```bash
uv add langchain-agentcore-codeinterpreter

```

--------------------------------

### Install and use IsaacusEmbeddings

Source: https://docs.langchain.com/oss/python/deepagents/rag

Install the langchain-isaacus package and set up IsaacusEmbeddings with the kanon-2-embedder model. Prompts for an Isaacus API key if not already set.

```bash
pip install -qU langchain-isaacus

```

```python
import getpass
import os

if not os.environ.get("ISAACUS_API_KEY"):
os.environ["ISAACUS_API_KEY"] = getpass.getpass("Enter API key for Isaacus: ")

from langchain_isaacus import IsaacusEmbeddings

embeddings = IsaacusEmbeddings(model="kanon-2-embedder")

```

--------------------------------

### Install langchain-e2b with pip or uv

Source: https://docs.langchain.com/oss/python/deepagents/sandboxes

Install the langchain-e2b package using pip or uv.

```bash
pip install langchain-e2b
```

```bash
uv add langchain-e2b
```

--------------------------------

### Install langchain[openai] with pip or uv

Source: https://docs.langchain.com/oss/python/deepagents/customization

Install the LangChain OpenAI integration package using pip or uv.

```bash
pip install -U "langchain[openai]"

```

```bash
uv add "langchain[openai]"

```

--------------------------------

### Create Deep Agent with Ollama

Source: https://docs.langchain.com/oss/python/deepagents

Quickstart example for Ollama provider. Uses the model identifier 'ollama:north-mini-code-1.0' with a simple weather tool.

```python
from deepagents import create_deep_agent


def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"It's always sunny in {city}!"


agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    tools=[get_weather],
    system_prompt="You are a helpful assistant",
)

# Run the agent
agent.invoke(
    {"messages": [{"role": "user", "content": "what is the weather in sf"}]}
)

```

--------------------------------

### Quickstart: Connect agent to MCP server

Source: https://docs.langchain.com/oss/python/deepagents/mcp

Open an MCPAdapter, discover the server's tools with list_tools(), and build the agent inside the context. The tools hold the client, so the agent stays usable after the context exits.

```python
from langchain.agents import create_agent
from langchain.mcp import MCPAdapter


async def main():
    async with MCPAdapter("https://example.com/mcp") as adapter:
        tools = await adapter.list_tools()
        agent = create_agent("claude-sonnet-5", tools)
        return await agent.ainvoke({"messages": [{"role": "user", "content": "..."}]})

```

--------------------------------

### Create Deep Agent with Baseten GLM

Source: https://docs.langchain.com/oss/python/deepagents

Quickstart example for Baseten provider. Uses the model identifier 'baseten:zai-org/GLM-5.2' with a simple weather tool.

```python
from deepagents import create_deep_agent


def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"It's always sunny in {city}!"


agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    tools=[get_weather],
    system_prompt="You are a helpful assistant",
)

# Run the agent
agent.invoke(
    {"messages": [{"role": "user", "content": "what is the weather in sf"}]}
)

```

--------------------------------

### Set up Daytona sandbox backend

Source: https://docs.langchain.com/oss/python/deepagents/data-analysis

Installs the Daytona dependency (pip or uv) and creates a DaytonaSandbox backend by creating a Daytona sandbox.

```bash
pip install langchain-daytona

```

```bash
uv add langchain-daytona

```

```python
from daytona import Daytona

from langchain_daytona import DaytonaSandbox

sandbox = Daytona().create()
backend = DaytonaSandbox(sandbox=sandbox)

```

--------------------------------

### Create Deep Agent with Fireworks GLM

Source: https://docs.langchain.com/oss/python/deepagents

Quickstart example for Fireworks provider. Uses the model identifier 'fireworks:accounts/fireworks/models/glm-5p2' with a simple weather tool.

```python
from deepagents import create_deep_agent


def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"It's always sunny in {city}!"


agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    tools=[get_weather],
    system_prompt="You are a helpful assistant",
)

# Run the agent
agent.invoke(
    {"messages": [{"role": "user", "content": "what is the weather in sf"}]}
)

```

--------------------------------

### Set up E2B sandbox backend

Source: https://docs.langchain.com/oss/python/deepagents/data-analysis

Installs the E2B dependency (pip or uv) and creates an E2BSandbox backend.

```bash
pip install langchain-e2b

```

```bash
uv add langchain-e2b

```

```python
from e2b import Sandbox
from langchain_e2b import E2BSandbox

e2b_sandbox = Sandbox.create()
backend = E2BSandbox(sandbox=e2b_sandbox)

```

--------------------------------

### SKILL.md frontmatter and instructions

Source: https://docs.langchain.com/oss/python/deepagents/skills

Example SKILL.md file with YAML frontmatter (name and description) and markdown instructions for the agent to follow when the skill is activated.

```markdown
---
name: langgraph-docs
description: Use this skill for requests related to LangGraph in order to fetch relevant documentation to provide accurate, up-to-date guidance.
---

# langgraph-docs

## Overview

This skill explains how to access LangGraph documentation to help answer questions and guide implementation.

## Instructions

### 1. Fetch the documentation index

Use the fetch_url tool to read the following URL:
https://docs.langchain.com/llms.txt

This provides a structured list of all available documentation with descriptions.

### 2. Select relevant documentation

Based on the question, identify 2-4 most relevant documentation URLs from the index. Prioritize:

- Specific how-to guides for implementation questions
- Core concept pages for understanding questions
- Tutorials for end-to-end examples
- Reference docs for API details

### 3. Fetch and synthesize

Use the fetch_url tool to read the selected documentation URLs, then answer the user's question. Give a direct answer first, include the minimum necessary context, and link to the source pages rather than quoting long passages.

```

--------------------------------

### Create Deep Agent with OpenRouter GLM

Source: https://docs.langchain.com/oss/python/deepagents

Quickstart example for OpenRouter provider. Uses the model identifier 'openrouter:z-ai/glm-5.2' with a simple weather tool.

```python
from deepagents import create_deep_agent


def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"It's always sunny in {city}!"


agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    tools=[get_weather],
    system_prompt="You are a helpful assistant",
)

# Run the agent
agent.invoke(
    {"messages": [{"role": "user", "content": "what is the weather in sf"}]}
)

```

--------------------------------

### Set up Modal sandbox backend

Source: https://docs.langchain.com/oss/python/deepagents/data-analysis

Creates a ModalSandbox backend using a Modal app and sandbox.

```python
import modal

from langchain_modal import ModalSandbox

app = modal.App.lookup("your-app")
modal_sandbox = modal.Sandbox.create(app=app)
backend = ModalSandbox(sandbox=modal_sandbox)

```

--------------------------------

### Create Deep Agent with Anthropic Claude

Source: https://docs.langchain.com/oss/python/deepagents

Quickstart example for Anthropic provider. Uses the model identifier 'anthropic:claude-sonnet-5' with a simple weather tool.

```python
from deepagents import create_deep_agent


def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"It's always sunny in {city}!"


agent = create_deep_agent(
    model="anthropic:claude-sonnet-5",
    tools=[get_weather],
    system_prompt="You are a helpful assistant",
)

# Run the agent
agent.invoke(
    {"messages": [{"role": "user", "content": "what is the weather in sf"}]}
)

```

--------------------------------

### Create agent.py with imports and DOC_PATHS

Source: https://docs.langchain.com/oss/python/deepagents/rag

Sets up the necessary imports and a curated list of documentation paths to index. The DOC_PATHS list can be expanded or replaced by parsing URLs from llms.txt to cover more pages.

```python
import requests
from langchain_core.documents import Document
from langchain_core.vectorstores import InMemoryVectorStore
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter

DOCS_BASE = "https://docs.langchain.com"

# Curated LangChain OSS pages for this tutorial. Expand this list or parse
# URLs from https://docs.langchain.com/llms.txt to index more of the site.
DOC_PATHS = [
    "oss/python/langchain/agents",
    "oss/python/deepagents/rag",
    "oss/python/langchain/tools",
    "oss/python/langchain/models",
    "oss/python/deepagents/retrieval",
    "oss/python/langchain/knowledge-base",
    "oss/python/langchain/middleware",
    "oss/python/deepagents/overview",
    "oss/python/deepagents/subagents",
    "oss/python/deepagents/streaming",
    "oss/python/deepagents/frontend/subagent-streaming",
    "oss/python/deepagents/backends",
    "oss/python/langgraph/overview",
    "oss/python/langgraph/quickstart",
]
```

--------------------------------

### Create Deep Agent with OpenAI GPT

Source: https://docs.langchain.com/oss/python/deepagents

Quickstart example for OpenAI provider. Uses the model identifier 'openai:gpt-5.5' with a simple weather tool.

```python
from deepagents import create_deep_agent


def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"It's always sunny in {city}!"


agent = create_deep_agent(
    model="openai:gpt-5.5",
    tools=[get_weather],
    system_prompt="You are a helpful assistant",
)

# Run the agent
agent.invoke(
    {"messages": [{"role": "user", "content": "what is the weather in sf"}]}
)

```

--------------------------------

### Create Deep Agent with Google Gemini

Source: https://docs.langchain.com/oss/python/deepagents

Quickstart example for Google provider. Uses the model identifier 'google_genai:gemini-3.6-flash' with a simple weather tool.

```python
from deepagents import create_deep_agent


def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"It's always sunny in {city}!"


agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    tools=[get_weather],
    system_prompt="You are a helpful assistant",
)

# Run the agent
agent.invoke(
    {"messages": [{"role": "user", "content": "what is the weather in sf"}]}
)

```

--------------------------------

### Run ACP agent server with Toad

Source: https://docs.langchain.com/oss/python/deepagents/acp

Install Toad and run an ACP agent server as a local dev tool. Use either the python or uv run command to start your server.

```bash
uv tool install -U batrachian-toad

toad acp "python path/to/your_server.py" .
# or
toad acp "uv run python path/to/your_server.py" .

```

--------------------------------

### Set up LocalShellBackend

Source: https://docs.langchain.com/oss/python/deepagents/data-analysis

Creates a LocalShellBackend with a restricted root directory and virtual mode. This backend has important security considerations; use with caution.

```python
from deepagents.backends import LocalShellBackend

backend = LocalShellBackend(
    root_dir=".",
    virtual_mode=True,
    env={"PATH": "/usr/bin:/bin"},
)

```

--------------------------------

### Example cover image prompt for tutorial/how-to

Source: https://docs.langchain.com/oss/python/deepagents/content-builder

Example image prompt for a tutorial or how-to blog post. It describes a friendly, approachable style with a warm gradient background and centered composition with space for text overlay.

```text
Clean flat illustration of hands typing on a keyboard with abstract code symbols floating upward, transforming into lightbulbs and gears. Warm gradient background from soft coral to light peach. Friendly, approachable style. Centered composition with space for text overlay.
```

--------------------------------

### Stream custom events with Baseten model

Source: https://docs.langchain.com/oss/python/deepagents/streaming

Same streaming example but uses the Baseten model 'baseten:zai-org/GLM-5.2' instead of Fireworks. The coordinator and analyst subagent setup, tool, and stream loop are identical to the Fireworks variant.

```python
import time
from langchain.tools import tool
from langgraph.config import get_stream_writer
from deepagents import create_deep_agent


@tool
def analyze_data(topic: str) -> str:
    """Run a data analysis on a given topic.

    This tool performs the actual analysis and emits progress updates.
    You MUST call this tool for any analysis request.
    """
    writer = get_stream_writer()

    writer({"status": "starting", "topic": topic, "progress": 0})
    time.sleep(0.5)

    writer({"status": "analyzing", "progress": 50})
    time.sleep(0.5)

    writer({"status": "complete", "progress": 100})
    return (
        f'Analysis of "{topic}": Customer sentiment is 85% positive, '
        "driven by product quality and support response times."
    )


agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    system_prompt=(
        "You are a coordinator. For any analysis request, you MUST delegate "
        "to the analyst subagent using the task tool. Never try to answer directly. "
        "After receiving the result, summarize it in one sentence."
    ),
    subagents=[
        {
            "name": "analyst",
            "description": "Performs data analysis with real-time progress tracking",
            "system_prompt": (
                "You are a data analyst. You MUST call the analyze_data tool "
                "for every analysis request. Do not use any other tools. "
                "After the analysis completes, report the result."
            ),
            "tools": [analyze_data],
        },
    ],
)

custom_event_count = 0
for namespace, data in agent.stream(
    {"messages": [{"role": "user", "content": "Analyze customer satisfaction trends"}]},
    stream_mode="custom",
    subgraphs=True,
):
    custom_event_count += 1
    is_subagent = any(s.startswith("tools:") for s in namespace)
    if is_subagent:
        subagent_ns = next(s for s in namespace if s.startswith("tools:"))
        print(f"[{subagent_ns}]", data)
    else:
        print("[main]", data)
```

--------------------------------

### Set up Runloop sandbox backend

Source: https://docs.langchain.com/oss/python/deepagents/data-analysis

Installs the Runloop dependency (pip or uv) and creates a RunloopSandbox backend using a Runloop devbox.

```bash
pip install langchain-runloop

```

```bash
uv add langchain-runloop

```

```python
from runloop_api_client import RunloopSDK

from langchain_runloop import RunloopSandbox

api_key = "..."
client = RunloopSDK(bearer_token=api_key)

devbox = client.devbox.create()
backend = RunloopSandbox(devbox=devbox)

```

--------------------------------

### Create deep agent with Anthropic claude-sonnet-5

Source: https://docs.langchain.com/oss/python/deepagents/rag

Same RAG deep agent setup as the OpenAI example, but uses Anthropic's claude-sonnet-5 model. The rest of the configuration, including the chunk-analyst subagent and concurrency limit, remains identical.

```python
from deepagents import create_deep_agent
from langchain.chat_models import init_chat_model

max_concurrent_analysts = 3

INSTRUCTIONS = (
    RAG_WORKFLOW_INSTRUCTIONS
    + "\n\n"
    + "=" * 80
    + "\n\n"
    + SUBAGENT_DELEGATION_INSTRUCTIONS.format(
        max_concurrent_analysts=max_concurrent_analysts,
    )
)

chunk_analyst_subagent = {
    "name": "chunk-analyst",
    "description": (
        "Analyze one retrieved documentation chunk file. "
        "Pass the user question and a single file path under /retrieved/."
    ),
    "system_prompt": CHUNK_ANALYST_INSTRUCTIONS,
}

model = init_chat_model(model="anthropic:claude-sonnet-5")

agent = create_deep_agent(
    model=model,
    tools=[search_documentation],
    backend=backend,
    system_prompt=INSTRUCTIONS,
    subagents=[chunk_analyst_subagent],
)
```

--------------------------------

### Create project directory

Source: https://docs.langchain.com/oss/python/deepagents/rag

Creates and enters the project directory for the RAG agent example.

```bash
mkdir docs-rag-agent
cd docs-rag-agent

```

--------------------------------

### Create deep agent with ContextHubBackend for multiple model providers

Source: https://docs.langchain.com/oss/python/deepagents/backends

Create a deep agent with ContextHubBackend using different model providers. Each example shows the same setup with a different model string: Google, OpenAI, Anthropic, OpenRouter, Fireworks, Baseten, and Ollama. Requires a Context Hub repo and LANGSMITH_API_KEY.

```python
from deepagents import create_deep_agent
from deepagents.backends import ContextHubBackend

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    backend=ContextHubBackend("my-agent"),
)

```

```python
from deepagents import create_deep_agent
from deepagents.backends import ContextHubBackend

agent = create_deep_agent(
    model="openai:gpt-5.5",
    backend=ContextHubBackend("my-agent"),
)

```

```python
from deepagents import create_deep_agent
from deepagents.backends import ContextHubBackend

agent = create_deep_agent(
    model="anthropic:claude-sonnet-5",
    backend=ContextHubBackend("my-agent"),
)

```

```python
from deepagents import create_deep_agent
from deepagents.backends import ContextHubBackend

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    backend=ContextHubBackend("my-agent"),
)

```

```python
from deepagents import create_deep_agent
from deepagents.backends import ContextHubBackend

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    backend=ContextHubBackend("my-agent"),
)

```

```python
from deepagents import create_deep_agent
from deepagents.backends import ContextHubBackend

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    backend=ContextHubBackend("my-agent"),
)

```

```python
from deepagents import create_deep_agent
from deepagents.backends import ContextHubBackend

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    backend=ContextHubBackend("my-agent"),
)

```

--------------------------------

### Create deep agent with Ollama model and stream updates

Source: https://docs.langchain.com/oss/python/deepagents/streaming

Same deep agent setup as the Baseten example but uses the Ollama model 'north-mini-code-1.0'. The coordinator delegates research to a subagent and streams updates with subgraph namespaces. The loop prints main agent and subagent steps, and prints subagent results when a tool message is received.

```python
from deepagents import create_deep_agent

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    system_prompt=(
        "You are a project coordinator with no research knowledge. "
        "For every user request, you must call the task() tool with "
        "subagent_type set to researcher. Never answer research questions yourself. "
        "Keep your final response to one sentence."
    ),
        subagents=[
        {
            "name": "researcher",
            "description": "Researches topics thoroughly",
            "system_prompt": (
                "You are a thorough researcher. Research the given topic "
                "and provide a concise summary in 2-3 sentences."
            ),
        },
    ],
)

for namespace, data in agent.stream(
    {"messages": [{"role": "user", "content": "Write a short summary about AI safety"}]},
    stream_mode="updates",
    subgraphs=True,
):
    # Main agent updates (empty namespace)
    if not namespace:
        for node_name, data in data.items():
            if node_name == "tools":
                # Subagent results returned to main agent
                for msg in data.get("messages", []):
                    if msg.type == "tool":
                        print(f"\nSubagent complete: {msg.name}")
                        print(f"  Result: {str(msg.content)[:200]}...")
            else:
                print(f"[main agent] step: {node_name}")

    # Subagent updates (non-empty namespace)
    else:
        for node_name, data in data.items():
            print(f"  [{namespace[0]}] step: {node_name}")
```

--------------------------------

### Install and use OllamaEmbeddings

Source: https://docs.langchain.com/oss/python/deepagents/rag

Install the langchain-ollama package and create OllamaEmbeddings with the llama3 model. No API key prompt is shown; assumes Ollama is running locally.

```bash
pip install -qU langchain-ollama

```

```python
from langchain_ollama import OllamaEmbeddings

embeddings = OllamaEmbeddings(model="llama3")

```

--------------------------------

### Bad subagent description example

Source: https://docs.langchain.com/oss/python/deepagents/async-subagents

Example of a vague, non-action-oriented subagent description. This is shown as a contrast to the good example; it is not recommended.

```python
from deepagents import AsyncSubAgent

AsyncSubAgent(
    name="helper",
    description="helps with stuff",
    graph_id="helper",
)

```

--------------------------------

### Configure QdrantVectorStore

Source: https://docs.langchain.com/oss/python/deepagents/rag

Install langchain-qdrant and configure a Qdrant vector store using an in-memory client. Creates a collection with cosine distance if it does not exist.

```bash
pip install -qU langchain-qdrant

```

```python
from qdrant_client.models import Distance, VectorParams
from langchain_qdrant import QdrantVectorStore
from qdrant_client import QdrantClient

client = QdrantClient(":memory:")

vector_size = len(embeddings.embed_query("sample text"))

if not client.collection_exists("test"):
    client.create_collection(
        collection_name="test",
        vectors_config=VectorParams(size=vector_size, distance=Distance.COSINE)
    )
vector_store = QdrantVectorStore(
    client=client,
    collection_name="test",
    embedding=embeddings,
)

```

--------------------------------

### Install deepagents

Source: https://docs.langchain.com/oss/python/deepagents/data-analysis

Installs the core deepagents package.

```bash
pip install deepagents

```

--------------------------------

### Upload sample sales data to backend

Source: https://docs.langchain.com/oss/python/deepagents/data-analysis

Creates sample sales data, converts it to CSV bytes, and uploads it to the backend at /root/data/sales_data.csv.

```python
import csv
import io

# Create sample sales data
data = [
    ["Date", "Product", "Units Sold", "Revenue"],
    ["2025-08-01", "Widget A", 10, 250],
    ["2025-08-02", "Widget B", 5, 125],
    ["2025-08-03", "Widget A", 7, 175],
    ["2025-08-04", "Widget C", 3, 90],
    ["2025-08-05", "Widget B", 8, 200],
]

# Convert to CSV bytes
text_buf = io.StringIO()
writer = csv.writer(text_buf)
writer.writerows(data)
csv_bytes = text_buf.getvalue().encode("utf-8")
text_buf.close()

# Upload to backend
backend.upload_files([("/root/data/sales_data.csv", csv_bytes)])

```

--------------------------------

### Install langchain-vercel-sandbox with pip

Source: https://docs.langchain.com/oss/python/deepagents/sandboxes

Install the langchain-vercel-sandbox package using pip.

```bash
pip install langchain-vercel-sandbox
```

--------------------------------

### Create blog-post SKILL.md with YAML frontmatter and instructions

Source: https://docs.langchain.com/oss/python/deepagents/content-builder

The complete SKILL.md file for the blog-post skill. It defines the skill's name and description in YAML frontmatter, then provides instructions for research, output structure, blog post structure, cover image generation, and example image prompts. The skill requires delegating research to a researcher subagent, writing to blogs/<slug>/post.md, and generating a cover image to blogs/<slug>/hero.png.

```markdown
---
name: blog-post
description: Writes and structures long-form blog posts, creates tutorial outlines, and optimizes content for SEO with cover image generation. Use when the user asks to write a blog post, article, how-to guide, tutorial, technical writeup, thought leadership piece, or long-form content.
---

# Blog Post Writing Skill

## Research First (Required)

**Before writing any blog post, you MUST delegate research:**

1. Use the `task` tool with `subagent_type: "researcher"`
2. In the description, specify BOTH the topic AND where to save:

```
task(
    subagent_type="researcher",
    description="Research [TOPIC]. Save findings to research/[slug].md"
)
```

Example:
```
task(
    subagent_type="researcher",
    description="Research the current state of AI agents in 2025. Save findings to research/ai-agents-2025.md"
)
```

3. After research completes, read the findings file before writing

## Output Structure (Required)

**Every blog post MUST have both a post AND a cover image:**

```
blogs/
└── <slug>/
    ├── post.md        # The blog post content
    └── hero.png       # REQUIRED: Generated cover image
```

Example: A post about "AI Agents in 2025" → `blogs/ai-agents-2025/`

**You MUST complete both steps:**
1. Write the post to `blogs/<slug>/post.md`
2. Generate a cover image using `generate_image` and save to `blogs/<slug>/hero.png`

**A blog post is NOT complete without its cover image.**

## Blog Post Structure

Every blog post should follow this structure:

### 1. Hook (Opening)
- Start with a compelling question, statistic, or statement
- Make the reader want to continue
- Keep it to 2-3 sentences

### 2. Context (The Problem)
- Explain why this topic matters
- Describe the problem or opportunity
- Connect to the reader's experience

### 3. Main Content (The Solution)
- Break into 3-5 main sections with H2 headers
- Each section covers one key point
- Include code examples, diagrams, or screenshots where helpful
- Use bullet points for lists

### 4. Practical Application
- Show how to apply the concepts
- Include step-by-step instructions if applicable
- Provide code snippets or templates

### 5. Conclusion & CTA
- Summarize key takeaways (3 bullets max)
- End with a clear call-to-action
- Link to related resources

## Cover Image Generation

After writing the post, generate a cover image using the `generate_cover` tool:

```
generate_cover(prompt="A detailed description of the image...", slug="your-blog-slug")
```

The tool saves the image to `blogs/<slug>/hero.png`.

### Writing Effective Image Prompts

Structure your prompt with these elements:

1. **Subject**: What is the main focus? Be specific and concrete.
2. **Style**: Art direction (minimalist, isometric, flat design, 3D render, watercolor, etc.)
3. **Composition**: How elements are arranged (centered, rule of thirds, symmetrical)
4. **Color palette**: Specific colors or mood (warm earth tones, cool blues and purples, high contrast)
5. **Lighting/Atmosphere**: Soft diffused light, dramatic shadows, golden hour, neon glow
6. **Technical details**: Aspect ratio considerations, negative space for text overlay

### Example Prompts

**For a technical blog post:**
```
Isometric 3D illustration of interconnected glowing cubes representing AI agents, each cube has subtle circuit patterns. Cubes connected by luminous data streams. Deep navy background (#0a192f) with electric blue (#64ffda) and soft purple (#c792ea) accents. Clean minimal style, lots of negative space at top for title. Professional tech aesthetic.
```

**For a tutorial/how-to:**
```
Clean flat illustration of hands typing on a keyboard with abstract code symbols floating upward, transforming into lightbulbs and gears. Warm gradient background from soft coral to light peach. Friendly, approachable style. Centered composition with space for text overlay.
```

**For thought leadership:**
```
Abstract visualization of a human silhouette profile merging with geometric neural network patterns. Split composition - organic watercolor texture on left transitioning to clean vector lines on right. Muted sage green and warm terracotta color scheme. Contemplative, forward-thinking mood.
```
```

--------------------------------

### Install deepagents with QuickJS using uv

Source: https://docs.langchain.com/oss/python/deepagents/subagents

Add the QuickJS interpreter dependency using the uv package manager.

```bash
uv add "deepagents[quickjs]"

```
Tokens:
Raw