La llamada de función permite que un LLM actúe como un puente entre las indicaciones de lenguaje natural y el código o las API del mundo real. En lugar de simplemente generar texto, el modelo decide cuándo invocar una función predefinida, emite una llamada JSON estructurada con el nombre de la función y los argumentos, y luego espera a que su aplicación ejecute esa llamada y devuelva los resultados. Este back-and—–and-puede bucle, potencialmente invocando múltiples funciones en secuencia, lo que permite interacciones ricas de varios pasos en un control de conversación. En este tutorial, implementaremos un asistente meteorológico con Gemini 2.0 Flash para demostrar cómo configurar y administrar ese ciclo de llamadas de funciones. Implementaremos diferentes variantes de llamadas de funciones. Al integrar las llamadas de funciones, transformamos una interfaz de chat en una herramienta dinámica para tareas en tiempo real, ya sea para obtener datos meteorológicos en vivo, verificar los estados de pedido, programar citas o actualizar bases de datos. Los usuarios ya no completan formularios complejos ni navegan múltiples pantallas; Simplemente describen lo que necesitan, y el LLM orquesta las acciones subyacentes sin problemas. Esta automatización del lenguaje natural permite la fácil construcción de agentes de IA que pueden acceder a fuentes de datos externas, realizar transacciones o activar flujos de trabajo, todo dentro de una sola conversación.
Funcionar llamadas con Google Gemini 2.0 Flash
!pip install "google-genai>=1.0.0" geopy requestsInstalamos el Gemini Python SDK (Google-Genai ≥ 1.0.0), junto con Geopy para convertir los nombres de ubicación en coordenadas y solicitudes para realizar llamadas HTTP, asegurando que todas las dependencias básicas para nuestro asistente meteorológico de Colab estén en su lugar.
import os
from google import genai
GEMINI_API_KEY = "Use_Your_API_Key"
client = genai.Client(api_key=GEMINI_API_KEY)
model_id = "gemini-2.0-flash"Importamos el SDK de Gemini, establecemos su clave API y creamos una instancia de Genai.Client configurada para usar el modelo “Gemini-2.0-Flash”, estableciendo la base para todas las solicitudes posteriores de llamada de funciones.
res = client.models.generate_content(
model=model_id,
contents=["Tell me 1 good fact about Nuremberg."]
)
print(res.text)Enviamos un mensaje del usuario (“Dime 1 buen hecho sobre Nuremberg”) al modelo Flash Gemini 2.0 a través de Generate_Content, luego imprima la respuesta de texto del modelo, demostrando una llamada básica de generación de texto de extremo a extremo utilizando el SDK.
Función llamando con el esquema JSON
weather_function = {
"name": "get_weather_forecast",
"description": "Retrieves the weather using Open-Meteo API for a given location (city) and a date (yyyy-mm-dd). Returns a list dictionary with the time and temperature for each hour.",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and state, e.g., San Francisco, CA"
},
"date": {
"type": "string",
"description": "the forecasting date for when to get the weather format (yyyy-mm-dd)"
}
},
"required": ["location","date"]
}
}
Aquí, definimos un esquema JSON para nuestra herramienta get_weather_forecast, especificando su nombre, una solicitud descriptiva para guiar a Gemini sobre cuándo usarlo, y los parámetros de entrada exactos (ubicación y fecha) con sus tipos, descripciones y campos requeridos, para que el modelo pueda emitir llamadas de funciones válidas.
from google.genai.types import GenerateContentConfig
config = GenerateContentConfig(
system_instruction="You are a helpful assistant that use tools to access and retrieve information from a weather API. Today is 2025-03-04.",
tools=[{"function_declarations": [weather_function]}],
)
Creamos un GenerateContentConfig que le dice a Gemini que está actuando como un asistente de regreso climático y registra su función meteorológica bajo herramientas. Por lo tanto, el modelo sabe cómo generar llamadas estructuradas cuando se solicita datos de pronóstico.
response = client.models.generate_content(
model=model_id,
contents="Whats the weather in Berlin today?"
)
print(response.text)Esta llamada envía el aviso desnudo (“¿Cuál es el clima en Berlín hoy?”) Sin incluir su configuración (y, por lo tanto, sin definiciones de funciones), por lo que Gemini recurre a la finalización del texto plano, ofreciendo consejos genéricos en lugar de invocar su herramienta de ejecución por el clima.
response = client.models.generate_content(
model=model_id,
config=config,
contents="Whats the weather in Berlin today?"
)
for part in response.candidates[0].content.parts:
print(part.function_call)Al pasar la configuración (que incluye su herramienta JSON -Schema), Gemini reconoce que debería llamar a get_weather_forecast en lugar de responder en texto sin formato. El bucle sobre la respuesta.candidates[0].Content.Parts luego imprime el objeto .function_call de cada pieza, mostrando exactamente qué función del modelo decidió invocar (con su nombre y argumentos).
from google.genai import types
from geopy.geocoders import Nominatim
import requests
geolocator = Nominatim(user_agent="weather-app")
def get_weather_forecast(location, date):
location = geolocator.geocode(location)
if location:
try:
response = requests.get(f"https://api.open-meteo.com/v1/forecast?latitude={location.latitude}&longitude={location.longitude}&hourly=temperature_2m&start_date={date}&end_date={date}")
data = response.json()
return {time: temp for time, temp in zip(data["hourly"]["time"], data["hourly"]["temperature_2m"])}
except Exception as e:
return {"error": str(e)}
else:
return {"error": "Location not found"}
functions = {
"get_weather_forecast": get_weather_forecast
}
def call_function(function_name, **kwargs):
return functions[function_name](**kwargs)
def function_call_loop(prompt):
contents = [types.Content(role="user", parts=[types.Part(text=prompt)])]
response = client.models.generate_content(
model=model_id,
config=config,
contents=contents
)
for part in response.candidates[0].content.parts:
contents.append(types.Content(role="model", parts=[part]))
if part.function_call:
print("Tool call detected")
function_call = part.function_call
print(f"Calling tool: {function_call.name} with args: {function_call.args}")
tool_result = call_function(function_call.name, **function_call.args)
function_response_part = types.Part.from_function_response(
name=function_call.name,
response={"result": tool_result},
)
contents.append(types.Content(role="user", parts=[function_response_part]))
print(f"Calling LLM with tool results")
func_gen_response = client.models.generate_content(
model=model_id, config=config, contents=contents
)
contents.append(types.Content(role="model", parts=[func_gen_response]))
return contents[-1].parts[0].text.strip()
result = function_call_loop("Whats the weather in Berlin today?")
print(result)Implementamos un bucle completo “agente”: envía su aviso a Gemini, inspecciona la respuesta para una llamada de función, ejecuta get_weather_forecast (usando geopy más una solicitud http http abierta) y luego alimenta el resultado de la herramienta en el modelo para producir y devolver la respuesta conversacional final.
Función llamando al uso de funciones de Python
from geopy.geocoders import Nominatim
import requests
geolocator = Nominatim(user_agent="weather-app")
def get_weather_forecast(location: str, date: str) -> str:
"""
Retrieves the weather using Open-Meteo API for a given location (city) and a date (yyyy-mm-dd). Returns a list dictionary with the time and temperature for each hour."
Args:
location (str): The city and state, e.g., San Francisco, CA
date (str): The forecasting date for when to get the weather format (yyyy-mm-dd)
Returns:
Dict[str, float]: A dictionary with the time as key and the temperature as value
"""
location = geolocator.geocode(location)
if location:
try:
response = requests.get(f"https://api.open-meteo.com/v1/forecast?latitude={location.latitude}&longitude={location.longitude}&hourly=temperature_2m&start_date={date}&end_date={date}")
data = response.json()
return {time: temp for time, temp in zip(data["hourly"]["time"], data["hourly"]["temperature_2m"])}
except Exception as e:
return {"error": str(e)}
else:
return {"error": "Location not found"}La función get_weather_forecast primero usa Nominatim de Geopy para convertir una cadena de ciudad y estado en coordenadas, luego envía una solicitud HTTP a la API de meteeo abierto para recuperar datos de temperatura por hora para la fecha dada, devolviendo un diccionario que mapea cada marca de tiempo de tiempo correspondiente. También maneja los errores con gracia, devolviendo un mensaje de error si la ubicación no se encuentra o la llamada API falla.
from google.genai.types import GenerateContentConfig
config = GenerateContentConfig(
system_instruction="You are a helpful assistant that can help with weather related questions. Today is 2025-03-04.", # to give the LLM context on the current date.
tools=[get_weather_forecast],
automatic_function_calling={"disable": True}
)
Esta configuración registra su función Python get_weather_forecast como una herramienta invocable. Establece una solicitud de sistema CORRE (incluida la fecha) para el contexto, al tiempo que deshabilita “Automatic_function_calling” para que Gemini emita la carga útil de las llamadas de función en lugar de invocarla internamente.
r = client.models.generate_content(
model=model_id,
config=config,
contents="Whats the weather in Berlin today?"
)
for part in r.candidates[0].content.parts:
print(part.function_call)Al enviar el aviso con su configuración personalizada (incluida la herramienta Python pero con llamadas automáticas deshabilitadas), este fragmento captura la decisión de la función sin procesar de Gemini. Luego, supera cada parte de respuesta para imprimir el objeto .function_call, permitiéndole inspeccionar exactamente qué herramienta quiere invocar y con qué argumentos.
from google.genai.types import GenerateContentConfig
config = GenerateContentConfig(
system_instruction="You are a helpful assistant that use tools to access and retrieve information from a weather API. Today is 2025-03-04.", # to give the LLM context on the current date.
tools=[get_weather_forecast],
)
r = client.models.generate_content(
model=model_id,
config=config,
contents="Whats the weather in Berlin today?"
)
print(r.text)Con esta configuración (que incluye su función get_weather_forecast y deja la llamada automática habilitada de forma predeterminada), llamar a Generate_Content hará que Gemini invoque su herramienta meteorológica detrás de escena y luego devuelva una respuesta de lenguaje natural. Impresión R.Text salidas esa respuesta final, incluido el pronóstico de temperatura real para Berlín en la fecha especificada.
from google.genai.types import GenerateContentConfig
config = GenerateContentConfig(
system_instruction="You are a helpful assistant that use tools to access and retrieve information from a weather API.",
tools=[get_weather_forecast],
)
prompt = f"""
Today is 2025-03-04. You are chatting with Andrew, you have access to more information about him.
User Context:
- name: Andrew
- location: Nuremberg
User: Can i wear a T-shirt later today?"""
r = client.models.generate_content(
model=model_id,
config=config,
contents=prompt
)
print(r.text)Extendemos a su asistente con contexto personal, le dice el nombre y la ubicación de Gemini Andrew (Nuremberg) y preguntamos si es un clima de camiseta, mientras usa la herramienta Get_Weather_Forecast debajo del capó. Luego imprime la recomendación del idioma natural del modelo basada en el pronóstico real para ese día.
En conclusión, ahora sabemos cómo definir las funciones (a través del esquema JSON o las firmas de Python), configurar Gemini 2.0 Flash para detectar y emitir llamadas de funciones e implementar el bucle “agente” que ejecuta esas llamadas y compone la respuesta final. Con estos bloques de construcción, podemos extender cualquier LLM a un asistente capaz y habilitado para herramientas que automatiza los flujos de trabajo, recupera datos en vivo e interactúa con su código o API tan sin esfuerzo como chatear con un colega.
Aquí está el Cuaderno de colab. Además, no olvides seguirnos Gorjeo y únete a nuestro Canal de telegrama y LinkedIn GRsalpicar. No olvides unirte a nuestro 90k+ ml de subreddit.
Asif Razzaq es el CEO de MarktechPost Media Inc .. Como empresario e ingeniero visionario, ASIF se compromete a aprovechar el potencial de la inteligencia artificial para el bien social. Su esfuerzo más reciente es el lanzamiento de una plataforma de medios de inteligencia artificial, MarktechPost, que se destaca por su cobertura profunda de noticias de aprendizaje automático y de aprendizaje profundo que es técnicamente sólido y fácilmente comprensible por una audiencia amplia. La plataforma cuenta con más de 2 millones de vistas mensuales, ilustrando su popularidad entre el público.
