Mistral Delphi API Client

15. April 2026 · Komponenten

Mistral AI hat sich als führender europäischer KI-Anbieter etabliert und liefert leistungsstarke Modelle, die in mehrsprachigem Verständnis, Codegenerierung, Function Calling und strukturierten Ausgaben glänzen. Für Delphi-Entwickler, die Mistral in ihre Anwendungen integrieren möchten, bietet sgcWebSockets TsgcHTTP_API_Mistral — eine umfassende, native Komponente, die die gesamte Mistral-API mit sauberem, typsicherem Delphi-Code kapselt.

Egal, ob du intelligente Chatbots baust, strukturierte JSON-Ausgaben erzeugst, Bilder analysierst, Embeddings für semantische Suche erstellst oder werkzeuggestützte Workflows orchestrierst — diese Komponente verschafft dir direkten Zugriff auf jede Mistral-Funktion. Kein REST-Boilerplate. Kein JSON-Gefummel. Komponente ablegen, API-Key setzen und loslegen.

Vollständige API-Abdeckung

Jede wichtige Funktion der Mistral-API wird out of the box unterstützt.

Chat Completions Sende Nachrichten mit System Prompts, empfange Antworten synchron oder gestreamt. Volle Kontrolle über Temperatur, Top-p und Stopp-Sequenzen.	Echtzeit-Streaming Streame Antworten Token für Token per Server-Sent Events. Baue responsive Oberflächen, die Antworten während der Generierung anzeigen.	Vision Analysiere Bilder, indem du base64-codierte Daten oder Bild-URLs zusammen mit Text-Prompts sendest. Pixtral-Modelle beschreiben, interpretieren und argumentieren über visuelle Inhalte.
JSON-Modus Zwinge Mistral, gültiges JSON zurückzugeben. Ideal für Datenextraktion, strukturierte Antworten und API-Integrations-Pipelines.	Tool Use — Function Calling Definiere eigene Tools mit JSON Schema. Mistral entscheidet, wann es sie aufruft, und ermöglicht agentische, mehrstufige Workflows.	Embeddings Erzeuge hochwertige Vektor-Embeddings. Treibe semantische Suche, Clustering, Klassifikation und Empfehlungssysteme an.
Safe Prompt Aktiviere Mistrals eingebaute Sicherheitsleitplanken mit einer einzigen Eigenschaft. Filtere schädliche oder unangemessene Inhalte automatisch heraus.	Modellverwaltung Liste alle verfügbaren Mistral-Modelle programmatisch auf. Frage Modell-IDs, Eigentümer, Erstellungsdaten und Fähigkeiten ab.	Eingebautes Retry & Logging Automatisches Retry bei vorübergehenden Fehlern mit konfigurierbaren Versuchen und Wartezeiten. Vollständiges Request-/Response-Logging fürs Debugging.

Erste Schritte

Integriere Mistral AI in unter einer Minute in dein Delphi-Projekt. Komponente ablegen, API-Key konfigurieren und erste Nachricht senden.

// Create the component and configure the API key
var
  Mistral: TsgcHTTP_API_Mistral;
  vResponse: string;
begin
  Mistral := TsgcHTTP_API_Mistral.Create(nil);
  Try
    Mistral.MistralOptions.ApiKey := 'YOUR_API_KEY';
    // Send a simple message to Mistral
    vResponse := Mistral._CreateMessage(
      'mistral-large-latest', 'Hello, Mistral!');
    ShowMessage(vResponse);
  Finally
    Mistral.Free;
  End;
end;

Zwei API-Stile. Jede Funktion bietet sowohl Convenience-Methoden (string-basiert, minimaler Code) als auch typisierte Request-/Response-Klassen (volle Kontrolle, Typsicherheit). Wähle den Ansatz, der am besten zu deinem Anwendungsfall passt.

Chat Completions & Streaming

Die Chat-Completions-API ist die Grundlage jeder Mistral-Interaktion. Sende Text mit optionalen System Prompts und empfange Antworten synchron oder per Stream in Echtzeit.

System Prompts

Steuere Mistrals Verhalten, indem du einen System Prompt mitgibst, der Kontext, Persönlichkeit oder Einschränkungen für die Konversation festlegt.

vResponse := Mistral._CreateMessageWithSystem(
  'mistral-large-latest',
  '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 responsive Benutzeroberflächen streamst du Mistrals Antwort Token für Token per Server-Sent Events. Weise den Event-Handler OnHTTPAPISSE zu und rufe _CreateMessageStream auf.

// Enable streaming via SSE
Mistral.OnHTTPAPISSE := OnSSEEvent;
Mistral._CreateMessageStream('mistral-large-latest',
  '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;

Fortgeschrittene typisierte API

Für die volle Kontrolle über Anfrageparameter — Temperatur, Top-p, Stopp-Sequenzen, Random Seed, Safe Prompt — verwendest du die typisierten Request- und Response-Klassen.

var
  oRequest: TsgcMistralClass_Request_ChatCompletion;
  oMessage: TsgcMistralClass_Request_Message;
  oResponse: TsgcMistralClass_Response_ChatCompletion;
begin
  oRequest := TsgcMistralClass_Request_ChatCompletion.Create;
  Try
    oRequest.Model := 'mistral-large-latest';
    oRequest.MaxTokens := 2048;
    oRequest.Temperature := 0.7;
    oRequest.TopP := 0.9;
    oRequest.SafePrompt := True;
    oRequest.RandomSeed := 42;
    oMessage := TsgcMistralClass_Request_Message.Create;
    oMessage.Role := 'user';
    oMessage.Content := 'Explain quantum computing in simple terms.';
    oRequest.Messages.Add(oMessage);
    oResponse := Mistral.CreateMessage(oRequest);
    Try
      if Length(oResponse.Choices) > 0 then
        ShowMessage(oResponse.Choices[0].Message.Content);
    Finally
      oResponse.Free;
    End;
  Finally
    oRequest.Free;
  End;
end;

Vision — Bildverständnis

Mistrals Pixtral-Modelle können Bilder analysieren und über sie argumentieren. Sende Fotos, Screenshots, Diagramme oder Dokumente zusammen mit einem Text-Prompt und erhalte detaillierte Beschreibungen, Datenextraktion oder visuelle Q&A.

// Load an image and ask Mistral to analyze it
var
  vBase64: string;
begin
  vBase64 := sgcBase64Encode(LoadFileToBytes('architecture-diagram.png'));
  ShowMessage(Mistral._CreateVisionMessage(
    'pixtral-large-latest',
    'Describe the architecture shown in this diagram.',
    vBase64, 'image/png'));
end;

Anwendungsfall. Automatisiere die Dokumentenanalyse, extrahiere Daten aus Diagrammen, klassifiziere Bilder oder baue visuelles Verständnis in deine Workflows ein — alles aus nativem Delphi-Code.

JSON-Modus

Zwinge Mistral, gültiges, parsebares JSON zurückzugeben. Der JSON-Modus eignet sich perfekt für Datenextraktion, strukturierte API-Antworten und automatisierte Verarbeitungs-Pipelines, in denen du garantiert maschinenlesbare Ausgaben brauchst.

// Generate structured JSON output
vResponse := Mistral._CreateMessageJSON(
  'mistral-large-latest',
  'Extract the name, age, and city from: John is 30, lives in Madrid.');
// Returns: {"name": "John", "age": 30, "city": "Madrid"}
// Using the typed API for JSON mode
oRequest.ResponseFormat := 'json_object';

Tool Use — Function Calling

Definiere eigene Tools mit JSON Schema; Mistral entscheidet, wann und wie sie aufgerufen werden. Das ist die Grundlage für agentische, mehrstufige Workflows, die die KI mit deiner Geschäftslogik verbinden.

// Define a tool with JSON Schema
oTool := TsgcMistralClass_Request_Tool.Create;
oTool.FunctionName := 'get_weather';
oTool.FunctionDescription := 'Get the current weather in a location';
oTool.FunctionParameters :=
  '{"type":"object","properties":{"location":{"type":"string",' +
  '"description":"City and country"}},"required":["location"]}';
oRequest.Tools.Add(oTool);
oRequest.ToolChoice := 'auto';
oResponse := Mistral.CreateMessage(oRequest);
// Check if Mistral 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;

Embeddings

Erzeuge mit Mistrals Embedding-Modellen hochwertige Vektor-Embeddings für Texte. Embeddings treiben semantische Suche, Dokumenten-Clustering, Empfehlungssysteme und Klassifikationsaufgaben an.

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

Für die volle Kontrolle nutzt du die typisierte API, um mehrere Eingaben zu bündeln und das Codierungsformat auszuwählen.

var
  oRequest: TsgcMistralClass_Request_Embeddings;
  oResponse: TsgcMistralClass_Response_Embeddings;
begin
  oRequest := TsgcMistralClass_Request_Embeddings.Create;
  Try
    oRequest.Model := 'mistral-embed';
    oRequest.Input.Add('First document to embed');
    oRequest.Input.Add('Second document to embed');
    oRequest.EncodingFormat := 'float';
    oResponse := Mistral.CreateEmbeddings(oRequest);
    Try
      ShowMessage('Embeddings: ' + IntToStr(Length(oResponse.Data)));
      ShowMessage('Tokens used: ' + IntToStr(oResponse.Usage.TotalTokens));
    Finally
      oResponse.Free;
    End;
  Finally
    oRequest.Free;
  End;
end;

Safe Prompt

Mistral bietet eine eingebaute Sicherheitsschicht, die sich mit einer einzigen Eigenschaft aktivieren lässt. Wenn SafePrompt aktiviert ist, wird automatisch ein sicherheitsorientierter System Prompt vorangestellt, um schädliche oder unangemessene Inhalte herauszufiltern.

// Enable safety guardrails
oRequest.SafePrompt := True;

Reproduzierbare Ergebnisse. Setze RandomSeed auf einen festen Wert, um deterministische Ausgaben zu erhalten. In Kombination mit Temperature := 0 sorgt das für identische Antworten bei derselben Eingabe — ideal für Test- und Validierungs-Pipelines.

Modellverwaltung

Frage verfügbare Mistral-Modelle programmatisch ab. Liste alle Modelle auf, um neue Fähigkeiten zu entdecken, sobald sie verfügbar werden.

// List all available Mistral models
vModels := Mistral._GetModels;
// Typed API: access model properties directly
var
  oModels: TsgcMistralClass_Response_Models;
  i: Integer;
begin
  oModels := Mistral.GetModels;
  Try
    for i := 0 to Length(oModels.Data) - 1 do
      Memo1.Lines.Add(oModels.Data[i].Id + ' (by ' +
        oModels.Data[i].OwnedBy + ')');
  Finally
    oModels.Free;
  End;
end;

Konfiguration & Optionen

Stelle das Verhalten der Komponente über umfangreiche Konfigurationsoptionen fein ein.

Eigenschaft	Beschreibung
`MistralOptions.ApiKey`	Dein Mistral-API-Key (erforderlich)
`HttpOptions.ReadTimeout`	HTTP-Read-Timeout in Millisekunden (Standard: 60000)
`LogOptions.Enabled`	Request-/Response-Logging aktivieren
`RetryOptions.Enabled`	Automatisches Retry bei vorübergehenden Fehlern
`RetryOptions.Retries`	Maximale Anzahl an Wiederholungsversuchen (Standard: 3)
`RetryOptions.Wait`	Wartezeit zwischen Versuchen in Millisekunden (Standard: 3000)

Anfrageparameter

Parameter	Beschreibung
`Temperature`	Sampling-Temperatur (0,0–2,0). Niedrigere Werte = deterministischer.
`TopP`	Nucleus-Sampling (0,0–1,0). Steuert die kumulative Wahrscheinlichkeitsgrenze.
`MaxTokens`	Maximale Anzahl an Tokens in der Antwort (Standard: 4096).
`SafePrompt`	Aktiviert eingebaute Sicherheitsleitplanken zum Filtern von Inhalten.
`RandomSeed`	Fester Seed für reproduzierbare Ausgaben. Ideal für Tests.
`ResponseFormat`	Auf 'json_object' setzen für garantierte JSON-Ausgabe.
`ToolChoice`	Steuert die Tool-Auswahl: 'auto', 'none' oder 'required'.

Europäischer KI-Vorteil. Mistral hat seinen Hauptsitz in Frankreich und bietet EU-gehostete Inferenz, was es zu einer ausgezeichneten Wahl für Organisationen mit europäischen Datenresidenz-Anforderungen macht. In Kombination mit der eingebauten Retry-Logik, dem Logging und der typsicheren API der sgcWebSockets-Komponente erhältst du eine produktionsreife KI-Integration mit voller regulatorischer Konformität.