Premiers pas avec l'API Claude

Ce guide vous accompagne dans la création de votre première application utilisant l'API Claude d'Anthropic.

Prérequis

Avant de commencer :

• Compte Anthropic avec accès API
• Clé API valide
• Node.js 18+ ou Python 3.8+
• Connaissances de base en programmation
• Terminal/ligne de commande

Obtenir une clé API

1. Créer un compte Anthropic

1. Visitez console.anthropic.com
2. Cliquez sur "Sign Up"
3. Vérifiez votre email
4. Connectez-vous

2. Générer une clé API

1. Allez dans Settings > API Keys
2. Cliquez sur "Create Key"
3. Donnez un nom descriptif (ex: "Mon premier projet")
4. Copiez la clé immédiatement (elle ne sera plus affichée)
5. Stockez-la en sécurité

Format : sk-ant-api03-...

3. Crédits et facturation

• Nouveaux comptes : 5$ de crédits gratuits
• Consultez la tarification : anthropic.com/pricing
• Configurez une alerte de budget

Installation

Option 1 : Node.js / TypeScript

Créez un nouveau projet :

mkdir mon-projet-claude
cd mon-projet-claude
npm init -y
npm install @anthropic-ai/sdk
npm install -D typescript @types/node
npx tsc --init

Option 2 : Python

mkdir mon-projet-claude
cd mon-projet-claude
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
pip install anthropic

Option 3 : Bun (recommandé)

mkdir mon-projet-claude
cd mon-projet-claude
bun init
bun add @anthropic-ai/sdk

Configuration

Variables d'environnement

Créez un fichier .env :

ANTHROPIC_API_KEY=sk-ant-api03-...

Important : Ajoutez .env à votre .gitignore !

TypeScript/Node.js

Installez dotenv :

npm install dotenv

import 'dotenv/config';
import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

Python

import os
from anthropic import Anthropic

client = Anthropic(
    api_key=os.environ.get("ANTHROPIC_API_KEY")
)

Premier appel API

TypeScript

Créez index.ts :

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

async function main() {
  const message = await client.messages.create({
    model: 'claude-sonnet-4-5-20250929',
    max_tokens: 1024,
    messages: [
      {
        role: 'user',
        content: 'Bonjour Claude ! Peux-tu me dire bonjour en français ?'
      }
    ],
  });

  console.log(message.content[0].text);
}

main();

Exécutez :

npx tsx index.ts
# ou avec bun
bun run index.ts

Python

Créez main.py :

import anthropic

client = anthropic.Anthropic(
    api_key=os.environ.get("ANTHROPIC_API_KEY")
)

message = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Bonjour Claude ! Peux-tu me dire bonjour en français ?"
        }
    ]
)

print(message.content[0].text)

Exécutez :

python main.py

Concepts clés

Modèles disponibles (Famille Claude 4)

Modèle	Usage	Prix Input/Output	Vitesse
claude-sonnet-4-5-20250929	Recommandé - Code, agents, général	$3/$15 par M tokens	Rapide
claude-haiku-4-5-20251001	Rapide & économique - Perfs ≈ Sonnet 4	$1/$5 par M tokens	2x plus rapide
claude-opus-4-1-20250805	Raisonnement profond - Tâches complexes	$15/$75 par M tokens	Moyen

Note : Sonnet 4.5 est le modèle par défaut depuis septembre 2025. Context window : 200K tokens standard, 1M tokens avec header beta.

Messages et rôles

Chaque message a un rôle :

• user : Vous (l'utilisateur)
• assistant : Claude

Conversation :

messages: [
  { role: 'user', content: 'Quelle est la capitale de la France ?' },
  { role: 'assistant', content: 'La capitale de la France est Paris.' },
  { role: 'user', content: 'Combien d'habitants ?' }
]

Paramètres importants

max_tokens : Nombre maximum de tokens dans la réponse

max_tokens: 1024  // ~750 mots

temperature : Créativité (0-1)

temperature: 1.0  // Maximum de créativité
temperature: 0.0  // Déterministe

system : Instructions système

system: "Tu es un assistant expert en JavaScript."

top_p : Diversité des réponses

top_p: 0.9

Exemples pratiques

1. Assistant chatbot

async function chatbot() {
  const conversation: Array<{ role: string; content: string }> = [];
  const readline = require('readline');

  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });

  const ask = (question: string): Promise<string> => {
    return new Promise((resolve) => {
      rl.question(question, resolve);
    });
  };

  console.log('Chatbot Claude (tapez "exit" pour quitter)\n');

  while (true) {
    const userInput = await ask('Vous: ');

    if (userInput.toLowerCase() === 'exit') {
      rl.close();
      break;
    }

    conversation.push({
      role: 'user',
      content: userInput
    });

    const response = await client.messages.create({
      model: 'claude-sonnet-4-5-20250929',
      max_tokens: 1024,
      messages: conversation as any
    });

    const assistantMessage = response.content[0].text;
    conversation.push({
      role: 'assistant',
      content: assistantMessage
    });

    console.log(`\nClaude: ${assistantMessage}\n`);
  }
}

chatbot();

2. Analyse de texte

async function analyzeText(text: string) {
  const message = await client.messages.create({
    model: 'claude-sonnet-4-5-20250929',
    max_tokens: 2048,
    system: 'Tu es un expert en analyse de texte. Fournis une analyse structurée.',
    messages: [{
      role: 'user',
      content: `Analyse ce texte et fournis:
- Le ton général
- Les thèmes principaux
- Le sentiment (positif/négatif/neutre)
- Un résumé en 2 phrases

Texte: ${text}`
    }]
  });

  return message.content[0].text;
}

const article = "...";
const analysis = await analyzeText(article);
console.log(analysis);

3. Génération de code

async function generateCode(description: string, language: string) {
  const message = await client.messages.create({
    model: 'claude-sonnet-4-5-20250929',
    max_tokens: 4096,
    system: `Tu es un expert en ${language}. Génère du code propre, commenté et avec gestion d'erreurs.`,
    messages: [{
      role: 'user',
      content: `Génère un exemple de code ${language} pour: ${description}`
    }]
  });

  return message.content[0].text;
}

const code = await generateCode(
  'une fonction qui calcule la suite de Fibonacci',
  'TypeScript'
);
console.log(code);

4. Traduction

async function translate(text: string, targetLang: string) {
  const message = await client.messages.create({
    model: 'claude-haiku-4-5-20251001', // Haiku 4.5 : rapide et économique pour la traduction
    max_tokens: 2048,
    messages: [{
      role: 'user',
      content: `Traduis ce texte en ${targetLang}, en préservant le ton et les nuances:\n\n${text}`
    }]
  });

  return message.content[0].text;
}

Gestion des erreurs

async function safeCall() {
  try {
    const message = await client.messages.create({
      model: 'claude-sonnet-4-5-20250929',
      max_tokens: 1024,
      messages: [{ role: 'user', content: 'Hello!' }]
    });

    return message.content[0].text;
  } catch (error: any) {
    if (error.status === 401) {
      console.error('Clé API invalide');
    } else if (error.status === 429) {
      console.error('Rate limit atteint, attendez avant de réessayer');
    } else if (error.status === 500) {
      console.error('Erreur serveur Anthropic');
    } else {
      console.error('Erreur:', error.message);
    }
    throw error;
  }
}

Streaming

Pour les longues réponses, utilisez le streaming :

async function streamResponse() {
  const stream = await client.messages.create({
    model: 'claude-sonnet-4-5-20250929',
    max_tokens: 1024,
    messages: [{ role: 'user', content: 'Écris une courte histoire' }],
    stream: true
  });

  for await (const event of stream) {
    if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
      process.stdout.write(event.delta.text);
    }
  }
}

Optimisation des coûts

1. Choisir le bon modèle

• Haiku : Tâches simples, répétitives
• Sonnet : Usage général (recommandé)
• Opus : Tâches complexes uniquement

2. Limiter les tokens

max_tokens: 256  // Pour des réponses courtes

3. Caching (bientôt disponible)

Réutilisez le contexte pour économiser :

system: "...", // Sera mis en cache automatiquement

4. Compteur de tokens

const response = await client.messages.create({...});

console.log('Tokens utilisés:', {
  input: response.usage.input_tokens,
  output: response.usage.output_tokens,
  total: response.usage.input_tokens + response.usage.output_tokens
});

Sécurité

Ne jamais exposer la clé API

❌ Mauvais :

const apiKey = 'sk-ant-api03-...'; // Hardcodé !

✅ Bon :

const apiKey = process.env.ANTHROPIC_API_KEY;

Validation des entrées

function validateInput(input: string): boolean {
  if (input.length > 10000) {
    throw new Error('Input trop long');
  }
  return true;
}

Rate limiting côté client

import pLimit from 'p-limit';

const limit = pLimit(5); // Max 5 requêtes simultanées

const promises = texts.map(text =>
  limit(() => analyzeText(text))
);

await Promise.all(promises);

Ressources

• Documentation API : docs.anthropic.com/claude/reference
• SDKs officiels : github.com/anthropics
• Discord CC France : Salon #api-claude
• Exemples : github.com/anthropics/anthropic-sdk-typescript/tree/main/examples

Prochaines étapes

• 🔥 Explorez les techniques avancées de prompt engineering
• 🏗️ Créez une application web avec Claude
• 🤖 Intégrez Claude dans votre workflow
• 💬 Partagez vos projets sur Discord

Bon développement ! 🚀