Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Automatische Zitationen und bewährte Verfahren

Lektion 16 von 16 Aktualisiert am 30. Juli 2026 Entwickler
Auf dieser Seite
  1. Quellenbasierte und zuverlässige Antworten
  2. Funktionsweise von Zitationen
  3. Anzeigen von Zitationen in Ihrer Anwendung
  4. Bewährte Verfahren für die Produktion
  5. Bereitstellungs-Checkliste
  6. Kernaussagen
  7. Wissen überprüfen

Quellenbasierte und zuverlässige Antworten

Wenn das Modell die Websuche oder die X-Suche verwendet, enthält die Responses API automatisch Zitationen in der Antwort. Diese Zitationen ermöglichen es Ihren Nutzern, Quellen zu überprüfen und das Vertrauen in generierte Antworten zu stärken.

Funktionsweise von Zitationen

Zitationen erscheinen im Array annotations jedes Inhalts Elements:

{
  "output": [{
    "type": "message",
    "content": [{
      "type": "output_text",
      "text": "According to the latest data, the AI market...",
      "annotations": [
        {
          "type": "url_citation",
          "url": "https://example.com/article",
          "title": "AI Market Analysis in 2026",
          "start_index": 35,
          "end_index": 68
        }
      ]
    }]
  }]
}

Felder der Zitation

FeldBeschreibung
typeImmer url_citation
urlQuell-URL
titleTitel der Quellseite
start_indexStartposition im Text
end_indexEndposition im Text

Anzeigen von Zitationen in Ihrer Anwendung

response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="What are the latest advancements in AI?",
    tools=[{"type": "web_search"}]
)

text = response.output[0].content[0].text
annotations = response.output[0].content[0].annotations

# Text mit Fußnoten erstellen
footnotes = []
for i, ann in enumerate(annotations, 1):
    footnotes.append(f"[{i}] {ann.title} — {ann.url}")

print(text)
print("\n--- Quellen ---")
for fn in footnotes:
    print(fn)

In HTML

def render_with_citations(text, annotations):
    # Nach Position sortieren (von Ende nach Start, um Indizes nicht zu verschieben)
    sorted_anns = sorted(annotations, key=lambda a: a.start_index, reverse=True)
    html = text
    for i, ann in enumerate(sorted_anns):
        ref_num = len(sorted_anns) - i
        link = f'<a href="{ann.url}" title="{ann.title}" target="_blank">[{ref_num}]</a>'
        html = html[:ann.end_index] + link + html[ann.end_index:]
    return html

Bewährte Verfahren für die Produktion

1. Status immer validieren

response = client.responses.create(...)
if response.status != "completed":
    handle_error(response)
    return

2. Leere Antworten behandeln

if not response.output or not response.output[0].content:
    return "Das Modell hat keine Antwort generiert."
text = response.output[0].content[0].text

3. Metriken protokollieren

Protokollieren Sie für jede Produktionsanfrage:

  • response.id zur Rückverfolgbarkeit
  • usage.total_tokens für den Verbrauch
  • usage.cost_in_nano_usd für Kosten
  • Clientseitige Antwortzeit
  • Antwortstatus

4. Ihren API-Schlüssel sichern

  • Speichern Sie ihn in einer Umgebungsvariablen, niemals im Code
  • Verwenden Sie in der Produktion einen Secrets Manager (Vault, AWS Secrets Manager)
  • Rotieren Sie Ihre Schlüssel regelmäßig
  • Stellen Sie sicher, dass sie niemals clientseitig (Browser) exponiert werden

5. Generierten Inhalt verwalten

Modellantworten können trotz Filtern unangemessene Inhalte enthalten. Implementieren Sie eine Moderationsschicht, wenn Sie Antworten öffentlich anzeigen.

6. Skalierbarkeit planen

  • Verwenden Sie Streaming, um die wahrgenommene Wartezeit zu reduzieren
  • Implementieren Sie ein Warteschlangensystem für schwere Anfragen
  • Cachen Sie häufige Antworten
  • Überwachen Sie Ihre Rate-Limiting-Quoten

Bereitstellungs-Checkliste

  • Timeout auf 3600 Sekunden eingestellt
  • Wiederholung mit exponentiellem Backoff
  • Clientseitiges Rate-Limiting
  • Protokollierung von Metriken (Tokens, Kosten, Latenz)
  • Fehlerbehandlung (401, 429, 500, Timeout)
  • Sicherer API-Schlüssel
  • Inhaltliche Moderation falls erforderlich
  • Kostenüberwachung und Alarme
  • Circuit Breaker für Resilienz

Kernaussagen

  • Zitationen sind automatisch vorhanden, wenn das Modell web_search oder x_search verwendet
  • Sie enthalten die URL, den Titel und die Position im Text
  • Validieren Sie den Status immer und behandeln Sie leere Antworten
  • Sichern Sie Ihren API-Schlüssel – niemals im Quellcode oder clientseitig
  • Implementieren Sie Protokollierung, Wiederholung, Rate-Limiting und Überwachung, bevor Sie in die Produktion gehen

Wissen überprüfen

Die Responses API im Detail: die abschließende Prüfung.

1. Was bietet die Responses API im Vergleich zu Chat Completions?

Antwort: Das moderne Format: serverseitige Antwortpersistenz (GET/DELETE, Verkettung über ID), integrierte Tools und neue Funktionen – die API, auf die sich xAI bei der Weiterentwicklung konzentriert.

2. Wie verkettet man einen Gesprächsverlauf?

Antwort: Durch Verweis auf die vorherige Antwort: Der Kontext wird serverseitig gespeichert – es muss nicht der gesamte Verlauf bei jedem Durchgang erneut gesendet werden.

3. Was ist verschlüsselte Reasoning?

Antwort: Das interne Reasoning des Modells, das in verschlüsselter Form zurückgegeben wird: Es ist in folgenden Durchläufen wiederverwendbar, ohne lesbar zu sein – der Denkprozess reist mit, die Vertraulichkeit bleibt gewahrt.

4. Was ermöglicht das Mischen von Server- und Client-Tools?

Antwort: Die Kombination von integrierten Tools, die von xAI ausgeführt werden (Websuche usw.), und benutzerdefinierten Funktionen, die von Ihrem Code ausgeführt werden – jedes Tool an der richtigen Stelle, orchestriert in derselben Anfrage.

5. Was sind die bewährten Verfahren für die Produktion?

Antwort: Timeout und Wiederholung behandeln, Abrechnung verfolgen (Tokens, Tools) und automatische Zitationen für überprüfbare Antworten nutzen – Robustheit und Vertrauen gemeinsam.

Persistenz, Tools, verschlüsseltes Reasoning, Zitationen: Die Responses API ist das moderne Fundament – Ihre Grok-Anwendungen werden hier aufgebaut.