Klient API Gemini dla Delphi

14 kwietnia 2026 · Komponenty

Google Gemini to jedna z najpotężniejszych rodzin multimodalnych modeli AI dostępnych dziś, doskonałych w generowaniu tekstu, rozumieniu obrazów, ustrukturyzowanych danych wyjściowych i wywoływaniu funkcji w szerokim zakresie zastosowań. Dla programistów Delphi chcących zintegrować Gemini ze swoimi aplikacjami, sgcWebSockets dostarcza TsgcHTTP_API_Gemini — kompleksowy, natywny komponent opakowujący całą powierzchnię API Google Gemini.

Niezależnie od tego, czy budujesz asystentów konwersacyjnych, generujesz ustrukturyzowane dane, przetwarzasz obrazy, tworzysz embeddingi do wyszukiwania semantycznego, czy orkiestrowujesz przepływy pracy wspomagane narzędziami — ten komponent daje ci bezpośredni dostęp do każdej funkcji Gemini za pomocą czystego, typebezpiecznego kodu Delphi. Żadnych szablonów REST. Żadnego żonglowania JSON. Wystarczy upuścić komponent, ustawić klucz API i zacząć budować.

Pełne pokrycie API

Każda główna funkcja API Google Gemini jest obsługiwana od razu po wyjęciu z pudełka.

Generowanie treści Generuj tekst z promptów z opcjonalnymi instrukcjami systemowymi. Dostrajaj dane wyjściowe za pomocą temperatury, top-p, top-k i sekwencji zatrzymania.	Strumieniowanie w czasie rzeczywistym Strumieniuj odpowiedzi token po tokenie za pomocą Server-Sent Events. Buduj responsywne interfejsy wyświetlające odpowiedzi w trakcie generowania.	Wizja Analizuj obrazy, wysyłając dane zakodowane w base64 wraz z promptem tekstowym. Gemini opisuje, interpretuje i wnioskuje na temat treści wizualnych.
Ustrukturyzowane dane wyjściowe JSON Wymusz na Gemini zwracanie prawidłowego JSON zgodnego ze schematem. Ustaw typ MIME odpowiedzi i schemat, aby zagwarantować parsowalne wyniki.	Wywołanie funkcji Definiuj niestandardowe funkcje za pomocą schematu JSON. Gemini decyduje, kiedy je wywołać, umożliwiając agentyczne, wieloetapowe przepływy pracy.	Embeddingi Generuj wektorowe embeddingi dla tekstu. Zasilaj wyszukiwanie semantyczne, klastrowanie, klasyfikację i systemy rekomendacji.
Liczenie tokenów Zliczaj tokeny przed wysyłaniem żądań. Dokładnie szacuj koszty i zarządzaj budżetami okna kontekstu.	Zarządzanie modelami Wyświetl wszystkie dostępne modele Gemini lub pobierz szczegóły konkretnego modelu, w tym limity tokenów wejściowych/wyjściowych.	Wbudowane ponawianie i logowanie Automatyczne ponawianie przy przejściowych błędach z konfigurowalną liczbą prób i interwałami oczekiwania. Pełne logowanie żądań/odpowiedzi do debugowania.

Pierwsze kroki

Zintegruj Google Gemini ze swoim projektem Delphi w mniej niż minutę. Upuść komponent, skonfiguruj klucz API i wyślij pierwszą wiadomość.

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

Dwa style API. Każda funkcja oferuje zarówno wygodne metody (oparte na łańcuchach znaków, minimalny kod), jak i typizowane klasy żądań/odpowiedzi (pełna kontrola, bezpieczeństwo typów). Wybierz podejście najlepiej pasujące do Twojego przypadku użycia.

Generowanie treści i strumieniowanie

API GenerateContent stanowi podstawę każdej interakcji z Gemini. Wysyłaj tekst z opcjonalnymi instrukcjami systemowymi i odbieraj odpowiedzi synchronicznie lub strumieniowane w czasie rzeczywistym.

Instrukcje systemowe

Steruj zachowaniem Gemini, podając instrukcję systemową, która określa kontekst, osobowość lub ograniczenia rozmowy.

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

Strumieniowanie w czasie rzeczywistym

Dla responsywnych interfejsów użytkownika strumieniuj odpowiedź Gemini token po tokenie za pomocą Server-Sent Events. Przypisz obsługę zdarzenia OnHTTPAPISSE i wywołaj _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;

Zaawansowane API z typami

Aby mieć pełną kontrolę nad parametrami żądania — temperaturą, top-p, top-k, sekwencjami zatrzymania, maksymalną liczbą tokenów wyjściowych — użyj klas żądań i odpowiedzi z typami.

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;

Wizja — rozumienie obrazów

Gemini jest natywnie multimodalny. Wysyłaj zdjęcia, zrzuty ekranu, diagramy lub wykresy razem z promptem tekstowym i odbieraj szczegółowe opisy, ekstrakcję danych lub wizualne pytania i odpowiedzi.

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

Przypadek użycia. Automatyzuj inspekcję jakości, generuj tekst alt dla dostępności, ekstrahuj dane z wykresów lub buduj funkcje wyszukiwania wizualnego — wszystko z natywnego kodu Delphi.

Ustrukturyzowane dane wyjściowe JSON

Zagwarantuj, że Gemini zwróci prawidłowy, parsowalny JSON zgodny z Twoim dokładnym schematem. Ustaw typ MIME odpowiedzi i schemat, aby wyeliminować przetwarzanie końcowe — odpowiedź jest gotowa do bezpośredniej deserializacji do Twoich rekordów 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;

Wymuszanie schematu. Ustawiając ResponseMimeType na 'application/json' i podając ResponseSchema, Gemini gwarantuje strukturalnie prawidłowe dane wyjściowe za każdym razem.

Wywołanie funkcji

Definiuj niestandardowe funkcje za pomocą schematu JSON, a Gemini zdecyduje, kiedy i jak je wywołać. To podstawa budowania agentycznych, wieloetapowych przepływów pracy łączących AI z logiką biznesową.

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;

Embeddingi

Generuj wysokiej jakości wektorowe embeddingi dla tekstu. Embeddingi zasilają wyszukiwanie semantyczne, klastrowanie dokumentów, silniki rekomendacji i zadania klasyfikacji.

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

Aby mieć pełną kontrolę, użyj API z typami, aby uzyskać dostęp do tablicy surowych wartości embeddingów.

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;

Liczenie tokenów

Dokładnie szacuj koszty i zarządzaj budżetami okna kontekstu przed wysyłaniem żądań.

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

Zarządzanie modelami

Programowo odpytuj dostępne modele Gemini. Wyświetl wszystkie modele lub pobierz szczegóły dla konkretnego ID modelu, w tym nazwę wyświetlaną, opis i limity tokenów.

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

Konfiguracja i opcje

Dostrajaj zachowanie komponentu za pomocą kompleksowych opcji konfiguracji.

Właściwość	Opis
`GeminiOptions.ApiKey`	Twój klucz API Google Gemini (wymagany)
`HttpOptions.ReadTimeout`	Limit czasu odczytu HTTP w milisekundach (domyślnie: 60000)
`LogOptions.Enabled`	Włącz logowanie żądań/odpowiedzi
`LogOptions.FileName`	Ścieżka pliku dziennika do przechwytywania żądań/odpowiedzi
`RetryOptions.Enabled`	Automatyczne ponawianie przy przejściowych błędach (429, 503)
`RetryOptions.Retries`	Maksymalna liczba prób ponowienia (domyślnie: 3)
`RetryOptions.Wait`	Czas oczekiwania między ponowieniami w milisekundach (domyślnie: 3000)

Parametry żądania

Parametr	Opis
`Temperature`	Temperatura próbkowania (0.0–2.0). Niższe wartości = bardziej deterministyczne.
`TopP`	Próbkowanie jądra (0.0–1.0). Kontroluje próg skumulowanego prawdopodobieństwa.
`TopK`	Próbkowanie Top-K. Ogranicza wybór tokenów do K najlepszych kandydatów.
`MaxOutputTokens`	Maksymalna liczba tokenów w odpowiedzi (domyślnie: 4096).
`StopSequences`	Niestandardowe sekwencje zatrzymujące generowanie po napotkaniu.
`ResponseMimeType`	Format danych wyjściowych: 'application/json' dla JSON, 'text/plain' dla tekstu.
`ToolChoice`	Kontroluj sposób wyboru funkcji do wywołania przez model.