4. Tool Constructor

Define custom tools using Tool and StructuredTool constructors with Pydantic validation schemas

In this section, you will learn how to define custom tools using LangChain’s core constructors: Tool for simple single-argument inputs, and StructuredTool for complex multi-argument configurations validated with Pydantic.

Objectives

1. Define custom functions for greeting users, reversing strings, and concatenating values.
2. Formulate Pydantic schemas using BaseModel and Field to describe and validate tool inputs.
3. Instantiate Tool and StructuredTool classes and bind them to a tool-calling agent.

Implementation Plan

Goal

Construct a set of custom utility tools using constructors, compile them within an OpenAI tools agent, and verify executions on text inputs.

Sample Input

"Concatenate 'hello' and 'world'"

Sample Output

"helloworld"

Plan

1. Define functions: greet_user, reverse_string, and concatenate_strings.
2. Define a Pydantic class ConcatenateStringsArgs containing validation schemas for parameters a and b.
3. Wrap greeting and reversing functions inside the Tool(...) class constructor.
4. Wrap string concatenation inside StructuredTool.from_function(...) mapping the arguments schema.
5. Load the prompt hwchase17/openai-tools-agent and initialize the agent executor with create_tool_calling_agent.
6. Invoke the agent with query strings.

Step-by-Step Implementation

Step 1: Define Functions and Pydantic Schema

We write our Python operations and define the Pydantic validation schema for multiple arguments.

def greet_user(name: str) -> str:
    return f"Hello, {name}!"

def reverse_string(text: str) -> str:
    return text[::-1]

def concatenate_strings(a: str, b: str) -> str:
    return a + b

from langchain.pydantic_v1 import BaseModel, Field

class ConcatenateStringsArgs(BaseModel):
    a: str = Field(description="First string")
    b: str = Field(description="Second string")

Step 2: Instantiate Constructors

We wrap the functions into Tool and StructuredTool objects.

from langchain_core.tools import Tool, StructuredTool

tools = [
    Tool(
        name="GreetUser",
        func=greet_user,
        description="Greets the user by name.",
    ),
    Tool(
        name="ReverseString",
        func=reverse_string,
        description="Reverses the given string.",
    ),
    StructuredTool.from_function(
        func=concatenate_strings,
        name="ConcatenateStrings",
        description="Concatenates two strings.",
        args_schema=ConcatenateStringsArgs,
    ),
]

Step 3: Create and Invoke Tool-Calling Agent

We pull the specialized tools-agent prompt, initialize the model, build the agent executor, and run tests.

from langchain import hub
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain.chat_models import init_chat_model

llm = init_chat_model("llama-3.3-70b-versatile", model_provider="groq")
prompt = hub.pull("hwchase17/openai-tools-agent")

agent = create_tool_calling_agent(llm=llm, tools=tools, prompt=prompt)
agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True)

# Example invocations
# agent_executor.invoke({"input": "Greet Alice"})

Complete Combined Code

Below is the complete, consolidated Python script uniting all of the steps above:

# Import necessary libraries
from langchain import hub
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain.pydantic_v1 import BaseModel, Field
from langchain_core.tools import StructuredTool, Tool
from langchain.chat_models import init_chat_model


# Functions for the tools
def greet_user(name: str) -> str:
    """Greets the user by name."""
    return f"Hello, {name}!"


def reverse_string(text: str) -> str:
    """Reverses the given string."""
    return text[::-1]


def concatenate_strings(a: str, b: str) -> str:
    """Concatenates two strings."""
    return a + b


# Pydantic model for tool arguments
class ConcatenateStringsArgs(BaseModel):
    a: str = Field(description="First string")
    b: str = Field(description="Second string")


# Create tools using the Tool and StructuredTool constructor approach
tools = [
    # Use Tool for simpler functions with a single input parameter.
    Tool(
        name="GreetUser",  # Name of the tool
        func=greet_user,  # Function to execute
        description="Greets the user by name.",  # Description of the tool
    ),
    # Use Tool for another simple function with a single input parameter.
    Tool(
        name="ReverseString",  # Name of the tool
        func=reverse_string,  # Function to execute
        description="Reverses the given string.",  # Description of the tool
    ),
    # Use StructuredTool for more complex functions that require multiple input parameters.
    StructuredTool.from_function(
        func=concatenate_strings,  # Function to execute
        name="ConcatenateStrings",  # Name of the tool
        description="Concatenates two strings.",  # Description of the tool
        args_schema=ConcatenateStringsArgs,  # Schema defining the tool's input arguments
    ),
]

# Initialize a Groq model using core abstractions
llm = init_chat_model("llama-3.3-70b-versatile", model_provider="groq")

# Pull the prompt template from the hub
prompt = hub.pull("hwchase17/openai-tools-agent")

# Create the ReAct agent using the create_tool_calling_agent function
agent = create_tool_calling_agent(
    llm=llm,  # Language model to use
    tools=tools,  # List of tools available to the agent
    prompt=prompt,  # Prompt template to guide the agent's responses
)

# Create the agent executor
agent_executor = AgentExecutor.from_agent_and_tools(
    agent=agent,  # The agent to execute
    tools=tools,  # List of tools available to the agent
    verbose=True,  # Enable verbose logging
    handle_parsing_errors=True,  # Handle parsing errors gracefully
)

# Test the agent with sample queries
response = agent_executor.invoke({"input": "Greet Alice"})
print("Response for 'Greet Alice':", response)

response = agent_executor.invoke({"input": "Reverse the string 'hello'"})
print("Response for 'Reverse the string hello':", response)

response = agent_executor.invoke({"input": "Concatenate 'hello' and 'world'"})
print("Response for 'Concatenate hello and world':", response)

Practice & Exercises

To practice setting up tools using standard constructors, open the interactive notebook:

Practice & Exercises

Practice initializing Tool and StructuredTool constructor wrappers.

💻 VS Code | 🚀 Colab | 📥 Download