QnA com Múltiplos Documentos
Nesta página
Atualizado em 2 de novembro de 2026 — OCR. O OCR 4.0 (
mistral-ocr-4-0) foi descontinuado em 30 de setembro de 2026. Utilize o OCR 4.1 (mistral-ocr-4-1), disponível para uso geral desde 31 de agosto pelo mesmo preço, ou o aliasmistral-ocr-latest, que aponta para ele desde 16 de julho. O OCR 4.1 adiciona pontuações de confiança ao nível do bloco. Adenda de 3 de novembro de 2026: Um PDF local é transmitido em base64 como{"type": "document_url", "document_url": "data:application/pdf;base64,…"}; o tipodocument_base64de exemplos anteriores não existe nem na documentação nem no SDKmistralai, e esses exemplos teriam falhado. Fontes: Processador OCR · QnA de Documentos. Corrigido em 3 de novembro de 2026: O código lia anteriormentepage.document_annotationpágina por página; no SDKmistralai3.7.0, a anotação do documento é um único campo na resposta (response.document_annotation), e a anotação de uma imagem é lida a partir deimage.image_annotation.
Quando a Resposta Abrange Vários Ficheiros
Em muitos cenários profissionais, a resposta a uma pergunta não se encontra num único documento. Pode ser necessário comparar contratos, cruzar faturas com ordens de compra ou analisar uma série de relatórios. Existem três estratégias, e a melhor abordagem consiste em escolher com base no volume, em vez de recorrer imediatamente à opção mais sofisticada.
Enviar Tudo numa Única Chamada
O método mais direto consiste em empilhar vários blocos document_url na mesma mensagem. O modelo vê ambos os contratos lado a lado e pode compará-los genuinamente, algo que o processamento página por página não consegue alcançar. Mudamos aqui para mistral-large-latest porque a comparação envolve raciocínio, e não apenas leitura.
import os
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": (
"Compare as condições de pagamento "
"destes dois contratos."
)
},
{
"type": "document_url",
"document_url": "https://example.com/contract-A.pdf"
},
{
"type": "document_url",
"document_url": "https://example.com/contract-B.pdf"
}
]
}
]
)
print(response.choices[0].message.content)
A limitação surge rapidamente: a soma dos documentos não pode exceder a janela de contexto do modelo. Dois folhetos de dez páginas passam sem dificuldade; dois acordos-quadro de duzentas páginas, não.
Extração Separada da Consulta
Para grandes volumes, a estratégia recomendada desacopla estas duas etapas. Submete cada documento ao OCR, guarda o Markdown resultante e constrói manualmente o contexto enviado para o LLM. A vantagem é o controlo: o truncamento para 5.000 caracteres visível no exemplo, mantendo o nome de cada documento como cabeçalho de secção, e a mensagem de sistema que estabelece o papel de assistente jurídico. Decide exatamente o que entra na janela de contexto, em vez de deixar que isso aconteça automaticamente.
import os
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
def extract_text(url: str) -> str:
"""Extrai texto de um documento via OCR."""
response = client.ocr.process(
model="mistral-ocr-latest",
document={"type": "document_url", "document_url": url}
)
return "\n\n".join(p.markdown for p in response.pages)
# Extração OCR para cada documento
documents = {
"Contrato A": extract_text("https://example.com/contract-A.pdf"),
"Contrato B": extract_text("https://example.com/contract-B.pdf"),
"Contrato C": extract_text("https://example.com/contract-C.pdf"),
}
# Construir o prompt com contexto
context = "\n\n---\n\n".join(
f"## {name}\n\n{text[:5000]}" # Limitar se necessário
for name, text in documents.items()
)
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{
"role": "system",
"content": (
"É um assistente jurídico. Analise os "
"documentos fornecidos e responda às perguntas."
)
},
{
"role": "user",
"content": (
f"Aqui estão os documentos:\n\n{context}\n\n"
f"Pergunta: Qual contrato oferece as melhores "
f"condições de rescisão antecipada?"
)
}
]
)
Migrar para RAG de Documentos
Além de algumas dezenas de documentos, nenhuma janela de contexto será suficiente. Deve então enviar apenas as passagens relevantes, o que exige dividir os textos, vetorizá-los com mistral-embed e pesquisar por similaridade no momento da consulta. A divisão em fragmentos (chunking) com uma sobreposição de 200 caracteres impede que uma frase cortada ao meio perca o seu significado entre fragmentos, e top_k determina quantas passagens acompanharão finalmente a pergunta.
import os
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
def create_embeddings(text: str) -> list[float]:
"""Cria embeddings para um texto."""
response = client.embeddings.create(
model="mistral-embed",
inputs=[text]
)
return response.data[0].embedding
def chunker(text: str, size: int = 1000, overlap: int = 200) -> list[str]:
"""Divide o texto em fragmentos com sobreposição."""
chunks = []
start = 0
while start < len(text):
end = start + size
chunk = text[start:end]
chunks.append(chunk)
start = end - overlap
return chunks
# Pipeline RAG simplificado
def index_document(name: str, text: str) -> list[dict]:
"""Indexa um documento para pesquisa."""
chunks = chunker(text)
index = []
for i, chunk in enumerate(chunks):
embedding = create_embeddings(chunk)
index.append({
"document": name,
"chunk_id": i,
"text": chunk,
"embedding": embedding
})
return index
def search(query: str, index: list[dict], top_k: int = 5) -> list[dict]:
"""Pesquisa os fragmentos mais relevantes."""
q_embedding = create_embeddings(query)
# Cálculo da similaridade do cosseno
import numpy as np
scores = []
for item in index:
score = np.dot(q_embedding, item["embedding"])
scores.append((score, item))
scores.sort(key=lambda x: x[0], reverse=True)
return [item for _, item in scores[:top_k]]
Vamos resumir a lógica de seleção. Enviar múltiplos documentos numa única chamada permanece imbatível pela simplicidade e funciona bem para dois ou três documentos curtos. O OCR separado seguido de QnA oferece flexibilidade e dá-lhe controlo sobre o que é enviado para o LLM, ao custo de algum código adicional. O RAG de documentos é mais pesado de configurar, mas torna-se essencial à medida que o corpus cresce, porque é a única abordagem que escala.
Um Fluxo de Trabalho de Comparação de Ponta a Ponta
As duas técnicas podem ser combinadas: nada o impede de extrair primeiro dados estruturados via anotação e depois entregar esses dados ao LLM para análise. Num lote de faturas, cada documento é reduzido a três campos — fornecedor, valor, data — antes de um único pedido solicitar ao modelo que identifique tendências e anomalias. O custo em tokens torna-se negligenciável e a análise foca-se em valores limpos extraídos, em vez de texto interpretado em tempo real.
import os
from pydantic import BaseModel, Field
from mistralai.client import Mistral
from mistralai.extra import response_format_from_pydantic_model
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
class InvoiceSummary(BaseModel):
vendor: str = Field(..., description="Nome do fornecedor")
amount_inc_tax: float = Field(..., description="Valor com impostos")
date: str = Field(..., description="Data (AAAA-MM-DD)")
def compare_invoices(paths: list[str]) -> str:
"""Compara várias faturas e devolve uma análise."""
import base64
invoices = []
for path in paths:
with open(path, "rb") as f:
doc_b64 = base64.b64encode(f.read()).decode("utf-8")
response = client.ocr.process(
model="mistral-ocr-latest",
document={
"type": "document_url",
"document_url": f"data:application/pdf;base64,{doc_b64}"
},
document_annotation_format=response_format_from_pydantic_model(
InvoiceSummary
)
)
if response.document_annotation:
invoice = InvoiceSummary.model_validate_json(
response.document_annotation
)
invoices.append(invoice)
# Análise comparativa via LLM
summary = "\n".join(
f"- {f.vendor}: €{f.amount_inc_tax} ({f.date})"
for f in invoices
)
response = client.chat.complete(
model="mistral-small-latest",
messages=[
{
"role": "user",
"content": (
f"Aqui estão {len(invoices)} faturas:\n{summary}\n\n"
f"Analise tendências e anomalias."
)
}
]
)
return response.choices[0].message.content
Pontos-chave
- Três abordagens para QnA com múltiplos documentos: inline, OCR separado, RAG
- A abordagem inline funciona para 2–3 documentos curtos
- OCR separado + QnA oferece mais controlo sobre os tokens consumidos
- O RAG é essencial para grandes corpora (dezenas de documentos)
- Combine anotações estruturadas com QnA para análises precisas