Ir al contenido principal
Español— Elegir un idioma
Menú

Asistente de voz multimodal

Lección 16 de 18 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Asistente de voz multimodal
  2. Texto y audio en paralelo
  3. Mostrar una imagen al agente de voz
  4. Interfaz web multimodal
  5. Casos de uso multimodal
  6. Puntos clave

Actualizado el 2 de noviembre de 2026 — Modelos de audio. Varios modelos de este curso están obsoletos: tts-1, tts-1-hd y gpt-4o-mini-tts dejarán de funcionar el 6 de enero de 2027 (el sustituto indicado es gpt-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-realtime y 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-transcribe y /v1/audio/translations el 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.1 y gpt-realtime-2 aceptan imágenes como entrada: la imagen se adjunta directamente, como input_image, a un mensaje de usuario. El evento response.text.delta de la beta anterior se denomina ahora response.output_text.delta. Formas de eventos verificadas frente a los tipos del SDK openai 3.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.create permite enriquecer el contexto de voz
  • Los modelos en tiempo real aceptan imágenes: adjúntalas como input_image a 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