Capítulo 6: Llamada a funciones y uso de herramientas
Ejercicios Prácticos — Capítulo 6
Pon a prueba tu comprensión y refuerza tus habilidades trabajando en los siguientes ejercicios. Estas tareas te ayudarán a configurar llamadas a funciones, definir esquemas de funciones, encadenar llamadas a herramientas externas y analizar respuestas de la API.
Ejercicio 1: Llamada Básica a Funciones
Tarea:
Construye una conversación donde el asistente reconozca una solicitud que requiera un cálculo. Define una función llamada calculate_sum que tome dos números, y simula una llamada a la API donde el modelo activa una llamada a función para calcular la suma de 8 y 15.
Solución:
import openai
import os
import json
from dotenv import load_dotenv
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
# Define the function schema for calculating the sum.
function_definitions = [
{
"name": "calculate_sum",
"description": "Calculates the sum of two numbers.",
"parameters": {
"type": "object",
"properties": {
"a": {"type": "number", "description": "The first number."},
"b": {"type": "number", "description": "The second number."}
},
"required": ["a", "b"]
}
}
]
# Construct a multi-turn conversation to trigger the function call.
messages = [
{"role": "system", "content": "You are a helpful assistant who can perform calculations."},
{"role": "user", "content": "What is the sum of 8 and 15?"}
]
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
functions=function_definitions,
function_call="auto", # Let the model decide if it needs to call the function.
max_tokens=100,
temperature=0.5
)
if response["choices"][0].get("finish_reason") == "function_call":
function_call_info = response["choices"][0]["message"]["function_call"]
print("Function Call Triggered:")
print("Function Name:", function_call_info.get("name"))
print("Arguments:", function_call_info.get("arguments"))
else:
print("Textual Response:")
print(response["choices"][0]["message"]["content"])Este ejercicio demuestra cómo configurar una llamada a función, definir un esquema de función y verificar si el modelo elige llamar a la función según el contexto de la conversación.
Ejercicio 2: Definición de un Esquema de Función para una Operación Personalizada
Tarea:
Define un nuevo esquema de función para una función llamada calculate_difference que calcule la diferencia entre dos números. Luego simula una conversación donde un usuario pregunta "¿Cuál es la diferencia entre 20 y 5?" y maneja la llamada a la función.
Solución:
# Define the function schema for calculating the difference.
function_definitions = [
{
"name": "calculate_difference",
"description": "Calculates the difference between two numbers (first minus second).",
"parameters": {
"type": "object",
"properties": {
"a": {"type": "number", "description": "The number from which to subtract."},
"b": {"type": "number", "description": "The number to subtract."}
},
"required": ["a", "b"]
}
}
]
# Conversation setup
messages = [
{"role": "system", "content": "You are a calculator assistant."},
{"role": "user", "content": "Can you tell me the difference between 20 and 5?"}
]
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
functions=function_definitions,
function_call="auto",
max_tokens=100,
temperature=0.5
)
if response["choices"][0].get("finish_reason") == "function_call":
function_call_info = response["choices"][0]["message"]["function_call"]
print("Function Call Triggered:")
print("Function Name:", function_call_info.get("name"))
print("Arguments:", function_call_info.get("arguments"))
else:
print("Response:")
print(response["choices"][0]["message"]["content"])
Este ejercicio muestra cómo crear un esquema de función personalizado y configurar una conversación que pueda activar la llamada a función.
Ejercicio 3: Uso de Herramientas y Encadenamiento de API
Tarea:
Simula un escenario donde el usuario pregunta sobre el clima actual en "Los Ángeles". Primero, define una función get_weather para simular la obtención de datos meteorológicos. Luego integra esta función en tu conversación mediante el encadenamiento de API.
Solución:
def get_weather(city):
# Simulated weather data for demonstration purposes.
weather_data = {
"Los Angeles": {"temperature": 26, "condition": "sunny"},
"New York": {"temperature": 18, "condition": "cloudy"},
"San Francisco": {"temperature": 15, "condition": "foggy"}
}
return weather_data.get(city, {"temperature": None, "condition": "unknown"})
# Define the function schema for weather retrieval.
function_definitions = [
{
"name": "get_weather",
"description": "Fetches current weather data for a specified city.",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "The city to get weather information for."}
},
"required": ["city"]
}
}
]
# Construct the conversation.
messages = [
{"role": "system", "content": "You are a knowledgeable assistant that can provide weather updates."},
{"role": "user", "content": "What is the current weather in Los Angeles?"}
]
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
functions=function_definitions,
function_call="auto",
max_tokens=150,
temperature=0.5
)
if response["choices"][0].get("finish_reason") == "function_call":
function_call_info = response["choices"][0]["message"]["function_call"]
arguments_str = function_call_info.get("arguments", "{}")
# Parse the arguments, expecting a JSON dictionary.
import json
arguments = json.loads(arguments_str)
city = arguments.get("city", "Los Angeles")
# Call the simulated external weather function.
weather_info = get_weather(city)
follow_up_message = (
f"The weather in {city} is currently {weather_info['condition']} with a temperature of {weather_info['temperature']}°C."
)
# Append the function result to the conversation.
messages.append({
"role": "assistant",
"content": follow_up_message
})
# Optionally, generate a final summary response.
final_response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
max_tokens=100,
temperature=0.5
)
print("Final Chained Response:")
print(final_response["choices"][0]["message"]["content"])
else:
print("Response:")
print(response["choices"][0]["message"]["content"])
Este ejercicio demuestra cómo encadenar una llamada a función externa en el flujo de la conversación, obtener datos de un servicio meteorológico simulado e integrar esa información de vuelta en la conversación.
Ejercicio 4: Análisis de una Respuesta en Streaming
Tarea:
Implementa una llamada a la API en streaming que muestre el texto generado tan pronto como se produzca. Utiliza una consulta simple y muestra cada fragmento transmitido.
Solución:
import openai
import os
from dotenv import load_dotenv
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
messages = [
{"role": "system", "content": "You are a friendly assistant who provides inspirational quotes."},
{"role": "user", "content": "Share an inspirational quote about perseverance."}
]
response_stream = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
max_tokens=100,
temperature=0.6,
stream=True # Enable streaming mode.
)
print("Streaming Response:")
for chunk in response_stream:
if "choices" in chunk:
part = chunk["choices"][0].get("delta", {}).get("content", "")
print(part, end="", flush=True)
print("\nStreaming complete!")Este ejercicio te ayuda a familiarizarte con el manejo de respuestas en tiempo real, permitiendo que tu aplicación proporcione retroalimentación instantánea.
Estos ejercicios cubren los aspectos clave de las llamadas a funciones y el uso de herramientas—desde la configuración de llamadas a funciones y la definición de esquemas de funciones, hasta el encadenamiento de múltiples llamadas a API y el manejo de respuestas en tiempo real. Al completar estos ejercicios, obtendrás experiencia práctica en la integración de operaciones dinámicas en tus aplicaciones de IA conversacional.
Ejercicios Prácticos — Capítulo 6
Pon a prueba tu comprensión y refuerza tus habilidades trabajando en los siguientes ejercicios. Estas tareas te ayudarán a configurar llamadas a funciones, definir esquemas de funciones, encadenar llamadas a herramientas externas y analizar respuestas de la API.
Ejercicio 1: Llamada Básica a Funciones
Tarea:
Construye una conversación donde el asistente reconozca una solicitud que requiera un cálculo. Define una función llamada calculate_sum que tome dos números, y simula una llamada a la API donde el modelo activa una llamada a función para calcular la suma de 8 y 15.
Solución:
import openai
import os
import json
from dotenv import load_dotenv
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
# Define the function schema for calculating the sum.
function_definitions = [
{
"name": "calculate_sum",
"description": "Calculates the sum of two numbers.",
"parameters": {
"type": "object",
"properties": {
"a": {"type": "number", "description": "The first number."},
"b": {"type": "number", "description": "The second number."}
},
"required": ["a", "b"]
}
}
]
# Construct a multi-turn conversation to trigger the function call.
messages = [
{"role": "system", "content": "You are a helpful assistant who can perform calculations."},
{"role": "user", "content": "What is the sum of 8 and 15?"}
]
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
functions=function_definitions,
function_call="auto", # Let the model decide if it needs to call the function.
max_tokens=100,
temperature=0.5
)
if response["choices"][0].get("finish_reason") == "function_call":
function_call_info = response["choices"][0]["message"]["function_call"]
print("Function Call Triggered:")
print("Function Name:", function_call_info.get("name"))
print("Arguments:", function_call_info.get("arguments"))
else:
print("Textual Response:")
print(response["choices"][0]["message"]["content"])Este ejercicio demuestra cómo configurar una llamada a función, definir un esquema de función y verificar si el modelo elige llamar a la función según el contexto de la conversación.
Ejercicio 2: Definición de un Esquema de Función para una Operación Personalizada
Tarea:
Define un nuevo esquema de función para una función llamada calculate_difference que calcule la diferencia entre dos números. Luego simula una conversación donde un usuario pregunta "¿Cuál es la diferencia entre 20 y 5?" y maneja la llamada a la función.
Solución:
# Define the function schema for calculating the difference.
function_definitions = [
{
"name": "calculate_difference",
"description": "Calculates the difference between two numbers (first minus second).",
"parameters": {
"type": "object",
"properties": {
"a": {"type": "number", "description": "The number from which to subtract."},
"b": {"type": "number", "description": "The number to subtract."}
},
"required": ["a", "b"]
}
}
]
# Conversation setup
messages = [
{"role": "system", "content": "You are a calculator assistant."},
{"role": "user", "content": "Can you tell me the difference between 20 and 5?"}
]
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
functions=function_definitions,
function_call="auto",
max_tokens=100,
temperature=0.5
)
if response["choices"][0].get("finish_reason") == "function_call":
function_call_info = response["choices"][0]["message"]["function_call"]
print("Function Call Triggered:")
print("Function Name:", function_call_info.get("name"))
print("Arguments:", function_call_info.get("arguments"))
else:
print("Response:")
print(response["choices"][0]["message"]["content"])
Este ejercicio muestra cómo crear un esquema de función personalizado y configurar una conversación que pueda activar la llamada a función.
Ejercicio 3: Uso de Herramientas y Encadenamiento de API
Tarea:
Simula un escenario donde el usuario pregunta sobre el clima actual en "Los Ángeles". Primero, define una función get_weather para simular la obtención de datos meteorológicos. Luego integra esta función en tu conversación mediante el encadenamiento de API.
Solución:
def get_weather(city):
# Simulated weather data for demonstration purposes.
weather_data = {
"Los Angeles": {"temperature": 26, "condition": "sunny"},
"New York": {"temperature": 18, "condition": "cloudy"},
"San Francisco": {"temperature": 15, "condition": "foggy"}
}
return weather_data.get(city, {"temperature": None, "condition": "unknown"})
# Define the function schema for weather retrieval.
function_definitions = [
{
"name": "get_weather",
"description": "Fetches current weather data for a specified city.",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "The city to get weather information for."}
},
"required": ["city"]
}
}
]
# Construct the conversation.
messages = [
{"role": "system", "content": "You are a knowledgeable assistant that can provide weather updates."},
{"role": "user", "content": "What is the current weather in Los Angeles?"}
]
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
functions=function_definitions,
function_call="auto",
max_tokens=150,
temperature=0.5
)
if response["choices"][0].get("finish_reason") == "function_call":
function_call_info = response["choices"][0]["message"]["function_call"]
arguments_str = function_call_info.get("arguments", "{}")
# Parse the arguments, expecting a JSON dictionary.
import json
arguments = json.loads(arguments_str)
city = arguments.get("city", "Los Angeles")
# Call the simulated external weather function.
weather_info = get_weather(city)
follow_up_message = (
f"The weather in {city} is currently {weather_info['condition']} with a temperature of {weather_info['temperature']}°C."
)
# Append the function result to the conversation.
messages.append({
"role": "assistant",
"content": follow_up_message
})
# Optionally, generate a final summary response.
final_response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
max_tokens=100,
temperature=0.5
)
print("Final Chained Response:")
print(final_response["choices"][0]["message"]["content"])
else:
print("Response:")
print(response["choices"][0]["message"]["content"])
Este ejercicio demuestra cómo encadenar una llamada a función externa en el flujo de la conversación, obtener datos de un servicio meteorológico simulado e integrar esa información de vuelta en la conversación.
Ejercicio 4: Análisis de una Respuesta en Streaming
Tarea:
Implementa una llamada a la API en streaming que muestre el texto generado tan pronto como se produzca. Utiliza una consulta simple y muestra cada fragmento transmitido.
Solución:
import openai
import os
from dotenv import load_dotenv
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
messages = [
{"role": "system", "content": "You are a friendly assistant who provides inspirational quotes."},
{"role": "user", "content": "Share an inspirational quote about perseverance."}
]
response_stream = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
max_tokens=100,
temperature=0.6,
stream=True # Enable streaming mode.
)
print("Streaming Response:")
for chunk in response_stream:
if "choices" in chunk:
part = chunk["choices"][0].get("delta", {}).get("content", "")
print(part, end="", flush=True)
print("\nStreaming complete!")Este ejercicio te ayuda a familiarizarte con el manejo de respuestas en tiempo real, permitiendo que tu aplicación proporcione retroalimentación instantánea.
Estos ejercicios cubren los aspectos clave de las llamadas a funciones y el uso de herramientas—desde la configuración de llamadas a funciones y la definición de esquemas de funciones, hasta el encadenamiento de múltiples llamadas a API y el manejo de respuestas en tiempo real. Al completar estos ejercicios, obtendrás experiencia práctica en la integración de operaciones dinámicas en tus aplicaciones de IA conversacional.
Ejercicios Prácticos — Capítulo 6
Pon a prueba tu comprensión y refuerza tus habilidades trabajando en los siguientes ejercicios. Estas tareas te ayudarán a configurar llamadas a funciones, definir esquemas de funciones, encadenar llamadas a herramientas externas y analizar respuestas de la API.
Ejercicio 1: Llamada Básica a Funciones
Tarea:
Construye una conversación donde el asistente reconozca una solicitud que requiera un cálculo. Define una función llamada calculate_sum que tome dos números, y simula una llamada a la API donde el modelo activa una llamada a función para calcular la suma de 8 y 15.
Solución:
import openai
import os
import json
from dotenv import load_dotenv
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
# Define the function schema for calculating the sum.
function_definitions = [
{
"name": "calculate_sum",
"description": "Calculates the sum of two numbers.",
"parameters": {
"type": "object",
"properties": {
"a": {"type": "number", "description": "The first number."},
"b": {"type": "number", "description": "The second number."}
},
"required": ["a", "b"]
}
}
]
# Construct a multi-turn conversation to trigger the function call.
messages = [
{"role": "system", "content": "You are a helpful assistant who can perform calculations."},
{"role": "user", "content": "What is the sum of 8 and 15?"}
]
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
functions=function_definitions,
function_call="auto", # Let the model decide if it needs to call the function.
max_tokens=100,
temperature=0.5
)
if response["choices"][0].get("finish_reason") == "function_call":
function_call_info = response["choices"][0]["message"]["function_call"]
print("Function Call Triggered:")
print("Function Name:", function_call_info.get("name"))
print("Arguments:", function_call_info.get("arguments"))
else:
print("Textual Response:")
print(response["choices"][0]["message"]["content"])Este ejercicio demuestra cómo configurar una llamada a función, definir un esquema de función y verificar si el modelo elige llamar a la función según el contexto de la conversación.
Ejercicio 2: Definición de un Esquema de Función para una Operación Personalizada
Tarea:
Define un nuevo esquema de función para una función llamada calculate_difference que calcule la diferencia entre dos números. Luego simula una conversación donde un usuario pregunta "¿Cuál es la diferencia entre 20 y 5?" y maneja la llamada a la función.
Solución:
# Define the function schema for calculating the difference.
function_definitions = [
{
"name": "calculate_difference",
"description": "Calculates the difference between two numbers (first minus second).",
"parameters": {
"type": "object",
"properties": {
"a": {"type": "number", "description": "The number from which to subtract."},
"b": {"type": "number", "description": "The number to subtract."}
},
"required": ["a", "b"]
}
}
]
# Conversation setup
messages = [
{"role": "system", "content": "You are a calculator assistant."},
{"role": "user", "content": "Can you tell me the difference between 20 and 5?"}
]
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
functions=function_definitions,
function_call="auto",
max_tokens=100,
temperature=0.5
)
if response["choices"][0].get("finish_reason") == "function_call":
function_call_info = response["choices"][0]["message"]["function_call"]
print("Function Call Triggered:")
print("Function Name:", function_call_info.get("name"))
print("Arguments:", function_call_info.get("arguments"))
else:
print("Response:")
print(response["choices"][0]["message"]["content"])
Este ejercicio muestra cómo crear un esquema de función personalizado y configurar una conversación que pueda activar la llamada a función.
Ejercicio 3: Uso de Herramientas y Encadenamiento de API
Tarea:
Simula un escenario donde el usuario pregunta sobre el clima actual en "Los Ángeles". Primero, define una función get_weather para simular la obtención de datos meteorológicos. Luego integra esta función en tu conversación mediante el encadenamiento de API.
Solución:
def get_weather(city):
# Simulated weather data for demonstration purposes.
weather_data = {
"Los Angeles": {"temperature": 26, "condition": "sunny"},
"New York": {"temperature": 18, "condition": "cloudy"},
"San Francisco": {"temperature": 15, "condition": "foggy"}
}
return weather_data.get(city, {"temperature": None, "condition": "unknown"})
# Define the function schema for weather retrieval.
function_definitions = [
{
"name": "get_weather",
"description": "Fetches current weather data for a specified city.",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "The city to get weather information for."}
},
"required": ["city"]
}
}
]
# Construct the conversation.
messages = [
{"role": "system", "content": "You are a knowledgeable assistant that can provide weather updates."},
{"role": "user", "content": "What is the current weather in Los Angeles?"}
]
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
functions=function_definitions,
function_call="auto",
max_tokens=150,
temperature=0.5
)
if response["choices"][0].get("finish_reason") == "function_call":
function_call_info = response["choices"][0]["message"]["function_call"]
arguments_str = function_call_info.get("arguments", "{}")
# Parse the arguments, expecting a JSON dictionary.
import json
arguments = json.loads(arguments_str)
city = arguments.get("city", "Los Angeles")
# Call the simulated external weather function.
weather_info = get_weather(city)
follow_up_message = (
f"The weather in {city} is currently {weather_info['condition']} with a temperature of {weather_info['temperature']}°C."
)
# Append the function result to the conversation.
messages.append({
"role": "assistant",
"content": follow_up_message
})
# Optionally, generate a final summary response.
final_response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
max_tokens=100,
temperature=0.5
)
print("Final Chained Response:")
print(final_response["choices"][0]["message"]["content"])
else:
print("Response:")
print(response["choices"][0]["message"]["content"])
Este ejercicio demuestra cómo encadenar una llamada a función externa en el flujo de la conversación, obtener datos de un servicio meteorológico simulado e integrar esa información de vuelta en la conversación.
Ejercicio 4: Análisis de una Respuesta en Streaming
Tarea:
Implementa una llamada a la API en streaming que muestre el texto generado tan pronto como se produzca. Utiliza una consulta simple y muestra cada fragmento transmitido.
Solución:
import openai
import os
from dotenv import load_dotenv
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
messages = [
{"role": "system", "content": "You are a friendly assistant who provides inspirational quotes."},
{"role": "user", "content": "Share an inspirational quote about perseverance."}
]
response_stream = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
max_tokens=100,
temperature=0.6,
stream=True # Enable streaming mode.
)
print("Streaming Response:")
for chunk in response_stream:
if "choices" in chunk:
part = chunk["choices"][0].get("delta", {}).get("content", "")
print(part, end="", flush=True)
print("\nStreaming complete!")Este ejercicio te ayuda a familiarizarte con el manejo de respuestas en tiempo real, permitiendo que tu aplicación proporcione retroalimentación instantánea.
Estos ejercicios cubren los aspectos clave de las llamadas a funciones y el uso de herramientas—desde la configuración de llamadas a funciones y la definición de esquemas de funciones, hasta el encadenamiento de múltiples llamadas a API y el manejo de respuestas en tiempo real. Al completar estos ejercicios, obtendrás experiencia práctica en la integración de operaciones dinámicas en tus aplicaciones de IA conversacional.
Ejercicios Prácticos — Capítulo 6
Pon a prueba tu comprensión y refuerza tus habilidades trabajando en los siguientes ejercicios. Estas tareas te ayudarán a configurar llamadas a funciones, definir esquemas de funciones, encadenar llamadas a herramientas externas y analizar respuestas de la API.
Ejercicio 1: Llamada Básica a Funciones
Tarea:
Construye una conversación donde el asistente reconozca una solicitud que requiera un cálculo. Define una función llamada calculate_sum que tome dos números, y simula una llamada a la API donde el modelo activa una llamada a función para calcular la suma de 8 y 15.
Solución:
import openai
import os
import json
from dotenv import load_dotenv
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
# Define the function schema for calculating the sum.
function_definitions = [
{
"name": "calculate_sum",
"description": "Calculates the sum of two numbers.",
"parameters": {
"type": "object",
"properties": {
"a": {"type": "number", "description": "The first number."},
"b": {"type": "number", "description": "The second number."}
},
"required": ["a", "b"]
}
}
]
# Construct a multi-turn conversation to trigger the function call.
messages = [
{"role": "system", "content": "You are a helpful assistant who can perform calculations."},
{"role": "user", "content": "What is the sum of 8 and 15?"}
]
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
functions=function_definitions,
function_call="auto", # Let the model decide if it needs to call the function.
max_tokens=100,
temperature=0.5
)
if response["choices"][0].get("finish_reason") == "function_call":
function_call_info = response["choices"][0]["message"]["function_call"]
print("Function Call Triggered:")
print("Function Name:", function_call_info.get("name"))
print("Arguments:", function_call_info.get("arguments"))
else:
print("Textual Response:")
print(response["choices"][0]["message"]["content"])Este ejercicio demuestra cómo configurar una llamada a función, definir un esquema de función y verificar si el modelo elige llamar a la función según el contexto de la conversación.
Ejercicio 2: Definición de un Esquema de Función para una Operación Personalizada
Tarea:
Define un nuevo esquema de función para una función llamada calculate_difference que calcule la diferencia entre dos números. Luego simula una conversación donde un usuario pregunta "¿Cuál es la diferencia entre 20 y 5?" y maneja la llamada a la función.
Solución:
# Define the function schema for calculating the difference.
function_definitions = [
{
"name": "calculate_difference",
"description": "Calculates the difference between two numbers (first minus second).",
"parameters": {
"type": "object",
"properties": {
"a": {"type": "number", "description": "The number from which to subtract."},
"b": {"type": "number", "description": "The number to subtract."}
},
"required": ["a", "b"]
}
}
]
# Conversation setup
messages = [
{"role": "system", "content": "You are a calculator assistant."},
{"role": "user", "content": "Can you tell me the difference between 20 and 5?"}
]
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
functions=function_definitions,
function_call="auto",
max_tokens=100,
temperature=0.5
)
if response["choices"][0].get("finish_reason") == "function_call":
function_call_info = response["choices"][0]["message"]["function_call"]
print("Function Call Triggered:")
print("Function Name:", function_call_info.get("name"))
print("Arguments:", function_call_info.get("arguments"))
else:
print("Response:")
print(response["choices"][0]["message"]["content"])
Este ejercicio muestra cómo crear un esquema de función personalizado y configurar una conversación que pueda activar la llamada a función.
Ejercicio 3: Uso de Herramientas y Encadenamiento de API
Tarea:
Simula un escenario donde el usuario pregunta sobre el clima actual en "Los Ángeles". Primero, define una función get_weather para simular la obtención de datos meteorológicos. Luego integra esta función en tu conversación mediante el encadenamiento de API.
Solución:
def get_weather(city):
# Simulated weather data for demonstration purposes.
weather_data = {
"Los Angeles": {"temperature": 26, "condition": "sunny"},
"New York": {"temperature": 18, "condition": "cloudy"},
"San Francisco": {"temperature": 15, "condition": "foggy"}
}
return weather_data.get(city, {"temperature": None, "condition": "unknown"})
# Define the function schema for weather retrieval.
function_definitions = [
{
"name": "get_weather",
"description": "Fetches current weather data for a specified city.",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "The city to get weather information for."}
},
"required": ["city"]
}
}
]
# Construct the conversation.
messages = [
{"role": "system", "content": "You are a knowledgeable assistant that can provide weather updates."},
{"role": "user", "content": "What is the current weather in Los Angeles?"}
]
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
functions=function_definitions,
function_call="auto",
max_tokens=150,
temperature=0.5
)
if response["choices"][0].get("finish_reason") == "function_call":
function_call_info = response["choices"][0]["message"]["function_call"]
arguments_str = function_call_info.get("arguments", "{}")
# Parse the arguments, expecting a JSON dictionary.
import json
arguments = json.loads(arguments_str)
city = arguments.get("city", "Los Angeles")
# Call the simulated external weather function.
weather_info = get_weather(city)
follow_up_message = (
f"The weather in {city} is currently {weather_info['condition']} with a temperature of {weather_info['temperature']}°C."
)
# Append the function result to the conversation.
messages.append({
"role": "assistant",
"content": follow_up_message
})
# Optionally, generate a final summary response.
final_response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
max_tokens=100,
temperature=0.5
)
print("Final Chained Response:")
print(final_response["choices"][0]["message"]["content"])
else:
print("Response:")
print(response["choices"][0]["message"]["content"])
Este ejercicio demuestra cómo encadenar una llamada a función externa en el flujo de la conversación, obtener datos de un servicio meteorológico simulado e integrar esa información de vuelta en la conversación.
Ejercicio 4: Análisis de una Respuesta en Streaming
Tarea:
Implementa una llamada a la API en streaming que muestre el texto generado tan pronto como se produzca. Utiliza una consulta simple y muestra cada fragmento transmitido.
Solución:
import openai
import os
from dotenv import load_dotenv
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
messages = [
{"role": "system", "content": "You are a friendly assistant who provides inspirational quotes."},
{"role": "user", "content": "Share an inspirational quote about perseverance."}
]
response_stream = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages,
max_tokens=100,
temperature=0.6,
stream=True # Enable streaming mode.
)
print("Streaming Response:")
for chunk in response_stream:
if "choices" in chunk:
part = chunk["choices"][0].get("delta", {}).get("content", "")
print(part, end="", flush=True)
print("\nStreaming complete!")Este ejercicio te ayuda a familiarizarte con el manejo de respuestas en tiempo real, permitiendo que tu aplicación proporcione retroalimentación instantánea.
Estos ejercicios cubren los aspectos clave de las llamadas a funciones y el uso de herramientas—desde la configuración de llamadas a funciones y la definición de esquemas de funciones, hasta el encadenamiento de múltiples llamadas a API y el manejo de respuestas en tiempo real. Al completar estos ejercicios, obtendrás experiencia práctica en la integración de operaciones dinámicas en tus aplicaciones de IA conversacional.