🛠️ Function Calling Fine-tuning Guide

Function calling fine-tuning teaches models to reliably invoke tools and structured functions in response to user queries. This is essential for building agents that can interact with APIs, query databases, and perform actions in the real world.

This notebook provides a step-by-step guide to fine-tuning a model for function calling using the Together AI platform. We'll use a subset of the glaive-function-calling-v2 dataset to train a model that can accurately select and call the right tools with correct arguments.

We will cover:

1. Dataset Exploration: Loading and understanding the function calling dataset.
2. Data Transformation: Converting the dataset to Together AI's function calling fine-tuning format.
3. Data Upload: Validating and uploading the prepared dataset to Together AI.
4. Fine-tuning Job Launch: Configuring and starting a LoRA fine-tuning job.
5. Job Monitoring: Checking the status and progress of your fine-tuning job.
6. Inference: Comparing the base model vs. fine-tuned model on function calling tasks.

By following this guide, you'll learn how to create models that reliably call the right tools with correct arguments using Together AI.

Setup and Installation

First, install the necessary Python libraries:

• together: The official Together AI Python client for interacting with the API.
• datasets: A library from Hugging Face for easily downloading and manipulating datasets.
• tqdm: For progress bars.

1. Dataset Exploration

We'll use the glaive-function-calling-v2-formatted dataset, a curated collection of function calling conversations. The dataset contains:

• 112,000 training examples of conversations that include function calling
• 1,000 test examples

Each example includes a conversation with a system prompt, user query, and assistant responses that invoke functions, along with the available tool definitions.

Notice the current format of this dataset:

• The system message contains the tool definitions embedded in the text content
• The assistant messages contain function calls as JSON strings in the content field
• The tools are stored as a separate column with proper OpenAI-style schemas

For Together AI's function calling fine-tuning format, we need to restructure this so that:

• Assistant messages use the tool_calls field (not content) for function invocations
• Tool results use the tool role
• The tools field is at the top level of each example alongside messages

2. Data Transformation to Function Calling Format

Together AI's function calling fine-tuning requires a specific format where tool invocations use the tool_calls field in assistant messages.

Required Format

{
  "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What's the weather in SF?"},
    {"role": "assistant", "tool_calls": [
      {
        "id": "call_abc123",
        "type": "function",
        "function": {
          "name": "getCurrentWeather",
          "arguments": "{\"location\": \"San Francisco, CA\"}"
        }
      }
    ]},
    {"role": "tool", "content": "{\"temperature\": \"65\", \"unit\": \"fahrenheit\"}"}
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "getCurrentWeather",
        "description": "Get the current weather in a given location",
        "parameters": {
          "type": "object",
          "properties": {
            "location": {"type": "string", "description": "The city and state"}
          },
          "required": ["location"]
        }
      }
    }
  ]
}

Key Requirements:

• Assistant messages with function calls use tool_calls (not content)
• Each tool call needs an id, type: "function", and function with name and arguments (as a JSON string)
• Tool responses use the tool role with the result in content

We'll also subsample 200 training and 50 validation examples since this is a demo. For production use cases, you'd use significantly more data.

3. Upload Data to Together AI

Now we'll validate and upload our prepared datasets to Together AI. The check=True parameter validates the file format before uploading.

4. Launch Fine-tuning Job

Now we'll launch a LoRA fine-tuning job for function calling.

Key Parameters

Note: These hyperparameters are tuned for this small demo dataset. For production, you'd use more data and may want to adjust epochs and learning rate accordingly.

🔗 See the Function Calling Fine-tuning documentation for the full list of supported models and parameters.

5. Monitor Fine-tuning Job

You can monitor your fine-tuning job's progress using the Together AI API or the dashboard.

Your job will progress through several states: Pending → Queued → Running → Uploading → Completed.

Available methods:

• client.fine_tuning.retrieve(id) — Get job status
• client.fine_tuning.list_events(id=job_id) — Get job logs
• client.fine_tuning.cancel(id=job_id) — Cancel a job
• client.fine_tuning.list() — List all jobs

🔗 You can also monitor your job on the Together AI Fine-tuning Dashboard and view WandB logs if you provided an API key.

6. Inference — Base Model vs. Fine-tuned Model

Once training is complete, let's compare the base model against our fine-tuned model on function calling tasks. We'll define a set of test tools and queries to see how each model performs.

Below we compare the fine-tuned model against the base model on our test queries. We expect the fine-tuned model to more reliably select the correct tool and provide well-formed arguments.

Summary

In this notebook, we demonstrated how to:

1. Load and explore a function calling dataset from Hugging Face
2. Transform data into Together AI's function calling format with tool_calls, tool roles, and top-level tools
3. Upload and validate the dataset using the Together AI Python client
4. Launch a LoRA fine-tuning job on Qwen3-8B for function calling
5. Monitor training progress via the API and dashboard
6. Compare inference between the base model and fine-tuned model

Key Takeaways

• Function calling fine-tuning requires assistant messages to use the tool_calls field with id, type, and function (name + arguments as JSON string)
• LoRA fine-tuning is recommended for function calling — it's faster, cheaper, and enables serverless inference
• Even a small subset of training data (200 examples) can improve a model's tool selection and argument formatting
• The tools field at the top level of each example defines the available functions for that conversation

Next Steps

• Scale up to more training data for improved reliability
• Try DPO preference tuning to teach the model when not to call tools
• Experiment with different base models (Qwen3-8B, Qwen2.5-72B-Instruct, etc.)
• Deploy your fine-tuned model on a dedicated endpoint for production use

🔗 For more details, see the Function Calling Fine-tuning documentation.