Ir para o conteúdo principal
Português— Escolher um idioma
Menu

QnA com Múltiplos Documentos

Aula 14 de 16 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. Quando a Resposta Abrange Vários Ficheiros
  2. Enviar Tudo numa Única Chamada
  3. Extração Separada da Consulta
  4. Migrar para RAG de Documentos
  5. Um Fluxo de Trabalho de Comparação de Ponta a Ponta
  6. Pontos-chave

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 alias mistral-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 tipo document_base64 de exemplos anteriores não existe nem na documentação nem no SDK mistralai, e esses exemplos teriam falhado. Fontes: Processador OCR · QnA de Documentos. Corrigido em 3 de novembro de 2026: O código lia anteriormente page.document_annotation página por página; no SDK mistralai 3.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 de image.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