Tool Use Motivation: Why LLMs Need External Tools for Accuracy › Code Implementation: Building a Tool-Augmented System

import math
from datetime import datetime, timedelta
from typing import Any, Callable, Dict

# Tool definitions with schemas for the LLM
TOOLS: Dict[str, Dict[str, Any]] = {
    "calculator": {
        "description": "Evaluates mathematical expressions safely",
        "parameters": {
            "expression": "string containing a mathematical expression (e.g., '2 + 2', 'sqrt(16)', '5000 * (1 + 0.045/12)**43')"
        },
    },
    "current_date": {
        "description": "Returns the current date and time",
        "parameters": {},
    },
    "weather_lookup": {
        "description": "Simulates weather lookup for a given city",
        "parameters": {
            "city": "string, name of the city",
            "days": "integer, number of days for forecast (1-5)",
        },
    },
}


def calculator(expression: str) -> str:
    """Compute mathematical expressions using Python's math module."""
    try:
        allowed_names = {
            "sqrt": math.sqrt,
            "pow": pow,
            "abs": abs,
            "round": round,
            "max": max,
            "min": min,
            "pi": math.pi,
            "e": math.e,
        }
        result = eval(expression, {"__builtins__": {}}, allowed_names)  # noqa: S307
        return str(result)
    except Exception as exc:
        return f"Error: {str(exc)}"


def current_date() -> str:
    """Return current datetime."""
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")


def weather_lookup(city: str, days: int = 1) -> str:
    """Simulated weather API (deterministic for demo)."""
    seed = sum(ord(c) for c in city.lower())
    conditions = ["sunny", "cloudy", "rainy", "partly cloudy"]
    base_temp = (seed % 30) + 5

    results = []
    for i in range(min(days, 5)):
        date = (datetime.now() + timedelta(days=i)).strftime("%Y-%m-%d")
        temp = base_temp + (i % 5) - 2
        condition = conditions[(seed + i) % len(conditions)]
        results.append(f"{date}: {condition}, {temp}°C")

    return "; ".join(results)


TOOL_REGISTRY: Dict[str, Callable] = {
    "calculator": calculator,
    "current_date": current_date,
    "weather_lookup": weather_lookup,
}

import json
from typing import Callable, Dict, List, Tuple


class ToolAugmentedSystem:
    """
    Simulates a tool-augmented LLM system.
    In production, the LLM generates tool_calls based on the user query.
    """

    def __init__(self, tools: Dict[str, Callable], tool_schemas: Dict):
        self.tools = tools
        self.tool_schemas = tool_schemas
        self.conversation_history: List[Dict] = []

    def execute_tool(self, tool_name: str, parameters: Dict) -> str:
        """Execute a tool and return the result."""
        if tool_name not in self.tools:
            return f"Error: Tool '{tool_name}' not found"

        try:
            result = self.tools[tool_name](**parameters)
            return result
        except Exception as exc:
            return f"Error executing {tool_name}: {str(exc)}"

    def process_query(
        self, user_query: str, planned_tools: List[Tuple[str, Dict]]
    ) -> str:
        """
        Process a query by executing planned tool calls and synthesizing a response.

        Args:
            user_query: The original user question
            planned_tools: List of (tool_name, parameters) tuples representing
                          what an LLM would generate
        """
        self.conversation_history.append(
            {"role": "user", "content": user_query}
        )

        tool_results = []
        print(f"User Query: {user_query}\n")

        for i, (tool_name, params) in enumerate(planned_tools, 1):
            print(
                f"Step {i}: Calling tool '{tool_name}' with parameters {json.dumps(params)}"
            )

            result = self.execute_tool(tool_name, params)
            tool_results.append(
                {"tool": tool_name, "parameters": params, "result": result}
            )

            print(f"Result: {result}\n")

        final_response = self._synthesize_response(user_query, tool_results)
        return final_response

    def _synthesize_response(self, query: str, results: List[Dict]) -> str:
        """Synthesize final answer from tool results (simulating LLM generation)."""
        synthesis = "Based on the tool results:\n"

        if any(r["tool"] == "calculator" for r in results):
            calc_results = [r for r in results if r["tool"] == "calculator"]
            for r in calc_results:
                synthesis += f"- Calculation '{r['parameters']['expression']}' = {r['result']}\n"

        if any(r["tool"] == "current_date" for r in results):
            date_result = [r for r in results if r["tool"] == "current_date"][0]
            synthesis += f"- Current date/time: {date_result['result']}\n"

        if any(r["tool"] == "weather_lookup" for r in results):
            weather_results = [
                r for r in results if r["tool"] == "weather_lookup"
            ]
            for r in weather_results:
                city = r["parameters"]["city"]
                synthesis += f"- Weather for {city}: {r['result']}\n"

        synthesis += (
            "\n[Final natural language response would be generated by LLM here]"
        )
        return synthesis


system = ToolAugmentedSystem(TOOL_REGISTRY, TOOLS)

query = "If I invest $5000 at 4.5% annual interest compounded monthly, how much will I have after 3 years and 7 months?"

planned_tools = [
    ("calculator", {"expression": "3 * 12 + 7"}),
    (
        "calculator",
        {"expression": "5000 * (1 + 0.045/12) ** 43"},
    ),
]

response = system.process_query(query, planned_tools)

system.conversation_history = []

query = "What's the current date, and what's the weather in Tokyo today? Should I bring an umbrella if it's raining?"

planned_tools = [
    ("current_date", {}),
    ("weather_lookup", {"city": "Tokyo", "days": 1}),
]

response = system.process_query(query, planned_tools)