# Format Anthropic

> Utilisez l'API Anthropic Messages fournie par LLMoxy pour appeler les modèles Claude avec la prise en charge de l'authentification x-api-key.

LLMoxy fournit une interface API Anthropic Messages entièrement compatible, optimisée pour les modèles de la série Claude. Les utilisateurs du SDK officiel Anthropic n'ont qu'à modifier `base_url` pour basculer.

## URL de base

```txt
https://llmoxy.com/v1
```

## Authentification

Deux méthodes d'authentification sont prises en charge :

### Méthode 1 : x-api-key (recommandée)

```http
x-api-key: YOUR_API_KEY
```

### Méthode 2 : Authorization

```http
Authorization: Bearer YOUR_API_KEY
```

## Messages API

L'interface de conversation principale de Claude.

### URL de la requête

```txt
POST /v1/messages
```

### Exemple de requête

```bash
curl https://llmoxy.com/v1/messages \
-H "content-type: application/json" \
-H "x-api-key: YOUR_API_KEY" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 1024,
"messages": [
{
"role": "user",
"content": "Écrivez un algorithme de recherche binaire en Python"
}
]
}'
```

### Paramètres de la requête

| Paramètre | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| model | string | Oui | Nom du modèle |
| messages | array | Oui | Liste des messages de conversation |
| max_tokens | integer | Oui | Nombre maximum de tokens générés |
| system | string | Non | Invite système |
| temperature | number | Non | Paramètre de température, 0–1 |
| top_p | number | Non | Paramètre de nucleus sampling |
| stream | boolean | Non | Activer la sortie en flux |
| stop_sequences | array | Non | Séquences d'arrêt |

### Format des messages

Contrairement à OpenAI, le format Anthropic utilise un paramètre distinct pour l'invite système :

```json
{
"model": "claude-opus-5-5",
"max_tokens": 1024,
"system": "Vous êtes un expert en programmation Python",
"messages": [
{
"role": "user",
"content": "Écrivez un quicksort"
},
{
"role": "assistant",
"content": "D'accord, je vais écrire un quicksort en Python..."
},
{
"role": "user",
"content": "Ajoutez des commentaires détaillés"
}
]
}
```

> **Remarque**
> - messages ne peut contenir que les rôles `user` et `assistant`
> - Doit commencer par un message `user`
> - Les messages `user` et `assistant` doivent alterner

### Format de la réponse

```json
{
"id": "msg_123",
"type": "message",
"role": "assistant",
"content": [
{
"type": "text",
"text": "Voici le contenu de la réponse de Claude"
}
],
"model": "claude-opus-5-5",
"stop_reason": "end_turn",
"usage": {
"input_tokens": 25,
"output_tokens": 150
}
}
```

## Sortie en flux

Définissez `stream: true` pour activer la sortie en flux :

```bash
curl https://llmoxy.com/v1/messages \
-H "content-type: application/json" \
-H "x-api-key: YOUR_API_KEY" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 1024,
"messages": [{"role": "user", "content": "Bonjour"}],
"stream": true
}'
```

### Format de la réponse en flux

```txt
event: message_start
data: {"type":"message_start","message":{"id":"msg_123",...}}

event: content_block_delta
data: {"type":"content_block_delta","delta":{"type":"text_delta","text":"B"}}

event: content_block_delta
data: {"type":"content_block_delta","delta":{"type":"text_delta","text":"o"}}

event: message_stop
data: {"type":"message_stop"}
```

## Modèles pris en charge

| Modèle | Description | Groupes disponibles |
| --- | --- | --- |
| claude-fable-5-2 | Performance maximale | Claude |
| claude-opus-5-5 | Choix équilibré | Claude |

> **ASTUCE**
> Consultez la [place de marché officielle](https://llmoxy.com/) pour les modèles actuellement disponibles.

## Prise en charge multimodale

Claude prend en charge les entrées d'images :

```json
{
"model": "claude-opus-5-5",
"max_tokens": 1024,
"messages": [
{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "/9j/4AAQSkZJRg..."
}
},
{
"type": "text",
"text": "Qu'y a-t-il dans cette image ?"
}
]
}
]
}
```

Formats d'image pris en charge : JPEG, PNG, GIF, WebP. Max 5 Mo par image.

## Exemples de code

### Python (SDK officiel)

```python
from anthropic import Anthropic

client = Anthropic(
api_key="YOUR_API_KEY",
base_url="https://llmoxy.com/v1"
)

message = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
messages=[
{"role": "user", "content": "Écrivez un décorateur Python"}
]
)

print(message.content[0].text)
```

### Python (Flux)

```python
with client.messages.stream(
model="claude-opus-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Rédigez un article"}]
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
```

### Node.js (SDK officiel)

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

const client = new Anthropic({
apiKey: 'YOUR_API_KEY',
baseURL: 'https://llmoxy.com/v1'
});

const message = await client.messages.create({
model: 'claude-opus-5-5',
max_tokens: 1024,
messages: [
{ role: 'user', content: 'Écrivez un quicksort' }
]
});

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

### cURL

```bash
curl https://llmoxy.com/v1/messages \
-H "content-type: application/json" \
-H "x-api-key: YOUR_API_KEY" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hello, Claude!"}
]
}'
```

## Gestion des erreurs

### Format de la réponse d'erreur

```json
{
"type": "error",
"error": {
"type": "invalid_request_error",
"message": "Description de l'erreur"
}
}
```

### Types d'erreurs courants

| Type d'erreur | Description |
| --- | --- |
| invalid_request_error | Erreur de paramètre de requête |
| authentication_error | Échec d'authentification |
| permission_error | Permissions insuffisantes |
| not_found_error | Ressource introuvable |
| rate_limit_error | Limite de débit dépassée |
| api_error | Erreur interne |
| overloaded_error | Service surchargé |

### Exemple de gestion d'erreur

```python
from anthropic import Anthropic, APIError

client = Anthropic(
api_key="YOUR_API_KEY",
base_url="https://llmoxy.com/v1"
)

try:
message = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello"}]
)
except APIError as e:
print(f"Type d'erreur : {e.type}")
print(f"Message d'erreur : {e.message}")
```

## Utilisation avancée

### 1. Invite système

```python
message = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
system="Vous êtes un expert Python, spécialisé en analyse de données et machine learning.",
messages=[
{"role": "user", "content": "Comment gérer les valeurs manquantes avec pandas ?"}
]
)
```

### 2. Conversation multi-tours

```python
conversation = [
{"role": "user", "content": "Écrivez une classe utilisateur"},
{"role": "assistant", "content": "D'accord, je vais écrire une classe User..."},
{"role": "user", "content": "Ajoutez le chiffrement du mot de passe"}
]

message = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
messages=conversation
)
```

### 3. Analyse d'images

```python
import base64

with open("image.jpg", "rb") as f:
image_data = base64.b64encode(f.read()).decode()

message = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
messages=[
{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": image_data
}
},
{
"type": "text",
"text": "Analysez ce diagramme d'architecture"
}
]
}
]
)
```

## Bonnes pratiques

### 1. Définir max_tokens de manière raisonnable

Les modèles ont des sorties maximales différentes : Opus 32K, Sonnet 64K, Haiku 8K. Définissez en fonction des besoins réels pour éviter le gaspillage.

### 2. Utiliser le paramètre system pour les invites

Placez les définitions de rôle dans le paramètre `system`, pas dans messages :

```python
# ✅ Recommandé
message = client.messages.create(
system="Vous êtes un expert Python",
messages=[{"role": "user", "content": "Écrivez du code"}],
...
)

# ❌ Non recommandé
message = client.messages.create(
messages=[{"role": "user", "content": "Vous êtes un expert Python. Écrivez du code"}],
...
)
```

### 3. Gérer les longues conversations

Claude dispose d'une fenêtre de contexte de 200K, mais il est recommandé de résumer périodiquement les conversations et de supprimer les messages historiques peu importants pour économiser la consommation de tokens.

### 4. Implémenter une logique de réessai

```python
from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
stop=stop_after_attempt(3),
wait=wait_exponential(multiplier=1, min=4, max=10)
)
def call_claude():
return client.messages.create(...)
```

## Prochaines étapes

- [Groupes et tarification](https://fr.llmoxy.com/docs/get-started/recharge-and-pricing) — en savoir plus sur les tarifs
- [Obtenir de l'aide](mailto:contact@llmoxy.com) — contactez-nous en cas de problème

Ceci est la version markdown de https://fr.llmoxy.com/docs/api-reference/anthropic-format.
