Los entornos de prueba web son excelentes para demostraciones. Pegas un bloque de texto, observas cómo el modelo genera un resumen impecable y cierras la pestaña. Pero eso no es ingeniería. El trabajo de producción implica APIs, manejo de errores y código que se ejecuta mientras duermes. Si necesitas procesar de forma masiva transcripciones de reuniones, tickets de soporte o artículos de investigación de manera programada, necesitas un pipeline.

Esta guía explica cómo construir exactamente eso: un script de resumen de documentos ligero y automatizado utilizando Python, el AWS SDK para Python (boto3) y Amazon Bedrock. Utilizaremos Claude 3 Haiku de Anthropic, un modelo que encuentra el punto de equilibrio ideal entre velocidad y costo para tareas de resumen de texto.

¿Por qué Bedrock y Claude 3 Haiku?

Amazon Bedrock es un servicio gestionado que expone modelos fundacionales a través de un único conjunto de APIs de AWS. En lugar de unir diferentes endpoints externos y lidiar con modelos de facturación y seguridad separados, llamas a un endpoint de AWS con controles IAM estándar. Tus datos permanecen dentro de tu entorno de AWS.

Claude 3 Haiku es el modelo más ligero de la familia Claude 3 de Anthropic. Está diseñado para ofrecer capacidad de respuesta y bajo costo, lo que lo hace ideal para resúmenes de alto volumen donde buscas resultados predecibles sin pagar por la potencia de modelos más grandes en tareas de lectura sencillas.

Lo que necesitas

Antes de escribir cualquier código, asegúrate de tener lo siguiente listo:

  • Una cuenta de AWS activa.
  • Python 3.9 o superior instalado localmente.
  • La AWS CLI configurada con credenciales que tengan permiso para invocar modelos de Bedrock. Si aún no has ejecutado aws configure, hazlo ahora. Si encuentras errores de permisos más adelante, es probable que necesites adjuntar los permisos de invocación de Bedrock adecuados a tu usuario o rol de IAM.
  • El acceso al modelo habilitado específicamente para Anthropic Claude 3 Haiku dentro de la consola de AWS Bedrock. AWS requiere que aceptes explícitamente cada proveedor de modelos antes de poder llamarlo.

Paso 1: Habilitar el acceso al modelo

Bedrock no te permite llamar a los modelos de forma inmediata. Primero debes activar la opción en la consola.

  1. Inicia sesión en la consola de administración de AWS.
  2. Usa la barra de búsqueda para encontrar Amazon Bedrock.
  3. En el panel de navegación izquierdo, selecciona Model access.
  4. Haz clic en Modify model access.
  5. Marca la casilla de Anthropic (Claude 3 Haiku) y envía tu solicitud.

Una vez que el estado cambie a "Access granted", podrás llamar al modelo desde tu código.

Paso 2: Configurar tu entorno

Un entorno de Python limpio mantiene las dependencias aisladas y reproducibles. Abre tu terminal y ejecuta estos comandos:

mkdir bedrock-summarizer && cd bedrock-summarizer
python3 -m venv venv
source venv/bin/activate
pip install boto3

Los usuarios de Windows deben reemplazar el comando de activación con venv\Scripts\activate. Después de que termine pip install boto3, tendrás todo lo necesario para comunicarte con las APIs de AWS.

Paso 3: Escribir el script

Crea un archivo llamado summarize.py. El objetivo es leer un documento desde el disco, entregárselo a la API Converse de Bedrock e imprimir un resumen conciso.

A continuación se presenta una implementación completa y funcional. Utilizamos la API Converse porque abstrae el formato JSON puro que esperan los diferentes proveedores de modelos. Simplemente pasas una lista de mensajes y la configuración de inferencia.

import boto3

def summarize_document(text: str) -> str:
    client = boto3.client("bedrock-runtime")
    
    model_id = "anthropic.claude-3-haiku-20240307-v1:0"
    
    messages = [
        {
            "role": "user",
            "content": [
                {
                    "text": (
                        "Provide a concise summary of the following document. "
                        "Focus on the main points and avoid unnecessary detail:\n\n"
                        f"{text}"
                    )
                }
            ]
        }
    ]
    
    response = client.converse(
        modelId=model_id,
        messages=messages,
        inferenceConfig={
            "temperature": 0.3,
            "maxTokens": 512
        }
    )
    
    summary = response["output"]["message"]["content"][0]["text"]
    return summary.strip()


if __name__ == "__main__":
    with open("document.txt", "r", encoding="utf-8") as f:
        document_text = f.read()
    
    result = summarize_document(document_text)
    print("\n--- Summary ---\n")
    print(result)

Algunos detalles prácticos que vale la pena destacar:

  • boto3.client("bedrock-runtime") apunta al endpoint de tiempo de ejecución que maneja la inferencia. Asegúrate de que tu región de AWS en ~/.aws/config sea compatible con Bedrock y que hayas habilitado Haiku en esa misma región.
  • El Model ID anthropic.claude-3-haiku-20240307-v1:0 es el identificador exacto que Bedrock espera. Cópialo con precisión.
  • La temperatura establecida en 0.3 mantiene la respuesta fundamentada. Para resúmenes, buscas consistencia y fidelidad al texto original, no adornos creativos. Si aumentas la temperatura hacia 1.0, el modelo empezará a tomarse libertades con el fraseo y, ocasionalmente, inventará detalles.
  • El prompt en sí es específico. En lugar de lanzar texto sin procesar al modelo con un vago "resume esto", pedimos explícitamente los puntos principales e instruimos para que omita el relleno. Ese tipo de claridad es lo que separa un resultado inútil de algo que realmente puedes implementar.

Coloca cualquier archivo de texto que quieras resumir en el mismo directorio y cámbiale el nombre a document.txt.

Paso 4: Ejecutarlo

Con tu entorno virtual activo, ejecuta:

python summarize.py

Si tus credenciales y el acceso al modelo son correctos, deberías ver un resumen ordenado impreso en tu terminal en pocos segundos. Si recibes un error de acceso, verifica tus permisos de IAM y confirma que habilitaste Claude 3 Haiku en la consola.

Yendo más allá del script

This pipeline is intentionally simple, but it is the foundation for real automation. Here is how you can extend it without adding bloat.

Batch processing. Swap the single file read for a loop over a directory. Drop fifty PDFs or text files into an input folder, iterate through them, and write the summaries to an output folder. If you want to ingest PDFs directly, you will need a preprocessing step with a library like PyPDF2 or pdfplumber to extract raw text before it hits Bedrock.

Chunking strategy. Very long documents may exceed the model’s context limit. When that happens, split the text into logical chunks by paragraph or section, summarize each chunk individually, and then pass the intermediate summaries back through the model for a final synthesis. This two-stage approach keeps you under token limits while preserving coverage of the full document.

Error handling. Production code should catch boto3.exceptions.ClientError specifically. AWS may throttle your requests if you call the API too aggressively. Wrap your converse call in a retry loop with exponential backoff, or use a library like tenacity to handle rate limits gracefully.

Prompt engineering. The difference between a mediocre summary and a useful one often comes down to the prompt. Ask for bullet points if you need scanability. Ask for a one-paragraph executive summary if the audience is senior leadership. You can even pass formatting constraints, such as "Limit the summary to three sentences" or "Return the output as JSON with keys for topic, key_points, and action_items."

The Real Takeaway

Moving from a chat playground to a working script is the inflection point where AI becomes infrastructure. Once this pipeline runs locally, you can lift it into an AWS Lambda function triggered by S3 uploads, schedule it on ECS Fargate, or hook it into an existing data workflow. The API call is the easy part. The engineering value comes from wrapping that call in logic that handles files, errors, and formatting so you never have to copy and paste text into a browser again.

For additional context and variations on this setup, see the original walkthrough on Dev.to. If you want to discuss AWS architectures, LLM pipelines, or prompt engineering with a community of builders, join the conversation over at [GyaanSetu AI on Telegram](https://t.me/GyaanSet