Klient API Grok dla Delphi

15 kwietnia 2026 · Komponenty

Grok, opracowany przez xAI, to wydajny model AI zaprojektowany pod kątem szybkich, inteligentnych odpowiedzi z wiedzą w czasie rzeczywistym i zaawansowanymi możliwościami rozumowania. Dla programistów Delphi pragnących zintegrować Grok ze swoimi aplikacjami sgcWebSockets dostarcza TsgcHTTP_API_Grok — natywny komponent opakowujący całe API xAI Grok w czyste, typowo bezpieczne kod Delphi.

Czy budujesz asystentów konwersacyjnych, analizujesz obrazy, orkiestrujesz przepływy pracy wspomagane narzędziami czy strumieniujesz odpowiedzi w czasie rzeczywistym — ten komponent daje ci bezpośredni dostęp do każdej funkcji Grok. Bez szablonów REST. Bez żonglowania JSON. Po prostu dodaj komponent, ustaw klucz API i zacznij budować.

Pełne pokrycie API

Każda główna funkcja API xAI Grok jest obsługiwana od razu po instalacji.

Chat Completions Wysyłaj wiadomości z promptami systemowymi, odbieraj odpowiedzi synchronicznie lub strumieniowo. Pełna kontrola nad temperaturą, top-p oraz karami częstości i obecności.	Strumieniowanie w czasie rzeczywistym Strumieniuj odpowiedzi token po tokenie przy użyciu Server-Sent Events. Buduj responsywne interfejsy wyświetlające odpowiedzi w miarę ich generowania.	Rozpoznawanie obrazów Analizuj obrazy, wysyłając dane zakodowane w base64 lub adresy URL obrazów wraz z promptami tekstowymi. Grok opisuje, interpretuje i rozumuje na temat treści wizualnych.
Użycie narzędzi — wywoływanie funkcji Definiuj własne narzędzia ze schematem JSON. Grok decyduje, kiedy je wywołać, umożliwiając agentowe, wieloetapowe przepływy pracy.	Zarządzanie modelami Programowo wylistuj wszystkie dostępne modele Grok. Odpytuj identyfikatory modeli i możliwości, aby wybrać najlepiej pasujący.	Wbudowane ponowne próby i rejestrowanie Automatyczne ponowne próby przy przejściowych błędach z konfigurowalnymi próbami i interwałami oczekiwania. Pełne rejestrowanie żądań i odpowiedzi do debugowania.

Pierwsze kroki

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

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

Dwa style API. Każda funkcja oferuje zarówno wygodne metody (oparte na ciągach znaków, minimalny kod), jak i typowane klasy żądań/odpowiedzi (pełna kontrola, bezpieczeństwo typów). Wybierz podejście najlepiej odpowiadające Twojemu przypadkowi użycia.

Chat Completions i strumieniowanie

API Chat Completions jest podstawą każdej interakcji z Grok. Wysyłaj tekst z opcjonalnymi promptami systemowymi i odbieraj odpowiedzi synchronicznie lub strumieniowo w czasie rzeczywistym.

Prompty systemowe

Kontroluj zachowanie Grok, podając prompt systemowy określający kontekst, osobowość lub ograniczenia konwersacji.

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

Strumieniowanie w czasie rzeczywistym

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

Zaawansowane typowane API

Dla pełnej kontroli nad parametrami żądania — temperaturą, top-p, karą częstości, karą obecności, sekwencjami stop, liczbą uzupełnień — używaj typowanych klas żądań i odpowiedzi.

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;

Rozpoznawanie obrazów — Vision

Grok potrafi analizować obrazy i rozumować na ich temat. Wyślij zdjęcia, zrzuty ekranu, diagramy lub wykresy wraz z promptem tekstowym, a otrzymasz szczegółowe opisy, ekstrakcję danych lub wizualne pytania i odpowiedzi.

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

Przykład zastosowania. Automatyzuj analizę raportów, wyodrębniaj dane ze zrzutów ekranu, generuj opisy treści wizualnych lub buduj asystentów świadomych obrazu — wszystko z poziomu natywnego kodu Delphi.

Użycie narzędzi — wywoływanie funkcji

Definiuj własne narzędzia ze schematem JSON, a Grok sam zdecyduje, kiedy i jak je wywołać. To fundament do budowania agentowych, wieloetapowych przepływów pracy łączących AI z logiką biznesową.

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;

Zarządzanie modelami

Odpytuj programowo dostępne modele Grok. Wylistuj wszystkie modele, aby odkrywać nowe możliwości w miarę ich udostępniania.

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

Konfiguracja i opcje

Dostosuj zachowanie komponentu za pomocą kompleksowych opcji konfiguracyjnych.

Właściwość	Opis
`GrokOptions.ApiKey`	Twój klucz API xAI (wymagany)
`HttpOptions.ReadTimeout`	Limit czasu odczytu HTTP w milisekundach (domyślnie: 60000)
`LogOptions.Enabled`	Włącz rejestrowanie żądań i odpowiedzi
`RetryOptions.Enabled`	Automatyczne ponawianie przy przejściowych błędach
`RetryOptions.Retries`	Maksymalna liczba prób ponowienia (domyślnie: 3)
`RetryOptions.Wait`	Czas oczekiwania między próbami 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ądrowe (0,0–1,0). Kontroluje odcięcie skumulowanego prawdopodobieństwa.
`MaxTokens`	Maksymalna liczba tokenów w odpowiedzi (domyślnie: 4096).
`FrequencyPenalty`	Karze tokeny na podstawie częstości ich wystąpień w dotychczasowym tekście.
`PresencePenalty`	Karze tokeny na podstawie tego, czy pojawiły się już w dotychczasowym tekście.
`N`	Liczba uzupełnień do wygenerowania (domyślnie: 1).
`ToolChoice`	Kontrola wyboru narzędzia: 'auto', 'none' lub 'required'.

Dlaczego Grok? Zbudowany przez xAI z naciskiem na pomocność i wiedzę w czasie rzeczywistym, Grok wyróżnia się w zadaniach wymagających aktualnych informacji i niuansowego rozumowania. Komponent sgcWebSockets ułatwia przełączanie między Grok a innymi dostawcami AI, zachowując kod Delphi czysty i spójny.