.bind_tools(): Reference Guide

What is .bind_tools()?

.bind_tools() attaches structured tool definitions to a chat model, enabling function calling (also called tool use). When you call model.bind_tools(tools), LangChain serialises each tool's input schema — whether it comes from a Pydantic model, a @tool-decorated function, or a raw JSON schema dict — into the provider-specific wire format: OpenAI's tools parameter, Anthropic's tools array, Gemini's function_declarations, and so on. The method returns a new Runnable that sends that schema on every subsequent request.

The model never directly executes the tools. Instead, it emits an AIMessage with a tool_calls list indicating which tool to invoke and with what arguments. Your application code — or a ToolNode in LangGraph — is responsible for dispatching the call, collecting the result, appending a ToolMessage back to the conversation, and re-invoking the model. This separation is intentional: it keeps the model stateless and lets you intercept, validate, or mock tool calls in tests.

.bind_tools() returns a new Runnable that wraps the original model — the original model object is unchanged. You can chain it with other .bind_*() or .with_config() calls, and the result supports the full Runnable interface including .invoke(), .ainvoke(), .stream(), and .batch(). For agents, create one model_with_tools variable at startup and reuse it per invocation rather than rebinding on every call, which avoids redundant serialisation overhead.

Use Cases

• • Function calling
• • Agent tool binding
• • Structured output
• • API schema declaration
• • Tool selection
• • Agentic workflows

Key Features

• ✓ Attach tools to models
• ✓ Auto schema generation
• ✓ Multiple tools
• ✓ Provider-agnostic
• ✓ Tool call responses
• ✓ Structured output

When NOT to Use

Notes

Method Signature

model_with_tools = model.bind_tools(tools, tool_choice=None)

Parameters

Return Value

model.bind_tools([search, calculate])

Code Examples

from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langchain_core.messages import HumanMessage

@tool
def multiply(a: int, b: int) -> int:
    """Multiply two integers."""
    return a * b

model = ChatOpenAI(model="gpt-4o")
model_with_tools = model.bind_tools([multiply])
response = model_with_tools.invoke([HumanMessage(content="What is 6 * 7?")])
print(response.tool_calls)  # [{"name": "multiply", "args": {"a": 6, "b": 7}}]

from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langchain_core.messages import HumanMessage, ToolMessage

@tool
def get_weather(city: str) -> str:
    """Get current weather for a city."""
    return f"Sunny, 22°C in {city}"

model = ChatOpenAI(model="gpt-4o")
model_with_tools = model.bind_tools([get_weather])

messages = [HumanMessage(content="Whats the weather in Tokyo?")]
ai_msg = model_with_tools.invoke(messages)
messages.append(ai_msg)

# Execute each requested tool call
for call in ai_msg.tool_calls:
    result = get_weather.invoke(call["args"])
    messages.append(ToolMessage(content=result, tool_call_id=call["id"]))

# Re-invoke to get the final answer
final = model_with_tools.invoke(messages)
print(final.content)

from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langchain_core.messages import HumanMessage

@tool
def search(query: str) -> str:
    """Search the web for a query."""
    return f"Results for: {query}"

@tool
def calculate(expression: str) -> float:
    """Evaluate a math expression."""
    return eval(expression)  # noqa: S307 (demo only)

model = ChatOpenAI(model="gpt-4o")
# Parallel tool calls: gpt-4o may emit both in one response
model_with_tools = model.bind_tools([search, calculate])
response = model_with_tools.invoke(
    [HumanMessage(content="Search for LangChain and calculate 15 * 8")]
)
print(f"Tool calls received: {len(response.tool_calls)}")
for call in response.tool_calls:
    print(call["name"], call["args"])

Common Mistakes

Related LangChain References

Browse the full LangChain API reference index to explore more classes, methods, and decorators, or start with the LangChain introduction tutorial for end-to-end context on building with .bind_tools() and the wider framework.

.bind_tools() FAQ