Client API Delphi Gemini

14 avril 2026 · Composants

Google Gemini est l'une des familles de modèles IA multimodaux les plus puissantes disponibles aujourd'hui, excellant dans la génération de texte, la compréhension d'images, les sorties structurées et l'appel de fonctions sur une large gamme de cas d'usage. Pour les développeurs Delphi qui cherchent à intégrer Gemini dans leurs applications, sgcWebSockets fournit TsgcHTTP_API_Gemini — un composant natif complet qui encapsule toute la surface de l'API Google Gemini.

Que tu construises des assistants conversationnels, génères des données structurées, traites des images, crées des embeddings pour la recherche sémantique ou orchestres des workflows augmentés par des outils, ce composant te donne un accès direct à chaque fonctionnalité de Gemini via du code Delphi propre et typé. Pas de code REST répétitif. Pas de manipulation JSON. Il te suffit de poser le composant, de définir ta clé API et de commencer à construire.

Couverture complète de l'API

Chaque fonctionnalité majeure de l'API Google Gemini est prise en charge nativement.

Génération de contenu Génère du texte à partir de prompts avec des instructions système optionnelles. Affine la sortie avec temperature, top-p, top-k et stop sequences.	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 avec un prompt texte. Gemini décrit, interprète et raisonne sur le contenu visuel.
Sortie JSON structurée Force Gemini à renvoyer du JSON valide conforme à ton schéma. Définis un type MIME de réponse et un schéma pour des résultats parseables garantis.	Appel de fonctions Définis des fonctions personnalisées avec JSON Schema. Gemini décide quand les invoquer, ce qui permet des workflows agentiques en plusieurs étapes.	Embeddings Génère des embeddings vectoriels pour du texte. Alimente la recherche sémantique, le clustering, la classification et les systèmes de recommandation.
Comptage de tokens Compte les tokens avant d'envoyer des requêtes. Estime précisément les coûts et gère les budgets de fenêtre de contexte.	Gestion des modèles Liste tous les modèles Gemini disponibles ou récupère les détails d'un modèle spécifique, y compris les limites de tokens d'entrée/sortie.	Réessai et journalisation intégrés Réessai automatique en cas d'échecs transitoires avec nombre de tentatives et intervalles d'attente configurables. Journalisation complète des requêtes/réponses pour le débogage.

Premiers pas

Intègre Google Gemini 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
  Gemini: TsgcHTTP_API_Gemini;
  vResponse: string;
begin
  Gemini := TsgcHTTP_API_Gemini.Create(nil);
  Try
    Gemini.GeminiOptions.ApiKey := 'YOUR_API_KEY';
    // Send a simple message to Gemini
    vResponse := Gemini._CreateContent(
      'gemini-2.5-flash', 'Hello, Gemini!');
    ShowMessage(vResponse);
  Finally
    Gemini.Free;
  End;
end;

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

Génération de contenu et streaming

L'API GenerateContent est le fondement de chaque interaction avec Gemini. Envoie du texte avec des instructions système optionnelles et reçois des réponses de manière synchrone ou en streaming temps réel.

Instructions système

Contrôle le comportement de Gemini en fournissant une instruction système qui définit le contexte, la personnalité ou les contraintes de la conversation.

vResponse := Gemini._CreateContentWithSystem(
  'gemini-2.5-flash',
  '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 utilisateur réactives, diffuse la réponse de Gemini token par token via Server-Sent Events. Assigne le gestionnaire d'événements OnHTTPAPISSE et appelle _CreateContentStream.

// Enable streaming via SSE
Gemini.OnHTTPAPISSE := OnSSEEvent;
Gemini._CreateContentStream('gemini-2.5-flash',
  'Tell me a story about a brave explorer.');
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 total sur les paramètres de la requête — temperature, top-p, top-k, stop sequences, max output tokens — utilise les classes typées de requête et de réponse.

var
  oRequest: TsgcGeminiClass_Request_GenerateContent;
  oResponse: TsgcGeminiClass_Response_GenerateContent;
begin
  oRequest := TsgcGeminiClass_Request_GenerateContent.Create;
  Try
    oRequest.Model := 'gemini-2.5-flash';
    oRequest.SystemInstruction := 'You are a helpful assistant.';
    oRequest.MaxOutputTokens := 2048;
    oRequest.Temperature := 0.7;
    oRequest.TopP := 0.9;
    oRequest.TopK := 40;
    oRequest.Contents.Add('user', 'Explain quantum computing in simple terms.');
    oResponse := Gemini.CreateContent(oRequest);
    Try
      if Length(oResponse.Candidates) > 0 then
        ShowMessage(oResponse.Candidates[0].Parts[0].Text);
    Finally
      oResponse.Free;
    End;
  Finally
    oRequest.Free;
  End;
end;

Vision — compréhension des images

Gemini est nativement multimodal. Envoie des photographies, captures d'écran, diagrammes ou graphiques en parallèle d'un prompt texte et reçois des descriptions détaillées, l'extraction de données ou du Q&R visuel.

// Load an image and ask Gemini to describe it
var
  vBase64: string;
begin
  vBase64 := sgcBase64Encode(LoadFileToBytes('product-photo.png'));
  ShowMessage(Gemini._CreateVisionContent(
    'gemini-2.5-flash',
    'Describe this product image for an e-commerce listing.',
    vBase64, 'image/png'));
end;

Cas d'usage. Automatise l'inspection qualité, génère du texte alt pour l'accessibilité, extrais des données de graphiques ou construis des fonctionnalités de recherche visuelle — le tout depuis du code Delphi natif.

Sortie JSON structurée

Garantis que Gemini renvoie du JSON valide et parseable conforme à ton schéma exact. Définis un type MIME de réponse et un schéma pour éliminer le post-traitement — la réponse est prête à être désérialisée directement dans tes records Delphi.

var
  vSchema, vResponse: string;
begin
  vSchema :=
    '{"type":"object","properties":{"name":{"type":"string"},' +
    '"age":{"type":"integer"}},"required":["name","age"]}';
  vResponse := Gemini._CreateContentJSON(
    'gemini-2.5-flash',
    'Extract the name and age: John is 30 years old.',
    vSchema);
  // Returns: {"name": "John", "age": 30}
end;

Application du schéma. En définissant ResponseMimeType à 'application/json' et en fournissant un ResponseSchema, Gemini garantit une sortie structurellement valide à chaque fois.

Appel de fonctions

Définis des fonctions personnalisées avec JSON Schema, et Gemini décidera quand et comment les invoquer. C'est la base pour construire des workflows agentiques en plusieurs étapes qui connectent l'IA à ta logique métier.

var
  oRequest: TsgcGeminiClass_Request_GenerateContent;
  oFunc: TsgcGeminiClass_Request_FunctionDeclaration;
  oResponse: TsgcGeminiClass_Response_GenerateContent;
begin
  oRequest := TsgcGeminiClass_Request_GenerateContent.Create;
  Try
    oRequest.Model := 'gemini-2.5-flash';
    // Define a function
    oFunc := TsgcGeminiClass_Request_FunctionDeclaration.Create;
    oFunc.Name := 'get_weather';
    oFunc.Description := 'Get the current weather in a location';
    oFunc.Parameters :=
      '{"type":"object","properties":{"location":{"type":"string"}}}';
    oRequest.FunctionDeclarations.Add(oFunc);
    oRequest.Contents.Add('user',
      'What is the weather in Madrid?');
    oResponse := Gemini.CreateContent(oRequest);
    Try
      // Check if Gemini wants to call a function
      if oResponse.Candidates[0].Parts[0].FunctionCallName  '' then
      begin
        ShowMessage('Function: ' + oResponse.Candidates[0].Parts[0].FunctionCallName);
        ShowMessage('Args: ' + oResponse.Candidates[0].Parts[0].FunctionCallArgs);
      end;
    Finally
      oResponse.Free;
    End;
  Finally
    oRequest.Free;
  End;
end;

Embeddings

Génère des embeddings vectoriels de haute qualité pour du texte. Les embeddings alimentent la recherche sémantique, le clustering de documents, les moteurs de recommandation et les tâches de classification.

// Generate embeddings for a text
var
  vEmbedding: string;
begin
  vEmbedding := Gemini._EmbedContent(
    'text-embedding-004',
    'Delphi is a powerful programming language.');
  ShowMessage(vEmbedding);
end;

Pour un contrôle total, utilise l'API typée pour accéder au tableau brut de valeurs d'embedding.

var
  oResponse: TsgcGeminiClass_Response_Embedding;
  i: Integer;
begin
  oResponse := Gemini.EmbedContent(
    'text-embedding-004',
    'Delphi is a powerful programming language.');
  Try
    for i := 0 to Length(oResponse.Values) - 1 do
      Memo1.Lines.Add(FloatToStr(oResponse.Values[i]));
  Finally
    oResponse.Free;
  End;
end;

Comptage de tokens

Estime les coûts et gère précisément les budgets de fenêtre de contexte avant d'envoyer des requêtes.

var
  vTokens: string;
begin
  vTokens := Gemini._CountTokens(
    'gemini-2.5-flash',
    'How many tokens does this message consume?');
  ShowMessage(vTokens);
end;

Gestion des modèles

Interroge les modèles Gemini disponibles par programme. Liste tous les modèles ou récupère les détails d'un ID de modèle spécifique, y compris le nom d'affichage, la description et les limites de tokens.

// List all available Gemini models
vModels := Gemini._GetModels;
// Get details for a specific model
vModel := Gemini._GetModel('gemini-2.5-flash');
// Typed API: access model properties directly
var
  oModel: TsgcGeminiClass_Response_Model;
begin
  oModel := Gemini.GetModel('gemini-2.5-flash');
  Try
    ShowMessage('Name: ' + oModel.DisplayName);
    ShowMessage('Input limit: ' + IntToStr(oModel.InputTokenLimit));
    ShowMessage('Output limit: ' + IntToStr(oModel.OutputTokenLimit));
  Finally
    oModel.Free;
  End;
end;

Configuration et options

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

Propriété	Description
`GeminiOptions.ApiKey`	Ta clé API Google Gemini (obligatoire)
`HttpOptions.ReadTimeout`	Délai de lecture HTTP en millisecondes (par défaut : 60000)
`LogOptions.Enabled`	Active la journalisation des requêtes/réponses
`LogOptions.FileName`	Chemin du fichier journal pour la capture des requêtes/réponses
`RetryOptions.Enabled`	Réessai automatique en cas d'échecs transitoires (429, 503)
`RetryOptions.Retries`	Nombre maximum de tentatives de réessai (par défaut : 3)
`RetryOptions.Wait`	Temps d'attente entre les réessais en millisecondes (par défaut : 3000)

Paramètres de requête

Paramètre	Description
`Temperature`	Température d'échantillonnage (0.0–2.0). Des valeurs plus basses = plus déterministe.
`TopP`	Échantillonnage nucleus (0.0–1.0). Contrôle le seuil de probabilité cumulative.
`TopK`	Échantillonnage Top-K. Limite la sélection de tokens aux K meilleurs candidats.
`MaxOutputTokens`	Nombre maximum de tokens dans la réponse (par défaut : 4096).
`StopSequences`	Séquences personnalisées qui arrêtent la génération quand elles sont rencontrées.
`ResponseMimeType`	Format de sortie : 'application/json' pour JSON, 'text/plain' pour du texte.
`ToolChoice`	Contrôle comment le modèle sélectionne les fonctions à appeler.