CMC

Terminology for LLM tool use

Terminology and definitions around LLM tool use

LLMs using tools, functions, and APIs

Continuing my learning around agents, I started looking more closely today at a small but key topic. Specifically, why do I see different terminology for similar ideas like “tool use”, “function calling”, and MCP server APIs.

Mostly I just want to see if there is anything nuanced here, or if these terms are just a typical muddy lexicon emerging as a part of a fast moving field. Additionally I want to make sure I learn about the best path for some things I want to build.

A note on my own near-term goal

One project I’m slowly working on in the background, involves a chat-style user experience. I’ll avoid specifics, and just say it’s simple in that it needs to understand natural language when a user wants to add, update, or delete a thing.

My intuition is that I should be able to define thing.add, thing.update, and thing.delete as an internal API and then allow an LLM to decide when it’s appropriate to call the API. This removes a whole swatch of code and LLM calls where I would need to try and control and orchestrate just functionality.

So, it seems like function calling / tool use is appropriate here. That’s where I’m heading, but I want to understand the landscape in general too.

Terms the big players use

With a little time on my hands, I started with some simple search queries. I should maybe just ask an AI to summarize this, but I want to go direct to the sources for now.

So I just searched for things like “openai api documentation function use” and “anthropic api documentation function call”.

Terms in OpenAI API Docs

As I look through the OpenAI docs it seems like they focus on “function call” to the point they have a doc section named “OpenAI Function Calling Guide”.

Here’s the subtitle:

Enable models to fetch data and take actions

And they elaborate as follows:

Function calling provides a powerful and flexible way for OpenAI models to interface with your code or external services. This guide will explain how to connect the models to your own custom code to fetch data or take action.

Digging a little bit further, the code example indicates there are types:

--snip--
tools = [{
    "type": "function",
    "name": "get_weather",
--snip--

And continuing through the documentation, they have a separate section which is called “Tools”.

Inside the tools docs, they refer to function calling, web search, remote mcp servers, file search, image generation, code interpreter, and computer use. The documentation seems to imply that function calling is for user defined tools and all the rest are “built-in”. I’m suspect about the “remote” term for MCP, since I know there is some fuzziness with the client/server terminology for MCP.

There’s plenty more to learn here, but I’m just figuring out terms right now.

References:

  • https://platform.openai.com/docs/guides/function-calling
  • https://platform.openai.com/docs/guides/tools

Terms in Anthropic API Docs

Then, over in the Anthropic documentation, they have a top level section called “Tools”, and the first section is “Tool use with Claude”.

Here’s the initial text:

Claude is capable of interacting with tools and functions, allowing you to extend Claude’s capabilities to perform a wider variety of tasks.

Similar to OpenAI, it looks like they have a “tools” parameter with a list. The schem looks like it might be slightly different:

--snip--
   "tools": [
      {
        "name": "get_weather",
        "description": "Get the current weather in a given location",
--snip--

Continuing on, Anthropic starts to distinguish between client and server tools. Again though, we’ll see some confusion here as I’ve already learned that the words client and server get fuzzy when talking about various applications which leverage LLMs internally (like the claude application).

One thing I like in their docs about the client tools (local execution), is:

User-defined custom tools that you create and implement

This helps illustrate that both broad tools and specific functions could be user defined and called.

References: * https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/overview

Moving ahead with terminology

There’s still plenty of things I want to uncover in my exploration of agents.

For the terminology though, I think it is becoming more clear for me. The terms are roughly as follows:

  • Tool use is a broad term encompassing functions, tools, apis, etc
  • Function calling is more specific to defined and called code functions

Then, within various tools, there will likely be things like:

  • pre-defined tools from external sources (or provided in clients like Claude app)
  • user-defined tools like the ones I would develop for my own LLM apps/services

Language is often fuzzy, but I think those working definitions should be fine.

Lexicon curiosity

Finally, just out of curiosity and my responsibility as a Chief Lexicon Officer, I want to see what google trends says about the history of these terms.

Here’s a Google Trends chart:

This makes sense. Function calling was the first phrase I remember hearing, and it would have been first to emerge as a more specific capability. Then people began to generalize the idea to tool use.

logbook agents LLM