functiongemma

Model Information

Summary description and brief definition of inputs and outputs.

Description

[!Note] FunctionGemma is intended to be fine-tuned for your specific function-calling task, including multi-turn use cases.

FunctionGemma is a lightweight, open model from Google, built as a foundation for creating your own specialized function calling models. FunctionGemma is not intended for use as a direct dialogue model, and is designed to be highly performant after further fine-tuning, as is typical of models this size. Built on the Gemma 3 270M model and with the same research and technology used to create the Gemini models, FunctionGemma has been trained specifically for function calling. The model has the same architecture as Gemma 3, but uses a different chat format. The model is well suited for text-only function calling. The uniquely small size makes it possible to deploy in environments with limited resources such as laptops, desktops or your own cloud infrastructure, democratizing access to state of the art AI models and helping foster innovation for everyone. Furthermore, akin to the base Gemma 270M, the model has been optimized to be extremely versatile, performant on a variety of hardware in single turn scenarios, but should be finetuned on single turn or multiturn task specific data to achieve best accuracy in specific domains. To demonstrate how specializing the 270M parameter model can achieve high performance on specific agentic workflows, we have highlighted two use cases in the Google AI Edge Gallery app.

• Tiny Garden: A model fine-tuned to power a voice-controlled interactive game. It handles game logic to manage a virtual plot of land, decomposing commands like "Plant sunflowers in the top row" and "Water the flowers in plots 1 and 2" into app-specific functions (e.g., plant_seed, water_plots) and coordinate targets. This demonstrates the model's capacity to drive custom app mechanics without server connectivity.

• Mobile Actions: To empower developers to build their own expert agents, we have published a dataset and fine-tuning recipe to demonstrate fine-tuning FunctionGemma. It translates user inputs (e.g., "Create a calendar event for lunch," "Turn on the flashlight") into function calls that trigger Android OS system tools. This interactive notebook demonstrates how to take the base FunctionGemma model and build a "Mobile Actions" fine tune from scratch for use in the Google AI Edge gallery app. This use case demonstrates the model's ability to act as an offline, private agent for personal device tasks.

Inputs and outputs

• Input:
  • Text string, such as a question, a prompt, or a document to be summarized
  • Total input context of 32K tokens
• Output:
  • Generated text in response to the input, such as an answer to a question, or a summary of a document
  • Total output context up to 32K tokens per request, subtracting the request input tokens

Basic Usage

The following is a code example of how to use FunctionGemma to generate a function call from a JSON definition using the Hugging Face Transformers library.

First install the dependencies:

$ pip install torch
$ pip install transformers

Then load the model and the processor using Transformers:

from transformers import AutoProcessor, AutoModelForCausalLM

processor = AutoProcessor.from_pretrained("google/functiongemma-270m-it", device_map="auto")
model = AutoModelForCausalLM.from_pretrained("google/functiongemma-270m-it", dtype="auto", device_map="auto")

Define the function definition using JSON schema, then set a system instruction using the developer role. This is required to let the model know it should use the function(s) provided. Add a user query as input to the model and then generate the output. The model will then generate one or more function calls that it wants the developer to make on its behalf.

weather_function_schema = {
    "type": "function",
    "function": {
        "name": "get_current_temperature",
        "description": "Gets the current temperature for a given location.",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "The city name, e.g. San Francisco",
                },
            },
            "required": ["location"],
        },
    }
}

message = [
    # ESSENTIAL SYSTEM PROMPT:
    # This line activates the model's function calling logic.
    {
        "role": "developer",
        "content": "You are a model that can do function calling with the following functions"
    },
    {
        "role": "user",
        "content": "What's the temperature in London?"
    }
]

inputs = processor.apply_chat_template(message, tools=[weather_function_schema], add_generation_prompt=True, return_dict=True, return_tensors="pt")

out = model.generate(**inputs.to(model.device), pad_token_id=processor.eos_token_id, max_