Como acelerar o reconhecimento personalizado de entidades com Claude Tool use no Amazon Bedrock

Extrair informações valiosas de grandes volumes de dados não estruturados é um desafio comum para empresas de diversos setores. Métodos tradicionais costumam demandar muitos recursos e modelos rígidos, dificultando adaptações rápidas. Para resolver essas limitações, a AWS apresenta uma solução inovadora: o uso do Claude Tool use (function calling) no Amazon Bedrock, que utiliza modelos de linguagem avançados para realizar reconhecimento dinâmico e adaptável de entidades sem a necessidade de treinamentos extensivos.

O que é Claude Tool use e como ele funciona no Amazon Bedrock

Claude Tool use, também conhecido como function calling, é um recurso que amplia as capacidades do modelo Claude ao permitir a chamada e execução de funções externas pré-definidas. Isso possibilita que o modelo acesse ferramentas específicas conforme a necessidade do prompt do usuário, tornando o processo de extração de dados mais flexível e contextual.

Amazon Bedrock é um serviço gerenciado de inteligência artificial generativa que disponibiliza diversos modelos base de líderes do setor, como a Anthropic. Com ele, implementar o Claude Tool use torna-se simples: o usuário define as ferramentas (tools) com seus nomes, esquemas de entrada e descrições; o modelo avalia o prompt e decide se alguma ferramenta deve ser utilizada, escolhendo qual ferramenta chamar e com quais dados.

Visão geral da solução para reconhecimento de entidades personalizadas

Este tutorial demonstra a extração de campos personalizados de carteiras de motorista usando Claude Tool use no Amazon Bedrock. A solução serverless processa documentos em tempo real, extraindo informações como nome, data de emissão e endereço, eliminando a necessidade de treinamentos tradicionais de modelos.

Arquitetura da solução

Amazon S3: Armazena os documentos de entrada.
AWS Lambda: Função acionada pelo upload no S3, que processa o arquivo e envia o prompt para o Claude.
Amazon Bedrock (Claude): Processa o arquivo e extrai as entidades.
Amazon CloudWatch: Monitora e registra o desempenho do fluxo.

Essa arquitetura serverless permite escalabilidade automática e reduz a complexidade de gerenciamento de infraestrutura.

Pré-requisitos para implementação

Conta AWS com acesso ao Amazon Bedrock.
Permissões IAM para Amazon Bedrock, AWS Lambda e Amazon S3.
Conhecimentos básicos em Python e JSON.
Acesso ao modelo Claude no Amazon Bedrock.
Configuração de um perfil de inferência cross-region para Claude.

Passo a passo para criar a solução

1. Configurar o bucket S3

Crie um bucket S3 para armazenar as imagens de entrada, por exemplo, "driver-license-input".
Configure as políticas IAM para permitir que Lambda e Bedrock acessem o bucket. Exemplo de política JSON:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "bedrock:InvokeModel",
      "Resource": ["arn:aws:bedrock:*::foundation-model/*", "arn:aws:bedrock:*:111122223333:inference-profile/*"]
    },
    {
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::driver-license-input/*"
    }
  ]
}

2. Criar a função AWS Lambda

A função Lambda é disparada automaticamente ao fazer upload de uma imagem no bucket S3. Ela lê o arquivo, codifica-o em base64 e envia o conteúdo para o modelo Claude 4.5 Sonnet via Amazon Bedrock usando a API Tool use.

Configurações importantes:

Runtime: Python 3.12
Timeout: aumente para pelo menos 30 segundos (recomendado 1-2 minutos) para processar imagens maiores.

Código principal da função Lambda (lambda_function.py):

import boto3, json
import base64

def lambda_handler(event, context):
    bedrock = boto3.client("bedrock-runtime")
    s3 = boto3.client("s3")

    bucket = event["Records"][0]["s3"]["bucket"]["name"]
    key = event["Records"][0]["s3"]["object"]["key"]

    file = s3.get_object(Bucket=bucket, Key=key)
    image_data = file["Body"].read()
    base64_image = base64.b64encode(image_data).decode('utf-8')

    tools = [{
        "name": "extract_license_fields",
        "input_schema": {
            "type": "object",
            "properties": {
                "first_name": {"type": "string"},
                "last_name": {"type": "string"},
                "issue_date": {"type": "string"},
                "license_number": {"type": "string"},
                "address": {
                    "type": "object",
                    "properties": {
                        "street": {"type": "string"},
                        "city": {"type": "string"},
                        "state": {"type": "string"},
                        "zip": {"type": "string"}
                    }
                }
            },
            "required": ["first_name", "last_name", "issue_date", "license_number", "address"]
        }
    }]

    payload = {
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 2048,
        "messages": [{
            "role": "user",
            "content": [
                {"type": "image", "source": {"type": "base64", "media_type": "image/jpeg", "data": base64_image}},
                {"type": "text", "text": "Extract the driver's license fields from this image."}
            ]
        }],
        "tools": tools
    }

    try:
        response = bedrock.invoke_model(
            modelId="global.anthropic.claude-sonnet-4-5-20250929-v1:0",
            body=json.dumps(payload)
        )
        result = json.loads(response["body"].read())

        print("Resposta bruta:", json.dumps(result, indent=2))

        if "content" in result:
            for content in result["content"]:
                if content.get("type") == "tool_calls":
                    extracted = json.loads(content["tool_calls"][0]["function"]["arguments"])
                    print("Dados extraídos:", json.dumps(extracted, indent=2))

        return {
            "statusCode": 200,
            "body": json.dumps({"message": "Processamento concluído", "raw_response": result}, indent=2)
        }
    except Exception as e:
        print(f"Erro ocorrido: {str(e)}")
        return {
            "statusCode": 500,
            "body": json.dumps({"error": str(e), "type": str(type(e))})
        }

Após colar o código, clique em Deploy para salvar as alterações.

3. Configurar notificação de eventos no S3

Acesse o console do Amazon S3 e selecione seu bucket.
Na aba Properties, localize Event notifications e crie uma nova notificação.
Configure para disparar a função Lambda no evento PUT (upload de arquivo).

Considerações sobre formatos, limites e melhores práticas

Formatos suportados: JPEG, PNG, WebP e GIF (frame único). O exemplo atual suporta JPEG, mas pode ser adaptado para outros formatos ajustando o campo media_type.
Tamanho máximo da imagem: 20 MB.
Resolução recomendada: 300 DPI ou superior, dimensões máximas de 4096x4096 pixels.
Dicas para melhorar a precisão: recorte a imagem para eliminar ruídos, ajuste contraste e brilho, alinhe horizontalmente o texto, prefira fundo branco com texto escuro.

Monitoramento e depuração

Use o Amazon CloudWatch para visualizar logs da função Lambda. Verifique o conteúdo da resposta do Claude para identificar chamadas de ferramentas e dados extraídos. Sempre registre a resposta bruta para facilitar a depuração e trate exceções para capturar eventuais erros.

Boas práticas de segurança e desempenho

Implemente criptografia em repouso para os buckets S3.
Utilize chaves do AWS KMS para dados sensíveis.
Aplique políticas IAM com o princípio do menor privilégio.
Considere usar endpoints VPC para acesso privado.
Ajuste memória e timeout da função Lambda conforme o tamanho e complexidade dos documentos.
Implemente processamento em lote para múltiplos documentos, se necessário.

Limpeza após testes

Exclua buckets S3 e seus conteúdos.
Remova funções Lambda criadas.
Apague roles e políticas IAM associadas.
Revogue acessos ao Bedrock se não forem mais necessários.

Links úteis para aprofundamento

Com essa solução, é possível acelerar e simplificar a extração de dados personalizados de documentos variados, aproveitando a capacidade dos grandes modelos de linguagem da Anthropic via Amazon Bedrock. Ao automatizar esse processo com arquitetura serverless, sua empresa ganha em eficiência, escalabilidade e redução de custos operacionais.