DeepSeek Delphi-API-Client

14. April 2026 · Komponenten

DeepSeek hat sich rasch zu einem der kostengünstigsten und leistungsfähigsten Anbieter von KI-Modellen entwickelt und bietet starke Reasoning-, Vision- und Tool-Calling-Funktionen zu einem Bruchteil der Kosten konkurrierender Dienste. Für Delphi-Entwickler, die die Modelle von DeepSeek nutzen möchten, stellt sgcWebSockets TsgcHTTP_API_DeepSeek bereit — eine native Komponente, die die gesamte DeepSeek-API in sauberem, typsicherem Delphi-Code kapselt.

Ob du intelligente Chatbots baust, Bilder verarbeitest, Function-Calling-Workflows orchestrierst oder Antworten in Echtzeit an deine Nutzer streamst — diese Komponente bietet dir direkten Zugriff auf jede DeepSeek-Funktion. Kein REST-Boilerplate. Kein JSON-Gefummel. Einfach die Komponente platzieren, deinen API-Schlüssel setzen und loslegen.

Vollständige API-Abdeckung

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

Chat Completions Sende Nachrichten mit System-Prompts und empfange Antworten synchron oder gestreamt. Volle Kontrolle über Temperature, Top-p sowie Frequency- und Presence-Penalties.	Echtzeit-Streaming Streame Antworten Token für Token über Server-Sent Events. Baue reaktionsschnelle Oberflächen, die Antworten direkt während der Generierung anzeigen.	Vision Analysiere Bilder, indem du Base64-kodierte Daten oder Bild-URLs zusammen mit Text-Prompts sendest. DeepSeek beschreibt, interpretiert und argumentiert über visuelle Inhalte.
Tool-Nutzung — Function Calling Definiere eigene Tools per JSON-Schema. DeepSeek entscheidet, wann sie aufgerufen werden, und ermöglicht so agentische, mehrstufige Workflows.	Modellverwaltung Liste alle verfügbaren DeepSeek-Modelle programmatisch auf. Frage Modell-IDs, Besitzer und Fähigkeiten ab.	Integrierter Retry & Logging Automatisches Wiederholen bei vorübergehenden Fehlern mit konfigurierbaren Versuchen und Wartezeiten. Vollständiges Request/Response-Logging zum Debuggen.

Erste Schritte

Integriere DeepSeek in weniger als einer Minute in dein Delphi-Projekt. Platziere die Komponente, konfiguriere deinen API-Schlüssel und sende deine erste Nachricht.

// Create the component and configure the API key
var
  DeepSeek: TsgcHTTP_API_DeepSeek;
  vResponse: string;
begin
  DeepSeek := TsgcHTTP_API_DeepSeek.Create(nil);
  Try
    DeepSeek.DeepSeekOptions.ApiKey := 'YOUR_API_KEY';
    // Send a simple message to DeepSeek
    vResponse := DeepSeek._CreateMessage(
      'deepseek-chat', 'Hello, DeepSeek!');
    ShowMessage(vResponse);
  Finally
    DeepSeek.Free;
  End;
end;

Zwei API-Stile. Jede Funktion bietet sowohl Convenience-Methoden (stringbasiert, 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 Interaktion mit DeepSeek. Sende Text mit optionalen System-Prompts und empfange Antworten synchron oder in Echtzeit gestreamt.

System-Prompts

Steuere das Verhalten von DeepSeek, indem du einen System-Prompt vorgibst, der Kontext, Persönlichkeit oder Einschränkungen der Konversation festlegt.

vResponse := DeepSeek._CreateMessageWithSystem(
  'deepseek-chat',
  '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 Oberflächen streamst du die Antwort von DeepSeek Token für Token über Server-Sent Events. Weise den Ereignishandler OnHTTPAPISSE zu und rufe _CreateMessageStream auf.

// Enable streaming via SSE
DeepSeek.OnHTTPAPISSE := OnSSEEvent;
DeepSeek._CreateMessageStream('deepseek-chat',
  '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;

Erweiterte typisierte API

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

var
  oRequest: TsgcDeepSeekClass_Request_ChatCompletion;
  oMessage: TsgcDeepSeekClass_Request_Message;
  oResponse: TsgcDeepSeekClass_Response_ChatCompletion;
begin
  oRequest := TsgcDeepSeekClass_Request_ChatCompletion.Create;
  Try
    oRequest.Model := 'deepseek-chat';
    oRequest.MaxTokens := 2048;
    oRequest.Temperature := 0.7;
    oRequest.TopP := 0.9;
    oRequest.FrequencyPenalty := 0.5;
    oMessage := TsgcDeepSeekClass_Request_Message.Create;
    oMessage.Role := 'user';
    oMessage.Content := 'Explain quantum computing in simple terms.';
    oRequest.Messages.Add(oMessage);
    oResponse := DeepSeek.CreateMessage(oRequest);
    Try
      if Length(oResponse.Choices) > 0 then
        ShowMessage(oResponse.Choices[0].MessageContent);
    Finally
      oResponse.Free;
    End;
  Finally
    oRequest.Free;
  End;
end;

Vision — Bildverständnis

DeepSeek kann Bilder analysieren und über sie argumentieren. Sende Fotos, Screenshots, Diagramme oder Dokumente zusammen mit einem Text-Prompt und erhalte detaillierte Beschreibungen, extrahierte Daten oder visuelle Q&A-Antworten.

// Load an image and ask DeepSeek to analyze it
var
  vBase64: string;
begin
  vBase64 := sgcBase64Encode(LoadFileToBytes('invoice.png'));
  ShowMessage(DeepSeek._CreateVisionMessage(
    'deepseek-chat',
    'Extract all line items and totals from this invoice.',
    vBase64, 'image/png'));
end;

Anwendungsfall. Automatisiere die Rechnungsverarbeitung, extrahiere Text aus Dokumenten, analysiere Diagramme und Grafiken oder baue Pipelines zur Bildklassifizierung — alles aus nativem Delphi-Code und zu den konkurrenzfähigen Preisen von DeepSeek.

Tool-Nutzung — Function Calling

Definiere eigene Tools per JSON-Schema, und DeepSeek 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 := TsgcDeepSeekClass_Request_Tool.Create;
oTool.Name := 'get_stock_price';
oTool.Description := 'Get the current stock price for a ticker symbol';
oTool.Parameters :=
  '{"type":"object","properties":{"symbol":{"type":"string",' +
  '"description":"Stock ticker symbol"}},"required":["symbol"]}';
oRequest.Tools.Add(oTool);
oResponse := DeepSeek.CreateMessage(oRequest);
// Check if DeepSeek wants to call a tool
if oResponse.Choices[0].FinishReason = 'tool_calls' then
begin
  for i := 0 to Length(oResponse.Choices[0].ToolCalls) - 1 do
  begin
    vToolId   := oResponse.Choices[0].ToolCalls[i].Id;
    vFuncName := oResponse.Choices[0].ToolCalls[i].FunctionName;
    vFuncArgs := oResponse.Choices[0].ToolCalls[i].FunctionArguments;
    // Execute the tool and return the result
  end;
end;

Modellverwaltung

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

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

Konfiguration & Optionen

Feinabstimmung des Komponentenverhaltens über umfassende Konfigurationsoptionen.

Eigenschaft	Beschreibung
`DeepSeekOptions.ApiKey`	Dein DeepSeek-API-Schlüssel (Pflichtfeld)
`HttpOptions.ReadTimeout`	HTTP-Lese-Timeout in Millisekunden (Standard: 60000)
`LogOptions.Enabled`	Aktiviert das Request/Response-Logging
`RetryOptions.Enabled`	Automatisches Wiederholen bei vorübergehenden Fehlern
`RetryOptions.Retries`	Maximale Anzahl an Wiederholungsversuchen (Standard: 3)
`RetryOptions.Wait`	Wartezeit zwischen Versuchen in Millisekunden (Standard: 3000)

Request-Parameter

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 Tokens in der Antwort (Standard: 4096).
`FrequencyPenalty`	Bestraft Tokens basierend auf ihrer bisherigen Häufigkeit im Text.
`PresencePenalty`	Bestraft Tokens danach, ob sie bislang im Text vorkamen.
`ToolChoice`	Steuert die Tool-Auswahl: 'auto', 'none' oder 'required'.

Kostenvorteil. DeepSeek-Modelle liefern konkurrenzfähige Qualität zu deutlich niedrigeren Preisen als vergleichbare Anbieter. Zusammen mit der integrierten Retry-Logik und dem Logging der sgcWebSockets-Komponente erhältst du eine produktionsreife KI-Integration zu einem Bruchteil der Kosten.