Verification de Documents d'Achats - LightOn Documentation

Derniere mise a jour : Avril 2026 — L’API Paradigm evolue rapidement. Consultez toujours la derniere reference API et privilegiez les cookbooks les plus recents.

Presentation

Verifier la coherence des informations entre plusieurs documents lies — formulaires de marches publics, contrats, releves bancaires, declarations d’identite — est un travail fastidieux, source d’erreurs et couteux lorsqu’il est realise manuellement. Ce cookbook montre comment construire un pipeline de verification automatise qui charge des documents dans Paradigm, extrait des champs specifiques via Document Search, et les recoupe grace a Chat Completions avec des prompts structures. Ce pattern s’applique a tout workflow de verification multi-documents : audits de conformite, traitement de sinistres d’assurance, demandes de prets, integration de fournisseurs, et plus encore.

Cet exemple est base sur un cas d’usage reel en production pour la verification de formulaires de marches publics francais (DC4). Le pattern se generalise a tout scenario ou vous devez verifier la coherence entre plusieurs documents.

Demo

Decouvrez le pipeline en action — chargement de documents, execution des controles automatiques et generation d’un rapport de verification :

Fonctionnement

L’utilisateur charge un ensemble de documents lies (ex. : un formulaire, un contrat, un RIB, une declaration).
Les documents sont ingeres dans Paradigm via l’API Upload Sessions.
Pour chaque controle, des champs specifiques sont extraits des documents concernes via Document Search.
Les champs extraits sont compares via Chat Completions avec un prompt systeme structure qui gere la correspondance approximative (fautes, differences de format, abreviations).
Chaque controle retourne un resultat structure : is_correct, les valeurs comparees, et une explication de la decision.
Tous les resultats sont compiles dans un rapport de verification.

Pipeline de verification de documents — diagramme d'architecture montrant le chargement, l'extraction, le recoupement et la generation de rapport

Prerequis

Une cle API Paradigm (obtenir une cle)
Python 3.10+
Documents a verifier (des documents d’exemple sont fournis dans le depot GitHub)

Endpoints API utilises

Endpoint	Role dans ce pipeline
`POST /v2/upload-sessions`	Creer une session pour charger des documents
`POST /v2/upload-sessions/{id}/files`	Charger des fichiers individuels dans la session
`POST /v2/chat/document-search`	Extraire des champs specifiques des documents charges
`POST /v2/chat/completions`	Recouper les champs extraits avec correspondance approximative

Implementation etape par etape

Etape 1 : Configurer le client Paradigm

Creez un wrapper autour de l’API Paradigm. Ce client gere l’authentification, le chargement de documents, l’extraction de champs et le recoupement.

import requests
from typing import Optional

class ParadigmClient:
    """Client pour interagir avec l'API Paradigm."""

    def __init__(self, api_key: str, base_url: str = "https://paradigm.lighton.ai"):
        self.api_key = api_key
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }

Etape 2 : Charger les documents

Les documents doivent etre charges dans Paradigm avant de pouvoir etre interroges. L’API Upload Sessions gere le pipeline d’ingestion — vous creez une session, chargez les fichiers, puis fermez la session pour declencher l’embedding.

def create_upload_session(self) -> dict:
    """Cree une nouvelle session de chargement pour l'ingestion de documents."""
    response = requests.post(
        f"{self.base_url}/api/v2/upload-sessions",
        headers=self.headers,
        json={"pipeline": "v2.2.1"}
    )
    response.raise_for_status()
    return response.json()

def upload_file(self, session_id: str, file_path: str) -> dict:
    """Charge un fichier dans une session existante."""
    with open(file_path, "rb") as f:
        response = requests.post(
            f"{self.base_url}/api/v2/upload-sessions/{session_id}/files",
            headers={"Authorization": f"Bearer {self.api_key}"},
            files={"file": f}
        )
    response.raise_for_status()
    return response.json()

def close_upload_session(self, session_id: str) -> dict:
    """Ferme la session pour declencher l'embedding des documents."""
    response = requests.post(
        f"{self.base_url}/api/v2/upload-sessions/{session_id}/close",
        headers=self.headers
    )
    response.raise_for_status()
    return response.json()

Les documents doivent etre entierement indexes avant de pouvoir etre interroges. Le temps d’indexation depend de la taille et de la complexite du document — en general quelques secondes a quelques minutes.

Etape 3 : Extraire des champs avec Document Search

Une fois les documents indexes, utilisez Document Search pour extraire des champs specifiques. Le parametre query est une question en langage naturel — Paradigm recherche dans le document et retourne le contenu pertinent.

def search_document(
    self,
    file_ids: list[str],
    query: str,
    tool: str = "DocumentSearch"
) -> dict:
    """Extrait des informations specifiques des documents charges.

    Args:
        file_ids: identifiants Paradigm des fichiers a interroger.
        query: question en langage naturel decrivant ce qu'il faut extraire.
        tool: "DocumentSearch" pour le texte, "VisionDocumentSearch" pour les docs scannes.
    """
    payload = {
        "model": "alfred-4.2",
        "query": query,
        "file_ids": file_ids,
        "tool": tool
    }
    response = requests.post(
        f"{self.base_url}/api/v2/chat/document-search",
        headers=self.headers,
        json=payload,
        timeout=150
    )
    response.raise_for_status()
    return response.json()

Exemples de requetes d’extraction :

# Extraire le nom de l'acheteur d'un formulaire
result = client.search_document(
    file_ids=[form_file_id],
    query="Quel est le nom du pouvoir adjudicateur ?"
)

# Extraire le numero de reference du marche d'un avis de marche
result = client.search_document(
    file_ids=[tender_notice_id],
    query="Quel est le numero de reference du marche ?"
)

# Extraire les coordonnees bancaires d'un document scanne
result = client.search_document(
    file_ids=[bank_doc_id],
    query="Quel est le numero IBAN ?",
    tool="VisionDocumentSearch"  # Utiliser la vision pour les documents scannes
)

Etape 4 : Recouper les champs avec Chat Completions

C’est le coeur du pipeline de verification. Apres avoir extrait le meme champ de deux documents differents, utilisez Chat Completions avec un prompt systeme structure pour les comparer. Le prompt gere les imperfections du monde reel : fautes de frappe, differences de formatage, abreviations, accents manquants.

def cross_reference(self, query: str) -> dict:
    """Compare les valeurs extraites via correspondance approximative par LLM.

    Retourne une reponse JSON structuree avec :
        - is_correct: bool — si les valeurs correspondent
        - compare_values: dict — les valeurs comparees
        - details: str — explication du resultat de la comparaison
    """
    system_prompt = """You are a document verification assistant. Your role is to compare
data extracted from different documents and determine if they match.

Rules for comparison:
- Names: ignore case, accents, and minor spelling variations.
  "JEAN-PIERRE DUPONT" matches "Jean-Pierre Dupont" matches "Jean Pierre Dupont".
- Addresses: compare street, postal code, and city separately.
  Minor differences in formatting are acceptable.
- Phone numbers: ignore spaces, dots, and country prefixes.
  "01 23 45 67 89" matches "+33 1 23 45 67 89" matches "0123456789".
- Emails: case-insensitive comparison.

Always respond in valid JSON with this exact structure:
{
    "is_correct": true/false,
    "compare_values": {"document_1": "...", "document_2": "..."},
    "details": "Explanation of why the values match or don't match."
}"""

    payload = {
        "model": "alfred-4.2",
        "messages": [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": query}
        ],
        "max_tokens": 500,
        "temperature": 0.1
    }
    response = requests.post(
        f"{self.base_url}/api/v2/chat/completions",
        headers=self.headers,
        json=payload,
        timeout=150
    )
    response.raise_for_status()
    data = response.json()
    return data["choices"][0]["message"]["content"]

Le prompt systeme ci-dessus est essentiel pour gerer les donnees reelles. Adaptez les regles de correspondance approximative a votre domaine. Par exemple, pour la verification de documents financiers, vous pourriez vouloir une correspondance stricte sur les montants mais approximative sur les noms d’entreprise.

Etape 5 : Definir les controles de verification

Chaque controle est une fonction qui extrait un champ de deux documents et les compare. Voici le pattern — repetez-le pour chaque champ a verifier.

import json

def verify_buyer_name(client: ParadigmClient, form_id: str, tender_id: str) -> dict:
    """Verifie que le nom de l'acheteur correspond entre le formulaire et l'avis de marche."""
    # Etape A : extraction du document 1
    form_result = client.search_document(
        file_ids=[form_id],
        query="What is the full name of the public buyer?"
    )

    # Etape B : extraction du document 2
    tender_result = client.search_document(
        file_ids=[tender_id],
        query="What is the full name of the public buyer?"
    )

    # Etape C : recoupement
    comparison = client.cross_reference(
        f"Compare these buyer names:\n"
        f"Document 1 (form): {form_result['answer']}\n"
        f"Document 2 (tender notice): {tender_result['answer']}"
    )

    return {
        "check": "buyer_name",
        "result": json.loads(comparison)
    }

Etape 6 : Orchestrer tous les controles

Executez tous les controles en parallele pour gagner en rapidite, puis compilez les resultats dans un rapport.

import concurrent.futures

def run_verification(client: ParadigmClient, document_ids: dict) -> list[dict]:
    """Execute tous les controles de verification en parallele.

    Args:
        document_ids: correspondance entre type de document et identifiant Paradigm.
            Exemple: {"form": "abc123", "tender_notice": "def456", "bank_details": "ghi789"}
    """
    checks = [
        lambda: verify_buyer_name(client, document_ids["form"], document_ids["tender_notice"]),
        lambda: verify_buyer_address(client, document_ids["form"], document_ids["tender_notice"]),
        lambda: verify_buyer_email(client, document_ids["form"], document_ids["tender_notice"]),
        lambda: verify_contract_ref(client, document_ids["form"], document_ids["tender_notice"]),
        lambda: verify_candidate_name(client, document_ids["form"], document_ids["contract"]),
        lambda: verify_iban(client, document_ids["form"], document_ids["bank_details"]),
        # ... ajoutez d'autres controles selon vos besoins
    ]

    results = []
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        futures = [executor.submit(check) for check in checks]
        for future in concurrent.futures.as_completed(futures):
            results.append(future.result())

    return results

Exemple de sortie :

[
  {
    "check": "buyer_name",
    "result": {
      "is_correct": true,
      "compare_values": {
        "document_1": "Ministere de l'Interieur",
        "document_2": "MINISTÈRE DE L'INTÉRIEUR"
      },
      "details": "Les noms correspondent — les differences portent uniquement sur la casse et les accents."
    }
  },
  {
    "check": "iban",
    "result": {
      "is_correct": false,
      "compare_values": {
        "document_1": "FR76 3000 6000 0112 3456 7890 189",
        "document_2": "FR76 3000 6000 0112 3456 7890 199"
      },
      "details": "Divergence d'IBAN — les deux derniers chiffres different (189 vs 199)."
    }
  }
]

Etape 7 : Generer un rapport de verification

Compilez tous les resultats dans un rapport structure. L’exemple ci-dessous genere un resume simple — en production, vous pourriez generer un PDF ou ecrire en base de donnees.

def generate_report(results: list[dict]) -> dict:
    """Compile les resultats de verification dans un rapport de synthese."""
    passed = [r for r in results if r["result"]["is_correct"]]
    failed = [r for r in results if not r["result"]["is_correct"]]

    report = {
        "total_checks": len(results),
        "passed": len(passed),
        "failed": len(failed),
        "status": "VALID" if len(failed) == 0 else "INVALID",
        "details": {
            "passed_checks": [r["check"] for r in passed],
            "failed_checks": [
                {
                    "check": r["check"],
                    "reason": r["result"]["details"],
                    "values": r["result"]["compare_values"]
                }
                for r in failed
            ]
        }
    }
    return report

Code complet

Code source complet

Clonez le depot pour executer le pipeline complet avec des documents d’exemple.

Reference API

Documentation complete de l’API Paradigm.

Personnalisation

Adaptez ce pipeline a vos propres besoins de verification :

Parametre	Description	Defaut	Quand l’ajuster…
`model`	Modele LLM pour l’extraction et la comparaison	`alfred-4.2`	Vous avez besoin d’un compromis vitesse/qualite different
`temperature`	Determinisme de la comparaison	`0.1`	Vous voulez une correspondance plus stricte (baisser) ou plus souple (augmenter)
`tool`	Outil de recherche documentaire	`DocumentSearch`	Utilisez `VisionDocumentSearch` pour les documents scannes ou les images
`max_workers`	Threads paralleles pour les controles	`5`	Augmenter pour plus de controles, reduire si vous atteignez les limites de debit
Regles du prompt systeme	Comportement de correspondance approximative	Voir etape 4	Votre domaine a des exigences de correspondance differentes (montants, dates, identifiants)

Ajouter vos propres controles

Pour ajouter un nouveau controle de verification, suivez ce pattern en trois etapes :

Extraire le champ du document A avec search_document() et une requete en langage naturel claire
Extraire le meme champ du document B
Comparer avec cross_reference() — le prompt systeme gere la correspondance approximative

def verify_custom_field(client, doc_a_id, doc_b_id):
    a = client.search_document([doc_a_id], "Votre requete d'extraction pour le document A")
    b = client.search_document([doc_b_id], "Votre requete d'extraction pour le document B")
    comparison = client.cross_reference(
        f"Compare: Document A says '{a['answer']}', Document B says '{b['answer']}'"
    )
    return {"check": "custom_field", "result": json.loads(comparison)}

Bonnes pratiques

Utilisez VisionDocumentSearch pour les documents scannes — le DocumentSearch standard fonctionne pour les PDF natifs, mais les documents scannes et les images necessitent l’outil vision pour une extraction fiable.
Gardez les requetes d’extraction specifiques — “Quel est l’IBAN ?” fonctionne mieux que “Extraire toutes les informations bancaires.” Un champ par requete donne des resultats plus fiables.
Adaptez le prompt systeme a votre domaine — les regles de correspondance approximative doivent refleter vos exigences metier. Les donnees financieres peuvent necessiter une correspondance exacte ; les noms et adresses necessitent generalement une correspondance approximative.
Executez les controles en parallele — chaque controle est independant, utilisez le threading pour les traiter simultanement. Ajoutez un leger delai entre les lots si vous atteignez les limites de debit.
Journalisez les resultats intermediaires — quand un controle echoue, avoir les valeurs brutes extraites des deux documents facilite grandement le debogage.

​Presentation

​Demo

​Fonctionnement

​Prerequis

​Endpoints API utilises

​Implementation etape par etape

​Etape 1 : Configurer le client Paradigm

​Etape 2 : Charger les documents

​Etape 3 : Extraire des champs avec Document Search

​Etape 4 : Recouper les champs avec Chat Completions

​Etape 5 : Definir les controles de verification

​Etape 6 : Orchestrer tous les controles

​Etape 7 : Generer un rapport de verification

​Code complet

Code source complet

Reference API

​Personnalisation

​Ajouter vos propres controles

​Bonnes pratiques

Presentation

Demo

Fonctionnement

Prerequis

Endpoints API utilises

Implementation etape par etape

Etape 1 : Configurer le client Paradigm

Etape 2 : Charger les documents

Etape 3 : Extraire des champs avec Document Search

Etape 4 : Recouper les champs avec Chat Completions

Etape 5 : Definir les controles de verification

Etape 6 : Orchestrer tous les controles

Etape 7 : Generer un rapport de verification

Code complet

Personnalisation

Ajouter vos propres controles

Bonnes pratiques