	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > Gemini Function Calling

Gemini Function Calling

Author: Venkata Sudhakar

Gemini function calling lets you give the model access to your own business functions so it can look up real data before answering. When a customer asks "where is my order?" Gemini does not guess - it calls your order tracking function with the order number, reads the real status, and gives a grounded answer. You define functions as tools, Gemini decides when and how to call them, you execute the function and return the result, and Gemini incorporates it into its final response. This is how you build Gemini-powered assistants that are connected to your actual business systems rather than relying on the model knowledge alone.

In the google-genai SDK, tools are defined as ordinary Python functions with docstrings and type hints - the SDK automatically generates the JSON schema. Pass the function list in the tools parameter of generate_content. When Gemini decides to call a function it returns a function_call part; you execute it and send back a function_response part in the next turn. The SDK also supports automatic_function_calling which handles this loop for you - ideal for simple single-tool scenarios where you want minimal boilerplate.

The below example shows an online fashion retailer whose customer service chatbot checks order status and return eligibility - giving accurate real-time answers grounded in actual order data, not guesses.

from google import genai
from google.genai import types
from datetime import datetime

client = genai.Client(api_key="your-gemini-api-key")

# Business functions with docstrings - SDK reads these to build the tool schema
def get_order_status(order_id: str) -> dict:
    """Get current status and delivery details for a customer order.

Args:
        order_id: The order ID from the receipt, e.g. ORD-58291
    """
    orders = {
        "ORD-58291": {"status": "Out for delivery",
                      "product": "Blue Denim Jacket - Size M",
                      "carrier": "Delhivery", "eta": "Today by 8pm"},
        "ORD-44102": {"status": "Delivered",
                      "product": "Floral Kurta Set - Size L",
                      "delivered_on": "28 March 2025"},
        "ORD-71839": {"status": "Processing",
                      "product": "Leather Sneakers - Size 9",
                      "expected_dispatch": "1 April 2025"}
    }
    return orders.get(order_id, {"error": "Order not found. Please check the ID."})

def check_return_eligibility(order_id: str) -> dict:
    """Check if an order is eligible for return or exchange within 7 days.

Args:
        order_id: The order ID to check return eligibility for
    """
    delivered = {
        "ORD-44102": "2025-03-28",
        "ORD-58291": None,   # not yet delivered
        "ORD-71839": None    # not yet delivered
    }
    if order_id not in delivered:
        return {"eligible": False, "reason": "Order not found"}
    if delivered[order_id] is None:
        return {"eligible": False, "reason": "Order has not been delivered yet"}
    days_since = (datetime.today() - datetime.strptime(delivered[order_id], "%Y-%m-%d")).days
    if days_since <= 7:
        return {"eligible": True, "days_remaining": 7 - days_since,
                "instructions": "Go to StyleHub app > Orders > Return. "
                                "Free pickup within 24 hours."}
    return {"eligible": False, "reason": "7-day return window has expired"}

tools = [get_order_status, check_return_eligibility]

Running the Gemini function calling loop with real customer questions,

SYSTEM = ("You are a helpful StyleHub customer service agent. "
          "Always use tools to look up real order data before answering. "
          "Be warm and specific.")

def answer_customer(question: str) -> str:
    messages = [types.Content(role="user", parts=[types.Part.from_text(question)])]
    while True:
        resp = client.models.generate_content(
            model="gemini-2.0-flash",
            config=types.GenerateContentConfig(
                system_instruction=SYSTEM, tools=tools, max_output_tokens=250
            ),
            contents=messages
        )
        cand = resp.candidates[0]
        func_calls = [p for p in cand.content.parts if p.function_call]
        if not func_calls:
            return next(p.text for p in cand.content.parts if hasattr(p, "text"))
        messages.append(cand.content)
        fn_map = {"get_order_status": get_order_status,
                  "check_return_eligibility": check_return_eligibility}
        func_responses = []
        for part in func_calls:
            fc = part.function_call
            print("  [Tool] " + fc.name + " " + str(dict(fc.args)))
            result = fn_map[fc.name](**dict(fc.args))
            print("  [Data] " + str(result))
            func_responses.append(types.Part.from_function_response(
                name=fc.name, response=result))
        messages.append(types.Content(role="user", parts=func_responses))

for q in [
    "My order ORD-58291 was supposed to arrive today. Where is it?",
    "Can I return my Kurta from order ORD-44102?",
    "Check status of ORD-71839 and whether I can return it"
]:
    print("Customer:", q)
    print("Gemini:  ", answer_customer(q))
    print()

It gives the following output showing function calls before each answer,

Customer: My order ORD-58291 was supposed to arrive today. Where is it?
  [Tool] get_order_status {"order_id": "ORD-58291"}
  [Data] {"status": "Out for delivery", "product": "Blue Denim Jacket...", "eta": "Today by 8pm"}
Gemini:   Great news! Your Blue Denim Jacket (Size M) from order ORD-58291
          is out for delivery with Delhivery and is expected to arrive today
          by 8pm. You will receive an SMS update when it is nearby!

Customer: Can I return my Kurta from order ORD-44102?
  [Tool] check_return_eligibility {"order_id": "ORD-44102"}
  [Data] {"eligible": True, "days_remaining": 3, "instructions": "Go to StyleHub app..."}
Gemini:   Yes, your Floral Kurta Set is eligible for return! You have 3 days
          left in your 7-day return window. Just go to StyleHub app > Orders
          > Return and free pickup will be arranged within 24 hours.

Customer: Check status of ORD-71839 and whether I can return it
  [Tool] get_order_status {"order_id": "ORD-71839"}
  [Tool] check_return_eligibility {"order_id": "ORD-71839"}
  [Data] {"status": "Processing", "expected_dispatch": "1 April 2025"}
  [Data] {"eligible": False, "reason": "Order has not been delivered yet"}
Gemini:   Your Leather Sneakers (ORD-71839) are still being processed and
          are expected to be dispatched by 1 April. Returns are only possible
          after delivery, so check back once you receive them!

# Third question: Gemini called BOTH tools simultaneously - efficient!

Gemini often calls multiple tools in parallel in a single response when it can see that multiple lookups are needed - this is more efficient than sequential tool calls. The SDK detects multiple function_call parts in one response content. Automatic function calling (set automatic_function_calling_config in GenerateContentConfig) removes the need to write the loop entirely - the SDK calls your Python functions automatically and returns only the final text answer. Use the manual loop when you need to log tool calls, add latency tracking, or apply business logic between the tool call and the result being sent back to Gemini.

Send your comments, suggestions or queries regarding this site to [email protected].