Puis-je garder l'interface réactive pendant une longue génération ?

Sur Delphi 2010 et ultérieur, appelle ChatAsync, qui est entouré de {$IFDEF D2010} et renvoie un IsgcFuture . Sur Delphi 7 à 2009, cette méthode n'existe pas, exécute donc Chat dans un thread que tu crées toi-même.

Démarrage rapide de sgcAI

En un coup d'œil

Ce dont a besoin le premier appel

Un composant, une clé, un nom de modèle et un prompt. Pas de JSON à construire ni de client HTTP à configurer.

Composant

TsgcAIChat sur la page de palette SGC AI. C'est une fine enveloppe publiée autour de TsgcAI_Chat, que les démos livrées créent dans le code.

Unité

sgcAI_Chat.pas pour la classe, ou l'unité barrel sgcAI.pas pour le composant de palette. Les démos écrivent uses sgcAI_Chat;.

La propriété qui change de fournisseur

Provider, de type TsgcAIChatProvider. Les sept membres sont aicpOpenAI, aicpAnthropic, aicpGemini, aicpDeepSeek, aicpOllama, aicpGrok et aicpMistral. Rien d'autre ne change dans ton code.

Plateforme, lis bien ceci

TsgcAIChat se compile pour toutes les plateformes : Win32, Win64, macOS, Linux64, iOS et Android, et l'IDE le propose sur les fiches de toutes. Les appels HTTPS demandent la configuration TLS habituelle de chaque plateforme, par exemple les bibliothèques OpenSSL sous Linux. Voir le tableau ci-dessous.

Avant de commencer

Prérequis et éditions

La colonne d'édition indique le define qui conditionne le code, avec la ligne où il se trouve dans Source/sgcVer.inc.

Quoi	Valeur
IDE	Delphi 7 jusqu'à RAD Studio 13, et les versions C++Builder correspondantes. `ChatAsync` est le seul membre avec un plancher plus élevé, car il est entouré de `{$IFDEF D2010}`.
Clause uses	`sgcAI_Chat` pour `TsgcAI_Chat`, `TsgcAIChatProvider` et les types d'événements.
Édition, dans sgcWebSockets	`SGC_AI` est défini à la ligne 796, dans le bloc `{$IFDEF SGC_EDT_ENT}` qui va de la ligne 759 à la ligne 842. Donc Enterprise et supérieures, ni Standard ni Professional.
Édition, package autonome	Le produit sgcAI définit `SGC_PACK_AI` à la ligne 857, et son propre bloc des lignes 946 à 959 définit `SGC_AI` à la ligne 947. Les mêmes composants, sans le reste de la bibliothèque.
Plateformes	Aucune des deux définitions de `SGC_AI`, ligne 796 et ligne 947, ne comporte de garde de plateforme, donc `sgcAI_Chat.pas` se compile pour toutes les cibles et le composant porte `ComponentPlatforms(0)`. Seuls `TsgcAudioRecorderMCI`, `TsgcAudioRecorderWave`, `TsgcAudioPlayerMCI` et `TsgcTextToSpeechSystem`, qui appellent des API audio et vocales de Windows, ne sont compilés que sous Windows.
Ce qui est multiplateforme	`SGC_AI_MCP`, à la ligne 797 et à la ligne 955, ne comporte aucune garde de plateforme. Le client et le serveur MCP fonctionnent donc aussi sous Linux, macOS, iOS et Android. Les defines de fournisseurs `SGC_OPENAI`, `SGC_ANTHROPIC`, `SGC_GEMINI`, `SGC_DEEPSEEK`, `SGC_OLLAMA`, `SGC_GROK` et `SGC_MISTRAL`, lignes 786 à 792, ne sont pas non plus conditionnés par la plateforme.

Tu construis un service Linux ou une application mobile ? TsgcAIChat se compile aussi sur ces cibles. Tu peux aussi appeler directement le client REST du fournisseur, par exemple TsgcHTTP_API_OpenAI ou TsgcHTTP_API_Anthropic. Le guide appeler un LLM depuis Delphi présente les deux approches côte à côte.

Étape 1

Installer et trouver la page de palette

sgcAI est livré dans l'installeur de sgcWebSockets et aussi comme package à part. Dans les deux cas l'installation a la même forme.

1. Décompresser

Décompresse le téléchargement dans un dossier, appelé {$DIR} ci-dessous.

2. Chemin de bibliothèque

Outils, Options, Bibliothèque. Ajoute {$DIR}\source et le dossier lib de ton IDE, par exemple {$DIR}\libD13\$(Platform).

3. Compiler les packages

Ouvre le groupe de packages de ta version d'IDE sous {$DIR}\Packages\. Compile d'abord le .dpk d'exécution, puis installe celui de conception dcl.

4. Vérifier la palette

Une page nommée SGC AI apparaît avec quinze composants. TsgcAIChat est le premier. Si la page est absente sur une cible autre que Windows, c'est normal, car la palette de l'IDE ne propose ces composants que sous Win32 et Win64, alors que les unités se compilent sur toutes les plateformes.

5. Obtenir une clé d'API

Pour un fournisseur hébergé, tu apportes ta propre clé de ce fournisseur et tu l'affectes à ChatOptions.ApiKey. Ollama n'a besoin d'aucune clé, car le modèle s'exécute sur ta machine.

QuickStart

Ta première réponse, en une dizaine de lignes

Crée le composant, définis un fournisseur, une clé et un modèle, puis appelle Chat et lis la chaîne renvoyée.

fUnifiedChat.pas

uses
  Classes, SysUtils,
  // sgc
  sgcAI_Chat;

procedure TfrmUnifiedChat.btnChatClick(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.';

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

Changer de fournisseur tient en une ligne. Provider accepte aicpOpenAI, aicpAnthropic, aicpGemini, aicpDeepSeek, aicpOllama, aicpGrok et aicpMistral. Tout le reste reste en place.

fUnifiedChat.pas

procedure TfrmUnifiedChat.OnChatStream(Sender: TObject; const aChunk: string;
  var Cancel: Boolean);
begin
  memoResponse.Text := memoResponse.Text + aChunk;
  // set Cancel to stop the generation early
end;

procedure TfrmUnifiedChat.OnChatError(Sender: TObject; const aError: string);
begin
  memoResponse.Text := 'error: ' + aError;
end;

procedure TfrmUnifiedChat.btnChatStreamClick(Sender: TObject);
begin
  GetChat.Provider := aicpAnthropic;
  GetChat.ChatOptions.ApiKey := GetApiKey;
  GetChat.ChatOptions.Model := 'claude-sonnet-4-20250514';
  GetChat.SystemMessage := memoSystem.Text;

  memoResponse.Lines.Clear;
  GetChat.ChatStream(memoPrompt.Text);
end;

La démo construit son composant une seule fois dans GetChat et y affecte OnChatStream et OnChatError. ChatStream renvoie aussi la réponse complète, tu peux donc ignorer la valeur de retour et n'utiliser que l'événement, ou utiliser les deux.

uLocal.pas

uses
  Classes, SysUtils,
  // sgc
  sgcAI_Chat;

var
  oChat: TsgcAI_Chat;
begin
  oChat := TsgcAI_Chat.Create(nil);
  try
    // no API key at all: the model runs on this machine
    oChat.Provider := aicpOllama;
    oChat.ChatOptions.Model := 'llama3';

    // BaseUrl is read only for the Ollama provider, and only when
    // the server is not on the default address. Internally it is
    // forwarded to the Ollama client's Host property.
    oChat.ChatOptions.BaseUrl := 'http://localhost:11434';

    Writeln(oChat.Chat('Summarise this invoice in one line.'));
  finally
    oChat.Free;
  end;
end;

Il n'existe pas de OllamaOptions.BaseUrl. Au niveau de l'API brute, la propriété est OllamaOptions.Host sur TsgcHTTP_API_Ollama, et ChatOptions.BaseUrl est ce qui l'alimente depuis cette couche.

Les deux premiers onglets proviennent de la démo livrée Demos\15.AI\02.Applications\06.UnifiedChat\fUnifiedChat.pas, avec les contrôles de la fiche remplacés par des littéraux. Le troisième onglet est le même composant pointé vers un serveur Ollama local. Une seconde démo, 07.ConversationHistory, montre l'API d'historique dans le même dossier.

Étape 2

Vérifier que ça marche, et voir l'échec quand ce n'est pas le cas

Chat ne lève pas d'exception sur un appel en échec, ce qui surprend. Il renvoie plutôt une chaîne vide et déclenche un événement.

La valeur de retour

Chat renvoie le texte de l'assistant sous forme de string. Une chaîne vide signifie que l'appel a échoué, car un échec ne lève pas d'exception.

`OnChatError`

procedure(Sender: TObject; const aError: string). Chat et ChatStream interceptent l'exception et la dirigent ici. C'est le premier événement à brancher, avant toute autre chose.

`OnChatStream`

procedure(Sender: TObject; const aChunk: string; var Cancel: Boolean). Du texte qui apparaît dans le mémo pendant que le modèle écrit encore prouve que le streaming fonctionne au lieu de tout mettre en tampon.

La conversation

GetHistory renvoie ce que le composant rejoue à l'appel suivant. MaxHistoryMessages le plafonne et ClearHistory repart de zéro.

Problèmes courants

Ce qui se passe généralement mal la première fois

Six problèmes expliquent presque tous les premiers appels en échec.

Compiler pour Linux, macOS ou mobile

sgcAI_Chat.pas se compile pour toutes les plateformes. TsgcAudioRecorderMCI, TsgcAudioRecorderWave, TsgcAudioPlayerMCI et TsgcTextToSpeechSystem appellent des API audio et vocales de Windows et ne sont compilés que sous Windows, garde-les donc hors d'une fiche multiplateforme. Les appels HTTPS demandent la configuration TLS habituelle de chaque plateforme, par exemple les bibliothèques OpenSSL sous Linux.

Chat renvoie une chaîne vide et rien n'est levé

Chat et ChatStream avalent l'exception et la dirigent vers OnChatError, dont la signature est procedure(Sender: TObject; const aError: string). Branche cet événement avant de déboguer quoi que ce soit d'autre.

Un modèle Ollama local est ignoré

L'adresse de base d'Ollama se place dans ChatOptions.BaseUrl, pas dans l'objet d'options du fournisseur. Elle est transmise en interne à OllamaOptions.Host, et c'est le seul fournisseur pour lequel BaseUrl est lue.

La fiche se fige pendant une longue réponse

Chat et ChatStream sont synchrones. Sur Delphi 2010 et ultérieur, utilise ChatAsync, qui renvoie un IsgcFuture<string>. Sur les compilateurs plus anciens, exécute l'appel dans ton propre thread.

Le nom du modèle est rejeté

Les noms de modèles appartiennent au fournisseur, pas au composant, et ils changent. ChatOptions.Model est transmis tel quel, donc un nom qui fonctionne dans la console du fournisseur fonctionne ici.

La facture grossit sur une longue conversation

Le composant rejoue l'historique à chaque appel, ce qui permet à une question de suivi de fonctionner. Plafonne-le avec MaxHistoryMessages et repars de zéro avec ClearHistory.

Aller plus loin

Ce que les gens construisent après la première réponse

Une zone de saisie n'est que le début. Ces quatre éléments sont déjà dans le package.

Répondre à partir de tes propres documents

Transforme ton contenu en vecteurs avec TsgcAIOpenAIEmbeddings, stocke-les dans TsgcAIDatabaseVectorFile ou TsgcAIDatabaseVectorPinecone, et récupère les passages les plus proches à placer dans le prompt.

Référence des embeddings et référence des bases de données vectorielles

Lui parler à voix haute

TsgcAIOpenAIChatBot réunit en un seul composant un enregistreur, la transcription, l'appel de chat et la synthèse vocale. TsgcAIOpenAITranslator fait de même pour la traduction en direct.

Référence du ChatBot et référence du traducteur

Exposer ton application à un agent

Le composant serveur MCP transforme ton application en outil qu'un assistant peut appeler, et le client MCP consomme d'autres serveurs. Aucun des deux n'est limité à Windows, donc un serveur MCP écrit en Delphi fonctionne sous Linux.

Référence du serveur MCP et référence du client MCP

Utiliser toute l'API du fournisseur

La vision, les documents, la réflexion étendue, les lots, la génération d'images, la transcription et la modération se trouvent sur les clients REST par fournisseur plutôt que sur la couche de chat neutre.

Référence OpenAI et référence Anthropic

Ressources

Référence, démos et documentation

Les pages de référence documentent chaque option et chaque événement. Les projets de démo sont livrés dans le téléchargement, sous Demos\15.AI.

	Guide, appeler un LLM depuis Delphi Le pas à pas détaillé : streaming, appel d'outils, et hébergé contre local.	Ouvrir
	Référence, client OpenAI Chaque méthode, option et événement de `TsgcHTTP_API_OpenAI`.	Ouvrir
	Référence, client Anthropic Messages, outils, vision, lots et comptage de tokens sur `TsgcHTTP_API_Anthropic`.	Ouvrir
	Référence, serveur MCP Le composant qui permet à un assistant d'appeler ton application.	Ouvrir
	Page du composant TsgcAIChat Chaque propriété et événement du composant de chat, avec les quatorze autres liés depuis celle-ci.	Ouvrir
	Aide en ligne La référence générée, toujours en phase avec la version actuelle.	Ouvrir

Lectures associées : créer des applications Delphi dopées à l'IA, comparer les fournisseurs depuis Delphi et écrire un serveur MCP. Chaque produit a son propre démarrage rapide, listé sur la page de prise en main.

FAQ

Questions sur le démarrage rapide de sgcAI

Dépose TsgcAIChat depuis la page de palette SGC AI. Il est déclaré dans sgcAI.pas comme enveloppe publiée autour de TsgcAI_Chat, lui-même déclaré dans sgcAI_Chat.pas. Le code qui crée l'objet à l'exécution, comme le font les démos livrées, utilise TsgcAI_Chat et uses sgcAI_Chat;. Les deux te donnent les mêmes propriétés.

Dans sgcWebSockets, le verrou est SGC_AI, défini à la ligne 796 de sgcVer.inc, dans le bloc SGC_EDT_ENT qui va de la ligne 759 à la ligne 842. C'est l'édition Enterprise et supérieures. Standard, lignes 674 à 723, et Professional, lignes 726 à 757, ne le définissent pas. Si tu ne veux pas le reste de la bibliothèque, le package sgcAI autonome définit SGC_PACK_AI à la ligne 857, dont le propre bloc des lignes 946 à 959 active les mêmes composants.

Oui. SGC_AI est défini sans garde de plateforme, à la ligne 796 dans le bloc Enterprise et à la ligne 947 dans le bloc du pack autonome, donc sgcAI_Chat.pas et sgcAI.pas se compilent pour Windows, macOS, Linux, iOS et Android, et TsgcAIChat porte ComponentPlatforms(0). Les exceptions sont TsgcAudioRecorderMCI, TsgcAudioRecorderWave, TsgcAudioPlayerMCI et TsgcTextToSpeechSystem, qui appellent des API audio et vocales de Windows et ne sont compilés que sous Windows. Les appels HTTPS demandent la configuration TLS habituelle de chaque plateforme, par exemple les bibliothèques OpenSSL sous Linux.

Change Provider. Il accepte aicpOpenAI, aicpAnthropic, aicpGemini, aicpDeepSeek, aicpOllama, aicpGrok et aicpMistral. Définis ensuite la clé et le modèle de ce fournisseur. Pour aicpOllama il n'y a pas de clé, et si le serveur n'est pas à l'adresse par défaut, tu définis ChatOptions.BaseUrl, que le composant transmet en interne au client Ollama.

Appelle ChatStream plutôt que Chat, et gère OnChatStream. Sa signature est procedure(Sender: TObject; const aChunk: string; var Cancel: Boolean) : ajoute aChunk à ton mémo au fur et à mesure de son arrivée, et mets Cancel à True pour arrêter la génération plus tôt.

Chat et ChatStream ne lèvent pas d'exception. Ils interceptent l'exception, déclenchent OnChatError avec le message, et renvoient une chaîne vide. Un OnChatError non géré ressemble donc exactement à un modèle qui a répondu par du vide. Branche-le en premier.

Sur Delphi 2010 et ultérieur, appelle ChatAsync, qui est entouré de {$IFDEF D2010} et renvoie un IsgcFuture<string>. Sur Delphi 7 à 2009, cette méthode n'existe pas, exécute donc Chat dans un thread que tu crées toi-même.

Oui. Il conserve l'échange et le rejoue à l'appel suivant, ce qui permet à une question de suivi de fonctionner. MaxHistoryMessages plafonne la quantité rejouée, ClearHistory démarre une nouvelle conversation et GetHistory renvoie les messages stockés.

sgcAI en cinq minutes