Pourquoi un composant Delphi natif pour Claude ?
Anthropic Claude est l'une des familles d'IA les plus performantes du marché, mais tous les exemples publics utilisent Python ou Node. Pour les développeurs Delphi et C++Builder, appeler les endpoints REST à la main signifie bricoler du JSON, jongler avec les Server-Sent Events, gérer TLS, gérer les limites de débit et réécrire du boilerplate chaque fois qu'Anthropic livre une nouvelle fonctionnalité — ce qu'ils font à peu près tous les trimestres. Le composant TsgcHTTP_API_Anthropic livré avec sgcWebSockets supprime cette friction. C'est un wrapper fortement typé autour de toute la surface Anthropic — messages, streaming, vision, tool use, extended thinking, prompt caching, fichiers, batches et le connecteur Model Context Protocol — que vous pouvez déposer sur une fiche et utiliser depuis n'importe quelle application VCL, FMX ou console.
Ce tutoriel passe en revue toutes les capacités majeures avec du code Delphi fonctionnel. À la fin, vous serez capable de construire un client chat, un analyseur de documents avec vision, un exécuteur d'outils agentique et un pipeline de production optimisé en coût. Tous les snippets ciblent les derniers modèles claude-sonnet-4-20250514 et claude-opus-4-20250514, et tous tournent sans modification de Delphi 7 à Delphi 13.
Une note rapide sur la philosophie avant de plonger. Le composant expose intentionnellement deux surfaces. La surface « rapide » (méthodes comme _CreateMessage, _CreateMessageStream, _CreateMessageWithImage) accepte quelques chaînes et retourne une chaîne — parfait pour les prototypes, les démos et les 80 % d'appels où vous ne vous souciez pas de la température, du top-p, des métadonnées ou des stop sequences. La surface « typée » (classes comme TsgcAnthropicClass_Request_Messages et TsgcAnthropicClass_Response_Messages) vous donne un contrôle complet sur tous les paramètres que l'API Anthropic supporte, avec typage fort et auto-complétion IDE. Utilisez l'API rapide pour apprendre ; passez à l'API typée pour la production. Même composant, deux couches, pas de duplication.
1. Configuration et votre premier message
Ajoutez sgcHTTP_API_Anthropic à votre uses clause, créez le composant, définissez votre clé API (obtenez-en une sur console.anthropic.com) et appelez _CreateMessage. C'est le minimum absolu pour parler à Claude.
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;
Le composant fait le gros du travail : il construit le corps de requête JSON, définit les en-têtes x-api-key et anthropic-version, poste vers /v1/messages et parse la réponse en une chaîne Delphi simple. Si vous avez besoin d'un contrôle complet sur les paramètres de requête, utilisez la classe typée TsgcAnthropicClass_Request_Messages.
Un conseil opérationnel : ne jamais intégrer la clé API dans le binaire. Lisez-la depuis une variable d'environnement, une clé de registre ou un gestionnaire de secrets. Anthropic scanne maintenant GitHub à la recherche de clés divulguées et les révoque automatiquement — vous ne voulez pas livrer une mise à jour à 18h un vendredi parce que quelqu'un a fait une capture d'écran de votre fichier .pas.
2. Réponses en streaming avec SSE
Les appels synchrones conviennent aux prompts courts, mais pour une UI de chat vous voulez que les tokens apparaissent à mesure que Claude les génère. Anthropic diffuse les réponses sous forme de Server-Sent Events, et le composant les expose via l'événement OnHTTPAPISSE.
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;
Un détail à noter : le streaming tourne sur un thread d'arrière-plan, donc mettez à jour l'UI via TThread.Synchronize ou TThread.Queue en code de production. Le snippet ci-dessus utilise ProcessMessages par concision. Un autre : le flux SSE envoie plusieurs types d'événements en séquence (message_start, content_block_start, content_block_delta répétés, content_block_stop, message_delta, message_stop) et vous devriez ignorer ceux dont vous n'avez pas besoin. Le helper SSEExtractText gère le cas courant d'extraire le delta de texte de content_block_delta ; pour les statistiques d'usage et les raisons d'arrêt, vous parsez message_delta directement.
Le streaming est essentiel pour toute UI de chat orientée utilisateur — les utilisateurs perçoivent comme rapide une réponse qui commence en 400 ms, même si la réponse complète prend dix secondes. Sans streaming, ils fixent un spinner pendant dix secondes et supposent que l'application est cassée. Le coût est identique : les requêtes streaming et non-streaming sont facturées de la même manière.
3. Vision — Envoi d'images
Claude peut analyser des images JPEG, PNG, GIF et WebP. Vous les passez soit comme URL publique, soit comme octets encodés base64. Le composant expose _CreateMessageWithImage pour le cas URL et l'API typée pour tout le reste.
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;
La vision est idéale pour l'OCR sur des factures scannées, le tri de captures d'écran dans les tickets de support, l'interprétation de graphiques, et toute tâche où un moteur OCR déterministe peinerait avec la mise en page. Surveillez le coût en tokens : une image 1024x1024 consomme environ 1 600 tokens d'entrée. Anthropic redimensionne tout ce qui dépasse 1568 px sur le bord long avant traitement, donc il n'y a aucun intérêt à téléverser des captures d'écran 4K — réduisez de votre côté et économisez la bande passante.
Cas d'usage pratiques que nous avons vus livrés par des shops Delphi l'année dernière : extraire les lignes d'articles de PDF fournisseurs trop incohérents pour les pipelines OCR traditionnels, classer l'imagerie médicale en catégories larges avant de router vers des logiciels spécialisés, lire les valeurs de compteurs depuis des photos de terrain et trier les captures d'écran de bugs UI dans les tickets helpdesk (« la capture montre-t-elle un problème de mise en page ou un problème de données ? »). Dans chaque cas, le gain n'était pas la précision brute — c'était d'éliminer le besoin d'écrire et de maintenir un parseur fragile par document.
4. Tool Use (appel de fonction)
Le tool use permet à Claude de décider quand appeler vos fonctions Pascal. Vous déclarez chaque outil avec un nom, une description et un JSON Schema pour ses paramètres. Quand Claude répond avec un bloc tool_use au lieu de texte simple, vous exécutez l'appel et réinjectez le résultat dans la conversation.
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;
Construisez des workflows agentiques en chaînant des outils : un agent de recherche pourrait combiner les outils web_search, read_pdf et send_email. Gardez toujours une protection iMaxIterations pour qu'un modèle déréglé ne puisse pas boucler indéfiniment. En production, nous plafonnons à cinq appels d'outils par tour utilisateur pour des raisons de coût ; si Claude en a besoin de plus, c'est généralement un signe que le prompt ou la conception de l'outil est mauvaise.
Le plus grand déterminant de la qualité des appels d'outils est le texte de description. Les modèles choisissent le bon outil avec les bons arguments environ 99 % du temps quand les descriptions sont précises (« Return the current bid/ask for a US ticker symbol. Use this only for equities, not for crypto or FX ») ; ils tombent peut-être à 70 % avec une description vague (« Get a price »). Prenez le temps. Ajoutez des exemples dans la description. Indiquez ce que l'outil NE fait PAS. Le vous-futur, en train de déboguer un appel de fonction halluciné à 0,40 $ à 23 h, remerciera le vous-présent.
5. Extended Thinking
Claude 4 introduit un mode de réflexion où le modèle raisonne sur un problème étape par étape avant de répondre. Vous allouez un budget de réflexion en tokens, et Claude retourne la trace de raisonnement séparément de la réponse finale. C'est un changement de donne pour les maths, la revue de code et l'analyse multi-étapes.
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;
Utilisez l'extended thinking avec parcimonie — les tokens de raisonnement sont facturés comme de la sortie, donc un budget de réflexion de 16k tokens sur Opus 4 peut facilement coûter plus qu'un appel normal. Réservez-le aux problèmes où la justesse compte plus que la latence. Bons cas d'usage : analyse de documents juridiques, réconciliation financière, génération SQL complexe, débogage de stack traces, ordonnancement multi-contraintes. Mauvais cas d'usage : réponses de chat, classification de contenu, recherches simples — le temps et le coût de la réflexion ne sont pas justifiés.
Une astuce utile est d'exposer la trace de raisonnement dans votre UI comme une section repliable « afficher la réflexion », comme le fait l'application Claude publique. Les utilisateurs avancés adorent voir comment le modèle est arrivé à la réponse ; les utilisateurs occasionnels l'ignorent. Dans tous les cas, vous obtenez une piste d'audit gratuitement.
6. Prompt Caching
Si vous continuez à envoyer le même long system prompt, la même base de connaissances ou les mêmes définitions d'outils, le prompt caching peut réduire les coûts jusqu'à 90 % et réduire le temps jusqu'au premier token de 80 %. Vous marquez un bloc de contenu comme cachable ; Anthropic le stocke de leur côté pendant 5 minutes (ou 1 heure avec le cache étendu) et ne refacture que le prix moins cher de cache-read sur les appels suivants.
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;
Règle empirique : tout ce qui dépasse 1 024 tokens et que vous réutilisez dans les cinq minutes vaut la peine d'être caché. Les gros corpus de documentation, les exemples few-shot et les gros schémas d'outils sont les candidats évidents. La comptabilité : les écritures en cache coûtent 25 % de plus qu'un token d'entrée normal, les lectures en cache coûtent 10 % d'un token d'entrée normal. Vous atteignez donc le seuil de rentabilité au deuxième hit et commencez à économiser de l'argent réel à partir du troisième. Pour un bot de support client répondant à 50 questions par minute sur une base de connaissances de 40k tokens, le prompt caching coupe typiquement la facture mensuelle Anthropic de 80–85 %.
Vous pouvez marquer jusqu'à quatre blocs de contenu comme cachables par requête. Un pattern courant est : outils (cachable, change rarement), system prompt (cachable, change rarement), grand document (cachable, change par session), messages récents (PAS cachable, change à chaque tour). Le composant gère cette stratification naturellement — définissez simplement CacheControl sur les blocs que vous voulez cacher.
7. Connecteur MCP
Le Model Context Protocol permet à Claude de parler à des serveurs d'outils distants sans que vous ayez à wrapper chaque outil à la main. Pointez le composant sur une URL de serveur MCP et Claude peut découvrir les outils, les appeler et chaîner les résultats.
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);
Combinez le connecteur MCP avec votre propre TsgcAI_MCP_Server (couvert dans un tutoriel séparé) et vous avez un agent entièrement natif Delphi qui expose vos API de domaine à n'importe quel client IA compatible MCP — Claude Desktop, Cursor, Continue, vos propres applications, tout ce qui parle le protocole. L'authentification est de votre responsabilité : passez un bearer token ou un en-tête signé, et validez côté serveur. Anthropic ne voit pas vos identifiants — le handshake du connecteur MCP route le token de la requête vers le serveur cible.
Pour les déploiements SaaS multi-tenants, le pattern typique est un seul serveur MCP par tenant, avec l'ID du tenant embarqué dans l'URL ou le bearer token. Claude appelle les outils de chaque tenant sans jamais contaminer les données. Nous avons vu des déploiements en production se déployer en éventail vers 200+ serveurs MCP depuis une seule conversation.
Checklist de production
Avant de basculer une application Delphi propulsée par Anthropic en production, parcourez cette courte liste :
| Préoccupation | Comment la gérer |
| Stockage de clé API | Variable d'environnement ou coffre-fort OS, jamais en dur |
| Retries sur 429 / 529 | Backoff exponentiel avec jitter, max 3 tentatives |
| Plafonds de coût | Suivre Usage par requête, refuser les nouveaux appels au-delà du budget journalier |
| Rédaction PII | Supprimer emails/SSN/numéros CC avant envoi à l'API |
| Verrouillage de version de modèle | Utiliser les noms de modèles datés complets ; ne pas se fier aux alias « latest » |
| Versionnement de prompts | Stocker les system prompts dans le contrôle de source à côté du code |
| Télémétrie | Journaliser modèle, tokens d'entrée, tokens de sortie, latence par appel |
Pour aller plus loin
Ce tutoriel a couvert les huit fonctionnalités dont vous avez besoin 95 % du temps. Le composant supporte aussi les message batches (traitement async bon marché de milliers de prompts — 50 % moins cher que les appels synchrones, idéal pour les jobs d'enrichissement nocturnes), l'API Files (téléverser une fois, référencer pour toujours — parfait pour les gros PDF que vous interrogez à répétition), le comptage de tokens (estimer les coûts avant de payer) et les sorties JSON structurées (conformité de schéma forcée, plus d'erreurs de parsing). Parcourez la page du composant Anthropic pour la matrice complète des fonctionnalités et rendez-vous au hub Premiers pas si vous n'avez pas encore installé sgcWebSockets.
Et si vous construisez quelque chose d'intéressant avec Claude en Delphi — un agent, un copilote, un analyseur de docs — dites-le nous. Nous adorons voir ce que font les développeurs Pascal une fois que la friction IA disparaît.