Multimodaler Sprachassistent
Auf dieser Seite
Aktualisiert am 2. November 2026 — Audio-Modelle. Mehrere Modelle in diesem Kurs sind veraltet:
tts-1,tts-1-hdundgpt-4o-mini-ttswerden am 6. Januar 2027 nicht mehr funktionieren (die angegebene Alternative istgpt-realtime-2.1-mini, die laut OpenAI TTS-Anleitung nicht über/v1/audio/speechunterstützt wird: die Migration der Sprachsynthese muss über die Realtime-API erfolgen);gpt-realtime,gpt-4o-realtimeund veraltete Audio-Modelle am 20. Januar 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeund/v1/audio/translationsam 26. Februar 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Für die Voll-Duplex-Stimme ist GPT-Live 1 seit dem 10. September 2026 in der API verfügbar.
Korrigiert am 3. November 2026. Um ein Bild zu analysieren, hat die Lektion zuvor einen separaten Aufruf an die Responses-API durchgeführt und die Beschreibung dann als Assistant-Nachricht mit
input_text-Inhalt injiziert, ein Typ, der nur für Benutzer- oder Systemnachrichten reserviert ist.gpt-realtime-2.1undgpt-realtime-2akzeptieren Bilder jedoch als Eingabe: Das Bild wird direkt alsinput_imagean eine Benutzer-Nachricht angehängt. Das Ereignisresponse.text.deltaaus dem alten Beta-Status heißt nunresponse.output_text.delta. Die Ereignisformen wurden gegenopenaiSDK-Typen 3.42.1 verifiziert. Quellen: Realtime-Gespräche, Bild-Eingaben · gpt-realtime-2.1.
Multimodaler Sprachassistent
Ein multimodaler Sprachassistent kombiniert Sprache mit anderen Modalitäten: Text, Bilder, Video und strukturierte Daten. Der Nutzer spricht, aber der Agent kann auch visuelle Informationen anzeigen, vom Nutzer gesendete Bilder analysieren oder mehrere Datenquellen kombinieren. Dies ist die Zukunft der Mensch-Maschine-Interaktion.
Text und Audio parallel
Die Realtime-API unterstützt Text- und Audio-Modalitäten nativ gleichzeitig. Sie können Text in das Gespräch injizieren, während der Sprachtausch aufrechterhalten wird:
async def inject_text_context(ws, context: str):
"""Fügt Text-Kontext zum Sprachgespräch hinzu."""
await ws.send(json.dumps({
"type": "conversation.item.create",
"item": {
"type": "message",
"role": "user",
"content": [
{
"type": "input_text",
"text": context
}
]
}
}))
# Löst eine Sprachantwort basierend auf diesem Kontext aus
await ws.send(json.dumps({"type": "response.create"}))
# Der Nutzer fragt mündlich: "Lies mir meine neueste E-Mail vor"
# Sie injizieren den E-Mail-Inhalt als Text
await inject_text_context(ws, """
Hier ist die neueste empfangene E-Mail:
Von: [email protected]
Betreff: Angebotsanfrage
Inhalt: Hallo, ich möchte ein Angebot für die
Integration eines Sprachagenten in unseren Callcenter anfragen.
""")Ein Bild dem Sprachassistenten zeigen
gpt-realtime-2.1 und gpt-realtime-2 akzeptieren Text, Audio und Bilder als Eingabe. Ein Bild wird als input_image-Teil einer Benutzer-Nachricht angehängt, unter Verwendung einer Base64-Daten-URI, sowohl über WebSocket als auch über den WebRTC-Datenkanal. Das Modell berücksichtigt dies in seiner Sprachantwort, ohne eine weitere API aufzurufen:
import base64
import json
async def montrer_image(ws, chemin_image: str, question: str) -> None:
"""Hängt ein Bild und eine Frage an das Gespräch an und fordert eine Sprachantwort an."""
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", "Was muss ich bezahlen und bis wann?")Bilder werden als Bild-Token abgerechnet, zu einem spezifischen Satz, der auf der Modellkarte aufgeführt ist. Für eine umfangreiche Analyse oder ein leistungsfähigeres Vision-Modell können Sie weiterhin die Responses-API separat abfragen und das Ergebnis der Sitzung übergeben: tun Sie dies über eine system- oder user-Nachricht (mit input_text-Inhalt), niemals über eine gefälschte Assistant-Nachricht, die das Modell als seine eigenen Worte interpretieren würde.
Multimodale Web-Oberfläche
Für eine Webanwendung kombinieren Sie den Realtime WebSocket mit einer visuellen Oberfläche:
from fastapi import FastAPI, WebSocket
from fastapi.staticfiles import StaticFiles
app = FastAPI()
@app.websocket("/ws/agent")
async def multimodal_agent(client_ws: WebSocket):
"""Multimodaler Agent mit Web-Oberfläche."""
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": "Multimodaler Assistent. Antworten Sie auf Englisch.",
"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":
# Weiterleiten von Audio
await openai_ws.send(json.dumps({
"type": "input_audio_buffer.append",
"audio": data["audio"]
}))
elif data["type"] == "text":
# Textnachricht (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())Multimodale Anwendungsfälle
Hier ist, wie ein multimodaler Agent verschiedene Szenarien in einem Funktion-Aufruf-Tool behandelt:
tools = [
{
"type": "function",
"name": "show_chart",
"description": "Zeigt dem Nutzer ein Daten-Diagramm an",
"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": "Sendet ein Dokument per E-Mail an den Client",
"parameters": {
"type": "object",
"properties": {
"document_type": {"type": "string"},
"recipient": {"type": "string"}
},
"required": ["document_type", "recipient"]
}
}
]Der Nutzer sagt mündlich: “Zeigen Sie mir den Umsatz des letzten Quartals als Diagramm.” Der Agent ruft show_chart auf, Ihre Frontend-Anwendung zeigt das Diagramm an, und der Agent kommentiert die Ergebnisse mündlich.
Kernaussagen
- Die Realtime-API unterstützt Text- und Audio-Modalitäten gleichzeitig in derselben Sitzung
- Das Injizieren von Text über
conversation.item.createermöglicht es Ihnen, den Sprachkontext zu bereichern - Realtime-Modelle akzeptieren Bilder: Hängen Sie sie als
input_imagean eine Benutzer-Nachricht an - Tools (Funktion-Aufrufe) ermöglichen es Ihnen, visuelle Elemente anzuzeigen, während Sie mündlich antworten
- Die Client-seitige WebSocket-Architektur ermöglicht es Ihnen, Audio, Text und strukturierte Daten zu mischen