Function calling data

This recipe generates function calls for user requests. It also shows how to give each row of a dataset its own generation parameters, so that each request can see a different set of tools. The full code is in the function calling example on GitHub.

Import the libraries

# pip install bespokelabs-curator
import json
from typing import Dict

from datasets import Dataset

from bespokelabs import curator

Define the function call generator

Set return_completions_object = True so that parse gets the full API response. The model may return a tool call or a plain message, so parse handles both.

class FunctionCallGenerator(curator.LLM):
    """A simple function calling generator."""

    return_completions_object = True

    def prompt(self, input: Dict) -> str:
        return f"""You are a function calling expert. Given the user request:
        {input['user_request']}.
        Generate a function call that can be used to satisfy the user request.
        """

    def parse(self, input: Dict, response) -> Dict:
        message = response["choices"][0]["message"]
        if message.get("tool_calls"):
            input["function_call"] = str([tool_call["function"] for tool_call in message["tool_calls"]])
        else:
            # The model returned a message instead of a function call.
            input["function_call"] = message["content"]
        return input

Define the tools

This list defines two tools. The first gets the weather for a location, and the second gets the local time.

function_docs = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Retrieves current weather for the given location.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City and country e.g. Bogotá, Colombia"},
                    "units": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Units the temperature will be returned in.",
                    },
                },
                "required": ["location", "units"],
                "additionalProperties": False,
            },
            "strict": True,
        },
    },
    {
        "type": "function",
        "function": {
            "name": "get_local_time",
            "description": "Get the local time of a given location",
            "strict": True,
            "parameters": {
                "type": "object",
                "required": ["location", "timezone"],
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The name or coordinates of the location for which to get the local time",
                    },
                    "timezone": {
                        "type": "string",
                        "description": "The timezone of the location, defaults to the location's timezone if not provided",
                    },
                },
                "additionalProperties": False,
            },
        },
    },
]

Create the generator with default parameters

By default, every request can use both tools.

llm = FunctionCallGenerator(
    model_name="gpt-4o-mini",
    generation_params={"tools": function_docs},
    backend_params={"max_retries": 1, "require_all_responses": False},
)

Set generation parameters for each row

Add a generation_params column to the dataset. For each row, Curator starts from the default generation parameters and replaces the keys that the row sets.

dataset = Dataset.from_dict(
    {
        "user_request": ["What's the current temperature in New York?", "What time is it in Tokyo?"],
        "generation_params": [
            json.dumps({"tools": [function_docs[0]]}),
            json.dumps({"tools": [function_docs[1]]}),
        ],
    }
)

Here the first row can use only the weather tool, and the second row can use only the time tool.

Store generation_params as a JSON string. If you store a dictionary, the datasets library splits its keys into separate columns. See issue 325 for details.

Run the generator

function_calls = llm(dataset)
print(function_calls.dataset.to_pandas())

Curator sends each row with its own tools, and the model returns a function call for each request.

You can use row-level parameters whenever different rows need different settings, e.g., to give each type of request only the tools it needs. In parse, always handle both tool calls and plain messages.

Get started

Core features

Guides

Recipes

Fine-tuning

Reference