n8n-nodes-docx-filler

Nodes n8n pour remplir automatiquement des documents DOCX avec des tags {{TAG}}.

Parfait pour: Contrats, factures, devis, formulaires, lettres, ou tout document avec des champs a remplir.

Les 2 Nodes

| Node | Role | LLM requis | |------|------|------------| | Template Mapper | Analyse un document vierge et insere les tags {{TAG}} via IA | Oui | | DOCX Template Filler | Remplit les tags avec les valeurs JSON | Non |

Installation

# Dans votre installation n8n
npm install n8n-nodes-docx-filler

# Ou en mode developpement
cd ~/.n8n/custom
git clone https://github.com/rokodo-io/n8n-nodes-docx-filler
cd n8n-nodes-docx-filler
npm install && npm run build
# Redemarrer n8n

Workflow Complet

ETAPE 1: Creer le template (une seule fois par type de document)

  Document vierge ─────┐
  (ex: contrat.docx)   │
                       ├──► Template Mapper ──► Template avec {{TAGS}}
  Structure JSON ──────┘    + LLM              + dataStructure exacte
  (champs a remplir)


ETAPE 2: Remplir le template (a chaque utilisation)

  Template avec tags ─────┐
  (ex: contrat_TEMPLATE)  │
                          ├──► DOCX Template Filler ──► Document rempli
  Donnees JSON ───────────┘
  (valeurs reelles)

Node 1: Template Mapper

Analyse un document vierge et une structure JSON, puis utilise l'IA pour placer les tags {{TAG}} aux bons emplacements.

Configuration

| Parametre | Description | |-----------|-------------| | Document Vierge | Propriete binaire contenant le DOCX a analyser | | Structure de Donnees | JSON decrivant les champs a placer | | LLM (requis) | Modele IA pour deduire les emplacements |

Options

| Option | Description | |--------|-------------| | Seuil de Confiance | Score minimum (0-100) pour inserer un tag | | Nom Fichier Sortie | Nom du template genere | | Inclure Details | Affiche les scores de confiance (debug) |

Exemple

Entree:

{
  "client": {
    "nom": "",
    "email": "",
    "telephone": ""
  },
  "commande": {
    "numero": "",
    "date": "",
    "montant": ""
  }
}

Sortie:

• Document DOCX avec tags: {{CLIENT_NOM}}, {{CLIENT_EMAIL}}, {{COMMANDE_NUMERO}}, etc.
• dataStructure pour DocxTemplateFiller:

{
  "dataStructure": {
    "CLIENT_NOM": "",
    "CLIENT_EMAIL": "",
    "CLIENT_TELEPHONE": "",
    "COMMANDE_NUMERO": "",
    "COMMANDE_DATE": "",
    "COMMANDE_MONTANT": ""
  }
}

Node 2: DOCX Template Filler

Remplit un document DOCX contenant des tags {{TAG}} avec des donnees JSON.

Configuration

| Parametre | Description | |-----------|-------------| | Document Template | Propriete binaire contenant le DOCX avec tags | | Source des Donnees | JSON complet ou champ specifique |

Options

| Option | Description | |--------|-------------| | Style Checkboxes | Unicode, Texte (X), ou Boolean | | Nom Fichier Sortie | Nom du document genere | | Conserver Tags Vides | Garder les {{TAG}} sans valeur | | Rapport de Mapping | Liste des tags remplaces/restants |

Exemple

Entree:

{
  "client": {
    "nom": "Marie Dupont",
    "email": "[email protected]",
    "telephone": "+33 6 12 34 56 78"
  },
  "commande": {
    "numero": "CMD-2024-001",
    "date": "30/12/2024",
    "montant": "1 250,00 EUR"
  }
}

Sortie:

• Document DOCX avec les valeurs inserees
• Rapport:

{
  "success": true,
  "report": {
    "tagsReplaced": 6,
    "tagsRemaining": 0,
    "replacedTags": ["CLIENT_NOM", "CLIENT_EMAIL", "CLIENT_TELEPHONE", "COMMANDE_NUMERO", "COMMANDE_DATE", "COMMANDE_MONTANT"]
  }
}

Conversion JSON vers Tags

Les cles JSON sont automatiquement converties en tags majuscules:

| Structure JSON | Tag genere | |----------------|------------| | client.nom | {{CLIENT_NOM}} | | client.email | {{CLIENT_EMAIL}} | | adresse.rue | {{ADRESSE_RUE}} | | produit.prix_unitaire | {{PRODUIT_PRIX_UNITAIRE}} | | date_livraison | {{DATE_LIVRAISON}} |

Valeurs booleennes

Les booleens sont automatiquement convertis en checkboxes:

| JSON | Resultat (Unicode) | Resultat (Texte) | |------|-------------------|------------------| | true | ☑ | X | | false | ☐ | (espace) |

Exemple complet

1. Structure de donnees pour Template Mapper

{
  "societe": {
    "nom": "",
    "adresse": "",
    "siret": ""
  },
  "client": {
    "nom": "",
    "prenom": "",
    "email": "",
    "adresse": ""
  },
  "devis": {
    "numero": "",
    "date": "",
    "validite": "",
    "montant_ht": "",
    "tva": "",
    "montant_ttc": ""
  },
  "conditions": {
    "paiement_30j": false,
    "paiement_comptant": false,
    "livraison_incluse": false
  },
  "signature": {
    "lieu": "",
    "date": ""
  }
}

2. Tags generes dans le document

{{SOCIETE_NOM}}, {{SOCIETE_ADRESSE}}, {{SOCIETE_SIRET}}
{{CLIENT_NOM}}, {{CLIENT_PRENOM}}, {{CLIENT_EMAIL}}, {{CLIENT_ADRESSE}}
{{DEVIS_NUMERO}}, {{DEVIS_DATE}}, {{DEVIS_VALIDITE}}
{{DEVIS_MONTANT_HT}}, {{DEVIS_TVA}}, {{DEVIS_MONTANT_TTC}}
{{CONDITIONS_PAIEMENT_30J}}, {{CONDITIONS_PAIEMENT_COMPTANT}}, {{CONDITIONS_LIVRAISON_INCLUSE}}
{{SIGNATURE_LIEU}}, {{SIGNATURE_DATE}}

3. Donnees pour remplir le template

{
  "societe": {
    "nom": "TechCorp SAS",
    "adresse": "45 avenue des Champs, 75008 Paris",
    "siret": "123 456 789 00012"
  },
  "client": {
    "nom": "Martin",
    "prenom": "Jean",
    "email": "[email protected]",
    "adresse": "12 rue de la Paix, 69001 Lyon"
  },
  "devis": {
    "numero": "DEV-2024-0042",
    "date": "30/12/2024",
    "validite": "30 jours",
    "montant_ht": "5 000,00",
    "tva": "1 000,00",
    "montant_ttc": "6 000,00"
  },
  "conditions": {
    "paiement_30j": true,
    "paiement_comptant": false,
    "livraison_incluse": true
  },
  "signature": {
    "lieu": "Paris",
    "date": "30/12/2024"
  }
}

LLM supportes

Template Mapper fonctionne avec tous les LLM de n8n:

• OpenAI (GPT-4, GPT-4o, GPT-3.5)
• Anthropic (Claude 3, Claude 3.5)
• Ollama (Llama, Mistral, Qwen - local et gratuit)
• Azure OpenAI
• Google Gemini
• Mistral AI

Architecture Technique Detaillee

Vue d'ensemble des deux noeuds

┌─────────────────────────────────────────────────────────────────────────────┐
│                           TEMPLATE MAPPER                                    │
│  (Utilise l'IA - Transfer Learning)                                         │
│                                                                              │
│  Document Cible (sans tags) ──┐                                             │
│                               ├──► Segmentation ──► Prompts LLM ──► Tags    │
│  Template Reference (avec tags) ─┘   par section     par segment    inseres │
└─────────────────────────────────────────────────────────────────────────────┘
                                        │
                                        ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│                         DOCX TEMPLATE FILLER                                 │
│  (PAS d'IA - Remplacement direct)                                           │
│                                                                              │
│  Document avec {{TAGS}} ──┐                                                 │
│                           ├──► Flatten JSON ──► Replace Tags ──► Document   │
│  Donnees JSON ────────────┘   CLIENT_NOM       {{TAG}}→valeur     rempli   │
└─────────────────────────────────────────────────────────────────────────────┘

Concept de Segmentation (Decoupage de Session)

Le Template Mapper utilise un systeme de segmentation pour ameliorer la precision du matching IA. Voici comment ca fonctionne:

Probleme sans segmentation

Sans segmentation, le LLM recoit tout le document en une seule fois:

• Prompts trop volumineux: Risque d'erreur HTTP 413 (Request Entity Too Large)
• Confusions entre sections: L'IA peut confondre des sections similaires (ex: plusieurs tableaux)
• Moins de precision: Plus le contexte est grand, moins l'IA est precise

Solution: La segmentation

┌──────────────────────────────────────────────────────────────────────────┐
│                     FLUX DE SEGMENTATION                                  │
├──────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  1. SEGMENTER les documents                                              │
│     Template:  [Section A] [Tableau CA] [Section B] [Signature]          │
│     Cible:     [Section A'] [Tableau CA'] [Section B'] [Signature']      │
│                                                                          │
│  2. MATCHER les segments (template ↔ cible)                              │
│     Section A ←→ Section A' (score: 85%)                                 │
│     Tableau CA ←→ Tableau CA' (score: 92%)                               │
│     etc.                                                                  │
│                                                                          │
│  3. GENERER un prompt CIBLE par paire de segments                        │
│     Prompt segment CA: "Tu as les tags CA_N, CA_N1... dans ce tableau"   │
│     → L'IA ne traite QUE ce segment, pas tout le document                │
│                                                                          │
│  4. COMBINER les resultats de tous les segments                          │
│     Matches totaux = Matches(A) + Matches(CA) + Matches(B) + ...         │
│                                                                          │
└──────────────────────────────────────────────────────────────────────────┘

Modes de segmentation disponibles

| Mode | Comportement | |------|-------------| | auto (defaut) | Active la segmentation si: document > 50KB OU > 10 tags OU tags repartis sur 3+ sections | | always | Force la segmentation. Recommande pour les tableaux financiers (CA) | | never | Desactive la segmentation. Utilise le prompt global |

Code concerne

// Dans TemplateMapper.node.ts ligne 352-356
const useSegmentation = decideSegmentationMode(
  params.useSegmentation,  // 'auto' | 'always' | 'never'
  templateXml,
  extractedTags
);

Approche Few-Shot Learning (v3.0)

Le systeme utilise maintenant une approche Few-Shot Learning pour que l'IA "consomme" vraiment la logique:

┌─────────────────────────────────────────────────────────────────────────────┐
│                    AVANT vs APRES                                            │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│  AVANT (regles abstraites):                                                 │
│  ┌────────────────────────────────────────────────────────────┐             │
│  │ "REGLE 1: Les tags d'identification doivent etre places   │             │
│  │  APRES le label correspondant..."                          │             │
│  │ → L'IA IGNORE souvent ces regles                           │             │
│  └────────────────────────────────────────────────────────────┘             │
│                                                                              │
│  APRES (exemples concrets):                                                 │
│  ┌────────────────────────────────────────────────────────────┐             │
│  │ "### Tag: {{NOM_COMMERCIAL}}                               │             │
│  │  - Contexte template: 'Nom commercial :'                   │             │
│  │  - Candidat cible: idx=15 ('Nom commercial :...')"         │             │
│  │ → L'IA COMPREND par l'exemple                              │             │
│  └────────────────────────────────────────────────────────────┘             │
│                                                                              │
└─────────────────────────────────────────────────────────────────────────────┘

Principe du Few-Shot Learning

1. Montrer, pas expliquer: Chaque tag est presente avec son contexte reel
2. Pre-calcul des candidats: Le systeme trouve les candidats probables AVANT d'appeler l'IA
3. Format JSON strict: L'IA voit le format exact attendu dans le prompt
4. Validation robuste: Parsing multi-strategies avec logs detailles

Fichiers modifies (v3.0)

| Fichier | Changement | |---------|------------| | prompt.service.ts | Nouvelle fonction buildFewShotExamples() | | segment-matcher.service.ts | Prompt Few-Shot par segment | | llm.service.ts | Parsing robuste avec logs detailles |

Pourquoi l'IA peut ne pas "consommer la logique"

Il y a plusieurs raisons pour lesquelles le LLM peut ne pas retourner de matches valides:

1. Le LLM ne retourne aucun match valide

// Dans llm.service.ts ligne 128-139
return parsed.matches.filter((match) => {
  return (
    match.confidence >= 0.7 &&           // ❌ Confiance trop basse
    match.tag &&                          // ❌ Tag absent
    (match.targetParagraphIndex !== undefined || match.targetIdx !== undefined)
  );
});

Cause: L'IA retourne des matches avec confidence < 0.7 → ils sont filtres.

2. Reponse JSON invalide du LLM

// Dans llm.service.ts ligne 149-153
} catch {
  // En cas d'erreur de parsing, retourner une liste vide
  return [];
}

Cause: Le LLM retourne du texte non-JSON ou du JSON mal forme.

3. Fallback automatique vers pattern matching

// Dans TemplateMapper.node.ts ligne 424-435
if (matches.length === 0) {
  console.log('⚠️ LLM n\'a retourne aucun match, fallback vers matching par patterns...');
  matches = patternBasedMatching(tagContexts, targetParagraphs);
  patternFallbackUsed = true;
}

Cause: Si l'IA echoue, le systeme utilise un matching par patterns (regex/similarite textuelle) comme secours.

4. Limites de taille des prompts

// Dans prompt.service.ts lignes 46-48
const MAX_PROMPT_SIZE = 60000;    // 60KB max
const MAX_PARAGRAPHS = 80;        // Max paragraphes envoyes au LLM
const MAX_TAG_CONTEXTS = 40;      // Max contextes de tags

Cause: Si le document depasse ces limites, des informations sont tronquees et l'IA peut manquer des correspondances.

5. Qualite du modele LLM connecte

| Modele | Precision attendue | Recommandation | |--------|-------------------|----------------| | GPT-4, GPT-4o | Haute | Recommande | | Claude 3.5 Sonnet, Opus | Haute | Recommande | | Gemini Pro | Moyenne-Haute | OK | | Mistral Large | Moyenne | OK pour documents simples | | Ollama (local) | Variable | Depend du modele | | GPT-3.5 | Basse | Non recommande |

Flux complet d'execution du Template Mapper

1. Charger les documents
   ├── Document cible (binaire → XML)
   └── Template reference (binaire → XML)

2. Extraire les tags du template
   └── Regex: /\{\{([A-Z][A-Z0-9_]*)\}\}/g

3. Extraire les contextes (labelBefore, section, type)
   └── Pour chaque tag: quel texte le precede?

4. DECISION: Segmentation ou Global?
   ├── Si 'always' ou criteres auto remplis → MODE SEGMENTE
   │   ├── Segmenter template et cible
   │   ├── Matcher les segments
   │   ├── Pour chaque paire:
   │   │   ├── Generer prompt cible
   │   │   ├── Appeler LLM
   │   │   └── Parser reponse
   │   └── Combiner resultats
   │
   └── Sinon → MODE GLOBAL
       ├── Generer prompt unique (tout le document)
       ├── Appeler LLM
       └── Parser reponse

5. FALLBACK si aucun match
   └── patternBasedMatching (regex + similarite)

6. Appliquer les tags au document cible
   ├── Pour chaque match:
   │   ├── Trouver le paragraphe XML
   │   ├── Inserer {{TAG}} selon insertionPoint
   │   └── Valider le XML
   └── Generer le document final

7. Retourner
   ├── Document DOCX tagge (binaire)
   ├── dataStructure (JSON pour DocxTemplateFiller)
   └── Statistiques (tags appliques, echecs)

Points d'insertion des tags (insertionPoint)

| Type | Description | Exemple | |------|-------------|---------| | after_colon | Apres un label finissant par ":" | Nom commercial : → Nom commercial : {{NOM}} | | table_cell | Dans une cellule de tableau | Cellule vide → {{CA_N}} | | replace_empty | Remplace un paragraphe vide | <w:p/> → <w:p>{{TAG}}</w:p> | | inline | Dans le texte existant | Le montant est X → Le montant est {{MONTANT}} | | checkbox | Case a cocher | ☐ → ☑ ou ☐ selon valeur |

Support des Checkboxes

Le systeme detecte et mappe automatiquement les cases a cocher entre le template et le document cible.

Formats supportes

| Format | Detection | Exemple | |--------|-----------|---------| | Unicode | ☑ ☐ □ ✓ ✔ | ☐ Oui ☑ Non | | Word Form Controls | FORMCHECKBOX | Controles de formulaire Word |

Fonctionnement

┌─────────────────────────────────────────────────────────────────────┐
│                 MAPPING DES CHECKBOXES                              │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  TEMPLATE                          CIBLE                            │
│  ┌─────────────────────┐           ┌─────────────────────┐          │
│  │ ☐ Candidat seul     │    →      │ FORMCHECKBOX seul   │          │
│  │ ☑ Groupement        │    →      │ FORMCHECKBOX group. │          │
│  │ ☐ Oui  ☑ Non        │    →      │ FORMCHECKBOX Oui/Non│          │
│  └─────────────────────┘           └─────────────────────┘          │
│                                                                     │
│  Le systeme:                                                        │
│  1. Detecte les checkboxes dans les deux documents                  │
│  2. Extrait leur etat (coche/non coche)                            │
│  3. Trouve les correspondances par similarite semantique            │
│  4. Genere des tags booleens                                        │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Sortie JSON

Les checkboxes sont incluses dans la sortie:

{
  "checkboxes": {
    "templateCount": 7,
    "targetCount": 7,
    "pairsDetected": 1,
    "tags": {
      "LE_CANDIDAT_SE_PRESENTE_SEUL": false,
      "GROUPEMENT_CONJOINT": true,
      "QUESTION_OUI_NON": false
    }
  }
}

Paires Oui/Non

Le systeme detecte automatiquement les paires de checkboxes Oui/Non:

Template:  ☐ Oui  ☑ Non   →   Tag: {{QUESTION}} = false
Template:  ☑ Oui  ☐ Non   →   Tag: {{QUESTION}} = true

Troubleshooting

Les tags ne sont pas remplaces

• Format attendu: {{TAG_NAME}} (double accolades, majuscules, underscores)
• Verifiez que les cles JSON correspondent aux tags du document
• Utilisez le rapport de mapping pour voir les tags restants

Template Mapper n'insere pas tous les tags

• Baissez le seuil de confiance (par defaut: 70)
• Verifiez que les noms de champs sont semantiquement clairs
• Activez "Inclure Details" pour voir les scores de confiance

Document corrompu

• Verifiez que les fichiers source sont des DOCX valides
• N'utilisez pas de fichiers DOC (ancien format)

Caracteres speciaux

• Les caracteres <, >, & sont automatiquement echappes
• Les accents et emojis sont supportes

Node 3: DOCX Direct Filler

Remplit directement un document DOCX vierge (sans tags) en utilisant l'IA avec auto-réflexion (ReAct).

Parfait pour: Formulaires administratifs (DC1, DC2, AE), documents où l'insertion de tags est impossible ou fastidieuse.

Architecture ReAct (comme Claude Code)

┌─────────────────────────────────────────────────────────────────────────────┐
│                    DOCX DIRECT FILLER v6.1 - Auto-réflexion                  │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│  1. ANALYSE - L'IA analyse le document et identifie les champs              │
│     └─ Extraction des paragraphes, tableaux, checkboxes                      │
│                                                                              │
│  2. MAPPING avec RAISONNEMENT - Pour chaque champ:                           │
│     ├─ L'IA raisonne étape par étape (thinking)                              │
│     ├─ Propose une correspondance avec score de confiance                    │
│     └─ Si confiance < 70%, déclenche une vérification                        │
│                                                                              │
│  3. VÉRIFICATION - Auto-correction si doute                                  │
│     ├─ L'IA re-vérifie sa proposition                                        │
│     └─ Si échec → nouvelle tentative (max 3 retries)                         │
│                                                                              │
│  4. INSERTION - Placement déterministe après validation                      │
│     └─ Insertion XML directe (pas d'estimation de position)                  │
│                                                                              │
└─────────────────────────────────────────────────────────────────────────────┘

Configuration

| Paramètre | Description | |-----------|-------------| | Mode | Remplir le document ou Injecter des tags | | Document DOCX | Nom du champ binaire contenant le DOCX | | Données à remplir | JSON avec fields, checkboxes et tables | | LLM (requis) | Modèle IA connecté au port "Model" |

Options

| Option | Description | Défaut | |--------|-------------|--------| | Nom fichier sortie | Nom du DOCX généré | nom_original_filled.docx | | Mode Debug | Logs détaillés avec reasoning | false |

Exemple complet - Formulaire DC2

Données à remplir (fillData)

{
  "fields": {
    "Nom commercial et dénomination sociale": "Rokodo SAS",
    "Adresses postale": "13 rue Camille Desmoulins, 92130 Issy-les-Moulineaux",
    "Adresse électronique": "[email protected]",
    "Numéros de téléphone": "+33 6 89 09 33 41",
    "Numéro SIRET": "123 456 789 00012",
    "Forme juridique": "Société par Actions Simplifiée (SAS)"
  },
  "checkboxes": {
    "Oui": true,
    "Non": false
  },
  "tables": [
    {
      "identifier": "Chiffres d'affaires",
      "cells": [
        {"row": 1, "col": 1, "value": "1 500 000 €"},
        {"row": 1, "col": 2, "value": "1 800 000 €"},
        {"row": 1, "col": 3, "value": "2 100 000 €"}
      ]
    }
  ]
}

Structure des données

| Section | Clé | Description | |---------|-----|-------------| | fields | Label du document → Valeur | Champs texte. L'IA trouve le paragraphe correspondant | | checkboxes | Label → true/false | Cases à cocher. Cherche le texte près de la checkbox | | tables | identifier + cells | Tableaux. identifier = texte pour trouver le tableau |

Résultat du test (DC2.docx)

📊 RÉSULTATS
   Success: ✅
   Fields inserted: 5
   Checkboxes checked: 1
   LLM calls: 5
   Retries: 0
   Duration: 21.60s

📋 Mappings:
   - Nom commercial et dénomination sociale → P46 (confidence: 95%)
   - Adresse électronique → P52 (confidence: 95%)
   - Numéros de téléphone → P55 (confidence: 95%)
   - Numéro SIRET → P58 (confidence: 95%)
   - Forme juridique → P61 (confidence: 90%)

Sortie JSON

{
  "success": true,
  "mode": "fill",
  "stats": {
    "fieldsInserted": 5,
    "checkboxesChecked": 1,
    "tableCellsFilled": 0,
    "llmCalls": 5,
    "duration": 21.60,
    "retries": 0
  },
  "mappings": [
    {
      "field": "Nom commercial et dénomination sociale",
      "value": "Rokodo SAS",
      "paragraphIndex": 46,
      "insertType": "inline",
      "confidence": 0.95,
      "verified": true
    }
  ],
  "reasoning": [
    "🚀 Démarrage du remplissage intelligent avec auto-réflexion",
    "📄 Document analysé: 334 paragraphes, 12 tableaux",
    "📝 Traitement de 5 champs texte...",
    "✅ \"Nom commercial\" → P46 (confiance: 95%)",
    "✅ \"Adresse électronique\" → P52 (confiance: 95%)"
  ]
}

Mode Injection de Tags

Ce mode permet de créer un template réutilisable en injectant des tags {{PLACEHOLDER}}.

Tags à injecter (tagData)

{
  "fields": {
    "Nom commercial et dénomination sociale": "{{NOM_COMMERCIAL}}",
    "Adresse électronique": "{{EMAIL}}",
    "Numéro SIRET": "{{SIRET}}"
  },
  "checkboxes": {
    "Oui": "{{PME_OUI}}",
    "Non": "{{PME_NON}}"
  }
}

Le document généré contiendra des tags {{TAG}} que vous pourrez remplir avec le DOCX Template Filler.

Différences avec Template Mapper + Filler

| Aspect | Template Mapper + Filler | DOCX Direct Filler | |--------|--------------------------|---------------------| | Étapes | 2 (création template + remplissage) | 1 (remplissage direct) | | Réutilisabilité | Template réutilisable | Chaque doc est traité individuellement | | Appels LLM | 1 par template | 1-3 par champ | | Précision | ~95% (tags explicites) | ~98% (vérification IA) | | Meilleur pour | Documents standardisés, volume élevé | Documents uniques, formulaires complexes |

Node 4: PDF Template Mapper

Analyse un PDF et remplit automatiquement les champs détectés en utilisant l'IA (ReAct Agent).

Parfait pour: Formulaires administratifs (DC1, DC2), CERFA, documents PDF avec zones de saisie.

Configuration

| Paramètre | Description | |-----------|-------------| | Document PDF | Nom du champ binaire contenant le PDF | | Page à analyser | Numéro de la page où placer les données | | Données à remplir | JSON avec les valeurs à insérer | | Configuration des champs | JSON optionnel pour définir la détection des champs | | LLM (requis) | Modèle IA connecté au port "Model" |

Options

| Option | Description | Défaut | |--------|-------------|--------| | Nom fichier sortie | Nom du PDF généré | nom_original_filled.pdf | | Taille de police | Taille du texte inséré (pts) | 9 | | Mode Debug | Logs détaillés | false |

Structure des Données - PDF Template Mapper

1. Données à remplir (fillData)

Le JSON contient les valeurs à insérer dans le PDF.

{
  "NOM_COMMERCIAL": "Rokodo.io",
  "ADRESSE": "13 rue Camille Desmoulins 92130 Issy les Moulineaux",
  "EMAIL": "[email protected]",
  "TELEPHONE": "+33 (0) 6 89 09 33 41",
  "SIRET": "123 456 789 00012",
  "CANDIDAT_SEUL": true
}

Types de valeurs supportés

| Type | Format | Exemple | Comportement | |------|--------|---------|--------------| | Texte | "string" | "Ma Société" | Texte inséré à la position détectée | | Checkbox | true ou false | true | Coche/décoche la case correspondante |

Règles importantes

1. Texte vide = champ ignoré ("NOM": "" → pas de remplissage)
2. Checkbox false = case non cochée (mais pas modifiée)
3. Checkbox true = case cochée (nécessite fieldConfig pour détecter le label)

2. Configuration des champs (fieldConfig)

Définit COMMENT détecter chaque champ dans le PDF.

{
  "NOM_DU_CHAMP": {
    "labels": ["Texte à chercher dans le PDF", "Variante du texte"],
    "type": "inline | multiline | checkbox",
    "minGap": 15
  }
}

Propriétés

| Propriété | Obligatoire | Description | |-----------|-------------|-------------| | labels | ✓ | Liste de textes à chercher dans le PDF pour localiser le champ | | type | ✓ | Type de placement (voir ci-dessous) | | minGap | ✗ | Gap minimum en points pour les champs multiline (défaut: 0) |

Types de champs

| Type | Utilisation | Placement | |------|-------------|-----------| | inline | Email, téléphone | Après le ":" sur la même ligne que le label | | multiline | Nom, adresse, SIRET | Dans un espace vide sous le label | | checkbox | Cases à cocher | Sur la case à cocher associée au label |

3. Champs prédéfinis (configuration par défaut)

Ces champs fonctionnent sans fieldConfig :

| Nom du champ | Labels recherchés | Type | |--------------|-------------------|------| | NOM_COMMERCIAL | "Nom commercial et dénomination", "Nom commercial" | multiline | | ADRESSE | "Adresses postale", "Adressespostale", "Adresse postale" | multiline | | EMAIL | "Adresse électronique" | inline | | TELEPHONE | "Numéros de téléphone", "Numéro de téléphone" | inline | | SIRET | "Numéro SIRET" | multiline |

Exemple sans fieldConfig (champs prédéfinis)

// Données à remplir - suffisant pour les champs prédéfinis
{
  "NOM_COMMERCIAL": "Rokodo.io",
  "EMAIL": "[email protected]",
  "SIRET": "123 456 789 00012"
}

// Configuration des champs - laisser vide {}
{}

4. Quand utiliser fieldConfig ?

CAS 1: Checkbox → OBLIGATOIRE

Les checkboxes ne sont PAS dans la config par défaut.

// Données à remplir
{
  "CANDIDAT_SEUL": true,
  "GROUPEMENT": false
}

// Configuration des champs - OBLIGATOIRE pour les checkbox
{
  "CANDIDAT_SEUL": {
    "labels": ["Le candidat se présente seul"],
    "type": "checkbox"
  },
  "GROUPEMENT": {
    "labels": ["Groupement conjoint", "Membre d'un groupement"],
    "type": "checkbox"
  }
}

CAS 2: Champ personnalisé → OBLIGATOIRE

Pour un champ qui n'est pas prédéfini.

// Données à remplir
{
  "CODE_APE": "6201Z",
  "CAPITAL_SOCIAL": "50 000 €"
}

// Configuration des champs - OBLIGATOIRE pour les champs personnalisés
{
  "CODE_APE": {
    "labels": ["Code APE", "Code NAF"],
    "type": "inline"
  },
  "CAPITAL_SOCIAL": {
    "labels": ["Capital social"],
    "type": "multiline",
    "minGap": 20
  }
}

CAS 3: Surcharger un champ prédéfini → OPTIONNEL

Pour utiliser un label différent de celui par défaut.

// Configuration - surcharge le label EMAIL
{
  "EMAIL": {
    "labels": ["Courriel", "Mail professionnel"],
    "type": "inline"
  }
}

5. Exemple complet DC1/DC2

Données à remplir (fillData)

{
  "NOM_COMMERCIAL": "Rokodo.io",
  "ADRESSE": "13 rue Camille Desmoulins 92130 Issy les Moulineaux",
  "EMAIL": "[email protected]",
  "TELEPHONE": "+33 (0) 6 89 09 33 41",
  "SIRET": "123 456 789 00012",
  "CANDIDAT_SEUL": true,
  "GROUPEMENT_CONJOINT": false,
  "PME": true
}

Configuration des champs (fieldConfig)

{
  "CANDIDAT_SEUL": {
    "labels": ["Le candidat se présente seul", "candidat individuel seul"],
    "type": "checkbox"
  },
  "GROUPEMENT_CONJOINT": {
    "labels": ["Groupement conjoint", "membre d'un groupement conjoint"],
    "type": "checkbox"
  },
  "PME": {
    "labels": ["petite ou une moyenne entreprise", "PME"],
    "type": "checkbox"
  }
}

Note: Les champs texte (NOM_COMMERCIAL, ADRESSE, etc.) utilisent la config par défaut. Seules les checkboxes nécessitent une configuration explicite.

6. Résumé - Quand configurer quoi ?

| Situation | fillData | fieldConfig | |-----------|------------|---------------| | Champ texte prédéfini (EMAIL, SIRET...) | Valeur string | {} (vide) | | Champ texte personnalisé | Valeur string | Obligatoire avec labels et type | | Checkbox | true ou false | Obligatoire avec labels et "type": "checkbox" | | Surcharger label par défaut | Valeur string | Optionnel |

7. Erreurs courantes

| Erreur | Cause | Solution | |--------|-------|----------| | Checkbox non cochée | fieldConfig absent | Ajouter la config avec "type": "checkbox" | | Texte mal positionné | Mauvais label dans config | Vérifier le texte exact dans le PDF | | Champ non trouvé | Label pas dans le PDF | Ajuster les labels ou vérifier la page | | Collision de texte | Position déjà occupée | L'agent corrige automatiquement |

8. Sortie du node

{
  "success": true,
  "mode": "react_agent_llm",
  "iterations": 2,
  "satisfaction": 100,
  "placements": [
    { "field": "NOM_COMMERCIAL", "value": "Rokodo.io", "type": "text", "page": 2, "x": 71, "y": 588 },
    { "field": "EMAIL", "value": "minhtuan.nguyen@roko...", "type": "text", "page": 2, "x": 187, "y": 533 }
  ],
  "checkboxes": [
    { "field": "CANDIDAT_SEUL", "checked": true, "type": "checkbox" }
  ],
  "stats": {
    "fieldsRequested": 6,
    "textFieldsPlaced": 5,
    "checkboxesPlaced": 1,
    "autoCorrections": 0
  }
}

Licence

MIT - Rokodo.io