Pipeline de producție
Pe această pagină
Actualizare 2 noiembrie 2026 — OCR. OCR 4.0 (
mistral-ocr-4-0) a fost retras la 30 septembrie 2026. Utilizați OCR 4.1 (mistral-ocr-4-1), disponibil public din 31 august la același preț, sau aliasulmistral-ocr-latest, care indică spre acesta din 16 iulie. OCR 4.1 adaugă scoruri de încredere la nivel de bloc. Addendum 3 noiembrie 2026: Un PDF local este transmis în base64 sub forma{"type": "document_url", "document_url": "data:application/pdf;base64,…"}; tipuldocument_base64din exemplele mai vechi nu există nici în documentație, nici în SDK-ulmistralai, iar acele exemple ar fi eșuat. Surse: Procesor OCR · Document QnA. Corectat la 3 noiembrie 2026: Codul anterior citeapage.document_annotationpagină cu pagină; în SDK-ulmistralaiversiunea 3.7.0, adnotarea documentului este un singur câmp în răspuns (response.document_annotation), iar adnotarea unei imagini se citește dinimage.image_annotation.
De la dovada conceptului la producție
Ați învățat cum să utilizați OCR, adnotările și Document AI QnA. Mai rămâne o lacună costisitoare: distanța dintre un script care funcționează pe laptopul dumneavoastră și un serviciu pe care colegii dumneavoastră se bazează în fiecare dimineață. Această ultimă lecție asamblează blocurile de construcție anterioare într-un pipeline robust, complet cu recuperare după erori, monitorizare și control al costurilor.
Cele șase componente ale unui pipeline complet
- Coada de ingestie: Primește și prioritizează documentele.
- Pre-procesare: Validează, convertește formatele și îmbunătățește imaginile.
- OCR + Adnotări: Extrage textul și datele structurate.
- Post-procesare: Validează, curăță și îmbogățește datele.
- Stocare: Baze de date, stocuri vectoriale și arhivare.
- Interfață de interogare: API QnA, panouri de control și integrări.
Codul din această lecție acoperă nucleul lanțului—pașii 3 și 4—deoarece acolo se concentrează dificultățile operaționale.
O clasă care încapsulează procesarea
Clasa PipelineDocumentAI setează o configurație o dată pentru totdeauna—schema de adnotare, formatul tabelului și numărul de reîncercări—apoi o aplică fiecărui document. Trei mecanisme merită atenția dumneavoastră. În primul rând, reîncercarea cu backoff exponențial (time.sleep(2 ** tentative) espacează încercările la una, apoi două, apoi patru secunde. Acest lucru oferă timp saturării tranzitorii a API-ului să se rezolve, în loc să o agraveze. În al doilea rând, jurnalizarea (logging) urmărește fiecare succes cu numărul său de pagini și durata, și fiecare eșec cu numărul încercării; fără aceste linii, veți descoperi incidentele abia când vă sună departamentul de contabilitate. În final, dicționarul stats alimentează raportul de la sfârșitul lotului.
Rețineți că metoda returnează întotdeauna un ResultatTraitement, chiar și după epuizarea reîncercărilor: apelantul nu trebuie niciodată să gestioneze o excepție, ci pur și simplu citește câmpul erreur.
import os
import time
import base64
import logging
from pathlib import Path
from dataclasses import dataclass, field
from mistralai.client import Mistral
from mistralai.extra import response_format_from_pydantic_model
from pydantic import BaseModel, Field
from typing import Optional
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("document_ai_pipeline")
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
@dataclass
class ResultatTraitement:
fichier: str
pages: int = 0
texte: str = ""
annotations: Optional[dict] = None
duree_secondes: float = 0.0
erreur: Optional[str] = None
class PipelineDocumentAI:
def __init__(
self,
schema_annotation=None,
table_format: str = "markdown",
max_retries: int = 3,
):
self.schema_annotation = schema_annotation
self.table_format = table_format
self.max_retries = max_retries
self.stats = {"total": 0, "succes": 0, "erreurs": 0}
def traiter_document(self, chemin: str) -> ResultatTraitement:
"""Procesează un document cu reîncercare și monitorizare."""
debut = time.time()
self.stats["total"] += 1
for tentative in range(self.max_retries):
try:
# Citire și codificare
with open(chemin, "rb") as f:
doc_b64 = base64.b64encode(f.read()).decode("utf-8")
# Parametri apelului
params = {
"model": "mistral-ocr-latest",
"document": {
"type": "document_url",
"document_url": f"data:application/pdf;base64,{doc_b64}"
},
"table_format": self.table_format,
}
if self.schema_annotation:
params["document_annotation_format"] = (
response_format_from_pydantic_model(
self.schema_annotation
)
)
# Apel OCR
response = client.ocr.process(**params)
# Extrage textul
texte = "\n\n".join(
p.markdown for p in response.pages
)
# Extrage adnotările
annotations = None
if self.schema_annotation:
if response.document_annotation:
annotations = response.document_annotation
duree = time.time() - debut
self.stats["succes"] += 1
logger.info(
f"OK: {chemin} ({len(response.pages)} pagini, "
f"{duree:.1f}s)"
)
return ResultatTraitement(
fichier=chemin,
pages=len(response.pages),
texte=texte,
annotations=annotations,
duree_secondes=duree,
)
except Exception as e:
logger.warning(
f"Tentativa {tentative + 1}/{self.max_retries} "
f"eșuată pentru {chemin}: {e}"
)
if tentative < self.max_retries - 1:
time.sleep(2 ** tentative) # Backoff exponențial
# Toate încercările au eșuat
self.stats["erreurs"] += 1
return ResultatTraitement(
fichier=chemin,
duree_secondes=time.time() - debut,
erreur="Eșec după toate încercările",
)
def traiter_dossier(self, dossier: str) -> list[ResultatTraitement]:
"""Procesează toate fișierele PDF dintr-un dosar."""
chemin = Path(dossier)
fichiers = sorted(chemin.glob("*.pdf"))
resultats = []
for fichier in fichiers:
resultat = self.traiter_document(str(fichier))
resultats.append(resultat)
return resultats
def rapport(self) -> str:
"""Generează un raport de procesare."""
return (
f"Documente procesate: {self.stats['total']}\n"
f"Succese: {self.stats['succes']}\n"
f"Erori: {self.stats['erreurs']}\n"
f"Rata de succes: "
f"{self.stats['succes']/max(self.stats['total'],1)*100:.1f}%"
)
În practică, aceeași clasă acoperă ambele nevoi: instanțiată fără o schemă, extrage simplu textul; instanțiată cu un model Pydantic, produce și date structurate.
# Pipeline simplu (doar OCR)
pipeline = PipelineDocumentAI(table_format="markdown")
resultats = pipeline.traiter_dossier("./factures/")
print(pipeline.rapport())
# Pipeline cu adnotări
from pydantic import BaseModel, Field
class ExtractionFacture(BaseModel):
fournisseur: str = Field(..., description="Numele furnizorului")
montant_ttc: float = Field(..., description="Suma totală cu TVA")
date: str = Field(..., description="Data (YYYY-MM-DD)")
pipeline_annote = PipelineDocumentAI(
schema_annotation=ExtractionFacture,
table_format="markdown"
)
resultats = pipeline_annote.traiter_dossier("./factures/")
Anticiparea facturii
Controlul costurilor este esențial în producție și începe cu înțelegerea elementelor pentru care vi se facturează.
| Element | Baza de facturare |
|---|---|
| OCR | Per pagină procesată |
| Adnotări | Incluse în apelul OCR (fără cost suplimentar) |
| QnA | Tokeni de intrare/ieșire bazați pe modelul de chat |
| Embeddings | Tokeni de intrare |
Faptul că adnotările nu implică costuri suplimentare schimbă proiectarea: extrageți metadatele în timpul pasului OCR, în loc să rulați un apel LLM separat ulterior. Funcția de estimare de mai jos vă permite să calculați prețul unui proiect înainte de a-l lansa; ratele sale sunt cifre ordinale de mărime care trebuie ajustate, tabelul de referință publicat de Mistral rămânând autoritatea supremă.
def estimer_cout(
nombre_pages: int,
avec_qna: bool = False,
modele_qna: str = "mistral-small-latest"
) -> dict:
"""Estimează costul de procesare."""
# Rate aproximative (verificați ratele curente)
cout_ocr_par_page = 0.001 # Ajustați în funcție de nivel
cout_qna_par_1k_tokens = {
"mistral-small-latest": 0.001,
"mistral-large-latest": 0.008,
}
cout_ocr = nombre_pages * cout_ocr_par_page
cout_qna = 0.0
if avec_qna:
# Estimare: ~500 tokeni per pagină în medie
tokens_estimes = nombre_pages * 500
cout_qna = (
tokens_estimes / 1000
* cout_qna_par_1k_tokens.get(modele_qna, 0.001)
)
return {
"cout_ocr": round(cout_ocr, 4),
"cout_qna": round(cout_qna, 4),
"cout_total": round(cout_ocr + cout_qna, 4),
}
Monitorizarea sănătății serviciului
Un pipeline se degradează lent și silențios: un nou furnizor trimite scanări de calitate slabă, rata de eroare crește de la 2% la 15%, și nimeni nu observă până la închiderea lunară. Patru metrici sunt suficiente pentru a detecta deriva—volumul procesat, durata medie, rata de eroare și costul estimat—cu condiția să le emiteți sistematic și să le trimiteți către instrumentul dumneavoastră obișnuit, fie el Datadog, Prometheus sau altul.
import json
from datetime import datetime
def log_metrique(nom: str, valeur: float, tags: dict = None) -> None:
"""Înregistrează o metrică de monitorizare."""
metrique = {
"timestamp": datetime.utcnow().isoformat(),
"nom": nom,
"valeur": valeur,
"tags": tags or {}
}
# În producție: trimiteți către Datadog, Prometheus, etc.
logger.info(f"METRIQUE: {json.dumps(metrique)}")
# Exemple de metrici de urmărit
log_metrique("ocr.pages_traitees", 150, {"batch": "factures_mars"})
log_metrique("ocr.duree_moyenne_secondes", 2.3)
log_metrique("ocr.taux_erreur", 0.02)
log_metrique("ocr.cout_estime_usd", 0.15)
Încotro дальше
Aveți acum bazele pentru a construi un sistem complet Document AI, iar mai multe extensii se deschid în funcție de constrângerile dumneavoastră. Volumele foarte mari justifică o implementare on-premise a modelului OCR pe un GPU dedicat; documentele foarte specifice afacerii dumneavoastră pot motiva fine-tuning-ul, un subiect de abordat direct cu Mistral. Din partea de integrare, provocarea constă în conectarea pipeline-ului la sistemele dumneavoastră existente—ERP, CRM—și construirea unui panou de control astfel încât echipele dumneavoastră să poată interoga documentele singure, fără a trece prin dumneavoastră. Pasul final este eliminarea declanșării manuale: pipeline-ul rulează automat când sosesc documente noi.
Rezumatul cursului
Aceste șaisprezece lecții v-au ghidat prin întregul ciclu. Ați început cu fundamentele—ce este Document AI, modelul OCR 4 și cazurile de utilizare—înainte de a trece la OCR avansat cu API-ul, extragerea tabelelor, anteturi/subsoluri și optimizare. Adnotările v-au oferit apoi extracție structurată, procesare în lot și control al conformității, urmate de Document QnA, care a deschis interogarea în limbaj natural, de la documente izolate la corpusuri indexate în RAG. Aveți acum blocurile de construcție necesare pentru a echipa gestionarea documentelor organizației dumneavoastră cu Mistral Document AI.
Puncte cheie
- Un pipeline de producție include reîncercare, jurnalizare, monitorizare și gestionarea costurilor.
- Backoff-ul exponențial protejează împotriva erorilor tranzitorii ale API-ului.
- Estimați-vă costurile înainte de scalare (OCR per pagină, QnA per token).
- Monitorizarea continuă vă permite să detectați degradarea performanței.
- Document AI acoperă întregul ciclu de viață al documentului, de la ingestie la operare.
Testați-vă cunoștințele
OCR, adnotări, QnA: validați lanțul complet de documente.
1. Ce produce API-ul OCR de la Mistral dintr-un document?
Răspuns: Conținutul structurat al documentului—text, tabele, aspect—gata pentru utilizare programatică: OCR 4 citește documentul ca sursă de date, nu ca imagine.
2. Care este scopul API-ului de Adnotări?
Răspuns: Extrage metadate structurate conform schemei dumneavoastră (câmpuri de factură, clauze de contract)—fie individual, fie în lot pentru volume mari.
3. Ce permite Document QnA?
Răspuns: Punerea de întrebări în limbaj natural despre unul sau mai multe documente și obținerea de răspunsuri bazate pe conținutul lor—stratul conversațional peste extracție.
4. Cum optimizați acuratețea OCR?
Răspuns: Prin calitatea intrării (rezoluție, claritate, orientare) și gestionarea zonelor dificile—anteturi, subsoluri, paginare—pe care cursul vă învață să le gestionați explicit.
5. De ce să combinați OCR și RAG?
Răspuns: OCR transformă documentele scanate în text indexabil, în timp ce RAG le face interogabile la scară: împreună, permit căutarea semantică prin arhive întregi.
Extracție, adnotare, întrebări și răspunsuri, indexare: pipeline-ul de producție de mai sus înlănțuie toate cele patru—hârtiile dumneavoastră devin o bază de date.