File inputs

Subir archivos a OpenAI

La API Files de OpenAI permite cargar documentos directamente en la plataforma para su posterior procesamiento con modelos de inteligencia artificial. Esta funcionalidad resulta fundamental para aplicaciones de RAG, ya que nos permite trabajar con contenido documental de forma eficiente sin necesidad de procesar manualmente cada archivo.

El proceso de subida de archivos se realiza mediante el endpoint /v1/files, que acepta diversos formatos de documento y los almacena de forma segura en los servidores de OpenAI. Una vez subido, cada archivo recibe un identificador único que podemos utilizar en nuestras consultas posteriores.

Subida básica de archivos

Para subir un archivo utilizamos el método files.create() del cliente de OpenAI. El proceso requiere especificar el archivo a subir y el propósito del mismo:

from openai import OpenAI

client = OpenAI()

# Subir un archivo PDF
file = client.files.create(
    file=open("documento.pdf", "rb"),
    purpose="user_data"
)

print(f"Archivo subido con ID: {file.id}")
print(f"Nombre del archivo: {file.filename}")
print(f"Tamaño: {file.bytes} bytes")

El parámetro purpose indica el uso previsto del archivo. Para archivos que utilizaremos como entrada en modelos, recomendamos usar "user_data", aunque la API acepta otros valores según el contexto de uso.

Ejemplo:

Una vez subido el archivo podemos hacer preguntas sobre el mismo:

Es decir, openai gestiona automáticamente la búsqueda sobre el archivo. No obstante en siguientes lecciones hablaremos en más detalle de cómo funciona a nivel interno, con los conceptos de embeddings y bases de datos vectoriales.

Gestión de diferentes formatos

La API Files admite múltiples formatos de documento, siendo PDF el más común para aplicaciones de RAG. También podemos trabajar con archivos de texto plano, documentos de Word y otros formatos estructurados:

# Subir diferentes tipos de archivo
archivos = [
    ("informe.pdf", "user_data"),
    ("datos.txt", "user_data"),
    ("manual.docx", "user_data")
]

archivos_subidos = []

for nombre_archivo, proposito in archivos:
    try:
        file = client.files.create(
            file=open(nombre_archivo, "rb"),
            purpose=proposito
        )
        archivos_subidos.append({
            'id': file.id,
            'nombre': file.filename,
            'tamaño': file.bytes
        })
        print(f"✓ {nombre_archivo} subido correctamente")
    except Exception as e:
        print(f"✗ Error subiendo {nombre_archivo}: {e}")

Verificación y listado de archivos

Una vez subidos los archivos, podemos verificar su estado y obtener información detallada sobre los mismos. La API proporciona métodos para listar y consultar archivos individuales:

# Listar todos los archivos subidos
archivos = client.files.list()

print("Archivos disponibles:")
for archivo in archivos.data:
    print(f"- ID: {archivo.id}")
    print(f"  Nombre: {archivo.filename}")
    print(f"  Tamaño: {archivo.bytes} bytes")
    print(f"  Fecha: {archivo.created_at}")
    print()

# Obtener información de un archivo específico
archivo_info = client.files.retrieve("file-abc123")
print(f"Detalles del archivo: {archivo_info.filename}")

Manejo de errores y validaciones

Al trabajar con subida de archivos, es importante implementar un manejo robusto de errores. Los fallos más comunes incluyen archivos demasiado grandes, formatos no soportados o problemas de conectividad:

import os

def subir_archivo_seguro(ruta_archivo, proposito="user_data"):
    """
    Sube un archivo con validaciones y manejo de errores
    """
    # Verificar que el archivo existe
    if not os.path.exists(ruta_archivo):
        raise FileNotFoundError(f"El archivo {ruta_archivo} no existe")
    
    # Verificar el tamaño del archivo (máximo 32MB)
    tamaño_archivo = os.path.getsize(ruta_archivo)
    if tamaño_archivo > 32 * 1024 * 1024:  # 32MB en bytes
        raise ValueError("El archivo excede el límite de 32MB")
    
    try:
        with open(ruta_archivo, "rb") as archivo:
            file = client.files.create(
                file=archivo,
                purpose=proposito
            )
        
        return {
            'id': file.id,
            'nombre': file.filename,
            'tamaño': file.bytes,
            'estado': 'subido'
        }
    
    except Exception as e:
        return {
            'error': str(e),
            'estado': 'error'
        }

# Uso de la función
resultado = subir_archivo_seguro("documento_grande.pdf")
if 'error' in resultado:
    print(f"Error: {resultado['error']}")
else:
    print(f"Archivo subido: {resultado['id']}")

Eliminación de archivos

Para mantener un control eficiente del almacenamiento y los costes, podemos eliminar archivos que ya no necesitemos. La API proporciona un método específico para esta operación:

# Eliminar un archivo específico
try:
    client.files.delete("file-abc123")
    print("Archivo eliminado correctamente")
except Exception as e:
    print(f"Error eliminando archivo: {e}")

# Eliminar archivos antiguos (ejemplo con filtro por fecha)
import time

archivos = client.files.list()
tiempo_limite = time.time() - (7 * 24 * 60 * 60)  # 7 días atrás

for archivo in archivos.data:
    if archivo.created_at < tiempo_limite:
        try:
            client.files.delete(archivo.id)
            print(f"Eliminado archivo antiguo: {archivo.filename}")
        except Exception as e:
            print(f"Error eliminando {archivo.filename}: {e}")

La gestión adecuada de archivos subidos incluye tanto la organización inicial como el mantenimiento posterior, asegurando que nuestro espacio de almacenamiento se utilice de forma eficiente y que los archivos estén disponibles cuando los necesitemos para nuestras aplicaciones de RAG.