Marketplace · Text & chat

functiongemma:latest

Call functiongemma:latest through one OpenAI-compatible API. It's served by 4 hosts on the Inpherio grid, each at a price it sets — your request goes to the cheapest healthy one, and fails over to the next if it's down.

From
£0.015
per 1M output tokens
£1 buys about 67 million tokens (≈ 50 million words)
Hosts
4
Loaded now
0

At a glance.

tools router

  • Type: Text & chat
  • Hosts serving it now: 4 (0 with it loaded in memory)
  • Engines: ollama
  • Context window: up to 32,768 tokens
  • Rentable: a whole host from £0.04 an hour (rentals)
python · openai sdk
from openai import OpenAI
client = OpenAI(base_url="https://inpherio.co.uk/v1",
                api_key=INPHERIO_API_KEY)
reply = client.chat.completions.create(
    model="functiongemma:latest",
    messages=[{"role": "user", "content": "Hello"}],
)

functiongemma:latest in detail.

FunctionGemma is a specialized version of Google's Gemma 3 270M model fine-tuned explicitly for function calling.

Published by
google
Parameters
268M
Download size
301 MB (as packaged for Ollama)
Quantisation
Q8_0
Format
gguf
Architecture
gemma3_text
Licence
Gemma terms · access is gated (accept the terms on Hugging Face)
Task
text generation
Library
transformers
First published
8 Oct 2025
Last updated
14 Jan 2026
Downloads (30 days)
15,818 on Hugging Face
Likes
1,124

gemma3_text text-generation gemma3 gemma google functiongemma

The model card

Published by the model's authors on Ollama — shown as they wrote it, unedited by Inpherio.

Requires Ollama v0.13.5 or later

FunctionGemma

FunctionGemma is a lightweight, open model from Google, built as a foundation for creating your own specialized function calling models. 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.

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.

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.

Examples

Python

Run the python example with uv run tool.py

/// script

requires-python = ">=3.11"

dependencies = [

"ollama",

"rich",

]

///

""" Single tool, single turn example. Run with: uv run tool.py """

import json

from rich import print

from ollama import chat

model = 'functiongemma'

def get_weather(city: str) -> str: """ Get the current weather for a city.

Args: city: The name of the city

Returns: A string describing the weather """ return json.dumps({'city': city, 'temperature': 22, 'unit': 'celsius', 'condition': 'sunny'})

messages = [{'role': 'user', 'content': 'What is the weather in Paris?'}] print('Prompt:', messages[0]['content'])

response = chat(model, messages=messages, tools=[get_weather])

if response.message.tool_calls: tool = response.message.tool_calls[0] print(f'Calling: {tool.function.name}({tool.function.arguments})')

result = get_weather(**tool.function.arguments) print(f'Result: {result}')

messages.append(response.message) messages.append({'role': 'tool', 'content': result})

final = chat(model, messages=messages) print('Response:', final.message.content) else: print('Response:', response.message.content)

TypeScript

Run the TypeScript example with bun run tool.ts or npx tsx tool.ts

/**

  • Single tool, single turn example.
  • Run with: bun run tool.ts or npx tsx tool.ts

*/

const OLLAMA_HOST = process.env.OLLAMA_HOST || 'http://localhost:11434'; const MODEL = 'functiongemma';

function getWeather(city: string): string { return JSON.stringify({ city, temperature: 22, unit: 'celsius', condition: 'sunny' }); }

const tools = [ { type: 'function', function: { name: 'get_weather', description: 'Get the current weather for a city.', parameters: { type: 'object', properties: { city: { type: 'string', description: 'The name of the city' }, }, required: ['city'], }, }, }, ];

interface Message { role: string; content: string; tool_calls?: { function: { name: string; arguments: Record } }[]; }

interface ChatResponse { message: Message; }

async function chat(messages: Message[]): Promise { const response = await fetch(${OLLAMA_HOST}/api/chat, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ model: MODEL, messages, tools, stream: false }), });

Read the rest of the model card

if (!response.ok) { throw new Error(HTTP error: ${response.status} ${await response.text()}); }

return response.json(); }

async function main() { const messages: Message[] = [{ role: 'user', content: 'What is the weather in Paris?' }]; console.log('Prompt:', messages[0].content);

const response = await chat(messages);

if (response.message.tool_calls?.length) { const tool = response.message.tool_calls[0]; console.log(Calling: ${tool.function.name}(${JSON.stringify(tool.function.arguments)})\n);

const result = getWeather(tool.function.arguments.city); console.log('Function Result:', result);

messages.push(response.message); messages.push({ role: 'tool', content: result });

const final = await chat(messages); console.log('Response:', final.message.content); } else { console.log('Response:', response.message.content); } }

main().catch(console.error);

Benchmark

Benchmark n-shot Function Gemma 270m

BFCL Simple 0-shot 61.6

BFCL Multiple 0-shot 63.5

BFCL Parallel 0-shot 39

BFCL Parallel Multiple 0-shot 29.5

BFCL Live Simple 0-shot 36.2

BFCL Live Multiple 0-shot 25.7

BFCL Live Parallel 0-shot 22.9

BFCL Live Parallel Multiple 0-shot 20.8

BFCL Relevance 0-shot 61.1

BFCL Irrelevance 0-shot 73.7

Training Dataset

These models were trained on a dataset of text data that includes a wide variety of sources. The model was trained with 6T tokens. The knowledge cutoff date for the training data was August 2024. There are the key components:

• Public Tool Definitions - Common APIs found on the web

• Tool Use Interactions - These are a mix of prompts, function calls, function responses, and natural language responses from the model to summarise the function call response, or request clarifications when the prompt is ambiguous or incomplete.

Data Preprocessing

Here are the key data cleaning and filtering methods applied to the training data:

• CSAM Filtering: Rigorous CSAM (Child Sexual Abuse Material) filtering was applied at multiple stages in the data preparation process to ensure the exclusion of harmful and illegal content.

• Sensitive Data Filtering: As part of making Gemma pre-trained models safe and reliable, automated techniques were used to filter out certain personal information and other sensitive data from training sets.

• Additional methods: Filtering based on content quality and safety in line with Google’s policies.

Sources: google/functiongemma-270m-it on Hugging Face · functiongemma:latest on Ollama. Collected from public sources on 8 Nov 2026; the host serving it may run a different build or quantisation — the marketplace shows each host's own measurements.

Who's serving it.

Every host benchmarked this model on its own hardware before serving it. Prices are set by each host; health is scored by the platform from what it observes.

Hosts serving functiongemma:latest right now
HostTierPriceMeasured speedHealthStateRent
GTX 1080 Ti (11G)L1£0.0072 in · £0.015 out77 tok/s · 50 ms first token78loads on request£0.60/h
W11BOXL1£0.03 in · £0.06 out70 tok/s · 42 ms first token77loads on request—
7B-A1B (5G)L1£0.024 in · £0.093 out48 tok/s · 60 ms first token82loads on request£0.04/h
Raspberry Pi 4 (2G)L2£0.012 in · £0.046 out10 tok/s · 148 ms first token72loads on request£0.10/h

Live data, refreshed on every visit. How billing works.

Room on the grid for your machine.

4 machines serve functiongemma:latest today. Every extra host is somewhere a request can fail over to when one drops, and spare capacity when demand spikes. The router weighs price, measured speed, health and whether the model is already loaded — so a host with a sharper price or quicker hardware wins the next call.

Hosts now
4
0 loaded in memory
Price to beat
£0.015
per 1M output tokens
Fastest measured
77 tok/s

Set your own price — you keep 85% of what it earns, and new hosts start with 12 months fee-free (up to £250 of earnings). A payout fee of £2 + 1% per payout to a UK bank account, £2 + 2% to any other country applies when you're paid. Install the connector, load functiongemma:latest, and the platform benchmarks it on your hardware before your first request.