# Complétions de chat

> Générez des complétions de chat à partir d'une liste de messages — le point d'accès principal pour la génération de texte avec tous les modèles pris en charge.

- Canonical: https://tchavi.com/fr/docs/chat-completions

---


<Endpoint method="POST" path="/v1/chat/completions" />

Générez une complétion de chat à partir d'une liste de messages. C'est le point d'accès principal pour la génération de texte avec tous les modèles pris en charge.

<Callout type="note">
  Les tableaux de paramètres ci-dessous répertorient les champs communs partagés par tous les
  modèles. Chaque modèle peut prendre en charge des paramètres supplémentaires qui lui sont propres
  (par ex. entrée vision, appel d'outils, mode JSON). Pour la liste exhaustive des paramètres
  acceptés par un modèle donné, ouvrez sa page de détails sur [Modèles](/fr/models) et basculez vers
  l'onglet **API** — la référence des paramètres y est générée à partir des capacités déclarées du
  modèle.
</Callout>

## Corps de la requête

| Paramètre           | Type               | Requis | Description                                                                                                                                                                                                                                                                                                                           |
| ------------------- | ------------------ | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `model`             | string             | Oui    | ID du modèle (par ex. « gpt-4o-mini », « claude-sonnet-4-6 »)                                                                                                                                                                                                                                                                         |
| `messages`          | array              | Oui    | Tableau d'objets message. Chacun possède un `role` (`system`, `user` ou `assistant`) et un `content` qui est soit une simple chaîne, soit un tableau de blocs de contenu (`text`, `image_url`, `document_url`). `system` définit le comportement de l'IA ; `user` est votre message ; `assistant` est une réponse antérieure de l'IA. |
| `temperature`       | number             | Non    | Contrôle l'aléatoire. 0 = déterministe/ciblé, 1 = équilibré (par défaut), 2 = très créatif/aléatoire.                                                                                                                                                                                                                                 |
| `max_tokens`        | integer            | Non    | Nombre maximal de tokens à générer                                                                                                                                                                                                                                                                                                    |
| `stream`            | boolean            | Non    | Diffuse la réponse en SSE. Par défaut : false                                                                                                                                                                                                                                                                                         |
| `top_p`             | number             | Non    | Paramètre d'échantillonnage par noyau (0–1)                                                                                                                                                                                                                                                                                           |
| `stop`              | string \| string[] | Non    | Jusqu'à 4 séquences d'arrêt. Le modèle cesse de générer dès qu'il en rencontre une.                                                                                                                                                                                                                                                   |
| `frequency_penalty` | number             | Non    | -2.0 à 2.0. Les valeurs positives pénalisent les tokens répétés. Par défaut : 0                                                                                                                                                                                                                                                       |
| `presence_penalty`  | number             | Non    | -2.0 à 2.0. Les valeurs positives orientent le modèle vers de nouveaux sujets. Par défaut : 0                                                                                                                                                                                                                                         |
| `seed`              | integer            | Non    | Graine de reproductibilité. La même graine + les mêmes paramètres renvoient une sortie similaire (au mieux).                                                                                                                                                                                                                          |
| `response_format`   | object             | Non    | `{ type: "json_object" }` ou `{ type: "json_schema", json_schema: ... }` pour une sortie structurée. La prise en charge varie selon le modèle — voir l'onglet API du modèle.                                                                                                                                                          |
| `tools`             | array              | Non    | Définitions de fonctions que le modèle peut appeler. Associé à `tool_choice`. Disponible uniquement sur les modèles compatibles avec les outils.                                                                                                                                                                                      |

<Callout type="note">
**Entrée PDF.** Joignez un PDF à un message `user` en passant un bloc de contenu avec `{ type: "document_url", document_url: { url: ... } }`. Jusqu'à 5 PDF par requête. Seuls les modèles avec `supportsDocuments: true` acceptent ce bloc — actuellement `claude-opus-4-7`, `claude-sonnet-4-6`, `claude-haiku-4-5-20251001`, `gpt-4.1` et `gpt-4.1-mini`.
</Callout>

## Exemple de requête

<CodeTabs>

```tchavi
import Tchavi from '@tchavi/sdk';

const client = new Tchavi({ apiKey: 'YOUR_API_KEY' });

const response = await client.chat.completions.create({
  model: 'gpt-4o-mini',
  messages: [
    { role: 'system', content: 'Tu es un assistant utile.' },
    { role: 'user', content: 'Quelle est la capitale du Bénin ?' },
  ],
  temperature: 0.7,
});

console.log(response.choices[0].message.content);
console.log('Crédits utilisés :', response.tchavi.credits_used);
```

```openai
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://tchavi.com/api/v1",
)

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Tu es un assistant utile."},
        {"role": "user", "content": "Quelle est la capitale du Bénin ?"},
    ],
    temperature=0.7,
)

print(response.choices[0].message.content)
```

```javascript
const response = await fetch('https://tchavi.com/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: 'Bearer YOUR_API_KEY',
  },
  body: JSON.stringify({
    model: 'gpt-4o-mini',
    messages: [
      { role: 'system', content: 'Tu es un assistant utile.' },
      { role: 'user', content: 'Quelle est la capitale du Bénin ?' },
    ],
    temperature: 0.7,
  }),
});

const data = await response.json();
console.log(data.choices[0].message.content);

// Vérifier les crédits restants
console.log('Crédits :', response.headers.get('X-Credits-Remaining'));
```

```python
import requests

response = requests.post(
    "https://tchavi.com/api/v1/chat/completions",
    headers={
        "Content-Type": "application/json",
        "Authorization": "Bearer YOUR_API_KEY",
    },
    json={
        "model": "gpt-4o-mini",
        "messages": [
            {"role": "system", "content": "Tu es un assistant utile."},
            {"role": "user", "content": "Quelle est la capitale du Bénin ?"},
        ],
        "temperature": 0.7,
    },
)

data = response.json()
print(data["choices"][0]["message"]["content"])

# Vérifier les crédits restants
print("Crédits :", response.headers.get("X-Credits-Remaining"))
```

```curl
curl -X POST https://tchavi.com/api/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [
      { "role": "system", "content": "Tu es un assistant utile." },
      { "role": "user", "content": "Quelle est la capitale du Bénin ?" }
    ],
    "temperature": 0.7
  }'
```

</CodeTabs>

## Exemple de réponse

```json
{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1711234567,
  "model": "gpt-4o-mini",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "La capitale du Bénin est Porto-Novo."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 24,
    "completion_tokens": 12,
    "total_tokens": 36
  },
  "tchavi": {
    "credits_used": 2,
    "credits_remaining": 498,
    "model_tier": "budget"
  }
}
```

## Streaming

Définissez `stream: true` pour recevoir la réponse token par token sous forme de Server-Sent Events (SSE). Cela vous permet d'afficher le texte au fur et à mesure de son arrivée plutôt que d'attendre la réponse complète.

<CodeTabs>

```tchavi
import Tchavi from '@tchavi/sdk';

const client = new Tchavi({ apiKey: process.env.TCHAVI_API_KEY });

const stream = await client.chat.completions.create({
  model: 'gpt-4o-mini',
  messages: [{ role: 'user', content: 'Raconte-moi une courte histoire.' }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
}
```

```javascript
const response = await fetch('https://tchavi.com/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: 'Bearer YOUR_API_KEY',
  },
  body: JSON.stringify({
    model: 'gpt-4o-mini',
    messages: [{ role: 'user', content: 'Raconte-moi une courte histoire.' }],
    stream: true,
  }),
});

const reader = response.body.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;

  const lines = decoder.decode(value).split('\n');
  for (const line of lines) {
    if (!line.startsWith('data: ') || line.includes('[DONE]')) continue;
    const delta = JSON.parse(line.slice(6)).choices[0]?.delta?.content ?? '';
    process.stdout.write(delta);
  }
}
```

```python
import requests, json

response = requests.post(
    "https://tchavi.com/api/v1/chat/completions",
    headers={
        "Content-Type": "application/json",
        "Authorization": "Bearer YOUR_API_KEY",
    },
    json={
        "model": "gpt-4o-mini",
        "messages": [{"role": "user", "content": "Raconte-moi une courte histoire."}],
        "stream": True,
    },
    stream=True,
)

for line in response.iter_lines():
    if not line or line == b"data: [DONE]":
        continue
    data = json.loads(line.decode().removeprefix("data: "))
    print(data["choices"][0]["delta"].get("content", ""), end="", flush=True)
```

</CodeTabs>

