Grok Delphi API Client

15 avril 2026 · Composants

Grok, développé par xAI, est un modèle d'IA haute performance conçu pour des réponses rapides et intelligentes avec une connaissance en temps réel et des capacités de raisonnement avancées. Pour les développeurs Delphi qui veulent intégrer Grok dans leurs applications, sgcWebSockets fournit TsgcHTTP_API_Grok — un composant natif qui encapsule l'ensemble de l'API xAI Grok avec du code Delphi propre et typé.

Que tu construises des assistants conversationnels, que tu analyses des images, que tu orchestres des workflows augmentés par des outils ou que tu diffuses des réponses en temps réel, ce composant te donne un accès direct à toutes les fonctionnalités de Grok. Pas de plomberie REST. Pas de manipulation JSON. Pose simplement le composant, configure ta clé API et commence à construire.

Couverture API complète

Chaque fonctionnalité majeure de l'API xAI Grok est prise en charge dès l'installation.

Chat Completions Envoie des messages avec des prompts système, reçois des réponses synchrones ou en streaming. Contrôle total sur la température, top-p, frequency et presence penalties.	Streaming en temps réel Diffuse les réponses token par token via Server-Sent Events. Construis des interfaces réactives qui affichent les réponses au fur et à mesure de leur génération.	Vision Analyse des images en envoyant des données encodées en base64 ou des URL d'images aux côtés de prompts textuels. Grok décrit, interprète et raisonne sur du contenu visuel.
Tool Use — Function Calling Définis des outils personnalisés avec JSON Schema. Grok décide quand les invoquer, permettant des workflows agentiques multi-étapes.	Gestion des modèles Liste tous les modèles Grok disponibles par programmation. Interroge les ID et capacités des modèles pour sélectionner le meilleur choix.	Retry et journalisation intégrés Retry automatique en cas d'échecs transitoires avec un nombre de tentatives et un délai configurables. Journalisation complète des requêtes/réponses pour le debug.

Premiers pas

Intègre xAI Grok dans ton projet Delphi en moins d'une minute. Pose le composant, configure ta clé API et envoie ton premier message.

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

Deux styles d'API. Chaque fonctionnalité offre à la fois des méthodes de commodité (basées sur des chaînes, code minimal) et des classes de requête/réponse typées (contrôle complet, sécurité de typage). Choisis l'approche qui correspond le mieux à ton cas d'usage.

Chat Completions et streaming

L'API Chat Completions est la fondation de chaque interaction avec Grok. Envoie du texte avec des prompts système optionnels et reçois des réponses synchrones ou diffusées en temps réel.

Prompts système

Contrôle le comportement de Grok en fournissant un prompt système qui définit le contexte, la personnalité ou les contraintes de la conversation.

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

Streaming en temps réel

Pour des interfaces réactives, diffuse la réponse de Grok token par token via Server-Sent Events. Assigne le gestionnaire d'événement OnHTTPAPISSE et appelle _CreateMessageStream.

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

API typée avancée

Pour un contrôle complet sur les paramètres de requête — température, top-p, frequency penalty, presence penalty, séquences stop, nombre de complétions — utilise les classes typées de requête et de réponse.

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 — compréhension d'images

Grok peut analyser et raisonner sur des images. Envoie des photographies, captures d'écran, diagrammes ou graphiques aux côtés d'un prompt textuel et reçois des descriptions détaillées, des extractions de données ou du Q&A visuel.

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

Cas d'usage. Automatise l'analyse de rapports, extrais des données depuis des captures d'écran, génère des descriptions de contenu visuel ou construis des assistants conscients des images — le tout depuis du code Delphi natif.

Tool Use — Function Calling

Définis des outils personnalisés avec JSON Schema, et Grok décidera quand et comment les invoquer. C'est la fondation pour construire des workflows agentiques multi-étapes qui connectent l'IA à ta logique métier.

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;

Gestion des modèles

Interroge par programmation les modèles Grok disponibles. Liste tous les modèles pour découvrir les nouvelles capacités dès qu'elles deviennent disponibles.

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

Configuration et options

Affine le comportement du composant avec des options de configuration complètes.

Propriété	Description
`GrokOptions.ApiKey`	Ta clé API xAI (obligatoire)
`HttpOptions.ReadTimeout`	Timeout de lecture HTTP en millisecondes (par défaut : 60000)
`LogOptions.Enabled`	Active la journalisation des requêtes/réponses
`RetryOptions.Enabled`	Retry automatique en cas d'échecs transitoires
`RetryOptions.Retries`	Nombre maximum de tentatives de retry (par défaut : 3)
`RetryOptions.Wait`	Temps d'attente entre les retries en millisecondes (par défaut : 3000)

Paramètres de requête

Paramètre	Description
`Temperature`	Température d'échantillonnage (0.0–2.0). Valeurs plus basses = plus déterministe.
`TopP`	Nucleus sampling (0.0–1.0). Contrôle le seuil de probabilité cumulative.
`MaxTokens`	Nombre maximum de tokens dans la réponse (par défaut : 4096).
`FrequencyPenalty`	Pénalise les tokens en fonction de leur fréquence dans le texte généré jusqu'ici.
`PresencePenalty`	Pénalise les tokens selon qu'ils apparaissent ou non dans le texte généré jusqu'ici.
`N`	Nombre de complétions à générer (par défaut : 1).
`ToolChoice`	Contrôle la sélection d'outil : 'auto', 'none' ou 'required'.

Pourquoi Grok ? Construit par xAI avec un focus sur l'utilité et la connaissance en temps réel, Grok excelle dans les tâches nécessitant des informations à jour et un raisonnement nuancé. Le composant sgcWebSockets facilite la bascule entre Grok et d'autres fournisseurs d'IA tout en gardant ton code Delphi propre et cohérent.