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

Integração OCR + RAG

Aula 15 de 16 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. Construir um sistema de documentos inteligente
  2. A arquitetura de cinco passos
  3. Passo 1: Extração sem perdas
  4. Passo 2: Fragmentação onde o documento o permite
  5. Passo 3: Vetorizar e pesquisar
  6. Passo 4: Gerar uma resposta com fontes
  7. Do protótipo à loja vetorial
  8. Pontos-chave

Atualização de 2 de novembro de 2026 — OCR. O OCR 4.0 (mistral-ocr-4-0) foi descontinuado a 30 de setembro de 2026. Utilize o OCR 4.1 (mistral-ocr-4-1), geralmente disponível 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 · Perguntas e Respostas sobre Documentos. Adenda de 3 de novembro: As anotações de imagem são lidas a partir de image.image_annotation (SDK mistralai 3.7.0), e não de image.annotation.

Construir um sistema de documentos inteligente

A Geração Aumentada por Recuperação (RAG) é a técnica que torna consultáveis grandes corpora de documentos. Ao combinar o OCR da Mistral, embeddings e uma loja vetorial, cria um sistema capaz de responder a perguntas sobre os seus arquivos — dez anos de relatórios, um repositório de contratos ou uma biblioteca técnica digitalizada.

Por que utilizar OCR em vez de indexar os ficheiros tal como estão? Porque o desafio fundamental do RAG para documentos é que os fragmentos indexados devem ser texto. Os embeddings multimodais ainda não são suficientemente performantes para comparar diretamente perguntas em texto com imagens de documentos. O OCR serve de ponte: converte os seus documentos em texto estruturado de alta qualidade, que depois indexa na sua loja vetorial.

A arquitetura de cinco passos

Tudo começa pela ingestão, ou seja, a receção de documentos, quer cheguem como PDFs, imagens ou ficheiros DOCX. Segue-se o OCR com anotações, produzindo tanto texto como metadados estruturados. A fragmentação corta este texto em segmentos coerentes, o embedding vetoriza-os e armazena-os na loja vetorial, e a consulta fecha o ciclo: pesquisa semântica entre os vetores, seguida da geração da resposta. Cada passo condiciona o seguinte, e a extração determina todo o resto — se o OCR falhar, nenhuma pesquisa encontrará a informação.

As secções seguintes detalham o código para os quatro passos que escreverá; a ingestão depende do seu sistema de entrada específico.

Passo 1: Extração sem perdas

A chamada ao OCR aqui está configurada para RAG, o que é evidente em três escolhas. table_format="markdown" preserva as tabelas num formato que o LLM consegue ler. A anotação da caixa delimitadora descreve as imagens, e o código substitui subsequentemente cada referência ![image](image) pela sua descrição textual: um gráfico de distribuição de receitas torna-se uma frase indexável em vez de uma lacuna no texto. Por fim, include_image_base64=False evita buscar megabytes de pixels de que o índice não precisa.

import os
import base64
from mistralai.client import Mistral
from mistralai.extra import response_format_from_pydantic_model
from pydantic import BaseModel, Field
from typing import Optional

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

class DescriptionImage(BaseModel):
    type_image: str = Field(..., description="Type: graph, table, photo, logo")
    description: str = Field(..., description="Content description")

def extraire_document_enrichi(chemin: str) -> list[dict]:
    """Extracts enriched content from a document for RAG."""
    with open(chemin, "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}"
        },
        table_format="markdown",
        bbox_annotation_format=response_format_from_pydantic_model(
            DescriptionImage
        ),
        include_image_base64=False  # Images not needed for RAG
    )

    pages = []
    for page in response.pages:
        contenu = page.markdown

        # Replace image references with their descriptions
        for image in page.images:
            if image.image_annotation:
                desc = DescriptionImage.model_validate_json(
                    image.image_annotation
                )
                placeholder = f"![{image.id}]({image.id})"
                remplacement = (
                    f"[{desc.type_image}: {desc.description}]"
                )
                contenu = contenu.replace(placeholder, remplacement)

        pages.append({
            "page": page.index + 1,
            "contenu": contenu,
            "header": page.header or "",
            "footer": page.footer or "",
        })

    return pages

Passo 2: Fragmentação onde o documento o permite

Dividir a cada mil caracteres corta frases a meio e separa um título do seu conteúdo. Como o OCR lhe fornece Markdown, aproveite a sua estrutura: a função segmenta primeiro pelos títulos de nível dois, mantém toda a secção apenas se couber no tamanho máximo e recorre aos parágrafos apenas quando há excesso. Cada fragmento mantém assim o seu título de secção, o que melhora significativamente a relevância da pesquisa semântica.

def chunker_par_sections(
    texte: str,
    taille_max: int = 1000,
    chevauchement: int = 200
) -> list[str]:
    """Splits text respecting Markdown sections."""
    sections = texte.split("\n## ")
    chunks = []

    for section in sections:
        if not section.strip():
            continue

        # Reconstruct section heading
        if not section.startswith("## "):
            section = "## " + section

        if len(section) <= taille_max:
            chunks.append(section)
        else:
            # Sub-split by paragraphs
            paragraphes = section.split("\n\n")
            chunk_courant = ""

            for para in paragraphes:
                if len(chunk_courant) + len(para) > taille_max:
                    if chunk_courant:
                        chunks.append(chunk_courant.strip())
                    chunk_courant = para
                else:
                    chunk_courant += "\n\n" + para

            if chunk_courant:
                chunks.append(chunk_courant.strip())

    return chunks

Passo 3: Vetorizar e pesquisar

A indexação vetoriza cada fragmento com mistral-embed e armazena, juntamente com o vetor, o nome do documento e o ID do fragmento — sem estes metadados, pode responder mas não citar fontes. A pesquisa vetoriza a pergunta da mesma forma e calcula depois a similaridade do cosseno normalizada pelas normas de ambos os vetores, impedindo que um fragmento longo vença simplesmente por ser longo.

import numpy as np

def creer_index(documents: dict[str, list[dict]]) -> list[dict]:
    """Creates a vector index from extracted documents."""
    index = []

    for nom_doc, pages in documents.items():
        # Concatenate all pages
        texte_complet = "\n\n".join(p["contenu"] for p in pages)

        # Chunking
        chunks = chunker_par_sections(texte_complet)

        for i, chunk in enumerate(chunks):
            # Embedding
            response = client.embeddings.create(
                model="mistral-embed",
                inputs=[chunk]
            )

            index.append({
                "document": nom_doc,
                "chunk_id": i,
                "texte": chunk,
                "embedding": np.array(response.data[0].embedding),
                "page": pages[0]["page"] if pages else 0,
            })

    return index


def rechercher_chunks(
    question: str,
    index: list[dict],
    top_k: int = 5
) -> list[dict]:
    """Searches for the most relevant chunks."""
    response = client.embeddings.create(
        model="mistral-embed",
        inputs=[question]
    )
    q_emb = np.array(response.data[0].embedding)

    scores = []
    for item in index:
        similarite = np.dot(q_emb, item["embedding"]) / (
            np.linalg.norm(q_emb) * np.linalg.norm(item["embedding"])
        )
        scores.append((similarite, item))

    scores.sort(key=lambda x: x[0], reverse=True)
    return [item for _, item in scores[:top_k]]

Passo 4: Gerar uma resposta com fontes

A peça final reúne os cinco melhores fragmentos num contexto, cada um prefixado com o seu documento e número, e impõe uma instrução estrita ao modelo: responder apenas com base no contexto fornecido e citar as fontes. Este prompt de sistema distingue um assistente de documentos de um modelo que improvisa, e é por isso que preservou os metadados durante a indexação.

def repondre_question(question: str, index: list[dict]) -> str:
    """Answers a question using RAG."""
    # Search for relevant chunks
    resultats = rechercher_chunks(question, index, top_k=5)

    # Build context
    contexte = "\n\n---\n\n".join(
        f"[Source: {r['document']}, Chunk {r['chunk_id']}]\n{r['texte']}"
        for r in resultats
    )

    # Generate answer
    response = client.chat.complete(
        model="mistral-small-latest",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are a document assistant. Answer "
                    "questions based solely on the provided "
                    "context. Cite sources."
                )
            },
            {
                "role": "user",
                "content": (
                    f"Context:\n{contexte}\n\n"
                    f"Question: {question}"
                )
            }
        ]
    )

    return response.choices[0].message.content

Do protótipo à loja vetorial

Um índice em memória funciona enquanto se mantiver abaixo de alguns milhares de fragmentos. Para além disso, a pesquisa linear colapsa e nada sobrevive a um reinício: mude para uma loja vetorial real (Pinecone, Weaviate, Qdrant, ChromaDB). A mudança é pouco dispendiosa, como mostra esta variante com ChromaDB onde apenas o armazenamento e a consulta mudam — as suas funções de extração e fragmentação permanecem intactas.

# Example with ChromaDB
import chromadb

chroma_client = chromadb.Client()
collection = chroma_client.create_collection(name="documents")

# Indexing
for item in index:
    collection.add(
        ids=[f"{item['document']}_{item['chunk_id']}"],
        embeddings=[item["embedding"].tolist()],
        documents=[item["texte"]],
        metadatas=[{"document": item["document"]}]
    )

# Search
resultats = collection.query(
    query_embeddings=[q_emb.tolist()],
    n_results=5
)

Pontos-chave

  • O pipeline OCR + RAG converte os seus documentos numa base de conhecimento consultável
  • O enriquecimento via anotações (descrições de imagens) previne a perda de informação
  • A fragmentação inteligente respeita as secções e parágrafos do documento
  • Utilize uma loja vetorial real em produção (ChromaDB, Pinecone, Qdrant)
  • A qualidade da extração por OCR determina a qualidade das respostas do RAG