Anthropic API Delphi

16 March 2026 · Components

Integriere die Anthropic-Claude-API in deine Delphi-Anwendungen

sgcWebSockets liefert eine produktionsreife Delphi-Komponente für die vollständige Anthropic-Claude-API – von Textgenerierung und Vision über Tool Use, Extended Thinking und mehr.

Anthropic Claude gehört zu den fortschrittlichsten KI-Modellfamilien der Gegenwart und ist bekannt für sein herausragendes Reasoning, sein Safety-First-Design und seine vielseitigen Fähigkeiten in Text, Code, Vision und strukturierten Daten. Für Delphi-Entwickler, die diese Fähigkeiten nutzen möchten, bietet sgcWebSockets TsgcHTTP_API_Anthropic – eine umfassende, native Komponente, die die gesamte Anthropic-API-Oberfläche kapselt.

Egal, ob du intelligente Chatbots baust, Dokumentenanalyse automatisierst, komplexe Tool-Pipelines orchestrierst oder Tausende Anfragen im Batch verarbeitest – diese Komponente verschafft dir über sauberen, typsicheren Delphi-Code direkten Zugriff auf jede Claude-Funktion. Kein REST-Boilerplate. Kein JSON-Gefummel. Einfach Komponente ablegen, API-Key setzen und loslegen.

Vollständige API-Abdeckung

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

Messages & Streaming Sende Nachrichten mit System Prompts und erhalte Antworten synchron oder per Server-Sent Events in Echtzeit gestreamt.	Vision Analysiere Bilder in den Formaten JPEG, PNG, GIF und WebP. Claude beschreibt, interpretiert und argumentiert über visuelle Inhalte.	Tool Use Definiere eigene Tools mit JSON Schema und lass Claude sie aufrufen. Baue agentische Workflows mit Function Calling.
Extended Thinking Aktiviere schrittweises Reasoning für komplexe Aufgaben. Ideal für Mathematik, Analyse und mehrstufige Problemlösung.	Dokumentenverarbeitung Sende PDF-Dokumente und Textdateien zur Analyse, Zusammenfassung und Beantwortung von Fragen mit Zitationsunterstützung.	Structured Outputs Zwinge Claude, gültiges JSON gemäß deinem Schema zurückzugeben. Garantiert parsebare, typsichere Antworten.
Web-Suche Lass Claude während der Konversation per eingebauter serverseitiger Tools nach aktuellen Informationen im Web suchen.	Prompt Caching Cache System Prompts, Content Blocks und Tool-Definitionen. Reduziere Kosten bei wiederholtem Kontext um bis zu 90 %.	Message Batches Verarbeite Tausende von Anfragen asynchron. Perfekt für Massen-Content-Generierung und Datenverarbeitungs-Pipelines.
Files API Lade Dateien auf Anthropic-Servern hoch, liste sie auf, lade sie herunter und verwalte sie. Referenziere sie über mehrere Konversationen hinweg.	MCP-Connector Verbinde Claude mit externen Model-Context-Protocol-Servern. Erweitere die Fähigkeiten um Drittanbieter-Tools und -Dienste.	Token-Zählung Zähle Tokens, bevor du Anfragen sendest. Schätze Kosten präzise ab und steuere dein Kontextfenster-Budget.

Erste Schritte

Integriere Claude 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
  Anthropic: TsgcHTTP_API_Anthropic;
  vResponse: string;
begin
  Anthropic := TsgcHTTP_API_Anthropic.Create(nil);
  Try
    Anthropic.AnthropicOptions.ApiKey := 'YOUR_API_KEY';
    // Send a simple message to Claude
    vResponse := Anthropic._CreateMessage(
      'claude-sonnet-4-20250514', 'Hello, Claude!');
    ShowMessage(vResponse);
  Finally
    Anthropic.Free;
  End;
end;

Messages & Streaming

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

System Prompts

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

vResponse := Anthropic._CreateMessageWithSystem(
  'claude-sonnet-4-20250514',
  '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 Claudes Antwort Token für Token per Server-Sent Events. Weise den Event-Handler OnHTTPAPISSE zu und rufe _CreateMessageStream auf.

// Enable streaming via SSE
Anthropic.OnHTTPAPISSE := OnSSEEvent;
Anthropic._CreateMessageStream('claude-sonnet-4-20250514',
  'Tell me a story about a brave explorer.');
procedure TForm1.OnSSEEvent(Sender: TObject;
  const aEvent, aData: string; var Cancel: Boolean);
begin
  // aEvent: event type (e.g., content_block_delta)
  // aData: JSON payload for this event
  Memo1.Lines.Add(aData);
end;

Fortgeschrittene typisierte API

Für die volle Kontrolle über Anfrageparameter – Temperatur, Top-p, Stopp-Sequenzen, Metadaten – verwendest du die typisierten Request- und Response-Klassen.

var
  oRequest: TsgcAnthropicClass_Request_Messages;
  oMessage: TsgcAnthropicClass_Request_Message;
  oResponse: TsgcAnthropicClass_Response_Messages;
begin
  oRequest := TsgcAnthropicClass_Request_Messages.Create;
  Try
    oRequest.Model := 'claude-sonnet-4-20250514';
    oRequest.MaxTokens := 1024;
    oRequest.System := 'You are a helpful assistant.';
    oRequest.Temperature := 0.7;
    oMessage := TsgcAnthropicClass_Request_Message.Create;
    oMessage.Role := 'user';
    oMessage.Content := 'Explain quantum computing in simple terms.';
    // ... add message to request, send, and process response
    oResponse := Anthropic.CreateMessage(oRequest);
    Try
      if Length(oResponse.Content) > 0 then
        ShowMessage(oResponse.Content[0].Text);
    Finally
      oResponse.Free;
    End;
  Finally
    oMessage.Free;
    oRequest.Free;
  End;
end;

Vision – Bildverständnis

Claude kann Bilder analysieren und über sie argumentieren. Sende Fotos, Screenshots, Diagramme oder Charts und erhalte detaillierte Beschreibungen, Datenextraktion oder visuelle Q&A.

Unterstützte Formate sind JPEG, PNG, GIF und WebP. Bilder werden als base64-codierte Content Blocks übermittelt.

// Load an image and ask Claude to describe it
var
  vBase64: string;
begin
  vBase64 := sgcBase64Encode(LoadFileToBytes('product-photo.png'));
  ShowMessage(Anthropic._CreateVisionMessage(
    'claude-sonnet-4-20250514',
    'Describe this product image for an e-commerce listing.',
    vBase64, 'image/png'));
end;

Tool Use – Function Calling

Definiere eigene Tools mit JSON Schema; Claude entscheidet, wann und wie sie aufgerufen werden. Das ist die Grundlage für agentische, mehrstufige Workflows.

Der Tool-Use-Ablauf folgt einem klaren Muster: Tools definieren, Request senden, tool_use in der Antwort erkennen, die Funktion lokal ausführen und das Ergebnis für die finale Antwort an Claude zurückgeben.

// Define a weather tool with JSON Schema input
oTool := TsgcAnthropicClass_Request_Tool.Create;
oTool.Name := 'get_weather';
oTool.Description := 'Get the current weather in a given location';
oTool.InputSchema :=
  '{"type":"object","properties":{"location":{"type":"string",' +
  '"description":"The city and state"}},"required":["location"]}';
// Send request with tools defined
oResponse := Anthropic.CreateMessage(oRequest);
// Check if Claude wants to call a tool
if oResponse.StopReason = 'tool_use' then
begin
  for i := 0 to Length(oResponse.Content) - 1 do
  begin
    if oResponse.Content[i].ContentType = 'tool_use' then
    begin
      vToolUseId := oResponse.Content[i].Id;
      vToolName  := oResponse.Content[i].Name;
      vToolInput := oResponse.Content[i].Input;
      // Execute the tool and return the result to Claude
    end;
  end;
end;

Dokumentenverarbeitung & Zitationen

Sende PDF-Dokumente und Textdateien an Claude zur Analyse, Zusammenfassung und Beantwortung von Fragen. Aktiviere Zitationen, um nachprüfbare Verweise auf das Quellmaterial zu erhalten.

// Send a PDF and ask Claude to summarize it
vBase64 := sgcBase64Encode(LoadFileToBytes('annual-report.pdf'));
vResponse := Anthropic._CreateDocumentMessage(
  'claude-sonnet-4-20250514',
  'Summarize the key findings of this report.',
  vBase64, 'application/pdf');

Zitationen

Aktiviere Zitationen auf Dokument-Content-Blöcken, um in Claudes Antwort Quellenverweise zu erhalten – inklusive Seitenzahlen, Zeichenbereichen und zitiertem Text.

oDocBlock := TsgcAnthropicClass_Request_Content_Block.Create;
oDocBlock.ContentType := 'document';
oDocBlock.SourceType := 'base64';
oDocBlock.MediaType := 'application/pdf';
oDocBlock.Data := vBase64;
oDocBlock.Title := 'Annual Report';
oDocBlock.CitationsEnabled := True;

MCP-Connector

Verbinde Claude mit externen Model-Context-Protocol-(MCP-)Servern, um seine Fähigkeiten um Drittanbieter-Tools und -Dienste zu erweitern – Datenbanken, CRMs, interne APIs und mehr.

Anthropic.AnthropicOptions.BetaHeaders := 'mcp-client-2025-11-20';
// Connect to an MCP server with one method call
vResponse := Anthropic._CreateMessageWithMCP(
  'claude-sonnet-4-20250514',
  'What tools are available?',
  'https://my-mcp-server.example.com/sse',
  'my-mcp-server');

Authentifizierte MCP-Server

Für Server, die Authentifizierung erfordern, unterstützt die typisierte API OAuth-Bearer-Tokens.

oServer := TsgcAnthropicClass_Request_MCPServer.Create;
oServer.ServerType := 'url';
oServer.Url := 'https://my-mcp-server.example.com/sse';
oServer.Name := 'my-server';
oServer.AuthorizationToken := 'OAUTH_TOKEN';
oTool := TsgcAnthropicClass_Request_Tool.Create;
oTool.ToolType := 'mcp_toolset';
oTool.MCPServerName := 'my-server';