> ## Documentation Index
> Fetch the complete documentation index at: https://novita.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Grands modèles de langage

## Capacités des modèles

Les grands modèles de langage (LLM) sont des types de modèles d’IA construits à l’aide de techniques d’apprentissage profond et de traitement du langage naturel. Après avoir été entraînés sur d’immenses quantités de données textuelles, ils peuvent comprendre, générer et traiter le langage humain. Les LLM disposent des principales capacités suivantes :

* **Génération de texte**

  Les LLM peuvent générer un contenu logiquement cohérent en fonction du contexte et ajuster le style de sortie selon les besoins.
* **Compréhension du langage**

  Les LLM peuvent comprendre avec précision le sens du texte d’entrée et prendre en charge des conversations tenant compte du contexte.
* **Traduction de texte**

  Les LLM sont capables de compréhension et de génération multilingues, ce qui permet la traduction entre différentes langues.
* **Questions-réponses basées sur les connaissances**

  Grâce à une vaste base de connaissances, les LLM peuvent répondre à des questions dans des domaines tels que la culture, la science et l’histoire.
* **Compréhension et génération de code**

  Les LLM peuvent comprendre et générer du code (Python, Java, C++, etc.), détecter les erreurs de code et proposer des suggestions.
* **Classification et résumé de texte**

  Les LLM peuvent comprendre des phrases complexes, catégoriser et extraire des informations, ainsi que résumer les points clés.

## Sélection du modèle

Sur la [page du service LLM](https://novita.ai/models), vous pouvez parcourir la liste des modèles pris en charge, découvrir les bases des modèles et consulter les tarifs. Cliquez sur un modèle spécifique pour ouvrir sa page de détail et accéder à une démonstration en ligne. Après avoir essayé différents modèles avec votre tâche, vous pouvez les comparer et choisir celui qui convient le mieux.

## Intégration de l’API

Novita AI fournit des API rapides et fiables pour les modèles open source, combinant la simplicité et la fiabilité des meilleures API LLM avec la flexibilité et la rentabilité des LLM open source.

* [ChatCompletion](https://platform.openai.com/docs/guides/text-generation/chat-completions-api) : prend en charge les modes streaming et non streaming.
* [Completion](https://platform.openai.com/docs/guides/text-generation/completions-api) : prend également en charge les modes streaming et non streaming.

Si vous utilisez déjà l’API `ChatCompletion` ou `Completion` d’OpenAI, définissez simplement votre URL de base sur : api.novita.ai/openai , obtenez et configurez votre clé API, puis mettez à jour le nom du modèle si nécessaire pour commencer à utiliser les services LLM.

<Tip>
  Pour savoir comment créer, stocker et utiliser une clé API, consultez [Clés API](/docs/fr/guides/llm-api-keys).
</Tip>

## Exemples de code

### Python

<CodeGroup>
  ```python ChatCompletion theme={"system"}
  from openai import OpenAI

  client = OpenAI(
      base_url="https://api.novita.ai/openai",
      api_key="<Your API Key>",
  )

  model = "deepseek/deepseek-r1"
  stream = True  # or False
  max_tokens = 512

  chat_completion_res = client.chat.completions.create(
      model=model,
      messages=[
          {
              "role": "system",
              "content": "you are a professional AI helper.",
          },
          {
              "role": "user",
              "content": "Where can the example of GPU provided by novita ai be adapted?",
          }
      ],
      stream=stream,
      max_tokens=max_tokens,
  )

  if stream:
      for chunk in chat_completion_res:
          print(chunk.choices[0].delta.content or "", end="")
  else:
      print(chat_completion_res.choices[0].message.content)
  ```

  ```python Completion theme={"system"}
  from openai import OpenAI

  client = OpenAI(
      base_url="https://api.novita.ai/openai",
      api_key="<Your API Key>",
  )

  model = "deepseek/deepseek-r1"
  stream = True  # or False
  max_tokens = 512

  completion_res = client.completions.create(
      model=model,
      prompt="Where can the example of GPU provided by novita ai be adapted?",
      stream=stream,
      max_tokens=max_tokens,
  )

  if stream:
      for chunk in completion_res:
          print(chunk.choices[0].text or "", end="")
  else:
      print(completion_res.choices[0].text)
  ```
</CodeGroup>

### Curl

<CodeGroup>
  ```bash ChatCompletion theme={"system"}
  export API_KEY="<Your API Key>"

  curl "https://api.novita.ai/openai/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer ${API_KEY}" \
    -d '{
      "model": "deepseek/deepseek-r1",
      "messages": [
          {
              "role": "system",
              "content": "you are a professional AI helper."
          },
         {
              "role": "user",
              "content": "Where can the example of GPU provided by novita ai be adapted?"
          }
      ],
      "max_tokens": 512
  }'
  ```

  ```bash Completion theme={"system"}
  export API_KEY="<Your API Key>"

  curl "https://api.novita.ai/openai/v1/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer ${API_KEY}" \
    -d '{
      "model": "deepseek/deepseek-r1",
      "prompt": "Where can the example of GPU provided by novita ai be adapted?",
      "max_tokens": 512
  }'
  ```
</CodeGroup>

## Paramètres clés

### Paramètres de base

`model` : le LLM cible. Consultez la liste complète sur la [page du service LLM](https://novita.ai/models).

### Messages

> ChatCompletion uniquement

`messages` : entrées et sorties lors de l’interaction avec le LLM. Chaque message appartient à un rôle. Les messages peuvent vous aider à obtenir de meilleurs résultats ; vous pouvez essayer différentes méthodes pour améliorer les sorties.

* `content` : contenu du message.
* `role` : définit l’interlocuteur :
  * `system` : définit le rôle de l’IA, en indiquant au modèle son rôle ou son comportement.
  * `user` : l’entrée de l’utilisateur.
  * `assistant` : la réponse de l’IA. Les utilisateurs peuvent fournir à l’avance des exemples de sortie, afin d’indiquer au modèle comment répondre à la requête actuelle.
* `name` (facultatif) : permet de distinguer les auteurs de messages ayant le même rôle.

### Prompt

> ChatCompletion uniquement

`prompt` : texte d’instruction destiné à générer une complétion, rédigé par l’utilisateur à l’attention du LLM afin d’indiquer clairement au modèle sa tâche.

### Contrôle de la sortie

Différentes combinaisons de paramètres peuvent aider le modèle à générer un contenu plus satisfaisant.

**Diversité du texte**

> 'temperature' et 'top\_p' peuvent contrôler la diversité du texte généré ; nous vous conseillons de n’en définir qu’un seul. Plus la valeur définie est élevée, plus le texte sera diversifié. Plus la valeur définie est faible, plus le texte sera précis.

* `temperature` : contrôle l’aléatoire. Plus élevé = plus créatif.
* `top_p` : échantillonnage par noyau. Contrôle la probabilité cumulée.
* `top_k` : limite le nombre de tokens candidats.

**Pénalités de répétition**

* `presence_penalty` : contrôle les tokens répétés dans les textes. Si un token existe déjà dans le texte, une pénalité s’applique, ce qui entraîne davantage de tokens dans le texte.
* `frequency_penalty` : contrôle la fréquence des tokens dans les textes. Chaque fois que le même token existe dans le texte, une pénalité s’applique, ce qui réduit la présence future du même token dans le texte.
* `repetition_penalty` : pénalise ou encourage la répétition.

### Limites de sortie

* `max_tokens` : nombre maximal de tokens dans une réponse. Le contenu au-delà de cette valeur dans le texte sera tronqué.
* `stream` : indique s’il faut utiliser le streaming. Pour les sorties longues, nous vous conseillons d’utiliser le mode streaming afin d’éviter les erreurs de délai d’expiration :
  * `true` : résultats partiels en streaming au fur et à mesure de leur génération.
  * `false` : résultat complet après traitement.
* `stop` : chaînes qui mettront fin à la génération lorsqu’elles seront rencontrées.