O problema: classificar documentos similares com precisão
Empresas de seguros lidam diariamente com milhares de documentos — apólices, declarações juramentadas, endossos e formulários regulatórios. Classificar tudo isso corretamente é crítico para conformidade, processamento de sinistros e atendimento ao cliente. O problema é que documentos distintos muitas vezes compartilham terminologia parecida: um endosso de apólice e uma declaração regulatória podem usar linguagem semelhante, mas tratá-los de forma errada pode gerar violações de conformidade ou atrasos no processamento.
Abordagens manuais são lentas e sujeitas a erros. Sistemas automatizados tradicionais, por sua vez, têm dificuldade com documentos que se parecem, mas têm propósitos diferentes. É justamente para resolver esse desafio que a AWS publicou um guia técnico demonstrando como construir um sistema de classificação baseado em múltiplos agentes de IA usando o Amazon Bedrock.
A solução: arquitetura com múltiplos agentes especializados
A solução proposta orquestra três agentes de IA especializados, cada um responsável por um aspecto diferente da análise de documentos. A coordenação entre eles é feita por meio do Strands Agents SDK, que permite tratar agentes como ferramentas chamáveis por um orquestrador central.
A escolha pelo Strands Agents SDK se justifica porque ele implementa o padrão de agentes como ferramentas: o agente orquestrador pode invocar os agentes especialistas diretamente, sem precisar de código de orquestração personalizado. Isso traz vantagens claras:
- Modularidade: cada agente pode ser desenvolvido, testado e melhorado de forma independente.
- Transparência: cada agente fornece o raciocínio por trás de suas decisões, criando uma trilha de auditoria.
- Flexibilidade: novos agentes podem ser adicionados sem reestruturar o sistema.
- Confiabilidade: o orquestrador cuida da coordenação, tratamento de erros e síntese dos resultados.
Agente de Análise de Documentos
Este agente usa o Claude Haiku 4.5 da Anthropic no Amazon Bedrock para raciocínio textual avançado e interpretação de linguagem jurídica. O Claude se destaca em entender documentos complexos, extrair informações-chave e identificar padrões sutis no texto que indicam o tipo do documento.
Agente de Busca por Similaridade Vetorial
Este agente usa o Amazon Titan Multimodal Embeddings G1 para converter documentos em representações vetoriais de alta dimensionalidade, focando nas características visuais e estruturais — como layouts de formulários, estruturas de tabelas e convenções de formatação. Para a busca por similaridade, o agente utiliza o FAISS (Busca por Similaridade de IA do Facebook), que permite comparação rápida contra modelos de documentos conhecidos armazenados em um banco de dados vetorial.
Agente de Validação (Orquestrador)
No centro da arquitetura está o Agente de Validação, que atua como orquestrador. Ele invoca os dois agentes especialistas, compara os resultados, identifica concordâncias e discordâncias, e gera uma classificação final com uma pontuação de confiança associada. Quando a confiança cai abaixo de um limite definido, o sistema aciona automaticamente a revisão humana, evitando que classificações incertas se propaguem para os sistemas seguintes.
Pré-requisitos
Para implementar a solução, são necessários:
Atenção: o uso dos serviços AWS pode gerar custos. Revise a tabela de preços do Amazon Bedrock antes de começar e siga as instruções de limpeza ao final para evitar cobranças contínuas.
Implementando o sistema passo a passo
Passo 1: Configurar os modelos de fundação
O primeiro passo é configurar o acesso ao Claude via perfil de inferência do Amazon Bedrock. Isso garante desempenho consistente e disponibilidade entre regiões:
def create_bedrock_model(
model_id: str = "anthropic.claude-haiku-4-5-20251001-v1:0",
# temperature: float = 0.1,
max_tokens: int = 4096
) -> BedrockModel:
"""Create a configured Bedrock model instance."""
return BedrockModel(
model_id=model_id,
region_name="us-east-1",
temperature=temperature,
max_tokens=max_tokens
)
Dica: para menor latência e maior disponibilidade, é possível usar um perfil de inferência entre regiões adicionando um prefixo geográfico (us., eu. ou ap.) ao ID do modelo.
Passo 2: Criar o Agente de Análise de Documentos
Este agente usa saída estruturada para retornar resultados de classificação consistentes e interpretáveis por máquina:
class TextualAnalysisOutput(BaseModel):
"""Structured output for document text analysis."""
classification: str = Field(description="Document category: POLICY, AFFIDAVIT, or MISCELLANEOUS")
confidence: float = Field(description="Classification confidence score from 0.0 to 1.0")
reasoning: str = Field(description="Explanation of textual features that led to this classification")
@tool
def analyze_document_text(document_text: str) -> str:
"""Analyze document text content to classify the insurance document."""
TEXTUAL_ANALYSIS_PROMPT = """You are a Document Analysis Specialist for insurance documents.
Analyze the provided document text and classify it into exactly one category:
- POLICY: Insurance policies, endorsements, declarations, coverage documents
- AFFIDAVIT: Sworn statements, notarized documents, legal declarations, regulatory filings
- MISCELLANEOUS: Any document that doesn't clearly fit the above categories
Provide your classification with a confidence score (0.0-1.0) and detailed reasoning explaining what textual features led to your decision."""
text_agent = Agent(
model=create_bedrock_model(),
system_prompt=TEXTUAL_ANALYSIS_PROMPT,
conversation_manager=NullConversationManager(),
)
result = text_agent(
f"Classify this document:\n\n{document_text}",
structured_output_model=TextualAnalysisOutput,
)
return str(result.structured_output)
Passo 3: Construir o Agente de Busca por Similaridade Vetorial
Este agente carrega um índice FAISS pré-treinado e analisa as características visuais do documento:
# Load FAISS index once at module level.
# allow_dangerous_deserialization=True is required because FAISS uses pickle internally;
# safe here since we created the index ourselves from our own training documents.
db = FAISS.load_local("hybrid_docs.vdb", embeddings=embeddings, allow_dangerous_deserialization=True)
VECTOR_ANALYSIS_PROMPT = """You are a Vector Similarity Search Specialist.
Analyze the similarity search results and determine the document classification.
Consider the confidence scores and consistency of matches across pages."""
@tool
def analyze_document_vectors(pdf_path: str) -> str:
"""Classify document using vector similarity search with agentic reasoning."""
base64_pages = pdf_to_base64(pdf_path)
first_embedding = create_multimodal_embedding(image_base64=base64_pages[0])
results = db.similarity_search_by_vector(embedding=first_embedding, k=3)
labels = [r.metadata["label"] for r in results]
classification = Counter(labels).most_common(1)[0][0]
confidence = labels.count(classification) / len(labels)
vector_agent = Agent(
model=create_bedrock_model(),
system_prompt=VECTOR_ANALYSIS_PROMPT,
conversation_manager=NullConversationManager(),
)
result = vector_agent(
f"Vector search results for {pdf_path}:\n"
f"Top match: {classification} (confidence: {confidence:.2f})\n"
f"All matches: {labels}\n"
f"Provide final classification with reasoning.",
structured_output_model=VectorAnalysisOutput,
)
return str(result.structured_output)
Passo 4: Implementar o Agente de Validação
O Agente de Validação coordena os especialistas usando o padrão de agentes como ferramentas:
class OrchestratorOutput(BaseModel):
"""Structured output for the validation orchestrator."""
textual_analysis: str = Field(description="Textual agent classification: POLICY, AFFIDAVIT, or MISCELLANEOUS")
textual_confidence: float = Field(description="Textual agent confidence 0.0-1.0")
vector_analysis: str = Field(description="Vector agent classification: POLICY, AFFIDAVIT, or MISCELLANEOUS")
vector_confidence: float = Field(description="Vector agent confidence 0.0-1.0")
final_classification: str = Field(description="Final validated classification")
confidence: float = Field(description="Overall confidence score")
requires_human_review: bool = Field(description="Whether edge case needs human review")
decision_logic: str = Field(description="Brief explanation of decision")
justification: str = Field(description="Detailed reasoning from both specialists")
class MultiAgentDocumentClassifier:
def __init__(self, model=None):
self.model = model or create_bedrock_model()
self.orchestrator = Agent(
model=self.model,
tools=[analyze_document_text, analyze_document_vectors],
system_prompt="""You are a Document Classification Orchestrator.
Your workflow:
1. Use analyze_document_text for textual analysis
2. Use analyze_document_vectors for visual similarity analysis
3. Synthesize both into a final classification
Reasoning guidelines:
- Both agree → high confidence (0.85-0.95)
- Disagree → textual is more reliable for content-rich docs, vector for visually distinctive formats
- Very short text (<50 chars) or low textual confidence (<0.3) → defer to vector analysis
- Endorsements are POLICY documents
- Flag for human review when evidence is contradictory
Always use both tools before deciding."""
)
Passo 5: Classificar documentos
Com todos os componentes no lugar, o MultiAgentDocumentClassifier processa um documento de ponta a ponta da seguinte forma:
# Method of MultiAgentDocumentClassifier
def classify_document(self, pdf_path: str) -> OrchestratorOutput:
"""Classify a document using multi-agent orchestration."""
filename = os.path.basename(pdf_path)
text_content = extract_pdf_text(pdf_path, max_chars=3000)
query = f"""Classify this insurance document: {filename}
Document text content (first 3000 characters):
{text_content}
Document file path for vector analysis: {pdf_path}
Use both analyze_document_text and analyze_document_vectors, then synthesize."""
result = self.orchestrator(query, structured_output_model=OrchestratorOutput)
return result.structured_output
Para usar o classificador:
classifier = MultiAgentDocumentClassifier()
result = classifier.classify_document("documents/sample_policy.pdf")
print(f"Classification: {result.final_classification}")
print(f"Confidence: {result.confidence:.2f}")
print(f"Reasoning: {result.justification}")
Comparação de desempenho: por que múltiplos agentes?
A AWS comparou o sistema multi-agente com três abordagens comuns. O objetivo era identificar a abordagem mais simples que atendesse aos requisitos de precisão para cargas de trabalho sensíveis à conformidade:
- Amazon Textract + palavras-chave: 25% de precisão, ~2,88s por documento — baixo custo e complexidade, mas ineficaz para documentos com terminologia sobreposta.
- Amazon Comprehend + entidades: 25% de precisão, ~3,26s — mesma limitação da abordagem anterior.
- Amazon Bedrock Data Automation (BDA): 70% de precisão, ~25,7s — desempenho significativamente melhor, mas ainda classificou errado quase 1 em cada 3 documentos.
- Sistema multi-agente: 100% de precisão, ~23,3s — única abordagem a acertar todas as classes.
A diferença é mais evidente nos documentos de apólice: textos jurídicos densos com terminologia que se sobrepõe às outras classes. Apenas o sistema multi-agente classificou todos corretamente. Declarações juramentadas seguiram padrão semelhante. Documentos miscelâneos, que têm marcadores estruturais mais distintos, foram classificados corretamente por todas as abordagens.
Dentro do framework multi-agente, o Claude Haiku 4.5 atingiu a mesma precisão que o Claude Sonnet 4.5, sendo 17% mais rápido — o que o torna a escolha mais adequada para cargas de trabalho em produção, onde velocidade e custo-benefício são prioridades.
Importante: os testes foram realizados com um conjunto limitado de 20 documentos em 3 classes. A precisão em produção pode variar com conjuntos maiores e mais diversificados.
Salvaguardas para produção
Para implantações em produção com documentos sensíveis, a AWS recomenda o uso do Amazon Bedrock Guardrails, que oferece filtragem de conteúdo e controles de segurança para as interações com os modelos. As políticas configuráveis incluem tópicos negados, filtros de conteúdo, filtros de palavras e redação de informações sensíveis.
As boas práticas recomendadas para esse tipo de pipeline incluem:
- Aplicar filtros de redação de Informações de Identificação Pessoal (PII) para evitar que dados dos segurados se propaguem para os logs de classificação.
- Configurar políticas de negação de tópicos para restringir os agentes ao escopo de classificação.
- Ativar o registro de invocações de modelos do Amazon Bedrock para capturar a cadeia completa de requisição-resposta, incluindo eventos de intervenção do Guardrails, para fins de auditoria.
O flag requires_human_review gerado pelo Agente de Validação aciona o escalonamento automático quando a confiança cai abaixo de um limite definido, garantindo que classificações incertas cheguem a um revisor humano em vez de se propagarem automaticamente.
Limpeza dos recursos
Para evitar cobranças futuras, remova os recursos criados durante a implementação:
- Exclua os arquivos do banco de dados vetorial FAISS (
hybrid_docs.vdb) do ambiente local.
- Remova os documentos PDF de teste utilizados na classificação.
- Se os documentos de treinamento foram armazenados no Amazon Simple Storage Service (Amazon S3), exclua o bucket e seu conteúdo.
- Limpe os logs do Amazon CloudWatch gerados durante os testes.
Instruções detalhadas de limpeza e scripts estão disponíveis na seção de cleanup do repositório GitHub da solução.
Conclusão
O artigo da AWS demonstra como a combinação de múltiplos agentes especializados — análise textual com Claude Haiku 4.5, análise visual com Amazon Titan Multimodal Embeddings e validação cruzada com um agente orquestrador — pode superar significativamente abordagens tradicionais de classificação de documentos.
A arquitetura é modular, auditável e extensível: é possível começar implementando apenas o Agente de Análise de Documentos com seus próprios tipos de documentos e adicionar o Agente de Busca Vetorial posteriormente para melhorar a precisão em documentos visualmente distintos.
Para explorar a implementação completa, acesse o repositório GitHub com o código da solução. Também vale conferir a lista de modelos de fundação disponíveis no Amazon Bedrock, a documentação do Strands Agents SDK e os posts relacionados sobre processamento inteligente de documentos e arquiteturas multi-agente.
Fonte
Implement vector-prompt document classification using Amazon Bedrock (https://aws.amazon.com/blogs/machine-learning/implement-vector-prompt-document-classification-using-amazon-bedrock/)
