Docling 2.140.0 testé pour de vrai : installation, conversion d'un document Word en Markdown (2026-10-18)

En résumé

Le 2026-10-18, nous avons installé Docling 2.140.0 dans un environnement Python neuf et converti en Markdown un seul document Word (.docx) que nous avons inventé : titres, paragraphes avec accents, listes à puces sur trois niveaux, liste numérotée et tableau de chiffrage de 5 lignes. Ce test porte sur une machine, une version et un document court : il décrit ce que nous avons observé, il ne mesure pas la qualité générale de Docling et ne se généralise pas à vos documents. Il complète l'avis MagicMate sur Docling, qui reste une lecture des sources publiques, en particulier pour les licences des modèles.

Ce que nous avons observé :

Installation par pip en 216 s, sans erreur ; l'environnement obtenu pèse 1 419 Mo, dont PyTorch, installé comme dépendance même si nous n'avons pas vérifié qu'il sert à une conversion Word.
Conversion d'un fichier Word sans télécharger de modèle : avec le mode hors ligne de Hugging Face activé et un dossier personnel qui n'existait pas, la conversion a réussi et ce dossier n'a pas été créé (aucun cache de modèles écrit).
Durées de conversion de 103, 77, 73 et 75 ms sur 4 exécutions d'un même processus, après environ 5,4 s d'import et 184 ms de création du convertisseur.
Toutes les chaînes que nous avons vérifiées (titres, accents, montants, symboles €, ², %) sont présentes dans la sortie ; les trois niveaux de puces et le tableau sont restitués.
Les deux niveaux de titres de notre document ressortent un cran plus bas dans le Markdown (titre de niveau 1 en ##, niveau 2 en ###).
Deux exécutions successives ont produit un fichier identique octet pour octet.

Protocole et commandes

Machine : Windows 11, Python 3.13.13, shell Git Bash. Tout s'est fait dans un dossier neuf, hors du projet, avec un environnement virtuel dédié ; les scripts sont restés dans un autre sous-dossier et ont été lancés avec python -I. Dans les commandes, $b désigne ce dossier de travail (sous-dossiers dl, src, in, out, venv, hm).

Environnement isolé : python -m venv $b/venv.
Vérification de la version : l'API JSON de PyPI indique, le 2026-10-18, la version 2.140.0 (publiée le 2026-10-16), licence MIT dans les métadonnées du paquet. Le fichier docling-2.140.0-py3-none-any.whl y est déclaré avec le SHA-256 8500cb3344dd81b1dfdfd6f97885c3ccd1cf0c4768cb488104856c787af3787f.
Téléchargement sans installation : $b/venv/Scripts/python.exe -m pip download docling==2.140.0 --no-deps --only-binary=:all: -d $b/dl. Le SHA-256 calculé avec sha256sum est identique à celui publié par PyPI. Ce fichier ne fait que 5 241 octets : c'est un paquet d'enveloppe qui dépend de docling-slim en version identique.
Installation : $b/venv/Scripts/python.exe -m pip install $b/dl/docling-2.140.0-py3-none-any.whl, depuis le registre officiel PyPI, en 216 s, code de sortie 0 ; pip check ne signale aucun conflit. Versions résolues le jour même : docling-slim 2.140.0, docling-core 2.102.0, docling-parse 7.22.3, docling-ibm-models 4.0.3, torch 2.14.1, torchvision 0.29.1, transformers 5.20.1, python-docx 1.2.0, python-pptx 1.0.2, openpyxl 3.1.5, numpy 2.5.4, pydantic 2.14.1. Nous n'avons vérifié l'empreinte que du fichier docling lui-même, pas celle des autres paquets.
Document de test : $b/venv/Scripts/python.exe -I $b/src/make_docx.py $b/in/devis-test.docx (script ci-dessous, avec python-docx 1.2.0). Fichier de 37 351 octets, SHA-256 beee484a38d07f2cef1b1f46a648aef50f79eea127694e6cb62c96ea9e1edb79 ; une régénération donnerait un fichier probablement différent octet pour octet (horodatages internes du format), le contenu étant le même. Le total du tableau (1 626,90 €) est la somme des quatre lignes, vérifiée par nous.
Conversion : HF_HUB_OFFLINE=1 HOME=$b/hm USERPROFILE=$b/hm $b/venv/Scripts/python.exe -I $b/src/run_docling.py $b/in/devis-test.docx $b/out/devis-test.md 4. Le dossier hm n'existait pas au départ et n'existait toujours pas à la fin. Le script appelle DocumentConverter().convert(...) avec la configuration par défaut, puis export_to_markdown(). Le pic de mémoire est lu en fin de processus (PeakWorkingSetSize) : il couvre donc les 4 conversions. Il a été de 358,6 Mo sur ces 4 conversions et de 341,5 Mo sur une exécution à une seule conversion.
Vérification : nous avons relu la sortie en la comparant à notre script de génération et testé la présence de 14 chaînes attendues (titre, ville avec apostrophe, montants, total, 42 m², (€), pourcentage) : aucune n'est absente. Ce test de présence ne contrôle pas l'ordre ni la mise en forme, relus à l'œil.

Script exact make_docx.py (SHA-256 du fichier, fins de ligne LF : 3d5f4ae7caf555e572eccbb54f6230d80c43a300e0469438bbcb2681fdd22d64) :

# Usage: python -I make_docx.py <out.docx>
import sys
from docx import Document

d = Document()
d.add_heading("Devis n° 2026-014 : rénovation de la salle de réunion", level=1)
d.add_paragraph("Établi le 12 mars 2026 pour la société Atelier Brancourt, à Villeneuve-d'Ascq. Les prix sont indiqués en euros, hors taxes.")
d.add_heading("Périmètre des travaux", level=2)
d.add_paragraph("Dépose de l'ancien revêtement", style="List Bullet")
d.add_paragraph("Préparation des murs", style="List Bullet")
d.add_paragraph("Ponçage et rebouchage", style="List Bullet 2")
d.add_paragraph("Application de l'enduit lissé", style="List Bullet 2")
d.add_paragraph("Deux passes à vingt-quatre heures d'intervalle", style="List Bullet 3")
d.add_paragraph("Peinture finale", style="List Bullet")
d.add_heading("Étapes de validation", level=2)
d.add_paragraph("Visite préalable du chantier", style="List Number")
d.add_paragraph("Validation du nuancier par le client", style="List Number")
d.add_paragraph("Réception des travaux", style="List Number")
d.add_heading("Détail du chiffrage", level=2)
rows = [("Désignation", "Quantité", "Prix unitaire (€)", "Total (€)"),
        ("Dépose du revêtement", "42 m²", "8,50", "357,00"),
        ("Enduit lissé", "42 m²", "14,20", "596,40"),
        ("Peinture (deux couches)", "42 m²", "11,75", "493,50"),
        ("Évacuation des gravats", "1 forfait", "180,00", "180,00")]
t = d.add_table(rows=len(rows), cols=4)
t.style = "Table Grid"
for i, r in enumerate(rows):
    for j, v in enumerate(r):
        t.cell(i, j).text = v
d.add_paragraph("Total hors taxes : 1 626,90 €. Acompte de 30 % à la commande.")
d.save(sys.argv[1])

Script exact run_docling.py (SHA-256 du fichier, fins de ligne LF : 5f52864e18418ee58bc729b46bdb1b13c023598ac308917ab0cadff78633853b) :

# Usage: python -I run_docling.py <input.docx> <output.md> <runs>
import sys, time, ctypes
from ctypes import wintypes

t_imp = time.perf_counter()
from docling.document_converter import DocumentConverter
import_s = time.perf_counter() - t_imp

class PMC(ctypes.Structure):
    _fields_ = [("cb", wintypes.DWORD), ("PageFaultCount", wintypes.DWORD),
                ("PeakWorkingSetSize", ctypes.c_size_t), ("WorkingSetSize", ctypes.c_size_t),
                ("QuotaPeakPagedPoolUsage", ctypes.c_size_t), ("QuotaPagedPoolUsage", ctypes.c_size_t),
                ("QuotaPeakNonPagedPoolUsage", ctypes.c_size_t), ("QuotaNonPagedPoolUsage", ctypes.c_size_t),
                ("PagefileUsage", ctypes.c_size_t), ("PeakPagefileUsage", ctypes.c_size_t)]
def peak_mb():
    k = ctypes.WinDLL("kernel32", use_last_error=True); p = ctypes.WinDLL("psapi", use_last_error=True)
    k.GetCurrentProcess.restype = wintypes.HANDLE
    p.GetProcessMemoryInfo.argtypes = [wintypes.HANDLE, ctypes.POINTER(PMC), wintypes.DWORD]
    c = PMC(); c.cb = ctypes.sizeof(PMC)
    p.GetProcessMemoryInfo(k.GetCurrentProcess(), ctypes.byref(c), c.cb)
    return c.PeakWorkingSetSize / 1048576

src, out, runs = sys.argv[1], sys.argv[2], int(sys.argv[3])
t0 = time.perf_counter()
conv = DocumentConverter()
create_ms = round((time.perf_counter() - t0) * 1000)
times = []
md = ""
for r in range(runs):
    t1 = time.perf_counter()
    res = conv.convert(src)
    md = res.document.export_to_markdown()
    times.append(round((time.perf_counter() - t1) * 1000))
open(out, "w", encoding="utf-8", newline="\n").write(md)
print("import_s", round(import_s, 2), "create_ms", create_ms, "convert_ms", times, "peak_mb", round(peak_mb(), 1))
print("status", res.status, "format", res.input.format)

Résultats mesurés

Mesure	Valeur
Document converti	.docx de 37 351 octets, une page environ
Installation `pip`	216 s, 1 419 Mo sur disque (dossier de l'environnement)
Import du module	5,41 s (5,16 s sur une seconde exécution)
Création du convertisseur	184 ms
Conversion, 4 exécutions	103 / 77 / 73 / 75 ms
Pic de mémoire du processus	358,6 Mo (4 conversions)
Statut renvoyé	SUCCESS, format DOCX détecté
Sortie Markdown	1 114 octets, SHA-256 `48d9ed3bec0dcece220dbcaa021965ac239b3b79ca1ee318dc69a197ac7885bc`

Sortie Markdown exacte (brute, telle que publiée), identique sur deux exécutions :

## Devis n° 2026-014 : rénovation de la salle de réunion

Établi le 12 mars 2026 pour la société Atelier Brancourt, à Villeneuve-d'Ascq. Les prix sont indiqués en euros, hors taxes.

### Périmètre des travaux

- Dépose de l'ancien revêtement
- Préparation des murs
    - Ponçage et rebouchage
    - Application de l'enduit lissé
        - Deux passes à vingt-quatre heures d'intervalle
- Peinture finale

### Étapes de validation

1. Visite préalable du chantier
2. Validation du nuancier par le client
3. Réception des travaux

### Détail du chiffrage

| Désignation             | Quantité   | Prix unitaire (€)   | Total (€)   |
|-------------------------|------------|---------------------|-------------|
| Dépose du revêtement    | 42 m²      | 8,50                | 357,00      |
| Enduit lissé            | 42 m²      | 14,20               | 596,40      |
| Peinture (deux couches) | 42 m²      | 11,75               | 493,50      |
| Évacuation des gravats  | 1 forfait  | 180,00              | 180,00      |

Total hors taxes : 1 626,90 €. Acompte de 30 % à la commande.

Ce que nous relevons, sans le généraliser : les trois niveaux de la liste à puces sont restitués avec la bonne imbrication ; la liste numérotée garde ses numéros ; le tableau de 4 colonnes est restitué avec tous ses montants. Le titre principal est rendu en ## et non #, ce qui est un choix de conversion à connaître si vous reprenez le Markdown tel quel. Les issues ouvertes sur la fidélité des formats Office citées dans l'avis ne concernent pas forcément ce cas simple : nous n'avons pas essayé de les reproduire.

Limites du test

Une seule machine (Windows 11), une seule version (Docling 2.140.0, Python 3.13.13).
Un seul document, inventé par nous, court et propre, avec des styles Word standards ; un vrai devis ou une vraie facture (cellules fusionnées, images, mise en forme manuelle, listes ajoutées à la main) peut donner un autre résultat.
Seul le format Word (.docx) a été converti. Nous n'avons pas vérifié si ce chemin utilise les modèles de mise en page et d'OCR dont parle l'avis ; ce test n'apprend donc rien sur eux.
Le pic de mémoire couvre plusieurs conversions dans un même processus ; les temps de conversion mesurent un petit fichier après chargement des modules, pas un document volumineux.
Les durées dépendent du matériel ; nous n'avons ni comparé Docling à un autre outil, ni mesuré un taux d'erreur.

Ce que nous n'avons pas testé

Les PDF (natifs ou scannés), l'OCR, les images, les modèles de mise en page et de tableaux, le téléchargement des modèles depuis Hugging Face, le fonctionnement hors ligne avec modèles préchargés.
PowerPoint, Excel, HTML, e-mails, EPUB, audio, la ligne de commande docling, le serveur d'API et le serveur MCP, les intégrations LangChain, LlamaIndex et autres.
Des documents français réels et volumineux, les cas signalés dans les issues ouvertes, l'exécution sur un autre système d'exploitation, sur carte graphique, ou avec une autre version.
Les licences des modèles, que nous n'avons pas relues : voir l'avis.

Sources

Notre test du 2026-10-18, décrit ci-dessus (Docling 2.140.0, empreinte du fichier vérifiée).
https://github.com/docling-project/docling
https://pypi.org/pypi/docling/json (version, licence, empreinte SHA-256 du fichier)
Avis MagicMate sur Docling pour la lecture des sources publiques et des licences.