Client API Ollama pour Delphi

15 avril 2026 · Composants

Ollama facilite l'exécution de grands modèles de langage en local, sur ton propre matériel — sans dépendance au cloud, sans coût d'API et avec une confidentialité totale des données. Pour les développeurs Delphi qui veulent intégrer des capacités d'IA locale dans leurs applications, sgcWebSockets fournit TsgcHTTP_API_Ollama — un composant natif qui encapsule toute l'API Ollama dans du code Delphi propre et fortement typé.

Que tu aies besoin de garder des données sensibles sur site, de construire des fonctionnalités d'IA capables de fonctionner hors-ligne, de gérer ta propre bibliothèque de modèles ou de générer des embeddings pour la recherche vectorielle locale, ce composant te donne un accès direct à toutes les fonctionnalités d'Ollama. Pas de comptes cloud. Pas de frais d'API récurrents. Pose le composant, pointe-le vers ton instance Ollama et commence à construire.

Couverture complète de l'API

Toutes les fonctionnalités majeures de l'API Ollama sont prises en charge dès l'installation.

Chat completions Envoie des messages avec des prompts système, reçois des réponses de façon synchrone ou en streaming. Contrôle total sur la température, top-p et les séquences d'arrêt.	Streaming en temps réel Diffuse les réponses jeton par jeton via Server-Sent Events. Construis des interfaces réactives avec des modèles exécutés en local.	Gestion des modèles Télécharge, affiche les détails, liste les tags et supprime les modèles par programmation. Gestion complète du cycle de vie depuis le code Delphi.
Embeddings Génère des embeddings vectoriels en local. Alimente la recherche sémantique, le clustering et la classification sans envoyer de données vers le cloud.	Auto-hébergé / hôte configurable Connecte-toi à n'importe quelle instance Ollama via une URL d'hôte configurable. Exécute en local, sur un serveur LAN ou dans un cloud privé.	Réessai et journalisation intégrés Réessai automatique en cas d'échecs transitoires avec nombre de tentatives et intervalles d'attente configurables. Journalisation complète des requêtes/réponses pour le débogage.

Premiers pas

Intègre Ollama dans ton projet Delphi en moins d'une minute. Pose le composant, configure l'hôte et envoie ton premier message.

// Créer le composant et configurer l'hôte
var
  Ollama: TsgcHTTP_API_Ollama;
  vResponse: string;
begin
  Ollama := TsgcHTTP_API_Ollama.Create(nil);
  Try
    Ollama.OllamaOptions.Host := 'http://localhost:11434';
    // Envoyer un message simple à un modèle local
    vResponse := Ollama._CreateMessage(
      'llama3', 'Hello, Ollama!');
    ShowMessage(vResponse);
  Finally
    Ollama.Free;
  End;
end;

Aucune clé API requise. Lors de la connexion à une instance Ollama locale, aucune authentification n'est nécessaire. Pour des déploiements distants ou sécurisés, tu peux éventuellement définir une clé API via OllamaOptions.ApiKey.

Chat completions et streaming

L'API Chat Completions fonctionne avec n'importe quel modèle que tu as téléchargé dans ton instance Ollama. Envoie du texte avec des prompts système optionnels et reçois les réponses de façon synchrone ou en streaming en temps réel.

Prompts système

Contrôle le comportement du modèle en fournissant un prompt système qui définit le contexte, la personnalité ou les contraintes de la conversation.

vResponse := Ollama._CreateMessageWithSystem(
  'llama3',
  'You are a helpful assistant that responds in Spanish.',
  'What is the capital of France?');
// Returns: "La capital de Francia es París."

Streaming en temps réel

Pour des interfaces utilisateur réactives, diffuse la réponse du modèle jeton par jeton via Server-Sent Events.

// Activer le streaming via SSE
Ollama.OnHTTPAPISSE := OnSSEEvent;
Ollama._CreateMessageStream('llama3',
  'Write a short poem about Delphi programming.');
procedure TForm1.OnSSEEvent(Sender: TObject;
  const aEvent, aData: string; var Cancel: Boolean);
begin
  // aData : charge JSON avec le contenu généré
  Memo1.Lines.Add(aData);
end;

API typée avancée

Pour un contrôle total sur les paramètres de requête — température, top-p, séquences d'arrêt, max tokens — utilise les classes de requête et de réponse typées.

var
  oRequest: TsgcOllamaClass_Request_ChatCompletion;
  oMessage: TsgcOllamaClass_Request_Message;
  oResponse: TsgcOllamaClass_Response_ChatCompletion;
begin
  oRequest := TsgcOllamaClass_Request_ChatCompletion.Create;
  Try
    oRequest.Model := 'llama3';
    oRequest.MaxTokens := 2048;
    oRequest.Temperature := 0.7;
    oMessage := TsgcOllamaClass_Request_Message.Create;
    oMessage.Role := 'user';
    oMessage.Content := 'Explain quantum computing in simple terms.';
    oRequest.Messages.Add(oMessage);
    oResponse := Ollama.CreateMessage(oRequest);
    Try
      if Length(oResponse.Choices) > 0 then
        ShowMessage(oResponse.Choices[0].MessageContent);
    Finally
      oResponse.Free;
    End;
  Finally
    oRequest.Free;
  End;
end;

Gestion des modèles

Gère toute ta bibliothèque locale de modèles depuis le code Delphi. Télécharge de nouveaux modèles, inspecte leurs détails, liste les tags disponibles et supprime les modèles dont tu n'as plus besoin — le tout par programmation.

Télécharger un modèle

// Télécharger un modèle depuis le registre Ollama
Ollama._PullModel('llama3');

Afficher les détails d'un modèle

// Obtenir des informations détaillées sur un modèle
vDetails := Ollama._ShowModel('llama3');
ShowMessage(vDetails);

Lister les modèles et les tags

// Lister tous les modèles via l'endpoint compatible OpenAI
vModels := Ollama._GetModels;
// Lister les tags des modèles avec les métadonnées détaillées (nom, taille, digest)
vTags := Ollama._GetTags;
// API typée : accéder directement aux propriétés des tags
var
  oTags: TsgcOllamaClass_Response_Tags;
  i: Integer;
begin
  oTags := Ollama.GetTags;
  Try
    for i := 0 to Length(oTags.Models) - 1 do
      Memo1.Lines.Add(Format('%s (%d bytes)',
        [oTags.Models[i].Name, oTags.Models[i].Size]));
  Finally
    oTags.Free;
  End;
end;

Supprimer un modèle

// Retirer un modèle du système local
Ollama._DeleteModel('old-model:latest');

Embeddings

Génère des embeddings vectoriels en local avec n'importe quel modèle d'embeddings. Les embeddings alimentent la recherche sémantique, le clustering de documents et la classification — le tout sans envoyer de données vers des serveurs externes.

// Générer des embeddings en local
var
  vEmbedding: string;
begin
  vEmbedding := Ollama._CreateEmbeddings(
    'nomic-embed-text',
    'Delphi is a powerful programming language.');
  ShowMessage(vEmbedding);
end;

Pour un contrôle total, utilise l'API typée pour accéder aux valeurs brutes des embeddings.

var
  oResponse: TsgcOllamaClass_Response_Embeddings;
  i: Integer;
begin
  oResponse := Ollama.CreateEmbeddings(
    'nomic-embed-text',
    'Delphi is a powerful programming language.');
  Try
    for i := 0 to oResponse.EmbeddingCount - 1 do
      Memo1.Lines.Add(FloatToStr(oResponse.GetEmbeddingValue(i)));
  Finally
    oResponse.Free;
  End;
end;

Confidentialité des données. Avec Ollama, tes données ne quittent jamais ton réseau. C'est idéal pour les secteurs réglementés (santé, finance, secteur public) où la résidence des données et la confidentialité sont des exigences critiques.

Configuration et options

Affine le comportement du composant grâce à des options de configuration complètes.

Propriété	Description
`OllamaOptions.Host`	URL du serveur Ollama (par exemple http://localhost:11434)
`OllamaOptions.ApiKey`	Clé API optionnelle pour les déploiements sécurisés
`HttpOptions.ReadTimeout`	Délai d'expiration de lecture HTTP en millisecondes (par défaut : 60000)
`LogOptions.Enabled`	Active la journalisation des requêtes/réponses
`RetryOptions.Enabled`	Réessai automatique en cas d'échecs transitoires
`RetryOptions.Retries`	Nombre maximum de tentatives de réessai (par défaut : 3)
`RetryOptions.Wait`	Temps d'attente entre les tentatives en millisecondes (par défaut : 3000)

Modèles pris en charge

Ollama prend en charge des centaines de modèles open source. Voici quelques choix populaires :

Modèle	Paramètres	Idéal pour
`llama3`	8B / 70B	Chat polyvalent, raisonnement
`mistral`	7B	Génération de texte rapide et efficace
`codellama`	7B / 13B / 34B	Génération et analyse de code
`nomic-embed-text`	137M	Embeddings de texte, recherche sémantique

Coût nul, contrôle total. Exécute des modèles d'IA sur ton propre matériel sans frais par jeton. Combiné à la logique de réessai et à la journalisation intégrées de sgcWebSockets, tu obtiens une intégration d'IA locale prête pour la production en Delphi.