Schnellstart

Bevor Sie ein Projekt erstellen oder die OCI-Antworten-API aufrufen, stellen Sie sicher, dass die erforderlichen IAM-Berechtigungen vorhanden sind.

Die OCI Responses API unterstützt zwei Authentifizierungsmethoden. Sie können eine der beiden Optionen verwenden.

• OCI Generative AI-API-Schlüssel

  Authentifizieren und erreichen Sie die Modelle und Endpunkte mit OpenAI-kompatiblen service-spezifischen API-Schlüsseln der generativen KI. Verwenden Sie diese Option für Tests und frühe Entwicklung.

• OCI-IAM-basierte Authentifizierung

  Authentifizieren und erreichen Sie die Modelle und Endpunkte mit signierten API-Anforderungen. Wir empfehlen diese Option für Produktions-Workloads und OCI-verwaltete Umgebungen. Verwenden Sie die IAM-Authentifizierung, wenn Sie:

  • Anwendungen in OCI-Services wie Functions oder Oracle Kubernetes Engine (OKE) ausführen
  • Möchten Sie langlebige API-Schlüssel vermeiden?
  • Zentrale Zugriffskontrolle über OCI IAM erforderlich

Installieren Sie das offizielle OpenAI SDK.

Python

pip install openai

Weitere Sprachen finden Sie auf der Seite OpenAI-Bibliotheken.

Die OCI-Responses-API ist die primäre API zum Erstellen von Agent-Anwendungen für Unternehmens-KI in OCI Generative AI. Damit können Sie Modellanforderungen senden, Tools verwenden und den Konversationskontext über eine einzige API verwalten.

Mit der Antwort-API können Sie:

• Einfache Inferenz- oder mehrstufige Agent-Workflows ausführen
• Logik je nach Anwendungsfall aktivieren oder deaktivieren
• Plattformverwaltete oder clientseitige Tools integrieren
• Unterhaltungsstatus entweder im Service oder im Client verwalten

Die OCI Responses API verwendet eine OpenAI-kompatible Schnittstelle. Anforderungen verwenden dieselbe OpenAI-ähnliche Syntax, werden jedoch an OCI Generative AI gesendet und mit OCI-Zugangsdaten authentifiziert, wie OCI Generative AI-API-Schlüssel oder OCI IAM-basierte Authentifizierung.

Der empfohlene Client ist das OpenAI-SDK. Es unterstützt Sprachen wie Python, Java, TypeScript, Go und .NET. Sie können es auch mit Frameworks wie LangChain, LlamaIndex und OpenAI Agents SDK verwenden.

Verwenden Sie die folgende Basis-URL:

Basis-URL: https://inference.generativeai.${region}.oci.oraclecloud.com/openai/v1

Ersetzen Sie ${region} durch Ihre OCI-Region. Beispiel: us-chicago-1.

Verwenden Sie für die Responses-API den folgenden Endpunktpfad:

/responses

Mit der OCI-Antworten-API können Sie verschiedene Typen von Modellen aufrufen, die in von OCI Generative AI unterstützten Regionen verfügbar sind. Eine Liste der unterstützten Modelle und Regionen finden Sie unter Agent-Modelle und -Regionen.

response = client.responses.create(
    model="xai.grok-4-1-fast-reasoning",
    input="Write a one-sentence explanation of what a database is."
)

response = client.responses.create(
    model="google.gemini-2.5-pro",
    input="Write a one-sentence explanation of what a database is."
)

response = client.responses.create(
    model="<dedicated-ai-cluster-endpoint-ocid>",
    input="Write a one-sentence explanation of what a database is."
)

Wählen Sie ein Modell in einer verfügbaren Region mit dem verfügbaren Modus, der am besten zu Ihren Anforderungen an Performance, Kosten und Kontrolle passt.

Die folgenden Beispiele zeigen, wie Sie die Responses-API mit Python aufrufen. Wenn die Anforderung eine Erklärung zurückgibt, funktioniert die OCI Responses API ordnungsgemäß.

Wenn beim Aufruf der API Probleme auftreten, kann die Aktivierung des Debug-Loggings bei der Fehlerbehebung hilfreich sein. In Debuglogs werden die Raw-HTTP-Anforderungen und -Antworten angezeigt, einschließlich der opc-request-id, die bei der Arbeit mit Oracle-Support nützlich ist.

Sie können diese Anforderungs-ID referenzieren, wenn Sie Probleme melden, um Probleme schneller zu identifizieren und zu diagnostizieren.

from openai import OpenAI
import logging

logger = logging.getLogger("openai")
logger.setLevel(logging.DEBUG)
logger.addHandler(logging.StreamHandler())

# Create and use the OpenAI client as usual
client = OpenAI(
    ...
)

Die OCI Responses API unterstützt Streaming, bei dem Sie Modellausgaben inkrementell empfangen können, wenn die Token generiert werden.

response_stream = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Explain the difference between structured and unstructured data.",
    stream=True
)

for event in response_stream:
    print(event)

response_stream = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Explain the difference between structured and unstructured data.",
    stream=True
)

for event in response_stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

Mit Argumentationssteuerelementen können Sie einstellen, wie viel Aufwand das Modell verwendet, bevor Sie eine Antwort erstellen. Dies ist nützlich, wenn Sie Geschwindigkeit, Tiefe oder eine Balance von beidem priorisieren möchten.

response = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Solve 18 * (4 + 2).",
    reasoning={"effort": "medium"},
    store=False,
)

print(response.output_text)

response = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Solve 18 * (4 + 2).",
    reasoning={"summary": "auto"},
    store=False,
)

print(response.output_text)

Verwenden Sie strukturierte Ausgaben, wenn das Modell Daten in einem vorhersehbaren Format anstelle von Freiformtext zurückgeben soll. Dies ist nützlich, um Felder aus unstrukturierten Eingaben zu extrahieren, Ergebnisse an andere Systeme zu übergeben oder bestimmte Werte in einer Benutzeroberfläche anzuzeigen. In der OCI Responses API definieren Sie ein Schema und parsen die Antwort darauf, wodurch die Ausgabe konsistenter und einfacher für Anwendungen zu verwenden ist. Strukturierte Ausgaben stimmen mit einem angegebenen Schema überein, während ein JSON-Modus nur gültige JSON garantiert.

Ein stark eingegebenes Objekt ist ein Objekt, dessen Felder und Datentypen im Voraus definiert werden. Beispiel: Wenn ein Schema angibt, dass customer_name eine Zeichenfolge sein muss und priority einer der folgenden Werte sein muss: "low", "medium" oder "high", folgt das geparste Ergebnis dieser Struktur. Dies erleichtert es dem Code, sicher und vorhersehbar mit der Antwort zu arbeiten. Die OCI Responses API unterstützt dies, indem Sie ein Schema definieren und die Modellausgabe in stark typisierte Objekte parsen können.

Dieser Ansatz ist nützlich, wenn er in nachgelagerte Systeme integriert, Konsistenz durchgesetzt oder bestimmte Felder aus der Eingabe in natürlicher Sprache extrahiert werden.

from pydantic import BaseModel
from typing import Literal

class SupportRequest(BaseModel):
    customer_name: str
    product: str
    issue_summary: str
    priority: Literal["low", "medium", "high"]
    requested_action: str

response = client.responses.parse(
    model="<supported-model-id>",
    input=[
        {"role": "system", "content": "Extract the support request into the schema."},
        {
            "role": "user",
            "content": (
                "Sarah Johnson from Example Company says the mobile inventory app "
                "crashes whenever she scans more than 20 items in one session. "
                "This is delaying warehouse processing, and she wants a fix as soon as possible."
            ),
        },
    ],
    text_format=SupportRequest,
)

support_request = response.output_parsed
print(support_request)

Beispielausgabe:

SupportRequest(
customer_name='Sarah Johnson', 
product='mobile inventory app', 
issue_summary='App crashes whenever she scans more than 20 items in one session.', 
priority='high', 
requested_action='Provide a fix as soon as possible'
)

Die OCI Responses API unterstützt Modelle, die multimodale Eingaben akzeptieren. Sie können Text mit Bildern, Dateien und Argumentationssteuerelementen kombinieren, um umfangreichere Workflows wie Dokumentanalyse, Bildverständnis und bewusstere Modellantworten zu unterstützen.

import base64

def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

base64_image = encode_image("/path/to/image.png")

response = client.responses.create(
    model="google.gemini-2.5-pro",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Describe the main objects in this image."},
                {
                    "type": "input_image",
                    "image_url": f"data:image/jpeg;base64,{base64_image}",
                    "detail": "high",
                },
            ],
        }
    ],
)

print(response.output_text)

response = client.responses.create(
    model="google.gemini-2.5-pro",
    store=False,
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Describe the scene shown in this image."},
                {
                    "type": "input_image",
                    "image_url": "https://example.photos/id/123",
                },
            ],
        }
    ],
)

print(response.output_text)

file = client.files.create(
    file=open("<path-to-file>", "rb"),
    purpose="user_data"
)

response = client.responses.create(
    model="google.gemini-2.5-pro",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_file",
                    "file_id": file.id,
                },
                {
                    "type": "input_text",
                    "text": "Summarize this document.",
                },
            ]
        }
    ]
)

print(response.output_text)

response = client.responses.create(
    model="google.gemini-2.5-flash",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Summarize this file."},
                {
                    "type": "input_file",
                    "file_url": "https://www.example.com/letters/example-letter.pdf",
                },
            ],
        }
    ],
)

print(response.output_text)

Einige OCI Responses API-Tools verwenden OCI Generative AI-Container als temporäre, isolierte Workspaces. Container werden von Code Interpreter verwendet.

Ein Container kann hochgeladene Dateien, vom Modell erstellte Dateien, Logs, Berichte, Diagramme und temporäre Arbeitsdaten speichern. Dateien und generierte Artefakte bleiben verfügbar, während der Container aktiv ist. Wenn der Container abläuft oder gelöscht wird, ist der Workspace-Status nicht mehr verfügbar.

Mit der Containerdateien-API können Sie Dateien in einen Container hochladen, Dateien auflisten, generierte Dateien abrufen und Dateien löschen.

API-Referenz: OpenAI Container Files API-Dokumentation und Container Files API.

Es gibt zwei Möglichkeiten, Container zu verwenden:

Wenn Sie das File Search-Tool zur Responses-API hinzufügen, kann das Modell Inhalt aus Dateien abrufen, die während der Antwortgenerierung in einem Vektorspeicher gespeichert sind. Dies ist nützlich, wenn Antworten die von Ihnen bereitgestellten Dokumente widerspiegeln sollen, anstatt sich nur auf das integrierte Wissen des Modells zu verlassen.

Indem Sie Vektorspeicher erstellen und Dateien hinzufügen, aktivieren Sie die semantische und schlüsselwortbasierte Suche in Ihren Daten. Dies erweitert das integrierte Wissen des Modells um Ihre benutzerdefinierten Inhalte und hilft, präzisere, kontextbezogene Antworten zu erstellen.

Da die Dateisuche vom Service verarbeitet wird, muss Ihre Anwendung keine eigene Abrufpipeline implementieren.

response = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Summarize the main ideas covered in the documents in this vector store.",
    tools=[
        {
            "type": "file_search",
            "vector_store_ids": ["<vector_store_id>"]
        }
    ]
)

print(response)

Mit Code Interpreter kann das Modell Python-Code in einem isolierten, von OCI verwalteten Container schreiben und ausführen. Code Interpreter ist nützlich für Berechnungen, Datenanalyse, Dateiverarbeitung, Diagrammgenerierung und andere rechenintensive Aufgaben. Code Interpreter unterstützt die dynamische Dateiinteraktion während der Lebensdauer des Containers. Das Modell kann von Ihnen bereitgestellte Dateien lesen und auch neue Dateien erstellen.

Die Python-Umgebung umfasst mehr als 420 vorinstallierte Bibliotheken, darunter Pandas, Matplotlib und SciPy. Da Code Interpreter OCI Generative AI-Container verwendet, finden Sie unter Container für gehostete Tools gemeinsame Details zu Containermodi, Speichergrößen, Dateipersistenz, Ablauf und den Containerdateien-APIs.

Da Code in einer isolierten Umgebung ohne externen Netzwerkzugriff ausgeführt wird, ist Code Interpreter eine gute Option, wenn der Workflow eine Berechnung oder Dateiverarbeitung in einer kontrollierten Einstellung erfordert.

Um Codeinterpreter zu verwenden, fügen Sie in der Eigenschaft tools eine Tooldefinition mit "type": "code_interpreter" hinzu.

Python-Beispiel:

response = client.responses.create(
    model="xai.grok-4-1-fast-reasoning",
    tools=[
        {
            "type": "code_interpreter",
            "container": {"type": "auto"}
            "memory_limit": "1g"
        }
    ],
    instructions="Use the python tool to solve the problem and explain the result.",
    input="Find the value of (18 / 3) + 7 * 2."
)

print(response.output_text)

Um einen bestimmten Container wiederzuverwenden, erstellen Sie zuerst den Container, und übergeben Sie die Container-ID in der Anforderung.

Python-Beispiel:

container = client.containers.create(
    name="analysis-container",
    memory_limit="4g"
)

response = client.responses.create(
    model="xai.grok-code-fast-1",
    tools=[
        {
            "type": "code_interpreter",
            "container": container.id
        }
    ],
    input="Use the python tool to calculate the average of 12, 18, 24, and 30."
)

print(response.output_text)

Verwenden Sie den Funktionsaufruf, damit das Modell Daten oder Aktionen aus Ihrer Anwendung während eines API-Workflow für Antworten anfordert. Dies ist nützlich, wenn das Modell Informationen oder Vorgänge benötigt, die im Prompt selbst nicht verfügbar sind, wie z.B. Kalenderdaten, interner Anwendungsstatus oder das Ergebnis eines benutzerdefinierten Vorgangs.

Mit diesem Muster führt das Modell die Funktion nicht direkt aus. Stattdessen werden der Funktionsname und die Argumente zurückgegeben, die Anwendung führt die Funktion aus, und dann sendet die Anwendung die Funktionsausgabe zurück, damit das Modell fortfahren und die benutzerorientierte Antwort erzeugen kann.

tools = [
    {
        "type": "function",
        "name": "get_calendar_events",
        "description": "Return calendar events scheduled for a specific date.",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {
                    "type": "string",
                    "description": "Date to query, for example 2026-04-02"
                }
            },
            "required": ["date"],
        },
    },
]

import json

tools = [
    {
        "type": "function",
        "name": "get_calendar_events",
        "description": "Return calendar events scheduled for a specific date.",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {
                    "type": "string",
                    "description": "Date to query, for example 2026-04-02"
                }
            },
            "required": ["date"],
        },
    },
]

def get_calendar_events(date):
    # Replace this with actual calendar logic or an API call
    return [
        {"time": "09:00", "title": "Team standup"},
        {"time": "13:00", "title": "Design review"},
        {"time": "16:00", "title": "Project check-in"},
    ]

# Initial request
response = client.responses.create(
    model="openai.gpt-oss-120b",
    tools=tools,
    input="Show the calendar events for 2026-04-02.",
)

# Execute the requested function
tool_outputs = []
for item in response.output:
    if item.type == "function_call" and item.name == "get_calendar_events":
        args = json.loads(item.arguments)
        events = get_calendar_events(**args)
        tool_outputs.append({
            "type": "function_call_output",
            "call_id": item.call_id,
            "output": json.dumps({"events": events}),
        })

# Follow-up request
final = client.responses.create(
    model="openai.gpt-oss-120b",
    instructions="Summarize the schedule clearly for the user.",
    tools=tools,
    input=tool_outputs,
    previous_response_id=response.id,
)

print(final.output_text)

import json

tools = [
    {
        "type": "function",
        "name": "get_calendar_events",
        "description": "Return calendar events scheduled for a specific date.",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {
                    "type": "string",
                    "description": "Date to query, for example 2026-04-02"
                }
            },
            "required": ["date"],
        },
    },
]

def get_calendar_events(date):
    # Replace this with actual calendar logic or an API call
    return [
        {"time": "09:00", "title": "Team standup"},
        {"time": "13:00", "title": "Design review"},
        {"time": "16:00", "title": "Project check-in"},
    ]

conversation = [
    {"role": "user", "content": "Show the calendar events for 2026-04-02."}
]

response = client.responses.create(
    model="openai.gpt-oss-120b",
    tools=tools,
    input=conversation,
)

conversation += response.output

for item in response.output:
    if item.type == "function_call" and item.name == "get_calendar_events":
        args = json.loads(item.arguments)
        events = get_calendar_events(**args)
        conversation.append({
            "type": "function_call_output",
            "call_id": item.call_id,
            "output": json.dumps({"events": events}),
        })

final = client.responses.create(
    model="openai.gpt-oss-120b",
    instructions="Summarize the schedule clearly for the user.",
    tools=tools,
    input=conversation,
)

print(final.output_text)

"tool_choice": {
    "type": "allowed_tools",
    "mode": "auto",
    "tools": [
        { "type": "function", "name": "get_calendar_events" },
        { "type": "function", "name": "purchase_tickets" }
    ]
  }
}

MCP-(Model Context Protocol-)Tools sind ausführbare Funktionen oder Funktionen, mit denen KI-Modelle mit externen Systemen interagieren können. Verwenden Sie MCP-Aufrufe in OCI Generative AI, damit ein Modell auf ausführbare Tools zugreifen kann, die von einem Remote-MCP-Server während einer Responses-API-Anforderung bereitgestellt werden. Diese Tools können Zugriff auf externe Systeme wie API, Datenbanken, Dateisysteme oder Anwendungsendpunkte ermöglichen. OCI Generative AI kommuniziert im Rahmen des Anforderungsworkflows direkt mit Remote-MCP-Servern.

Verwenden Sie SQL Search (NL2SQL), um Anforderungen in natürlicher Sprache in validiertes SQL für Unternehmensdaten in OCI Generative AI zu konvertieren.

NL2SQL unterstützt Enterprise AI Agents bei der Arbeit mit föderierten Unternehmensdaten, ohne die zugrunde liegenden Daten zu verschieben oder zu duplizieren. Es verwendet eine semantische Anreicherungsebene, um Geschäftsbegriffe Datenbanktabellen, Spalten und Joins zuzuordnen, und generiert dann SQL aus der Eingabe in natürlicher Sprache.

Bevor Sie NL2SQL verwenden können, benötigen Sie:

• Eine Quelldatenbank, wie Oracle Autonomous Database
• Zwei DBTools-Verbindungen:
  • Anreicherungsverbindung
  • Abfrageverbindung
• IAM-Berechtigungen für semantische Speicher, NL2SQL, Datenbanktools und Secrets
• OCI-IAM-Authentifizierung für die OCI-Service-APIs konfiguriert, die in diesem Schnellstart verwendet werden

Bevor Sie einen semantischen Speicher erstellen, erstellen Sie die Quelldatenbank und die erforderlichen DBTools-Verbindungen.

Sie benötigen die folgenden Verbindungen:

Bevor Sie einen semantischen Speicher erstellen, richten Sie die erforderlichen IAM-Policys ein.

Dieser QuickStart verwendet die OCI IAM-Authentifizierung für die OCI-Service-API, mit der semantische Speicher erstellt, Anreicherungsjobs ausgeführt und SQL generiert werden.

Richten Sie die OCI-IAM-Authentifizierung für die Identität ein, die Anforderungen signiert. Die Beispiele in diesem Abschnitt verwenden das OCI-Python-SDK und BaseClient.

Sie können die Authentifizierung folgendermaßen durchführen:

• OCI-Konfigurationsdatei und API-Signaturschlüssel
• Ein Sicherheitstoken-Unterzeichner

In den folgenden Beispielen wird SecurityTokenSigner verwendet. Sie können jedoch auch einen Standard-OCI-Konfigurationsunterzeichner verwenden, wenn dieser besser zu Ihrer Umgebung passt.

Verwandte Themen

• SDK- und CLI-Konfigurationsdatei
• Anforderungssignaturen
• Python-SDK des Unterzeichners

Wenn Sie unter Automatisierung anstelle von Beim Erstellen die Option Keine ausgewählt haben, können Sie die Anreicherung ausführen, nachdem der semantische Speicher erstellt wurde. Führen Sie diesen Schritt aus, wenn Sie die Option Beim Erstellen übersprungen haben.

Der Anreicherungsprozess liest Schemametadaten, wie Tabellen und Spalten, aus der angemeldeten Datenbank. OCI Generative AI verwendet diese Metadaten, um die SQL zu generieren.

Um die Anreicherung manuell auszulösen, rufen Sie die API GenerateEnrichmentJob auf.

Sie können Anreicherungsjobs auch mit der folgenden API verwalten:

• ListEnrichmentJobs
• GetEnrichmentJob
• CancelEnrichmentJob

NL2SQL verwendet OCI-Service-APIs anstelle der OCI OpenAI-kompatiblen /openai/v1-Pfade.

Nachdem der semantische Speicher bereit ist und die Anreicherung abgeschlossen ist, rufen Sie die NL2SQL-API auf, um SQL aus natürlicher Sprache zu generieren.

import json
import oci
from oci.base_client import BaseClient

INFERENCE_BASE_URL = "https://inference.generativeai.<region>.oci.oraclecloud.com"
API_VERSION = "20260325"
SEMANTIC_STORE_ID = "ocid1.generativeaisemanticstore.oc1.xxx"

config = oci.config.from_file("~/.oci/config", "oc1")
signer = oci.auth.signers.SecurityTokenSigner(config)

client = BaseClient(
    service_endpoint=INFERENCE_BASE_URL,
    signer=signer,
    retry_strategy=None,
)

resource_path = (
    f"/{API_VERSION}/semanticStores/{SEMANTIC_STORE_ID}/actions/generateSqlFromNl"
)

body = {
    "displayName": "Generate SQL example",
    "description": "Generate SQL from natural language",
    "inputNaturalLanguageQuery": "Give me last week's order details."
}

resp = client.call_api(
    resource_path=resource_path,
    method="POST",
    header_params={"content-type": "application/json"},
    body=body,
)

print("HTTP status:", resp.status)
print("opc-request-id:", resp.headers.get("opc-request-id"))

data = resp.data
if isinstance(data, (bytes, str)):
    data = json.loads(data)

print(json.dumps(data, indent=2))

Verwenden Sie die integrierten Antworttracedaten in der OCI-Antwort-API, um zu verstehen, wie eine Anforderung verarbeitet wurde. Um eine bessere Beobachtbarkeit zu gewährleisten, können Sie die OCI Responses API auch in externe Beobachtbarkeitsplattformen wie Langfuse integrieren.

Dieser QuickStart zeigt, wie Sie die von der Responses-API zurückgegebenen Ausführungsdetails prüfen und wie Sie Anforderungen mit Langfuse verfolgen.

Bevor Sie beginnen, müssen Sie folgende Schritte ausführen:

• Ein OCI Generative AI-Projekt
• Für die OCI-Antwort-API konfigurierte Authentifizierung
• Das OpenAI SDK installiert
• Ein funktionierender OCI Responses API-Client

(Optional) Für die Integration mit Langfuse benötigen Sie ein Langfuse-Konto und Zugangsdaten.

Wenn Sie die OCI-Antworten-API aufrufen, enthält die Antwort ein Feld output. Dieses Feld enthält eine Reihe von Elementen, die beschreiben, was während der Anforderung geschehen ist.

Jedes Element stellt einen Schritt in der Ausführung dar und kann verschiedene Typen enthalten, wie:

• message
• file_search_call
• mcp_call

Diese Ausgabeelemente bieten einen Einblick in die Verarbeitung der Anforderung. Sie können sie verwenden, um:

• Modellverhalten debuggen und verstehen
• Ausführungsschritte in einer Benutzeroberfläche anzeigen
• Benutzerdefinierte Beobachtbarkeits- oder Loggingworkflows erstellen

Beispiel: Nachdem Sie eine Anforderung gesendet haben, können Sie das Feld output prüfen:

response = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Explain the difference between structured and unstructured data."
)

for item in response.output:
    print(item.type)

Um tiefere Einblicke zu erhalten, wie Latenz-, Kosten- und Ausführungstraces, können Sie die OCI Responses API in eine Beobachtungsplattform integrieren.

Eine Option ist Langfuse, eine Open-Source-LLM-Engineering-Plattform, mit der Entwickler LLM-Anwendungen debuggen, überwachen und verbessern können. Langfuse bietet End-to-End-Beobachtbarkeit für das Tracing von Agent-Aktionen, unterstützt die Prompt-Versionierung und hilft bei der Auswertung von Modellausgaben. Es lässt sich in gängige Frameworks wie OpenAI, LangChain und LlamaIndex integrieren.

Installieren Sie das Langfuse SDK:

pip install langfuse

Legen Sie die erforderlichen Langfuse- und OCI-Umgebungsvariablen fest:

LANGFUSE_SECRET_KEY="sk-lf-xxxxxxxxx"
LANGFUSE_PUBLIC_KEY="pk-lf-xxxxxxxxx"
LANGFUSE_BASE_URL="https://us.cloud.langfuse.com"

# OCI Generative AI credentials
OCI_GENAI_API_KEY="sk-xxxxxxxxx"
OCI_GENAI_PROJECT_ID="ocid1.generativeaiproject.oc1.xxx"

Importieren Sie den OpenAI-Client aus dem Langfuse-SDK. Der vorhandene Anforderungscode bleibt unverändert, Anforderungen werden jedoch automatisch verfolgt.

import os
from langfuse.openai import OpenAI  # Import from Langfuse

client = OpenAI(
    base_url="https://inference.generativeai.<region>.oci.oraclecloud.com/openai/v1",
    api_key=os.getenv("OCI_GENAI_API_KEY"),
    project=os.getenv("OCI_GENAI_PROJECT_ID"),
)

Nachdem Sie den Client instrumentiert haben, senden Sie wie gewohnt eine Responses API-Anforderung. Langfuse verfolgt die Anforderung automatisch.

Beispiel:

response = client.responses.create(
    model="openai.gpt-oss-120b",
    tools=[
        {
            "type": "mcp",
            "server_label": "dmcp",
            "server_url": "https://mcp.example.com/mcp",
            "require_approval": "never",
        },
    ],
    input="Explain why tracing and observability are important in distributed systems."
)

print(response.output_text)