ChatAnthropic integration

pip install -U langchain-anthropic

uv add langchain-anthropic

from langchain_anthropic import ChatAnthropic
from langchain.messages import HumanMessage

model = ChatAnthropic(model="claude-sonnet-4-6")

message = HumanMessage(
    content=[
        {"type": "text", "text": "Describe the image at the URL."},
        {
            "type": "image",
            "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg",
        },
    ]
)
response = model.invoke([message])

import base64
import httpx
from langchain_anthropic import ChatAnthropic
from langchain.messages import HumanMessage

model = ChatAnthropic(model="claude-sonnet-4-6")

image_url = "https://picsum.photos/id/237/200/300"
image_data = base64.b64encode(httpx.get(image_url, follow_redirects=True).content).decode("utf-8")

message = HumanMessage(
    content=[
        {"type": "text", "text": "Describe the image."},
        { # [!code highlight]
            "type": "image", # [!code highlight]
            "base64": image_data, # [!code highlight]
            "mime_type": "image/jpeg", # [!code highlight]
        }, # [!code highlight]
    ]
)
response = model.invoke([message])

import anthropic
from langchain_anthropic import ChatAnthropic
from langchain.messages import HumanMessage

client = anthropic.Anthropic()
file = client.beta.files.upload(
    file=("image.png", open("/path/to/image.png", "rb"), "image/png"),
)

model = ChatAnthropic(
    model="claude-sonnet-4-6",
    betas=["files-api-2025-04-14"], # [!code highlight]
)

message = HumanMessage(
    content=[
        {"type": "text", "text": "Describe this image."},
        {
            "type": "image",
            "file_id": file.id, # [!code highlight]
        },
    ]
)
response = model.invoke([message])

from langchain_anthropic import ChatAnthropic
from langchain.messages import HumanMessage

model = ChatAnthropic(model="claude-sonnet-4-6")

message = HumanMessage(
    content=[
        {"type": "text", "text": "Summarize this document."},
        {
            "type": "file",
            "url": "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf",
            "mime_type": "application/pdf",
        },
    ]
)
response = model.invoke([message])

import base64
import httpx
from langchain_anthropic import ChatAnthropic
from langchain.messages import HumanMessage

model = ChatAnthropic(model="claude-sonnet-4-6")

pdf_url = "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf"
pdf_data = base64.b64encode(httpx.get(pdf_url).content).decode("utf-8")

message = HumanMessage(
    content=[
        {"type": "text", "text": "Summarize this document."},
        {
            "type": "file",
            "base64": pdf_data, # [!code highlight]
            "mime_type": "application/pdf", # [!code highlight]
        },
    ]
)
response = model.invoke([message])

import anthropic
from langchain_anthropic import ChatAnthropic
from langchain.messages import HumanMessage

client = anthropic.Anthropic()
file = client.beta.files.upload(
    file=("document.pdf", open("/path/to/document.pdf", "rb"), "application/pdf"),
)

model = ChatAnthropic(
    model="claude-sonnet-4-6",
    betas=["files-api-2025-04-14"], # [!code highlight]
)

message = HumanMessage(
    content=[
        {"type": "text", "text": "Summarize this document."},
        {
            "type": "file",
            "file_id": file.id, # [!code highlight]
        },
    ]
)
response = model.invoke([message])

import json
from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(
    model="claude-sonnet-4-6",
    max_tokens=5000,
    thinking={"type": "enabled", "budget_tokens": 2000}, # [!code highlight]
)

response = model.invoke("What is the cube root of 50.653?")
print(json.dumps(response.content_blocks, indent=2))

import json
from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(
    model="claude-opus-4-8",
    max_tokens=5000,
    thinking={"type": "adaptive"}, # [!code highlight]
)

response = model.invoke("What is the cube root of 50.653?")
print(json.dumps(response.content_blocks, indent=2))

import json
from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(model="claude-sonnet-4-6")

response = model.invoke(
    "What is the cube root of 50.653?",
    max_tokens=5000,
    thinking={"type": "enabled", "budget_tokens": 2000} # [!code highlight]
)
print(json.dumps(response.content_blocks, indent=2))

import subprocess

from anthropic.types.beta import BetaToolBash20250124Param  # [!code highlight]
from langchain_anthropic import ChatAnthropic
from langchain.messages import HumanMessage, ToolMessage
from langchain.tools import tool

tool_spec = BetaToolBash20250124Param(  # [!code highlight]
    name="bash",  # [!code highlight]
    type="bash_20250124",  # [!code highlight]
)  # [!code highlight]


@tool(extras={"provider_tool_definition": tool_spec})  # [!code highlight]
def bash(*, command: str, restart: bool = False, **kw):
    """Execute a bash command."""
    if restart:
        return "Bash session restarted"
    try:
        result = subprocess.run(
            command,
            shell=True,
            capture_output=True,
            text=True,
            timeout=30,
        )
        return result.stdout + result.stderr
    except Exception as e:
        return f"Error: {e}"


model = ChatAnthropic(model="claude-sonnet-4-6")
model_with_bash = model.bind_tools([bash]) # [!code highlight]

# Initial request
messages = [HumanMessage("List all files in the current directory")]
response = model_with_bash.invoke(messages)
print(response.content_blocks)

# Tool execution loop
while response.tool_calls:
    # Execute each tool call
    tool_messages = []
    for tool_call in response.tool_calls:
        result = bash.invoke(tool_call)
        tool_messages.append(result)

    # Continue conversation with tool results
    messages = [*messages, response, *tool_messages]
    response = model_with_bash.invoke(messages)
    print(response.content_blocks)

import subprocess

from anthropic.types.beta import BetaToolBash20250124Param # [!code highlight]
from langchain.agents import create_agent
from langchain_anthropic import ChatAnthropic
from langchain.tools import tool

tool_spec = BetaToolBash20250124Param( # [!code highlight]
    name="bash", # [!code highlight]
    type="bash_20250124", # [!code highlight]
) # [!code highlight]


@tool(extras={"provider_tool_definition": tool_spec}) # [!code highlight]
def bash(*, command: str, restart: bool = False, **kw):
    """Execute a bash command."""
    if restart:
        return "Bash session restarted"
    result = subprocess.run(
        command,
        shell=True,
        capture_output=True,
        text=True,
    )
    return result.stdout + result.stderr


agent = create_agent(
    model=ChatAnthropic(model="claude-sonnet-4-6"),
    tools=[bash],  # [!code highlight]
)

result = agent.invoke({"messages": [{"role": "user", "content": "List files"}]})

for message in result["messages"]:
    message.pretty_print()

from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(model="claude-sonnet-4-6")

bash_tool = { # [!code highlight]
    "type": "bash_20250124", # [!code highlight]
    "name": "bash", # [!code highlight]
} # [!code highlight]

model_with_bash = model.bind_tools([bash_tool]) # [!code highlight]
response = model_with_bash.invoke(
    "List all Python files in the current directory"
)
# You must handle execution of the bash command in response.tool_calls via a tool execution loop

[{'type': 'text',
'text': "I'll list the Python files in the current directory for you."},
{'type': 'tool_call',
'name': 'bash',
'args': {'command': 'ls -la *.py'},
'id': 'toolu_01ABC123...'}]

from anthropic.types.beta import BetaCodeExecutionTool20250825Param # [!code highlight]
from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(
    model="claude-sonnet-4-6",
    # (Optional) Enable the param below to automatically
    # pass back in container IDs from previous response
    reuse_last_container=True,
)

code_tool = BetaCodeExecutionTool20250825Param( # [!code highlight]
    name="code_execution", # [!code highlight]
    type="code_execution_20250825", # [!code highlight]
) # [!code highlight]
model_with_tools = model.bind_tools([code_tool]) # [!code highlight]

response = model_with_tools.invoke(
    "Calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
)

from anthropic.types.beta import BetaCodeExecutionTool20250825Param # [!code highlight]
from langchain.agents import create_agent
from langchain_anthropic import ChatAnthropic

code_tool = BetaCodeExecutionTool20250825Param( # [!code highlight]
    name="code_execution", # [!code highlight]
    type="code_execution_20250825", # [!code highlight]
) # [!code highlight]

agent = create_agent(
    model=ChatAnthropic(model="claude-sonnet-4-6"),
    tools=[code_tool],  # [!code highlight]
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "Calculate mean and std of [1,2,3,4,5]"}]
})

for message in result["messages"]:
    message.pretty_print()

from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(
    model="claude-sonnet-4-6",
)

code_tool = {"type": "code_execution_20250825", "name": "code_execution"} # [!code highlight]
model_with_tools = model.bind_tools([code_tool])

response = model_with_tools.invoke(
    "Calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
)

import base64
from typing import Literal

from anthropic.types.beta import BetaToolComputerUse20250124Param # [!code highlight]
from langchain_anthropic import ChatAnthropic
from langchain.messages import HumanMessage, ToolMessage
from langchain.tools import tool

DISPLAY_WIDTH = 1024
DISPLAY_HEIGHT = 768

tool_spec = BetaToolComputerUse20250124Param( # [!code highlight]
    name="computer", # [!code highlight]
    type="computer_20250124", # [!code highlight]
    display_width_px=DISPLAY_WIDTH, # [!code highlight]
    display_height_px=DISPLAY_HEIGHT, # [!code highlight]
    display_number=1, # [!code highlight]
) # [!code highlight]

@tool(extras={"provider_tool_definition": tool_spec}) # [!code highlight]
def computer(
    *,
    action: Literal[
        "key", "type", "mouse_move", "left_click", "left_click_drag",
        "right_click", "middle_click", "double_click", "screenshot",
        "cursor_position", "scroll"
    ],
    coordinate: list[int] | None = None,
    text: str | None = None,
    **kw
):
    """Control the computer display."""
    if action == "screenshot":
        # Take screenshot and return base64-encoded image
        # Implementation depends on your display setup (e.g., Xvfb, pyautogui)
        return {"type": "image", "data": "base64_screenshot_data..."}
    elif action == "left_click" and coordinate:
        # Execute click at coordinate
        return f"Clicked at {coordinate}"
    elif action == "type" and text:
        # Type text
        return f"Typed: {text}"
    # ... implement other actions
    return f"Executed {action}"

model = ChatAnthropic(model="claude-sonnet-4-6")
model_with_computer = model.bind_tools([computer]) # [!code highlight]

# Initial request
messages = [HumanMessage("Take a screenshot to see what's on the screen")]
response = model_with_computer.invoke(messages)
print(response.content_blocks)

# Tool execution loop
while response.tool_calls:
    tool_messages = []
    for tool_call in response.tool_calls:
        result = computer.invoke(tool_call)
        tool_messages.append(
            ToolMessage(content=str(result), tool_call_id=tool_call["id"])
        )

    messages = [*messages, response, *tool_messages]
    response = model_with_computer.invoke(messages)
    print(response.content_blocks)

from typing import Literal

from anthropic.types.beta import BetaToolComputerUse20250124Param # [!code highlight]
from langchain.agents import create_agent
from langchain_anthropic import ChatAnthropic
from langchain.tools import tool

tool_spec = BetaToolComputerUse20250124Param( # [!code highlight]
    name="computer", # [!code highlight]
    type="computer_20250124", # [!code highlight]
    display_width_px=1024, # [!code highlight]
    display_height_px=768, # [!code highlight]
) # [!code highlight]


@tool(extras={"provider_tool_definition": tool_spec}) # [!code highlight]
def computer(
    *,
    action: Literal[
        "key", "type", "mouse_move", "left_click", "left_click_drag",
        "right_click", "middle_click", "double_click", "screenshot",
        "cursor_position", "scroll"
    ],
    coordinate: list[int] | None = None,
    text: str | None = None,
    **kw
):
    """Control the computer display."""
    if action == "screenshot":
        return {"type": "image", "data": "base64_screenshot_data..."}
    elif action == "left_click" and coordinate:
        return f"Clicked at {coordinate}"
    elif action == "type" and text:
        return f"Typed: {text}"
    return f"Executed {action}"


agent = create_agent(
    model=ChatAnthropic(model="claude-sonnet-4-6"),
    tools=[computer],  # [!code highlight]
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "Take a screenshot"}]
})

for message in result["messages"]:
    message.pretty_print()

from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(model="claude-sonnet-4-6")

computer_tool = {
    "type": "computer_20250124",
    "name": "computer",
    "display_width_px": 1024,
    "display_height_px": 768,
    "display_number": 1,
}

model_with_computer = model.bind_tools([computer_tool]) # [!code highlight]
response = model_with_computer.invoke(
    "Take a screenshot to see what's on the screen"
)
# You must handle execution of the computer actions in response.tool_calls via a tool execution loop

[{'type': 'text',
'text': "I'll take a screenshot to see what's currently on the screen."},
{'type': 'tool_call',
'name': 'computer',
'args': {'action': 'screenshot'},
'id': 'toolu_01RNsqAE7dDZujELtacNeYv9'}]

from anthropic.types.beta import BetaMCPToolsetParam # [!code highlight]
from langchain_anthropic import ChatAnthropic

mcp_servers = [
    {
        "type": "url",
        "url": "https://docs.langchain.com/mcp",
        "name": "LangChain Docs",
    }
]

model = ChatAnthropic(
    model="claude-sonnet-4-6",
    mcp_servers=mcp_servers, # [!code highlight]
)

mcp_tool = BetaMCPToolsetParam( # [!code highlight]
    type="mcp_toolset", # [!code highlight]
    mcp_server_name="LangChain Docs", # [!code highlight]
) # [!code highlight]

response = model.invoke(
    "What are LangChain content blocks?",
    tools=[mcp_tool], # [!code highlight]
)

from anthropic.types.beta import BetaMCPToolsetParam # [!code highlight]
from langchain.agents import create_agent
from langchain_anthropic import ChatAnthropic

mcp_servers = [
    {
        "type": "url",
        "url": "https://docs.langchain.com/mcp",
        "name": "LangChain Docs",
    }
]

mcp_tool = BetaMCPToolsetParam( # [!code highlight]
    type="mcp_toolset", # [!code highlight]
    mcp_server_name="LangChain Docs", # [!code highlight]
) # [!code highlight]

agent = create_agent(
    model=ChatAnthropic(
        model="claude-sonnet-4-6",
        mcp_servers=mcp_servers,  # [!code highlight]
    ),
    tools=[mcp_tool],  # [!code highlight]
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "What are LangChain content blocks?"}]
})

for message in result["messages"]:
    message.pretty_print()

from langchain_anthropic import ChatAnthropic

mcp_servers = [
    {
        "type": "url",
        "url": "https://docs.langchain.com/mcp",
        "name": "LangChain Docs",
        # "tool_configuration": {  # optional configuration
        #     "enabled": True,
        #     "allowed_tools": ["ask_question"],
        # },
        # "authorization_token": "PLACEHOLDER",  # optional authorization if needed
    }
]

model = ChatAnthropic(
    model="claude-sonnet-4-6",
    mcp_servers=mcp_servers, # [!code highlight]
)

response = model.invoke(
    "What are LangChain content blocks?",
    tools=[{"type": "mcp_toolset", "mcp_server_name": "LangChain Docs"}], # [!code highlight]
)
response.content_blocks

from typing import Literal

from anthropic.types.beta import BetaToolTextEditor20250728Param # [!code highlight]
from langchain_anthropic import ChatAnthropic
from langchain.messages import HumanMessage, ToolMessage
from langchain.tools import tool

tool_spec = BetaToolTextEditor20250728Param( # [!code highlight]
    name="str_replace_based_edit_tool", # [!code highlight]
    type="text_editor_20250728", # [!code highlight]
) # [!code highlight]

# Simple in-memory file storage for demonstration
files: dict[str, str] = {
    "/workspace/primes.py": "def is_prime(n):\n    if n < 2\n        return False\n    return True"
}

@tool(extras={"provider_tool_definition": tool_spec}) # [!code highlight]
def str_replace_based_edit_tool(
    *,
    command: Literal["view", "create", "str_replace", "insert", "undo_edit"],
    path: str,
    file_text: str | None = None,
    old_str: str | None = None,
    new_str: str | None = None,
    insert_line: int | None = None,
    view_range: list[int] | None = None,
    **kw
):
    """View and edit text files."""
    if command == "view":
        if path not in files:
            return f"Error: File {path} not found"
        content = files[path]
        if view_range:
            lines = content.splitlines()
            start, end = view_range[0] - 1, view_range[1]
            return "\n".join(lines[start:end])
        return content
    elif command == "create":
        files[path] = file_text or ""
        return f"Created {path}"
    elif command == "str_replace" and old_str is not None:
        if path not in files:
            return f"Error: File {path} not found"
        files[path] = files[path].replace(old_str, new_str or "", 1)
        return f"Replaced in {path}"
    # ... implement other commands
    return f"Executed {command} on {path}"

model = ChatAnthropic(model="claude-sonnet-4-6")
model_with_tools = model.bind_tools([str_replace_based_edit_tool]) # [!code highlight]

# Initial request
messages = [HumanMessage("There's a syntax error in my primes.py file. Can you fix it?")]
response = model_with_tools.invoke(messages)
print(response.content_blocks)

# Tool execution loop
while response.tool_calls:
    tool_messages = []
    for tool_call in response.tool_calls:
        result = str_replace_based_edit_tool.invoke(tool_call)
        tool_messages.append(
            ToolMessage(content=result, tool_call_id=tool_call["id"])
        )

    messages = [*messages, response, *tool_messages]
    response = model_with_tools.invoke(messages)
    print(response.content_blocks)

from typing import Literal

from anthropic.types.beta import BetaToolTextEditor20250728Param # [!code highlight]
from langchain.agents import create_agent
from langchain_anthropic import ChatAnthropic
from langchain.tools import tool

# Simple in-memory file storage
files: dict[str, str] = {
    "/workspace/primes.py": "def is_prime(n):\n    if n < 2\n        return False\n    return True"
}

tool_spec = BetaToolTextEditor20250728Param( # [!code highlight]
    name="str_replace_based_edit_tool", # [!code highlight]
    type="text_editor_20250728", # [!code highlight]
) # [!code highlight]


@tool(extras={"provider_tool_definition": tool_spec}) # [!code highlight]
def str_replace_based_edit_tool(
    *,
    command: Literal["view", "create", "str_replace", "insert", "undo_edit"],
    path: str,
    file_text: str | None = None,
    old_str: str | None = None,
    new_str: str | None = None,
    **kw
):
    """View and edit text files."""
    if command == "view":
        return files.get(path, f"Error: File {path} not found")
    elif command == "create":
        files[path] = file_text or ""
        return f"Created {path}"
    elif command == "str_replace" and old_str is not None:
        if path not in files:
            return f"Error: File {path} not found"
        files[path] = files[path].replace(old_str, new_str or "", 1)
        return f"Replaced in {path}"
    return f"Executed {command} on {path}"


agent = create_agent(
    model=ChatAnthropic(model="claude-sonnet-4-6"),
    tools=[str_replace_based_edit_tool],  # [!code highlight]
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "Fix the syntax error in /workspace/primes.py"}]
})

for message in result["messages"]:
    message.pretty_print()

from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(model="claude-sonnet-4-6")

editor_tool = {"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"} # [!code highlight]

model_with_tools = model.bind_tools([editor_tool]) # [!code highlight]

response = model_with_tools.invoke(
    "There's a syntax error in my primes.py file. Can you help me fix it?"
)
# You must handle execution of the text editor commands in response.tool_calls via a tool execution loop

[{'name': 'str_replace_based_edit_tool',
'args': {'command': 'view', 'path': '/root'},
'id': 'toolu_011BG5RbqnfBYkD8qQonS9k9',
'type': 'tool_call'}]

from anthropic.types.beta import BetaWebFetchTool20250910Param # [!code highlight]
from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(model="claude-haiku-4-5-20251001")

fetch_tool = BetaWebFetchTool20250910Param( # [!code highlight]
    name="web_fetch", # [!code highlight]
    type="web_fetch_20250910", # [!code highlight]
    max_uses=3, # [!code highlight]
) # [!code highlight]

model_with_tools = model.bind_tools([fetch_tool]) # [!code highlight]

response = model_with_tools.invoke(
    "Please analyze the content at https://docs.langchain.com/"
)

from anthropic.types.beta import BetaWebFetchTool20250910Param # [!code highlight]
from langchain.agents import create_agent
from langchain_anthropic import ChatAnthropic

fetch_tool = BetaWebFetchTool20250910Param( # [!code highlight]
    name="web_fetch", # [!code highlight]
    type="web_fetch_20250910", # [!code highlight]
    max_uses=3, # [!code highlight]
) # [!code highlight]

agent = create_agent(
    model=ChatAnthropic(model="claude-haiku-4-5-20251001"),
    tools=[fetch_tool],  # [!code highlight]
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "Analyze https://docs.langchain.com/"}]
})

for message in result["messages"]:
    message.pretty_print()

from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(model="claude-haiku-4-5-20251001")

fetch_tool = {"type": "web_fetch_20250910", "name": "web_fetch", "max_uses": 3} # [!code highlight]

model_with_tools = model.bind_tools([fetch_tool]) # [!code highlight]

response = model_with_tools.invoke(
    "Please analyze the content at https://docs.langchain.com/"
)

from anthropic.types import WebSearchTool20260209Param # [!code highlight]
from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(model="claude-sonnet-4-6")

search_tool = WebSearchTool20260209Param( # [!code highlight]
    name="web_search", # [!code highlight]
    type="web_search_20260209", # [!code highlight]
    max_uses=3, # [!code highlight]
) # [!code highlight]

model_with_tools = model.bind_tools([search_tool]) # [!code highlight]

response = model_with_tools.invoke("How do I update a web app to TypeScript 5.5?")

from anthropic.types import WebSearchTool20260209Param # [!code highlight]
from langchain.agents import create_agent
from langchain_anthropic import ChatAnthropic

search_tool = WebSearchTool20260209Param( # [!code highlight]
    name="web_search", # [!code highlight]
    type="web_search_20260209", # [!code highlight]
    max_uses=3, # [!code highlight]
) # [!code highlight]

agent = create_agent(
    model=ChatAnthropic(model="claude-sonnet-4-6"),
    tools=[search_tool],  # [!code highlight]
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "How do I update a web app to TypeScript 5.5?"}]
})

for message in result["messages"]:
    message.pretty_print()

from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(model="claude-sonnet-4-6")

search_tool = {"type": "web_search_20260209", "name": "web_search", "max_uses": 3} # [!code highlight]

model_with_tools = model.bind_tools([search_tool]) # [!code highlight]

response = model_with_tools.invoke("How do I update a web app to TypeScript 5.5?")

from typing import Literal

from anthropic.types.beta import BetaMemoryTool20250818Param  # [!code highlight]
from langchain_anthropic import ChatAnthropic
from langchain.messages import HumanMessage, ToolMessage
from langchain.tools import tool

tool_spec = BetaMemoryTool20250818Param(  # [!code highlight]
    name="memory",  # [!code highlight]
    type="memory_20250818",  # [!code highlight]
)  # [!code highlight]

# Simple in-memory storage for demonstration purposes
memory_store: dict[str, str] = {
    "/memories/interests": "User enjoys Python programming and hiking"
}


@tool(extras={"provider_tool_definition": tool_spec})  # [!code highlight]
def memory(
    *,
    command: Literal["view", "create", "str_replace", "insert", "delete", "rename"],
    path: str,
    content: str | None = None,
    old_str: str | None = None,
    new_str: str | None = None,
    insert_line: int | None = None,
    new_path: str | None = None,
    **kw,
):
    """Manage persistent memory across conversations."""
    if command == "view":
        if path == "/memories":
            # List all memories
            return "\n".join(memory_store.keys()) or "No memories stored"
        return memory_store.get(path, f"No memory at {path}")
    elif command == "create":
        memory_store[path] = content or ""
        return f"Created memory at {path}"
    elif command == "str_replace" and old_str is not None:
        if path in memory_store:
            memory_store[path] = memory_store[path].replace(old_str, new_str or "", 1)
        return f"Updated {path}"
    elif command == "delete":
        memory_store.pop(path, None)
        return f"Deleted {path}"
    # ... implement other commands
    return f"Executed {command} on {path}"


model = ChatAnthropic(model="claude-sonnet-4-6")
model_with_tools = model.bind_tools([memory]) # [!code highlight]

# Initial request
messages = [HumanMessage("What are my interests?")]
response = model_with_tools.invoke(messages)
print(response.content_blocks)

# Tool execution loop
while response.tool_calls:
    tool_messages = []
    for tool_call in response.tool_calls:
        result = memory.invoke(tool_call)
        tool_messages.append(ToolMessage(content=result, tool_call_id=tool_call["id"]))

    messages = [*messages, response, *tool_messages]
    response = model_with_tools.invoke(messages)
    print(response.content_blocks)

[{'type': 'text',
'text': "I'll check my memory to see what information I have about your interests."},
{'type': 'tool_call',
'name': 'memory',
'args': {'command': 'view', 'path': '/memories'},
'id': 'toolu_01XeP9sxx44rcZHFNqXSaKqh'}]

from typing import Literal

from anthropic.types.beta import BetaMemoryTool20250818Param # [!code highlight]
from langchain.agents import create_agent
from langchain_anthropic import ChatAnthropic
from langchain.tools import tool

# Simple in-memory storage
memory_store: dict[str, str] = {
    "/memories/interests": "User enjoys Python programming and hiking"
}

tool_spec = BetaMemoryTool20250818Param( # [!code highlight]
    name="memory", # [!code highlight]
    type="memory_20250818", # [!code highlight]
) # [!code highlight]


@tool(extras={"provider_tool_definition": tool_spec}) # [!code highlight]
def memory(
    *,
    command: Literal["view", "create", "str_replace", "insert", "delete", "rename"],
    path: str,
    content: str | None = None,
    old_str: str | None = None,
    new_str: str | None = None,
    **kw
):
    """Manage persistent memory across conversations."""
    if command == "view":
        if path == "/memories":
            return "\n".join(memory_store.keys()) or "No memories stored"
        return memory_store.get(path, f"No memory at {path}")
    elif command == "create":
        memory_store[path] = content or ""
        return f"Created memory at {path}"
    elif command == "str_replace" and old_str is not None:
        if path in memory_store:
            memory_store[path] = memory_store[path].replace(old_str, new_str or "", 1)
        return f"Updated {path}"
    elif command == "delete":
        memory_store.pop(path, None)
        return f"Deleted {path}"
    return f"Executed {command} on {path}"


agent = create_agent(
    model=ChatAnthropic(model="claude-sonnet-4-6"),
    tools=[memory],  # [!code highlight]
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "What are my interests?"}]
})

for message in result["messages"]:
    message.pretty_print()

from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(
    model="claude-sonnet-4-6",
)
model_with_tools = model.bind_tools([{"type": "memory_20250818", "name": "memory"}]) # [!code highlight]

response = model_with_tools.invoke("What are my interests?")
response.content_blocks
# You must handle execution of the memory commands in response.tool_calls via a tool execution loop

[{'type': 'text',
'text': "I'll check my memory to see what information I have about your interests."},
{'type': 'tool_call',
'name': 'memory',
'args': {'command': 'view', 'path': '/memories'},
'id': 'toolu_01XeP9sxx44rcZHFNqXSaKqh'}]

from anthropic.types.beta import BetaToolSearchToolRegex20251119Param # [!code highlight]
from langchain_anthropic import ChatAnthropic
from langchain.tools import tool

@tool(extras={"defer_loading": True}) # [!code highlight]
def get_weather(location: str, unit: str = "fahrenheit") -> str:
    """Get the current weather for a location.

    Args:
        location: City name
        unit: Temperature unit (celsius or fahrenheit)
    """
    return f"Weather in {location}: Sunny"

@tool(extras={"defer_loading": True}) # [!code highlight]
def search_files(query: str) -> str:
    """Search through files in the workspace.

    Args:
        query: Search query
    """
    return f"Found files matching '{query}'"

model = ChatAnthropic(model="claude-sonnet-4-6")

tool_search = BetaToolSearchToolRegex20251119Param( # [!code highlight]
    name="tool_search_tool_regex", # [!code highlight]
    type="tool_search_tool_regex_20251119", # [!code highlight]
) # [!code highlight]

model_with_tools = model.bind_tools([
    tool_search, # [!code highlight]
    get_weather,
    search_files,
])
response = model_with_tools.invoke("What's the weather in San Francisco?")

from anthropic.types.beta import BetaToolSearchToolRegex20251119Param # [!code highlight]
from langchain.agents import create_agent
from langchain_anthropic import ChatAnthropic
from langchain.tools import tool

tool_search = BetaToolSearchToolRegex20251119Param( # [!code highlight]
    name="tool_search_tool_regex", # [!code highlight]
    type="tool_search_tool_regex_20251119", # [!code highlight]
) # [!code highlight]


@tool(extras={"defer_loading": True}) # [!code highlight]
def get_weather(location: str, unit: str = "fahrenheit") -> str:
    """Get the current weather for a location.

    Args:
        location: City name
        unit: Temperature unit (celsius or fahrenheit)
    """
    return f"Weather in {location}: Sunny"


@tool(extras={"defer_loading": True}) # [!code highlight]
def search_files(query: str) -> str:
    """Search through files in the workspace.

    Args:
        query: Search query
    """
    return f"Found files matching '{query}'"


agent = create_agent(
    model=ChatAnthropic(model="claude-sonnet-4-6"),
    tools=[
        tool_search,  # [!code highlight]
        get_weather,
        search_files,
    ],
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "What's the weather in San Francisco?"}]
})

for message in result["messages"]:
    message.pretty_print()

from langchain_anthropic import ChatAnthropic
from langchain.tools import tool

@tool(extras={"defer_loading": True})  # [!code highlight]
def get_weather(location: str, unit: str = "fahrenheit") -> str:
    """Get the current weather for a location.

    Args:
        location: City name
        unit: Temperature unit (celsius or fahrenheit)
    """
    return f"Weather in {location}: Sunny"

@tool(extras={"defer_loading": True})  # [!code highlight]
def search_files(query: str) -> str:
    """Search through files in the workspace.

    Args:
        query: Search query
    """
    return f"Found files matching '{query}'"

model = ChatAnthropic(model="claude-sonnet-4-6")

model_with_tools = model.bind_tools([
    {"type": "tool_search_tool_regex_20251119", "name": "tool_search_tool_regex"}, # [!code highlight]
    get_weather,
    search_files,
])
response = model_with_tools.invoke("What's the weather in San Francisco?")