Day 2/30: LLM Tool Calls

Kasi Yaswanth — Sun, 12 Jul 2026 08:54:43 +0000

Day 2/30: LLM Tool Calls

I still remember the frustration of trying to integrate a large language model (LLM) into our support bot. The model could understand natural language, generate human-like responses, and even learn from feedback. However, it lacked the ability to interact with external tools and services, making it feel like a disembodied brain - incredibly smart, but unable to act on its knowledge. Our bot would often respond with phrases like "I can help you with that," but then fail to actually perform the task. It was as if the LLM had no "hands" to manipulate the world.

The problem was that our LLM was not designed to make tool calls from scratch. It relied on pre-existing frameworks and libraries to interact with external services, which limited its flexibility and autonomy. We needed a way to give our LLM the ability to call tools and services without relying on these frameworks, essentially giving it "hands" to manipulate the world.

To solve this problem, we turned to the Model Context Protocol (MCP) and LangGraph. MCP provides a standardized way to represent and interact with external tools and services, while LangGraph allows us to model complex workflows and decision-making processes. By combining these two technologies, we could create a system that enables our LLM to make tool calls from scratch, without relying on pre-existing frameworks.

Here's an example of how we used LangGraph and MCP to give our LLM "hands":

import langgraph
from langgraph import StateGraph, add_node, add_conditional_edges
from mcp import Tool, ToolCall

# Define a tool that our LLM can call
class SendMessageTool(Tool):
    def __init__(self, message):
        self.message = message

    def execute(self):
        # Simulate sending a message
        print(f"Sending message: {self.message}")

# Create a LangGraph state graph
graph = StateGraph()

# Add nodes to the graph
start_node = add_node(graph, "start")
message_node = add_node(graph, "send_message")
end_node = add_node(graph, "end")

# Add conditional edges to the graph
add_conditional_edges(graph, start_node, message_node, lambda x: x["action"] == "send_message")
add_conditional_edges(graph, message_node, end_node, lambda x: x["message"] is not None)

# Define a tool call
tool_call = ToolCall(SendMessageTool, "Hello, world!")

# Create an LLM that can make tool calls
class LLM:
    def __init__(self, graph):
        self.graph = graph

    def make_tool_call(self, tool_call):
        # Use the graph to determine the next action
        current_node = self.graph.get_node("start")
        while current_node != self.graph.get_node("end"):
            # Get the next node based on the current state
            next_node = self.graph.get_next_node(current_node, {"action": "send_message", "message": tool_call.tool.message})
            # Execute the tool call
            if next_node == self.graph.get_node("send_message"):
                tool_call.tool.execute()
            current_node = next_node

# Create an instance of the LLM and make a tool call
llm = LLM(graph)
llm.make_tool_call(tool_call)

This code defines a simple tool that sends a message, and an LLM that uses a LangGraph state graph to determine when to make a tool call. The LLM can make tool calls from scratch, without relying on pre-existing frameworks.

One practical gotcha we learned from this experience is that it's essential to carefully design the state graph and tool calls to avoid infinite loops. If the graph is not properly structured, the LLM may get stuck in an infinite loop, making repeated tool calls without achieving any meaningful outcome.

As we continue to develop our agentic AI system, we'll explore more advanced topics, such as integrating multiple tools and services, and using MCP to handle errors and exceptions. Tomorrow, we'll dive deeper into the world of agentic AI and explore new ways to give our LLM "hands" to manipulate the world.

Day 1/30: ReAct Pattern Explained

Kasi Yaswanth — Sun, 12 Jul 2026 08:25:11 +0000

Day 1/30: ReAct Pattern Explained

I was recently tasked with building a support bot that could handle customer inquiries about our company's products. The bot was supposed to be able to understand the context of the conversation and respond accordingly. However, I soon realized that my initial implementation had a major flaw - the bot would often forget the context of the conversation and respond with irrelevant answers. For example, if a customer asked about the features of a specific product, the bot would respond with a generic description of the product, without taking into account the customer's previous questions.

This is when I stumbled upon the ReAct pattern, a fundamental concept in building agentic AI systems. The ReAct pattern is a simple yet powerful idea that helps AI agents maintain context and make decisions based on their current state. In the context of my support bot, the ReAct pattern helped me understand how to design the bot's behavior to take into account the conversation history and respond accordingly.

The ReAct pattern consists of three main components: Reasoning, Action, and Context. The Reasoning component is responsible for evaluating the current state of the agent and determining the best course of action. The Action component is responsible for executing the chosen action, and the Context component is responsible for updating the agent's state based on the outcome of the action.

In the case of my support bot, the Reasoning component would evaluate the customer's input and determine the best response based on the conversation history. The Action component would then generate the response, and the Context component would update the conversation history to reflect the customer's new question.

Here's an example of how I implemented the ReAct pattern in my support bot using LangGraph and MCP:

import langgraph as lg
from mcp import tools

# Define the support bot's state graph
state_graph = lg.StateGraph()

# Add nodes for each possible state
state_graph.add_node("start")
state_graph.add_node("product_inquiry")
state_graph.add_node("pricing_inquiry")

# Add conditional edges between nodes
state_graph.add_conditional_edges(
    ("start", "product_inquiry", lambda x: x["intent"] == "product_inquiry"),
    ("product_inquiry", "pricing_inquiry", lambda x: x["intent"] == "pricing_inquiry")
)

# Define the reasoning function
def reasoning(state, input_data):
    # Evaluate the customer's input and determine the best course of action
    if input_data["intent"] == "product_inquiry":
        return "product_inquiry"
    elif input_data["intent"] == "pricing_inquiry":
        return "pricing_inquiry"
    else:
        return "start"

# Define the action function
def action(state, input_data):
    # Generate a response based on the current state and customer input
    if state == "product_inquiry":
        return "What product would you like to know more about?"
    elif state == "pricing_inquiry":
        return "What is your budget for the product?"
    else:
        return "Welcome to our support bot! How can I help you today?"

# Define the context function
def context(state, input_data):
    # Update the conversation history based on the customer's input
    if input_data["intent"] == "product_inquiry":
        return {"conversation_history": ["product_inquiry"]}
    elif input_data["intent"] == "pricing_inquiry":
        return {"conversation_history": ["pricing_inquiry"]}
    else:
        return {"conversation_history": []}

# Create an MCP tool to interact with the support bot
tool = tools.Tool(
    state_graph=state_graph,
    reasoning_function=reasoning,
    action_function=action,
    context_function=context
)

# Test the support bot
input_data = {"intent": "product_inquiry", "text": "I'm interested in learning more about your products"}
response = tool.interact(input_data)
print(response)  # Output: What product would you like to know more about?

One practical gotcha I learned while implementing the ReAct pattern is that it's essential to carefully design the state graph and conditional edges to ensure that the agent can transition between states correctly. If the state graph is not well-designed, the agent may get stuck in an infinite loop or fail to respond to certain inputs.

As I continue to work on my support bot, I'm excited to explore more advanced topics in agentic AI, such as how to integrate multiple AI models and handle complex decision-making scenarios. Tomorrow, I'll be diving deeper into the world of LangGraph and MCP, and I'm looking forward to sharing my discoveries with you.

DEV Community: Kasi Yaswanth

Day 2/30: LLM Tool Calls

Day 2/30: LLM Tool Calls

Day 1/30: ReAct Pattern Explained

Day 1/30: ReAct Pattern Explained