Tool Calling in LangChain | Generative AI using LangChain | Video 17 | CampusX

LangChain tool calling turns an LLM from a text-only assistant into a system that can use external functions safely—by letting the model *suggest* which tool to use and with what structured inputs, while the application code performs the actual execution. The core workflow is built from four linked steps: create tools (Python functions wrapped with metadata), bind them to an LLM (so the model knows what tools exist and their input schemas), tool calling (the LLM emits a structured “tool call” with arguments when a task requires it), and tool execution (the program runs the chosen tool and returns the result back to the model). This separation matters because it avoids letting the LLM directly run code or hit APIs on its own; instead, the developer retains control over what gets executed and with which parameters.

The transcript begins by revisiting why tool use is necessary for AI agents. LLMs are strong at reasoning and generating outputs, but they can’t directly perform actions like updating databases, posting on social platforms, or querying live services. Tools provide the missing “hands and feet”: explicit functions such as a DuckDuckGo search tool or a shell command tool. The missing piece is how to connect an LLM to those tools and how the LLM decides when to use them.

Tool binding is introduced as the registration step where each tool’s name, description, and input schema are provided to the LLM. Once bound, the model can format future tool calls correctly—sending inputs in the exact structure the tool expects. The transcript then demonstrates tool calling using a simple multiply tool. When asked a normal conversational question (“how are you?”), the LLM responds directly without tool use. When asked a computation (“what is 8 * 7?”), it generates a structured output indicating the tool name (e.g., “multiply”) and the argument values (A=8, B=7). A key clarification follows: tool calling does not execute the tool. The LLM only suggests the tool and arguments; LangChain (and the developer’s code) handles execution.

Tool execution is shown next. The application takes the tool call structure, extracts the arguments, and invokes the underlying Python function. The result is returned as a special “tool message,” which can then be appended to the conversation history. That conversation history—human message, AI message, and tool message—is sent back to the LLM so it can produce the final answer grounded in the tool’s output.

To make the concepts concrete, the transcript builds a small real-world application: real-time currency conversion. Because LLMs lack live exchange rates, a tool is created to call an external Exchange Rate API to fetch the conversion factor between a base currency and a target currency. A second tool multiplies the user’s amount by that factor. The LLM is bound to both tools and asked questions like converting 10 USD to INR.

A subtle failure mode appears when the LLM tries to answer two related questions in sequence: it may call the “get conversion factor” tool correctly, but then guess the conversion rate for the “convert” tool instead of using the freshly fetched value. The fix is LangChain’s “Injected Tool Arguments,” where the developer marks the conversion-rate parameter as injected so the LLM does not fill it. Instead, the application extracts the conversion rate from the first tool’s result and injects it into the second tool call. The final flow loops through tool calls, executes them in order, appends tool messages to the history, and returns a grounded final conversion.

The transcript closes by distinguishing this setup from a fully autonomous agent. The currency app uses tool calling and execution, but the developer still orchestrates the execution order and injection logic. A true agent would autonomously plan and execute the multi-step process without manual intervention—something promised for the next video.