Gemini API ile işlev çağırma

İşlev çağırma, modelleri harici araçlara ve API'lere bağlamanızı sağlar. Model, metin yanıtları oluşturmak yerine belirli işlevlerin ne zaman çağrılacağını anlar ve gerçek dünyadaki işlemleri gerçekleştirmek için gerekli parametreleri sağlar. Bu sayede model, doğal dil ile gerçek dünyadaki işlemler ve veriler arasında köprü görevi görebilir. İşlev çağırma işleminin 3 temel kullanım alanı vardır:

• Bilgiyi artırma: Veritabanları, API'ler ve bilgi bankaları gibi harici kaynaklardan bilgilere erişin.
• Özellikleri genişletme: Hesaplama yapmak ve modelin sınırlarını genişletmek için harici araçlar kullanın (ör. hesap makinesi kullanma veya grafik oluşturma).
• İşlem yapma: API'leri kullanarak randevu planlama, fatura oluşturma, e-posta gönderme veya akıllı ev cihazlarını kontrol etme gibi harici sistemlerle etkileşim kurma

Hava Durumu Alın Toplantı Planlayın Grafiği Oluşturun

İşlev Çağırma İşlevinin İşleyiş Şekli

İşlev çağrısı, uygulamanız, model ve harici işlevler arasında yapılan yapılandırılmış bir etkileşimi içerir. Sürecin dökümü aşağıda verilmiştir:

1. İşlev Tanımlamasını Tanımlama: Uygulama kodunuzda işlev tanımını tanımlayın. İşlev tanımları, işlevin adını, parametrelerini ve modeldeki amacını açıklar.
2. LLM'yi işlev tanımlarıyla çağırma: Kullanıcı istemlerini işlev tanımlarıyla birlikte modele gönderin. İsteği analiz eder ve bir işlev çağrısının yararlı olup olmayacağını belirler. Bu durumda, yapılandırılmış bir JSON nesnesi ile yanıt verir.
3. İşlev kodunu yürütme (Sorumluluğunuz): Model, işlevi kendi başına yürütmez. Yanıtı işlemek ve işlev çağrısını kontrol etmek uygulamanızın sorumluluğundadır.
   • Evet: İşlevin adını ve args parametresini ayıklayın ve uygulamanızda ilgili işlevi yürütün.
   • Hayır: Model, istem için doğrudan bir metin yanıtı sağladı (bu akış örnekte daha az vurgulanmıştır ancak olası bir sonuçtur).
4. Kullanıcı dostu yanıt oluşturma: Bir işlev yürütüldüyse sonucu yakalayıp sohbetin sonraki bir aşamasında modele geri gönderin. Sonuç, işlev çağrısındaki bilgileri içeren nihai ve kullanıcı dostu bir yanıt oluşturmak için kullanılır.

Bu işlem, karmaşık etkileşimlere ve iş akışlarına olanak tanıyan birden fazla turda tekrarlanabilir. Model, birden fazla işlevin tek bir turda (paralel işlev çağırma) ve sırayla (kompozisyonel işlev çağırma) çağrılmasını da destekler.

1. Adım: İşlev Tanımlamasını Tanımlayın

Uygulama kodunuzda, kullanıcıların ışık değerlerini ayarlamalarına ve API isteği göndermelerine olanak tanıyan bir işlev ve işlevin tanımını yapın. Bu işlev, harici hizmetleri veya API'leri çağırabilir.

from google.genai import types

# Define a function that the model can call to control smart lights
set_light_values_declaration = {
    "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. Zero is off and 100 is full brightness",
            },
            "color_temp": {
                "type": "string",
                "enum": ["daylight", "cool", "warm"],
                "description": "Color temperature of the light fixture, which can be `daylight`, `cool` or `warm`.",
            },
        },
        "required": ["brightness", "color_temp"],
    },
}

# This is the actual function that would be called based on the model's suggestion
def set_light_values(brightness: int, color_temp: str) -> dict[str, int | str]:
    """Set the brightness and color temperature of a room light. (mock API).

    Args:
        brightness: Light level from 0 to 100. Zero is off and 100 is full brightness
        color_temp: Color temperature of the light fixture, which can be `daylight`, `cool` or `warm`.

    Returns:
        A dictionary containing the set brightness and color temperature.
    """
    return {"brightness": brightness, "colorTemperature": color_temp}

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

// Define a function that the model can call to control smart lights
const setLightValuesFunctionDeclaration = {
  name: 'set_light_values',
  description: 'Sets the brightness and color temperature of a light.',
  parameters: {
    type: Type.OBJECT,
    properties: {
      brightness: {
        type: Type.NUMBER,
        description: 'Light level from 0 to 100. Zero is off and 100 is full brightness',
      },
      color_temp: {
        type: Type.STRING,
        enum: ['daylight', 'cool', 'warm'],
        description: 'Color temperature of the light fixture, which can be `daylight`, `cool` or `warm`.',
      },
    },
    required: ['brightness', 'color_temp'],
  },
};

/**
* Set the brightness and color temperature of a room light. (mock API)
* @param {number} brightness - Light level from 0 to 100. Zero is off and 100 is full brightness
* @param {string} color_temp - Color temperature of the light fixture, which can be `daylight`, `cool` or `warm`.
* @return {Object} A dictionary containing the set brightness and color temperature.
*/
function setLightValues(brightness, color_temp) {
  return {
    brightness: brightness,
    colorTemperature: color_temp
  };
}

2. Adım: Modeli işlev tanımlarıyla çağırın

İşlev beyanlarınızı tanımladıktan sonra modelden işlevi kullanmasını isteyebilirsiniz. İstem ve işlev tanımlarını analiz eder ve doğrudan yanıt vermeye veya bir işlevi çağırmaya karar verir. Bir işlev çağrılırsa yanıt nesnesi bir işlev çağrısı önerisi içerir.

from google import genai

# Generation Config with Function Declaration
tools = types.Tool(function_declarations=[set_light_values_declaration])
config = types.GenerateContentConfig(tools=[tools])

# Configure the client
client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))

# Define user prompt
contents = [
    types.Content(
        role="user", parts=[types.Part(text="Turn the lights down to a romantic level")]
    )
]

# Send request with function declarations
response = client.models.generate_content(
    model="gemini-2.0-flash", config=config, contents=contents
)

print(response.candidates[0].content.parts[0].function_call)

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

// Generation Config with Function Declaration
const config = {
  tools: [{
    functionDeclarations: [setLightValuesFunctionDeclaration]
  }]
};

// Configure the client
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

// Define user prompt
const contents = [
  {
    role: 'user',
    parts: [{ text: 'Turn the lights down to a romantic level' }]
  }
];

// Send request with function declarations
const response = await ai.models.generateContent({
  model: 'gemini-2.0-flash',
  contents: contents,
  config: config
});

console.log(response.functionCalls[0]); 

Ardından model, kullanıcının sorusuna yanıt vermek için beyan edilen işlevlerden en az birinin nasıl çağrılacağını belirten OpenAPI uyumlu bir şemada bir functionCall nesnesi döndürür.

id=None args={'color_temp': 'warm', 'brightness': 25} name='set_light_values'

{
  name: 'set_light_values',
  args: { brightness: 25, color_temp: 'warm' }
}

3. Adım: set_light_values işlev kodunu yürütün

Modelin yanıtından işlev çağrısı ayrıntılarını ayıklayın, bağımsız değişkenleri ayrıştırın ve kodumuzda set_light_values işlevini yürütün.

# Extract tool call details
tool_call = response.candidates[0].content.parts[0].function_call

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

// Extract tool call details
const tool_call = response.functionCalls[0]

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

4. Adım: İşlev sonucuyla kullanıcı dostu yanıt oluşturun ve modeli tekrar çağırın

Son olarak, işlevin yürütülmesinin sonucunu modele geri gönderin. Böylece model bu bilgileri kullanıcıya verdiği nihai yanıta dahil edebilir.

# Create a function response part
function_response_part = types.Part.from_function_response(
    name=tool_call.name,
    response={"result": result},
)

# Append function call and result of the function execution to contents
contents.append(types.Content(role="model", parts=[types.Part(function_call=tool_call)])) # Append the model's function call message
contents.append(types.Content(role="user", parts=[function_response_part])) # Append the function response

final_response = client.models.generate_content(
    model="gemini-2.0-flash",
    config=config,
    contents=contents,
)

print(final_response.text)

// Create a function response part
const function_response_part = {
  name: tool_call.name,
  response: { result }
}

// Append function call and result of the function execution to contents
contents.push({ role: 'model', parts: [{ functionCall: tool_call }] });
contents.push({ role: 'user', parts: [{ functionResponse: function_response_part }] });

// Get the final response from the model
const final_response = await ai.models.generateContent({
  model: 'gemini-2.0-flash',
  contents: contents,
  config: config
});

console.log(final_response.text);

Böylece işlev çağırma akışı tamamlanmış olur. Model, kullanıcının istek işlemini gerçekleştirmek için set_light_values işlevini başarıyla kullandı.

İşlev bildirimleri

Bir istemde işlev çağrısı uyguladığınızda bir veya daha fazla function declarations içeren bir tools nesnesi oluşturursunuz. İşlevleri JSON'u kullanarak, özellikle OpenAPI şeması biçiminin belirli bir alt kümesiyle tanımlarsınız. Tek bir işlev beyanı aşağıdaki parametreleri içerebilir:

• name (dize): İşlevin benzersiz adı (get_weather_forecast, send_email). Boşluk veya özel karakter içermeyen açıklayıcı adlar kullanın (alt çizgi veya büyük/küçük harf kullanma).
• description (dize): İşlevin amacının ve özelliklerinin net ve ayrıntılı bir açıklaması. Bu, modelin işlevi ne zaman kullanacağını anlaması için çok önemlidir. Belirli olun ve faydalı olacaksa örnekler verin ("Konuma ve isteğe bağlı olarak şu anda sinemalarda gösterilen film başlığına göre sinemaları bulur.").
• parameters (nesne): İşlevin beklediği giriş parametrelerini tanımlar.
  • type (dize): Genel veri türünü belirtir (ör. object).
  • properties (nesne): Her biri şu bilgileri içeren bağımsız parametreleri listeler:
    • type (dize): Parametrenin veri türü (ör. string, integer, boolean, array).
    • description (dize): Parametrenin amacının ve biçiminin açıklaması. Örnekler ve kısıtlamalar sağlayın ("Şehir ve eyalet, ör. "San Francisco, CA" veya bir posta kodu (ör. '95616'.").
    • enum (dizi, isteğe bağlı): Parametre değerleri sabit bir kümeden geliyorsa izin verilen değerleri açıklamada açıklamak yerine listeleyebilirsiniz. Bunun için "enum" değerini kullanın. Bu, doğruluğu artırır ("enum": ["daylight", "cool", "warm"]).
  • required (dizi): İşlevin çalışması için zorunlu olan parametre adlarını listeleyen bir dize dizisi.

Paralel İşlev Çağrısı

Tek tur işlev çağrısına ek olarak, aynı anda birden fazla işlevi de çağırabilirsiniz. Paralel işlev çağrısı, birden fazla işlevi aynı anda yürütmenize olanak tanır ve işlevler birbirine bağlı olmadığında kullanılır. Bu, farklı veritabanlarından müşteri ayrıntılarını almak, çeşitli depolardaki envanter seviyelerini kontrol etmek veya dairenizi diskoya dönüştürmek gibi birden fazla bağımsız kaynaktan veri toplama gibi senaryolarda faydalıdır.

power_disco_ball = {
    "name": "power_disco_ball",
    "description": "Powers the spinning disco ball.",
    "parameters": {
        "type": "object",
        "properties": {
            "power": {
                "type": "boolean",
                "description": "Whether to turn the disco ball on or off.",
            }
        },
        "required": ["power"],
    },
}

start_music = {
    "name": "start_music",
    "description": "Play some music matching the specified parameters.",
    "parameters": {
        "type": "object",
        "properties": {
            "energetic": {
                "type": "boolean",
                "description": "Whether the music is energetic or not.",
            },
            "loud": {
                "type": "boolean",
                "description": "Whether the music is loud or not.",
            },
        },
        "required": ["energetic", "loud"],
    },
}

dim_lights = {
    "name": "dim_lights",
    "description": "Dim the lights.",
    "parameters": {
        "type": "object",
        "properties": {
            "brightness": {
                "type": "number",
                "description": "The brightness of the lights, 0.0 is off, 1.0 is full.",
            }
        },
        "required": ["brightness"],
    },
}

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

const powerDiscoBall = {
  name: 'power_disco_ball',
  description: 'Powers the spinning disco ball.',
  parameters: {
    type: Type.OBJECT,
    properties: {
      power: {
        type: Type.BOOLEAN,
        description: 'Whether to turn the disco ball on or off.'
      }
    },
    required: ['power']
  }
};

const startMusic = {
  name: 'start_music',
  description: 'Play some music matching the specified parameters.',
  parameters: {
    type: Type.OBJECT,
    properties: {
      energetic: {
        type: Type.BOOLEAN,
        description: 'Whether the music is energetic or not.'
      },
      loud: {
        type: Type.BOOLEAN,
        description: 'Whether the music is loud or not.'
      }
    },
    required: ['energetic', 'loud']
  }
};

const dimLights = {
  name: 'dim_lights',
  description: 'Dim the lights.',
  parameters: {
    type: Type.OBJECT,
    properties: {
      brightness: {
        type: Type.NUMBER,
        description: 'The brightness of the lights, 0.0 is off, 1.0 is full.'
      }
    },
    required: ['brightness']
  }
};

Modeli, belirtilen tüm araçları kullanabilecek bir talimatla çağırın. Bu örnekte bir tool_config kullanılmaktadır. Daha fazla bilgi edinmek için işlev çağrısını yapılandırma hakkındaki makaleyi okuyabilirsiniz.

from google import genai
from google.genai import types

# Set up function declarations
house_tools = [
    types.Tool(function_declarations=[power_disco_ball, start_music, dim_lights])
]

config = {
    "tools": house_tools,
    "automatic_function_calling": {"disable": True},
    # Force the model to call 'any' function, instead of chatting.
    "tool_config": {"function_calling_config": {"mode": "any"}},
}

# Configure the client
client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))

chat = client.chats.create(model="gemini-2.0-flash", config=config)
response = chat.send_message("Turn this place into a party!")

# Print out each of the function calls requested from this single call
print("Example 1: Forced function calling")
for fn in response.function_calls:
    args = ", ".join(f"{key}={val}" for key, val in fn.args.items())
    print(f"{fn.name}({args})")

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

// Set up function declarations
const houseFns = [powerDiscoBall, startMusic, dimLights];

const config = {
    tools: [{
        functionDeclarations: houseFns
    }],
    // Force the model to call 'any' function, instead of chatting.
    toolConfig: {
        functionCallingConfig: {
        mode: 'any'
        }
    }
};

// Configure the client
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

// Create a chat session
const chat = ai.chats.create({
    model: 'gemini-2.0-flash',
    config: config
});
const response = await chat.sendMessage({message: 'Turn this place into a party!'});

// Print out each of the function calls requested from this single call
console.log("Example 1: Forced function calling");
for (const fn of response.functionCalls) {
    const args = Object.entries(fn.args)
        .map(([key, val]) => `${key}=${val}`)
        .join(', ');
    console.log(`${fn.name}(${args})`);
}

Basılan sonuçların her biri, modelin istediği tek bir işlev çağrısını yansıtır. Sonuçları geri göndermek için yanıtları istendikleri sırayla ekleyin.

Python SDK'sı, Python işlevini beyana dönüştüren, işlev çağrısı yürütme ve yanıt döngüsünü sizin için yöneten otomatik işlev çağırma adlı bir özelliği destekler. Aşağıda, disko kullanım alanımıza ait bir örnek verilmiştir.

from google import genai
from google.genai import types

# Actual implementation functions
def power_disco_ball_impl(power: bool) -> dict:
    """Powers the spinning disco ball.

    Args:
        power: Whether to turn the disco ball on or off.

    Returns:
        A status dictionary indicating the current state.
    """
    return {"status": f"Disco ball powered {'on' if power else 'off'}"}

def start_music_impl(energetic: bool, loud: bool) -> dict:
    """Play some music matching the specified parameters.

    Args:
        energetic: Whether the music is energetic or not.
        loud: Whether the music is loud or not.

    Returns:
        A dictionary containing the music settings.
    """
    music_type = "energetic" if energetic else "chill"
    volume = "loud" if loud else "quiet"
    return {"music_type": music_type, "volume": volume}

def dim_lights_impl(brightness: float) -> dict:
    """Dim the lights.

    Args:
        brightness: The brightness of the lights, 0.0 is off, 1.0 is full.

    Returns:
        A dictionary containing the new brightness setting.
    """
    return {"brightness": brightness}

config = {
    "tools": [power_disco_ball_impl, start_music_impl, dim_lights_impl],
}

chat = client.chats.create(model="gemini-2.0-flash", config=config)
response = chat.send_message("Do everything you need to this place into party!")

print("\nExample 2: Automatic function calling")
print(response.text)
# I've turned on the disco ball, started playing loud and energetic music, and dimmed the lights to 50% brightness. Let's get this party started!

Kompozit İşlev Çağrısı

Gemini 2.0, işlev çağrılarını birleştirmeyi destekler. Yani model, birden fazla işlev çağrısını birbirine bağlayabilir. Örneğin, "Mevcut konumumdaki sıcaklığı al" isteğini yanıtlamak için Gemini API hem bir get_current_location() işlevi hem de konumu parametre olarak alan bir get_weather() işlevi çağırabilir.

# Light control schemas
turn_on_the_lights_schema = {'name': 'turn_on_the_lights'}
turn_off_the_lights_schema = {'name': 'turn_off_the_lights'}

prompt = """
  Hey, can you write run some python code to turn on the lights, wait 10s and then turn off the lights?
  """

tools = [
    {'code_execution': {}},
    {'function_declarations': [turn_on_the_lights_schema, turn_off_the_lights_schema]}
]

await run(prompt, tools=tools, modality="AUDIO")

// Light control schemas
const turnOnTheLightsSchema = { name: 'turn_on_the_lights' };
const turnOffTheLightsSchema = { name: 'turn_off_the_lights' };

const prompt = `
  Hey, can you write run some python code to turn on the lights, wait 10s and then turn off the lights?
`;

const tools = [
  { codeExecution: {} },
  { functionDeclarations: [turnOnTheLightsSchema, turnOffTheLightsSchema] }
];

await run(prompt, tools=tools, modality="AUDIO")

İşlev çağırma modları

Gemini API, modelin sağlanan araçları (işlev bildirimleri) nasıl kullanacağını kontrol etmenize olanak tanır. Özellikle function_calling_config içinde modu ayarlayabilirsiniz.

• AUTO (Default): Model, istemi ve bağlamı temel alarak doğal dil yanıtı oluşturmaya veya işlev çağrısı önermeye karar verir. Bu, en esnek moddur ve çoğu senaryo için önerilir.
• ANY: Model, her zaman bir işlev çağrısını tahmin etmek ve işlev şemasına bağlılığı garanti etmek için kısıtlanmıştır. allowed_function_names belirtilmezse model, sağlanan işlev beyanlarından herhangi birini seçebilir. allowed_function_names bir liste olarak sağlanırsa model yalnızca bu listedeki işlevler arasından seçim yapabilir. Her istem için işlev çağrısı gerektiğinde (varsa) bu modu kullanın.

• NONE: Modelin işlev çağrısı yapması yasaktır. Bu, işlev beyanları olmadan istek göndermeye eşdeğerdir. Araç tanımlarınızı kaldırmadan işlev çağrısını geçici olarak devre dışı bırakmak için bunu kullanın.

from google.genai import types

# Configure function calling mode
tool_config = types.ToolConfig(
    function_calling_config=types.FunctionCallingConfig(
        mode="ANY", allowed_function_names=["get_current_temperature"]
    )
)

# Create the generation config
config = types.GenerateContentConfig(
    temperature=0,
    tools=[tools],  # not defined here.
    tool_config=tool_config,
)

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

// Configure function calling mode
const toolConfig = {
  functionCallingConfig: {
    mode: FunctionCallingConfigMode.ANY,
    allowedFunctionNames: ['get_current_temperature']
  }
};

// Create the generation config
const config = {
  temperature: 0,
  tools: tools, // not defined here.
  toolConfig: toolConfig,
};

Otomatik İşlev Çağırma (Yalnızca Python)

Python SDK'sını kullanırken Python işlevlerini doğrudan araç olarak sağlayabilirsiniz. SDK, Python işlevini otomatik olarak beyana dönüştürür, işlev çağrısı yürütme ve yanıt döngüsünü sizin için yönetir. Python SDK'sı daha sonra otomatik olarak:

1. Modelden gelen işlev çağrısı yanıtlarını algılar.
2. Kodunuzda ilgili Python işlevini çağırın.
3. İşlev yanıtını modele geri gönderir.
4. Modelin nihai metin yanıtını döndürür.

Bunu kullanmak için işlevinizi tür ipuçları ve bir açıklama metniyle tanımlayın, ardından işlevin kendisini (JSON beyanı değil) bir araç olarak iletin:

from google import genai
from google.genai import types

# Define the function with type hints and docstring
def get_current_temperature(location: str) -> dict:
    """Gets the current temperature for a given location.

    Args:
        location: The city and state, e.g. San Francisco, CA

    Returns:
        A dictionary containing the temperature and unit.
    """
    # ... (implementation) ...
    return {"temperature": 25, "unit": "Celsius"}

# Configure the client and model
client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))  # Replace with your actual API key setup
config = types.GenerateContentConfig(
    tools=[get_current_temperature]
)  # Pass the function itself

# Make the request
response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents="What's the temperature in London?",
    config=config,
)

print(response.text)  # The SDK handles the function call and returns the final text

Otomatik işlev çağrısını şu yöntemlerle devre dışı bırakabilirsiniz:

# To disable automatic function calling:
config = types.GenerateContentConfig(
    tools=[get_current_temperature],
    automatic_function_calling=types.AutomaticFunctionCallingConfig(disable=True)
)

Otomatik işlev şeması beyanı

Python işlevlerinden otomatik şema ayıklama işlemi her durumda çalışmaz. Örneğin, iç içe yerleştirilmiş bir sözlük nesnesinin alanlarını tanımladığınız durumları işlemez. API, aşağıdaki türlerden herhangi birini tanımlayabilir:

AllowedType = (int | float | bool | str | list['AllowedType'] | dict[str, AllowedType])

Tahmine dayalı şemanın nasıl göründüğünü görmek için from_callable kullanarak dönüştürebilirsiniz:

def multiply(a: float, b: float):
    """Returns a * b."""
    return a * b

fn_decl = types.FunctionDeclaration.from_callable(callable=multiply, client=client)

# to_json_dict() provides a clean JSON representation.
print(fn_decl.to_json_dict())

Çoklu araç kullanımı: Yerel araçları işlev çağırma ile birleştirme

Gemini 2.0 ile yerel araçları işlev çağrısıyla aynı anda birleştiren birden fazla aracı etkinleştirebilirsiniz. Canlı API'yi kullanan bir istekte Google Arama ile temellendirme ve kod yürütme olmak üzere iki aracı etkinleştiren bir örnek verilmiştir.

# Multiple tasks example - combining lights, code execution, and search
prompt = """
  Hey, I need you to do three things for me.

    1.  Turn on the lights.
    2.  Then compute the largest prime palindrome under 100000.
    3.  Then use Google Search to look up information about the largest earthquake in California the week of Dec 5 2024.

  Thanks!
  """

tools = [
    {'google_search': {}},
    {'code_execution': {}},
    {'function_declarations': [turn_on_the_lights_schema, turn_off_the_lights_schema]} # not defined here.
]

# Execute the prompt with specified tools in audio modality
await run(prompt, tools=tools, modality="AUDIO")

// Multiple tasks example - combining lights, code execution, and search
const prompt = `
  Hey, I need you to do three things for me.

    1.  Turn on the lights.
    2.  Then compute the largest prime palindrome under 100000.
    3.  Then use Google Search to look up information about the largest earthquake in California the week of Dec 5 2024.

  Thanks!
`;

const tools = [
  { googleSearch: {} },
  { codeExecution: {} },
  { functionDeclarations: [turnOnTheLightsSchema, turnOffTheLightsSchema] } // not defined here.
];

// Execute the prompt with specified tools in audio modality
await run(prompt, {tools: tools, modality: "AUDIO"});

Python geliştiricileri bunu Live API Tool Use notebook'ta deneyebilir.

Desteklenen Modeller

Deneme aşamasındaki modeller dahil değildir. Bu modellerin özelliklerini modele genel bakış sayfasında bulabilirsiniz.

En İyi Uygulamalar

• İşlev ve Parametre Açıklamaları: Açıklamalarınızda son derece net ve spesifik olun. Model, doğru işlevi seçmek ve uygun bağımsız değişkenler sağlamak için bu bilgilerden yararlanır.
• Adlandırma: Açıklayıcı işlev adları kullanın (boşluk, nokta veya kısa çizgi olmadan).
• Güçlü Yazma: Hataları azaltmak için parametreler için belirli türleri (tam sayı, dize, enum) kullanın. Bir parametrenin sınırlı sayıda geçerli değeri varsa bir enum kullanın.
• İstem Mühendisliği:
  • Bağlam bilgisi sağlayın: Modele rolünü söyleyin (ör. "Hava durumuyla ilgili yardımcı bir asistansınız.").
  • Talimatlar verin: İşlevlerin nasıl ve ne zaman kullanılacağını belirtin (ör. "Tarihleri tahmin etmeyin; öngörmeler için her zaman gelecekteki bir tarih kullanın.").
  • Açıklama yapılmasını teşvik edin: Gerekirse modele açıklayıcı sorular sormasını söyleyin.
• Sıcaklık: Düşük bir sıcaklık kullanın (ör. 0) ayarlayarak daha kesin ve güvenilir işlev çağrıları yapabilirsiniz.
• Doğrulama: Bir işlev çağrısının önemli sonuçları varsa (ör. sipariş verme) çağrıyı yürütmeden önce kullanıcıyla doğrulayın.
• Hata İşleme: Beklenmedik girişleri veya API hatalarını sorunsuz bir şekilde işlemek için işlevlerinize güçlü hata işleme yöntemleri uygulayın. Modelin kullanıcıya yararlı yanıtlar oluşturmak için kullanabileceği bilgilendirici hata mesajları döndürün.
• Güvenlik: Harici API'leri çağırırken güvenlik konusunda dikkatli olun. Uygun kimlik doğrulama ve yetkilendirme mekanizmalarını kullanın. İşlev çağrılarında hassas verileri göstermekten kaçının.
• Jeton Sınırları: İşlev açıklamaları ve parametreleri, giriş jetonu sınırınıza dahil edilir. Jeton sınırlarına ulaşıyorsanız işlev sayısını veya açıklamaların uzunluğunu sınırlayabilir, karmaşık görevleri daha küçük ve daha odaklanmış işlev kümelerine ayırabilirsiniz.

Notlar ve Sınırlılıklar

• Yalnızca OpenAPI şemasının bir alt kümesi desteklenir.
• Python'da desteklenen parametre türleri sınırlıdır.
• Otomatik işlev çağırma yalnızca Python SDK'sı özelliğidir.