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": "marie@example.com",
    "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": "jean.martin@email.com",
    "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": "contact@rokodo.io",
    "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": "minhtuan.nguyen@rokodo.io",
  "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": "contact@rokodo.io",
  "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": "minhtuan.nguyen@rokodo.io",
  "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