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

# File Inputs

> Senden Sie Dokumente und Quelldateien an Chat-Modelle mit der Venice API

File Inputs ermöglichen es Ihnen, Dokumente und Quelldateien direkt an eine `/chat/completions`-Anfrage anzuhängen. Venice extrahiert die Datei in Text, bevor sie an das gewählte Modell gesendet wird, sodass Sie Fragen stellen, zusammenfassen, vergleichen oder Dateiinhalte transformieren können, ohne zuerst Ihren eigenen Parser zu bauen.

Verwenden Sie File Inputs, wenn Ihr Prompt vom Inhalt eines Dokuments, einer Tabelle, einer Markdown-Datei, einer JSON-Datei oder einer Code-Datei abhängt. Es handelt sich um anfragebezogene Inputs, nicht um persistente Dateispeicherung — daher fügen Sie die Datei in jede Anfrage ein, die sie benötigt.

<Info>
  File Inputs verwenden das OpenAI-kompatible Chat-Content-Array. Fügen Sie einen Content-Block mit `type: "file"` hinzu und stellen Sie den Dateiinhalt in `file.file_data` bereit.
</Info>

## Unterstützte Dateitypen

Die Chat-API akzeptiert File Inputs entweder als base64-Data-URLs oder als öffentlich zugängliche URLs.

Die maximale Dateigröße beträgt **25 MB pro Datei**, gemessen nach der Dekodierung einer base64-Data-URL bzw. nach dem Abrufen einer URL.

| Kategorie      | Formate                                                                                                                                       |
| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| Dokumente      | PDF, DOCX, PPTX                                                                                                                               |
| Tabellen       | XLSX, XLS, CSV                                                                                                                                |
| Text und Daten | TXT, Markdown, JSON                                                                                                                           |
| Quellcode      | Die meisten gängigen Code-Dateien, einschließlich `.py`, `.js`, `.ts`, `.c`, `.cpp`, `.java`, `.go`, `.rs`, `.ps1`, `.sh`, `.yaml` und `.sql` |

<Note>
  Dateien werden vor der Inferenz in Text extrahiert. Der extrahierte Text zählt zum Eingabekontext des Modells, also wählen Sie ein Modell mit ausreichend `availableContextTokens` für die Datei plus Ihre Anweisungen und die erwartete Antwort.
</Note>

## Grundlegende Verwendung

Senden Sie ein `messages`-Array, in dem das `content` der Benutzernachricht ein Array aus Text- und Datei-Blöcken ist:

<CodeGroup>
  ```python Python theme={"dark"}
  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={"dark"}
  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={"dark"}
  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>

## Datei-URLs

Wenn die Datei bereits unter einer öffentlichen HTTP- oder HTTPS-URL gehostet wird, übergeben Sie die URL in `file_data` statt sie base64-zu-kodieren:

```json theme={"dark"}
{
  "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>
  Verwenden Sie nur öffentliche URLs, die Venice ohne Authentifizierung abrufen kann. Für private Dateien senden Sie eine base64-Data-URL.
</Warning>

## Mehrere Dateien

Sie können mehr als einen Datei-Block in derselben Nachricht einfügen. Schreiben Sie vor den Dateien eine kurze Textanweisung, damit das Modell weiß, wie es sie verwenden soll.

```json theme={"dark"}
{
  "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"
          }
        }
      ]
    }
  ]
}
```

Für beste Ergebnisse benennen Sie jede Datei eindeutig und verweisen in Ihrem Prompt auf diese Namen.

## Data-URLs

Für lokale Dateien kodieren Sie die Datei-Bytes als base64 und stellen ihnen den korrekten MIME-Typ voran:

| Dateityp | Data-URL-Prefix                                                                          |
| -------- | ---------------------------------------------------------------------------------------- |
| 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,`                                                             |
| Klartext | `data:text/plain;base64,`                                                                |
| JSON     | `data:application/json;base64,`                                                          |

Wenn Sie den genauen MIME-Typ nicht kennen, verwenden Sie `application/octet-stream`. Ein korrekter `filename` hilft Venice weiterhin, die Datei zu identifizieren und anzuzeigen.

## Umgang mit großen Dateien

Da Dateien zu Prompt-Text werden, können große Dateien Latenz, Token-Verbrauch und Kosten erhöhen. Behalten Sie das Kontextfenster des Modells im Auge.

Die Rohdatei muss 25 MB oder kleiner sein. Base64-Kodierung erhöht die Anfragegröße um etwa 33 %, daher ergibt eine Datei nahe dem 25-MB-Limit einen größeren JSON-Request-Body.

Gute Muster für große Dateien:

* Bitten Sie um eine konkrete Aufgabe statt um einen breiten "Analysiere alles"-Prompt.
* Fügen Sie nur die Dokumente bei, die für die aktuelle Antwort benötigt werden.
* Verwenden Sie Modelle mit größeren `availableContextTokens` für lange Berichte oder Codebases.
* Platzieren Sie stabile, wiederholt verwendete Dokumente vor dynamischen Benutzeranfragen, wenn Sie zusätzlich [Prompt Caching](/guides/features/prompt-caching) verwenden.
* Verwenden Sie `stream: true`, wenn Sie eine lange Antwort erwarten.

## File Inputs vs. Text Parser

Verwenden Sie Chat-File-Inputs, wenn das Modell sofort über die Datei räsonieren soll.

Verwenden Sie die [Text-Parser-API](/api-reference/endpoint/augment/text-parser), wenn Sie zuerst Text extrahieren, die Token-Anzahl prüfen, den extrahierten Text in Ihrem eigenen System speichern oder denselben extrahierten Text an mehrere Anfragen senden möchten.

| Bedarf                                                 | Verwenden                                          |
| ------------------------------------------------------ | -------------------------------------------------- |
| Ein Modell in einer Anfrage zu einem Dokument befragen | Chat-File-Input                                    |
| Text ohne Modell-Inferenz extrahieren                  | Text-Parser-API                                    |
| Extrahierte Token-Anzahl vor dem Prompt prüfen         | Text-Parser-API                                    |
| Extrahierten Text in vielen Anfragen wiederverwenden   | Text-Parser-API, dann den Text in Prompts einfügen |

## Best Practices

* Geben Sie nach Möglichkeit immer einen `filename` an, insbesondere bei mehreren Dateien.
* Schreiben Sie die Anweisung vor die Datei-Blöcke, damit das Modell die Aufgabe kennt, bevor es den extrahierten Inhalt liest.
* Verwenden Sie öffentliche URLs nur für Dateien, die ohne Cookies, Header oder signierten Session-Zustand abrufbar sind.
* Bevorzugen Sie base64-Data-URLs für private Dateien oder Dateien, die in Ihrer Anwendung generiert werden.
* Stellen Sie fokussierte Fragen und geben Sie das gewünschte Ausgabeformat an.
* Für strukturierte Extraktion kombinieren Sie File Inputs mit [strukturierten Antworten](/guides/features/structured-responses).

## Troubleshooting

<AccordionGroup>
  <Accordion title="Das Modell sagt, es kann nicht auf die Datei zugreifen">
    Stellen Sie sicher, dass das Nachrichten-Content ein Array verwendet und einen `type: "file"`-Block enthält. Wenn Sie eine URL verwendet haben, verifizieren Sie, dass sie öffentlich ohne Authentifizierung erreichbar ist.
  </Accordion>

  <Accordion title="Die Anfrage ist langsam oder teuer">
    Die Datei wird möglicherweise zu sehr viel Text extrahiert. Verwenden Sie ein Modell mit größerem Kontext, schränken Sie die Aufgabe ein, senden Sie weniger Dateien oder vorextrahieren und kürzen Sie den Text mit der Text-Parser-API.
  </Accordion>

  <Accordion title="Die Antwort ignoriert eine meiner Dateien">
    Geben Sie jeder Datei einen aussagekräftigen `filename` und verweisen Sie in Ihrem Prompt direkt auf die Dateinamen. Beispiel: "Compare `policy-v1.pdf` against `policy-v2.pdf`."
  </Accordion>

  <Accordion title="Ein Modell lehnt den Dateiinhalt ab">
    File Inputs sind auf kompatiblen Chat-Modellen verfügbar. Prüfen Sie die [Models-Seite](/models/overview) für aktuelle Modell-Capabilities und Kontextlimits oder versuchen Sie ein aktuelles Textmodell mit großem Kontext.
  </Accordion>
</AccordionGroup>
