> ## Documentation Index
> Fetch the complete documentation index at: https://veniceai-mintlify-d2fddb8a.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Entrées de fichiers

> Joignez des fichiers PDF, des documents Office, des fichiers texte, de données et de code source à vos requêtes de complétion de chat Venice pour la synthèse, les questions-réponses et la transformation.

Les entrées de fichiers vous permettent de joindre des documents et fichiers sources directement à une requête `/chat/completions`. Venice extrait le fichier en texte avant de l'envoyer au modèle sélectionné, ce qui vous permet de poser des questions, résumer, comparer ou transformer le contenu d'un fichier sans avoir à créer votre propre analyseur au préalable.

Utilisez les entrées de fichiers lorsque votre prompt dépend du contenu d'un document, d'une feuille de calcul, d'un fichier markdown, d'un fichier JSON ou d'un fichier de code. Ce sont des entrées limitées à la requête, et non du stockage de fichiers persistant ; incluez donc le fichier dans chaque requête qui en a besoin.

<Info>
  Les entrées de fichiers utilisent le tableau de contenu de chat compatible avec OpenAI. Ajoutez un bloc de contenu avec `type: "file"` et fournissez le contenu du fichier dans `file.file_data`.
</Info>

## Types de fichiers pris en charge

L'API de chat accepte les entrées de fichiers sous forme de data URL en base64 ou d'URL publiquement accessibles.

La taille maximale d'un fichier est de **25 Mo par fichier**, mesurée après décodage d'une data URL base64 ou après récupération d'une URL.

| Catégorie          | Formats                                                                                                                                        |
| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| Documents          | PDF, DOCX, PPTX                                                                                                                                |
| Feuilles de calcul | XLSX, XLS, CSV                                                                                                                                 |
| Texte et données   | TXT, Markdown, JSON                                                                                                                            |
| Code source        | La plupart des fichiers de code courants, notamment `.py`, `.js`, `.ts`, `.c`, `.cpp`, `.java`, `.go`, `.rs`, `.ps1`, `.sh`, `.yaml` et `.sql` |

<Note>
  Les fichiers sont extraits en texte avant l'inférence. Le texte extrait est comptabilisé dans le contexte d'entrée du modèle ; choisissez donc un modèle avec un `availableContextTokens` suffisant pour le fichier, plus vos instructions et la réponse attendue.
</Note>

## Utilisation de base

Envoyez un tableau `messages` où le `content` du message utilisateur est un tableau de blocs de texte et de fichiers :

<CodeGroup>
  ```python Python theme={null}
  import base64
  import os
  from pathlib import Path

  from openai import OpenAI

  client = OpenAI(
      api_key=os.environ["VENICE_API_KEY"],
      base_url="https://api.venice.ai/api/v1",
  )

  path = Path("q3-report.pdf")
  file_data = "data:application/pdf;base64," + base64.b64encode(path.read_bytes()).decode("utf-8")

  response = client.chat.completions.create(
      model="openai-gpt-55",
      messages=[
          {
              "role": "user",
              "content": [
                  {
                      "type": "text",
                      "text": "Summarize this report in five bullets and list the main risks.",
                  },
                  {
                      "type": "file",
                      "file": {
                          "file_data": file_data,
                          "filename": "q3-report.pdf",
                      },
                  },
              ],
          }
      ],
  )

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

  ```javascript Node.js theme={null}
  import OpenAI from "openai";
  import { readFile } from "node:fs/promises";

  const client = new OpenAI({
    apiKey: process.env.VENICE_API_KEY,
    baseURL: "https://api.venice.ai/api/v1",
  });

  const pdf = await readFile("q3-report.pdf");
  const fileData = `data:application/pdf;base64,${pdf.toString("base64")}`;

  const response = await client.chat.completions.create({
    model: "openai-gpt-55",
    messages: [
      {
        role: "user",
        content: [
          {
            type: "text",
            text: "Summarize this report in five bullets and list the main risks.",
          },
          {
            type: "file",
            file: {
              file_data: fileData,
              filename: "q3-report.pdf",
            },
          },
        ],
      },
    ],
  });

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

  ```bash cURL theme={null}
  PDF_BASE64=$(base64 < q3-report.pdf | tr -d '\n')

  curl https://api.venice.ai/api/v1/chat/completions \
    -H "Authorization: Bearer $VENICE_API_KEY" \
    -H "Content-Type: application/json" \
    -d @- <<EOF
  {
    "model": "openai-gpt-55",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "Summarize this report in five bullets and list the main risks."
          },
          {
            "type": "file",
            "file": {
              "file_data": "data:application/pdf;base64,$PDF_BASE64",
              "filename": "q3-report.pdf"
            }
          }
        ]
      }
    ]
  }
  EOF
  ```
</CodeGroup>

## URL de fichiers

Si le fichier est déjà hébergé à une URL HTTP ou HTTPS publique, transmettez l'URL dans `file_data` au lieu de l'encoder en base64 :

```json theme={null}
{
  "model": "openai-gpt-55",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Identify the governing law, renewal terms, and termination rights in this agreement."
        },
        {
          "type": "file",
          "file": {
            "file_data": "https://example.com/contracts/vendor-agreement.pdf",
            "filename": "vendor-agreement.pdf"
          }
        }
      ]
    }
  ]
}
```

<Warning>
  N'utilisez que des URL publiques que Venice peut récupérer sans authentification. Pour les fichiers privés, envoyez une data URL en base64.
</Warning>

## Plusieurs fichiers

Vous pouvez inclure plusieurs blocs de fichiers dans le même message. Placez une courte instruction textuelle avant les fichiers afin que le modèle sache comment les utiliser.

```json theme={null}
{
  "model": "openai-gpt-55",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Compare these two policy drafts. Return the material differences and recommend which version is clearer."
        },
        {
          "type": "file",
          "file": {
            "file_data": "data:application/pdf;base64,JVBERi0xLjQK...",
            "filename": "policy-v1.pdf"
          }
        },
        {
          "type": "file",
          "file": {
            "file_data": "data:application/pdf;base64,JVBERi0xLjQK...",
            "filename": "policy-v2.pdf"
          }
        }
      ]
    }
  ]
}
```

Pour de meilleurs résultats, nommez chaque fichier clairement et faites référence à ces noms dans votre prompt.

## Data URL

Pour les fichiers locaux, encodez les octets du fichier en base64 et préfixez-les avec le type MIME correct :

| Type de fichier | Préfixe de data URL                                                                      |
| --------------- | ---------------------------------------------------------------------------------------- |
| PDF             | `data:application/pdf;base64,`                                                           |
| DOCX            | `data:application/vnd.openxmlformats-officedocument.wordprocessingml.document;base64,`   |
| PPTX            | `data:application/vnd.openxmlformats-officedocument.presentationml.presentation;base64,` |
| XLSX            | `data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64,`         |
| CSV             | `data:text/csv;base64,`                                                                  |
| Markdown        | `data:text/markdown;base64,`                                                             |
| Texte brut      | `data:text/plain;base64,`                                                                |
| JSON            | `data:application/json;base64,`                                                          |

Si vous ne connaissez pas le type MIME exact, utilisez `application/octet-stream`. Inclure un `filename` précis aide tout de même Venice à identifier et afficher le fichier.

## Travailler avec des fichiers volumineux

Comme les fichiers deviennent du texte de prompt, les gros fichiers peuvent augmenter la latence, la consommation de tokens et le coût. Gardez à l'esprit la fenêtre de contexte du modèle.

Le fichier brut doit faire 25 Mo ou moins. L'encodage base64 augmente la taille de la requête d'environ 33 %, donc un fichier proche de la limite de 25 Mo produira un corps de requête JSON plus volumineux.

Bonnes pratiques pour les fichiers volumineux :

* Demandez une tâche précise au lieu d'un prompt général de type « analyse tout ».
* N'incluez que les documents nécessaires à la réponse en cours.
* Utilisez des modèles avec un `availableContextTokens` plus grand pour les longs rapports ou bases de code.
* Placez les documents stables et répétés avant les questions dynamiques de l'utilisateur si vous utilisez également la [mise en cache des prompts](/guides/features/prompt-caching).
* Utilisez `stream: true` lorsque vous attendez une longue réponse.

## Entrées de fichiers vs. Text Parser

Utilisez les entrées de fichiers de chat lorsque vous voulez que le modèle raisonne immédiatement sur le fichier.

Utilisez l'[API Text Parser](/api-reference/endpoint/augment/text-parser) lorsque vous voulez d'abord extraire le texte, inspecter le nombre de tokens, stocker le texte extrait dans votre propre système, ou envoyer le même texte extrait à plusieurs requêtes.

| Besoin                                                    | Utiliser                                                |
| --------------------------------------------------------- | ------------------------------------------------------- |
| Interroger un modèle sur un document en une seule requête | Entrée de fichier de chat                               |
| Extraire du texte sans inférence de modèle                | API Text Parser                                         |
| Vérifier le nombre de tokens extraits avant de prompter   | API Text Parser                                         |
| Réutiliser le texte extrait dans plusieurs requêtes       | API Text Parser, puis inclure le texte dans les prompts |

## Bonnes pratiques

* Incluez `filename` chaque fois que possible, surtout lorsque vous envoyez plusieurs fichiers.
* Placez l'instruction avant les blocs de fichiers afin que le modèle connaisse la tâche avant de lire le contenu extrait.
* N'utilisez des URL publiques que pour les fichiers récupérables sans cookies, en-têtes ou état de session signé.
* Préférez les data URL en base64 pour les fichiers privés ou ceux générés à l'intérieur de votre application.
* Posez des questions ciblées et précisez le format de sortie souhaité.
* Pour l'extraction structurée, combinez les entrées de fichiers avec les [réponses structurées](/guides/features/structured-responses).

## Dépannage

<AccordionGroup>
  <Accordion title="Le modèle dit qu'il ne peut pas accéder au fichier">
    Assurez-vous que le contenu du message utilise un tableau et inclut un bloc `type: "file"`. Si vous avez utilisé une URL, vérifiez qu'elle est publiquement accessible sans authentification.
  </Accordion>

  <Accordion title="La requête est lente ou coûteuse">
    Le fichier peut s'extraire en une grande quantité de texte. Utilisez un modèle à plus grand contexte, restreignez la tâche, envoyez moins de fichiers, ou pré-extrayez et réduisez le texte avec l'API Text Parser.
  </Accordion>

  <Accordion title="La réponse ignore l'un de mes fichiers">
    Donnez à chaque fichier un `filename` descriptif et faites référence aux noms de fichiers directement dans votre prompt. Par exemple, « Compare `policy-v1.pdf` à `policy-v2.pdf`. »
  </Accordion>

  <Accordion title="Un modèle rejette le contenu du fichier">
    Les entrées de fichiers sont disponibles sur les modèles de chat compatibles. Consultez la [page Modèles](/models/overview) pour connaître les capacités et limites de contexte actuelles des modèles, ou essayez un modèle texte récent à grand contexte.
  </Accordion>
</AccordionGroup>
