{ "@context": "https://schema.org", "@id": "https://aggr.aymericbeaumet.com/items/philschmid-de/2025-03-14-google-gemma-3-function-calling-example/#webpage", "@type": [ "WebPage", "ArchiveComponent" ], "articleBody": "March 14, 2025 8 minute read [View Code](https://github.com/philschmid/gemini-samples/blob/main/examples/gemma-function-calling.ipynb)\n\nGoogle Gemma 3 27B It is an open, multilingual, multimodal Vision-Language model. It handles context windows up to 128k tokens, understands over 140 languages, and offers improved math, reasoning, and chat capabilities, including structured outputs and function calling.\n\nGemma 3 can be used for agentic workflows and has very strong instruction following capabilities. While there are no dedicated tool/function calling special tokens, you can prompt it to do function calling through careful instruction. Gemma 3 27B is available via [AI Studio](https://aistudio.google.com/prompts/new_chat?model=gemma-3-27b-it) and the Gen AI API. Get your API key from [AI Studio](https://aistudio.google.com/apikey).\n\nFunction calling is the capability to connect LLMs to external tools and to interact with your code and APIs in a structured way. Instead of generating text responses, LLMs understand when to call specific functions and provide the necessary parameters to execute real-world actions.\n\n![Function calling](https://www.philschmid.de/static/blog/gemini-function-calling/function-calling.png)\n\nFunction Calling follows these steps:\n\n1. Your application sends a prompt to the LLM along with function definitions\n2. The LLM analyzes the prompt and decides whether to respond directly or use defined functions\n3. If using functions, the LLM generates structured arguments for the function call\n4. Your application receives the function call details and executes the actual function\n5. The function results are sent back to the LLM\n6. The LLM provides a final response incorporating the function results\n\n## Raw Text Example of how function calling can be implement with Gemma 3\n\nBelow is an textual example of how to use function calling with Gemma 3 27B It. In this example the first user message includes the general instruction how and when to use function calling and example flow. The prompt with the Gemma 3 template would look like this:\n\n1. Send user message with instructions and function definitons and first user message.\n\n````plaintext\nuser\nAt each turn, if you decide to invoke any of the function(s), it should be wrapped with ```tool_code```. The python methods described below are imported and available, you can only use defined methods. The generated code should be readable and efficient. The response to a method will be wrapped in ```tool_output``` use it to call more tools or generate a helpful, friendly response. When using a ```tool_call``` think step by step why and how it should be used.\n \nThe following Python methods are available:\n \n\\`\\`\\`python\ndef convert(amount: float, currency: str, new_currency: str) -> float:\n \"\"\"Convert the currency with the latest exchange rate\n \n Args:\n amount: The amount of currency to convert\n currency: The currency to convert from\n new_currency: The currency to convert to\n \"\"\"\n\\`\\`\\`\n \n \nUser: What is $200,000 in EUR?\nmodel\n````\n\n*Note: The \\`\\`\\` should not be escaped when you use it, but my blog cannot render \\`\\`\\` inside a code block. See [code](https://github.com/philschmid/gemini-samples/blob/main/examples/gemma-function-calling.ipynb).*\n\n3. Handle Model response when a tool/function is used.\n\n```plaintext\nOkay, I need to convert $200,000 to EUR. I will use the `convert` function for this.\n\\`\\`\\`tool_code\nconvert(amount=200000.0, currency=\"USD\", new_currency=\"EUR\")\n\\`\\`\\`\n```\n\n4. Execute local function and create tool output string\n\n```plaintext\n\\`\\`\\`tool_output\n180000.0\n\\`\\`\\`\n```\n\n5. Send the tool output as new request to the model\n\n````plaintext\nuser\nAt each turn, if you decide to invoke any of the function(s), it should be wrapped with ```tool_code```. The python methods described below are imported and available, you can only use defined methods. The generated code should be readable and efficient. The response to a method will be wrapped in ```tool_output``` use it to call more tools or generate a helpful, friendly response. When using a ```tool_call``` think step by step why and how it should be used.\n \nThe following Python methods are available:\n \n\\`\\`\\`python\ndef convert(amount: float, currency: str, new_currency: str) -> float:\n \"\"\"Convert the currency with the latest exchange rate\n \n Args:\n amount: The amount of currency to convert\n currency: The currency to convert from\n new_currency: The currency to convert to\n \"\"\"\n\\`\\`\\`\n \nUser: What is $200,000 in EUR?\nmodel\nOkay, I need to convert $200,000 to EUR. I will use the `convert` function for this.\n\\`\\`\\`tool_code\nconvert(amount=200000.0, currency=\"USD\", new_currency=\"EUR\")\n\\`\\`\\`\nuser\n\\`\\`\\`tool_output\n180000.0\n\\`\\`\\`\nmodel\n````\n\n6. Final Response: `$200,000 is approximately €180,000`\n\n## Function Calling Example with Gemma 3 27B and Python.\n\nNow, let's test this using the GenAI API. If you want to do this locally, e.g. ollama. You can just use the prompts and simulate the function execution. So first install the `google-genai` SDK.\n\nPython\n\n```python\n%pip install google-genai\n```\n\nThen we create our `client`, define Gemma as model id and create a helper method `extract_tool_call`. This method parses the model responses and checks if there is a \\`\\`\\`tool\\_code\\`\\`\\`. If there is one it uses the `eval` method to run it, extract the result and create a \\`\\`\\`tool\\_output\\`\\`\\`.\n\n*Note: We use `eval` only for demonstration purposes if you plan to use this in production you should add more security and safety as it will execute model generated code in your environment.*\n\nPython\n\n````python\nimport os\nfrom google import genai\nimport re \n# create client\napi_key = os.getenv(\"GEMINI_API_KEY\",\"xxx\")\nclient = genai.Client(api_key=api_key)\n \n# speicfy the model id\nmodel_id = \"gemma-3-27b-it\"\n \n# extract the tool call from the response\ndef extract_tool_call(text):\n import io\n from contextlib import redirect_stdout\n \n pattern = r\"```tool_code\\s*(.*?)\\s*```\"\n match = re.search(pattern, text, re.DOTALL)\n if match:\n code = match.group(1).strip()\n # Capture stdout in a string buffer\n f = io.StringIO()\n with redirect_stdout(f):\n result = eval(code)\n output = f.getvalue()\n r = result if output == '' else output\n return f'```tool_output\\n{r}\\n```'''\n return None\n \n````\n\nNext, we define a simple example for a function we want to use. Here is is a `convert` method that simulates the conversion calcuation of currencies. Since we use `eval` the method we want to use for function calling needs to be available in the environment.\n\nWe define our first user prompt including our instructions and function signature with a docstring and args and a template string for our user message.\n\nPython\n\n````python\ndef convert(amount: float, currency: str, new_currency: str) -> float:\n # demo implementation\n return amount * 0.9\n \n \ninstruction_prompt_with_function_calling = '''At each turn, if you decide to invoke any of the function(s), it should be wrapped with ```tool_code```. The python methods described below are imported and available, you can only use defined methods. The generated code should be readable and efficient. The response to a method will be wrapped in ```tool_output``` use it to call more tools or generate a helpful, friendly response. When using a ```tool_call``` think step by step why and how it should be used.\n \nThe following Python methods are available:\n \n\\`\\`\\`python\ndef convert(amount: float, currency: str, new_currency: str) -> float:\n \"\"\"Convert the currency with the latest exchange rate\n \n Args:\n amount: The amount of currency to convert\n currency: The currency to convert from\n new_currency: The currency to convert to\n \"\"\"\n \ndef get_exchange_rate(currency: str, new_currency: str) -> float:\n \"\"\"Get the latest exchange rate for the currency pair\n \n Args:\n currency: The currency to convert from\n new_currency: The currency to convert to\n \"\"\"\n\\`\\`\\`\n \nUser: \\{user_message\\}'''\n````\n\n*Note: The \\`\\`\\` should not be escaped when you use it, but my blog cannot render \\`\\`\\` inside a code block. See [code](https://github.com/philschmid/gemini-samples/blob/main/examples/gemma-function-calling.ipynb).*\n\nThe `genai` SDK supports stateful chat session, which makes it quite easy to test our example as we can easily append the different messages. First, we start with a simple greeting to see what Gemma does.\n\nPython\n\n```python\nchat = client.chats.create(model=model_id)\n \nresponse = chat.send_message(instruction_prompt_with_function_calling.format(user_message=\"hello\"))\nprint(response.text)\n# Hello! How can I help you today? Do you want to convert some currency, or get an exchange rate?\n```\n\nNice! it greeted us back and didn't use any function call. Okay now lets ask it to convert some currency.\n\nPython\n\n````python\nresponse = chat.send_message(\"What is $200,000 in EUR?\")\nprint(response.text)\nOkay, I need to convert $200,000 to EUR. I will use the `convert` function for this.\n# ```tool_code\n# convert(amount=200000.0, currency=\"USD\", new_currency=\"EUR\")\n# ```\n````\n\nGreat! it generated out \\`\\`\\`tool\\_code\\`\\`\\`, which we can now use and extract and to cool our method.\n\nPython\n\n````python\ncall_response = extract_tool_call(response.text)\nprint(call_response)\n# ```tool_output\n# 180000.0\n# ```\n````\n\nAfter we have the response from our tool call we send a final message to generate a user friendly output.\n\nPython\n\n```python\nresponse = chat.send_message(call_response)\nprint(response.text)\n# $200,000 is equivalent to €180,000. Is there anything else I can help you with?\n```\n\n## Conclusion\n\nFunction calling enables us to build powerful AI assistants that can access real-time data, perform actions, handle complex interactions, and provide natural language interfaces to APIs and tools, making it an increasingly important capability for practical AI applications that interact with the real world.\n\nThis is a simplified example on how you could implement function calling with Gemma 3. I didn't run detailed evaluation or benchmarks. Gemma 3 is an open model with strong reasoning and instruction following capabilities. This allows you to further optimize the prompt used to match your use case and data or further fine-tune on data with similar format to customize its agentic capabilities.\n\n* * *\n\nThanks for reading! If you have any questions or feedback, please let me know on [Twitter](https://twitter.com/_philschmid) or [LinkedIn](https://www.linkedin.com/in/philipp-schmid-a6a2bb196/).\n", "authors": [], "captured_at": "2026-09-27T19:29:15.293681927+00:00", "category": "programming", "content_html": "

March 14, 2025 8 minute read View Code

\n

Google Gemma 3 27B It is an open, multilingual, multimodal Vision-Language model. It handles context windows up to 128k tokens, understands over 140 languages, and offers improved math, reasoning, and chat capabilities, including structured outputs and function calling.

\n

Gemma 3 can be used for agentic workflows and has very strong instruction following capabilities. While there are no dedicated tool/function calling special tokens, you can prompt it to do function calling through careful instruction. Gemma 3 27B is available via AI Studio and the Gen AI API. Get your API key from AI Studio.

\n

Function calling is the capability to connect LLMs to external tools and to interact with your code and APIs in a structured way. Instead of generating text responses, LLMs understand when to call specific functions and provide the necessary parameters to execute real-world actions.

\n

\"Function

\n

Function Calling follows these steps:

\n
    \n
  1. Your application sends a prompt to the LLM along with function definitions
    2. \n
  2. The LLM analyzes the prompt and decides whether to respond directly or use defined functions
    3. \n
  3. If using functions, the LLM generates structured arguments for the function call
    4. \n
  4. Your application receives the function call details and executes the actual function
    5. \n
  5. The function results are sent back to the LLM
    6. \n
  6. The LLM provides a final response incorporating the function results
    7. \n
\n

Raw Text Example of how function calling can be implement with Gemma 3

\n

Below is an textual example of how to use function calling with Gemma 3 27B It. In this example the first user message includes the general instruction how and when to use function calling and example flow. The prompt with the Gemma 3 template would look like this:

\n
    \n
  1. Send user message with instructions and function definitons and first user message.
    2. \n
\n
<bos><start_of_turn>user\nAt each turn, if you decide to invoke any of the function(s), it should be wrapped with ```tool_code```. The python methods described below are imported and available, you can only use defined methods. The generated code should be readable and efficient. The response to a method will be wrapped in ```tool_output``` use it to call more tools or generate a helpful, friendly response. When using a ```tool_call``` think step by step why and how it should be used.\n \nThe following Python methods are available:\n \n\\`\\`\\`python\ndef convert(amount: float, currency: str, new_currency: str) -> float:\n    """Convert the currency with the latest exchange rate\n \n    Args:\n      amount: The amount of currency to convert\n      currency: The currency to convert from\n      new_currency: The currency to convert to\n    """\n\\`\\`\\`\n \n \nUser: What is $200,000 in EUR?<end_of_turn>\n<start_of_turn>model\n
\n

Note: The ``` should not be escaped when you use it, but my blog cannot render ``` inside a code block. See code.

\n
    \n
  1. Handle Model response when a tool/function is used.
    2. \n
\n
Okay, I need to convert $200,000 to EUR. I will use the `convert` function for this.\n\\`\\`\\`tool_code\nconvert(amount=200000.0, currency="USD", new_currency="EUR")\n\\`\\`\\`\n
\n
    \n
  1. Execute local function and create tool output string
    2. \n
\n
\\`\\`\\`tool_output\n180000.0\n\\`\\`\\`\n
\n
    \n
  1. Send the tool output as new request to the model
    2. \n
\n
<bos><start_of_turn>user\nAt each turn, if you decide to invoke any of the function(s), it should be wrapped with ```tool_code```. The python methods described below are imported and available, you can only use defined methods. The generated code should be readable and efficient. The response to a method will be wrapped in ```tool_output``` use it to call more tools or generate a helpful, friendly response. When using a ```tool_call``` think step by step why and how it should be used.\n \nThe following Python methods are available:\n \n\\`\\`\\`python\ndef convert(amount: float, currency: str, new_currency: str) -> float:\n    """Convert the currency with the latest exchange rate\n \n    Args:\n      amount: The amount of currency to convert\n      currency: The currency to convert from\n      new_currency: The currency to convert to\n    """\n\\`\\`\\`\n \nUser: What is $200,000 in EUR?<end_of_turn>\n<start_of_turn>model\nOkay, I need to convert $200,000 to EUR. I will use the `convert` function for this.\n\\`\\`\\`tool_code\nconvert(amount=200000.0, currency="USD", new_currency="EUR")\n\\`\\`\\`<end_of_turn>\n<start_of_turn>user\n\\`\\`\\`tool_output\n180000.0\n\\`\\`\\`<end_of_turn>\n<start_of_turn>model\n
\n
    \n
  1. Final Response: $200,000 is approximately €180,000
    2. \n
\n

Function Calling Example with Gemma 3 27B and Python.

\n

Now, let's test this using the GenAI API. If you want to do this locally, e.g. ollama. You can just use the prompts and simulate the function execution. So first install the google-genai SDK.

\n

Python

\n
%pip install google-genai\n
\n

Then we create our client, define Gemma as model id and create a helper method extract_tool_call. This method parses the model responses and checks if there is a ```tool_code```. If there is one it uses the eval method to run it, extract the result and create a ```tool_output```.

\n

Note: We use eval only for demonstration purposes if you plan to use this in production you should add more security and safety as it will execute model generated code in your environment.

\n

Python

\n
import os\nfrom google import genai\nimport re \n# create client\napi_key = os.getenv("GEMINI_API_KEY","xxx")\nclient = genai.Client(api_key=api_key)\n \n# speicfy the model id\nmodel_id = "gemma-3-27b-it"\n \n# extract the tool call from the response\ndef extract_tool_call(text):\n    import io\n    from contextlib import redirect_stdout\n \n    pattern = r"```tool_code\\s*(.*?)\\s*```"\n    match = re.search(pattern, text, re.DOTALL)\n    if match:\n        code = match.group(1).strip()\n        # Capture stdout in a string buffer\n        f = io.StringIO()\n        with redirect_stdout(f):\n            result = eval(code)\n        output = f.getvalue()\n        r = result if output == '' else output\n        return f'```tool_output\\n{r}\\n```'''\n    return None\n \n
\n

Next, we define a simple example for a function we want to use. Here is is a convert method that simulates the conversion calcuation of currencies. Since we use eval the method we want to use for function calling needs to be available in the environment.

\n

We define our first user prompt including our instructions and function signature with a docstring and args and a template string for our user message.

\n

Python

\n
def convert(amount: float, currency: str, new_currency: str) -> float:\n  # demo implementation\n  return amount * 0.9\n \n \ninstruction_prompt_with_function_calling = '''At each turn, if you decide to invoke any of the function(s), it should be wrapped with ```tool_code```. The python methods described below are imported and available, you can only use defined methods. The generated code should be readable and efficient. The response to a method will be wrapped in ```tool_output``` use it to call more tools or generate a helpful, friendly response. When using a ```tool_call``` think step by step why and how it should be used.\n \nThe following Python methods are available:\n \n\\`\\`\\`python\ndef convert(amount: float, currency: str, new_currency: str) -> float:\n    """Convert the currency with the latest exchange rate\n \n    Args:\n      amount: The amount of currency to convert\n      currency: The currency to convert from\n      new_currency: The currency to convert to\n    """\n \ndef get_exchange_rate(currency: str, new_currency: str) -> float:\n    """Get the latest exchange rate for the currency pair\n \n    Args:\n      currency: The currency to convert from\n      new_currency: The currency to convert to\n    """\n\\`\\`\\`\n \nUser: \\{user_message\\}'''\n
\n

Note: The ``` should not be escaped when you use it, but my blog cannot render ``` inside a code block. See code.

\n

The genai SDK supports stateful chat session, which makes it quite easy to test our example as we can easily append the different messages. First, we start with a simple greeting to see what Gemma does.

\n

Python

\n
chat = client.chats.create(model=model_id)\n \nresponse = chat.send_message(instruction_prompt_with_function_calling.format(user_message="hello"))\nprint(response.text)\n# Hello! How can I help you today? Do you want to convert some currency, or get an exchange rate?\n
\n

Nice! it greeted us back and didn't use any function call. Okay now lets ask it to convert some currency.

\n

Python

\n
response = chat.send_message("What is $200,000 in EUR?")\nprint(response.text)\nOkay, I need to convert $200,000 to EUR. I will use the `convert` function for this.\n# ```tool_code\n# convert(amount=200000.0, currency="USD", new_currency="EUR")\n# ```\n
\n

Great! it generated out ```tool_code```, which we can now use and extract and to cool our method.

\n

Python

\n
call_response = extract_tool_call(response.text)\nprint(call_response)\n# ```tool_output\n# 180000.0\n# ```\n
\n

After we have the response from our tool call we send a final message to generate a user friendly output.

\n

Python

\n
response = chat.send_message(call_response)\nprint(response.text)\n# $200,000 is equivalent to €180,000. Is there anything else I can help you with?\n
\n

Conclusion

\n

Function calling enables us to build powerful AI assistants that can access real-time data, perform actions, handle complex interactions, and provide natural language interfaces to APIs and tools, making it an increasingly important capability for practical AI applications that interact with the real world.

\n

This is a simplified example on how you could implement function calling with Gemma 3. I didn't run detailed evaluation or benchmarks. Gemma 3 is an open model with strong reasoning and instruction following capabilities. This allows you to further optimize the prompt used to match your use case and data or further fine-tune on data with similar format to customize its agentic capabilities.

\n
\n

Thanks for reading! If you have any questions or feedback, please let me know on Twitter or LinkedIn.

\n", "content_markdown": "March 14, 2025 8 minute read [View Code](https://github.com/philschmid/gemini-samples/blob/main/examples/gemma-function-calling.ipynb)\n\nGoogle Gemma 3 27B It is an open, multilingual, multimodal Vision-Language model. It handles context windows up to 128k tokens, understands over 140 languages, and offers improved math, reasoning, and chat capabilities, including structured outputs and function calling.\n\nGemma 3 can be used for agentic workflows and has very strong instruction following capabilities. While there are no dedicated tool/function calling special tokens, you can prompt it to do function calling through careful instruction. Gemma 3 27B is available via [AI Studio](https://aistudio.google.com/prompts/new_chat?model=gemma-3-27b-it) and the Gen AI API. Get your API key from [AI Studio](https://aistudio.google.com/apikey).\n\nFunction calling is the capability to connect LLMs to external tools and to interact with your code and APIs in a structured way. Instead of generating text responses, LLMs understand when to call specific functions and provide the necessary parameters to execute real-world actions.\n\n![Function calling](https://www.philschmid.de/static/blog/gemini-function-calling/function-calling.png)\n\nFunction Calling follows these steps:\n\n1. Your application sends a prompt to the LLM along with function definitions\n2. The LLM analyzes the prompt and decides whether to respond directly or use defined functions\n3. If using functions, the LLM generates structured arguments for the function call\n4. Your application receives the function call details and executes the actual function\n5. The function results are sent back to the LLM\n6. The LLM provides a final response incorporating the function results\n\n## Raw Text Example of how function calling can be implement with Gemma 3\n\nBelow is an textual example of how to use function calling with Gemma 3 27B It. In this example the first user message includes the general instruction how and when to use function calling and example flow. The prompt with the Gemma 3 template would look like this:\n\n1. Send user message with instructions and function definitons and first user message.\n\n````plaintext\nuser\nAt each turn, if you decide to invoke any of the function(s), it should be wrapped with ```tool_code```. The python methods described below are imported and available, you can only use defined methods. The generated code should be readable and efficient. The response to a method will be wrapped in ```tool_output``` use it to call more tools or generate a helpful, friendly response. When using a ```tool_call``` think step by step why and how it should be used.\n \nThe following Python methods are available:\n \n\\`\\`\\`python\ndef convert(amount: float, currency: str, new_currency: str) -> float:\n \"\"\"Convert the currency with the latest exchange rate\n \n Args:\n amount: The amount of currency to convert\n currency: The currency to convert from\n new_currency: The currency to convert to\n \"\"\"\n\\`\\`\\`\n \n \nUser: What is $200,000 in EUR?\nmodel\n````\n\n*Note: The \\`\\`\\` should not be escaped when you use it, but my blog cannot render \\`\\`\\` inside a code block. See [code](https://github.com/philschmid/gemini-samples/blob/main/examples/gemma-function-calling.ipynb).*\n\n3. Handle Model response when a tool/function is used.\n\n```plaintext\nOkay, I need to convert $200,000 to EUR. I will use the `convert` function for this.\n\\`\\`\\`tool_code\nconvert(amount=200000.0, currency=\"USD\", new_currency=\"EUR\")\n\\`\\`\\`\n```\n\n4. Execute local function and create tool output string\n\n```plaintext\n\\`\\`\\`tool_output\n180000.0\n\\`\\`\\`\n```\n\n5. Send the tool output as new request to the model\n\n````plaintext\nuser\nAt each turn, if you decide to invoke any of the function(s), it should be wrapped with ```tool_code```. The python methods described below are imported and available, you can only use defined methods. The generated code should be readable and efficient. The response to a method will be wrapped in ```tool_output``` use it to call more tools or generate a helpful, friendly response. When using a ```tool_call``` think step by step why and how it should be used.\n \nThe following Python methods are available:\n \n\\`\\`\\`python\ndef convert(amount: float, currency: str, new_currency: str) -> float:\n \"\"\"Convert the currency with the latest exchange rate\n \n Args:\n amount: The amount of currency to convert\n currency: The currency to convert from\n new_currency: The currency to convert to\n \"\"\"\n\\`\\`\\`\n \nUser: What is $200,000 in EUR?\nmodel\nOkay, I need to convert $200,000 to EUR. I will use the `convert` function for this.\n\\`\\`\\`tool_code\nconvert(amount=200000.0, currency=\"USD\", new_currency=\"EUR\")\n\\`\\`\\`\nuser\n\\`\\`\\`tool_output\n180000.0\n\\`\\`\\`\nmodel\n````\n\n6. Final Response: `$200,000 is approximately €180,000`\n\n## Function Calling Example with Gemma 3 27B and Python.\n\nNow, let's test this using the GenAI API. If you want to do this locally, e.g. ollama. You can just use the prompts and simulate the function execution. So first install the `google-genai` SDK.\n\nPython\n\n```python\n%pip install google-genai\n```\n\nThen we create our `client`, define Gemma as model id and create a helper method `extract_tool_call`. This method parses the model responses and checks if there is a \\`\\`\\`tool\\_code\\`\\`\\`. If there is one it uses the `eval` method to run it, extract the result and create a \\`\\`\\`tool\\_output\\`\\`\\`.\n\n*Note: We use `eval` only for demonstration purposes if you plan to use this in production you should add more security and safety as it will execute model generated code in your environment.*\n\nPython\n\n````python\nimport os\nfrom google import genai\nimport re \n# create client\napi_key = os.getenv(\"GEMINI_API_KEY\",\"xxx\")\nclient = genai.Client(api_key=api_key)\n \n# speicfy the model id\nmodel_id = \"gemma-3-27b-it\"\n \n# extract the tool call from the response\ndef extract_tool_call(text):\n import io\n from contextlib import redirect_stdout\n \n pattern = r\"```tool_code\\s*(.*?)\\s*```\"\n match = re.search(pattern, text, re.DOTALL)\n if match:\n code = match.group(1).strip()\n # Capture stdout in a string buffer\n f = io.StringIO()\n with redirect_stdout(f):\n result = eval(code)\n output = f.getvalue()\n r = result if output == '' else output\n return f'```tool_output\\n{r}\\n```'''\n return None\n \n````\n\nNext, we define a simple example for a function we want to use. Here is is a `convert` method that simulates the conversion calcuation of currencies. Since we use `eval` the method we want to use for function calling needs to be available in the environment.\n\nWe define our first user prompt including our instructions and function signature with a docstring and args and a template string for our user message.\n\nPython\n\n````python\ndef convert(amount: float, currency: str, new_currency: str) -> float:\n # demo implementation\n return amount * 0.9\n \n \ninstruction_prompt_with_function_calling = '''At each turn, if you decide to invoke any of the function(s), it should be wrapped with ```tool_code```. The python methods described below are imported and available, you can only use defined methods. The generated code should be readable and efficient. The response to a method will be wrapped in ```tool_output``` use it to call more tools or generate a helpful, friendly response. When using a ```tool_call``` think step by step why and how it should be used.\n \nThe following Python methods are available:\n \n\\`\\`\\`python\ndef convert(amount: float, currency: str, new_currency: str) -> float:\n \"\"\"Convert the currency with the latest exchange rate\n \n Args:\n amount: The amount of currency to convert\n currency: The currency to convert from\n new_currency: The currency to convert to\n \"\"\"\n \ndef get_exchange_rate(currency: str, new_currency: str) -> float:\n \"\"\"Get the latest exchange rate for the currency pair\n \n Args:\n currency: The currency to convert from\n new_currency: The currency to convert to\n \"\"\"\n\\`\\`\\`\n \nUser: \\{user_message\\}'''\n````\n\n*Note: The \\`\\`\\` should not be escaped when you use it, but my blog cannot render \\`\\`\\` inside a code block. See [code](https://github.com/philschmid/gemini-samples/blob/main/examples/gemma-function-calling.ipynb).*\n\nThe `genai` SDK supports stateful chat session, which makes it quite easy to test our example as we can easily append the different messages. First, we start with a simple greeting to see what Gemma does.\n\nPython\n\n```python\nchat = client.chats.create(model=model_id)\n \nresponse = chat.send_message(instruction_prompt_with_function_calling.format(user_message=\"hello\"))\nprint(response.text)\n# Hello! How can I help you today? Do you want to convert some currency, or get an exchange rate?\n```\n\nNice! it greeted us back and didn't use any function call. Okay now lets ask it to convert some currency.\n\nPython\n\n````python\nresponse = chat.send_message(\"What is $200,000 in EUR?\")\nprint(response.text)\nOkay, I need to convert $200,000 to EUR. I will use the `convert` function for this.\n# ```tool_code\n# convert(amount=200000.0, currency=\"USD\", new_currency=\"EUR\")\n# ```\n````\n\nGreat! it generated out \\`\\`\\`tool\\_code\\`\\`\\`, which we can now use and extract and to cool our method.\n\nPython\n\n````python\ncall_response = extract_tool_call(response.text)\nprint(call_response)\n# ```tool_output\n# 180000.0\n# ```\n````\n\nAfter we have the response from our tool call we send a final message to generate a user friendly output.\n\nPython\n\n```python\nresponse = chat.send_message(call_response)\nprint(response.text)\n# $200,000 is equivalent to €180,000. Is there anything else I can help you with?\n```\n\n## Conclusion\n\nFunction calling enables us to build powerful AI assistants that can access real-time data, perform actions, handle complex interactions, and provide natural language interfaces to APIs and tools, making it an increasingly important capability for practical AI applications that interact with the real world.\n\nThis is a simplified example on how you could implement function calling with Gemma 3. I didn't run detailed evaluation or benchmarks. Gemma 3 is an open model with strong reasoning and instruction following capabilities. This allows you to further optimize the prompt used to match your use case and data or further fine-tune on data with similar format to customize its agentic capabilities.\n\n* * *\n\nThanks for reading! If you have any questions or feedback, please let me know on [Twitter](https://twitter.com/_philschmid) or [LinkedIn](https://www.linkedin.com/in/philipp-schmid-a6a2bb196/).\n", "dateCreated": "2026-09-27T19:29:15.293681927+00:00", "date_created": "2025-03-14T00:00:00+00:00", "date_modified": "2025-03-14T00:00:00+00:00", "date_published": "2025-03-14T00:00:00+00:00", "description": "Learn how to use function calling with Google DeepMind Gemma 3 27B It", "external_url": "https://www.philschmid.de/gemma-function-calling", "git": { "commit": "ebb0941c5c06a2ab2377342d607535262a3e969e", "path": "items/philschmid-de/2025/03/2025-03-14-google-gemma-3-function-calling-example.md", "permalink": "https://github.com/aymericbeaumet/aggr-instance/blob/ebb0941c5c06a2ab2377342d607535262a3e969e/items/philschmid-de/2025/03/2025-03-14-google-gemma-3-function-calling-example.md" }, "id": "urn:aggr:item:88f060a5ad3bac4442ad198e066d3595b7ea9122", "isBasedOn": { "@id": "https://www.philschmid.de/gemma-function-calling" }, "mainEntity": { "@id": "https://www.philschmid.de/gemma-function-calling", "@type": "CreativeWork", "archivedAt": { "@id": "https://aggr.aymericbeaumet.com/items/philschmid-de/2025-03-14-google-gemma-3-function-calling-example/#webpage" }, "dateModified": "2025-03-14T00:00:00+00:00", "datePublished": "2025-03-14T00:00:00+00:00", "headline": "Google Gemma 3 Function Calling Example", "timeRequired": "PT7M", "url": "https://www.philschmid.de/gemma-function-calling", "wordCount": 1475 }, "name": "Archived snapshot: Google Gemma 3 Function Calling Example", "preview": null, "reading_minutes": 7, "replicated_at": null, "source": "philschmid-de", "source_name": "philschmid.de - RSS feed", "summary": "Learn how to use function calling with Google DeepMind Gemma 3 27B It", "tags": [], "temporalCoverage": "2026-09-27T19:29:15.293681927+00:00", "title": "Google Gemma 3 Function Calling Example", "url": "https://aggr.aymericbeaumet.com/items/philschmid-de/2025-03-14-google-gemma-3-function-calling-example/", "word_count": 1475 }