¿Cómo implementar el uso de herramientas dentro de un modelo GPT?
En la actualidad, integrar herramientas externas en un modelo de lenguaje como GPT tiene un potencial ilimitado para expandir sus funcionalidades. En esta clase, aprenderemos a usar una API de GPT para obtener información climática en tiempo real basada en coordenadas geográficas. ¡Vamos a sumergirnos en el código y descubrir cómo hacer esto!
¿Cómo estructurar los mensajes en Python?
Para interactuar con la API de OpenAI, es fundamental estructurar adecuadamente los mensajes que el asistente manejará. En Python, una lista se utiliza para definir roles y mensajes:
mensajes =[{"role":"system","content":"Eres un asistente que entrega datos sobre el clima del mundo en tiempo real."},{"role":"user","content":"¿Cuál es el clima de Buenos Aires?"}]
¿Cómo definir y declarar la API de chat GPT?
El siguiente paso es declarar los modelos y usar la función create del módulo chat.completion. Esto permitirá integrar modelos actualizados que admiten funciones.
Para comunicar el modelo con la función, declaramos los parámetros y el tipo de datos que manejará:
funciones =[{"name":"get_weather","description":"Usa esta función para obtener información sobre el clima.","parameters":{"latitud":{"type":"number","description":"Latitud de la ubicación."},"longitud":{"type":"number","description":"Longitud de la ubicación."}},"required":["latitud","longitud"],"output":{"type":"string","description":"Clima de la ubicación pedida por el usuario"}}]
¿Cómo gestionar la ejecución y respuesta de la función?
Una vez que la función ha sido creada y definida, debemos integrarla en el flujo de ejecución del programa para obtener una respuesta detallada del asistente:
Este código nos permite hacer un seguimiento de las llamadas de la función get_weather, ejecutarlas y devolver la información al modelo GPT para una respuesta completa.
Recomendaciones y próximos pasos
Te animamos a expandir esta integración con otras APIs que te interesen, como las de Star Wars o Pokémon. No olvides definir claramente cada función en el código y siempre practicar para mejorar tus habilidades de programación e integración con modelos de lenguaje.
¡Sigue practicando y explorando las increíbles posibilidades que te ofrece la tecnología de los modelos GPT!
⚒️ Revisa el código desarrollado de esta clase en el repositorio del curso:
Muchas gracias profe!
⚒️ Así es cómo funciona el flujo de las herramientas para los asistentes basados en ChatCompletion API.
El asistente selecciona una herramienta, provee sus parámetros, obtenemos el resultado e implementamos la ejecución de la función. Y pasamos ese resultado final de vuelta al asistente:
como realizas ese grafico he visto flechas en movimiento y asi
Para los que quieran utilizar nodejs en vez de python aquí les dejo mi repo:
<>
Estaré llevando el curso con javascript 🚀
Gran aporte, gracias!
Para los que están estudiando este curso, les recomiendo siempre ir de la mano con la documentación oficial de la API, no digo que el curso esté mal, solo que hace poco (a la fecha de hoy) actualización la documentación y en especial este tema de calling functions.
Es el mismo fundamento, únicamente hay pequeños cambios, acá les dejo el link de la documentación:
Para manejar documentos, imágenes y OCR, puedes explorar varias APIs disponibles. Algunas de las más populares son:
Google Cloud Vision API: Ofrece capacidades de OCR y análisis de imágenes.
Microsoft Azure Computer Vision: Permite realizar OCR y análisis de contenido visual.
Tesseract: Un motor de OCR de código abierto que puedes integrar en tus proyectos.
Adobe PDF Services API: Para manipulación y creación de documentos PDF.
Investiga la documentación de cada API para entender sus capacidades y cómo integrarlas en tus proyectos.
json.dumps() es una función en Python que convierte un objeto de Python (como un diccionario o lista) en una cadena JSON (JavaScript Object Notation). Es útil para serializar datos y poder enviarlos a través de una API o almacenarlos. El uso de dumps() es parte del módulo json, que facilita el manejo de datos en formato JSON en tus aplicaciones. Por ejemplo:
Esto permite que los datos sean fácilmente intercambiables entre diferentes lenguajes y plataformas.
¡Gracias por el aporte, Diego!
Documentación de interés:
Function calling: Function calling - OpenAI API
Compare the Responses API and Chat Completions API: Responses vs. Chat Completions - OpenAI API
Ejemplo con Responses API:
import os
from dotenv import load_dotenv
from openai import OpenAI
import requests
import json
load_dotenv()client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))defget_weather(latitude =float, longitude =float):print("Getting weather ...") url =f"https://api.open-meteo.com/v1/forecast?latitude={latitude}&longitude={longitude}¤t_weather=true" response = requests.get(url) weather_data = response.json()return json.dumps(weather_data)tools =[{"type":"function","name":"get_weather","description":"Get current temperature for provide coordinates incelsius.","parameters":{"type":"object","properties":{"latitude":{"type":"number","description":"Latitude"},"longitude":{"type":"number","description":"Longitude"}},"required":["latitude","longitude"],"additionalProperties":False},"strict":True}]input_messages =[{"role":"system","content":"Eres un asistente que entrega datos sobre el clima del mundo en tiempo real usando la función get_weather"},{"role":"user","content":"What's the weather like in Paris today?"}]response = client.responses.create( model="gpt-4o",input=input_messages, tools=tools
)tool_calls = response.output
print(tool_calls)for tool_call in tool_calls:if tool_call.type!="function_call":continue name = tool_call.name
args = json.loads(tool_call.arguments)if name =="get_weather":print("Call get_weather function") weather_info = get_weather(args.get("latitude"), args.get("longitude")); input_messages.append(tool_call) input_messages.append({"type":"function_call_output","call_id": tool_call.call_id,"output": weather_info
})response_2 = client.responses.create( model="gpt-4o",input=input_messages,)print(response_2.output_text)
El mismo ejercicio esta aquí en la página oficial de OpenAI actualizado
Cuando los parámetros necesarios para una función no pueden ser extraídos del modelo por falta de información, el asistente de GPT puede no ser capaz de ejecutar la función correctamente. En tales casos, el modelo puede responder con un mensaje indicando que no tiene suficiente información para proceder. Por ejemplo, podría sugerir al usuario que proporcione los datos requeridos o utilizar otra fuente para obtener la información necesaria. Esto subraya la importancia de proporcionar siempre los datos relevantes para obtener respuestas precisas.
La función de tools en la API de OpenAI permite al modelo GPT interactuar con herramientas externas, como APIs. Para usarla, primero defines las funciones que deseas que el modelo llame. Esto se hace creando un objeto de función que describe la función, sus parámetros y su salida esperada.
Luego, al momento de hacer la llamada a la API, incluyes el parámetro tools donde listan las funciones disponibles. Cuando el modelo necesita usar una función, llamará a tools con el nombre y parámetros necesarios, y tú ejecutarás la función en tu código, retornando el resultado para que el modelo lo utilice en su respuesta. Esto permite a GPT acceder a datos en tiempo real o realizar acciones específicas.
importaxiosfrom"axios";import{OpenAI}from"openai";const openai =newOpenAI();constget_weather=async(latitude, longitude)=>{try{const url =`https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}¤t_weather=true`;const response =await axios.get(url);return response.data;}catch(error){thrownewError(`Error al realizar la solicitud: ${error.message}`);}};const tools =[{type:"function",function:{name:"get_weather",description:"Obtiene el clima actual en una ubicación específica",parameters:{type:"object",properties:{latitude:{type:"string",description:"Latitud de la ubicación",},longitude:{type:"string",description:"Longitud de la ubicación",},},required:["latitude","longitude"],},}},];const messages =[{role:"user",content:"What's the weather like in Paris today?",},];const response =await openai.chat.completions.create({model:"gpt-4o",messages: messages,tools: tools,});const assistantMessage = response.choices[0].message;if(assistantMessage.tool_calls){console.log(assistantMessage.tool_calls);for(let tool_call of assistantMessage.tool_calls){const{name: functionName,arguments: functionArgs }= tool_call.function;const parsedArgs =JSON.parse(functionArgs);if(functionName ==="get_weather"){const weatherInfo =awaitget_weather(parsedArgs.latitude, parsedArgs.longitude); messages.push({role: tool_call.type,tool_call_id: tool_call.id,name: functionName,content:JSON.stringify(weatherInfo),});}}const secondResponse =await openai.chat.completions.create({model:"gpt-4",messages: messages,});console.log(secondResponse.choices[0].message.content);}```Comparto mi aporte, lo estoy haciendo en Node.js
🧠 Integración de APIs en modelos GPT
👉 Un modelo GPT puede conectarse con APIs externas.
👉 Esto le permite acceder a datos en tiempo real.
👉 También le permite resolver tareas más complejas.
🧩 1. ESTRUCTURA DE MENSAJES
📌 Los mensajes se organizan en una lista.
👉 Cada mensaje tiene un rol:
• 🧠 system → Define cómo debe comportarse el modelo.
• 🙋 user → Contiene la pregunta del usuario.
🔎 Ejemplo:
mensajes = [
{"role": "system", "content": "Eres un asistente que entrega datos sobre el clima..."},
{"role": "user", "content": "¿Cuál es el clima de Buenos Aires?"}
]
💡 Clave: Esta estructura guía la respuesta del modelo.
💡 Clave: Permite obtener datos reales (como el clima).
🔗 4. DEFINIR LA FUNCIÓN EN GPT
📌 Se le explica al modelo cómo es la función.
👉 Se debe especificar:
• 🏷️ Nombre
• 📝 Descripción
• 📥 Parámetros
• 📤 Tipo de respuesta
🎯 Objetivo:
👉 Que el modelo sepa cuándo debe usar la función.
⚙️ 5. EJECUCIÓN DE LA FUNCIÓN
📌 El modelo puede decidir llamar a la función.
🔍 ¿Cómo detectarlo?
if response['choices'][0]['finish_reason'] == 'function_call':
📌 Proceso paso a paso:
• 1️⃣ El modelo indica que quiere usar la función.
• 2️⃣ Se ejecuta la función en Python.
• 3️⃣ Se obtiene el resultado.
• 4️⃣ Se devuelve el resultado al modelo.
💡 Clave: Esto permite completar la respuesta con datos reales.
🚀 RESULTADO FINAL
✅ El modelo ahora puede:
• 🌍 Acceder a información en tiempo real.
• 🧠 Resolver tareas más complejas.
• ⚡ Ser más útil en aplicaciones reales.
¡Excelente clase!
Para que la API de OpenAI utilice funciones en tu script, como las que defines con el MCP de Playwright, es necesario que declares cada función en el contexto de herramientas que pasarás al modelo GPT.
Esto significa que debes estructurar cada función con su nombre, descripción y parámetros requeridos, de tal manera que el modelo comprenda cómo interactuar con ellas. El modelo no puede ver el código directamente, así que toda esta información debe estar bien definida en el objeto de herramientas que le proporcionas.
Así que sí, deberás definir todas las funciones que desees que OpenAI use, similar a lo que hiciste con getweather en el ejemplo de la clase.
La conexión de un Modelo de Control Predictivo (MCP) con la API de OpenAI se asemeja a la integración de herramientas. Al igual que con los "tools", debes definir el modelo y las funciones que el MCP utilizará. Deberás estructurar los mensajes y garantizar que el modelo tenga acceso a los parámetros necesarios para realizar las predicciones. En ambos casos, la clave es definir claramente cómo interactúa el modelo con la API y los roles de cada elemento involucrado.
Ese formato json de la funcion se encuentra en una documentacion ?
¡Hola Jeisson!,
Sí, el formato JSON de una función (tipo de herramienta) se encuentra en la documentación:
import os
from dotenv import load_dotenv
from openai import OpenAI
import requests
import json
load_dotenv()client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))defget_star_wars_character(name:str)->str:print(f"Buscando personaje: {name}") url =f"https://swapi.py4e.com/api/people/?search={name}" response = requests.get(url) data = response.json()if data["count"]==0:returnf"No se encontró información sobre el personaje '{name}'."return json.dumps(data["results"][0], indent=2)messages =[{"role":"system","content":"Eres un asistente experto en el universo de Star Wars. Usa la función get_star_wars_character para buscar información sobre personajes."},{"role":"user","content":"¿Quién es Luke Skywalker?"}]functions =[{"type":"function","function":{"name":"get_star_wars_character","description":"Obtiene información sobre un personaje de Star Wars","parameters":{"type":"object","properties":{"name":{"type":"string","description":"Nombre del personaje de Star Wars"}},"required":["name"]},"output":{"type":"string","description":"Información sobre el personaje de Star Wars"}}}]response = client.chat.completions.create( model="gpt-4o", messages=messages, tools=functions
)assistant_message = response.choices[0].message
print("Respuesta del asistente")print(assistant_message)if assistant_message.tool_calls:for tool_call in assistant_message.tool_calls:if tool_call.type=="function": function_name = tool_call.function.name
function_args = json.loads(tool_call.function.arguments)if function_name =="get_star_wars_character":print(f"El asistente está llamando a la función get_star_wars_character") character_info = get_star_wars_character( name=function_args.get("name")) messages.append(assistant_message) messages.append({"role":"tool","tool_call_id": tool_call.id,"name": function_name,"content": character_info
})second_response = client.chat.completions.create( model="gpt-4o", messages=messages
)final_reply = second_response.choices[0].message.content
print("Respuesta final del asistente:")print(final_reply)```El ejemplo con Star Wars resuelto, por si alguien necesita la referencia 
Forzosamente debemos usar Python en nuestros scripts o podemos usar JS?
Par lograr entender este Curso o Comprender como aplicar la integracion de API. Definitivamnete ha que saber de Codigo o Programacion.
