> ## 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.

# Entradas de archivo

> Envía documentos y archivos fuente a modelos de chat con la API de Venice

Las entradas de archivo te permiten adjuntar documentos y archivos fuente directamente a una solicitud `/chat/completions`. Venice extrae el archivo a texto antes de enviarlo al modelo seleccionado, para que puedas hacer preguntas, resumir, comparar o transformar el contenido del archivo sin tener que construir antes tu propio parser.

Usa entradas de archivo cuando tu prompt dependa del contenido de un documento, hoja de cálculo, archivo markdown, archivo JSON o archivo de código. Son entradas con alcance de solicitud, no almacenamiento de archivos persistente, así que incluye el archivo en cada solicitud que lo necesite.

<Info>
  Las entradas de archivo usan el array de contenido de chat compatible con OpenAI. Añade un bloque de contenido con `type: "file"` y proporciona el contenido del archivo en `file.file_data`.
</Info>

## Tipos de archivo admitidos

La API de chat acepta entradas de archivo como data URLs en base64 o como URLs públicamente accesibles.

El tamaño máximo de archivo es de **25 MB por archivo**, medido después de decodificar una data URL en base64 o después de descargar una URL.

| Categoría        | Formatos                                                                                                                                       |
| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| Documentos       | PDF, DOCX, PPTX                                                                                                                                |
| Hojas de cálculo | XLSX, XLS, CSV                                                                                                                                 |
| Texto y datos    | TXT, Markdown, JSON                                                                                                                            |
| Código fuente    | La mayoría de archivos de código comunes, incluyendo `.py`, `.js`, `.ts`, `.c`, `.cpp`, `.java`, `.go`, `.rs`, `.ps1`, `.sh`, `.yaml` y `.sql` |

<Note>
  Los archivos se extraen a texto antes de la inferencia. El texto extraído cuenta para el contexto de entrada del modelo, así que elige un modelo con suficientes `availableContextTokens` para el archivo más tus instrucciones y la respuesta esperada.
</Note>

## Uso básico

Envía un array `messages` donde el `content` del mensaje de usuario sea un array de bloques de texto y archivo:

<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>

## URLs de archivo

Si el archivo ya está alojado en una URL pública HTTP o HTTPS, pasa la URL en `file_data` en lugar de codificarlo en base64:

```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>
  Usa solo URLs públicas que Venice pueda descargar sin autenticación. Para archivos privados, envía una data URL en base64.
</Warning>

## Múltiples archivos

Puedes incluir más de un bloque de archivo en el mismo mensaje. Pon una instrucción de texto breve antes de los archivos para que el modelo sepa cómo usarlos.

```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"
          }
        }
      ]
    }
  ]
}
```

Para mejores resultados, nombra claramente cada archivo y haz referencia a esos nombres en tu prompt.

## Data URLs

Para archivos locales, codifica los bytes del archivo como base64 y antepónles el tipo MIME correcto:

| Tipo de archivo | Prefijo 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,`                                                             |
| Texto plano     | `data:text/plain;base64,`                                                                |
| JSON            | `data:application/json;base64,`                                                          |

Si no conoces el tipo MIME exacto, usa `application/octet-stream`. Incluir un `filename` preciso sigue ayudando a Venice a identificar y mostrar el archivo.

## Trabajar con archivos grandes

Como los archivos se convierten en texto del prompt, los archivos grandes pueden aumentar la latencia, el uso de tokens y el coste. Ten en cuenta la ventana de contexto del modelo.

El archivo bruto debe ser de 25 MB o menos. La codificación base64 incrementa el tamaño de la solicitud aproximadamente un 33 %, así que un archivo cercano al límite de 25 MB producirá un cuerpo de solicitud JSON más grande.

Buenos patrones para archivos grandes:

* Pide una tarea específica en lugar de un prompt amplio "analiza todo".
* Incluye solo los documentos necesarios para la respuesta actual.
* Usa modelos con mayor `availableContextTokens` para informes o bases de código largas.
* Pon los documentos estables y repetidos antes de las preguntas dinámicas del usuario si también estás usando [prompt caching](/guides/features/prompt-caching).
* Usa `stream: true` cuando esperes una respuesta larga.

## Entradas de archivo vs. Text Parser

Usa entradas de archivo en chat cuando quieras que el modelo razone sobre el archivo de inmediato.

Usa la [Text Parser API](/api-reference/endpoint/augment/text-parser) cuando quieras extraer el texto primero, inspeccionar el recuento de tokens, almacenar el texto extraído en tu propio sistema o enviar el mismo texto extraído a varias solicitudes.

| Necesidad                                                          | Usar                                                    |
| ------------------------------------------------------------------ | ------------------------------------------------------- |
| Preguntar a un modelo sobre un documento en una sola solicitud     | Entrada de archivo en chat                              |
| Extraer texto sin inferencia del modelo                            | Text Parser API                                         |
| Comprobar el recuento de tokens extraídos antes de hacer el prompt | Text Parser API                                         |
| Reutilizar el texto extraído en muchas solicitudes                 | Text Parser API y luego incluir el texto en los prompts |

## Mejores prácticas

* Incluye `filename` siempre que sea posible, especialmente al enviar varios archivos.
* Pon la instrucción antes de los bloques de archivo para que el modelo conozca la tarea antes de leer el contenido extraído.
* Usa URLs públicas solo para archivos que se puedan descargar sin cookies, cabeceras o estado de sesión firmado.
* Prefiere data URLs en base64 para archivos privados o archivos generados dentro de tu aplicación.
* Haz preguntas enfocadas y especifica el formato de salida que quieres.
* Para extracción estructurada, combina las entradas de archivo con [respuestas estructuradas](/guides/features/structured-responses).

## Resolución de problemas

<AccordionGroup>
  <Accordion title="El modelo dice que no puede acceder al archivo">
    Asegúrate de que el contenido del mensaje usa un array e incluye un bloque `type: "file"`. Si usaste una URL, verifica que sea accesible públicamente sin autenticación.
  </Accordion>

  <Accordion title="La solicitud es lenta o cara">
    El archivo puede extraerse a una gran cantidad de texto. Usa un modelo de contexto más grande, acota la tarea, envía menos archivos o pre-extrae y recorta el texto con la Text Parser API.
  </Accordion>

  <Accordion title="La respuesta ignora uno de mis archivos">
    Dale a cada archivo un `filename` descriptivo y haz referencia a los nombres de archivo directamente en tu prompt. Por ejemplo, "Compara `policy-v1.pdf` con `policy-v2.pdf`."
  </Accordion>

  <Accordion title="Un modelo rechaza el contenido del archivo">
    Las entradas de archivo están disponibles en modelos de chat compatibles. Consulta la [página de modelos](/models/overview) para conocer las capacidades actuales de los modelos y los límites de contexto, o prueba un modelo de texto actual con gran contexto.
  </Accordion>
</AccordionGroup>
