Tutoriel LLMSTXT : encadrer l’usage de vos contenus par les IA

Tutoriel pratique destiné à toutes les organisations et propriétaires de sites (PME, e-commerce, médias, ONG, collectivités, institutions, blogueurs, éditeurs). Il explique ce qu’est llmstxt, le fichier texte qui encadre l’usage de vos contenus par les systèmes d’IA (entraînement, résumé, dérivés, rétention, attribution). Vous verrez pourquoi l’adopter, comment l’écrire, le générer automatiquement, l’héberger, le tester et le compléter avec robots.txt, balises meta et en-têtes HTTP. Le guide propose des modèles prêts à l’emploi (opt-out, non-commercial, granularité par dossier/agent), une table des directives courantes, des exemples Nginx/Apache et un plan pour décliner votre politique selon la GEO (pays/langues). Si nécessaire, un accompagnement ciblé peut aider à cadrer rapidement la stratégie — par exemple Lumineth peut vous assister sur l’adaptation GEO et la cohérence avec vos mentions légales, sans vous rendre dépendant d’un prestataire.

Introduction

En 2025, de plus en plus d’outils d’IA explorent et indexent le web pour résumer des pages, alimenter des moteurs de réponse, entraîner des modèles ou générer des fiches produits. Beaucoup d’éditeurs souhaitent clarifier leurs préférences : “OK pour le résumé et l’indexation, non pour l’entraînement commercial”, “OK pour des extraits avec attribution”, “pas de rétention au-delà de 7 jours”, etc. Le fichier llmstxt fournit un moyen simple et lisible par machine d’exprimer ces préférences à la racine de votre site.

llmstxt n’est pas un verrou légal : c’est une convention technique, comparable à robots.txt, qui gagne en force avec l’adoption par les acteurs sérieux. Bien configuré et documenté, il réduit les ambiguïtés, facilite les échanges avec les fournisseurs d’IA et sert de base en cas de litige (“nos préférences étaient publiées à telle date”).

1) LLMSTXT en deux mots : principe, portée, limites

Principe : héberger un fichier texte UTF-8 (ex. https://votre-domaine/llmstxt) listant vos préférences d’usage par des “agents IA” (crawlers, clients d’API, indexeurs) : entraînement, extraction/résumé, création de dérivés, rétention de données, attribution, licence, etc. On peut cibler tous les agents (*) ou un agent nommé.

Portée : llmstxt complète robots.txt. Robots contrôle l’accès/crawl ; llmstxt décrit l’usage autorisé des contenus consultés. Les deux se combinent utilement.

Limites : des acteurs peuvent l’ignorer. Son intérêt tient à la clarté, à la traçabilité et à l’adoption de plus en plus large dans l’écosystème.

2) Pourquoi l’adopter (et pour qui)

llmstxt est utile si vous :

• publiez des contenus à valeur (articles, tutoriels, photos, catalogues, fiches techniques, docs d’aide) ;
• souhaitez autoriser certains usages (résumé, recherche) tout en refusant d’autres (entraînement commercial, dérivés sans attribution) ;
• avez des contraintes GEO (UE/hors UE, pays différenciés) ou par type de contenu (texte oui, images non) ;
• voulez un point de contact clair pour les acteurs IA et une politique de rétention cadrée.

Bénéfices : moins d’ambiguïté, réduction des frictions juridiques, signal de sérieux pour vos utilisateurs et partenaires.

3) Anatomie d’un llmstxt (directives fréquentes)

La syntaxe reste lisible (paires clé: valeur, sections User-agent). Voici les directives courantes :

Les noms peuvent légèrement varier selon les implémentations. L’important : rester explicite, stable, et documenter votre choix dans vos Conditions d’utilisation.

4) Modèles prêts à l’emploi

Adaptez les e-mails, URL et chemins à votre contexte. Copiez-collez puis personnalisez.

4.1 Opt-out maximal (aucun entraînement, usage minimal)

    Copier le code
    
# llmstxt — Opt-out maximal
User-agent: *
Disallow: /
Training: disallow
Summarization: disallow
Derivatives: disallow
Retention: 0
Attribution: require
Policy: https://exemple.fr/conditions
Contact: legal@exemple.fr
Sitemaps: https://exemple.fr/sitemap.xml
    
  

4.2 Autoriser résumé/recherche, refuser l’entraînement commercial

    Copier le code
    
# llmstxt — Usage éditorial OK, pas d'entraînement commercial
User-agent: *
Allow: /
Training: non-commercial-only
Summarization: allow
Derivatives: allow-with-attribution
Retention: 7d
Attribution: require
License: CC BY-NC 4.0
Policy: https://exemple.fr/conditions
Contact: ai@exemple.fr
    
  

4.3 Politique par type de contenu (texte OK, images non)

    Copier le code
    
# llmstxt — Texte autorisé (résumé/indexation), images interdites
User-agent: *
Allow: /articles/
Disallow: /media_lumineth/images_lumineth/
Training: disallow
Summarization: allow
Derivatives: allow-with-attribution
Retention: 14d
Attribution: require
Policy: https://exemple.fr/conditions
Contact: legal@exemple.fr
    
  

4.4 Ciblage par agent (autoriser un partenaire, bloquer le reste)

    Copier le code
    
# llmstxt — Politique par User-agent
User-agent: PartnerAI
Allow: /
Training: allow
Summarization: allow
Derivatives: allow-with-attribution
Retention: 30d
Attribution: require
Policy: https://exemple.fr/conditions
Contact: partner@exemple.fr
User-agent: *
Training: disallow
Summarization: allow
Derivatives: non-commercial
Retention: 7d
Attribution: require
    
  

5) Générer automatiquement votre llmstxt

Deux options rapides : un script shell minimal et une génération Python intégrable en CI/CD.

5.1 Script bash minimal

    Copier le code
    
#!/usr/bin/env bash
DOMAIN="exemple.fr"
CONTACT="legal@exemple.fr"
POLICY="https://exemple.fr/conditions"
cat > llmstxt <<EOF
# llmstxt généré le $(date -u +"%Y-%m-%dT%H:%M:%SZ")
User-agent: *
Allow: /
Training: non-commercial-only
Summarization: allow
Derivatives: allow-with-attribution
Retention: 14d
Attribution: require
Policy: $POLICY
Contact: $CONTACT
Sitemaps: https://$DOMAIN/sitemap.xml
EOF
echo "Fichier llmstxt généré."
    
  

5.2 Générateur Python (CI/CD)

    Copier le code
    
from datetime import datetime, timezone
CONFIG = {
  "user_agent": "*",
  "training": "non-commercial-only",
  "summarization": "allow",
  "derivatives": "allow-with-attribution",
  "retention": "14d",
  "attribution": "require",
  "policy": "https://exemple.fr/conditions",
  "contact": "legal@exemple.fr",
  "sitemaps": ["https://exemple.fr/sitemap.xml"]
}
def render_llmstxt(cfg: dict) -> str:
    ts = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
    lines = [f"# llmstxt généré le {ts}",
             f"User-agent: {cfg['user_agent']}"]
    lines += [
        f"Training: {cfg['training']}",
        f"Summarization: {cfg['summarization']}",
        f"Derivatives: {cfg['derivatives']}",
        f"Retention: {cfg['retention']}",
        f"Attribution: {cfg['attribution']}",
        f"Policy: {cfg['policy']}",
        f"Contact: {cfg['contact']}",
    ]
    if cfg.get("sitemaps"):
        lines.append("Sitemaps: " + ", ".join(cfg["sitemaps"]))
    return "\n".join(lines) + "\n"
open("llmstxt", "w", encoding="utf-8").write(render_llmstxt(CONFIG))
print("llmstxt écrit.")
    
  

Ajoutez ces scripts à votre dépôt (ex. répertoire /ops) et déclenchez la génération à chaque évolution de politique/licence via votre pipeline.

6) Où héberger & comment servir le fichier

Emplacements recommandés :

• https://votre-domaine/llmstxt (racine du site) ;
• facultatif : variante sous /.well-known/ (selon vos conventions internes).

Servez-le avec Content-Type: text/plain; charset=utf-8 et un cache raisonnable (ex. 24 h).

6.1 Nginx

    Copier le code
    
location = /llmstxt {
  default_type text/plain; charset=utf-8;
  add_header Cache-Control "public, max-age=86400";
  try_files /llmstxt =404;
}
    
  

6.2 Apache (.htaccess)

    Copier le code
    
<Files "llmstxt">
  ForceType text/plain; charset=utf-8
  Header set Cache-Control "public, max-age=86400"
</Files>
    
  

Test express :

    Copier le code
    
curl -I https://votre-domaine/llmstxt
# Attendu : HTTP/200 et Content-Type: text/plain; charset=utf-8
    
  

7) Compléter llmstxt avec robots.txt, meta et en-têtes

Combinez plusieurs signaux cohérents :

7.1 Extraits robots.txt (agents d’entraînement connus)

    Copier le code
    
# robots.txt — exemples
User-agent: GPTBot
Disallow: /
User-agent: Google-Extended
Disallow: /
User-agent: CCBot
Disallow: /
User-agent: *
Allow: /
    
  

7.2 Balises meta et en-têtes HTTP

    Copier le code
    
<!-- Dans <head> : signaux côté document (prise en charge variable) -->
<meta name="robots" content="noai, noimageai">
    
  

    Copier le code
    
# Apache — en-tête global
Header set X-Robots-Tag "noai, noimageai"
    
  

L’objectif n’est pas la “parfaite” couverture, mais un ensemble cohérent et documenté : robots.txt (accès), llmstxt (usage), meta/headers (préférences au niveau page).

8) GEO, langues et multi-domaines : décliner sans complexifier

Selon vos marchés, vous pouvez vouloir différencier la politique par pays ou langue. Trois options :

1. Politique unique (recommandée) pour tous les pays : simple et robuste.
2. Une politique par domaine (ex. exemple.fr vs example.com) : publiez un llmstxt propre à chaque TLD.
3. Réponse dynamique selon la région (GeoIP/CDN) : puissant mais délicat (les crawlers utilisent des IP variées). À documenter clairement.

Exemple d’esquisse Nginx (à adapter avec un module GeoIP réel) :

    Copier le code
    
# PSEUDO-CONFIG GEO — à remplacer par votre module GeoIP
map $geoip2_country_code $is_eu {
  default 0;
  FR 1; BE 1; CH 0; DE 1; IT 1; ES 1;
}
location = /llmstxt {
  default_type text/plain; charset=utf-8;
  if ($is_eu) {
    return 200 "User-agent: *\n"
               "Training: disallow\n"
               "Summarization: allow\n"
               "Policy: https://exemple.fr/conditions\n";
  }
  return 200 "User-agent: *\n"
             "Training: non-commercial-only\n"
             "Summarization: allow\n"
             "Policy: https://example.com/terms\n";
}
    
  

Si vous avez besoin d’une stratégie GEO réaliste (par domaines/langues) et d’un alignement avec vos mentions légales/consentement, un accompagnement ciblé peut vous faire gagner du temps. À titre d’exemple, Lumineth peut vous aider à concevoir cette politique, la documenter et la déployer, puis vous laisser autonomes.

9) Tests, monitoring et preuve

Vérifiez l’accessibilité du fichier et conservez des traces :

• Tester en HTTP : curl -I → statut 200 + bon content-type.
• Surveiller depuis plusieurs régions (uptime).
• Journaliser les accès à /llmstxt pour identifier les agents.
• Versionner chaque évolution (Git), horodatée en UTC.

    Copier le code
    
# Journal Nginx dédié à /llmstxt
log_format llm '$remote_addr - $time_local "$request" $status "$http_user_agent"';
map $request_uri $llm_log { default 0; /llmstxt 1; }
access_log /var/log/nginx/llm_access.log llm if=$llm_log;
    
  

10) Gouvernance : qui décide, qui met à jour

llmstxt touche à l’édito et au juridique. Pour que ça tienne dans le temps :

• Responsable désigné (ex. produit, juridique, communication).
• Revue périodique (tous les 6–12 mois ou changement de politique/licence).
• Journal des changements (en pied de fichier et dans Git).
• Cohérence avec Conditions d’utilisation, bannières consentement, robots.txt.

    Copier le code
    
# Journal (exemple)
# 2025-08-26T13:00:00Z — Ajout Derivatives: allow-with-attribution
# 2025-07-10T09:30:00Z — Training: disallow — décision éditoriale
    
  

Les points à retenir

Conclusion

Publier un llmstxt ne vous protège pas de tout, mais clarifie votre position et facilite le dialogue avec l’écosystème IA. C’est une brique simple, peu coûteuse, et compatible avec vos dispositifs existants (robots.txt, meta/headers, mentions légales). Démarrez avec un modèle, placez-le à la racine, testez son accessibilité, puis installez une routine de mise à jour. Si votre activité couvre plusieurs pays/langues, une stratégie GEO bien pensée vous évitera les pièges — et pourra être mise en place rapidement avec un accompagnement ciblé.

Annexe

Checklist express d’implémentation :

• Choisir la politique initiale (opt-out, non-commercial, granularité).
• Rédiger la première version (modèle adapté à votre cas).
• Publier à la racine, servir en text/plain, cache 24 h.
• Aligner robots.txt, meta/headers et Conditions d’utilisation.
• Activer un log d’accès à /llmstxt et le versionning Git.
• Programmer une revue trimestrielle ; consigner les changements en UTC.

Ressources Complémentaires

• llmstxt.org — spécification et exemples
• Introduction à robots.txt (Google)
• web.dev — bonnes pratiques de performance
• WAVE — évaluation d’accessibilité
• Articles et tutoriels Lumineth (SEO, accessibilité, GEO)