Probablemente hayas oído hablar de las últimas innovaciones de OpenAI, sus nuevas herramientas para crear agentes. Estas herramientas, impulsadas por la API de OpenAI, están revolucionando la forma en que los desarrolladores crean sistemas inteligentes y receptivos. Tanto si eres un programador experimentado como si estás empezando, esta entrada de blog te guiará a través de todo lo que necesitas saber para aprovechar las ofertas de OpenAI y crear tus propios agentes.
Por qué las nuevas herramientas de OpenAI para crear agentes cambian las reglas del juego
OpenAI anunció la integración de capacidades de búsqueda web en la API de OpenAI. Esta actualización introduce respuestas rápidas y actualizadas con enlaces a fuentes web relevantes, todo ello impulsado por el mismo modelo que ChatGPT search. Es un gran salto para los desarrolladores que buscan construir sistemas de agentes, piensen en asistentes de IA que puedan manejar tareas complejas, obtener datos en tiempo real e interactuar sin problemas con los usuarios.
OpenAI introdujo la API de Responses, las capacidades de búsqueda web, las herramientas de búsqueda de archivos, las funciones de uso de la computadora y el SDK de Agents. Juntos, forman un marco robusto para construir agentes que se sientan más inteligentes y autónomos que nunca. Las nuevas herramientas están diseñadas para ayudar a los desarrolladores a crear agentes seguros, eficientes y potentes.
¿Qué son los agentes, de todos modos? Un repaso rápido
Los agentes, en el contexto de la IA, son sistemas o programas autónomos que pueden percibir su entorno, tomar decisiones y realizar acciones para lograr objetivos específicos. Piensen en ellos como sus compañeros digitales capaces de responder preguntas, ejecutar tareas o incluso aprender de las interacciones.
Las nuevas herramientas de OpenAI permiten a los desarrolladores construir estos agentes utilizando la API de OpenAI, haciéndolos más inteligentes, más rápidos y más conectados a la web.
Primeros pasos: comprensión de la API de Responses de OpenAI
La API de Responses es un cambio de juego que combina las mejores características de las API de Chat Completions y Assistants de OpenAI en una herramienta más simple y potente. Si estás familiarizado con las API anteriores de OpenAI, apreciarás cómo esto agiliza el proceso de construcción de agentes.
Para empezar, dirígete a la documentación para desarrolladores de OpenAI . La API de Responses te permite integrar múltiples herramientas y modelos para ejecutar tareas complejas, lo que la hace perfecta para crear agentes de IA que puedan manejar todo, desde responder preguntas hasta orquestar flujos de trabajo de varios pasos.
Aquí te mostramos cómo puedes empezar:
La API de OpenAI proporciona una interfaz sencilla para los modelos de IA de última generación para la generación de texto, el procesamiento del lenguaje natural, la visión artificial y mucho más. Este ejemplo genera una salida de texto a partir de un mensaje, como podrías hacer usando ChatGPT.
import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-4o",
input: "Write a one-sentence bedtime story about a unicorn."
});
console.log(response.output_text);Analizar entradas de imagen
También puedes proporcionar entradas de imagen al modelo. Escanea recibos, analiza capturas de pantalla o encuentra objetos en el mundo real con visión artificial.
import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-4o",
input: [
{ role: "user", content: "What two teams are playing in this photo?" },
{
role: "user",
content: [
{
type: "input_image",
image_url: "https://upload.wikimedia.org/wikipedia/commons/3/3b/LeBron_James_Layup_%28Cleveland_vs_Brooklyn_2018%29.jpg",
}
],
},
],
});
console.log(response.output_text);Ampliar el modelo con herramientas
Dale al modelo acceso a nuevos datos y capacidades utilizando herramientas. Puedes llamar a tu propio código personalizado, o utilizar una de las potentes herramientas integradas de OpenAI. Este ejemplo utiliza la búsqueda web para dar al modelo acceso a la información más reciente en Internet.
import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-4o",
tools: [ { type: "web_search_preview" } ],
input: "What was a positive news story from today?",
});
console.log(response.output_text);Ofrecer experiencias de IA increíblemente rápidas
Utilizando la nueva API en tiempo real o los eventos de transmisión enviados por el servidor, puedes crear experiencias de alto rendimiento y baja latencia para tus usuarios.
import { OpenAI } from "openai";
const client = new OpenAI();
const stream = await client.responses.create({
model: "gpt-4o",
input: [
{
role: "user",
content: "Say 'double bubble bath' ten times fast.",
},
],
stream: true,
});
for await (const event of stream) {
console.log(event);
}Crear agentes
Utiliza la plataforma OpenAI para crear agentes capaces de tomar medidas, como controlar computadoras, en nombre de tus usuarios. Utiliza el SDK de Agent para Python para crear lógica de orquestación en el backend.
from agents import Agent, Runner
import asyncio
spanish_agent = Agent(
name="Spanish agent",
instructions="You only speak Spanish.",
)
english_agent = Agent(
name="English agent",
instructions="You only speak English",
)
triage_agent = Agent(
name="Triage agent",
instructions="Handoff to the appropriate agent based on the language of the request.",
handoffs=[spanish_agent, english_agent],
)
async def main():
result = await Runner.run(triage_agent, input="Hola, ¿cómo estás?")
print(result.final_output)
if __name__ == "__main__":
asyncio.run(main())
# ¡Hola! Estoy bien, gracias por preguntar. ¿Y tú, cómo estás?Las herramientas integradas de la API ejecutan estas tareas sin problemas, ahorrándote tiempo y esfuerzo. Además, está diseñado teniendo en cuenta la seguridad y la fiabilidad, lo cual es una gran ventaja para los desarrolladores.
Búsqueda web para agentes más inteligentes
La herramienta de búsqueda web de OpenAI, impulsada por modelos como GPT-4o search y GPT-4o mini search, permite a tus agentes obtener información actualizada de Internet y citar fuentes. Esto es especialmente útil para construir agentes que necesitan proporcionar respuestas precisas y en tiempo real.
La herramienta de búsqueda web está disponible en vista previa a través de la API de OpenAI, y cuenta con una precisión impresionante. En el benchmark SimpleQA de OpenAI, GPT-4o search obtiene una puntuación del 90%, mientras que GPT-4o mini search obtiene una puntuación del 88%. ¡Eso es una precisión seria!
Para implementar la búsqueda web en tu agente, consulta la guía de OpenAI. Aquí tienes un resumen rápido:
- Integrar la herramienta: utiliza la API de Responses para habilitar las capacidades de búsqueda web en tu agente.
- Crear consultas: diseña tu agente para enviar consultas específicas a la herramienta de búsqueda web, que luego recupera los resultados relevantes.
- Mostrar resultados: tu agente puede presentar los hallazgos a los usuarios, con enlaces a las fuentes para mayor transparencia.
Imagina construir un bot de atención al cliente que utilice la búsqueda web para responder preguntas sobre la disponibilidad de productos o las tendencias de la industria. Con la búsqueda web de OpenAI, tu agente puede ofrecer respuestas oportunas y precisas, aumentando la confianza y la satisfacción del usuario.
Dominar la búsqueda de archivos para un acceso eficiente a los datos
Otra herramienta potente en el arsenal de OpenAI es la búsqueda de archivos. Esta función permite a tus agentes de IA escanear rápidamente los archivos en las bases de datos de una empresa para recuperar información. Es ideal para aplicaciones empresariales donde los agentes necesitan acceder a documentos internos, informes o conjuntos de datos.
OpenAI enfatiza que no entrenará sus modelos en estos archivos, lo que garantiza la privacidad y la seguridad, una consideración crítica para las empresas. Puedes obtener más información sobre la búsqueda de archivos en la documentación .
Aquí te mostramos cómo incorporar la búsqueda de archivos en tu agente:
- Cargar archivos: utiliza la API de OpenAI para cargar tus archivos en la plataforma.
- Configurar el agente: configura tu agente para que utilice la herramienta de búsqueda de archivos dentro de la API de Responses.
- Consultar los datos: tu agente puede buscar información específica dentro de los archivos y devolver resultados relevantes.
Por ejemplo, podrías construir un agente de RR. HH. que busque registros de empleados para proporcionar detalles de nómina o saldos de vacaciones. Este nivel de automatización puede ahorrar horas de trabajo manual y mejorar la eficiencia en todos los departamentos.
Automatizar tareas con capacidades de uso de la computadora
El modelo Computer-Using Agent (CUA) de OpenAI, que impulsa el producto Operator, permite a los agentes generar acciones de ratón y teclado. Esto significa que tus agentes pueden automatizar tareas como la entrada de datos, los flujos de trabajo de aplicaciones y la navegación por sitios web.
Esta herramienta se encuentra actualmente en vista previa de investigación, pero ya está mostrando promesas para los desarrolladores. Puedes explorar sus capacidades en la documentación. La versión para consumidores de CUA, disponible en Operator, se centra en acciones basadas en la web, pero las empresas pueden ejecutarla localmente para aplicaciones más amplias.
Aquí te mostramos cómo empezar:
- Acceder a la vista previa: regístrate en la vista previa de investigación para probar el modelo CUA.
- Definir tareas: programa tu agente para que realice tareas informáticas específicas, como rellenar formularios o hacer clic en botones.
- Supervisar el rendimiento: utiliza las herramientas de OpenAI para depurar y optimizar las acciones de tu agente.
Imagina construir un agente que automatice tareas de oficina repetitivas, como actualizar hojas de cálculo o programar reuniones. Con las capacidades de uso de la computadora, tu agente puede manejar estas tareas de forma autónoma, liberando a los trabajadores humanos para tareas más creativas.
1. Enviar una solicitud al modelo
Primero, es posible que desees configurar la clave de OpenAI
import openai
import os
# Set API key
openai.api_key = os.environ.get("OPENAI_API_KEY")
Envía una solicitud para crear una Response con el modelo computer-use-preview equipado con la herramienta computer_use_preview. Esta solicitud debe incluir detalles sobre tu entorno, junto con un mensaje de entrada inicial.
Opcionalmente, puedes incluir una captura de pantalla del estado inicial del entorno.
Para poder utilizar la herramienta computer_use_preview, debes establecer el parámetro truncation en "auto" (de forma predeterminada, la truncación está desactivada).
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="computer-use-preview",
tools=[{
"type": "computer_use_preview",
"display_width": 1024,
"display_height": 768,
"environment": "browser" # other possible values: "mac", "windows", "ubuntu"
}],
input=[
{
"role": "user",
"content": "Check the latest OpenAI news on bing.com."
}
# Optional: include a screenshot of the initial state of the environment
# {
# type: "input_image",
# image_url: f"data:image/png;base64,{screenshot_base64}"
# }
],
truncation="auto"
)
print(response.output)2. Recibir una acción sugerida
El modelo devuelve una salida que contiene un elemento computer_call, solo texto u otras llamadas a herramientas, dependiendo del estado de la conversación.
Ejemplos de elementos computer_call son un clic, un desplazamiento, una pulsación de tecla o cualquier otro evento definido en la referencia de la API. En nuestro ejemplo, el elemento es una acción de clic:
"output": [
{
"type": "reasoning",
"id": "rs_67cc...",
"content": []
},
{
"type": "computer_call",
"id": "cu_67cc...",
"call_id": "call_zw3...",
"action": {
"type": "click",
"button": "left",
"x": 156,
"y": 50
},
"pending_safety_checks": [],
"status": "completed"
}
]El modelo puede devolver un elemento reasoning en la salida de la respuesta para algunas acciones. Si lo hace, siempre debes incluir los elementos de razonamiento al enviar la siguiente solicitud al modelo CUA.
Los elementos de razonamiento solo son compatibles con el mismo modelo que los produjo. Si implementas un flujo en el que utilizas varios modelos con el mismo historial de conversación, debes filtrar estos elementos de razonamiento de la matriz de entradas que envías a otros modelos.
3. Ejecutar la acción en tu entorno
Ejecuta las acciones correspondientes en tu computadora o navegador. La forma en que asignas una llamada de computadora a acciones a través del código depende de tu entorno. Este código muestra implementaciones de ejemplo para las acciones de computadora más comunes.
def handle_model_action(page, action):
"""
Given a computer action (e.g., click, double_click, scroll, etc.),
execute the corresponding operation on the Playwright page.
"""
action_type = action.type
try:
match action_type:
case "click":
x, y = action.x, action.y
button = action.button
print(f"Action: click at ({x}, {y}) with button '{button}'")
# Not handling things like middle click, etc.
if button != "left" and button != "right":
button = "left"
page.mouse.click(x, y, button=button)
case "scroll":
x, y = action.x, action.y
scroll_x, scroll_y = action.scroll_x, action.scroll_y
print(f"Action: scroll at ({x}, {y}) with offsets (scroll_x={scroll_x}, scroll_y={scroll_y})")
page.mouse.move(x, y)
page.evaluate(f"window.scrollBy({scroll_x}, {scroll_y})")
case "keypress":
keys = action.keys
for k in keys:
print(f"Action: keypress '{k}'")
# A simple mapping for common keys; expand as needed.
if k.lower() == "enter":
page.keyboard.press("Enter")
elif k.lower() == "space":
page.keyboard.press(" ")
else:
page.keyboard.press(k)
case "type":
text = action.text
print(f"Action: type text: {text}")
page.keyboard.type(text)
case "wait":
print(f"Action: wait")
time.sleep(2)
case "screenshot":
# Nothing to do as screenshot is taken at each turn
print(f"Action: screenshot")
# Handle other actions here
case _:
print(f"Unrecognized action: {action}")
except Exception as e:
print(f"Error handling action {action}: {e}")4. Capturar la captura de pantalla actualizada
Después de ejecutar la acción, captura el estado actualizado del entorno como una captura de pantalla, que también difiere según tu entorno.
def get_screenshot(page):
"""
Take a full-page screenshot using Playwright and return the image bytes.
"""
return page.screenshot()5. Repetir
Una vez que tengas la captura de pantalla, puedes enviarla de vuelta al modelo como un computer_call_output para obtener la siguiente acción. Repite estos pasos siempre que obtengas un elemento computer_call en la respuesta.
import time
import base64
from openai import OpenAI
client = OpenAI()
def computer_use_loop(instance, response):
"""
Run the loop that executes computer actions until no 'computer_call' is found.
"""
while True:
computer_calls = [item for item in response.output if item.type == "computer_call"]
if not computer_calls:
print("No computer call found. Output from model:")
for item in response.output:
print(item)
break # Exit when no computer calls are issued.
# We expect at most one computer call per response.
computer_call = computer_calls[0]
last_call_id = computer_call.call_id
action = computer_call.action
# Execute the action (function defined in step 3)
handle_model_action(instance, action)
time.sleep(1) # Allow time for changes to take effect.
# Take a screenshot after the action (function defined in step 4)
screenshot_bytes = get_screenshot(instance)
screenshot_base64 = base64.b64encode(screenshot_bytes).decode("utf-8")
# Send the screenshot back as a computer_call_output
response = client.responses.create(
model="computer-use-preview",
previous_response_id=response.id,
tools=[
{
"type": "computer_use_preview",
"display_width": 1024,
"display_height": 768,
"environment": "browser"
}
],
input=[
{
"call_id": last_call_id,
"type": "computer_call_output",
"output": {
"type": "input_image",
"image_url": f"data:image/png;base64,{screenshot_base64}"
}
}
],
truncation="auto"
)
return responseOrquestar agentes con el SDK de Agents
El kit de herramientas de código abierto de OpenAI para construir y gestionar flujos de trabajo multiagente. Este SDK se basa en el marco anterior de OpenAI, Swarm, y ofrece a los desarrolladores herramientas gratuitas para integrar modelos, implementar salvaguardias y supervisar las actividades de los agentes.
El SDK de Agents es Python-first e incluye características como bucles de agentes integrados y comprobaciones de seguridad. Es perfecto para crear sistemas complejos donde varios agentes trabajan juntos para resolver problemas.
Aquí te mostramos cómo utilizar el SDK de Agents:
- Descargar el SDK: accede al código de código abierto desde el repositorio de GitHub de OpenAI.
- Configurar flujos de trabajo multiagente: utiliza el SDK para orquestar tareas entre agentes, delegando en función de sus capacidades.
- Añadir salvaguardias: implementa comprobaciones de seguridad para garantizar que tus agentes operen de forma responsable y fiable.
Por ejemplo, podrías construir un equipo de ventas de agentes de IA donde un agente se encarga de la investigación web, otro gestiona los archivos y un tercero automatiza las tareas informáticas. El SDK de Agents los une, creando un sistema eficiente y sin fisuras.
Conclusión
Desde la API de Responses hasta la búsqueda web, la búsqueda de archivos, el uso de la computadora y el SDK de Agents, OpenAI ha equipado a los desarrolladores con todo lo necesario para crear sistemas autónomos e inteligentes. Ya sea que estés automatizando tareas empresariales, mejorando el servicio al cliente o explorando nuevas fronteras de investigación, estas herramientas abren un mundo de posibilidades.
Entonces, ¿a qué esperas? Sumérgete en la API de OpenAI, experimenta con sus nuevas herramientas y empieza a construir agentes que sorprendan a tus usuarios. Y no olvides descargar Apidog gratis para optimizar tu desarrollo de API y hacer que tu viaje sea aún más fluido.
