Web playgrounds são ótimos para demonstrações. Você cola um bloco de texto, observa o modelo gerar um resumo organizado e fecha a aba. Mas isso não é engenharia. Trabalho de produção significa APIs, tratamento de erros e código que roda enquanto você dorme. Se você precisa processar transcrições de reuniões, tickets de suporte ou artigos de pesquisa em um cronograma, você precisa de um pipeline.

Este guia orienta a construção exatamente disso: um script de sumarização de documentos leve e automatizado usando Python, o AWS SDK para Python (boto3) e o Amazon Bedrock. Usaremos o Claude 3 Haiku da Anthropic, um modelo que atinge o ponto ideal entre velocidade e custo para tarefas de sumarização de texto.

Por que Bedrock e Claude 3 Haiku?

O Amazon Bedrock é um serviço gerenciado que expõe modelos de fundação por meio de um único conjunto de APIs da AWS. Em vez de reunir endpoints externos e lidar com modelos de faturamento e segurança separados, você chama um endpoint da AWS com controles IAM padrão. Seus dados permanecem dentro do seu ambiente AWS.

O Claude 3 Haiku é o modelo mais enxuto da família Claude 3 da Anthropic. Ele foi construído para oferecer rapidez e baixo custo, o que o torna ideal para sumarizações de alto volume onde você deseja um resultado previsível sem pagar pelo poder de processamento de modelos maiores em tarefas simples de leitura.

O que você precisa

Antes de escrever qualquer código, certifique-se de ter o seguinte pronto:

  • Uma conta AWS ativa.
  • Python 3.9 ou superior instalado localmente.
  • O AWS CLI configurado com credenciais que tenham permissão para invocar modelos do Bedrock. Se você ainda não executou aws configure, faça isso agora. Se encontrar erros de permissão mais tarde, provavelmente precisará anexar as permissões de invocação do Bedrock apropriadas ao seu usuário ou função IAM.
  • Acesso ao modelo habilitado especificamente para o Anthropic Claude 3 Haiku dentro do console do AWS Bedrock. A AWS exige que você opte explicitamente por cada provedor de modelo antes de poder chamá-lo.

Passo 1: Habilitar o acesso ao modelo

O Bedrock não permite que você chame modelos de imediato. Você deve ativar a opção no console primeiro.

  1. Faça login no AWS Management Console.
  2. Use a barra de pesquisa para encontrar o Amazon Bedrock.
  3. No painel de navegação à esquerda, selecione Model access.
  4. Clique em Modify model access.
  5. Marque a caixa para Anthropic (Claude 3 Haiku) e envie sua solicitação.

Assim que o status mudar para "Access granted", você estará pronto para chamar o modelo via código.

Passo 2: Configurar seu ambiente

Um ambiente Python limpo mantém as dependências isoladas e reproduzíveis. Abra seu terminal e execute estes comandos:

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

Usuários de Windows devem substituir o comando de ativação por venv\Scripts\activate. Após a conclusão do pip install boto3, você terá tudo o que precisa para se comunicar com as APIs da AWS.

Passo 3: Escrever o script

Crie um arquivo chamado summarize.py. O objetivo é ler um documento do disco, enviá-lo para a Bedrock Converse API e imprimir um resumo conciso.

Abaixo está uma implementação completa e funcional. Usamos a Converse API porque ela abstrai a formatação JSON bruta que diferentes provedores de modelos esperam. Você simplesmente passa uma lista de mensagens e configurações de inferência.

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)

Alguns detalhes práticos que valem a pena destacar aqui:

  • boto3.client("bedrock-runtime") direciona para o endpoint de runtime que lida com a inferência. Certifique-se de que sua região AWS em ~/.aws/config suporte o Bedrock e que você habilitou o Haiku nessa mesma região.
  • Model ID anthropic.claude-3-haiku-20240307-v1:0 é o identificador exato que o Bedrock espera. Copie-o precisamente.
  • Temperatura definida em 0.3 mantém o resultado fundamentado. Para sumarização, você deseja consistência e fidelidade ao texto de origem, não floreios criativos. Se você aumentar a temperatura para perto de 1.0, o modelo começará a tomar liberdades com o fraseado e, ocasionalmente, inventará detalhes.
  • O prompt em si é específico. Em vez de jogar o texto bruto no modelo com um vago "resuma isso", pedimos explicitamente os pontos principais e instruímos para ignorar informações irrelevantes. Esse tipo de clareza separa um resultado inutilizável de algo que você realmente pode implementar.

Coloque qualquer arquivo de texto que você queira sumarizar no mesmo diretório e nomeie-o como document.txt.

Passo 4: Executar

Com seu ambiente virtual ativo, execute:

python summarize.py

Se suas credenciais e o acesso ao modelo estiverem corretos, você deverá ver um resumo organizado impresso no seu terminal em poucos segundos. Se receber um erro de acesso, verifique novamente suas permissões IAM e confirme se habilitou o Claude 3 Haiku no console.

Indo além do 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