API de Procesamiento de Documentos con Inteligencia Artificial

import openai
import PyPDF2
import docx
import pandas as pd
from fastapi import FastAPI, File, UploadFile
from io import BytesIO
import uvicorn

# Configura tu clave API de OpenAI
openai.api_key = 'tu_clave_api'  # Reemplaza 'tu_clave_api' por tu clave API de OpenAI

# Crea la aplicación FastAPI
app = FastAPI()

# Función para leer archivos PDF
def leer_pdf(file: BytesIO):
    reader = PyPDF2.PdfReader(file)
    texto = ""
    for pagina in range(len(reader.pages)):
        texto += reader.pages[pagina].extract_text()
    return texto

# Función para leer archivos DOCX
def leer_docx(file: BytesIO):
    doc = docx.Document(file)
    texto = ""
    for para in doc.paragraphs:
        texto += para.text + "\n"
    return texto

# Función para leer archivos Excel (solo el contenido de las celdas)
def leer_excel(file: BytesIO):
    df = pd.read_excel(file)
    texto = df.to_string(index=False)
    return texto

# Función para procesar texto con OpenAI utilizando el endpoint de chat
def procesar_con_openai(texto):
    # Llamada a la API de OpenAI para procesar el texto con un modelo de chat
    response = openai.ChatCompletion.create(
        model="gpt-4",  # Usa el modelo adecuado, por ejemplo, "gpt-4"
        messages=[
            {"role": "system", "content": "Eres un asistente que ayuda a procesar documentos."},
            {"role": "user", "content": texto}
        ],
        max_tokens=1500  # Ajusta la cantidad de tokens según lo necesario
    )
    return response['choices'][0]['message']['content'].strip()

# Endpoint para recibir archivos y procesarlos
@app.post("/procesar_archivo/")
async def procesar_archivo(file: UploadFile = File(...)):
    # Obtener el nombre del archivo y su extensión
    extension = file.filename.split('.')[-1].lower()
    
    # Leer el archivo según su tipo
    contenido = await file.read()
    archivo = BytesIO(contenido)
    
    if extension == 'pdf':
        texto = leer_pdf(archivo)
    elif extension == 'docx':
        texto = leer_docx(archivo)
    elif extension in ['xls', 'xlsx']:
        texto = leer_excel(archivo)
    else:
        return {"error": "Formato de archivo no soportado."}
    
    # Enviar el texto a OpenAI para que lo procese
    resultado = procesar_con_openai(texto)
    
    return {"texto_procesado": resultado}

# Iniciar el servidor
if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

fastapi==0.115.6
pandas==2.2.3
PyPDF2==3.0.1
uvicorn==0.34.0
openai==0.28
python-docx
python-multipart

pip install -r requirements.txt

import os
from dotenv import load_dotenv

load_dotenv()  # Carga variables desde .env
openai.api_key = os.getenv("OPENAI_API_KEY")

uvicorn main:app --host localhost --port 8081 --reload

import requests

url = "http://localhost:8081/procesar_archivo/"
archivo = "documento_ejemplo.pdf"  # Cambia esto al archivo que quieras procesar

with open(archivo, "rb") as f:
    files = {"file": (archivo, f, "application/pdf")}
    response = requests.post(url, files=files)

if response.status_code == 200:
    resultado = response.json()
    print("Texto procesado:", resultado["texto_procesado"])
else:
    print(f"Error: {response.status_code}")
    print(response.text)

def procesar_con_openai(texto):
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "Eres un asistente especializado en resumir documentos legales. Extrae los puntos clave y resume el contenido en formato de lista."},
            {"role": "user", "content": texto}
        ],
        max_tokens=1500
    )
    return response['choices'][0]['message']['content'].strip()

def leer_csv(file: BytesIO):
    df = pd.read_csv(file)
    texto = df.to_string(index=False)
    return texto

# Y luego en el endpoint:
elif extension == 'csv':
    texto = leer_csv(archivo)

def procesar_documento_grande(texto, max_chunk_size=4000):
    # Dividir el texto en fragmentos más pequeños
    chunks = [texto[i:i+max_chunk_size] for i in range(0, len(texto), max_chunk_size)]
    
    resultados = []
    for chunk in chunks:
        # Procesar cada fragmento individualmente
        resultado_chunk = procesar_con_openai(chunk)
        resultados.append(resultado_chunk)
    
    # Combinar los resultados o realizar un procesamiento adicional si es necesario
    resultado_final = "\n\n".join(resultados)
    
    # Opcionalmente, hacer un resumen final de todos los fragmentos
    if len(resultados) > 1:
        resumen = procesar_con_openai("Resume los siguientes resultados:\n" + resultado_final)
        return resumen
    
    return resultado_final

# Crear un archivo .env
OPENAI_API_KEY=tu_clave_api_real

# En tu código principal
import os
from dotenv import load_dotenv

load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

@app.post("/procesar_archivo/")
async def procesar_archivo(file: UploadFile = File(...)):
    try:
        # Verificar si se proporcionó un archivo
        if not file:
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail="No se proporcionó ningún archivo"
            )
        
        # Verificar el tamaño del archivo (por ejemplo, límite de 10MB)
        MAX_SIZE = 10 * 1024 * 1024  # 10MB
        file_size = 0
        contenido = BytesIO()
        
        # Leer el archivo en chunks para controlar el tamaño
        chunk = await file.read(1024)
        while chunk:
            file_size += len(chunk)
            if file_size > MAX_SIZE:
                raise HTTPException(
                    status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
                    detail=f"El tamaño del archivo excede el límite de {MAX_SIZE/1024/1024}MB"
                )
            contenido.write(chunk)
            chunk = await file.read(1024)
        
        contenido.seek(0)
        
        # Verificar la extensión
        extension = file.filename.split('.')[-1].lower()
        if extension not in ['pdf', 'docx', 'xlsx', 'xls']:
            raise HTTPException(
                status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
                detail=f"Formato de archivo no soportado: {extension}"
            )
        
        # Continuar con el procesamiento normal...
        
    except Exception as e:
        # Capturar cualquier otra excepción
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Error al procesar el archivo: {str(e)}"
        )

FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

docker build -t document-processor-api .
docker run -p 8000:8000 -e OPENAI_API_KEY=tu_clave_api document-processor-api