Thirrja e funksionit me API-n Gemini

Thirrja e funksioneve ju lejon të lidhni modelet me mjete dhe API të jashtme. Në vend që të gjenerojë përgjigje me tekst, modeli përcakton se kur duhet të thirren funksione specifike dhe ofron parametrat e nevojshëm për të ekzekutuar veprime të botës reale. Kjo i lejon modelit të veprojë si një urë lidhëse midis gjuhës natyrore dhe veprimeve dhe të dhënave të botës reale. Thirrja e funksioneve ka 3 raste përdorimi kryesore:

  • Rrit njohuritë: Qasje informacioni nga burime të jashtme si bazat e të dhënave, API-të dhe bazat e njohurive.
  • Zgjerimi i Aftësive: Përdorni mjete të jashtme për të kryer llogaritjet dhe për të zgjeruar kufizimet e modelit, siç është përdorimi i një kalkulatori ose krijimi i grafikëve.
  • Ndërmerrni Veprime: Ndërveproni me sisteme të jashtme duke përdorur API-të, të tilla si caktimi i takimeve, krijimi i faturave, dërgimi i email-eve ose kontrollimi i pajisjeve inteligjente të shtëpisë.

e Motit

Python 

from google import genai

schedule_meeting_function = {
    "type": "function",
    "name": "schedule_meeting",
    "description": "Schedules a meeting with specified attendees at a given time and date.",
    "parameters": {
        "type": "object",
        "properties": {
            "attendees": {"type": "array", "items": {"type": "string"}},
            "date": {"type": "string", "description": "Date (e.g., '2024-07-29')"},
            "time": {"type": "string", "description": "Time (e.g., '15:00')"},
            "topic": {"type": "string", "description": "The meeting topic."},
        },
        "required": ["attendees", "date", "time", "topic"],
    },
}

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3-flash-preview",
    input="Schedule a meeting with Bob and Alice for 03/14/2025 at 10:00 AM about Q3 planning.",
    tools=[{"type": "function", **schedule_meeting_function}],
)

for step in interaction.steps:
    if step.type == "function_call":
        print(f"Function to call: {step.name}")
        print(f"Arguments: {step.arguments}")

JavaScript 

import { GoogleGenAI } from '@google/genai';

const client = new GoogleGenAI({});

const scheduleMeetingFunction = {
  type: 'function',
  name: 'schedule_meeting',
  description: 'Schedules a meeting with specified attendees at a given time and date.',
  parameters: {
    type: 'object',
    properties: {
      attendees: { type: 'array', items: { type: 'string' } },
      date: { type: 'string', description: 'Date (e.g., "2024-07-29")' },
      time: { type: 'string', description: 'Time (e.g., "15:00")' },
      topic: { type: 'string', description: 'The meeting topic.' },
    },
    required: ['attendees', 'date', 'time', 'topic'],
  },
};

const interaction = await client.interactions.create({
  model: 'gemini-3-flash-preview',
  input: 'Schedule a meeting with Bob and Alice for 03/27/2025 at 10:00 AM about Q3 planning.',
  tools: [scheduleMeetingFunction],
});

for (const step of interaction.steps) {
  if (step.type === 'function_call') {
    console.log(`Function to call: ${step.name}`);
    console.log(`Arguments: ${JSON.stringify(step.arguments)}`);
  }
}

PUSHTIM 

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-3-flash-preview",
    "input": "Schedule a meeting with Bob and Alice for 03/27/2025 at 10:00 AM about Q3 planning.",
    "tools": [{
        "type": "function",
        "name": "schedule_meeting",
        "description": "Schedules a meeting with specified attendees at a given time and date.",
        "parameters": {
          "type": "object",
          "properties": {
            "attendees": {"type": "array", "items": {"type": "string"}},
            "date": {"type": "string"},
            "time": {"type": "string"},
            "topic": {"type": "string"}
          },
          "required": ["attendees", "date", "time", "topic"]
        }
    }]
  }'

Si funksionon thirrja e funksionit

përmbledhje e thirrjes së funksionit

Thirrja e funksionit përfshin një bashkëveprim të strukturuar midis aplikacionit tuaj, modelit dhe funksioneve të jashtme:

  1. Përcaktoni Deklaratën e Funksionit: Përcaktoni emrin, parametrat dhe qëllimin e funksionit për modelin.
  2. Thirrja e LLM me deklaratat e funksionit: Dërgoni kërkesën e përdoruesit së bashku me deklaratën(at) e funksionit te modeli.
  3. Ekzekutoni Kodin e Funksionit (Përgjegjësia Juaj): Modeli nuk e ekzekuton vetë funksionin. Nxirrni emrin dhe argumentet dhe ekzekutojeni në aplikacionin tuaj.
  4. Krijo një përgjigje miqësore për përdoruesin: Dërgo rezultatin përsëri te modeli për një përgjigje përfundimtare, miqësore për përdoruesin.

Ky proces mund të përsëritet në disa raunde. Modeli mbështet thirrjen e shumë funksioneve në një raund të vetëm ( thirrje paralele e funksioneve ) dhe në sekuencë ( thirrje kompozicionale e funksioneve ).

Hapi 1: Përcaktoni një deklaratë funksioni

Python 

set_light_values_declaration = {
    "type": "function",
    "name": "set_light_values",
    "description": "Sets the brightness and color temperature of a light.",
    "parameters": {
        "type": "object",
        "properties": {
            "brightness": {
                "type": "integer",
                "description": "Light level from 0 to 100",
            },
            "color_temp": {
                "type": "string",
                "enum": ["daylight", "cool", "warm"],
                "description": "Color temperature",
            },
        },
        "required": ["brightness", "color_temp"],
    },
}

def set_light_values(brightness: int, color_temp: str) -> dict:
    """Set the brightness and color temperature of a room light."""
    return {"brightness": brightness, "colorTemperature": color_temp}

JavaScript 

const setLightValuesTool = {
  type: 'function',
  name: 'set_light_values',
  description: 'Sets the brightness and color temperature of a light.',
  parameters: {
    type: 'object',
    properties: {
      brightness: { type: 'number', description: 'Light level from 0 to 100' },
      color_temp: { type: 'string', enum: ['daylight', 'cool', 'warm'] },
    },
    required: ['brightness', 'color_temp'],
  },
};

function setLightValues(brightness, color_temp) {
  return { brightness: brightness, colorTemperature: color_temp };
}

Hapi 2: Thirrni modelin me deklaratat e funksionit

Python 

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3-flash-preview",
    input="Turn the lights down to a romantic level",
    tools=[set_light_values_declaration],
)

# Find the function call step
fc_step = next(s for s in interaction.steps if s.type == "function_call")
print(fc_step)

JavaScript 

import { GoogleGenAI } from '@google/genai';

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
  model: 'gemini-3-flash-preview',
  input: 'Turn the lights down to a romantic level',
  tools: [setLightValuesTool],
});

// Find the function call step
const fcStep = interaction.steps.find(s => s.type === 'function_call');
console.log(fcStep);

Modeli kthen një hap function_call me type , name dhe arguments : 

type='function_call'
name='set_light_values'
arguments={'color_temp': 'warm', 'brightness': 25}

Hapi 3: Ekzekutoni funksionin

Python 

fc_step = next(s for s in interaction.steps if s.type == "function_call")

if fc_step.name == "set_light_values":
    result = set_light_values(**fc_step.arguments)
    print(f"Function execution result: {result}")

JavaScript 

const fcStep = interaction.steps.find(s => s.type === 'function_call');

let result;
if (fcStep.name === 'set_light_values') {
  result = setLightValues(fcStep.arguments.brightness, fcStep.arguments.color_temp);
  console.log(`Function execution result: ${JSON.stringify(result)}`);
}

Hapi 4: Dërgo rezultatin përsëri te modeli

Python 

final_interaction = client.interactions.create(
    model="gemini-3-flash-preview",
    input=[
        {
            "type": "function_result",
            "name": fc_step.name,
            "call_id": fc_step.id,
            "result": [{"type": "text", "text": json.dumps(result)}],
        }
    ],
    tools=[set_light_values_declaration],
    previous_interaction_id=interaction.id,
)

print(final_interaction.steps[-1].content[0].text)

JavaScript 

const finalInteraction = await client.interactions.create({
  model: 'gemini-3-flash-preview',
  input: [{
    type: 'function_result',
    name: fcStep.name,
    call_id: fcStep.id,
    result: [{ type: 'text', text: JSON.stringify(result) }]
  }],
  tools: [setLightValuesTool],
  previousInteractionId: interaction.id,
});

console.log(finalInteraction.steps.at(-1).content[0].text);

Deklaratat e funksioneve

Një deklaratë funksioni kalohet si një mjet dhe përfshin:

  • type (string): Duhet të jetë "function" për funksionet e personalizuara.
  • name (string): Emër unik i funksionit (përdor nënvizime ose camelCase).
  • description (varg): Shpjegim i qartë i qëllimit të funksionit.
  • parameters (objekti): Futni parametrat që funksioni pret.
    • type (string): Lloji i përgjithshëm i të dhënave, siç është object .
    • properties (objekti): Parametrat individualë me llojin dhe përshkrimin.
    • required (matricë): Emrat e parametrave të detyrueshëm.

Thirrja e funksioneve me modele të të menduarit

Modelet e serive Gemini 3 dhe 2.5 përdorin një proces të brendshëm "të të menduarit" që përmirëson thirrjen e funksioneve. SDK-të përpunojnë automatikisht nënshkrimet e mendimit për ju.

Thirrja paralele e funksionit

Thirrni disa funksione në të njëjtën kohë kur ato janë të pavarura:

Python 

power_disco_ball = {"type": "function", "name": "power_disco_ball", "description": "Powers the disco ball.",
    "parameters": {"type": "object", "properties": {"power": {"type": "boolean"}}, "required": ["power"]}}
start_music = {"type": "function", "name": "start_music", "description": "Play music.",
    "parameters": {"type": "object", "properties": {"energetic": {"type": "boolean"}, "loud": {"type": "boolean"}}, "required": ["energetic", "loud"]}}
dim_lights = {"type": "function", "name": "dim_lights", "description": "Dim the lights.",
    "parameters": {"type": "object", "properties": {"brightness": {"type": "number"}}, "required": ["brightness"]}}

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3-flash-preview",
    input="Turn this place into a party!",
    tools=[power_disco_ball, start_music, dim_lights],
    generation_config={"tool_choice": "any"},
)

for step in interaction.steps:
    if step.type == "function_call":
        args = ", ".join(f"{key}={val}" for key, val in step.arguments.items())
        print(f"{step.name}({args})")

JavaScript 

const powerDiscoBall = { type: 'function', name: 'power_disco_ball', description: 'Powers the disco ball.',
  parameters: { type: 'object', properties: { power: { type: 'boolean' } }, required: ['power'] } };
const startMusic = { type: 'function', name: 'start_music', description: 'Play music.',
  parameters: { type: 'object', properties: { energetic: { type: 'boolean' }, loud: { type: 'boolean' } }, required: ['energetic', 'loud'] } };
const dimLights = { type: 'function', name: 'dim_lights', description: 'Dim the lights.',
  parameters: { type: 'object', properties: { brightness: { type: 'number' } }, required: ['brightness'] } };

const interaction = await client.interactions.create({
  model: 'gemini-3-flash-preview',
  input: 'Turn this place into a party!',
  tools: [powerDiscoBall, startMusic, dimLights],
  generationConfig: { toolChoice: 'any' },
});

for (const step of interaction.steps) {
  if (step.type === 'function_call') {
    console.log(`${step.name}(${JSON.stringify(step.arguments)})`);
  }
}

Thirrja e funksionit kompozitiv

Ndërtoni së bashku thirrje të shumëfishta funksionesh për kërkesa komplekse (p.sh., merrni së pari vendndodhjen, pastaj merrni motin për atë vendndodhje).

Python 

def get_weather_forecast(location: str) -> dict:
    """Gets the current weather temperature for a given location."""
    return {"temperature": 25, "unit": "celsius"}

def set_thermostat_temperature(temperature: int) -> dict:
    """Sets the thermostat to a desired temperature."""
    return {"status": "success"}

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3-flash-preview",
    input="If it's warmer than 20°C in London, set the thermostat to 20°C, otherwise 18°C.",
    tools=[get_weather_forecast, set_thermostat_temperature],
)

print(interaction.steps[-1].content[0].text)

Modalitetet e thirrjes së funksionit

Kontrolloni se si modeli përdor mjetet duke përdorur tool_choice në generation_config :

  • auto (Parazgjedhur): Modeli vendos nëse do të thërrasë një funksion apo do të përgjigjet drejtpërdrejt.
  • any : Modeli është i kufizuar të parashikojë gjithmonë një thirrje funksioni.
  • none : Modelit i ndalohet të bëjë thirrje funksionesh.

  • validated (Parashikim): Modeli siguron përputhshmërinë me skemën e funksionit.

Python 

generation_config = {
    "tool_choice": {
        "allowed_tools": {
            "mode": "any",
            "tools": ["get_current_temperature"]
        }
    }
}

JavaScript 

const generationConfig = {
  toolChoice: {
    allowedTools: {
      mode: 'any',
      tools: ['get_current_temperature']
    }
  }
};

PUSHTIM 

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: \$GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-3-flash-preview",
    "input": "What is the temperature in Boston?",
    "tools": [{
      "type": "function",
      "name": "get_current_temperature",
      "description": "Gets the current temperature for a given location.",
      "parameters": {
        "type": "object",
        "properties": {
          "location": {"type": "string"}
        },
        "required": ["location"]
      }
    }],
    "generation_config": {
      "tool_choice": {
        "allowed_tools": {
          "mode": "any",
          "tools": ["get_current_temperature"]
        }
      }
    }
  }'

Përdorimi i shumë mjeteve

Mund të aktivizoni mjete të shumta, duke kombinuar mjetet e integruara me thirrjen e funksioneve në të njëjtën kërkesë. Modelet Gemini 3 mund të kombinojnë mjetet e integruara me thirrjen e funksioneve menjëherë në Ndërveprime. Kalimi i previous_interaction_id qarkullon automatikisht kontekstin e mjetit të integruar.

Python 

from google import genai
import json

client = genai.Client()

get_weather = {
    "type": "function",
    "name": "get_weather",
    "description": "Gets the weather for a requested city.",
    "parameters": {
        "type": "object",
        "properties": {
            "city": {
                "type": "string",
                "description": "The city and state, e.g. Utqiaġvik, Alaska",
            },
        },
        "required": ["city"],
    },
}

tools = [
    {"type": "google_search"},  # Built-in tool
    get_weather                 # Custom tool
]

# Turn 1: Initial request with both tools enabled
interaction = client.interactions.create(
    model="gemini-3-flash-preview",
    input="What is the northernmost city in the United States? What's the weather like there today?",
    tools=tools
)

for step in interaction.steps:
    if step.type == "function_call":
        print(f"Function call: {step.name} (ID: {step.id})")
        # Execute your custom function locally
        result = {"response": "Very cold. 22 degrees Fahrenheit."}
        # Turn 2: Provide the function result back to the model.
        # Passing `previous_interaction_id` automatically circulates the
        # built-in Google Search context from Turn 1
        interaction_2 = client.interactions.create(
            model="gemini-3-flash-preview",
            previous_interaction_id=interaction.id,
            tools=tools,
            input=[{
                "type": "function_result",
                "name": step.name,
                "call_id": step.id,
                "result": [{"type": "text", "text": json.dumps(result)}]
            }]
        )

        print(interaction_2.steps[-1].content[0].text)

JavaScript 

import { GoogleGenAI } from '@google/genai';

const client = new GoogleGenAI({});

const weatherTool = {
    type: 'function',
    name: 'get_weather',
    description: 'Gets the weather for a given location.',
    parameters: {
        type: 'object',
        properties: {
            location: { type: 'string', description: 'The city and state, e.g. San Francisco, CA' }
        },
        required: ['location']
    }
};

const tools = [
    {type: 'google_search'}, // Built-in tool
    weatherTool              // Custom tool
];

// Turn 1: Initial request with both tools enabled
let interaction = await client.interactions.create({
    model: 'gemini-3-flash-preview',
    input: "What is the northernmost city in the United States? What's the weather like there today?",
    tools: tools
});

for (const step of interaction.steps) {
    if (step.type === 'function_call') {
        console.log(`Function call: ${step.name} (ID: ${step.id})`);
        // Execute your custom function locally
        const result = {response: "Very cold. 22 degrees Fahrenheit."};
        // Turn 2: Provide the function result back to the model.
        const interaction_2 = await client.interactions.create({
            model: 'gemini-3-flash-preview',
            previousInteractionId: interaction.id,
            tools: tools,
            input: [{
                type: 'function_result',
                name: step.name,
                call_id: step.id,
                result: [{ type: 'text', text: JSON.stringify(result) }]
            }]
        });

        console.log(interaction_2.steps.at(-1).content[0].text);
    }
}

Përgjigjet e funksionit multimodal

Për modelet e serisë Gemini 3, mund të përfshini përmbajtje multimodale në pjesët e përgjigjes së funksionit që i dërgoni modelit. Modeli mund ta përpunojë këtë përmbajtje multimodale në kthesën e tij të radhës për të prodhuar një përgjigje më të informuar.

Për të përfshirë të dhëna multimodale në një përgjigje të funksionit, përfshijini ato si një ose më shumë blloqe përmbajtjeje në fushën e result të hapit function_result . Çdo bllok përmbajtjeje duhet të specifikojë type e tij (p.sh., "text" , "image" ).

Shembulli i mëposhtëm tregon se si të dërgoni një përgjigje funksioni që përmban të dhëna imazhi përsëri te modeli në një bashkëveprim:

Python 

import base64
from google import genai
import requests

client = genai.Client()

# Find the function call step
tool_call = next(s for s in interaction.steps if s.type == "function_call")

# Execute your tool to get image bytes
image_path = "https://goo.gle/instrument-img"
image_bytes = requests.get(image_path).content

base64_image_data = base64.b64encode(image_bytes).decode("utf-8")

final_interaction = client.interactions.create(
    model="gemini-3-flash-preview",
    previous_interaction_id=interaction.id,
    input=[
        {
            "type": "function_result",
            "name": tool_call.name,
            "call_id": tool_call.id,
            "result": [
                {"type": "text", "text": "instrument.jpg"},
                {
                    "type": "image",
                    "mime_type": "image/jpeg",
                    "data": base64_image_data,
                },
            ],
        }
    ],
)

print(final_interaction.steps[-1].content[0].text)

JavaScript 

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});

// Find the function call step
const toolCall = interaction.steps.find(s => s.type === 'function_call');

// Execute your tool to get image bytes and convert to base64
// (Implementation depends on your environment)
const base64ImageData = "BASE64_IMAGE_DATA";

const finalInteraction = await ai.interactions.create({
    model: 'gemini-3-flash-preview',
    previousInteractionId: interaction.id,
    input: [{
        type: 'function_result',
        name: toolCall.name,
        call_id: toolCall.id,
        result: [
            { type: 'text', text: 'instrument.jpg' },
            {
                type: 'image',
                mimeType: 'image/jpeg',
                data: base64ImageData,
            }
        ]
    }]
});

console.log(finalInteraction.steps.at(-1).content[0].text);

PUSHTIM 

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: \$GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-3-flash-preview",
    "previous_interaction_id": "INTERACTION_ID",
    "input": [
      {
        "type": "function_result",
        "name": "get_image",
        "call_id": "call_123",
        "result": [
          {"type": "text", "text": "instrument.jpg"},
          {
            "type": "image",
            "mime_type": "image/jpeg",
            "data": "BASE64_IMAGE_DATA"
          }
        ]
      }
    ]
  }'

Thirrja e funksionit me dalje të strukturuar

Për modelet e serisë Gemini 3, kombinoni thirrjen e funksioneve me daljen e strukturuar për përgjigje të formatuara në mënyrë të qëndrueshme.

MCP i largët (Protokolli i Kontekstit të Modelit)

API-ja e Ndërveprimeve mbështet lidhjen me serverë të largët MCP për t'i dhënë modelit qasje në mjete dhe shërbime të jashtme. Ju jepni name e serverit dhe url në konfigurimin e mjeteve.

Kur përdorni Remote MCP, kini parasysh kufizimet e mëposhtme:

  • Llojet e serverëve : MCP në distancë funksionon vetëm me serverë HTTP të transmetueshëm. Serverët SSE (Ngjarjet e Dërguara nga Serveri) nuk mbështeten.
  • Mbështetja e modeleve : MCP në distancë nuk funksionon me modelet Gemini 3 për momentin. Mbështetja për Gemini 3 do të vijë së shpejti.
  • Emërtimi : Emrat e serverëve MCP nuk duhet të përfshijnë karakterin - . Përdorni emrat e serverëve snake_case në vend të tyre.
Fushë Lloji E detyrueshme Përshkrimi
type string Po Duhet të jetë "mcp_server" .
name string Jo Një emër shfaqës për serverin MCP.
url string Jo URL-ja e plotë për pikën fundore të serverit MCP.
headers object Jo Çiftet çelës-vlerë të dërguara si koka HTTP me çdo kërkesë drejtuar serverit (për shembull, tokenët e autentifikimit).
allowed_tools array Jo Kufizoni cilat mjete nga serveri mund të thirren nga agjenti.

Shembull

Python 

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-2.5-flash",
    input="Check the status of my last server deployment.",
    tools=[
        {
            "type": "mcp_server",
            "name": "Deployment Tracker",
            "url": "https://mcp.example.com/mcp",
            "headers": {"Authorization": "Bearer my-token"},
        }
    ]
)

JavaScript 

import { GoogleGenAI } from '@google/genai';

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
    model: 'gemini-2.5-flash',
    input: 'Check the status of my last server deployment.',
    tools: [
        {
            type: 'mcp_server',
            name: 'Deployment Tracker',
            url: 'https://mcp.example.com/mcp',
            headers: { Authorization: 'Bearer my-token' }
        }
    ]
});

PUSHTIM 

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "model": "gemini-2.5-flash",
    "input": "Check the status of my last server deployment.",
    "tools": [
        {
            "type": "mcp_server",
            "name": "Deployment Tracker",
            "url": "https://mcp.example.com/mcp",
            "headers": {"Authorization": "Bearer my-token"}
        }
    ]
}'

Transmetoni thirrjet e mjetit

Kur përdoren mjete me transmetim, modeli gjeneron thirrje funksionesh si një sekuencë ngjarjesh step.delta në transmetim. Argumentet e mjeteve mund të transmetohen si argumente të pjesshme duke përdorur arguments . Ju duhet t'i agregoni këto delta për të rindërtuar thirrjet e plota të mjeteve përpara se t'i ekzekutoni ato.

Python 

import json
from google import genai

client = genai.Client()

weather_tool = {
    "type": "function",
    "name": "get_weather",
    "description": "Gets the weather for a given location.",
    "parameters": {
        "type": "object",
        "properties": {
            "location": {"type": "string", "description": "The city and state"}
        },
        "required": ["location"]
    }
}

stream = client.interactions.create(
    model="gemini-3-flash-preview",
    input="What is the weather in Paris?",
    tools=[weather_tool],
    stream=True
)

current_calls = {}
tool_calls = []

for event in stream:
    if event.event_type == "step.start":
        if event.step.type == "function_call":
            current_calls[event.index] = {
                "id": event.step.id,
                "name": event.step.name,
                "arguments": ""
            }
    elif event.event_type == "step.delta":
        if event.delta.type == "arguments":
            if event.index in current_calls:
                current_calls[event.index]["arguments"] += event.delta.partial_arguments
        elif event.delta.type == "text":
            print(event.delta.text, end="", flush=True)

    elif event.event_type == "interaction.completed":
        for index, call in current_calls.items():
            args = call["arguments"]
            if args:
                args = json.loads(args)
            else:
                args = {}

            tool_calls.append({
                "type": "function_call",
                "id": call["id"],
                "name": call["name"],
                "arguments": args
            })

        print(f"\nFinal tool calls ready to execute:")
        print(json.dumps(tool_calls, indent=2))

JavaScript 

import { GoogleGenAI } from '@google/genai';

const client = new GoogleGenAI({});

const weatherTool = {
    type: 'function',
    name: 'get_weather',
    description: 'Gets the weather for a given location.',
    parameters: {
        type: 'object',
        properties: {
            location: { type: 'string', description: 'The city and state' }
        },
        required: ['location']
    }
};

const stream = await client.interactions.create({
    model: 'gemini-3-flash-preview',
    input: 'What is the weather in Paris?',
    tools: [weatherTool],
    stream: true,
});

const currentCalls = new Map();
let toolCalls = [];

for await (const event of stream) {
    if (event.type === 'step.start') {
        if (event.step.type === 'function_call') {
            currentCalls.set(event.index, {
                id: event.step.id,
                name: event.step.name,
                arguments: ''
            });
        }
    } else if (event.type === 'step.delta') {
        if (event.delta.type === 'arguments') {
            if (currentCalls.has(event.index)) {
                currentCalls.get(event.index).arguments += event.delta.partial_arguments;
            }
        } else if (event.delta.type === 'text') {
            process.stdout.write(event.delta.text);
        }
    } else if (event.type === 'interaction.completed') {
        toolCalls = Array.from(currentCalls.values()).map(call => ({
            type: 'function_call',
            id: call.id,
            name: call.name,
            arguments: call.arguments ? JSON.parse(call.arguments) : {}
        }));
        console.log('\nFinal tool calls ready to execute:');
        console.log(JSON.stringify(toolCalls, null, 2));
    }
}

PUSHTIM 

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions?alt=sse" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "model": "gemini-3-flash-preview",
    "input": "What is the weather in Paris?",
    "tools": [{
        "type": "function",
        "name": "get_weather",
        "description": "Gets the weather for a given location.",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {"type": "string", "description": "The city and state"}
            },
            "required": ["location"]
        }
    }],
    "stream": true
}'

Modelet e mbështetura

Model Thirrja e funksionit Paralel Kompozicionale
Pamje paraprake e Gemini 3.1 Pro ✔️ ✔️ ✔️
Pamje paraprake e shpejtë e Gemini 3 ✔️ ✔️ ✔️
Gemini 2.5 Pro ✔️ ✔️ ✔️
Binjakët 2.5 Flash ✔️ ✔️ ✔️
Gemini 2.5 Flash-Lite ✔️ ✔️ ✔️
Binjakët 2.0 Flash ✔️ ✔️ ✔️
Gemini 2.0 Flash-Lite X X X

Praktikat më të mira

  • Përshkrimet e funksioneve dhe parametrave: Jini të qartë dhe specifikë.
  • Emërtimi: Përdorni emra përshkrues pa hapësira ose karaktere të veçanta.
  • Shtypje e fortë: Përdorni lloje specifike (numër i plotë, varg, numërim).
  • Përzgjedhja e mjeteve: Mbajeni numrin aktiv në maksimum 10-20 mjete.
  • Inxhinieri e shpejtë: Jepni kontekstin dhe udhëzimet.

  • Temperatura: Përdorni temperaturë të ulët (p.sh., 0) për thirrjet deterministe.

  • Validimi: Validoni thirrjet e funksioneve përpara se të ekzekutohen.

  • Trajtimi i Gabimeve: Implementoni trajtim të fuqishëm të gabimeve.

  • Siguria: Përdorni autentifikimin e duhur për API-të e jashtme.

Shënime dhe kufizime

  • Mbështetet vetëm një nëngrup i skemës OpenAPI .
  • Për any modalitet, API mund të refuzojë skema shumë të mëdha ose të ndërthurura thellë.
  • Llojet e parametrave të mbështetur në Python janë të kufizuara.