kalo-cli 0.1.0

package/generators/ai-enhancer/keywords.json

@@ -0,0 +1,1158 @@
+[
+  {
+    "terms": [
+      "modèle",
+      "model",
+      "classe",
+      "entité",
+      "objet métier",
+      "table"
+    ],
+    "instruction": "INTENT DETECTED: MODEL DEFINITION. Créer ou modifier un modèle Django. Définir la classe, l'héritage (models.Model ou Page), les Meta options et __str__.",
+    "example_output": "class Article(models.Model):\n    title = models.CharField(max_length=200)\n    class Meta:\n        verbose_name = 'Article'\n    def __str__(self):\n        return self.title",
+    "documentation": "Un modèle est la source unique et définitive d'informations sur vos données. Il contient les champs et les comportements essentiels des données que vous stockez. Généralement, chaque modèle correspond à une seule table de base de données.",
+    "documentation_officielle": "Un modèle est la source unique et définitive d'informations sur vos données. Il contient les champs et les comportements essentiels des données que vous stockez. Généralement, chaque modèle correspond à une seule table de base de données."
+  },
+  {
+    "terms": [
+      "data",
+      "field",
+      "champ",
+      "donnée",
+      "attribut",
+      "colonne",
+      "propriété"
+    ],
+    "instruction": "INTENT DETECTED: FIELD. Identifier le modèle cible, définir le type de champ Django approprié (CharField, TextField, IntegerField, etc.), gérer null/blank/default/validators.",
+    "example_output": "subtitle = models.CharField(max_length=255, blank=True, null=True, help_text='Sous-titre optionnel')",
+    "documentation": "Les champs définissent le type de données stockées dans une colonne de la base de données. Chaque champ est une instance d'une classe Field appropriée (CharField, IntegerField, etc.) qui détermine le type de colonne, la validation et le widget par défaut.",
+    "documentation_officielle": "La partie la plus importante d'un modèle – et la seule obligatoire – est la liste des champs de base de données qu'il définit. Les champs sont spécifiés par des attributs de classe."
+  },
+  {
+    "terms": [
+      "clé primaire",
+      "pk",
+      "id",
+      "identifiant unique",
+      "primary key"
+    ],
+    "instruction": "INTENT DETECTED: PRIMARY KEY. Définir explicitement une clé primaire personnalisée ou utiliser AutoField/UUIDField.",
+    "example_output": "id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)",
+    "documentation": "Une clé primaire est un champ unique identifiant chaque enregistrement dans une table. Par défaut, Django ajoute un champ `id` auto-incrémenté, mais vous pouvez définir votre propre clé primaire en définissant `primary_key=True` sur un champ.",
+    "documentation_officielle": "Par défaut, Django donne à chaque modèle une clé primaire auto-incrémentée : id = models.AutoField(primary_key=True). Si vous souhaitez spécifier une clé primaire personnalisée, spécifiez primary_key=True sur l'un de vos champs."
+  },
+  {
+    "terms": [
+      "index",
+      "indexation",
+      "performance recherche",
+      "db_index"
+    ],
+    "instruction": "INTENT DETECTED: INDEX. Ajouter des index pour optimiser les requêtes. Utiliser db_index=True ou Meta.indexes.",
+    "example_output": "class Meta:\n    indexes = [models.Index(fields=['slug', '-created_at'])]",
+    "documentation": "Les index de base de données accélèrent les opérations de recherche. Django permet de définir des index via l'option `indexes` dans la classe `Meta` du modèle ou avec `db_index=True` sur un champ.",
+    "documentation_officielle": "L'option Meta.indexes permet de définir une liste d'index que vous souhaitez créer sur le modèle."
+  },
+  {
+    "terms": [
+      "contrainte",
+      "constraint",
+      "unicité",
+      "unique",
+      "check"
+    ],
+    "instruction": "INTENT DETECTED: CONSTRAINT. Ajouter des contraintes de base de données via Meta.constraints.",
+    "example_output": "class Meta:\n    constraints = [models.UniqueConstraint(fields=['user', 'product'], name='unique_user_product')]",
+    "documentation": "Les contraintes permettent d'imposer des règles au niveau de la base de données, comme l'unicité composite ou des vérifications de conditions (CheckConstraint). Elles sont définies dans la classe `Meta`.",
+    "documentation_officielle": "L'option Meta.constraints permet de définir une liste de contraintes que vous souhaitez définir sur le modèle."
+  },
+  {
+    "terms": [
+      "abstract",
+      "abstrait",
+      "héritage",
+      "base class"
+    ],
+    "instruction": "INTENT DETECTED: ABSTRACT MODEL. Créer un modèle abstrait pour factoriser des champs communs sans créer de table.",
+    "example_output": "class TimestampedModel(models.Model):\n    created_at = models.DateTimeField(auto_now_add=True)\n    class Meta:\n        abstract = True",
+    "documentation": "Les modèles abstraits sont des classes de base qui ne créent pas de table en base de données. Ils servent à factoriser des champs et méthodes communs pour d'autres modèles qui en héritent.",
+    "documentation_officielle": "Les modèles abstraits sont des classes de base dans lesquelles vous définissez des champs que vous souhaitez inclure dans de nombreux modèles enfants. Django ne crée pas de table de base de données pour les modèles abstraits."
+  },
+  {
+    "terms": [
+      "proxy",
+      "modèle proxy",
+      "comportement alternatif"
+    ],
+    "instruction": "INTENT DETECTED: PROXY MODEL. Créer un modèle proxy pour modifier le comportement sans nouvelle table.",
+    "example_output": "class PublishedArticle(Article):\n    class Meta:\n        proxy = True\n        ordering = ['-published_date']",
+    "documentation": "Les modèles proxy permettent de modifier le comportement d'un modèle (méthodes, manager par défaut, méta-options) sans changer le schéma de base de données.",
+    "documentation_officielle": "Les modèles proxy sont utilisés pour modifier le comportement d'un modèle (par exemple, pour inclure des méthodes supplémentaires ou modifier le gestionnaire par défaut) sans changer le schéma de base de données."
+  },
+  {
+    "terms": [
+      "page",
+      "type de page",
+      "nouvelle page",
+      "template",
+      "contenu",
+      "page wagtail"
+    ],
+    "instruction": "INTENT DETECTED: PAGE TYPE. Créer ou modifier une Page Wagtail. Définir l'héritage de Page, le template, les champs, les panels, parent_page_types et subpage_types.",
+    "example_output": "class BlogPage(Page):\n    template = 'blog/blog_page.html'\n    parent_page_types = ['BlogIndexPage']\n    subpage_types = []\n    intro = models.TextField(blank=True)\n    content_panels = Page.content_panels + [FieldPanel('intro')]",
+    "documentation": "Dans Wagtail, les pages sont définies comme des modèles Django héritant de `Page`. Chaque type de page définit ses propres champs et templates, et s'intègre dans l'arborescence de contenu.",
+    "documentation_officielle": "La classe Page est le type de base pour tout contenu qui a une URL dans votre site Wagtail. Les modèles de page sont définis comme des modèles Django standard héritant de wagtail.models.Page."
+  },
+  {
+    "terms": [
+      "page index",
+      "listing",
+      "liste",
+      "index page"
+    ],
+    "instruction": "INTENT DETECTED: INDEX PAGE. Créer une page d'index qui liste des sous-pages. Surcharger get_context pour passer les enfants.",
+    "example_output": "class BlogIndexPage(Page):\n    def get_context(self, request):\n        context = super().get_context(request)\n        context['posts'] = BlogPage.objects.child_of(self).live()\n        return context",
+    "documentation": "Une page d'index (ou listing) est utilisée pour lister d'autres pages (généralement ses enfants). Elle utilise souvent `get_context` pour récupérer et passer les sous-pages au template.",
+    "documentation_officielle": "L'option Meta.indexes permet de définir une liste d'index que vous souhaitez créer sur le modèle."
+  },
+  {
+    "terms": [
+      "routable",
+      "routes multiples",
+      "sous-urls",
+      "routablepagem"
+    ],
+    "instruction": "INTENT DETECTED: ROUTABLE PAGE. Utiliser RoutablePageMixin pour définir plusieurs URLs sous une même page.",
+    "example_output": "from wagtail.contrib.routable_page.models import RoutablePageMixin, route\n\nclass BlogIndexPage(RoutablePageMixin, Page):\n    @route(r'^tag/(?P<tag>[-\\w]+)/$')\n    def tag(self, request, tag):\n        posts = self.get_posts().filter(tags__slug=tag)\n        return self.render(request, context={'posts': posts})",
+    "documentation": "Le `RoutablePageMixin` permet à une page d'intégrer son propre système d'URL, permettant de créer des sous-vues (comme /année/mois/) au sein d'une même page Wagtail sans polluer l'arbre des pages.",
+    "documentation_officielle": "Le RoutablePageMixin permet à une page d'intégrer des vues Django standard, permettant à une page de répondre à plusieurs URL sous son URL principale."
+  },
+  {
+    "terms": [
+      "texte",
+      "text",
+      "string",
+      "chaîne",
+      "varchar"
+    ],
+    "instruction": "INTENT DETECTED: TEXT FIELD. Utiliser CharField pour texte court ou TextField pour texte long.",
+    "example_output": "title = models.CharField(max_length=200)\ndescription = models.TextField()",
+    "documentation": "`CharField` est pour les chaînes courtes de taille fixe (nécessite `max_length`), tandis que `TextField` est pour les grands blocs de texte sans limite de taille stricte.",
+    "documentation_officielle": "CharField est un champ de chaîne de caractères, pour les chaînes de petite à grande taille. Pour de grandes quantités de texte, utilisez TextField."
+  },
+  {
+    "terms": [
+      "nombre",
+      "integer",
+      "entier",
+      "décimal",
+      "float",
+      "numérique"
+    ],
+    "instruction": "INTENT DETECTED: NUMERIC FIELD. Choisir IntegerField, DecimalField, FloatField selon le besoin.",
+    "example_output": "price = models.DecimalField(max_digits=10, decimal_places=2)\nquantity = models.IntegerField(default=0)",
+    "documentation": "`IntegerField` pour les entiers, `DecimalField` pour les nombres décimaux précis (monétaire), et `FloatField` pour les nombres à virgule flottante.",
+    "documentation_officielle": "IntegerField est un entier. DecimalField est un nombre décimal à virgule fixe, représenté en Python par une instance de Decimal. FloatField est un nombre à virgule flottante."
+  },
+  {
+    "terms": [
+      "boolean",
+      "booléen",
+      "true/false",
+      "oui/non",
+      "checkbox"
+    ],
+    "instruction": "INTENT DETECTED: BOOLEAN FIELD. Utiliser BooleanField avec default approprié.",
+    "example_output": "is_published = models.BooleanField(default=False)",
+    "documentation": "`BooleanField` stocke des valeurs vrai/faux. Utilisez `NullBooleanField` (obsolète, maintenant `BooleanField(null=True)`) si la valeur peut être inconnue.",
+    "documentation_officielle": "Un champ vrai/faux. Le widget de formulaire par défaut est une case à cocher (CheckboxInput)."
+  },
+  {
+    "terms": [
+      "date",
+      "datetime",
+      "heure",
+      "timestamp",
+      "temps"
+    ],
+    "instruction": "INTENT DETECTED: DATE/TIME FIELD. Utiliser DateField, DateTimeField ou TimeField avec auto_now/auto_now_add si nécessaire.",
+    "example_output": "published_date = models.DateField()\ncreated_at = models.DateTimeField(auto_now_add=True)\nupdated_at = models.DateTimeField(auto_now=True)",
+    "documentation": "`DateField` pour une date, `DateTimeField` pour date et heure. `auto_now_add` définit la date à la création, `auto_now` à chaque modification.",
+    "documentation_officielle": "DateField est une date, représentée en Python par une instance de datetime.date. DateTimeField est une date et une heure, représentée par datetime.datetime."
+  },
+  {
+    "terms": [
+      "email",
+      "courriel",
+      "adresse email"
+    ],
+    "instruction": "INTENT DETECTED: EMAIL FIELD. Utiliser EmailField avec validation intégrée.",
+    "example_output": "email = models.EmailField(unique=True)",
+    "documentation": "`EmailField` est un CharField qui vérifie que la valeur est une adresse email valide grâce à un validateur intégré.",
+    "documentation_officielle": "Un CharField qui vérifie que la valeur est une adresse email valide en utilisant EmailValidator."
+  },
+  {
+    "terms": [
+      "url",
+      "lien",
+      "website",
+      "site web"
+    ],
+    "instruction": "INTENT DETECTED: URL FIELD. Utiliser URLField avec validation d'URL.",
+    "example_output": "website = models.URLField(blank=True)",
+    "documentation": "`URLField` est un CharField pour les URL, validé par `URLValidator`.",
+    "documentation_officielle": "Un CharField pour une URL, validé par URLValidator."
+  },
+  {
+    "terms": [
+      "slug",
+      "url-friendly",
+      "permalink"
+    ],
+    "instruction": "INTENT DETECTED: SLUG FIELD. Utiliser SlugField, souvent avec unique=True.",
+    "example_output": "slug = models.SlugField(max_length=200, unique=True)",
+    "documentation": "`SlugField` est un terme générique pour un label court, composé de lettres, chiffres, underscores ou traits d'union, généralement utilisé dans les URLs.",
+    "documentation_officielle": "Un slug est un label court pour quelque chose, contenant uniquement des lettres, des chiffres, des underscores ou des traits d'union. Ils sont généralement utilisés dans les URL."
+  },
+  {
+    "terms": [
+      "json",
+      "jsonfield",
+      "données structurées"
+    ],
+    "instruction": "INTENT DETECTED: JSON FIELD. Utiliser JSONField pour stocker des données JSON.",
+    "example_output": "metadata = models.JSONField(default=dict, blank=True)",
+    "documentation": "`JSONField` permet de stocker des structures de données JSON arbitraires. Il supporte les requêtes sur les clés JSON (sur PostgreSQL notamment).",
+    "documentation_officielle": "Un champ pour stocker des données encodées en JSON. En Python, les données sont représentées par leur format natif (dict, list, etc.)."
+  },
+  {
+    "terms": [
+      "fichier",
+      "upload",
+      "file"
+    ],
+    "instruction": "INTENT DETECTED: FILE FIELD. Utiliser FileField avec upload_to.",
+    "example_output": "attachment = models.FileField(upload_to='attachments/', blank=True)",
+    "documentation": "`FileField` gère le téléchargement de fichiers. `upload_to` détermine le répertoire de stockage. `ImageField` est une spécialisation avec validation d'image.",
+    "documentation_officielle": "Un champ de téléchargement de fichier. Nécessite l'argument upload_to pour spécifier le répertoire de stockage."
+  },
+  {
+    "terms": [
+      "choix",
+      "choices",
+      "select",
+      "dropdown",
+      "options"
+    ],
+    "instruction": "INTENT DETECTED: CHOICE FIELD. Définir des choices avec TextChoices ou IntegerChoices.",
+    "example_output": "class Status(models.TextChoices):\n    DRAFT = 'draft', 'Brouillon'\n    PUBLISHED = 'published', 'Publié'\n\nstatus = models.CharField(max_length=20, choices=Status.choices, default=Status.DRAFT)",
+    "documentation": "L'argument `choices` limite les valeurs possibles d'un champ. Il utilise souvent des classes `TextChoices` ou `IntegerChoices` pour définir des énumérations lisibles.",
+    "documentation_officielle": "L'argument choices est une séquence d'itérables contenant exactement deux éléments (valeur stockée, étiquette lisible) à utiliser comme choix pour un champ."
+  },
+  {
+    "terms": [
+      "relation",
+      "liaison",
+      "foreignkey",
+      "clé étrangère",
+      "many-to-one"
+    ],
+    "instruction": "INTENT DETECTED: FOREIGN KEY. Créer une relation many-to-one avec ForeignKey. Définir on_delete et related_name.",
+    "example_output": "author = models.ForeignKey('auth.User', on_delete=models.CASCADE, related_name='articles')",
+    "documentation": "Une relation plusieurs-à-un. Nécessite un argument positionnel : la classe à laquelle le modèle est lié. `on_delete` définit le comportement lors de la suppression de l'objet lié.",
+    "documentation_officielle": "Une relation plusieurs-à-un. Nécessite un argument positionnel : la classe à laquelle le modèle est lié."
+  },
+  {
+    "terms": [
+      "many to many",
+      "plusieurs à plusieurs",
+      "m2m",
+      "manytomany"
+    ],
+    "instruction": "INTENT DETECTED: MANY TO MANY. Créer une relation many-to-many avec ManyToManyField.",
+    "example_output": "tags = models.ManyToManyField('Tag', related_name='articles', blank=True)",
+    "documentation": "Une relation plusieurs-à-plusieurs. Crée une table intermédiaire pour lier les enregistrements des deux modèles.",
+    "documentation_officielle": "Une relation plusieurs-à-plusieurs. Nécessite un argument positionnel : la classe à laquelle le modèle est lié."
+  },
+  {
+    "terms": [
+      "one to one",
+      "un à un",
+      "onetoone"
+    ],
+    "instruction": "INTENT DETECTED: ONE TO ONE. Créer une relation one-to-one avec OneToOneField.",
+    "example_output": "profile = models.OneToOneField('UserProfile', on_delete=models.CASCADE)",
+    "documentation": "Une relation un-à-un. Similaire à une ForeignKey avec `unique=True`, mais le côté inverse renvoie un seul objet.",
+    "documentation_officielle": "Une relation un-à-un. Conceptuellement, c'est similaire à une ForeignKey avec unique=True, mais le côté 'inverse' de la relation renvoie directement un seul objet."
+  },
+  {
+    "terms": [
+      "parental",
+      "parentalkey",
+      "enfant",
+      "parent",
+      "relation wagtail"
+    ],
+    "instruction": "INTENT DETECTED: PARENTAL KEY. Utiliser ParentalKey pour relations parent-enfant dans Wagtail avec inline editing.",
+    "example_output": "from modelcluster.fields import ParentalKey\n\npage = ParentalKey('BlogPage', related_name='gallery_images', on_delete=models.CASCADE)",
+    "documentation": "Spécifique à Wagtail (via `django-modelcluster`). Similaire à ForeignKey, mais l'objet enfant est considéré comme faisant partie du parent, essentiel pour les relations inline dans l'éditeur (comme les galeries d'images).",
+    "documentation_officielle": "Une ParentalKey est similaire à une ForeignKey, mais elle définit également que l'objet enfant 'appartient' au parent, ce qui est essentiel pour les relations éditables en ligne (InlinePanel) dans Wagtail."
+  },
+  {
+    "terms": [
+      "parental many to many",
+      "clusterable",
+      "m2m wagtail"
+    ],
+    "instruction": "INTENT DETECTED: PARENTAL M2M. Utiliser ParentalManyToManyField pour relations many-to-many éditables inline.",
+    "example_output": "from modelcluster.fields import ParentalManyToManyField\n\ncategories = ParentalManyToManyField('Category', blank=True)",
+    "documentation": "Spécifique à Wagtail. Permet de gérer des relations ManyToMany directement dans l'interface d'édition de la page (ex: tags, catégories) sans sauvegarder immédiatement.",
+    "documentation_officielle": "ParentalManyToManyField est une sous-classe de ManyToManyField qui permet aux objets liés d'être attachés à une instance de modèle qui n'a pas encore été sauvegardée (en utilisant django-modelcluster)."
+  },
+  {
+    "terms": [
+      "orderable",
+      "ordre",
+      "tri",
+      "réorganiser",
+      "position",
+      "inline orderable"
+    ],
+    "instruction": "INTENT DETECTED: ORDERABLE. Hériter de Orderable pour gérer le tri manuel dans l'admin avec drag & drop.",
+    "example_output": "from modelcluster.models import ClusterableModel\nfrom wagtail.models import Orderable\n\nclass GalleryImage(Orderable):\n    page = ParentalKey('BlogPage', related_name='gallery_images')\n    image = models.ForeignKey('wagtailimages.Image', on_delete=models.CASCADE)\n    caption = models.CharField(max_length=250, blank=True)",
+    "documentation": "Mixin Wagtail permettant de rendre des objets triables (via drag-and-drop) dans l'admin, souvent utilisé avec `InlinePanel`.",
+    "documentation_officielle": "Orderable est un modèle abstrait qui ajoute un champ 'sort_order' de type entier pour permettre le tri manuel des objets."
+  },
+  {
+    "terms": [
+      "bloc",
+      "block",
+      "stream",
+      "streamfield",
+      "contenu flexible",
+      "champ flexible",
+      "modular content"
+    ],
+    "instruction": "INTENT DETECTED: STREAMFIELD. Ajouter un StreamField avec use_json_field=True. Définir les blocks disponibles.",
+    "example_output": "from wagtail.fields import StreamField\nfrom wagtail import blocks\n\nbody = StreamField([\n    ('heading', blocks.CharBlock()),\n    ('paragraph', blocks.RichTextBlock()),\n    ('image', ImageChooserBlock()),\n], use_json_field=True, blank=True)",
+    "documentation": "Un champ Wagtail puissant permettant aux éditeurs de construire des pages en assemblant une séquence de blocs de contenu de différents types (texte, image, vidéo, etc.).",
+    "documentation_officielle": "StreamField fournit un modèle d'édition de contenu adapté aux pages qui ne suivent pas une structure fixe (comme des articles de blog), où le texte peut être entremêlé d'images et d'autres blocs."
+  },
+  {
+    "terms": [
+      "struct",
+      "structblock",
+      "structure",
+      "composite",
+      "groupe",
+      "bloc composite"
+    ],
+    "instruction": "INTENT DETECTED: STRUCTBLOCK. Créer un StructBlock pour regrouper plusieurs champs cohérents.",
+    "example_output": "class HeroBlock(blocks.StructBlock):\n    title = blocks.CharBlock(max_length=200)\n    text = blocks.TextBlock()\n    button_text = blocks.CharBlock(required=False)\n    button_link = blocks.URLBlock(required=False)\n    \n    class Meta:\n        icon = 'hero'\n        template = 'blocks/hero_block.html'",
+    "documentation": "Un bloc StreamField composé de plusieurs sous-blocs fixes (ex: un titre, un texte et une image regroupés). Permet de créer des structures complexes.",
+    "documentation_officielle": "Un StructBlock est un bloc conteneur qui regroupe plusieurs blocs enfants (champs) de types différents en une seule valeur structurée."
+  },
+  {
+    "terms": [
+      "liste",
+      "list",
+      "listblock",
+      "répétition",
+      "multiple",
+      "collection"
+    ],
+    "instruction": "INTENT DETECTED: LISTBLOCK. Utiliser ListBlock pour permettre la répétition d'éléments.",
+    "example_output": "features = blocks.ListBlock(blocks.CharBlock(max_length=100))",
+    "documentation": "Un bloc StreamField qui contient une liste variable d'un même type de sous-bloc.",
+    "documentation_officielle": "Un ListBlock est un bloc conteneur qui gère une liste de sous-blocs du même type."
+  },
+  {
+    "terms": [
+      "stream",
+      "streamblock",
+      "nested stream",
+      "stream imbriqué"
+    ],
+    "instruction": "INTENT DETECTED: STREAMBLOCK. Créer un StreamBlock pour des structures flexibles imbriquées.",
+    "example_output": "class ColumnBlock(blocks.StreamBlock):\n    heading = blocks.CharBlock()\n    paragraph = blocks.RichTextBlock()\n    image = ImageChooserBlock()",
+    "documentation": "Un bloc conteneur qui permet de choisir parmi un ensemble de types de blocs enfants, permettant une structure imbriquée flexible.",
+    "documentation_officielle": "Un StreamBlock est un bloc conteneur qui permet aux éditeurs de choisir parmi un ensemble de types de blocs et de les ordonner librement."
+  },
+  {
+    "terms": [
+      "static",
+      "staticblock",
+      "bloc statique",
+      "fixed"
+    ],
+    "instruction": "INTENT DETECTED: STATICBLOCK. Utiliser StaticBlock pour des marqueurs sans données.",
+    "example_output": "separator = blocks.StaticBlock(admin_text='Séparateur horizontal')",
+    "documentation": "Un bloc qui n'a pas de valeur stockée, utile pour afficher du texte statique ou des séparateurs dans l'interface d'édition.",
+    "documentation_officielle": "Un StaticBlock est un bloc qui n'a pas de données éditables, mais qui peut afficher du contenu statique dans l'interface d'administration ou le template."
+  },
+  {
+    "terms": [
+      "page chooser",
+      "sélecteur page",
+      "lien page"
+    ],
+    "instruction": "INTENT DETECTED: PAGE CHOOSER BLOCK. Utiliser PageChooserBlock pour sélectionner une page.",
+    "example_output": "related_page = blocks.PageChooserBlock(required=False, target_model='blog.BlogPage')",
+    "documentation": "Un bloc permettant à l'éditeur de sélectionner une page interne Wagtail.",
+    "documentation_officielle": "Un bloc permettant de sélectionner une page Wagtail existante."
+  },
+  {
+    "terms": [
+      "snippet chooser",
+      "sélecteur snippet"
+    ],
+    "instruction": "INTENT DETECTED: SNIPPET CHOOSER BLOCK. Utiliser SnippetChooserBlock pour sélectionner un snippet.",
+    "example_output": "author = blocks.SnippetChooserBlock(target_model='blog.Author')",
+    "documentation": "Un bloc permettant de sélectionner un snippet existant.",
+    "documentation_officielle": "Un bloc permettant de sélectionner un snippet existant."
+  },
+  {
+    "terms": [
+      "texte riche",
+      "richtext",
+      "wysiwyg",
+      "éditeur riche"
+    ],
+    "instruction": "INTENT DETECTED: RICHTEXT FIELD. Utiliser RichTextField avec features personnalisables.",
+    "example_output": "from wagtail.fields import RichTextField\n\ncontent = RichTextField(features=['bold', 'italic', 'link', 'ol', 'ul', 'h2', 'h3'])",
+    "documentation": "Champ stockant du HTML riche. Dans l'admin, il s'affiche comme un éditeur WYSIWYG. Les liens et images internes sont stockés dans un format spécial pour maintenir l'intégrité référentielle.",
+    "documentation_officielle": "RichTextField fournit un champ d'édition WYSIWYG pour créer du contenu HTML riche, avec gestion des liens internes et des images Wagtail."
+  },
+  {
+    "terms": [
+      "richtext block",
+      "bloc texte riche"
+    ],
+    "instruction": "INTENT DETECTED: RICHTEXT BLOCK. Utiliser RichTextBlock dans StreamField avec features.",
+    "example_output": "text = blocks.RichTextBlock(features=['bold', 'italic', 'link'], required=False)",
+    "documentation": "L'équivalent de `RichTextField` mais sous forme de bloc pour StreamField.",
+    "documentation_officielle": "RichTextBlock est l'équivalent de RichTextField mais destiné à être utilisé à l'intérieur d'un StreamField."
+  },
+  {
+    "terms": [
+      "features",
+      "fonctionnalités éditeur",
+      "toolbar"
+    ],
+    "instruction": "INTENT DETECTED: RICHTEXT FEATURES. Configurer les features disponibles dans l'éditeur richtext.",
+    "example_output": "# Dans settings.py\nWAGTAILADMIN_RICH_TEXT_EDITORS = {\n    'default': {\n        'WIDGET': 'wagtail.admin.rich_text.DraftailRichTextArea',\n        'OPTIONS': {'features': ['h2', 'h3', 'bold', 'italic', 'link', 'document-link']}\n    }\n}",
+    "documentation": "Permet de restreindre ou d'étendre les options de formatage (gras, italique, liens, h2, etc.) disponibles dans l'éditeur riche.",
+    "documentation_officielle": "Les fonctionnalités de l'éditeur de texte riche (comme 'bold', 'italic', 'h2') peuvent être configurées globalement ou par champ pour restreindre ou étendre les options disponibles."
+  },
+  {
+    "terms": [
+      "image",
+      "photo",
+      "visuel",
+      "picture"
+    ],
+    "instruction": "INTENT DETECTED: IMAGE. Utiliser ForeignKey vers wagtailimages.Image avec renditions.",
+    "example_output": "image = models.ForeignKey(\n    'wagtailimages.Image',\n    null=True,\n    blank=True,\n    on_delete=models.SET_NULL,\n    related_name='+'\n)",
+    "documentation": "Wagtail gère les images via son propre modèle `wagtailimages.Image`, offrant des fonctionnalités avancées de traitement (renditions, point focal).",
+    "documentation_officielle": "Wagtail fournit un modèle d'image intégré (wagtailimages.Image) qui gère le stockage et le traitement des images, y compris la détection des points focaux."
+  },
+  {
+    "terms": [
+      "image chooser",
+      "sélecteur image",
+      "chooser image"
+    ],
+    "instruction": "INTENT DETECTED: IMAGE CHOOSER BLOCK. Utiliser ImageChooserBlock dans StreamField.",
+    "example_output": "from wagtail.images.blocks import ImageChooserBlock\n\nimage = ImageChooserBlock(required=False)",
+    "documentation": "Bloc permettant de sélectionner une image de la bibliothèque Wagtail dans un StreamField.",
+    "documentation_officielle": "Wagtail fournit un modèle d'image intégré (wagtailimages.Image) qui gère le stockage et le traitement des images, y compris la détection des points focaux."
+  },
+  {
+    "terms": [
+      "rendition",
+      "taille image",
+      "format image",
+      "crop",
+      "resize"
+    ],
+    "instruction": "INTENT DETECTED: IMAGE RENDITION. Générer des renditions d'image dans le template.",
+    "example_output": "{% load wagtailimages_tags %}\n{% image page.image fill-800x400 %}\n{% image page.image max-1200x800 as hero_img %}",
+    "documentation": "Processus de génération de versions redimensionnées ou recadrées des images à la volée dans les templates (ex: `fill-800x600`).",
+    "documentation_officielle": "Wagtail fournit un modèle d'image intégré (wagtailimages.Image) qui gère le stockage et le traitement des images, y compris la détection des points focaux."
+  },
+  {
+    "terms": [
+      "document",
+      "fichier",
+      "pdf",
+      "download"
+    ],
+    "instruction": "INTENT DETECTED: DOCUMENT. Utiliser ForeignKey vers wagtaildocs.Document.",
+    "example_output": "document = models.ForeignKey(\n    'wagtaildocs.Document',\n    null=True,\n    blank=True,\n    on_delete=models.SET_NULL,\n    related_name='+'\n)",
+    "documentation": "Modèle Wagtail pour gérer les fichiers téléchargeables (PDF, Doc, etc.) avec suivi d'usage.",
+    "documentation_officielle": "Le modèle Document (wagtaildocs.Document) gère les fichiers téléchargés qui ne sont pas des images (comme les PDF ou les documents Word)."
+  },
+  {
+    "terms": [
+      "document chooser",
+      "sélecteur document"
+    ],
+    "instruction": "INTENT DETECTED: DOCUMENT CHOOSER BLOCK. Utiliser DocumentChooserBlock.",
+    "example_output": "from wagtail.documents.blocks import DocumentChooserBlock\n\nfile = DocumentChooserBlock(required=False)",
+    "documentation": "Bloc permettant de sélectionner un document dans un StreamField.",
+    "documentation_officielle": "Le modèle Document (wagtaildocs.Document) gère les fichiers téléchargés qui ne sont pas des images (comme les PDF ou les documents Word)."
+  },
+  {
+    "terms": [
+      "embed",
+      "video",
+      "média externe",
+      "oembed"
+    ],
+    "instruction": "INTENT DETECTED: EMBED. Utiliser EmbedBlock pour YouTube, Vimeo, etc.",
+    "example_output": "from wagtail.embeds.blocks import EmbedBlock\n\nvideo = EmbedBlock(required=False, help_text='URL YouTube ou Vimeo')",
+    "documentation": "Gère l'intégration de contenus externes (oEmbed) comme YouTube ou Vimeo simplement en collant l'URL.",
+    "documentation_officielle": "Le module Embeds permet d'intégrer du contenu externe (comme des vidéos YouTube ou des tweets) simplement en fournissant l'URL, en utilisant le standard oEmbed."
+  },
+  {
+    "terms": [
+      "dashboard",
+      "admin",
+      "ui admin",
+      "backoffice",
+      "éditeur",
+      "panels"
+    ],
+    "instruction": "INTENT DETECTED: ADMIN PANELS. Configurer l'interface d'édition avec FieldPanel, InlinePanel, MultiFieldPanel.",
+    "example_output": "from wagtail.admin.panels import FieldPanel, InlinePanel, MultiFieldPanel\n\ncontent_panels = Page.content_panels + [\n    FieldPanel('subtitle'),\n    MultiFieldPanel([\n        FieldPanel('date'),\n        FieldPanel('author'),\n    ], heading='Métadonnées'),\n    InlinePanel('gallery_images', label='Images'),\n]",
+    "documentation": "Les `Panels` définissent comment les champs du modèle sont présentés dans l'interface d'édition Wagtail. Ils remplacent `admin.py` de Django pour les Pages.",
+    "documentation_officielle": "Les panneaux (Panels) sont des classes qui définissent comment les champs d'un modèle sont présentés dans l'interface d'édition de Wagtail."
+  },
+  {
+    "terms": [
+      "inline",
+      "inlinepanel",
+      "relation inline",
+      "nested"
+    ],
+    "instruction": "INTENT DETECTED: INLINE PANEL. Ajouter un InlinePanel pour éditer des relations inline.",
+    "example_output": "InlinePanel('related_links', label='Liens associés', min_num=0, max_num=5)",
+    "documentation": "Permet d'éditer des objets liés (enfants) directement dans la page d'édition du parent (ex: diapositives d'un carrousel).",
+    "documentation_officielle": "InlinePanel permet l'édition d'objets liés (généralement via une ParentalKey) directement dans l'interface d'édition du modèle parent."
+  },
+  {
+    "terms": [
+      "fieldpanel",
+      "field panel",
+      "champ éditable"
+    ],
+    "instruction": "INTENT DETECTED: FIELD PANEL. Exposer un champ dans l'admin avec FieldPanel.",
+    "example_output": "FieldPanel('title', classname='title')",
+    "documentation": "Le panneau de base pour éditer un champ de modèle. Il choisit automatiquement le widget approprié.",
+    "documentation_officielle": "La partie la plus importante d'un modèle – et la seule obligatoire – est la liste des champs de base de données qu'il définit. Les champs sont spécifiés par des attributs de classe."
+  },
+  {
+    "terms": [
+      "multifieldpanel",
+      "groupe champs",
+      "fieldset"
+    ],
+    "instruction": "INTENT DETECTED: MULTI FIELD PANEL. Regrouper plusieurs champs sous un heading.",
+    "example_output": "MultiFieldPanel([\n    FieldPanel('start_date'),\n    FieldPanel('end_date'),\n], heading='Période', classname='collapsible')",
+    "documentation": "Regroupe visuellement plusieurs panneaux sous un titre commun, et peut être repliable.",
+    "documentation_officielle": "MultiFieldPanel regroupe une collection de panneaux enfants, avec un titre optionnel."
+  },
+  {
+    "terms": [
+      "tabs",
+      "onglets",
+      "edit handler",
+      "tabbed"
+    ],
+    "instruction": "INTENT DETECTED: TABS. Organiser l'interface en onglets avec TabbedInterface.",
+    "example_output": "from wagtail.admin.panels import TabbedInterface\n\nedit_handler = TabbedInterface([\n    ObjectList(content_panels, heading='Contenu'),\n    ObjectList(promote_panels, heading='SEO'),\n    ObjectList(settings_panels, heading='Paramètres'),\n])",
+    "documentation": "`TabbedInterface` permet d'organiser les panneaux dans différents onglets (Contenu, Promote, Paramètres) pour clarifier l'interface.",
+    "documentation_officielle": "TabbedInterface permet d'organiser les panneaux en plusieurs onglets (comme 'Contenu', 'Promouvoir', 'Paramètres')."
+  },
+  {
+    "terms": [
+      "promote",
+      "seo",
+      "référencement",
+      "meta"
+    ],
+    "instruction": "INTENT DETECTED: SEO PANELS. Configurer promote_panels avec champs SEO.",
+    "example_output": "promote_panels = Page.promote_panels + [\n    FieldPanel('seo_title'),\n    FieldPanel('search_description'),\n    FieldPanel('search_image'),\n]",
+    "documentation": "Champs standards (titre SEO, description meta) pour optimiser le référencement naturel des pages.",
+    "documentation_officielle": "Wagtail fournit des champs standard (slug, seo_title, search_description) regroupés dans promote_panels pour gérer le référencement."
+  },
+  {
+    "terms": [
+      "settings",
+      "paramètres page",
+      "settings panels"
+    ],
+    "instruction": "INTENT DETECTED: SETTINGS PANELS. Ajouter des paramètres techniques dans settings_panels.",
+    "example_output": "settings_panels = Page.settings_panels + [\n    FieldPanel('show_in_menus'),\n    FieldPanel('go_live_at'),\n    FieldPanel('expire_at'),\n]",
+    "documentation": "Champs de configuration de la page (date de publication, visibilité dans les menus, etc.).",
+    "documentation_officielle": "Les settings_panels contiennent les champs de configuration de la page, tels que la date de publication et la visibilité dans les menus."
+  },
+  {
+    "terms": [
+      "snippet",
+      "réutilisable",
+      "global content",
+      "contenu global"
+    ],
+    "instruction": "INTENT DETECTED: SNIPPET. Créer un snippet réutilisable avec @register_snippet.",
+    "example_output": "from wagtail.snippets.models import register_snippet\nfrom wagtail.admin.panels import FieldPanel\n\n@register_snippet\nclass Author(models.Model):\n    name = models.CharField(max_length=100)\n    bio = models.TextField()\n    panels = [FieldPanel('name'), FieldPanel('bio')]",
+    "documentation": "Contenu réutilisable qui n'a pas besoin de structure arborescente (ex: Auteurs, Publicités, Catégories). Géré via le menu Snippets.",
+    "documentation_officielle": "Les snippets sont des morceaux de contenu réutilisables (comme des auteurs ou des catégories) qui n'ont pas besoin de faire partie de l'arborescence hiérarchique des pages."
+  },
+  {
+    "terms": [
+      "snippet chooser field",
+      "relation snippet"
+    ],
+    "instruction": "INTENT DETECTED: SNIPPET RELATION. Créer une ForeignKey vers un snippet.",
+    "example_output": "author = models.ForeignKey('blog.Author', null=True, blank=True, on_delete=models.SET_NULL)",
+    "documentation": "Lier une page à un snippet via une ForeignKey.",
+    "documentation_officielle": "Les snippets sont des morceaux de contenu réutilisables (comme des auteurs ou des catégories) qui n'ont pas besoin de faire partie de l'arborescence hiérarchique des pages."
+  },
+  {
+    "terms": [
+      "contexte",
+      "context",
+      "data template",
+      "variable template",
+      "get_context"
+    ],
+    "instruction": "INTENT DETECTED: TEMPLATE CONTEXT. Étendre get_context pour passer des données au template.",
+    "example_output": "def get_context(self, request, *args, **kwargs):\n    context = super().get_context(request, *args, **kwargs)\n    context['recent_posts'] = BlogPage.objects.live().order_by('-first_published_at')[:5]\n    return context",
+    "documentation": "La méthode `get_context` permet d'injecter des variables supplémentaires dans le template lors du rendu de la page.",
+    "documentation_officielle": "La méthode get_context() est utilisée pour préparer les données (le contexte) qui seront passées au template lors du rendu de la page."
+  },
+  {
+    "terms": [
+      "vue",
+      "view",
+      "logique",
+      "serve",
+      "render"
+    ],
+    "instruction": "INTENT DETECTED: VIEW LOGIC. Surcharger serve() pour logique de rendu personnalisée.",
+    "example_output": "def serve(self, request, *args, **kwargs):\n    if request.method == 'POST':\n        # Handle form\n        pass\n    return super().serve(request, *args, **kwargs)",
+    "documentation": "La méthode `serve` contrôle comment la page répond à la requête HTTP. Elle peut être surchargée pour gérer des formulaires ou des réponses personnalisées.",
+    "documentation_officielle": "La méthode serve() est responsable de renvoyer une réponse HTTP pour la page. Elle peut être surchargée pour gérer des interactions complexes comme le traitement de formulaires."
+  },
+  {
+    "terms": [
+      "template",
+      "gabarit",
+      "html",
+      "rendu"
+    ],
+    "instruction": "INTENT DETECTED: TEMPLATE. Définir le template associé à une page.",
+    "example_output": "template = 'blog/blog_page.html'\n# ou\ndef get_template(self, request):\n    if request.is_ajax():\n        return 'blog/blog_page_ajax.html'\n    return 'blog/blog_page.html'",
+    "documentation": "Fichier HTML utilisant le langage de gabarit Django (DTL) pour afficher dynamiquement les données.",
+    "documentation_officielle": "Un template Django est un fichier texte (souvent du HTML) qui utilise le langage de gabarit de Django pour générer dynamiquement du contenu."
+  },
+  {
+    "terms": [
+      "requête",
+      "query",
+      "queryset",
+      "filtre",
+      "filter",
+      "recherche"
+    ],
+    "instruction": "INTENT DETECTED: QUERYSET. Écrire une requête ORM Django avec filtres et optimisations.",
+    "example_output": "articles = ArticlePage.objects.live().public().filter(\n    status='published'\n).select_related('author').prefetch_related('tags').order_by('-first_published_at')",
+    "documentation": "Une collection d'objets de la base de données. Les QuerySets sont paresseux (lazy) : la requête SQL n'est exécutée que lorsque les données sont nécessaires.",
+    "documentation_officielle": "Un QuerySet représente une collection d'objets de la base de données. Il est évaluable de manière paresseuse (lazy) et permet de filtrer, trier et découper les résultats."
+  },
+  {
+    "terms": [
+      "pagination",
+      "paginate",
+      "page par page"
+    ],
+    "instruction": "INTENT DETECTED: PAGINATION. Implémenter la pagination dans get_context.",
+    "example_output": "from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage\n\ndef get_context(self, request):\n    context = super().get_context(request)\n    posts = BlogPage.objects.live()\n    paginator = Paginator(posts, 10)\n    page = request.GET.get('page')\n    try:\n        posts = paginator.page(page)\n    except PageNotAnInteger:\n        posts = paginator.page(1)\n    except EmptyPage:\n        posts = paginator.page(paginator.num_pages)\n    context['posts'] = posts\n    return context",
+    "documentation": "Diviser une liste d'objets sur plusieurs pages. Django fournit la classe `Paginator` pour gérer cela facilement.",
+    "documentation_officielle": "Django fournit une classe Paginator pour gérer la pagination des données, permettant de diviser une liste d'objets sur plusieurs pages."
+  },
+  {
+    "terms": [
+      "search",
+      "recherche",
+      "search backend",
+      "elasticsearch"
+    ],
+    "instruction": "INTENT DETECTED: SEARCH. Configurer la recherche Wagtail avec search_fields.",
+    "example_output": "from wagtail.search import index\n\nsearch_fields = Page.search_fields + [\n    index.SearchField('body'),\n    index.FilterField('date'),\n    index.AutocompleteField('title'),\n]",
+    "documentation": "Wagtail intègre un moteur de recherche puissant (compatible Elasticsearch) pour indexer et rechercher dans les pages et images.",
+    "documentation_officielle": "Wagtail inclut un backend de recherche abstrait qui permet d'indexer et de rechercher des objets (pages, images, documents) en utilisant une API unifiée."
+  },
+  {
+    "terms": [
+      "annotation",
+      "aggregate",
+      "count",
+      "sum",
+      "avg"
+    ],
+    "instruction": "INTENT DETECTED: AGGREGATION. Utiliser annotate() et aggregate() pour calculs.",
+    "example_output": "from django.db.models import Count, Avg\n\nauthors = Author.objects.annotate(\n    article_count=Count('articles'),\n    avg_views=Avg('articles__views')\n)",
+    "documentation": "Calculer des valeurs sur un ensemble d'objets (somme, moyenne, compte) directement en base de données.",
+    "documentation_officielle": "Django permet de générer des agrégats (statistiques) sur un QuerySet, comme compter, sommer ou faire la moyenne des valeurs des champs."
+  },
+  {
+    "terms": [
+      "distinct",
+      "unique values",
+      "valeurs uniques"
+    ],
+    "instruction": "INTENT DETECTED: DISTINCT. Utiliser distinct() pour éliminer les doublons.",
+    "example_output": "tags = Tag.objects.filter(articles__status='published').distinct()",
+    "documentation": "Élimine les doublons dans les résultats d'une requête.",
+    "documentation_officielle": "La méthode distinct() renvoie un nouveau QuerySet avec les résultats en double éliminés."
+  },
+  {
+    "terms": [
+      "exists",
+      "vérification existence"
+    ],
+    "instruction": "INTENT DETECTED: EXISTS. Utiliser exists() pour vérifier l'existence efficacement.",
+    "example_output": "has_posts = BlogPage.objects.child_of(self).exists()",
+    "documentation": "Vérifie efficacement si au moins un objet correspond à la requête, sans récupérer les données.",
+    "documentation_officielle": "La méthode exists() renvoie True si le QuerySet contient des résultats, et False sinon. C'est la méthode la plus efficace pour vérifier l'existence."
+  },
+  {
+    "terms": [
+      "formulaire",
+      "form",
+      "saisie",
+      "input utilisateur",
+      "form page"
+    ],
+    "instruction": "INTENT DETECTED: FORM. Créer un formulaire Django ou hériter de FormPage dans Wagtail.",
+    "example_output": "from wagtail.contrib.forms.models import AbstractEmailForm, AbstractFormField\n\nclass ContactPage(AbstractEmailForm):\n    intro = RichTextField(blank=True)\n    thank_you_text = RichTextField(blank=True)\n    \n    content_panels = AbstractEmailForm.content_panels + [\n        FieldPanel('intro'),\n        InlinePanel('form_fields', label='Champs du formulaire'),\n        FieldPanel('thank_you_text'),\n        MultiFieldPanel([\n            FieldPanel('to_address'),\n            FieldPanel('from_address'),\n            FieldPanel('subject'),\n        ], 'Email'),\n    ]",
+    "documentation": "Classe définissant un formulaire, ses champs et sa validation. Wagtail propose `FormPage` pour créer des formulaires administrables.",
+    "documentation_officielle": "La classe Form de Django décrit un formulaire, détermine comment il fonctionne et apparaît, et gère la validation des données."
+  },
+  {
+    "terms": [
+      "validation",
+      "validator",
+      "clean",
+      "contrainte formulaire"
+    ],
+    "instruction": "INTENT DETECTED: FORM VALIDATION. Ajouter validation personnalisée avec clean() ou validators.",
+    "example_output": "from django.core.exceptions import ValidationError\n\ndef clean(self):\n    cleaned_data = super().clean()\n    start = cleaned_data.get('start_date')\n    end = cleaned_data.get('end_date')\n    if start and end and start > end:\n        raise ValidationError('La date de fin doit être après la date de début')\n    return cleaned_data",
+    "documentation": "Processus de vérification des données soumises. La méthode `clean()` permet une validation croisée entre plusieurs champs.",
+    "documentation_officielle": "La classe Form de Django décrit un formulaire, détermine comment il fonctionne et apparaît, et gère la validation des données."
+  },
+  {
+    "terms": [
+      "modelform",
+      "form depuis modèle"
+    ],
+    "instruction": "INTENT DETECTED: MODEL FORM. Créer un formulaire à partir d'un modèle avec ModelForm.",
+    "example_output": "from django import forms\n\nclass ArticleForm(forms.ModelForm):\n    class Meta:\n        model = Article\n        fields = ['title', 'content', 'status']\n        widgets = {\n            'content': forms.Textarea(attrs={'rows': 5}),\n        }",
+    "documentation": "Un formulaire généré automatiquement à partir d'un modèle, mappant les champs du modèle aux champs du formulaire.",
+    "documentation_officielle": "ModelForm est une classe helper qui crée automatiquement une classe Form à partir d'un modèle Django, mappant les champs du modèle aux champs du formulaire."
+  },
+  {
+    "terms": [
+      "url",
+      "route",
+      "chemin",
+      "endpoint",
+      "path"
+    ],
+    "instruction": "INTENT DETECTED: URL ROUTING. Définir les routes Django dans urls.py.",
+    "example_output": "from django.urls import path\nfrom . import views\n\nurlpatterns = [\n    path('articles/', views.article_list, name='article_list'),\n    path('articles/<slug:slug>/', views.article_detail, name='article_detail'),\n]",
+    "documentation": "Le système d'URL de Django mappe les URL demandées à des fonctions de vue (views) via des expressions (path ou re_path).",
+    "documentation_officielle": "Le dispatcher d'URL de Django associe les modèles d'URL demandés aux fonctions de vue (views) appropriées."
+  },
+  {
+    "terms": [
+      "redirect",
+      "redirection",
+      "renvoi"
+    ],
+    "instruction": "INTENT DETECTED: REDIRECT. Créer une redirection avec redirect() ou RedirectView.",
+    "example_output": "from django.shortcuts import redirect\n\ndef old_view(request):\n    return redirect('new_view', permanent=True)",
+    "documentation": "Renvoyer une réponse HTTP demandant au navigateur d'aller à une autre URL.",
+    "documentation_officielle": "Une redirection renvoie une réponse HTTP spéciale qui demande au navigateur d'aller à une autre URL."
+  },
+  {
+    "terms": [
+      "api",
+      "json",
+      "headless",
+      "endpoint api",
+      "rest"
+    ],
+    "instruction": "INTENT DETECTED: WAGTAIL API. Exposer des pages via l'API Wagtail avec api_fields.",
+    "example_output": "from wagtail.api import APIField\n\napi_fields = [\n    APIField('subtitle'),\n    APIField('author'),\n    APIField('featured_image'),\n]",
+    "documentation": "Module permettant d'exposer le contenu Wagtail (Pages, Images, Documents) via une API REST JSON.",
+    "documentation_officielle": "Le module wagtail.api fournit une API publique en lecture seule pour accéder au contenu de votre site (pages, images, documents) au format JSON."
+  },
+  {
+    "terms": [
+      "serializer",
+      "sérialisation",
+      "drf",
+      "django rest framework"
+    ],
+    "instruction": "INTENT DETECTED: DRF SERIALIZER. Créer un serializer Django REST Framework.",
+    "example_output": "from rest_framework import serializers\n\nclass ArticleSerializer(serializers.ModelSerializer):\n    class Meta:\n        model = Article\n        fields = ['id', 'title', 'slug', 'content', 'published_date']",
+    "documentation": "Transforme des types de données complexes (QuerySets, instances) en types natifs Python (JSON) et inversement.",
+    "documentation_officielle": "Les sérialiseurs permettent de convertir des données complexes (comme les instances de modèles) en types de données natifs Python qui peuvent être facilement rendus en JSON ou XML."
+  },
+  {
+    "terms": [
+      "viewset",
+      "api view",
+      "vue api"
+    ],
+    "instruction": "INTENT DETECTED: DRF VIEWSET. Créer un ViewSet pour exposer des endpoints CRUD.",
+    "example_output": "from rest_framework import viewsets\n\nclass ArticleViewSet(viewsets.ModelViewSet):\n    queryset = Article.objects.all()\n    serializer_class = ArticleSerializer",
+    "documentation": "Combine la logique de plusieurs vues liées (list, create, retrieve, update, destroy) en une seule classe.",
+    "documentation_officielle": "Les ViewSets permettent de combiner la logique d'un ensemble de vues associées (comme list, create, retrieve) dans une seule classe."
+  },
+  {
+    "terms": [
+      "signal",
+      "événement",
+      "post_save",
+      "pre_save",
+      "trigger"
+    ],
+    "instruction": "INTENT DETECTED: DJANGO SIGNAL. Réagir aux événements modèle avec signals.",
+    "example_output": "from django.db.models.signals import post_save\nfrom django.dispatch import receiver\n\n@receiver(post_save, sender=Article)\ndef article_saved(sender, instance, created, **kwargs):\n    if created:\n        # Nouvelle création\n        pass",
+    "documentation": "Système de dispatch permettant à des composants découplés d'être notifiés quand certaines actions se produisent (ex: post_save).",
+    "documentation_officielle": "Django inclut un distributeur de signaux qui permet aux applications découplées d'être notifiées quand des actions se produisent ailleurs dans le framework."
+  },
+  {
+    "terms": [
+      "hook",
+      "wagtail hook",
+      "register hook"
+    ],
+    "instruction": "INTENT DETECTED: WAGTAIL HOOK. Utiliser les hooks Wagtail pour étendre le comportement.",
+    "example_output": "from wagtail import hooks\n\n@hooks.register('before_serve_page')\ndef set_custom_header(page, request, serve_args, serve_kwargs):\n    # Logique custom\n    pass",
+    "documentation": "Points d'entrée permettant d'exécuter du code à des moments précis du cycle de vie Wagtail ou de modifier l'interface admin.",
+    "documentation_officielle": "Les hooks sont un mécanisme permettant d'exécuter du code à certains points d'extension de Wagtail, par exemple pour modifier le menu admin ou le rendu des pages."
+  },
+  {
+    "terms": [
+      "admin hook",
+      "menu admin",
+      "customisation admin"
+    ],
+    "instruction": "INTENT DETECTED: ADMIN HOOK. Ajouter des éléments au menu admin Wagtail.",
+    "example_output": "from wagtail import hooks\nfrom wagtail.admin.menu import MenuItem\n\n@hooks.register('register_admin_menu_item')\ndef register_reports_menu():\n    return MenuItem(\n        'Rapports',\n        '/admin/reports/',\n        icon_name='doc-full',\n        order=10000\n    )",
+    "documentation": "Hooks spécifiques pour modifier le menu principal, ajouter des boutons ou des CSS/JS dans l'admin Wagtail.",
+    "documentation_officielle": "Les hooks d'administration permettent de personnaliser l'interface d'administration de Wagtail, par exemple en ajoutant des éléments de menu ou des fichiers CSS/JS."
+  },
+  {
+    "terms": [
+      "permission",
+      "autorisation",
+      "droits",
+      "access control"
+    ],
+    "instruction": "INTENT DETECTED: PERMISSIONS. Gérer les permissions avec Meta.permissions ou decorators.",
+    "example_output": "class Meta:\n    permissions = [\n        ('can_publish_article', 'Peut publier des articles'),\n    ]",
+    "documentation": "Système déterminant si un utilisateur peut effectuer une action (add, change, delete, view) sur un modèle.",
+    "documentation_officielle": "Le système d'authentification de Django gère à la fois l'authentification (vérification de l'identité) et l'autorisation (ce que l'utilisateur a le droit de faire)."
+  },
+  {
+    "terms": [
+      "group",
+      "groupe",
+      "utilisateur",
+      "rôle"
+    ],
+    "instruction": "INTENT DETECTED: GROUPS. Créer des groupes d'utilisateurs avec permissions.",
+    "example_output": "from django.contrib.auth.models import Group, Permission\n\neditors_group = Group.objects.create(name='Éditeurs')\npermission = Permission.objects.get(codename='can_publish_article')\neditors_group.permissions.add(permission)",
+    "documentation": "Collections d'utilisateurs permettant d'attribuer des permissions en masse.",
+    "documentation_officielle": "Les groupes sont un moyen générique de classer les utilisateurs, afin que vous puissiez appliquer des permissions ou d'autres métadonnées à tous les membres du groupe."
+  },
+  {
+    "terms": [
+      "cache",
+      "performance",
+      "rapidité",
+      "optimisation"
+    ],
+    "instruction": "INTENT DETECTED: CACHE. Mettre en cache avec decorators ou cache framework.",
+    "example_output": "from django.views.decorators.cache import cache_page\nfrom django.core.cache import cache\n\n@cache_page(60 * 15)  # 15 minutes\ndef my_view(request):\n    data = cache.get('my_data')\n    if data is None:\n        data = expensive_operation()\n        cache.set('my_data', data, 60 * 60)\n    return render(request, 'template.html', {'data': data})",
+    "documentation": "Stockage temporaire de données ou de pages entières pour améliorer les performances et réduire la charge de la base de données.",
+    "documentation_officielle": "Le système de cache de Django permet de stocker le résultat de calculs coûteux ou de requêtes afin de servir les requêtes futures plus rapidement."
+  },
+  {
+    "terms": [
+      "select_related",
+      "jointure",
+      "fk optimization"
+    ],
+    "instruction": "INTENT DETECTED: SELECT RELATED. Optimiser les ForeignKey avec select_related().",
+    "example_output": "articles = Article.objects.select_related('author', 'category')",
+    "documentation": "Optimisation SQL effectuant une jointure (JOIN) pour récupérer les objets liés par ForeignKey en une seule requête.",
+    "documentation_officielle": "select_related renvoie un QuerySet qui suivra les relations de clé étrangère, sélectionnant les données liées supplémentaires lors de l'exécution de la requête."
+  },
+  {
+    "terms": [
+      "prefetch_related",
+      "m2m optimization",
+      "reverse fk"
+    ],
+    "instruction": "INTENT DETECTED: PREFETCH RELATED. Optimiser M2M et reverse FK avec prefetch_related().",
+    "example_output": "from django.db.models import Prefetch\n\nauthors = Author.objects.prefetch_related(\n    Prefetch('articles', queryset=Article.objects.filter(status='published'))\n)",
+    "documentation": "Optimisation SQL pour les relations ManyToMany ou Reverse ForeignKey, effectuant une requête séparée et liant les résultats en Python.",
+    "documentation_officielle": "prefetch_related effectue des recherches séparées pour chaque relation et effectue le 'joining' en Python. Il est utilisé pour les relations ManyToMany et ForeignKey inversées."
+  },
+  {
+    "terms": [
+      "only",
+      "defer",
+      "champs sélectifs"
+    ],
+    "instruction": "INTENT DETECTED: FIELD SELECTION. Limiter les champs chargés avec only() ou defer().",
+    "example_output": "articles = Article.objects.only('id', 'title', 'slug')\n# ou\narticles = Article.objects.defer('content', 'metadata')",
+    "documentation": "`only()` et `defer()` permettent de ne charger qu'un sous-ensemble des champs d'un modèle pour optimiser la mémoire.",
+    "documentation_officielle": "La partie la plus importante d'un modèle – et la seule obligatoire – est la liste des champs de base de données qu'il définit. Les champs sont spécifiés par des attributs de classe."
+  },
+  {
+    "terms": [
+      "bulk",
+      "bulk_create",
+      "bulk_update",
+      "masse"
+    ],
+    "instruction": "INTENT DETECTED: BULK OPERATIONS. Créer/modifier en masse avec bulk_create() et bulk_update().",
+    "example_output": "Article.objects.bulk_create([\n    Article(title='Article 1'),\n    Article(title='Article 2'),\n])\n\nArticle.objects.bulk_update(articles_list, ['status', 'updated_at'])",
+    "documentation": "Méthodes pour créer ou mettre à jour de nombreux objets en une seule requête SQL, beaucoup plus rapide que des boucles."
+  },
+  {
+    "terms": [
+      "migration",
+      "schema",
+      "base de données",
+      "makemigrations",
+      "migrate"
+    ],
+    "instruction": "INTENT DETECTED: MIGRATION. Générer et appliquer des migrations Django.",
+    "example_output": "# Créer migrations\npython manage.py makemigrations\n\n# Appliquer migrations\npython manage.py migrate\n\n# Migration personnalisée\npython manage.py makemigrations --empty myapp",
+    "documentation": "Fichiers décrivant les changements de schéma de base de données. Ils permettent de propager les modifications des modèles vers la DB.",
+    "documentation_officielle": "Les migrations sont la façon dont Django propage les changements que vous apportez à vos modèles (ajout d'un champ, suppression d'un modèle, etc.) dans le schéma de votre base de données."
+  },
+  {
+    "terms": [
+      "data migration",
+      "migration données",
+      "populate"
+    ],
+    "instruction": "INTENT DETECTED: DATA MIGRATION. Créer une migration de données.",
+    "example_output": "from django.db import migrations\n\ndef populate_data(apps, schema_editor):\n    Article = apps.get_model('blog', 'Article')\n    Article.objects.create(title='Initial Article')\n\nclass Migration(migrations.Migration):\n    dependencies = [('blog', '0001_initial')]\n    operations = [migrations.RunPython(populate_data)]",
+    "documentation": "Migration spéciale exécutant du code Python pour manipuler les données existantes lors d'un changement de schéma.",
+    "documentation_officielle": "Les migrations de données permettent de modifier les données dans la base de données en même temps que le schéma, souvent pour adapter les données existantes à une nouvelle structure."
+  },
+  {
+    "terms": [
+      "settings",
+      "config",
+      "configuration",
+      "paramètres projet"
+    ],
+    "instruction": "INTENT DETECTED: SETTINGS. Configurer le projet dans settings.py.",
+    "example_output": "# settings.py\nWAGTAIL_SITE_NAME = 'Mon Site'\nWAGTAILADMIN_BASE_URL = 'https://example.com'\n\nINSTALLED_APPS = [\n    'myapp',\n    'wagtail.contrib.forms',\n]\n\nMEDIA_URL = '/media/'\nMEDIA_ROOT = BASE_DIR / 'media'",
+    "documentation": "Fichier central de configuration de Django (BDD, apps installées, middleware, templates, etc.).",
+    "documentation_officielle": "Un fichier de paramètres Django contient toute la configuration de votre installation Django."
+  },
+  {
+    "terms": [
+      "middleware",
+      "intergiciel"
+    ],
+    "instruction": "INTENT DETECTED: MIDDLEWARE. Ajouter ou créer un middleware.",
+    "example_output": "# settings.py\nMIDDLEWARE = [\n    'django.middleware.security.SecurityMiddleware',\n    'myapp.middleware.CustomMiddleware',\n]\n\n# middleware.py\nclass CustomMiddleware:\n    def __init__(self, get_response):\n        self.get_response = get_response\n    \n    def __call__(self, request):\n        response = self.get_response(request)\n        return response",
+    "documentation": "Couches de traitement s'exécutant à chaque requête/réponse, permettant d'altérer globalement les entrées ou sorties.",
+    "documentation_officielle": "Le middleware est un cadre de hooks dans le traitement des requêtes/réponses de Django. C'est un système de plugins léger et de bas niveau pour modifier globalement l'entrée ou la sortie de Django."
+  },
+  {
+    "terms": [
+      "environnement",
+      "env",
+      "variable environnement",
+      "dotenv"
+    ],
+    "instruction": "INTENT DETECTED: ENVIRONMENT VARIABLES. Utiliser des variables d'environnement.",
+    "example_output": "import os\nfrom pathlib import Path\nimport environ\n\nenv = environ.Env()\nenviron.Env.read_env()\n\nSECRET_KEY = env('SECRET_KEY')\nDEBUG = env.bool('DEBUG', default=False)\nDATABASE_URL = env('DATABASE_URL')",
+    "documentation": "Bonne pratique consistant à séparer la configuration sensible (clés secrètes, DB passwords) du code source.",
+    "documentation_officielle": "Il est recommandé de séparer la configuration du code. L'utilisation de variables d'environnement permet de garder les secrets (comme SECRET_KEY) hors du code source."
+  },
+  {
+    "terms": [
+      "authentification",
+      "login",
+      "connexion",
+      "user"
+    ],
+    "instruction": "INTENT DETECTED: AUTHENTICATION. Gérer l'authentification utilisateur.",
+    "example_output": "from django.contrib.auth.decorators import login_required\nfrom django.contrib.auth import authenticate, login\n\n@login_required\ndef my_view(request):\n    pass\n\ndef login_view(request):\n    user = authenticate(username=username, password=password)\n    if user:\n        login(request, user)",
+    "documentation": "Système gérant les comptes utilisateurs, les sessions, et la vérification des identités.",
+    "documentation_officielle": "Django fournit un système d'authentification complet, gérant les comptes utilisateurs, les groupes, les permissions et les sessions basées sur les cookies."
+  },
+  {
+    "terms": [
+      "custom user",
+      "utilisateur personnalisé",
+      "user model"
+    ],
+    "instruction": "INTENT DETECTED: CUSTOM USER MODEL. Créer un modèle utilisateur personnalisé.",
+    "example_output": "from django.contrib.auth.models import AbstractUser\n\nclass CustomUser(AbstractUser):\n    bio = models.TextField(blank=True)\n    avatar = models.ImageField(upload_to='avatars/', blank=True)\n\n# settings.py\nAUTH_USER_MODEL = 'myapp.CustomUser'",
+    "documentation": "Remplacement du modèle User par défaut de Django pour ajouter des champs spécifiques au projet.",
+    "documentation_officielle": "Django permet de substituer un modèle d'utilisateur personnalisé au modèle User par défaut, ce qui permet d'utiliser une adresse email comme identifiant ou d'ajouter des champs spécifiques."
+  },
+  {
+    "terms": [
+      "test",
+      "unittest",
+      "testing",
+      "test case"
+    ],
+    "instruction": "INTENT DETECTED: TESTING. Créer des tests unitaires Django/Wagtail.",
+    "example_output": "from django.test import TestCase\nfrom wagtail.test.utils import WagtailPageTests\n\nclass ArticlePageTest(TestCase, WagtailPageTests):\n    def test_can_create_article(self):\n        article = ArticlePage(title='Test', slug='test')\n        self.assertCanCreate(HomePage, article)",
+    "documentation": "Pratique consistant à écrire du code pour vérifier que l'application fonctionne comme prévu et prévenir les régressions.",
+    "documentation_officielle": "Les tests automatisés sont des routines qui vérifient le fonctionnement de votre code. Django fournit un framework de test basé sur le module unittest de Python."
+  },
+  {
+    "terms": [
+      "factory",
+      "fixture",
+      "données test"
+    ],
+    "instruction": "INTENT DETECTED: TEST FIXTURES. Créer des fixtures ou factories pour les tests.",
+    "example_output": "import factory\nfrom factory.django import DjangoModelFactory\n\nclass ArticleFactory(DjangoModelFactory):\n    class Meta:\n        model = Article\n    \n    title = factory.Sequence(lambda n: f'Article {n}')\n    slug = factory.LazyAttribute(lambda obj: slugify(obj.title))",
+    "documentation": "Données de test pré-remplies ou générées dynamiquement (factories) pour mettre la base de données dans un état connu avant les tests.",
+    "documentation_officielle": "Une fixture est une collection de données que Django peut charger dans la base de données. C'est utile pour charger des données de test initiales."
+  },
+  {
+    "terms": [
+      "i18n",
+      "traduction",
+      "translation",
+      "multilingue",
+      "langue"
+    ],
+    "instruction": "INTENT DETECTED: INTERNATIONALIZATION. Gérer les traductions avec i18n.",
+    "example_output": "from django.utils.translation import gettext_lazy as _\n\nclass Article(models.Model):\n    title = models.CharField(_('titre'), max_length=200)\n    \n    class Meta:\n        verbose_name = _('article')\n        verbose_name_plural = _('articles')",
+    "documentation": "Processus de conception de l'application pour qu'elle puisse être adaptée à différentes langues et régions sans modifications techniques.",
+    "documentation_officielle": "L'internationalisation (i18n) est le processus de conception d'une application logicielle afin qu'elle puisse être adaptée à diverses langues et régions sans modification technique."
+  },
+  {
+    "terms": [
+      "wagtail localize",
+      "traduction wagtail",
+      "multilingual"
+    ],
+    "instruction": "INTENT DETECTED: WAGTAIL LOCALIZE. Configurer wagtail-localize pour traductions de pages.",
+    "example_output": "# settings.py\nINSTALLED_APPS += ['wagtail_localize']\n\n# models.py\nfrom wagtail_localize.fields import TranslatableField\n\nclass ArticlePage(Page):\n    translatable_fields = [\n        TranslatableField('title'),\n        TranslatableField('body'),\n    ]",
+    "documentation": "Extension Wagtail facilitant la traduction de contenu avec synchronisation des arbres de pages et intégration d'outils de traduction.",
+    "documentation_officielle": "Wagtail Localize est un plugin qui facilite la traduction du contenu Wagtail en intégrant des services de traduction et en synchronisant les arbres de pages."
+  },
+  {
+    "terms": [
+      "workflow",
+      "flux travail",
+      "modération",
+      "approbation"
+    ],
+    "instruction": "INTENT DETECTED: WORKFLOW. Configurer des workflows de modération Wagtail.",
+    "example_output": "from wagtail.models import WorkflowState\n\nclass ArticlePage(Page):\n    def get_workflow(self):\n        return Workflow.objects.get(name='Article Approval')",
+    "documentation": "Système permettant de définir des étapes de validation (ex: rédaction -> révision -> publication) avant la mise en ligne.",
+    "documentation_officielle": "Les workflows permettent de définir des processus de modération personnalisés pour les pages, impliquant plusieurs étapes d'approbation avant la publication."
+  },
+  {
+    "terms": [
+      "révision",
+      "version",
+      "historique"
+    ],
+    "instruction": "INTENT DETECTED: REVISIONS. Gérer les révisions de page Wagtail.",
+    "example_output": "# Récupérer les révisions\nrevisions = page.revisions.all()\n\n# Créer une révision\npage.save_revision()\n\n# Revenir à une révision\nrevision = page.revisions.first()\nrevision.publish()",
+    "documentation": "Wagtail conserve un historique des modifications de chaque page, permettant de comparer ou de revenir à une version antérieure.",
+    "documentation_officielle": "Wagtail enregistre une copie du contenu de la page (une révision) chaque fois que vous l'enregistrez ou la publiez, permettant de revenir à des états antérieurs."
+  },
+  {
+    "terms": [
+      "modeladmin",
+      "admin personnalisé",
+      "listing admin"
+    ],
+    "instruction": "INTENT DETECTED: MODEL ADMIN. Créer une interface admin personnalisée avec ModelAdmin.",
+    "example_output": "from wagtail.contrib.modeladmin.options import ModelAdmin, modeladmin_register\n\nclass ArticleAdmin(ModelAdmin):\n    model = Article\n    menu_label = 'Articles'\n    menu_icon = 'doc-full'\n    list_display = ('title', 'status', 'created_at')\n    list_filter = ('status', 'created_at')\n    search_fields = ('title', 'content')\n\nmodeladmin_register(ArticleAdmin)",
+    "documentation": "Module `wagtail.contrib.modeladmin` permettant de créer des interfaces CRUD pour n'importe quel modèle Django dans l'admin Wagtail.",
+    "documentation_officielle": "ModelAdmin (désormais remplacé par les Snippets améliorés dans Wagtail récent) permet de créer une interface d'administration complète pour n'importe quel modèle Django."
+  },
+  {
+    "terms": [
+      "viewset wagtail",
+      "custom listing"
+    ],
+    "instruction": "INTENT DETECTED: SNIPPET VIEWSET. Créer un viewset personnalisé pour snippets.",
+    "example_output": "from wagtail.snippets.views.snippets import SnippetViewSet\nfrom wagtail.snippets.models import register_snippet\n\nclass AuthorViewSet(SnippetViewSet):\n    model = Author\n    icon = 'user'\n    list_display = ['name', 'email']\n    search_fields = ['name']\n\nregister_snippet(AuthorViewSet)",
+    "documentation": "Classe permettant de personnaliser l'affichage et la gestion des snippets dans l'admin, unifiant la gestion des modèles.",
+    "documentation_officielle": "Les snippets sont des morceaux de contenu réutilisables (comme des auteurs ou des catégories) qui n'ont pas besoin de faire partie de l'arborescence hiérarchique des pages."
+  },
+  {
+    "terms": [
+      "csrf",
+      "sécurité",
+      "protection"
+    ],
+    "instruction": "INTENT DETECTED: CSRF PROTECTION. Gérer la protection CSRF dans les formulaires.",
+    "example_output": "{% csrf_token %}\n\n# Dans une vue\nfrom django.views.decorators.csrf import csrf_exempt\n\n@csrf_exempt\ndef my_api_view(request):\n    pass",
+    "documentation": "Protection contre les attaques Cross Site Request Forgery. Django exige un jeton CSRF pour toute requête POST provenant d'un formulaire.",
+    "documentation_officielle": "Le middleware CSRF de Django protège contre les attaques de falsification de requête inter-sites (Cross Site Request Forgery) en vérifiant un jeton secret dans chaque requête POST."
+  },
+  {
+    "terms": [
+      "xss",
+      "injection",
+      "sanitize"
+    ],
+    "instruction": "INTENT DETECTED: XSS PROTECTION. Protéger contre les injections XSS.",
+    "example_output": "from django.utils.html import escape\n\n# Dans template\n{{ user_input|escape }}\n\n# Dans code\nescaped = escape(user_input)",
+    "documentation": "Protection contre le Cross Site Scripting. Les templates Django échappent automatiquement les variables, sauf si marquées comme sûres.",
+    "documentation_officielle": "Les templates Django protègent contre les attaques XSS (Cross Site Scripting) en échappant automatiquement les caractères dangereux dans les variables."
+  },
+  {
+    "terms": [
+      "collectstatic",
+      "static files",
+      "fichiers statiques"
+    ],
+    "instruction": "INTENT DETECTED: STATIC FILES. Configurer et collecter les fichiers statiques.",
+    "example_output": "# settings.py\nSTATIC_URL = '/static/'\nSTATIC_ROOT = BASE_DIR / 'staticfiles'\nSTATICFILES_DIRS = [BASE_DIR / 'static']\n\n# Commande\npython manage.py collectstatic --noinput",
+    "documentation": "Fichiers (CSS, JS, images) servis tels quels. En production, `collectstatic` les rassemble en un seul endroit pour être servis efficacement.",
+    "documentation_officielle": "Les fichiers statiques sont des fichiers qui ne changent pas dynamiquement (CSS, JavaScript, images). Django fournit django.contrib.staticfiles pour les gérer."
+  },
+  {
+    "terms": [
+      "wsgi",
+      "asgi",
+      "gunicorn",
+      "production"
+    ],
+    "instruction": "INTENT DETECTED: DEPLOYMENT CONFIG. Configurer le déploiement production.",
+    "example_output": "# gunicorn config\ngunicorn myproject.wsgi:application --bind 0.0.0.0:8000\n\n# settings.py production\nDEBUG = False\nALLOWED_HOSTS = ['example.com']\nSECURE_SSL_REDIRECT = True",
+    "documentation": "Configuration nécessaire pour exécuter Django dans un environnement de production (WSGI/ASGI, serveur web, sécurité).",
+    "documentation_officielle": "Le déploiement de Django nécessite de configurer un serveur WSGI (comme Gunicorn), un serveur web (Nginx), et de s'assurer que les paramètres de sécurité (DEBUG=False) sont corrects."
+  }
+]