Grok Delphi API Client

15. April 2026 · Komponenten

Grok, entwickelt von xAI, ist ein leistungsstarkes KI-Modell, das auf schnelle, intelligente Antworten mit Echtzeitwissen und fortgeschrittenen Reasoning-Fähigkeiten ausgelegt ist. Für Delphi-Entwickler, die Grok in ihre Anwendungen integrieren möchten, stellt sgcWebSockets TsgcHTTP_API_Grok bereit — eine native Komponente, die die gesamte xAI-Grok-API mit sauberem, typsicherem Delphi-Code kapselt.

Egal ob du Konversationsassistenten baust, Bilder analysierst, toolgestützte Workflows orchestrierst oder Antworten in Echtzeit streamst — diese Komponente gibt dir direkten Zugriff auf jede Grok-Funktion. Kein REST-Boilerplate. Kein JSON-Gefrickel. Komponente einbinden, API-Schlüssel setzen und loslegen.

Vollständige API-Abdeckung

Jede wichtige Funktion der xAI-Grok-API wird sofort unterstützt.

Chat Completions Sende Nachrichten mit System-Prompts und empfange Antworten synchron oder gestreamt. Volle Kontrolle über Temperature, Top-p, Frequency- und Presence-Penalties.	Echtzeit-Streaming Streame Antworten Token für Token über Server-Sent Events. Baue reaktionsfähige UIs, die Antworten anzeigen, während sie generiert werden.	Vision Analysiere Bilder, indem du base64-kodierte Daten oder Bild-URLs zusammen mit Text-Prompts sendest. Grok beschreibt, interpretiert und schließt aus visuellen Inhalten.
Tool Use — Function Calling Definiere eigene Tools mit JSON Schema. Grok entscheidet, wann sie aufgerufen werden, und ermöglicht so agentische, mehrstufige Workflows.	Modellverwaltung Liste alle verfügbaren Grok-Modelle programmatisch auf. Frage Modell-IDs und Fähigkeiten ab, um die beste Wahl zu treffen.	Eingebauter Retry & Logging Automatischer Retry bei vorübergehenden Fehlern mit konfigurierbaren Versuchen und Wartezeiten. Vollständiges Request/Response-Logging zum Debuggen.

Erste Schritte

Integriere xAI Grok in unter einer Minute in dein Delphi-Projekt. Komponente einbinden, API-Schlüssel konfigurieren und die erste Nachricht senden.

// Create the component and configure the API key
var
  Grok: TsgcHTTP_API_Grok;
  vResponse: string;
begin
  Grok := TsgcHTTP_API_Grok.Create(nil);
  Try
    Grok.GrokOptions.ApiKey := 'YOUR_API_KEY';
    // Send a simple message to Grok
    vResponse := Grok._CreateMessage(
      'grok-3', 'Hello, Grok!');
    ShowMessage(vResponse);
  Finally
    Grok.Free;
  End;
end;

Zwei API-Stile. Jede Funktion bietet sowohl Convenience-Methoden (string-basiert, minimaler Code) als auch typisierte Request/Response-Klassen (volle Kontrolle, Typsicherheit). Wähle den Ansatz, der am besten zu deinem Anwendungsfall passt.

Chat Completions & Streaming

Die Chat-Completions-API ist die Grundlage jeder Grok-Interaktion. Sende Text mit optionalen System-Prompts und empfange Antworten synchron oder in Echtzeit gestreamt.

System-Prompts

Steuere Groks Verhalten, indem du einen System-Prompt setzt, der Kontext, Persönlichkeit oder Vorgaben für die Konversation festlegt.

vResponse := Grok._CreateMessageWithSystem(
  'grok-3',
  'You are a helpful assistant that responds in Spanish.',
  'What is the capital of France?');
// Returns: "La capital de Francia es París."

Echtzeit-Streaming

Für reaktionsfähige Oberflächen kannst du Groks Antwort Token für Token über Server-Sent Events streamen. Weise den Event-Handler OnHTTPAPISSE zu und rufe _CreateMessageStream auf.

// Enable streaming via SSE
Grok.OnHTTPAPISSE := OnSSEEvent;
Grok._CreateMessageStream('grok-3',
  'Explain the theory of relativity.');
procedure TForm1.OnSSEEvent(Sender: TObject;
  const aEvent, aData: string; var Cancel: Boolean);
begin
  // aData: JSON payload with generated content
  Memo1.Lines.Add(aData);
end;

Erweiterte typisierte API

Für volle Kontrolle über die Request-Parameter — Temperature, Top-p, Frequency Penalty, Presence Penalty, Stop-Sequenzen, Anzahl der Completions — nutze die typisierten Request- und Response-Klassen.

var
  oRequest: TsgcGrokClass_Request_ChatCompletion;
  oMessage: TsgcGrokClass_Request_Message;
  oResponse: TsgcGrokClass_Response_ChatCompletion;
begin
  oRequest := TsgcGrokClass_Request_ChatCompletion.Create;
  Try
    oRequest.Model := 'grok-3';
    oRequest.MaxTokens := 2048;
    oRequest.Temperature := 0.7;
    oRequest.TopP := 0.9;
    oRequest.FrequencyPenalty := 0.5;
    oRequest.N := 1;
    oMessage := TsgcGrokClass_Request_Message.Create;
    oMessage.Role := 'user';
    oMessage.Content := 'Explain quantum computing in simple terms.';
    oRequest.Messages.Add(oMessage);
    oResponse := Grok.CreateMessage(oRequest);
    Try
      if Length(oResponse.Choices) > 0 then
        ShowMessage(oResponse.Choices[0].Message.Content);
    Finally
      oResponse.Free;
    End;
  Finally
    oRequest.Free;
  End;
end;

Vision — Bildverständnis

Grok kann Bilder analysieren und über sie reflektieren. Sende Fotos, Screenshots, Diagramme oder Charts zusammen mit einem Text-Prompt und erhalte detaillierte Beschreibungen, Datenextraktionen oder visuelle Q&A.

// Load an image and ask Grok to analyze it
var
  vBase64: string;
begin
  vBase64 := sgcBase64Encode(LoadFileToBytes('dashboard-screenshot.png'));
  ShowMessage(Grok._CreateVisionMessage(
    'grok-3',
    'Analyze this dashboard and summarize the key metrics.',
    vBase64, 'image/png'));
end;

Anwendungsfall. Automatisiere die Auswertung von Berichten, extrahiere Daten aus Screenshots, erzeuge Beschreibungen visueller Inhalte oder baue bildbewusste Assistenten — alles aus nativem Delphi-Code.

Tool Use — Function Calling

Definiere eigene Tools mit JSON Schema, und Grok entscheidet, wann und wie es sie aufruft. Das ist die Grundlage für agentische, mehrstufige Workflows, die die KI mit deiner Geschäftslogik verbinden.

var
  oRequest: TsgcGrokClass_Request_ChatCompletion;
  oTool: TsgcGrokClass_Request_Tool;
  oResponse: TsgcGrokClass_Response_ChatCompletion;
begin
  // Define a tool with JSON Schema
  oTool := TsgcGrokClass_Request_Tool.Create;
  oTool.Name := 'search_database';
  oTool.Description := 'Search the product database by keyword';
  oTool.Parameters :=
    '{"type":"object","properties":{"query":{"type":"string",' +
    '"description":"Search keyword"}},"required":["query"]}';
  oRequest.Tools.Add(oTool);
  oRequest.ToolChoice := 'auto';
  oResponse := Grok.CreateMessage(oRequest);
  // Check if Grok wants to call a tool
  if oResponse.Choices[0].FinishReason = 'tool_calls' then
  begin
    for i := 0 to Length(oResponse.Choices[0].Message.ToolCalls) - 1 do
    begin
      vToolId   := oResponse.Choices[0].Message.ToolCalls[i].Id;
      vFuncName := oResponse.Choices[0].Message.ToolCalls[i].FunctionCall.Name;
      vFuncArgs := oResponse.Choices[0].Message.ToolCalls[i].FunctionCall.Arguments;
      // Execute the tool and return the result
    end;
  end;

Modellverwaltung

Frage verfügbare Grok-Modelle programmatisch ab. Liste alle Modelle, um neue Fähigkeiten zu entdecken, sobald sie verfügbar sind.

// List all available Grok models
vModels := Grok._GetModels;
// Typed API: access model properties directly
var
  oModels: TsgcGrokClass_Response_Models;
  i: Integer;
begin
  oModels := Grok.GetModels;
  Try
    for i := 0 to Length(oModels.Data) - 1 do
      Memo1.Lines.Add(oModels.Data[i].Id);
  Finally
    oModels.Free;
  End;
end;

Konfiguration & Optionen

Feinjustiere das Verhalten der Komponente mit umfassenden Konfigurationsoptionen.

Eigenschaft	Beschreibung
`GrokOptions.ApiKey`	Dein xAI-API-Schlüssel (erforderlich)
`HttpOptions.ReadTimeout`	HTTP-Read-Timeout in Millisekunden (Standard: 60000)
`LogOptions.Enabled`	Request/Response-Logging aktivieren
`RetryOptions.Enabled`	Automatischer Retry bei vorübergehenden Fehlern
`RetryOptions.Retries`	Maximale Anzahl der Retry-Versuche (Standard: 3)
`RetryOptions.Wait`	Wartezeit zwischen Retries in Millisekunden (Standard: 3000)

Request-Parameter

Parameter	Beschreibung
`Temperature`	Sampling-Temperatur (0.0–2.0). Niedrigere Werte = deterministischer.
`TopP`	Nucleus-Sampling (0.0–1.0). Steuert den kumulativen Wahrscheinlichkeits-Cutoff.
`MaxTokens`	Maximale Anzahl Tokens in der Antwort (Standard: 4096).
`FrequencyPenalty`	Bestraft Tokens basierend auf ihrer Häufigkeit im bisherigen Text.
`PresencePenalty`	Bestraft Tokens basierend darauf, ob sie im bisherigen Text vorkommen.
`N`	Anzahl der zu generierenden Completions (Standard: 1).
`ToolChoice`	Steuert die Tool-Auswahl: 'auto', 'none' oder 'required'.

Warum Grok? Von xAI mit Fokus auf Hilfsbereitschaft und Echtzeitwissen entwickelt, brilliert Grok bei Aufgaben, die aktuelle Informationen und nuanciertes Reasoning erfordern. Die sgcWebSockets-Komponente macht es leicht, zwischen Grok und anderen KI-Anbietern zu wechseln und dabei deinen Delphi-Code sauber und konsistent zu halten.