Een LLM aanroepen vanuit Delphi: OpenAI, Claude, Ollama

Begin hier

Twee manieren om de aanroep te doen

Er is een providerneutrale chatcomponent, en er is een aparte REST-client voor elke leverancier. Beide zitten in dezelfde bibliotheek, dus je kunt met de ene beginnen en naar de andere afzakken zonder van project te wisselen.

TsgcAIChat, één API voor elke provider

Stel Provider, een API-sleutel en een model in, en roep dan Chat aan. De component bouwt de leveranciers-JSON, houdt de gespreksgeschiedenis bij en geeft de tekst van de assistent terug. Wisselen van OpenAI naar Claude, of naar een lokaal Ollama-model, is één toewijzing. Geïmplementeerd door TsgcAI_Chat in de unit sgcAI_Chat, en op het palet geregistreerd als TsgcAIChat.

De REST-clients per leverancier

TsgcHTTP_API_OpenAI, TsgcHTTP_API_Anthropic en TsgcHTTP_API_Ollama ontsluiten elke leveranciers-API volledig, inclusief de onderdelen die geen enkele neutrale laag kan afdekken: vision-invoer, documentinvoer, extended thinking, batches, bestanden, embeddings, beeldgeneratie en transcriptie. Gebruik deze wanneer je een specifiek endpoint nodig hebt.

Editie en platform

De AI- en LLM-clients zijn een Enterprise-functie van sgcWebSockets, niet Standard en niet Professional, of je koopt het losse package sgcAI.

Het platform telt hier mee. De drie REST-clients compileren op Windows, macOS, Linux, iOS en Android. TsgcAIChat niet: die is alleen voor Windows gecompileerd, dus op een Linux-service, een macOS-build of een mobiel doel roep je de REST-client rechtstreeks aan. De voorbeelden op deze pagina zijn zo geschreven dat beide routes werken.

QuickStart

Je eerste aanroep, in ongeveer tien regels

Plaats de component, stel een sleutel en een model in, stuur een prompt. Kies het tabblad van de provider waarmee je begint. Het laatste tabblad heeft helemaal geen API-sleutel nodig, omdat het model op je eigen machine draait.

uChat.pas

uses
  Classes, SysUtils,
  // sgc
  sgcAI_Chat;

procedure TfrmMain.btnAskClick(Sender: TObject);
var
  oChat: TsgcAI_Chat;
begin
  oChat := TsgcAI_Chat.Create(nil);
  try
    oChat.Provider := aicpOpenAI;
    oChat.ChatOptions.ApiKey := GetApiKey;
    oChat.ChatOptions.Model := 'gpt-4o-mini';
    oChat.ChatOptions.MaxTokens := 1024;
    oChat.SystemMessage := 'You are a concise assistant inside a Delphi ERP.';

    memoAnswer.Lines.Text := oChat.Chat(memoPrompt.Lines.Text);
  finally
    oChat.Free;
  end;
end;

Van leverancier wisselen is één regel. Provider accepteert aicpOpenAI, aicpAnthropic, aicpGemini, aicpDeepSeek, aicpOllama, aicpGrok en aicpMistral. De rest van je code blijft waar die is.

Alleen Windows. TsgcAI_Chat en de bijbehorende paletcomponent TsgcAIChat zijn gecompileerd voor Windows, Win32 en Win64. Op macOS, Linux, iOS en Android wordt de unit helemaal niet gecompileerd, dus als je doel een Linux-service of een mobiele app is, gebruik je de REST-clients van de leveranciers in de andere drie tabbladen. Die kennen geen platformbeperking.

uOpenAI.pas

uses
  Classes, SysUtils,
  // sgc
  sgcHTTP_API_OpenAI;

var
  oOpenAI: TsgcHTTP_API_OpenAI;
begin
  oOpenAI := TsgcHTTP_API_OpenAI.Create(nil);
  try
    oOpenAI.OpenAIOptions.ApiKey := GetApiKey;

    // Shortcut: model plus one user message, raw JSON back
    memoAnswer.Lines.Text := oOpenAI._CreateChatCompletion(
      'gpt-4o', 'Say hello');
  finally
    oOpenAI.Free;
  end;
end;

De methoden met een underscore zijn snelkoppelingen op stringniveau die de ruwe responsbody teruggeven. Wil je een geparseerd object, bouw dan een TsgcOpenAIClass_Request_ChatCompletion en roep CreateChatCompletion aan, verderop op deze pagina te zien.

uClaude.pas

uses
  Classes, SysUtils,
  // sgc
  sgcHTTP_API_Anthropic;

var
  oAnthropic: TsgcHTTP_API_Anthropic;
begin
  oAnthropic := TsgcHTTP_API_Anthropic.Create(nil);
  try
    oAnthropic.AnthropicOptions.ApiKey := GetApiKey;
    oAnthropic.AnthropicOptions.AnthropicVersion := '2023-06-01';

    // Model, prompt, max tokens
    memoAnswer.Lines.Text := oAnthropic._CreateMessage(
      'claude-sonnet-4-20250514',
      'Summarise RFC 6455 in three bullet points.', 1024);
  finally
    oAnthropic.Free;
  end;
end;

Claude vereist de header met de API-versie, dus stel AnthropicVersion naast de sleutel in. _CreateMessageWithSystem voegt een systeemprompt toe, en _CountTokens berekent de prijs van een prompt voordat je hem verstuurt.

uOllama.pas

uses
  Classes, SysUtils,
  // sgc
  sgcHTTP_API_Ollama;

var
  oOllama: TsgcHTTP_API_Ollama;
begin
  oOllama := TsgcHTTP_API_Ollama.Create(nil);
  try
    // Local server, no API key required
    oOllama.OllamaOptions.Host := 'http://localhost:11434';

    // Which models are pulled on this machine?
    memoModels.Lines.Text := oOllama._GetTags;

    memoAnswer.Lines.Text := oOllama._CreateMessage(
      'llama3', 'Summarise this invoice in one line.');
  finally
    oOllama.Free;
  end;
end;

Host staat standaard op http://localhost:11434, dus bij een standaardinstallatie kun je hem met rust laten. _PullModel downloadt een model, _GetTags toont wat er al op schijf staat en _ShowModel leest de details ervan.

Streaming

Toon het antwoord terwijl het geschreven wordt

Een enkele aanroep blokkeert tot het model klaar is, wat bij een lang antwoord aanvoelt alsof er iets stuk is. Streaming levert het antwoord in fragmenten, zodat er tekst in je memo verschijnt terwijl het model nog nadenkt. Hier lopen de meeste mensen vast, dus hier zijn allebei de niveaus.

Met TsgcAIChat, delta's al gedecodeerd

Roep ChatStream aan in plaats van Chat en handel OnChatStream af. De component vraagt de provider om een gestreamd antwoord, parseert elk Server-Sent Event en geeft je aChunk, wat de nieuwe tekst is en verder niets. Jij plakt die eraan vast, en dat is de hele implementatie.

Elke provider streamt een andere JSON-vorm. OpenAI, DeepSeek, Ollama, Grok en Mistral zetten de tekst in choices[0].delta.content, Claude in delta.text, Gemini nog dieper in candidates. TsgcAIChat weet al welke vorm geldt voor de provider die je hebt gekozen, dus je handler ziet nooit JSON.

Zet Cancel op True in de handler om een op hol geslagen antwoord te stoppen. Het verzoek wordt op dat moment afgebroken, en er komen geen chunks meer binnen. Als de stream eindigt, wordt de samengestelde tekst aan de geschiedenis toegevoegd en door ChatStream teruggegeven, en OnChatMessage vuurt één keer af met het volledige antwoord.

uChatStream.pas

procedure TfrmMain.btnStreamClick(Sender: TObject);
begin
  FChat.Provider := aicpAnthropic;
  FChat.ChatOptions.ApiKey := GetApiKey;
  FChat.ChatOptions.Model := 'claude-sonnet-4-20250514';
  FChat.OnChatStream := OnChatStream;
  FChat.OnChatError := OnChatError;

  memoAnswer.Lines.Clear;
  FChat.ChatStream(memoPrompt.Lines.Text);
end;

procedure TfrmMain.OnChatStream(Sender: TObject;
  const aChunk: string; var Cancel: Boolean);
begin
  memoAnswer.Text := memoAnswer.Text + aChunk;
  Cancel := FUserPressedStop;
end;

procedure TfrmMain.OnChatError(Sender: TObject;
  const aError: string);
begin
  memoAnswer.Lines.Add('ERROR: ' + aError);
end;

Met een client van de leverancier, ruwe events

De REST-clients streamen ook. Wijs OnHTTPAPISSE toe en roep de snelkoppeling voor streaming aan: _CreateMessageStream bij Claude en bij Ollama, en bij OpenAI een TsgcOpenAIClass_Request_ChatCompletion met Stream op True. De gebeurtenis geeft je aEvent, de naam van het Server-Sent Event, en aData, de payload voor die gebeurtenis, precies zoals de leverancier hem verstuurd heeft.

Op dit niveau parseer je de JSON zelf, en dat is precies de bedoeling: je ziet de delta's van tool calls, stopredenen, verbruiksgegevens en al het andere dat de leverancier over de lijn stuurt. Gedeeltelijke netwerkleesbewerkingen zijn al voor je samengevoegd, dus een gebeurtenis die over twee TCP-leesbewerkingen verdeeld is, komt toch heel binnen, en de door nieuwe regels gescheiden JSON van Ollama wordt via dezelfde gebeurtenis geleverd.

De afsluiters verschillen per leverancier. OpenAI sluit af met de letterlijke tekst [DONE], Claude met een gebeurtenis met de naam message_stop. Handel ze allebei af als je code allebei de leveranciers ondersteunt.

uRawStream.pas

procedure TfrmMain.FormCreate(Sender: TObject);
begin
  FAnthropic := TsgcHTTP_API_Anthropic.Create(nil);
  FAnthropic.AnthropicOptions.ApiKey := GetApiKey;
  FAnthropic.AnthropicOptions.AnthropicVersion := '2023-06-01';
  FAnthropic.OnHTTPAPISSE := HandleSSE;
  FAnthropic.OnHTTPAPIException := HandleException;
end;

procedure TfrmMain.btnStreamClick(Sender: TObject);
begin
  memoRaw.Lines.Clear;
  FAnthropic._CreateMessageStream(
    'claude-sonnet-4-20250514',
    'Write a haiku about Object Pascal.', 1024);
end;

procedure TfrmMain.HandleSSE(Sender: TObject;
  const aEvent, aData: string; var Cancel: Boolean);
begin
  if (aEvent = 'message_stop') or (aData = '[DONE]') then
    Exit;
  memoRaw.Lines.Add(aEvent + ': ' + aData);
end;

procedure TfrmMain.HandleException(Sender: TObject;
  E: Exception);
begin
  memoRaw.Lines.Add('ERROR: ' + E.Message);
end;

Threads. Chat en ChatStream zijn synchroon, dus ze rechtstreeks vanuit een knopklik aanroepen bevriest het formulier zolang het verzoek duurt. Op Delphi 2010 en later voert ChatAsync de aanroep uit op een worker thread en geeft een IsgcFuture<string> terug. Koppel ThenProc voor het resultaat en OnError voor fouten, en roep Cancel aan om een lopend verzoek af te breken. De callback van ThenProc wordt op de hoofdthread afgehandeld, dus je kunt de UI daar rechtstreeks vanuit aanraken.

Tool calling

Laat het model je Pascal-code aanroepen

Tool calling, ook wel function calling genoemd, is de manier waarop een model je toepassing vraagt om iets op te zoeken of een actie uit te voeren. Jij beschrijft de functie met een JSON Schema, het model antwoordt met de argumenten die het wil, jij voert de Pascal-code uit en stuurt het resultaat terug. Dit is het mechanisme achter elke bruikbare assistent binnen een bedrijfstoepassing.

Claude, met getypeerde toolobjecten

Bouw een TsgcAnthropicClass_Request_Messages, koppel er een of meer TsgcAnthropicClass_Request_Tool-items aan en roep CreateMessage aan. Elke tool heeft een Name, een Description en een InputSchema, dat het JSON Schema voor de argumenten is.

Het antwoord is een TsgcAnthropicClass_Response_Messages waarvan Content een array van blokken is. Een blok waarvan ContentType gelijk is aan 'tool_use' bevat de Name van de tool, de argumenten in Input en een Id. Voer je functie uit en stuur daarna een vervolgbericht met een TsgcAnthropicClass_Request_Content_Block waarin ContentType op 'tool_result' staat, met dezelfde ToolUseId en jouw antwoord in Content. Zet IsError wanneer de aanroep mislukt is, zodat het model kan herstellen in plaats van te gokken.

Let op het eigenaarschap: het Anthropic-verzoek is geen eigenaar van de berichten en tools die je eraan koppelt, dus geef je ze zelf vrij, zoals in het voorbeeld.

uToolUse.pas

var
  oRequest: TsgcAnthropicClass_Request_Messages;
  oMessage: TsgcAnthropicClass_Request_Message;
  oTool: TsgcAnthropicClass_Request_Tool;
  oMessages: TsgcAnthropicArray_Request_Messages;
  oTools: TsgcAnthropicArray_Request_Tools;
  oResponse: TsgcAnthropicClass_Response_Messages;
  i: Integer;
begin
  oRequest := TsgcAnthropicClass_Request_Messages.Create;
  try
    oRequest.Model := 'claude-sonnet-4-20250514';
    oRequest.MaxTokens := 4096;

    oMessage := TsgcAnthropicClass_Request_Message.Create;
    oMessage.Role := 'user';
    oMessage.Content := 'What is the stock of SKU 8841?';
    SetLength(oMessages, 1);
    oMessages[0] := oMessage;
    oRequest.Messages := oMessages;

    oTool := TsgcAnthropicClass_Request_Tool.Create;
    oTool.Name := 'get_stock';
    oTool.Description := 'Read the on-hand stock for a SKU';
    oTool.InputSchema :=
      '{"type":"object","properties":{"sku":{"type":"string",' +
      '"description":"The product code"}},"required":["sku"]}';
    SetLength(oTools, 1);
    oTools[0] := oTool;
    oRequest.Tools := oTools;

    oResponse := FAnthropic.CreateMessage(oRequest);
    try
      for i := 0 to Length(oResponse.Content) - 1 do
        if oResponse.Content[i].ContentType = 'tool_use' then
          // .Name is the tool, .Input the JSON arguments,
          // .Id the value to echo back as ToolUseId
          RunTool(oResponse.Content[i].Name,
            oResponse.Content[i].Input, oResponse.Content[i].Id)
        else if oResponse.Content[i].ContentType = 'text' then
          memoAnswer.Lines.Add(oResponse.Content[i].Text);
    finally
      oResponse.Free;
    end;
  finally
    sgcFree(oMessage);
    sgcFree(oTool);
    sgcFree(oRequest);
  end;
end;

OpenAI, met een getypeerd verzoek

Hetzelfde idee, andere vorm. Vul een TsgcOpenAIClass_Request_ChatCompletion, wijs de array Messages toe, zet je tooldefinities als JSON-array in Tools en stuur het model desgewenst bij met ToolChoice. ParallelToolCalls bepaalt of het model meerdere tools tegelijk mag vragen, en ResponseFormat legt het antwoord vast op JSON wanneer je het moet parseren.

CreateChatCompletion geeft een geparseerde TsgcOpenAIClass_Response_ChatCompletion terug. Lees het antwoord uit Choices[0]._Message.Content, de gevraagde aanroepen uit Choices[0]._Message.ToolCalls, waarom het model gestopt is uit Choices[0].FinishReason, en wat het gekost heeft uit Usage.PromptTokens, Usage.CompletionTokens en Usage.TotalTokens. Anders dan het Anthropic-verzoek is dit verzoek wel eigenaar van de berichtobjecten die je eraan koppelt, en geeft het ze samen met zichzelf vrij.

De oudere eigenschappen Functions en FunctionCall zijn er nog steeds voor code die geschreven is tegen de oorspronkelijke vorm van function calling bij OpenAI.

uTypedRequest.pas

var
  oRequest: TsgcOpenAIClass_Request_ChatCompletion;
  oResponse: TsgcOpenAIClass_Response_ChatCompletion;
  oSystem, oUser: TsgcOpenAIClass_Request_Completion_Message;
  oMessages: TsgcOpenAIArray_Request_Completion_Messages;
begin
  oRequest := TsgcOpenAIClass_Request_ChatCompletion.Create;
  try
    oRequest.Model := 'gpt-4o';
    oRequest.MaxTokens := 1024;
    oRequest.Temperature := 0.2;

    oSystem := TsgcOpenAIClass_Request_Completion_Message.Create;
    oSystem.Role := 'system';
    oSystem.Content := 'You are a warehouse assistant.';

    oUser := TsgcOpenAIClass_Request_Completion_Message.Create;
    oUser.Role := 'user';
    oUser.Content := 'What is the stock of SKU 8841?';

    SetLength(oMessages, 2);
    oMessages[0] := oSystem;
    oMessages[1] := oUser;
    oRequest.Messages := oMessages;

    // Tool definitions as a JSON array
    oRequest.Tools :=
      '[{"type":"function","function":{"name":"get_stock",' +
      '"description":"Read the on-hand stock for a SKU",' +
      '"parameters":{"type":"object","properties":' +
      '{"sku":{"type":"string"}},"required":["sku"]}}}]';
    oRequest.ToolChoice := 'auto';

    oResponse := FOpenAI.CreateChatCompletion(oRequest);
    try
      if Length(oResponse.Choices) > 0 then
      begin
        memoAnswer.Lines.Text := oResponse.Choices[0]._Message.Content;
        memoTools.Lines.Text := oResponse.Choices[0]._Message.ToolCalls;
        lblStop.Caption := oResponse.Choices[0].FinishReason;
      end;
      lblTokens.Caption := IntToStr(oResponse.Usage.TotalTokens);
    finally
      oResponse.Free;
    end;
  finally
    // frees the attached Messages too
    oRequest.Free;
  end;
end;

De echte keuze

Gehost model of lokaal model

Als je prompts klantgegevens, medische gegevens, contracten of iets anders bevatten dat onder een verwerkersovereenkomst valt, is dit geen prestatievraag, maar een compliancevraag. Hier is de vergelijking.

	Gehost, OpenAI of Claude	Lokaal, Ollama
Waar de prompt heen gaat	Naar de leverancier, via HTTPS, onder hun voorwaarden	Nergens heen. Het verzoek gaat naar `http://localhost:11434`
Inloggegevens	Een API-sleutel die je buiten je versiebeheer en buiten de binary moet houden	Standaard geen. `OllamaOptions.ApiKey` bestaat voor een instantie achter een proxy of op afstand
Kwaliteit van het antwoord	De sterkste modellen die er vandaag zijn	Goed en steeds beter, duidelijk achter de koplopers bij moeilijk redeneren
Kosten	Per token, voor altijd. Houd `Usage.TotalTokens` in de gaten	Je hardware, eenmalig. Een bruikbaar model wil veel RAM of een GPU
Latentie	Een rondgang over het netwerk, plus wachtrijen bij de leverancier op drukke momenten	Geen netwerk. De snelheid is wat je machine aankan
Offline en air-gapped	Nee	Ja
Rate limits en storingen	Aan de kant van de leverancier. Gebruik `RetryOptions` en respecteer `Retry-After`	Alleen je eigen capaciteit
Component	`TsgcHTTP_API_OpenAI`, `TsgcHTTP_API_Anthropic`	`TsgcHTTP_API_Ollama`

Een veelgehoord antwoord is: allebei. Omdat TsgcAIChat elke provider achter één API zet, kun je tijdens runtime routeren op dataclassificatie: lokaal voor alles wat een klantgegeven raakt, gehost voor de rest. De schakelaar is Provider, plus ChatOptions.BaseUrl wanneer de provider Ollama is.

if aContainsPersonalData then
begin
  FChat.Provider := aicpOllama;
  FChat.ChatOptions.BaseUrl := 'http://localhost:11434';
  FChat.ChatOptions.Model := 'llama3';
end
else
begin
  FChat.Provider := aicpOpenAI;
  FChat.ChatOptions.ApiKey := GetApiKey;
  FChat.ChatOptions.Model := 'gpt-4o-mini';
end;

memoAnswer.Lines.Text := FChat.Chat(memoPrompt.Lines.Text);

Voordat je live gaat

De instellingen die in productie tellen

Een demo die op je eigen bureau werkt is niet hetzelfde als een client die een rate limit, een traag model en een supportticket met "hij stopte gewoon" overleeft.

Herpogingen en backoff

Elke client heeft een blok RetryOptions: Enabled, Retries, Wait, Multiplier, MaxInterval, Jitter en HonorRetryAfter. Zet het aan en een tijdelijke fout wordt opnieuw geprobeerd met exponentiële backoff in plaats van als exceptie naar boven te komen. HonorRetryAfter laat de client de Retry-After-header van de leverancier volgen in plaats van te gokken.

Time-outs

HttpOptions.ReadTimeout is degene die je moet verhogen. Een lange generatie, zeker op een lokaal model, kan langer duren dan een standaard HTTP-leestime-out en halverwege een antwoord dat prima liep alsnog mislukken.

Logging

LogOptions.Enabled plus LogOptions.FileName schrijft het verkeer naar een bestand. Als een prompt zich in productie anders gedraagt, is dit de snelste manier om te zien welke JSON je code echt verstuurd heeft.

Gespreksgeschiedenis

TsgcAIChat bewaart de uitwisseling en speelt die opnieuw af bij de volgende aanroep, en dat is wat een vervolgvraag laat werken. Begrens hem met MaxHistoryMessages, zodat een lange sessie de prompt, en daarmee de rekening, niet ongelimiteerd laat groeien. ClearHistory begint opnieuw, en GetHistory ontsluit Count en de losse berichten.

Azure OpenAI

Zet OpenAIOptions.Provider op oapvAzure en vul AzureOptions.ResourceName, AzureOptions.DeploymentId en AzureOptions.APIVersion in. De rest van je code blijft ongewijzigd, en dat telt wanneer inkoop erop staat dat het verkeer binnen je eigen Azure-tenant blijft.

Fouten en circuit breaking

OnHTTPAPIException brengt fouten uit de REST-clients naar boven, en OnChatError doet hetzelfde voor TsgcAIChat. Een HTTP-fout komt binnen als een EsgcHTTPAPIProtocolException, die nog steeds afstamt van EIdHTTPProtocolException en daarnaast de responsheaders meedraagt. CircuitBreaker en RateLimit zijn op de client beschikbaar voor de aanroepen die je zelf doet.

Verder gaan

Wat mensen bouwen na de eerste aanroep

Een chatvenster is het begin. Dit zijn de vier richtingen die dit werk meestal opgaat, en ze zitten alle vier al in de bibliotheek.

Antwoorden vanuit je eigen data

Zet je documenten om in vectoren met TsgcAIOpenAIEmbeddings, sla ze op in TsgcAIDatabaseVectorFile of TsgcAIDatabaseVectorPinecone, en haal de dichtstbijzijnde passages op om in de prompt te zetten. Dit is retrieval augmented generation, en zo voorkom je dat het model antwoorden over jouw bedrijf verzint.

Embeddings en vectordatabases

Praat ertegen, en laat het terugpraten

TsgcAIOpenAIChatBot koppelt een recorder, transcriptie, de chataanroep en tekst-naar-spraak in één component, zodat een gebruiker een gesproken gesprek met je toepassing kan voeren. TsgcAIOpenAITranslator doet hetzelfde voor live vertaling.

AI ChatBot en AI Translator

Stel je app open voor een AI-agent

Het Model Context Protocol is de manier waarop assistenten tools ontdekken en aanroepen. TsgcWSServer_API_MCP maakt van je Delphi-toepassing een MCP-server die Claude en andere clients kunnen aansturen, en TsgcWSAPI_Client_MCP gebruikt andere servers vanuit je code. Op het palet verschijnen ze als TsgcWSAPIServer_MCP en TsgcWSAPIClient_MCP.

Goed om te weten: anders dan de chatcomponent zijn de MCP-units niet beperkt tot Windows, dus een MCP-server die in Delphi geschreven is kan op Linux draaien.

MCP-overzicht, MCP-server en MCP-client

Gebruik de rest van elke leveranciers-API

Beeldgeneratie, transcriptie, moderatie, batches en fine-tuning bij OpenAI. Vision, documenten, extended thinking, zoeken op het web en het tellen van tokens bij Claude. Embeddings en modelbeheer bij Ollama. Op elke leverancierspagina staat wat de bijbehorende client ontsluit.

OpenAI, Claude en Ollama

Resources

Naslag, demo's en tutorials

De componentnaslag documenteert elke property en elke event. Kant-en-klare demoprojecten zitten in de bibliotheek, onder Demos\AI.

	Naslag, OpenAI-client Elke methode, optie en event op `TsgcHTTP_API_OpenAI`.	Openen
	Naslag, Anthropic-client Berichten, tools, vision, batches en het tellen van tokens op `TsgcHTTP_API_Anthropic`.	Openen
	Tutorial, Claude vanuit Delphi De uitgebreide rondleiding door de Anthropic-client, van begin tot eind.	Openen
	Tutorial, lokale modellen met Ollama Haal een model op, richt de client op localhost en draai het offline.	Openen
	Tutorial, function calling Een model koppelen aan je eigen Pascal-functies, stap voor stap.	Openen
	Gebruikershandleiding (PDF) Uitgebreide handleiding over elke component in de bibliotheek.	Openen

Meer lezen: de OpenAI-client vanuit Delphi, een AI-chatbot bouwen, een AI-agent bouwen en de MCP-client. De landingspagina's van de componenten zijn Delphi OpenAI-client en Anthropic API.

Deze pagina is een van de Delphi use cases, die elk één klus van begin tot eind behandelen. De andere tot nu toe zijn een gebruiker inloggen met OAuth2 en PKCE en twee toepassingen peer-to-peer verbinden met WebRTC.

FAQ

Veelgestelde vragen

Maak een TsgcAI_Chat aan uit de unit sgcAI_Chat, zet Provider op de leverancier die je wilt, stel ChatOptions.ApiKey en ChatOptions.Model in, en roep dan Chat('your prompt') aan, dat het antwoord als string teruggeeft. Wil je liever rechtstreeks met één leveranciers-API praten, gebruik dan TsgcHTTP_API_OpenAI, TsgcHTTP_API_Anthropic of TsgcHTTP_API_Ollama en roep _CreateChatCompletion of _CreateMessage aan. Beide routes zitten in sgcWebSockets en in het losse package sgcAI, en ze werken van Delphi 7 tot en met RAD Studio 13.

Roep ChatStream aan in plaats van Chat, en handel OnChatStream af, dat afvuurt met aChunk, de gedecodeerde tekst van elke delta, en een vlag Cancel die je kunt zetten om vroegtijdig te stoppen. Op het niveau van de REST-client wijs je OnHTTPAPISSE toe en roep je _CreateMessageStream aan op de Claude- en Ollama-clients, of zet je Stream op True in een TsgcOpenAIClass_Request_ChatCompletion. Die gebeurtenis geeft je de ruwe naam en data van het Server-Sent Event, met gedeeltelijke netwerkleesbewerkingen al samengevoegd.

Ja. Installeer Ollama, haal een model op, en richt TsgcHTTP_API_Ollama daarop. OllamaOptions.Host staat al standaard op http://localhost:11434, dus bij een standaardinstallatie kies je alleen een model en roep je _CreateMessage aan. Er verlaat niets de machine, er is geen API-sleutel nodig en de toepassing werkt offline. Via TsgcAIChat bereik je dezelfde server door Provider op aicpOllama te zetten en, als de server niet op localhost draait, ChatOptions.BaseUrl.

Beschrijf de functie met een JSON Schema en koppel die aan het verzoek. Bij Claude voeg je een TsgcAnthropicClass_Request_Tool met Name, Description en InputSchema toe aan de array Tools van een TsgcAnthropicClass_Request_Messages. Het antwoord bevat dan een contentblok waarvan ContentType gelijk is aan tool_use, met daarin Name, Input en Id, en jij antwoordt met een blok tool_result dat dezelfde ToolUseId aanhaalt. Bij OpenAI zet je de definities in de property Tools van een TsgcOpenAIClass_Request_ChatCompletion en lees je de gevraagde aanroepen uit Choices[0]._Message.ToolCalls.

De AI- en LLM-clients zijn een Enterprise-functie van sgcWebSockets. Ze zitten niet in de edities Standard of Professional. Als je de rest van sgcWebSockets niet nodig hebt, bevat het losse package sgcAI dezelfde componenten samen met de runtime die ze nodig hebben. De bibliotheek ondersteunt Delphi 7 tot en met RAD Studio 13 en de bijbehorende versies van C++ Builder. Qua platforms compileren de REST-clients TsgcHTTP_API_OpenAI, TsgcHTTP_API_Anthropic en TsgcHTTP_API_Ollama voor Windows, macOS, Linux, iOS en Android, terwijl TsgcAIChat alleen voor Windows is gecompileerd, Win32 en Win64. De MCP-client en -server zijn evenmin beperkt tot Windows.

Bij gehoste providers wel. De componenten zijn REST-clients, dus je neemt een sleutel mee van je eigen OpenAI-, Anthropic-, Google-, xAI-, DeepSeek- of Mistral-account en wijst die toe aan ChatOptions.ApiKey, of aan de opties van de leverancier zoals OpenAIOptions.ApiKey. Het verbruik wordt door die leverancier op jouw sleutel gefactureerd, en je kunt het per antwoord volgen via Usage.PromptTokens, Usage.CompletionTokens en Usage.TotalTokens. Ollama heeft geen sleutel nodig, omdat het model lokaal draait.

Chat en ChatStream zijn synchroon. Roep op Delphi 2010 en later in plaats daarvan ChatAsync aan: die voert het verzoek uit op een worker thread en geeft een IsgcFuture van string terug, dus je koppelt ThenProc om het antwoord te ontvangen, OnError om een exceptie te ontvangen en Cancel om een lopend verzoek af te breken. De callback van ThenProc wordt op de hoofdthread afgehandeld, dus je kunt daar veilig de UI vanuit bijwerken. Verhoog ook HttpOptions.ReadTimeout, want een lange generatie kan langer duren dan een standaard leestime-out.

Ja. Zet OpenAIOptions.Provider op oapvAzure en vul AzureOptions.ResourceName, AzureOptions.DeploymentId en AzureOptions.APIVersion in. De client richt zich dan op je Azure-deployment, en de aanroepen die je al geschreven hebt blijven precies hetzelfde.

Een LLM aanroepen vanuit Delphi