Asistente de voz multimodal
En esta página
Actualizado el 2 de noviembre de 2026 — Modelos de audio. Varios modelos de este curso están obsoletos:
tts-1,tts-1-hdygpt-4o-mini-ttsdejarán de funcionar el 6 de enero de 2027 (el sustituto indicado esgpt-realtime-2.1-mini, que la guía de TTS de OpenAI especifica que no es compatible con/v1/audio/speech: la migración de la síntesis de voz debe realizarse a través de la API en tiempo real);gpt-realtime,gpt-4o-realtimey los modelos de audio heredados el 20 de enero de 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribey/v1/audio/translationsel 26 de febrero de 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Para la voz a dúplex completo, GPT-Live 1 está disponible en la API desde el 10 de septiembre de 2026.
Corregido el 3 de noviembre de 2026. Para analizar una imagen, la lección realizaba anteriormente una llamada separada a la API de Responses e inyectaba la descripción como un mensaje de asistente con contenido
input_text, un tipo reservado para mensajes de usuario o del sistema. Sin embargo,gpt-realtime-2.1ygpt-realtime-2aceptan imágenes como entrada: la imagen se adjunta directamente, comoinput_image, a un mensaje de usuario. El eventoresponse.text.deltade la beta anterior se denomina ahoraresponse.output_text.delta. Formas de eventos verificadas frente a los tipos del SDKopenai3.42.1. Fuentes: Conversaciones en tiempo real, entradas de imagen · gpt-realtime-2.1.
Asistente de voz multimodal
Un asistente de voz multimodal combina la voz con otras modalidades: texto, imágenes, vídeo y datos estructurados. El usuario habla, pero el agente también puede mostrar información visual, analizar imágenes enviadas por el usuario o combinar múltiples fuentes de datos. Este es el futuro de la interacción persona-ordenador.
Texto y audio en paralelo
La API en tiempo real admite de forma nativa las modalidades de texto y audio simultáneamente. Puedes inyectar texto en la conversación mientras mantienes el intercambio de voz:
async def inject_text_context(ws, context: str):
"""Añade contexto de texto a la conversación de voz."""
await ws.send(json.dumps({
"type": "conversation.item.create",
"item": {
"type": "message",
"role": "user",
"content": [
{
"type": "input_text",
"text": context
}
]
}
}))
# Trigger a voice response based on this context
await ws.send(json.dumps({"type": "response.create"}))
# El usuario pregunta verbalmente "Léeme mi último correo electrónico"
# Inyectas el contenido del correo como texto
await inject_text_context(ws, """
Here is the latest email received:
From: [email protected]
Subject: Quote Request
Content: Hello, I would like to request a quote for
integrating a voice agent into our call center.
""")
Mostrar una imagen al agente de voz
gpt-realtime-2.1 y gpt-realtime-2 aceptan texto, audio e imágenes como entrada. Una imagen se adjunta como una parte input_image de un mensaje de usuario, utilizando un URI de datos Base64, tanto a través de WebSocket como del canal de datos WebRTC. El modelo tiene esto en cuenta en su respuesta de voz sin necesidad de llamar a otra API:
import base64
import json
async def montrer_image(ws, chemin_image: str, question: str) -> None:
"""Adjunta una imagen y una pregunta a la conversación, y luego solicita una respuesta de voz."""
with open(chemin_image, "rb") as f:
image_b64 = base64.b64encode(f.read()).decode()
await ws.send(json.dumps({
"type": "conversation.item.create",
"item": {
"type": "message",
"role": "user",
"content": [
{"type": "input_image", "image_url": f"data:image/jpeg;base64,{image_b64}"},
{"type": "input_text", "text": question},
],
},
}))
await ws.send(json.dumps({"type": "response.create"}))
await montrer_image(ws, "facture.jpg", "What do I need to pay, and by what date?")
Las imágenes se facturan como tokens de imagen, a una tarifa específica indicada en la ficha del modelo. Para análisis complejos o si necesitas un modelo de visión más capaz, puedes consultar la API de Responses por separado y pasar luego su resultado a la sesión: hazlo mediante un mensaje system o user (con contenido input_text), nunca mediante un mensaje falso de asistente, ya que el modelo lo interpretaría como palabras propias.
Interfaz web multimodal
Para una aplicación web, combina el WebSocket en tiempo real con una interfaz visual:
from fastapi import FastAPI, WebSocket
from fastapi.staticfiles import StaticFiles
app = FastAPI()
@app.websocket("/ws/agent")
async def multimodal_agent(client_ws: WebSocket):
"""Agente multimodal con interfaz web."""
await client_ws.accept()
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
async with websockets.connect(REALTIME_URL, additional_headers=headers) as openai_ws:
await openai_ws.recv() # session.created
await openai_ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"output_modalities": ["audio"],
"instructions": "Multimodal assistant. Respond in English.",
"audio": {"output": {"voice": "marin"}}
}
}))
await openai_ws.recv()
async def client_to_openai():
async for message in client_ws.iter_text():
data = json.loads(message)
if data["type"] == "audio":
# Relay audio
await openai_ws.send(json.dumps({
"type": "input_audio_buffer.append",
"audio": data["audio"]
}))
elif data["type"] == "text":
# Text message (chat)
await openai_ws.send(json.dumps({
"type": "conversation.item.create",
"item": {
"type": "message",
"role": "user",
"content": [{
"type": "input_text",
"text": data["text"]
}]
}
}))
await openai_ws.send(json.dumps({
"type": "response.create"
}))
async def openai_to_client():
async for message in openai_ws:
event = json.loads(message)
t = event["type"]
if t == "response.output_audio.delta":
await client_ws.send_json({
"type": "audio",
"delta": event["delta"]
})
elif t == "response.output_audio_transcript.delta":
await client_ws.send_json({
"type": "transcript",
"delta": event["delta"]
})
elif t == "response.output_text.delta":
await client_ws.send_json({
"type": "text",
"delta": event["delta"]
})
await asyncio.gather(client_to_openai(), openai_to_client())
Casos de uso multimodal
Así es como un agente multimodal gestiona diferentes escenarios en una herramienta de llamada a funciones:
tools = [
{
"type": "function",
"name": "show_chart",
"description": "Displays a data chart to the user",
"parameters": {
"type": "object",
"properties": {
"chart_type": {"type": "string", "enum": ["bar", "line", "pie"]},
"title": {"type": "string"},
"data": {"type": "object"}
},
"required": ["chart_type", "title", "data"]
}
},
{
"type": "function",
"name": "send_document",
"description": "Sends a document to the client by email",
"parameters": {
"type": "object",
"properties": {
"document_type": {"type": "string"},
"recipient": {"type": "string"}
},
"required": ["document_type", "recipient"]
}
}
]
El usuario dice verbalmente: “Muéstrame las ventas del último trimestre en un gráfico”. El agente llama a show_chart, tu frontend muestra el gráfico y el agente comenta verbalmente los resultados.
Puntos clave
- La API en tiempo real admite las modalidades de texto y audio simultáneamente en la misma sesión
- Inyectar texto mediante
conversation.item.createpermite enriquecer el contexto de voz - Los modelos en tiempo real aceptan imágenes: adjúntalas como
input_imagea un mensaje de usuario - Las herramientas (llamada a funciones) permiten mostrar elementos visuales mientras se responde verbalmente
- La arquitectura WebSocket del lado del cliente permite mezclar audio, texto y datos estructurados