Премини към основното съдържание
Български— Изберете език
Меню

Интеграция на OCR + RAG

Урок 15 от 16 Обновен 3 ноември 2026 г. Програмист
На тази страница
  1. Изграждане на интелигентна документална система
  2. Архитектура от пет стъпки
  3. Стъпка 1: Извличане без загуба на информация
  4. Стъпка 2: Разделяне на части там, където документът позволява
  5. Стъпка 3: Векторизиране и търсене
  6. Стъпка 4: Генериране на отговор с източници
  7. От прототип до векторно хранилище
  8. Ключови изводи

Актуализация от 2 ноември 2026 г. — OCR. OCR 4.0 (mistral-ocr-4-0) беше прекратен на 30 септември 2026 г. Използвайте OCR 4.1 (mistral-ocr-4-1), който е общодостъпен от 31 август на същата цена, или псевдонима mistral-ocr-latest, който сочи към него от 16 юли. OCR 4.1 добавя оценки за достоверност на ниво блок. Допълнение от 3 ноември 2026 г.: Локален PDF файл се предава в base64 като {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; типът document_base64 от по-стари примери не съществува нито в документацията, нито в SDK mistralai и тези примери биха се провалили. Източници: OCR Processor · Document QnA. Допълнение от 3 ноември: Анотациите на изображенията се четат от image.image_annotation (SDK mistralai 3.7.0), а не от image.annotation.

Изграждане на интелигентна документална система

Генерирането с подпомагане от извличане (RAG) е техниката, която прави големите масиви от документи подлежащи на заявка. Чрез комбиниране на OCR на Mistral, вграждания (embeddings) и векторно хранилище, Вие създавате система, способна да отговаря на въпроси относно Вашите архиви – десетилетие от доклади, хранилище с договори или дигитализирана техническа библиотека.

Защо да използвате OCR вместо индексиране на файловете такива, каквито са? Защото основното предизвикателство при документалния RAG е, че индексираните части трябва да бъдат текст. Мултимодалните вграждания все още не са достатъчно ефективни, за да сравняват директно текстови въпроси с изображения на документи. OCR служи като мост: той преобразува Вашите документи във висококачествен структуриран текст, който след това индексирате във Вашето векторно хранилище.

Архитектура от пет стъпки

Всичко започва с поглъщането (ingestion), което означава получаване на документи, независимо дали пристигат като PDF файлове, изображения или DOCX файлове. Следва OCR с анотации, произвеждащ както текст, така и структурирани метаданни. Разделянето на части (chunking) разрязва този текст на смислени сегменти, вграждането ги векторизира и ги съхранява във векторното хранилище, а заявката затваря цикъла: семантично търсене сред векторите, последвано от генериране на отговор. Всяка стъпка обуславя следващата и извличането определя всичко останало – ако OCR го пропусне, никакво търсене няма да го открие.

Следващите раздели описват подробно кода за четирите стъпки, които ще напишете сами; поглъщането зависи от Вашата специфична система за входящи данни.

Стъпка 1: Извличане без загуба на информация

OCR повикването тук е конфигурирано за RAG, което личи от три избора. table_format="markdown" запазва таблиците във формат, който LLM може да прочете. Анотацията с ограничителна кутия (bounding box) описва изображенията и кодът впоследствие замества всяко препращане ![image](image) с неговото текстово описание: диаграма за разпределение на приходите става подлежащо на индексиране изречение вместо празнота в текста. Накрая, include_image_base64=False избягва изтеглянето на мегабайти пиксели, за които индексът няма употреба.

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

Стъпка 2: Разделяне на части там, където документът позволява

Разделянето на всеки хиляда знака прекъсва изреченията по средата и отделя заглавието от съдържанието му. Тъй като OCR Ви предоставя Markdown, използвайте неговата структура: функцията първо сегментира по заглавия от второ ниво, запазва целия раздел само ако се побира в максималния размер и прибягва до разбиване по абзаци само при надхвърляне. Всяка част така запазва заглавието на своя раздел, което значително подобрява релевантността на семантичното търсене.

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

Стъпка 3: Векторизиране и търсене

Индексирането векторизира всяка част с mistral-embed и съхранява, заедно с вектора, името на документа и ID на частта – без тези метаданни можете да отговорите, но не и да цитирате източници. Търсенето векторизира въпроса по същия начин, след което изчислява косинусовото сходство, нормализирано чрез нормите на двата вектора, предотвратявайки дълга част да „победи“ просто защото е дълга.

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]]

Стъпка 4: Генериране на отговор с източници

Последният елемент сглобява първите пет части в контекст, като всяка е префиксирана с нейния документ и номер, и налага строга инструкция на модела: отговаряйте единствено въз основа на предоставения контекст и цитирайте източниците. Този системен промпт отличава асистента за документи от модел, който импровизира, и това е причината да сте запазили метаданните по време на индексирането.

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

От прототип до векторно хранилище

Индекс в паметта работи, докато останете под няколко хиляди части. Отвъд това линейното търсене се срива и нищо не оцелява след рестарт: преминете към истинско векторно хранилище (Pinecone, Weaviate, Qdrant, ChromaDB). Превключването е евтино, както е показано във този вариант с ChromaDB, където се променят единствено съхранението и заявките – Вашите функции за извличане и разделяне на части остават непокътнати.

# 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
)

Ключови изводи

  • Потокът OCR + RAG преобразува Вашите документи в база от знания, подлежаща на заявка
  • Обогатяването чрез анотации (описания на изображения) предотвратява загубата на информация
  • Интелигентното разделяне на части tônува разделите и абзаците на документа
  • Използвайте истинско векторно хранилище в продукционна среда (ChromaDB, Pinecone, Qdrant)
  • Качеството на OCR извличането определя качеството на отговорите в RAG