Tools in LangChain

In a standard AI system, an LLM possesses two core capabilities: Reasoning (the ability to think and break down a problem) and Generation (the ability to speak or write an answer). However, LLMs are inherently limited; they cannot autonomously perform tasks like booking a flight, fetching live weather data, or running complex math reliably.

Tools are the mechanism that provides an LLM with “hands and legs”. They are essentially Python functions packaged in a way that an LLM can understand, decide when to use, and call when needed to execute a specific task.

---

1. Why are Tools Necessary? #

LLMs are powerful but have specific “blind spots” that tools help cover:

• Real-time Data: LLMs have a knowledge cut-off date. Tools like a Web Search tool allow them to fetch today’s news.
• Reliable Logic: LLMs are language models, not calculators. A Python REPL tool can run actual code to solve a math problem instead of the LLM guessing the answer.
• External Interaction: LLMs cannot naturally call APIs, send emails via Gmail, or interact with a SQL database. Tools provide the interface for these actions.

---

2. Types of Tools in LangChain #

A. Built-in Tools

LangChain provides production-ready tools for popular use cases so you don’t have to write the logic yourself.

• DuckDuckGo Search: For real-time web searches.
• Wikipedia Query Run: To fetch summarized information from Wikipedia.
• Shell Tool: To execute commands directly on the host machine (use with caution!).
• Python REPL: To execute raw Python code for logic or math.

B. Custom Tools

When you have a unique business case—like interacting with your company’s private API or database—you must build your own tools.

---

3. How to Create Custom Tools (3 Methods) #

Method 1: The @tool Decorator (Easiest)

This is the most straightforward way. You write a standard Python function and wrap it with a decorator.

from langchain_core.tools import tool

@tool
def multiply(a: int, b: int) -> int:
    """Multiply two numbers together.""" # Highly recommended docstring
    return a * b

# Tools are Runnables, so they use .invoke()
result = multiply.invoke({"a": 3, "b": 5})
print(result) # Output: 15

Important: The docstring and type hinting (e.g., a: int) are crucial because they tell the LLM what the tool does and what inputs it expects.

---

Method 2: StructuredTool with Pydantic

This method is more “strict” and better for production. It uses a Pydantic model to enforce the input schema.

from pydantic import BaseModel, Field
from langchain_core.tools import StructuredTool

class MultiplyInput(BaseModel):
    a: int = Field(description="First number")
    b: int = Field(description="Second number")

def multiply_logic(a: int, b: int) -> int:
    return a * b

calculator_tool = StructuredTool.from_function(
    func=multiply_logic,
    name="Calculator",
    description="Multiplies two numbers",
    args_schema=MultiplyInput
)

---

Method 3: Inheriting from BaseTool

This is the most advanced method, allowing for deep customization and the creation of asynchronous versions of your tools.

---

4. Understanding Toolkits #

When you have multiple related tools (e.g., several tools for interacting with Google Drive), you can group them into a Toolkit. This promotes reusability across different applications.

class MathToolkit:
    def get_tools(self):
        return [add_tool, multiply_tool]

toolkit = MathToolkit()
tools = toolkit.get_tools() # Access all related tools at once

---

5. From Tools to Agents #

The “marriage” of an LLM and Tools is what creates an Agent.

• Reasoning (LLM): “To answer this, I first need to find the weather in Mumbai”.
• Action (Tools): The Agent calls the weather tool, gets the data, and then generates the final response.

Understanding Tools is the fundamental first step toward building autonomous AI agents that can solve real-world problems. Acknowledge that the next steps in this journey are Tool Calling (connecting the tool to the LLM) and finally, Agent construction

6. What is Tool Calling? #

Tool Calling is the mechanism where an LLM, during a conversation, determines that it cannot answer a prompt using its internal knowledge alone and instead generates a structured output. This output contains:

• The name of the specific tool it wants to use.
• The arguments (inputs) required to run that tool.

It is important to understand that the LLM does not actually execute the tool itself. It acts as an advisor, suggesting: “I think this tool with these inputs will give us the answer”. The actual execution is handled by you (the programmer) or a framework like LangChain.

---

7. The Process: Binding and Calling #

Before an LLM can call a tool, you must Bind the tools to it.

• Tool Binding: This is the registration step where you tell the LLM which tools are available, what they do (via descriptions), and what input format they expect (via schemas).
• The Code: You use the bind_tools() method to connect your tools to the LLM.

# 1. Define the tool
@tool
def multiply(a: int, b: int) -> int:
    """Multiplies two numbers."""
    return a * b

# 2. Bind the tool to the LLM
llm_with_tools = llm.bind_tools([multiply])

---

3. The Tool Execution Loop

To get a final answer for a user, the system must complete a four-step loop:

1. Human Message: The user asks a question (e.g., “What is 3 times 10?”).
2. AI Message (Tool Call): The LLM realizes it needs the multiply tool. It returns an ai_message where the text content is empty, but a tool_calls attribute contains the tool name and arguments (a=3, b=10).
3. Tool Execution: The programmer takes those arguments, runs the actual Python function, and receives a Tool Message containing the result (30).
4. Final Response: The entire history (Human Message + AI Tool Call + Tool Message) is sent back to the LLM. The LLM then sees the result and generates a final natural language answer: “The product of 3 and 10 is 30”.

---

4. Advanced Concept: Injected Tool Arguments

Sometimes, you might have a chain of tools where the second tool depends on the first. For example, in a currency converter, the first tool fetches a “conversion rate” from an API, and the second tool multiplies the “amount” by that rate.

To prevent the LLM from “guessing” the conversion rate based on its old training data, you use Injected Tool Arguments. By annotating an argument as InjectedToolArg, you tell the LLM: “Do not try to fill this value; the programmer will provide it after the first tool runs”.

---

5. Transitioning to AI Agents

While the flow described above allows an LLM to use tools, it is not yet an AI Agent.

• Manual Flow: In the examples above, the programmer manually manages the loop, deciding which tool to run and when to send data back to the LLM.
• AI Agent: An agent is autonomous. It looks at a goal, breaks it down into steps, decides which tools to call, executes them, and continues this cycle until the goal is achieved without manual intervention from the programmer.

Mastering Tool Calling is the final “fundamental topic” required before you can build these fully autonomous agents.

Tools Quiz #