Tools & Tool Calling

tools = [multiply, get_weather, convert_currency, emi_calculator]
llm_with_tools = llm.bind_tools(tools)          # the LLM now sees the 4 schemas

ai_msg = llm_with_tools.invoke("What is the weather in Mumbai?")
ai_msg.content       # usually empty
ai_msg.tool_calls    # [{'name': 'get_weather', 'args': {'city': 'Mumbai'}, 'id': '...'}]

from standins import ScriptedModel, call
from langchain.tools import tool
from langchain_core.tools import StructuredTool
from langchain.messages import HumanMessage, ToolMessage
from pydantic import BaseModel, Field

@tool
def get_weather(city: str) -> str:
    """Get the current weather of an Indian city."""
    data = {"pune": "28°C, cloudy", "mumbai": "31°C, humid", "delhi": "35°C, sunny"}
    return data.get(city.lower(), "25°C, clear")

@tool
def convert_currency(amount: float, from_currency: str, to_currency: str) -> str:
    """Convert money between INR, USD and EUR."""
    rate_to_inr = {"INR": 1, "USD": 84, "EUR": 91}
    value = amount * rate_to_inr[from_currency.upper()] / rate_to_inr[to_currency.upper()]
    return f"{amount} {from_currency} = {round(value, 2)} {to_currency}"

class EMIInput(BaseModel):
    principal: float = Field(description="loan amount in INR")
    annual_rate: float = Field(description="interest rate per year in percent")
    years: int = Field(description="loan tenure in years")

@tool(args_schema=EMIInput)
def emi_calculator(principal: float, annual_rate: float, years: int) -> str:
    """Calculate the monthly EMI of a loan."""
    r = annual_rate / 12 / 100; n = years * 12
    return f"Monthly EMI = Rs {round(principal * r * (1 + r) ** n / ((1 + r) ** n - 1))}"

print("schema the LLM sees:", get_weather.name, "|", get_weather.description, "|", get_weather.args)
print("emi args          :", list(emi_calculator.args))
print("direct call       :", emi_calculator.invoke({"principal": 500000, "annual_rate": 9, "years": 5}))
print("StructuredTool    :", StructuredTool.from_function(func=lambda a, b: a + b, name="add", description="Add two numbers").invoke({"a": 5, "b": 7}))
try:
    emi_calculator.invoke({"principal": "five lakh", "annual_rate": 9, "years": 5})
except Exception as e:
    print("bad args rejected :", type(e).__name__)

# The manual loop. The stand-in LLM asks for 2 tools, then answers (a real LLM decides this itself).
tools = [get_weather, convert_currency, emi_calculator]
llm_with_tools = ScriptedModel([
    call("convert_currency", {"amount": 1500, "from_currency": "USD", "to_currency": "INR"}, "c1"),
    call("emi_calculator", {"principal": 126000, "annual_rate": 9, "years": 3}, "c2"),
    "1500 USD is Rs 1,26,000. For that amount at 9% for 3 years, the EMI is Rs 4,007 per month.",
])
tools_by_name = {t.name: t for t in tools}
messages = [HumanMessage("What is 1500 USD in INR, and what's the EMI for that INR amount at 9% for 3 years?")]
for step in range(5):
    ai_msg = llm_with_tools.invoke(messages)
    messages.append(ai_msg)
    if not ai_msg.tool_calls: break
    for c in ai_msg.tool_calls:
        result = tools_by_name[c["name"]].invoke(c["args"])
        print(f"🔧 {c['name']}({c['args']}) → {result}")
        messages.append(ToolMessage(content=str(result), tool_call_id=c["id"]))
print("final:", ai_msg.content)
print("message types:", [m.type for m in messages])