LangChain OSS Python

https://docs.langchain.com/oss/python
Admin
LangChain is a framework for developing applications powered by language models, offering tools and...
Tokens:1,451,133
Snippets:12,246
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Installation output example

Source: https://docs.langchain.com/oss/python/integrations/tools/tableau

Example output from the installation commands showing already satisfied dependencies. This is not code but a sample of the terminal output you might see.

```text
Requirement already satisfied: regex>=2022.1.18 in /Users/joe.constantino/.pyenv/versions/3.12.2/lib/python3.12/site-packages (from tiktoken<1,>=0.7->langchain-openai->langchain-tableau) (2024.11.6)
Requirement already satisfied: httpcore==1.* in /Users/joe.constantino/.pyenv/versions/3.12.2/lib/python3.12/site-packages (from httpx>=0.25.2->langgraph-sdk<0.2.0,>=0.1.42->langgraph->langchain-tableau) (1.0.7)
Requirement already satisfied: h11<0.15,>=0.13 in /Users/joe.constantino/.pyenv/versions/3.12.2/lib/python3.12/site-packages (from httpcore==1.*->httpx>=0.25.2->langgraph-sdk<0.2.0,>=0.1.42->langgraph->langchain-tableau) (0.14.0)

```

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

### Install FastAPI

Source: https://docs.langchain.com/oss/python/integrations/middleware/aws

Install FastAPI to run the asynchronous web server example.

```bash
pip install -U fastapi

```

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

### Credential setup output

Source: https://docs.langchain.com/oss/python/integrations/vectorstores/astradb

Example output from the credential setup script, showing the prompts and placeholder values.

```text
ASTRA_DB_API_ENDPOINT =  https://01234567-89ab-cdef-0123-456789abcdef-us-east1.apps.astra.datastax.com
ASTRA_DB_APPLICATION_TOKEN =  ········
(optional) ASTRA_DB_KEYSPACE =

```

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

### Install dependencies for LangGraph example

Source: https://docs.langchain.com/oss/python/integrations/chat/anthropic

Installs the required packages for the end-to-end LangGraph example: `langchain-openai` and `numpy`.

```bash
pip install langchain-openai numpy
```

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

### Set up local documentation preview with git clone, mise, make install, and make dev

Source: https://docs.langchain.com/oss/python/contributing/documentation

Run these commands in order to set up a local preview of the LangChain documentation. The first two clone the repository and enter its directory. The third installs the pinned toolchain via mise, which also wires up git hooks. The last two install dependencies and start a development server with hot reload at http://localhost:3000.

```bash
git clone https://github.com/langchain-ai/docs.git

```

```bash
cd docs

```

```bash
mise trust && mise install

```

```bash
make install

```

```bash
make dev

```

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

### Middleware configuration example

Source: https://docs.langchain.com/oss/python/integrations/middleware/aws

Shows the minimal setup when using the middleware. Compatible tools that meet the custom tool integration contract are handled automatically.

```python
config = AgentCorePaymentsConfig(
    payment_manager_arn="arn:...",
    user_id="...",
    payment_instrument_id="...",
    auto_session=True,
)
agent = create_agent(
    model=model,
    tools=[my_tools],
    middleware=[AgentCorePaymentsMiddleware(config)],
)

```

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

### Docstring with minimal example and link to multimodal guide

Source: https://docs.langchain.com/oss/python/contributing/code

Shows the recommended pattern for including a single minimal example in a docstring and linking to a comprehensive guide for more variations. The example uses a HumanMessage with an image content type.

```python
"""
Example:
    \`\`\`python
    message = HumanMessage(content=[
        {"type": "image", "url": "https://example.com/image.jpg"}
    ])
    \`\`\`

See the [multimodal guide](https://docs.langchain.com/oss/integrations/chat/anthropic#multimodal)
for all supported input formats.
"""

```

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

### Quick start with AzureBlobBackend

Source: https://docs.langchain.com/oss/python/integrations/providers/microsoft

Quick start example for using AzureBlobBackend with a deep agent. The backend defaults to DefaultAzureCredential and accepts a credential override. The prefix parameter is optional and isolates each agent/session.

```python
from deepagents import create_deep_agent
from langchain_azure_storage.deepagents import AzureBlobBackend

backend = AzureBlobBackend(
    account_url="https://<my-storage-account-name>.blob.core.windows.net",
    container_name="agent-workspace",
    prefix="session-001/",  # Optional: isolate each agent/session under a prefix.
)

agent = create_deep_agent(backend=backend)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Write a hello world script to hello.py"}]}
)

```

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

### Common setup: agent with get_weather tool

Source: https://docs.langchain.com/oss/python/langchain/test/evals

Defines a get_weather tool and creates an agent using create_agent with the tool. This setup is shared by the strict and unordered examples below.

```python
from langchain.agents import create_agent
from langchain.tools import tool
from langchain.messages import HumanMessage, AIMessage, ToolMessage
from agentevals.trajectory.match import create_trajectory_match_evaluator


@tool
def get_weather(city: str):
    """Get weather information for a city."""
    return f"It's 75 degrees and sunny in {city}."

agent = create_agent("claude-sonnet-4-6", tools=[get_weather])

```

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

### Install dependencies for GoogleGenerativeAIEmbeddings example

Source: https://docs.langchain.com/oss/python/integrations/embeddings/google_generative_ai

Installs the matplotlib and scikit-learn packages required for the cosine similarity example.

```bash
pip install -qU matplotlib scikit-learn

```

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

### 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": "..."}]})

```

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

### Quickstart with OpenAI (openai:gpt-5.5)

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

Creates a deep agent using the OpenAI model 'openai:gpt-5.5' with a weather tool and a system prompt, then invokes it with a user message.

```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"}]}
)
```

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

### Quickstart with Baseten (baseten:zai-org/GLM-5.2)

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

Creates a deep agent using the Baseten model 'baseten:zai-org/GLM-5.2' with a weather tool and a system prompt, then invokes it with a user message.

```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"}]}
)
```

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

### Get a specific tool by name

Source: https://docs.langchain.com/oss/python/integrations/tools/ibm_watsonx

Retrieves a specific WatsonxTool by name. In this example, it gets the GoogleSearch tool.

```python
google_search = watsonx_toolkit.get_tool(tool_name="GoogleSearch")

```

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

### Quickstart: Create agent with PrivyWalletTool

Source: https://docs.langchain.com/oss/python/integrations/tools/privy

Initializes a PrivyWalletTool, which automatically creates a wallet, and uses it with create_agent to enable wallet operations via natural language.

```python
import os
from langchain_privy import PrivyWalletTool
from langchain.agents import create_agent

# Set credentials
os.environ["PRIVY_APP_ID"] = "your-privy-app-id"
os.environ["PRIVY_APP_SECRET"] = "your-privy-app-secret"

# Initialize wallet tool (automatically creates wallet)
privy_tool = PrivyWalletTool()
print(f"Wallet created! Address: {privy_tool.wallet_address}")

# Create agent
agent = create_agent(
    model="claude-sonnet-4-6",
    tools=[privy_tool],
)

# Agent can now perform wallet operations
agent.invoke({"messages": [{"role": "user", "content": "What's my wallet address on Base?"}]})

```

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

### Install langchain-google-bigtable and langchain-google-vertexai

Source: https://docs.langchain.com/oss/python/integrations/stores/bigtable

Installs the Bigtable integration package and the Vertex AI package required for the embedding cache example.

```bash
pip install -qU langchain-google-bigtable langchain-google-vertexai

```

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

### Quickstart with Google Gemini (google_genai:gemini-3.6-flash)

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

Creates a deep agent using the Google Gemini model 'google_genai:gemini-3.6-flash' with a weather tool and a system prompt, then invokes it with a user message.

```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"}]}
)
```

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

### Install dependencies for Docugami loader

Source: https://docs.langchain.com/oss/python/integrations/document_loaders/docugami

Install the required packages for the Docugami loader example: langchain-openai, tiktoken, langchain-chroma, and hnswlib.

```bash
!poetry run pip install -U langchain-openai tiktoken langchain-chroma hnswlib

```

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

### Quickstart with OpenRouter (openrouter:z-ai/glm-5.2)

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

Creates a deep agent using the OpenRouter model 'openrouter:z-ai/glm-5.2' with a weather tool and a system prompt, then invokes it with a user message.

```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"}]}
)
```

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

### Install langchain-qdrant package

Source: https://docs.langchain.com/oss/python/integrations/vectorstores/qdrant

Install the langchain-qdrant package using pip. This is the required setup step before using Qdrant with LangChain.

```bash
pip install -qU langchain-qdrant

```

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

### Docstring link to extended thinking guide

Source: https://docs.langchain.com/oss/python/contributing/code

Shows how to link to a feature guide in a docstring instead of including extended walkthroughs. The example is a docstring fragment with a link to the extended thinking guide.

```python
"""
...

See the [extended thinking guide](https://docs.langchain.com/oss/integrations/chat/anthropic#extended-thinking)
for configuration options.
"""

```

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

### Enable task planning with TodoListMiddleware for different model providers

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

Enable task planning by passing TodoListMiddleware to the middleware parameter. Each example uses a different model provider (Google, OpenAI, Anthropic, OpenRouter, Fireworks, Baseten, Ollama) but the same setup. Task planning is opt-in starting in v0.7; earlier versions included it by default.

```python
from deepagents import create_deep_agent
from langchain.agents.middleware import TodoListMiddleware

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    middleware=[TodoListMiddleware()],
)

```

```python
from deepagents import create_deep_agent
from langchain.agents.middleware import TodoListMiddleware

agent = create_deep_agent(
    model="openai:gpt-5.5",
    middleware=[TodoListMiddleware()],
)

```

```python
from deepagents import create_deep_agent
from langchain.agents.middleware import TodoListMiddleware

agent = create_deep_agent(
    model="anthropic:claude-sonnet-5",
    middleware=[TodoListMiddleware()],
)

```

```python
from deepagents import create_deep_agent
from langchain.agents.middleware import TodoListMiddleware

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    middleware=[TodoListMiddleware()],
)

```

```python
from deepagents import create_deep_agent
from langchain.agents.middleware import TodoListMiddleware

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    middleware=[TodoListMiddleware()],
)

```

```python
from deepagents import create_deep_agent
from langchain.agents.middleware import TodoListMiddleware

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    middleware=[TodoListMiddleware()],
)

```

```python
from deepagents import create_deep_agent
from langchain.agents.middleware import TodoListMiddleware

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    middleware=[TodoListMiddleware()],
)

```

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

### Create demo table and insert sample documents

Source: https://docs.langchain.com/oss/python/integrations/document_loaders/oracleai

Create a demo table and insert sample documents. Uses the connection object from the previous example. On failure, prints an error and exits.

```python
try:
    cursor = conn.cursor()

    drop_table_sql = """drop table if exists demo_tab"""
    cursor.execute(drop_table_sql)

    create_table_sql = """create table demo_tab (id number, data clob)"""
    cursor.execute(create_table_sql)

    insert_row_sql = """insert into demo_tab values (:1, :2)"""
    rows_to_insert = [
        (
            1,
            "If the answer to any preceding questions is yes, then the database stops the search and allocates space from the specified tablespace; otherwise, space is allocated from the database default shared temporary tablespace.",
        ),
        (
            2,
            "A tablespace can be online (accessible) or offline (not accessible) whenever the database is open.\nA tablespace is usually online so that its data is available to users. The SYSTEM tablespace and temporary tablespaces cannot be taken offline.",
        ),
        (
            3,
            "The database stores LOBs differently from other data types. Creating a LOB column implicitly creates a LOB segment and a LOB index. The tablespace containing the LOB segment and LOB index, which are always stored together, may be different from the tablespace containing the table.\nSometimes the database can store small amounts of LOB data in the table itself rather than in a separate LOB segment.",
        ),
    ]
    cursor.executemany(insert_row_sql, rows_to_insert)

    conn.commit()

    print("Table created and populated.")
    cursor.close()
except Exception as e:
    print("Table creation failed.")
    cursor.close()
    conn.close()
    sys.exit(1)

```

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

### Set up Python environment with uv and run tests

Source: https://docs.langchain.com/oss/python/contributing/code

Run from the package directory to set up dependencies and verify unit tests pass before starting development. Requires the latest version of uv.

```bash
uv sync --all-groups
make test  # Verify unit tests pass before starting development

```

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

### Ollama embeddings setup

Source: https://docs.langchain.com/oss/python/integrations/vectorstores

Install the langchain-ollama package and create an OllamaEmbeddings instance using the nomic-embed-text model. No API key setup is shown.

```bash
pip install -qU langchain-ollama

```

```python
from langchain_ollama import OllamaEmbeddings

embeddings = OllamaEmbeddings(model="nomic-embed-text")

```

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

### Install dependencies with uv

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

Initializes a uv project, adds required dependencies, and syncs the environment.

```bash
uv init
uv add deepagents google-genai pillow pyyaml rich tavily-python langchain
uv sync

```

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

### Install Switchyard and langchain-nvidia integration

Source: https://docs.langchain.com/oss/python/integrations/middleware/nvidia

Clone and install NeMo Switchyard's libsy Python bindings from source, then install the langchain-nvidia switchyard integration with OpenRouter dependencies. Requires Python 3.12+ and OPENROUTER_API_KEY for the OpenRouter example.

```bash
git clone https://github.com/NVIDIA-NeMo/Switchyard.git
python -m pip install -e ./Switchyard

git clone https://github.com/langchain-ai/langchain-nvidia.git
python -m pip install -e "./langchain-nvidia/libs/switchyard[openrouter]"

```

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

### Install langchain-oci and oci using uv

Source: https://docs.langchain.com/oss/python/integrations/embeddings/oci_generative_ai

Install the OCI LangChain partner package and OCI SDK using uv.

```bash
uv add langchain-oci oci

```

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

### Get structured output with with_structured_output

Source: https://docs.langchain.com/oss/python/integrations/chat/crusoe

Uses with_structured_output with a Pydantic Joke schema to get a structured response. The output is a Joke instance with setup, punchline, and rating fields.

```python
from pydantic import BaseModel, Field
from typing import Optional

class Joke(BaseModel):
    """Joke to tell user."""
    setup: str = Field(description="The setup of the joke")
    punchline: str = Field(description="The punchline to the joke")
    rating: Optional[int] = Field(description="How funny the joke is, from 1 to 10")

structured_llm = llm.with_structured_output(Joke)
structured_llm.invoke("Tell me a joke about cats")

```

```text
Joke(setup='Why was the cat sitting on the computer?', punchline='To keep an eye on the mouse!', rating=7)

```

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

### Quickstart with Ollama (ollama:north-mini-code-1.0)

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

Creates a deep agent using the Ollama model 'ollama:north-mini-code-1.0' with a weather tool and a system prompt, then invokes it with a user message.

```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"}]}
)
```

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

### Install legacy InstructorEmbedding dependencies

Source: https://docs.langchain.com/oss/python/integrations/embeddings/instruct_embeddings

Install the legacy langchain-community package and dependencies required for HuggingFaceInstructEmbeddings. Note that langchain-community is no longer maintained and examples using it may be outdated or broken.

```bash
pip install -qU langchain-community InstructorEmbedding sentence-transformers

```

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

### 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)

```

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

### Provide input examples for tools with extras

Source: https://docs.langchain.com/oss/python/integrations/chat/anthropic

Use this snippet to provide usage examples for complex tools by setting `input_examples` in the tool's `extras` parameter. This helps Claude understand how to use the tool correctly. The example defines a `search_weather_data` tool with two input examples and binds it to a ChatAnthropic model.

```python
from langchain_anthropic import ChatAnthropic
from langchain.tools import tool

@tool(
    extras={
        "input_examples": [
            {
                "query": "weather report",
                "location": "San Francisco",
                "format": "detailed"
            },
            {
                "query": "temperature",
                "location": "New York",
                "format": "brief"
            }
        ]
    }
)
def search_weather_data(query: str, location: str, format: str = "brief") -> str:
    """Search weather database with specific query and format preferences.

    Args:
        query: The type of weather information to retrieve
        location: City or region to search
        format: Output format, either 'brief' or 'detailed'
    """
    return f"{format.title()} {query} for {location}: Data found"

model = ChatAnthropic(model="claude-sonnet-4-6")
model_with_tools = model.bind_tools([search_weather_data])

response = model_with_tools.invoke(
    "Get me a detailed weather report for Seattle"
)

```

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

### Install Kùzu and LangChain dependencies

Source: https://docs.langchain.com/oss/python/integrations/graphs/kuzu_db

Installs the Kùzu LangChain integration, the OpenAI Python package, and related packages. The langchain-experimental package is no longer maintained and examples using it may be outdated or broken.

```bash
pip install -U langchain-kuzu langchain-openai langchain-experimental langchain-neo4j

```

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

### Run agent with example query

Source: https://docs.langchain.com/oss/python/integrations/tools/google_gmail

Execute the agent with a sample query to draft an email, streaming events and printing messages.

```python
example_query = "Draft an email to fake@fake.com thanking them for coffee."

stream = agent_executor.stream_events(
    {"messages": [("user", example_query)]},
    version="v3",
)
for snapshot in stream.values:
    snapshot["messages"][-1].pretty_print()

```

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

### Install with uv

Source: https://docs.langchain.com/oss/python/integrations/providers/egnyte

Install the egnyte-langchain-connector package using uv.

```bash
uv add egnyte-langchain-connector

```

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

### Add examples in the cypher generation prompt

Source: https://docs.langchain.com/oss/python/integrations/graphs/neo4j_cypher

Define a custom Cypher generation prompt with examples to guide the LLM. The template includes a few-shot example for counting actors, and the chain uses it via cypher_prompt. The invocation shows the generated Cypher and the final natural language answer.

```python
from langchain_core.prompts.prompt import PromptTemplate

CYPHER_GENERATION_TEMPLATE = """Task:Generate Cypher statement to query a graph database.
Instructions:
Use only the provided relationship types and properties in the schema.
Do not use any other relationship types or properties that are not provided.
Schema:
{schema}
Note: Do not include any explanations or apologies in your responses.
Do not respond to any questions that might ask anything else than for you to construct a Cypher statement.
Do not include any text except the generated Cypher statement.
Examples: Here are a few examples of generated Cypher statements for particular questions:
# How many people played in Top Gun?
MATCH (m:Movie {{name:"Top Gun"}})<-[:ACTED_IN]-()
RETURN count(*) AS numberOfActors

The question is:
{question}"""

CYPHER_GENERATION_PROMPT = PromptTemplate(
    input_variables=["schema", "question"], template=CYPHER_GENERATION_TEMPLATE
)

chain = GraphCypherQAChain.from_llm(
    ChatOpenAI(temperature=0),
    graph=graph,
    verbose=True,
    cypher_prompt=CYPHER_GENERATION_PROMPT,
    allow_dangerous_requests=True,
)

```

```python
chain.invoke({"query": "How many people played in Top Gun?"})

```

```text
> Entering new GraphCypherQAChain chain...
Generated Cypher:
MATCH (m:Movie {name:"Top Gun"})<-[:ACTED_IN]-()
RETURN count(*) AS numberOfActors
Full Context:
[{'numberOfActors': 4}]

> Finished chain.

```

```python
{'query': 'How many people played in Top Gun?',
 'result': 'There were 4 actors in Top Gun.'}

```

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

### 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)

```

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

### Structured output result

Source: https://docs.langchain.com/oss/python/integrations/chat/sambanova

Example output from the structured LLM invocation, showing the Joke object with setup and punchline.

```python
Joke(setup='Why did the cat join a band?', punchline='Because it wanted to be the purr-cussionist!')

```

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

### Run the RAG agent with example query

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

Runs the RAG agent with an example query about streaming intermediate tool results from a subagent. Prints the text of each message in the result. Requires the agent variable from the previous setup snippet.

```python
from langchain.messages import HumanMessage

EXAMPLE_QUERY = "How do I stream intermediate tool results from a subagent?"

if __name__ == "__main__":
    result = agent.invoke(
        {"messages": [HumanMessage(content=EXAMPLE_QUERY)]}
    )

    for msg in result.get("messages", []):
        if msg.text:
            print(msg.text)

```

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

### Quickstart with Fireworks (fireworks:accounts/fireworks/models/glm-5p2)

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

Creates a deep agent using the Fireworks model 'fireworks:accounts/fireworks/models/glm-5p2' with a weather tool and a system prompt, then invokes it with a user message.

```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"}]}
)
```

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

### Good docstring example for ChatAnthropic

Source: https://docs.langchain.com/oss/python/contributing/code

Illustrates the required docstring structure for public classes: one-line summary, link to usage guide, parameter documentation, return description, exceptions, and a minimal usage example. The example shows a chat model class with a docstring that includes a nested Python code block.

```python
class ChatAnthropic(BaseChatModel):
    """Interface to Claude chat models.

    See the [usage guide](https://docs.langchain.com/oss/python/integrations/chat/anthropic)
    for tutorials, feature walkthroughs, and examples.

    Args:
        model: Model identifier (e.g., `'claude-sonnet-4-6'`).
        temperature: Sampling temperature between `0` and `1`.
        max_tokens: Maximum number of tokens to generate.
        api_key: Anthropic API key.

            If not provided, reads from the `ANTHROPIC_API_KEY`
            environment variable.
        timeout: Request timeout in seconds.
        max_retries: Maximum number of retries for failed requests.

    Returns:
        A chat model instance that can be invoked with messages.

    Raises:
        ValueError: If the model identifier is not recognized.
        AuthenticationError: If the API key is invalid.

    Example:
        ```python
        from langchain_anthropic import ChatAnthropic

        model = ChatAnthropic(model="claude-sonnet-4-6")
        response = model.invoke("Hello!")
        ```
    """

```

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

### Install langchain-box with uv

Source: https://docs.langchain.com/oss/python/integrations/providers/box

Install the langchain-box package using uv.

```bash
uv add langchain-box

```

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

### Clone and install Stagehand integration

Source: https://docs.langchain.com/oss/python/integrations/tools/stagehand

Commands to clone the Stagehand repository and sync dependencies for the deepagents integration and the local example project.

```bash
git clone https://github.com/browserbase/stagehand.git
cd stagehand/packages/integrations/deepagents
uv sync --locked
uv sync --project examples/local --locked

```

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

### 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)

```

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

### Install langchain-pinecone with uv

Source: https://docs.langchain.com/oss/python/integrations/providers/pinecone

Install the langchain-pinecone Python SDK using uv.

```bash
uv add langchain-pinecone

```

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

### Create agent with long-term memory using Baseten model

Source: https://docs.langchain.com/oss/python/langchain/long-term-memory

Same setup as the OpenRouter example but uses the Baseten model 'baseten:zai-org/GLM-5.2'.

```python
from dataclasses import dataclass

from langchain.agents import create_agent
from langchain.tools import ToolRuntime, tool
from langchain_core.runnables import Runnable
from langgraph.store.memory import InMemoryStore


@dataclass
class Context:
    user_id: str


# InMemoryStore saves data to an in-memory dictionary. Use a DB-backed store in production.
store = InMemoryStore()

# Write sample data to the store using the put method
store.put(
    (
        "users",
    ),  # Namespace to group related data together (users namespace for user data)
    "user_123",  # Key within the namespace (user ID as key)
    {
        "name": "John Smith",
        "language": "English",
    },  # Data to store for the given user
)


@tool
def get_user_info(runtime: ToolRuntime[Context]) -> str:
    """Look up user info."""
    # Access the store - same as that provided to `create_agent`
    assert runtime.store is not None
    user_id = runtime.context.user_id
    # Retrieve data from store - returns StoreValue object with value and metadata
    user_info = runtime.store.get(("users",), user_id)
    return str(user_info.value) if user_info else "Unknown user"


agent: Runnable = create_agent(
    model="baseten:zai-org/GLM-5.2",
    tools=[get_user_info],
    # Pass store to agent - enables agent to access store when running tools
    store=store,
    context_schema=Context,
)

# Run the agent
agent.invoke(
    {"messages": [{"role": "user", "content": "look up user information"}]},
    context=Context(user_id="user_123"),
)

```

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

### Install dependencies with pip or uv

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

Installs the required dependencies for the tutorial. The pip command is for pip users, while the uv commands are for uv users.

```bash
pip install deepagents "langchain[openai]" langchain-text-splitters requests numpy

```

```bash
uv init
uv add deepagents langchain "langchain[openai]" langchain-text-splitters requests numpy
uv sync

```

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

### Create agent with long-term memory using Fireworks model

Source: https://docs.langchain.com/oss/python/langchain/long-term-memory

Same setup as the OpenRouter example but uses the Fireworks model 'fireworks:accounts/fireworks/models/glm-5p2'.

```python
from dataclasses import dataclass

from langchain.agents import create_agent
from langchain.tools import ToolRuntime, tool
from langchain_core.runnables import Runnable
from langgraph.store.memory import InMemoryStore


@dataclass
class Context:
    user_id: str


# InMemoryStore saves data to an in-memory dictionary. Use a DB-backed store in production.
store = InMemoryStore()

# Write sample data to the store using the put method
store.put(
    (
        "users",
    ),  # Namespace to group related data together (users namespace for user data)
    "user_123",  # Key within the namespace (user ID as key)
    {
        "name": "John Smith",
        "language": "English",
    },  # Data to store for the given user
)


@tool
def get_user_info(runtime: ToolRuntime[Context]) -> str:
    """Look up user info."""
    # Access the store - same as that provided to `create_agent`
    assert runtime.store is not None
    user_id = runtime.context.user_id
    # Retrieve data from store - returns StoreValue object with value and metadata
    user_info = runtime.store.get(("users",), user_id)
    return str(user_info.value) if user_info else "Unknown user"


agent: Runnable = create_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    tools=[get_user_info],
    # Pass store to agent - enables agent to access store when running tools
    store=store,
    context_schema=Context,
)

# Run the agent
agent.invoke(
    {"messages": [{"role": "user", "content": "look up user information"}]},
    context=Context(user_id="user_123"),
)

```

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

### Set up Elasticsearch vector store

Source: https://docs.langchain.com/oss/python/integrations/vectorstores

Install langchain-elasticsearch and start Elasticsearch locally using the start-local script. Then create an ElasticsearchStore pointing to the local instance.

```bash
pip install -qU langchain-elasticsearch
curl -fsSL https://elastic.co/start-local | sh
```

```bash
cd elastic-start-local
./start.sh
```

```python
from langchain_elasticsearch import ElasticsearchStore

vector_store = ElasticsearchStore(
    index_name="langchain-demo",
    embedding=embeddings,
    es_url="http://localhost:9200",
)
```

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

### Example output from quick discovery

Source: https://docs.langchain.com/oss/python/integrations/tools/parallel_findall

Sample output showing candidate names and URLs.

```text
Anthropic — https://www.anthropic.com
OpenAI — https://www.openai.com
...

```

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

### Integration test for OpenAI chat with @pytest.mark.requires

Source: https://docs.langchain.com/oss/python/contributing/code

Integration test example that requires the 'openai' package. Uses the @pytest.mark.requires decorator to skip the test if the dependency is not installed.

```python
@pytest.mark.requires("openai")
def test_openai_chat_integration():
    """Test OpenAI chat integration with real API."""

    chat = ChatOpenAI()
    response = chat.invoke("Hello")

    assert isinstance(response.content, str)
    assert len(response.content) > 0

```

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

### Output of create_documents example

Source: https://docs.langchain.com/oss/python/integrations/splitters/recursive_text_splitter

Output of the previous create_documents example showing the first two Document objects.

```text
page_content='Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and'
page_content='of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans.'

```

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

### Clone and run Agent Chat UI from repository

Source: https://docs.langchain.com/oss/python/langgraph/ui

Clones the official agent-chat-ui repository from GitHub, installs package dependencies with pnpm, and starts the Next.js development server.

```bash
# Clone the repository
git clone https://github.com/langchain-ai/agent-chat-ui.git
cd agent-chat-ui

# Install dependencies and start
pnpm install
pnpm dev
```

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

### Get Box Developer Token

Source: https://docs.langchain.com/oss/python/integrations/retrievers/box

Prompts for a Box Developer Token using getpass and stores it in the variable box_developer_token. This token is used for authentication in the Box retriever examples.

```python
import getpass
import os

box_developer_token = getpass.getpass("Enter your Box Developer Token: ")

```
Tokens:
Raw