Gemini API Delphi Client

14 April 2026 · Components

Google Gemini ist eine der leistungsstärksten multimodalen KI-Modellfamilien heute und glänzt bei Textgenerierung, Bildverständnis, strukturierten Ausgaben und Function Calling über ein breites Anwendungsspektrum. Für Delphi-Entwickler, die Gemini in ihre Anwendungen integrieren möchten, bietet sgcWebSockets TsgcHTTP_API_Gemini — eine umfassende, native Komponente, die die gesamte Google-Gemini-API-Oberfläche kapselt.

Egal, ob du Konversationsassistenten baust, strukturierte Daten erzeugst, Bilder verarbeitest, Embeddings für semantische Suche erstellst oder werkzeuggestützte Workflows orchestrierst — diese Komponente verschafft dir über sauberen, typsicheren Delphi-Code direkten Zugriff auf jede Gemini-Funktion. Kein REST-Boilerplate. Kein JSON-Gefummel. Komponente ablegen, API-Key setzen und loslegen.

Vollständige API-Abdeckung

Jede wichtige Funktion der Google-Gemini-API wird out of the box unterstützt.

Content-Generierung Erzeuge Text aus Prompts mit optionalen System Instructions. Stimme die Ausgabe per Temperatur, Top-p, Top-k und Stopp-Sequenzen ab.	Echtzeit-Streaming Streame Antworten Token für Token per Server-Sent Events. Baue responsive Oberflächen, die Antworten während der Generierung anzeigen.	Vision Analysiere Bilder, indem du base64-codierte Daten zusammen mit einem Text-Prompt sendest. Gemini beschreibt, interpretiert und argumentiert über visuelle Inhalte.
Strukturierte JSON-Ausgabe Zwinge Gemini, gültiges JSON gemäß deinem Schema zurückzugeben. Setze einen Response-MIME-Type und ein Schema für garantiert parsebare Ergebnisse.	Function Calling Definiere eigene Funktionen mit JSON Schema. Gemini entscheidet, wann es sie aufruft, und ermöglicht agentische, mehrstufige Workflows.	Embeddings Erzeuge Vektor-Embeddings für Texte. Treibe semantische Suche, Clustering, Klassifikation und Empfehlungssysteme an.
Token-Zählung Zähle Tokens, bevor du Anfragen sendest. Schätze Kosten präzise ab und steuere dein Kontextfenster-Budget.	Modellverwaltung Liste alle verfügbaren Gemini-Modelle auf oder rufe Details zu einem bestimmten Modell ab, einschließlich Input-/Output-Token-Limits.	Eingebautes Retry & Logging Automatisches Retry bei vorübergehenden Fehlern mit konfigurierbaren Versuchen und Wartezeiten. Vollständiges Request-/Response-Logging fürs Debugging.

Erste Schritte

Integriere Google Gemini in unter einer Minute in dein Delphi-Projekt. Komponente ablegen, API-Key konfigurieren und erste Nachricht senden.

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

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.

Content-Generierung & Streaming

Die GenerateContent-API ist die Grundlage jeder Gemini-Interaktion. Sende Text mit optionalen System Instructions und empfange Antworten synchron oder per Stream in Echtzeit.

System Instructions

Steuere Geminis Verhalten, indem du eine System Instruction mitgibst, die Kontext, Persönlichkeit oder Einschränkungen für die Konversation festlegt.

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

Echtzeit-Streaming

Für responsive Benutzeroberflächen streamst du Geminis Antwort Token für Token per Server-Sent Events. Weise den Event-Handler OnHTTPAPISSE zu und rufe _CreateContentStream auf.

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

Fortgeschrittene typisierte API

Für die volle Kontrolle über Anfrageparameter — Temperatur, Top-p, Top-k, Stopp-Sequenzen, Max Output Tokens — verwendest du die typisierten Request- und Response-Klassen.

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 — Bildverständnis

Gemini ist nativ multimodal. Sende Fotos, Screenshots, Diagramme oder Charts zusammen mit einem Text-Prompt und erhalte detaillierte Beschreibungen, Datenextraktion oder visuelle Q&A.

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

Anwendungsfall. Automatisiere die Qualitätsprüfung, erzeuge Alt-Texte für Barrierefreiheit, extrahiere Daten aus Charts oder baue visuelle Suchfunktionen — alles aus nativem Delphi-Code.

Strukturierte JSON-Ausgabe

Garantiere, dass Gemini gültiges, parsebares JSON gemäß deinem genauen Schema zurückgibt. Setze einen Response-MIME-Type und ein Schema, um Nachbearbeitung zu vermeiden — die Antwort lässt sich direkt in deine Delphi-Records deserialisieren.

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;

Schema-Durchsetzung. Indem du ResponseMimeType auf 'application/json' setzt und ein ResponseSchema angibst, garantiert Gemini jedes Mal strukturell gültige Ausgaben.

Function Calling

Definiere eigene Funktionen mit JSON Schema; Gemini entscheidet, wann und wie sie aufgerufen werden. Das ist die Grundlage für agentische, mehrstufige Workflows, die die KI mit deiner Geschäftslogik verbinden.

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

Erzeuge hochwertige Vektor-Embeddings für Texte. Embeddings treiben semantische Suche, Dokumenten-Clustering, Empfehlungssysteme und Klassifikationsaufgaben an.

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

Für die volle Kontrolle greifst du über die typisierte API direkt auf das rohe Werte-Array der Embeddings zu.

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;

Token-Zählung

Schätze Kosten und steuere dein Kontextfenster-Budget präzise, bevor du Anfragen sendest.

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

Modellverwaltung

Frage verfügbare Gemini-Modelle programmatisch ab. Liste alle Modelle auf oder rufe Details zu einer bestimmten Modell-ID ab, einschließlich Anzeigename, Beschreibung und Token-Limits.

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

Konfiguration & Optionen

Stelle das Verhalten der Komponente über umfangreiche Konfigurationsoptionen fein ein.

Eigenschaft	Beschreibung
`GeminiOptions.ApiKey`	Dein Google-Gemini-API-Key (erforderlich)
`HttpOptions.ReadTimeout`	HTTP-Read-Timeout in Millisekunden (Standard: 60000)
`LogOptions.Enabled`	Request-/Response-Logging aktivieren
`LogOptions.FileName`	Pfad zur Log-Datei für Request-/Response-Aufzeichnung
`RetryOptions.Enabled`	Automatisches Retry bei vorübergehenden Fehlern (429, 503)
`RetryOptions.Retries`	Maximale Anzahl an Wiederholungsversuchen (Standard: 3)
`RetryOptions.Wait`	Wartezeit zwischen Versuchen in Millisekunden (Standard: 3000)

Anfrageparameter

Parameter	Beschreibung
`Temperature`	Sampling-Temperatur (0,0–2,0). Niedrigere Werte = deterministischer.
`TopP`	Nucleus-Sampling (0,0–1,0). Steuert die kumulative Wahrscheinlichkeitsgrenze.
`TopK`	Top-K-Sampling. Beschränkt die Token-Auswahl auf die Top-K-Kandidaten.
`MaxOutputTokens`	Maximale Anzahl an Tokens in der Antwort (Standard: 4096).
`StopSequences`	Eigene Sequenzen, die die Generierung beim Auftreten stoppen.
`ResponseMimeType`	Ausgabeformat: 'application/json' für JSON, 'text/plain' für Text.
`ToolChoice`	Steuert, wie das Modell aufzurufende Funktionen auswählt.