Anthropic Claude in Delphi — Komplettes Tutorial (2026)

28. Mai 2026 · Components

Warum eine native Delphi-Komponente für Claude?

Anthropic Claude gehört zu den leistungsfähigsten KI-Familien auf dem Markt, aber jedes öffentliche Beispiel nutzt Python oder Node. Für Delphi- und C++Builder-Entwickler heißt das Aufrufen der REST-Endpunkte von Hand: JSON selbst zusammenbauen, Server-Sent Events jonglieren, TLS verwalten, Rate Limits handhaben und Boilerplate jedes Mal neu schreiben, wenn Anthropic ein neues Feature ausliefert — was etwa alle drei Monate passiert. Die mit sgcWebSockets ausgelieferte Komponente TsgcHTTP_API_Anthropic beseitigt diese Reibung. Sie ist ein streng typisierter Wrapper über die gesamte Anthropic-Oberfläche — Messages, Streaming, Vision, Tool Use, Extended Thinking, Prompt Caching, Files, Batches und der Model-Context-Protocol-Connector — den du auf ein Formular ziehen und in jeder VCL-, FMX- oder Konsolen-Anwendung nutzen kannst.

Dieses Tutorial geht jede wichtige Fähigkeit mit funktionierendem Delphi-Code durch. Am Ende kannst du einen Chat-Client, einen Vision-fähigen Dokumentenanalysator, einen agentischen Tool-Runner und eine kostenoptimierte Produktions-Pipeline bauen. Alle Snippets zielen auf die aktuellen Modelle claude-sonnet-4-20250514 und claude-opus-4-20250514 und laufen unverändert von Delphi 7 bis Delphi 13.

Eine kurze Anmerkung zur Philosophie, bevor wir loslegen. Die Komponente gibt absichtlich zwei Oberflächen frei. Die „Quick“-Oberfläche (Methoden wie _CreateMessage, _CreateMessageStream, _CreateMessageWithImage) akzeptiert ein paar Strings und liefert einen String — perfekt für Prototypen, Demos und die 80 % der Aufrufe, bei denen Temperature, Top-p, Metadata oder Stop-Sequences keine Rolle spielen. Die „typisierte“ Oberfläche (Klassen wie TsgcAnthropicClass_Request_Messages und TsgcAnthropicClass_Response_Messages) gibt dir volle Kontrolle über jeden Parameter, den die Anthropic-API unterstützt — mit starker Typisierung und IDE-Autovervollständigung. Nutze die Quick-API zum Lernen; promote in die typisierte API für die Produktion. Eine Komponente, zwei Schichten, keine Duplikation.

1. Setup und deine erste Nachricht

Füge sgcHTTP_API_Anthropic deiner uses-Klausel hinzu, erzeuge die Komponente, setze deinen API-Key (hol einen von console.anthropic.com) und rufe _CreateMessage auf. Das ist das absolute Minimum, um mit Claude zu reden.

uses
  sgcHTTP_API_Anthropic;

var
  oClaude: TsgcHTTP_API_Anthropic;
  vReply : string;
begin
  oClaude := TsgcHTTP_API_Anthropic.Create(nil);
  try
    oClaude.AnthropicOptions.ApiKey := 'sk-ant-api03-...';
    vReply := oClaude._CreateMessage(
      'claude-sonnet-4-20250514',
      'Write a haiku about Pascal compilers.');
    ShowMessage(vReply);
  finally
    oClaude.Free;
  end;
end;

Die Komponente erledigt die Schwerarbeit: Sie baut den JSON-Request-Body, setzt die Header x-api-key und anthropic-version, postet an /v1/messages und parst die Antwort in einen einfachen Delphi-String. Wenn du volle Kontrolle über die Request-Parameter brauchst, nutze die typisierte Klasse TsgcAnthropicClass_Request_Messages.

Ein operativer Hinweis: Bake den API-Key niemals in die Binary. Lies ihn aus einer Umgebungsvariable, einem Registrierungsschlüssel oder einem Secrets-Manager. Anthropic scannt mittlerweile GitHub nach geleakten Keys und sperrt sie automatisch — du willst nicht freitags um 18 Uhr ein Update ausliefern, weil jemand deine .pas-Datei abgelichtet hat.

2. Streaming-Antworten mit SSE

Synchrone Aufrufe sind für kurze Prompts in Ordnung, aber für eine Chat-UI willst du, dass Tokens erscheinen, während Claude sie erzeugt. Anthropic streamt Antworten als Server-Sent Events, und die Komponente legt sie über das Event OnHTTPAPISSE frei.

procedure TForm1.FormCreate(Sender: TObject);
begin
  oClaude := TsgcHTTP_API_Anthropic.Create(Self);
  oClaude.AnthropicOptions.ApiKey := 'sk-ant-api03-...';
  oClaude.OnHTTPAPISSE := ClaudeSSE;
end;

procedure TForm1.ClaudeSSE(Sender: TObject;
  const aEvent, aData: string; var Cancel: Boolean);
var
  vDelta: string;
begin
  // aEvent values: message_start, content_block_delta,
  //                content_block_stop, message_stop
  if aEvent = 'content_block_delta' then
  begin
    vDelta := oClaude.SSEExtractText(aData);
    Memo1.Text := Memo1.Text + vDelta;
    Application.ProcessMessages;
  end;
end;

procedure TForm1.btnAskClick(Sender: TObject);
begin
  Memo1.Clear;
  oClaude._CreateMessageStream(
    'claude-sonnet-4-20250514',
    edtPrompt.Text);
end;

Ein erwähnenswertes Detail: Das Streaming läuft auf einem Hintergrund-Thread — aktualisiere die UI in Produktionscode über TThread.Synchronize oder TThread.Queue. Das Snippet oben nutzt der Kürze halber ProcessMessages. Noch eines: Der SSE-Stream sendet mehrere Event-Typen in Folge (message_start, content_block_start, wiederholt content_block_delta, content_block_stop, message_delta, message_stop) — ignoriere die, die du nicht brauchst. Der Helfer SSEExtractText deckt den häufigen Fall ab, das Text-Delta aus content_block_delta zu ziehen; für Usage-Statistiken und Stop-Reasons parst du message_delta direkt.

Streaming ist für jede benutzerseitige Chat-UI unverzichtbar — Nutzer empfinden eine Antwort, die in 400 ms beginnt, als schnell, auch wenn die komplette Antwort zehn Sekunden braucht. Ohne Streaming starren sie zehn Sekunden auf einen Spinner und gehen davon aus, dass die App kaputt ist. Die Kosten sind identisch: Streaming- und Nicht-Streaming-Requests werden gleich abgerechnet.

3. Vision — Bilder senden

Claude kann JPEG, PNG, GIF und WebP analysieren. Du übergibst sie entweder als öffentliche URL oder als base64-kodierte Bytes. Die Komponente bietet _CreateMessageWithImage für den URL-Fall und die typisierte API für alles Übrige.

var
  oRequest : TsgcAnthropicClass_Request_Messages;
  oMessage : TsgcAnthropicClass_Request_Message;
  oImage   : TsgcAnthropicClass_Request_Content_Image;
  oResponse: TsgcAnthropicClass_Response_Messages;
begin
  oRequest := TsgcAnthropicClass_Request_Messages.Create;
  try
    oRequest.Model     := 'claude-sonnet-4-20250514';
    oRequest.MaxTokens := 1024;

    oMessage := oRequest.NewMessage('user');
    oMessage.AddText('Describe what you see and read any text.');

    oImage := oMessage.AddImage;
    oImage.Source.LoadFromFile('C:\invoices\inv-2026-05-12.png');
    oImage.MediaType := 'image/png';

    oResponse := oClaude.CreateMessage(oRequest);
    try
      Memo1.Lines.Add(oResponse.Content[0].Text);
    finally
      oResponse.Free;
    end;
  finally
    oRequest.Free;
  end;
end;

Vision ist ideal für OCR auf gescannten Rechnungen, Screenshot-Triage in Support-Tickets, Chart-Interpretation und jede Aufgabe, an der eine deterministische OCR-Engine am Layout scheitert. Achte auf die Token-Kosten: Ein 1024×1024-Bild verbraucht grob 1.600 Input-Tokens. Anthropic skaliert alles größer als 1568 px auf der langen Kante vor der Verarbeitung herunter — es bringt nichts, 4K-Screenshots hochzuladen. Skaliere clientseitig herunter und spare Bandbreite.

Praktische Anwendungsfälle, die wir in Delphi-Häusern im letzten Jahr live gesehen haben: Positionen aus Lieferanten-PDFs ziehen, die für klassische OCR-Pipelines zu inkonsistent waren; medizinische Bilder grob klassifizieren, bevor sie an Fachsoftware geleitet werden; Zählerstände aus Field-Service-Fotos lesen; und UI-Bug-Screenshots in Helpdesk-Tickets triagieren („zeigt der Screenshot ein Layout- oder ein Datenproblem?“). In jedem Fall war der Gewinn nicht die rohe Genauigkeit — es war, einen pro Dokument fragilen Parser nicht mehr schreiben und pflegen zu müssen.

4. Tool Use (Function Calling)

Tool Use lässt Claude entscheiden, wann es deine Pascal-Funktionen aufruft. Du deklarierst jedes Tool mit Name, Beschreibung und JSON-Schema für seine Parameter. Wenn Claude mit einem tool_use-Block statt mit Text antwortet, führst du den Aufruf aus und fütterst das Ergebnis zurück in die Konversation.

var
  oRequest: TsgcAnthropicClass_Request_Messages;
  oTool   : TsgcAnthropicClass_Request_Tool;
begin
  oRequest := TsgcAnthropicClass_Request_Messages.Create;
  oRequest.Model     := 'claude-sonnet-4-20250514';
  oRequest.MaxTokens := 1024;

  oTool := oRequest.NewTool;
  oTool.Name        := 'get_stock_price';
  oTool.Description := 'Return the current bid/ask for a US ticker symbol.';
  oTool.InputSchema :=
    '{"type":"object",' +
     '"properties":{"symbol":{"type":"string","description":"Ticker, e.g. AAPL"}},' +
     '"required":["symbol"]}';

  oRequest.NewMessage('user').AddText('What is Apple trading at?');

  oResponse := oClaude.CreateMessage(oRequest);
  if oResponse.StopReason = 'tool_use' then
  begin
    vSymbol := oResponse.ToolUse[0].InputAsJSON.S['symbol'];
    vPrice  := MyQuoteFeed.Quote(vSymbol);        // your code
    oClaude.SendToolResult(oResponse.ToolUse[0].Id,
      Format('{"bid":%.2f,"ask":%.2f}', [vPrice.Bid, vPrice.Ask]));
  end;
end;

Baue agentische Workflows, indem du Tools verkettest: Ein Recherche-Agent könnte web_search, read_pdf und send_email kombinieren. Halte immer einen iMaxIterations-Riegel bereit, damit ein außer Kontrolle geratenes Modell nicht ewig läuft. In der Produktion deckeln wir aus Kostengründen bei fünf Tool-Calls pro User-Turn; braucht Claude mehr, ist meist der Prompt oder das Tool-Design falsch.

Der mit Abstand größte Hebel für die Qualität von Tool-Calls ist der Beschreibungstext. Modelle wählen das richtige Tool mit den richtigen Argumenten zu rund 99 % korrekt, wenn die Beschreibungen präzise sind („Return the current bid/ask for a US ticker symbol. Use this only for equities, not for crypto or FX“); sie fallen mit vager Beschreibung auf vielleicht 70 % („Get a price“). Nimm dir die Zeit. Füge Beispiele in die Beschreibung. Sage, was das Tool NICHT tut. Dein zukünftiges Ich, das um 23 Uhr einen 0,40-Dollar-Halluzinations-Function-Call debuggt, dankt dem gegenwärtigen Ich.

5. Extended Thinking

Claude 4 führt einen Thinking-Modus ein, in dem das Modell ein Problem Schritt für Schritt durchdenkt, bevor es antwortet. Du gibst ein Thinking-Budget in Tokens vor, und Claude liefert die Reasoning-Spur getrennt von der finalen Antwort. Das ist ein Gamechanger für Mathematik, Code-Review und mehrstufige Analyse.

oRequest.Thinking.Enabled       := True;
oRequest.Thinking.BudgetTokens  := 8000;   // soft cap on internal reasoning
oRequest.MaxTokens              := 16000;

oRequest.NewMessage('user').AddText(
  'A train leaves Madrid at 07:00 doing 220 km/h. Another leaves ' +
  'Barcelona at 07:15 doing 250 km/h. The route is 621 km. ' +
  'Where do they meet?');

oResponse := oClaude.CreateMessage(oRequest);
MemoThinking.Lines.Text := oResponse.Thinking;   // reasoning trace
MemoAnswer.Lines.Text   := oResponse.Content[0].Text;

Nutze Extended Thinking sparsam — Reasoning-Tokens werden als Output abgerechnet, ein 16k-Token-Thinking-Budget auf Opus 4 kann also schnell mehr kosten als ein normaler Aufruf. Reserviere es für Probleme, bei denen Korrektheit wichtiger ist als Latenz. Gut passend: juristische Dokumentenanalyse, Finanzabgleich, komplexe SQL-Generierung, Stack-Trace-Debugging, mehrkriterielle Terminplanung. Schlecht passend: Chat-Antworten, Content-Klassifikation, einfache Lookups — Zeit und Kosten lohnen sich nicht.

Ein nützlicher Kniff: Zeige die Reasoning-Spur in deiner UI als ausklappbaren Bereich „Denken anzeigen“ an, wie die öffentliche Claude-App. Power-User lieben es zu sehen, wie das Modell zur Antwort kam; Gelegenheitsnutzer ignorieren es. So oder so hast du gratis einen Audit-Trail.

6. Prompt Caching

Wenn du immer wieder denselben langen System-Prompt, dieselbe Wissensbasis oder dieselben Tool-Definitionen schickst, kann Prompt Caching die Kosten um bis zu 90 % senken und die Time-to-First-Token um 80 % verkürzen. Du markierst einen Content-Block als cacheable; Anthropic legt ihn 5 Minuten (oder mit dem Extended Cache 1 Stunde) auf seiner Seite ab und rechnet bei Folgeaufrufen nur den günstigeren Cache-Read-Preis ab.

var
  oSystem: TsgcAnthropicClass_Request_System;
begin
  oSystem := oRequest.NewSystemBlock;
  oSystem.Text         := LoadFile('C:\kb\product-manual.txt'); // 50k tokens
  oSystem.CacheControl := 'ephemeral';        // mark as cacheable

  oRequest.NewMessage('user').AddText('How do I configure SSL on the server?');
  oResponse := oClaude.CreateMessage(oRequest);

  // Inspect cache stats
  ShowMessage(Format('Cache: created=%d, read=%d, input=%d, output=%d',
    [oResponse.Usage.CacheCreationInputTokens,
     oResponse.Usage.CacheReadInputTokens,
     oResponse.Usage.InputTokens,
     oResponse.Usage.OutputTokens]));
end;

Daumenregel: Alles über 1.024 Tokens, das du innerhalb von fünf Minuten wiederverwendest, lohnt sich zu cachen. Große Dokumentations-Korpora, Few-Shot-Beispiele und große Tool-Schemas sind die offensichtlichen Kandidaten. Die Buchhaltung: Cache-Writes kosten 25 % mehr als ein normaler Input-Token, Cache-Reads kosten 10 % eines normalen Input-Tokens. Ab dem zweiten Treffer bist du also break-even, ab dem dritten sparst du echtes Geld. Ein Kundensupport-Bot, der 50 Fragen pro Minute gegen eine 40k-Token-Wissensbasis beantwortet, senkt mit Prompt Caching die monatliche Anthropic-Rechnung typischerweise um 80–85 %.

Du kannst pro Request bis zu vier Content-Blöcke als cacheable markieren. Ein häufiges Muster: Tools (cacheable, ändert sich selten), System-Prompt (cacheable, ändert sich selten), großes Dokument (cacheable, ändert sich pro Session), jüngste Nachrichten (NICHT cacheable, ändern sich pro Turn). Die Komponente handhabt diese Schichtung natürlich — setze einfach CacheControl an den Blöcken, die du cachen willst.

7. MCP-Connector

Das Model Context Protocol lässt Claude mit Remote-Tool-Servern reden, ohne dass du jedes Tool von Hand wrappen musst. Zeige die Komponente auf eine MCP-Server-URL, und Claude kann die Tools entdecken, aufrufen und die Ergebnisse verketten.

oRequest.MCPServers.Add(
  'weather-mcp',
  'https://mcp.example.com/weather',
  'Bearer ' + GetMcpToken);

oRequest.NewMessage('user').AddText(
  'What is the weather like in Madrid and should I take an umbrella?');

oResponse := oClaude.CreateMessage(oRequest);
ShowMessage(oResponse.Content[0].Text);

Kombiniere den MCP-Connector mit deinem eigenen TsgcAI_MCP_Server (behandelt in einem separaten Tutorial), und du hast einen vollständig Delphi-nativen Agent, der deine Domain-APIs jedem MCP-fähigen KI-Client — Claude Desktop, Cursor, Continue, deinen eigenen Apps, allem, was das Protokoll spricht — freigibt. Authentifizierung liegt in deiner Verantwortung: Übergib ein Bearer-Token oder einen signierten Header und validiere serverseitig. Anthropic sieht deine Credentials nicht — der MCP-Connector-Handshake routet das Token aus dem Request an den Ziel-Server.

Für Multi-Tenant-SaaS-Deployments ist das übliche Muster ein MCP-Server pro Tenant, mit der Tenant-ID in URL oder Bearer-Token eingebettet. Claude ruft die Tools jedes Tenants auf, ohne jemals Daten querzukreuzen. Wir haben Produktions-Deployments gesehen, die aus einer einzigen Konversation an über 200 MCP-Server ausfächern.

Produktions-Checkliste

Bevor du eine von Anthropic gestützte Delphi-App in die Produktion schaltest, geh diese kurze Liste durch:

Punkt	Wie damit umgehen
API-Key-Speicherung	Umgebungsvariable oder OS-Secret-Store, nie hartkodiert
Retries bei 429 / 529	Exponential Backoff mit Jitter, max. 3 Versuche
Kostengrenzen	Verfolge `Usage` pro Request, lehne neue Aufrufe nach Tagesbudget ab
PII-Redaktion	Entferne E-Mails/SSN/CC-Nummern, bevor du an die API sendest
Modellversion fixieren	Nutze vollständige datierte Modellnamen; verlasse dich nicht auf „latest“-Aliase
Prompt-Versionierung	Lege System-Prompts neben dem Code in der Versionsverwaltung ab
Telemetrie	Logge Modell, Input-Tokens, Output-Tokens, Latenz pro Aufruf

Wie es weitergeht

Dieses Tutorial deckt die acht Funktionen ab, die du in 95 % der Fälle brauchst. Die Komponente unterstützt zusätzlich Message Batches (günstige asynchrone Verarbeitung Tausender Prompts — 50 % günstiger als synchrone Aufrufe, ideal für nächtliche Anreicherungs-Jobs), die Files API (einmal hochladen, ewig referenzieren — perfekt für große PDFs, die du wiederholt abfragst), Token-Zählung (Kosten vor dem Bezahlen schätzen) und strukturierte JSON-Outputs (erzwungene Schema-Konformität, keine Parse-Fehler mehr). Stöbere auf der Anthropic-Komponentenseite für die vollständige Feature-Matrix und schau im Getting-Started-Hub vorbei, falls du sgcWebSockets noch nicht installiert hast.

Und wenn du etwas Spannendes mit Claude in Delphi baust — einen Agenten, einen Copilot, einen Doc-Analyzer — erzähl es uns. Wir lieben es zu sehen, was Pascal-Entwickler tun, sobald die KI-Reibung verschwindet.