Ollama-API-Client für Delphi

15. April 2026 · Komponenten

Mit Ollama kannst du Large Language Models einfach lokal auf deiner eigenen Hardware betreiben — ohne Cloud-Abhängigkeit, ohne API-Kosten und mit vollständigem Datenschutz. Für Delphi-Entwickler, die lokale KI-Funktionen in ihre Anwendungen integrieren möchten, bietet sgcWebSockets TsgcHTTP_API_Ollama — eine native Komponente, die die gesamte Ollama-API mit sauberem, typsicherem Delphi-Code kapselt.

Egal ob du sensible Daten on-premises halten, offline-fähige KI-Funktionen entwickeln, deine eigene Modellbibliothek verwalten oder Embeddings für lokale Vektorsuche erzeugen willst – diese Komponente gibt dir direkten Zugriff auf jede Ollama-Funktion. Keine Cloud-Konten. Keine wiederkehrenden API-Gebühren. Lege einfach die Komponente ab, richte sie auf deine Ollama-Instanz und leg los.

Vollständige API-Abdeckung

Alle wichtigen Funktionen der Ollama-API werden von Haus aus unterstützt.

Chat Completions Sende Nachrichten mit System-Prompts und empfange Antworten synchron oder gestreamt. Volle Kontrolle über Temperature, Top-p und Stop-Sequenzen.	Echtzeit-Streaming Streame Antworten Token für Token über Server-Sent Events. Baue reaktionsschnelle UIs mit lokal laufenden Modellen.	Modellverwaltung Modelle programmatisch pullen, Details anzeigen, Tags auflisten und löschen. Vollständiges Lifecycle-Management aus Delphi-Code.
Embeddings Erzeuge Vektor-Embeddings lokal. Treibe semantische Suche, Clustering und Klassifikation an, ohne Daten in die Cloud zu senden.	Selbst gehostet / konfigurierbarer Host Verbinde dich mit jeder Ollama-Instanz über eine konfigurierbare Host-URL. Lass sie lokal, auf einem LAN-Server oder in einer privaten Cloud laufen.	Integriertes Retry & Logging Automatische Wiederholversuche bei vorübergehenden Fehlern mit konfigurierbaren Versuchen und Wartezeiten. Vollständiges Request-/Response-Logging zum Debuggen.

Erste Schritte

Integriere Ollama in unter einer Minute in dein Delphi-Projekt. Lege die Komponente ab, konfiguriere den Host und sende deine erste Nachricht.

// Create the component and configure the host
var
  Ollama: TsgcHTTP_API_Ollama;
  vResponse: string;
begin
  Ollama := TsgcHTTP_API_Ollama.Create(nil);
  Try
    Ollama.OllamaOptions.Host := 'http://localhost:11434';
    // Send a simple message to a local model
    vResponse := Ollama._CreateMessage(
      'llama3', 'Hello, Ollama!');
    ShowMessage(vResponse);
  Finally
    Ollama.Free;
  End;
end;

Kein API-Key erforderlich. Wenn du dich mit einer lokalen Ollama-Instanz verbindest, ist keine Authentifizierung nötig. Für entfernte oder abgesicherte Deployments kannst du optional einen API-Key über OllamaOptions.ApiKey setzen.

Chat Completions & Streaming

Die Chat-Completions-API funktioniert mit jedem Modell, das du in deine Ollama-Instanz gepullt hast. Sende Text mit optionalen System-Prompts und empfange Antworten synchron oder in Echtzeit gestreamt.

System-Prompts

Steuere das Verhalten des Modells, indem du einen System-Prompt bereitstellst, der Kontext, Persönlichkeit oder Einschränkungen für das Gespräch festlegt.

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

Echtzeit-Streaming

Für reaktionsschnelle Benutzeroberflächen kannst du die Antwort des Modells Token für Token über Server-Sent Events streamen.

// Enable 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: JSON payload with generated content
  Memo1.Lines.Add(aData);
end;

Erweiterte typisierte API

Für volle Kontrolle über die Request-Parameter — Temperature, Top-p, Stop-Sequenzen, Max-Tokens — verwende die typisierten Request- und Response-Klassen.

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;

Modellverwaltung

Verwalte deine gesamte lokale Modellbibliothek aus Delphi-Code. Pulle neue Modelle, sieh ihre Details ein, liste verfügbare Tags auf und lösche Modelle, die du nicht mehr brauchst — alles programmatisch.

Ein Modell pullen

// Download a model from the Ollama registry
Ollama._PullModel('llama3');

Modell-Details anzeigen

// Get detailed information about a model
vDetails := Ollama._ShowModel('llama3');
ShowMessage(vDetails);

Modelle und Tags auflisten

// List all models via OpenAI-compatible endpoint
vModels := Ollama._GetModels;
// List model tags with detailed metadata (name, size, digest)
vTags := Ollama._GetTags;
// Typed API: access tag properties directly
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;

Ein Modell löschen

// Remove a model from the local system
Ollama._DeleteModel('old-model:latest');

Embeddings

Erzeuge Vektor-Embeddings lokal mit jedem embedding-fähigen Modell. Embeddings treiben semantische Suche, Dokumenten-Clustering und Klassifikation an — alles, ohne Daten an externe Server zu senden.

// Generate embeddings locally
var
  vEmbedding: string;
begin
  vEmbedding := Ollama._CreateEmbeddings(
    'nomic-embed-text',
    'Delphi is a powerful programming language.');
  ShowMessage(vEmbedding);
end;

Für volle Kontrolle verwende die typisierte API, um auf die rohen Embedding-Werte zuzugreifen.

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;

Datenschutz. Mit Ollama verlassen deine Daten nie dein Netzwerk. Das macht es ideal für regulierte Branchen (Gesundheitswesen, Finanzen, Behörden), in denen Data-Residency und Datenschutz kritische Anforderungen sind.

Konfiguration & Optionen

Feinjustiere das Verhalten der Komponente mit umfassenden Konfigurationsoptionen.

Eigenschaft	Beschreibung
`OllamaOptions.Host`	URL des Ollama-Servers (z. B. http://localhost:11434)
`OllamaOptions.ApiKey`	Optionaler API-Key für abgesicherte Deployments
`HttpOptions.ReadTimeout`	HTTP-Read-Timeout in Millisekunden (Standard: 60000)
`LogOptions.Enabled`	Request-/Response-Logging aktivieren
`RetryOptions.Enabled`	Automatische Wiederholung bei vorübergehenden Fehlern
`RetryOptions.Retries`	Maximale Anzahl der Wiederholversuche (Standard: 3)
`RetryOptions.Wait`	Wartezeit zwischen Wiederholversuchen in Millisekunden (Standard: 3000)

Unterstützte Modelle

Ollama unterstützt Hunderte von Open-Source-Modellen. Hier sind einige beliebte Optionen:

Modell	Parameter	Ideal für
`llama3`	8B / 70B	Universelle Chats, Reasoning
`mistral`	7B	Schnelle, effiziente Textgenerierung
`codellama`	7B / 13B / 34B	Codegenerierung und -analyse
`nomic-embed-text`	137M	Text-Embeddings, semantische Suche

Null Kosten, volle Kontrolle. Führe KI-Modelle auf deiner eigenen Hardware aus, ohne Pro-Token-Gebühren. Kombiniert mit der eingebauten Retry-Logik und dem Logging von sgcWebSockets bekommst du eine produktionsreife lokale KI-Integration für Delphi.