Análisis de Tarea y Conectividad: Enfrentemos el monstruo. Sé lo que es tener un PDF de 600 páginas en el escritorio a las 4:55 PM y que el CEO pida “un ejecutivo” para las 5:00 PM. El cuello de botella no es el análisis, es la lectura manual. Lo has hecho dos veces, así que se acabó: vamos a desplegar una “Bomba de Compresión Textual” usando un modelo de lenguaje grande (LLM) local para respetar la privacidad y maximizar la velocidad. Entiendo que la complejidad de orquestar estos sistemas parece intimidante, pero este camino es la única salida para reclamar tus horas perdidas.

FLUJO DE TRABAJO 1: Configuración de Entorno “Zero-Friction” (LLM Local)

El primer paso es construir nuestro motor. Olvídate de latencias de API externas; usaremos Ollama en un contenedor Docker para tener la potencia de un LLM de código abierto localmente, garantizando una velocidad impresionante. Esto elimina la burocracia de las credenciales y las llamadas lentas, dándonos el control total del runtime.

ACCIÓN 1: Instalación del Orquestador de Contenedores y el LLM

Copia y pega estas tres líneas. El objetivo es que tu máquina esté lista para la compresión en menos de 90 segundos. Esto instala Docker y levanta el servicio de Ollama para la API local.

sudo apt update && sudo apt install docker.io -y sudo systemctl start docker docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

Ahora, descarga el modelo de compresión ultrarrápida. Usaremos `llama2:7b` o similar por su eficiencia en tareas de resumen. Este comando se ejecuta dentro del contenedor que acabas de lanzar.

docker exec -it ollama ollama pull llama2:7b

ACCIÓN 2: Creación del Script de Compresión (Map-Reduce Táctico)

El LLM tiene un límite de contexto. Una novela de 600 páginas lo desborda. Nuestra táctica es simple: Map-Reduce. El script Python cargará el PDF, lo dividirá en trozos (chunks), llamará a la API local para resumir cada trozo (Map) y, finalmente, resumirá esos resúmenes (Reduce).

import pypdf import requests import json  # URL del LLM local (Ollama) LLM_API_URL = "http://localhost:11434/api/generate" MODEL_NAME = "llama2:7b" CHUNK_SIZE = 4000 # Caracteres por trozo  def extract_and_split(pdf_path):     # Lógica de extracción rápida y división para evitar el límite de contexto     reader = pypdf.PdfReader(pdf_path)     full_text = "".join(page.extract_text() for page in reader.pages)     return [full_text[i:i + CHUNK_SIZE] for i in range(0, len(full_text), CHUNK_SIZE)]

: (Abstract visualization of nested digital gears rapidly turning, symbolizing the automation orchestration of Docker and the local LLM, with data streams flowing into a central compression node, photorealistic, 16k, sharp focus, isometric view, unreal engine 5 render, ray tracing, cinematic lighting, dark background, blue and orange neon highlights, no text)

Este código es la válvula de presión. La lógica para manejar documentos masivos es brutalmente simple, pero requiere coraje dar el salto a este tipo de programación. Es normal que te sientas abrumado por la sintaxis; enfócate en el resultado: tiempo recuperado.

FLUJO DE TRABAJO 2: Ejecución e Inyección de la “Bomba”

Ahora, la función central de compresión. Aquí es donde inyectamos la orden de resumen para cada trozo, y luego la orden final. El `system` prompt le dice al modelo exactamente cómo comportarse: un analista frío y directo.

ACCIÓN 3: Función de Resumen y el Prompt Táctico

def compress_text(chunk, prompt_role):     # Llamada a la API local de Ollama para el resumen     response = requests.post(         LLM_API_URL,         headers={"Content-Type": "application/json"},         data=json.dumps({             "model": MODEL_NAME,             "prompt": f"{prompt_role}: {chunk}",             "stream": False         })     )     return json.loads(response.text)['response'].strip()  def executive_summary_pipeline(pdf_path):     chunks = extract_and_split(pdf_path)     intermediate_summaries = []          # 1. Fase MAP (Resumen de Chunks)     for i, chunk in enumerate(chunks):         intermediate_summaries.append(compress_text(chunk, "Eres un analista de datos. Genera un resumen de 2 párrafos del siguiente texto."))          # 2. Fase REDUCE (Resumen del Resumen)     final_input = " ".join(intermediate_summaries)     final_summary = compress_text(final_input, "Eres un CEO. Genera un resumen ejecutivo final de no más de 200 palabras y con viñetas sobre los puntos clave.")     return final_summary

: (A highly stylized digital pipeline splitting a massive stream of disorganized data into smaller, optimized packets (Map phase), then those packets merging into a single, highly compressed gold cube (Reduce phase/Final Summary), illustrating the Map-Reduce algorithm in a technical, abstract setting, photorealistic, 16k, sharp focus, isometric view, unreal engine 5 render, ray tracing, cinematic lighting, sharp contrast, no text)

ACCIÓN 4: El Disparo Final y la Medición del Ahorro

Para medir la velocidad, importaremos el módulo `time`. La promesa de 60 segundos no es un eslogan, es una métrica de rendimiento que vamos a cumplir. Este código ejecuta todo el pipeline y nos da la métrica exacta.

import time PDF_FILE = "reporte_anual_600_paginas.pdf" # Reemplazar con la ruta real if __name__ == "__main__":     start_time = time.time()     final_report = executive_summary_pipeline(PDF_FILE)     end_time = time.time()          print("n--- RESUMEN EJECUTIVO FINAL (Turbo-Comprimido) ---")     print(final_report)     print(f"nTIEMPO TOTAL DE COMPRESIÓN: **{end_time - start_time:.2f} segundos**")

Si el archivo pesa lo que debe pesar, el tiempo de compresión será ridículamente bajo. La lectura manual hubiera sido de 4 a 6 horas; la automatización te lo devuelve en menos de 60 segundos (dependiendo del CPU, claro, pero la latencia de la API local es casi nula). Es complejo, sí, construir el pipeline es un desafío, pero ahora tienes un arma de automatización que convierte la burocracia documental en tiempo libre. Utiliza esta arma sin piedad.