Tool use is a critical capability for Large Language Model (LLM) agents, enabling them to interact with external systems, access up-to-date information, and perform actions beyond their inherent knowledge¹⁾. This functionality allows LLMs to handle complex tasks that require real-time data retrieval or specific operations. Tool use represents a fundamental paradigm shift from passive LLM processing to active decision-making, where agents determine actions rather than simply process inputs, with key concepts including agent autonomy, tool calling, function calling, memory management, and planning²⁾.

import json
from [[openai|openai]] import [[openai|OpenAI]]
 
client = [[openai|OpenAI]]()
 
Define tools with JSON Schema for the model
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get the current weather for a location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {"type": "string", "description": "City name"},
                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
            },
            "required": ["location"],
        },
    },
}]
 
Tool implementation registry
def get_weather(location: str, unit: str = "celsius") -> str:
    # In production, call a real weather API here
    return json.dumps({"location": location, "temp": 22, "unit": unit, "condition": "sunny"})
 
TOOL_REGISTRY = {"get_weather": get_weather}
 
def run_with_tools(user_message: str) -> str:
    """Complete tool-use loop: send message, execute tools, return final response."""
    messages = [{"role": "user", "content": user_message}]
    response = client.chat.completions.create(
        model="gpt-4o", messages=messages, tools=tools
    )
    msg = response.choices[0].message
 
    # If the model wants to call tools, execute them
    while msg.tool_calls:
        messages.append(msg)
        for call in msg.tool_calls:
            func = TOOL_REGISTRY[call.function.name]
            args = json.loads(call.function.arguments)
            result = func(**args)
            messages.append({"role": "tool", "tool_call_id": call.id, "content": result})
        response = client.chat.completions.create(
            model="gpt-4o", messages=messages, tools=tools
        )
        msg = response.choices[0].message
    return msg.content
 
print(run_with_tools("What is the weather in Paris?"))

• Website: langchain.com/]]
• GitHub: langchain-ai/langchain]]
• Features:
  • Extensive toolkit for agent-tool interactions
  • Pre-built tools for tasks such as web search, mathematical computations, and code execution
  • Capabilities for creating custom tools

• GitHub: microsoft/autogen]]
• Features:
  • Flexible tool integration within multi-agent systems
  • Support for code execution and external API calls

• Website: llamaindex.ai/]]
• GitHub: https://github.com/run-llama/llama_index
• Features:
  • Data connectors and structuring for tool creation
  • Advanced retrieval interfaces for data-centric tools

• Website: haystack.deepset.ai/]]
• GitHub: https://github.com/deepset-ai/haystack
• Features:
  • SearchEngine tool for information retrieval
  • TopPSampler for text generation tasks

• GitHub: https://github.com/OpenBMB/BMTools
• Features:
  • Platform for building and sharing tools
  • Extends language models with various capabilities

• Web search tools
• Mathematical computation tools (e.g., WolframAlpha)
• Code execution tools
• Database query tools (e.g., SQL, CSV, JSON)
• API interaction tools
• Vector store tools for efficient data retrieval
• Image analysis tools

• Allows agents to select and use appropriate tools via function calling interfaces³⁾ based on task requirements. Tool calling mechanisms enable LLMs to invoke external tools and functions to accomplish tasks beyond text generation, with OpenAI's function calling API and LangChain's agent abstractions converging on similar implementations from different directions to become a standard capability in agent development⁴⁾.
• Supports dynamic tool selection and parameter passing

• Enhances tool use by providing relevant context from external data sources
• Improves the accuracy and relevance of tool outputs

• Models like Toolformer⁵⁾ and TALM are fine-tuned for tool interactions
• Exhibit enhanced ability to use external APIs and tools effectively

The emergence of models specifically designed for agentic and tool-heavy tasks represents a significant advancement in agent capabilities. MiniMax M2.5 and M2.7 models have gained prominence for their effectiveness in local agent development, providing reliable tool integration and functional execution without reliance on external cloud services⁶⁾. These models are preferred by developers building self-contained agent systems that prioritize tool reliability and local inference.

Harness engineering represents a technical shift where performance gains are derived from the surrounding infrastructure and toolsets rather than solely from model weights⁷⁾. This approach emphasizes building complex agentic environments with extensive tool ecosystems. Organizations like Meta have demonstrated this principle by constructing systems with 16 hidden tools, while projects like OpenClaw showcase the value of extensive codebases supporting LLM agents. This paradigm suggests that future performance improvements will increasingly come from intelligent tool orchestration and environmental design rather than model scaling alone.

• Quality and Availability of Tool Documentation: Diverse, redundant, or incomplete documentation can hinder effective tool utilization.
• Decision-Making in Tool Use⁸⁾: LLMs may struggle to determine when and which tools to use, affecting performance.

• ToolLLM: An open platform that enables LLMs to master thousands of real-world APIs, improving their ability to execute complex instructions and generalize to unseen APIs⁹⁾.
• GPT4Tools¹⁰⁾: A framework that allows open-source LLMs to use multimodal tools through self-instruction, enhancing their problem-solving capabilities.

• Memory Management for LLM Agents
• Agent-Based Task Management with LLMs
• AgentTuning: Enabling Generalized Agent Capabilities in LLMs
• Tool-Using Agents
• ToolLLM: Facilitating Large Language Models to Master 16,000+ Real-World APIs