Grok Delphi API-client

15 april 2026 · Componenten

Grok, ontwikkeld door xAI, is een high-performance AI-model dat is ontworpen voor snelle, intelligente antwoorden met realtime-kennis en geavanceerde redeneer-mogelijkheden. Voor Delphi-ontwikkelaars die Grok in hun toepassingen willen integreren, biedt sgcWebSockets TsgcHTTP_API_Grok — een native component dat de volledige xAI Grok-API verpakt in nette, type-veilige Delphi-code.

Of je nu conversationele assistenten bouwt, afbeeldingen analyseert, tool-uitgebreide workflows orkestreert of realtime-antwoorden streamt: dit component geeft je rechtstreeks toegang tot elke Grok-functie. Geen REST-boilerplate. Geen JSON-gepuzzel. Plaats het component, stel je API-sleutel in en begin met bouwen.

Volledige API-dekking

Elke belangrijke functie van de xAI Grok-API wordt direct ondersteund.

Chat Completions Verstuur berichten met system-prompts en ontvang antwoorden synchroon of gestreamd. Volledige controle over temperature, top-p, frequency- en presence-penalty.	Realtime-streaming Stream antwoorden token voor token via Server-Sent Events. Bouw responsive UI's die antwoorden tonen terwijl ze worden gegenereerd.	Vision Analyseer afbeeldingen door base64-gecodeerde data of afbeeldings-URL's naast tekst-prompts mee te sturen. Grok beschrijft, interpreteert en redeneert over visuele inhoud.
Tool Use — function-calling Definieer eigen tools met JSON Schema. Grok beslist wanneer hij ze aanroept, waardoor agentische, meerstaps workflows mogelijk worden.	Modelbeheer Vraag programmatisch alle beschikbare Grok-modellen op. Bekijk model-ID's en mogelijkheden om het beste te kiezen.	Ingebouwde retry & logging Automatisch opnieuw proberen bij tijdelijke storingen met instelbare pogingen en wachttijden. Volledige request/response-logging voor debuggen.

Aan de slag

Integreer xAI Grok binnen een minuut in je Delphi-project. Plaats het component, configureer je API-sleutel en verstuur je eerste bericht.

// 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;

Twee API-stijlen. Elke functie biedt zowel gemaks-methoden (op basis van strings, minimale code) als getypte request/response-klassen (volledige controle, typeveiligheid). Kies de aanpak die het beste past bij jouw use case.

Chat Completions & streaming

De Chat-Completions-API is de basis van elke Grok-interactie. Verstuur tekst met een optionele system-prompt en ontvang antwoorden synchroon of in realtime gestreamd.

System-prompts

Stuur het gedrag van Grok bij door een system-prompt mee te geven die de context, persoonlijkheid of beperkingen voor het gesprek vastlegt.

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."

Realtime-streaming

Stream voor responsive-gebruikersinterfaces het antwoord van Grok token voor token via Server-Sent Events. Wijs de event-handler OnHTTPAPISSE toe en roep _CreateMessageStream aan.

// 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;

Geavanceerde getypeerde API

Gebruik de getypte request- en response-klassen voor volledige controle over request-parameters — temperature, top-p, frequency-penalty, presence-penalty, stop-sequences, aantal completions.

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 — beeldherkenning

Grok kan afbeeldingen analyseren en erover redeneren. Stuur foto's, screenshots, diagrammen of grafieken naast een tekst-prompt mee en ontvang gedetailleerde beschrijvingen, data-extractie of visuele 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;

Use case. Automatiseer rapportanalyse, extraheer data uit screenshots, genereer beschrijvingen van visuele inhoud of bouw beeld-bewuste assistenten — allemaal vanuit native Delphi-code.

Tool Use — function-calling

Definieer eigen tools met JSON Schema en Grok beslist wanneer en hoe hij ze aanroept. Dit is de basis voor het bouwen van agentische, meerstaps workflows die de AI verbinden met je bedrijfslogica.

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;

Modelbeheer

Vraag programmatisch de beschikbare Grok-modellen op. Toon alle modellen om nieuwe mogelijkheden te ontdekken zodra ze beschikbaar komen.

// 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;

Configuratie & opties

Verfijn het gedrag van het component met uitgebreide configuratie-opties.

Eigenschap	Beschrijving
`GrokOptions.ApiKey`	Je xAI-API-sleutel (verplicht)
`HttpOptions.ReadTimeout`	HTTP-leestime-out in milliseconden (standaard: 60000)
`LogOptions.Enabled`	Schakel request/response-logging in
`RetryOptions.Enabled`	Automatisch opnieuw proberen bij tijdelijke storingen
`RetryOptions.Retries`	Maximaal aantal nieuwe pogingen (standaard: 3)
`RetryOptions.Wait`	Wachttijd tussen pogingen in milliseconden (standaard: 3000)

Request-parameters

Parameter	Beschrijving
`Temperature`	Sampling-temperatuur (0,0–2,0). Lagere waarden = deterministischer.
`TopP`	Nucleus-sampling (0,0–1,0). Bepaalt de cumulatieve waarschijnlijkheidsgrens.
`MaxTokens`	Maximaal aantal tokens in het antwoord (standaard: 4096).
`FrequencyPenalty`	Geef tokens een penalty op basis van hoe vaak ze al voorkomen in de tekst.
`PresencePenalty`	Geef tokens een penalty op basis van of ze tot dusver voorkomen in de tekst.
`N`	Aantal te genereren completions (standaard: 1).
`ToolChoice`	Bepaal de tool-selectie: 'auto', 'none' of 'required'.

Waarom Grok? Gebouwd door xAI met focus op behulpzaamheid en realtime-kennis blinkt Grok uit in taken waarvoor actuele informatie en genuanceerd redeneren nodig zijn. Met het sgcWebSockets-component is het eenvoudig om tussen Grok en andere AI-aanbieders te wisselen terwijl je Delphi-code netjes en consistent blijft.