Vibe-Coding un backend en 2026 : comment Directus et la compétence nikola66 transforment le langage naturel en schémas de production

# Option A : Installer depuis PyPI (une fois publié)
pip installer directus-compétence

## Option B : Cloner et utiliser directement (actuel)
clone git https://github.com/nikola66/directus-skill.git
## Copiez le package dans votre projet ou ajoutez-le à sys.path

compétences hermes installer directus

les compétences npx ajoutent nikola66/directus-skill

exporter DIRECTUS_URL="https://hub.aratech.ae"
export DIRECTUS_API_TOKEN="user_token_here" # opérations CRUD
export DIRECTUS_ADMIN_TOKEN="admin_token_here" # Gestion des schémas

Construisez-moi un backend [TYPE] avec Directus. Créez ces collections :

1. [Nom de la collection] - [objectif]
   - nom_champ (type), champ2 (type), ...
   - relations : [détails de la relation]

2. [Nom de la collection] - ...
   ...

Après avoir créé toutes les collections :
- Vérifiez en appelant get_collections() et en imprimant la liste
- Seed [N] enregistrements d'échantillons pour chaque collection
- Afficher le script Python complet

Construisez-moi un backend de blog multilingue avec Directus. Créez ces collections :

1. Blog_Authors - profils d'auteurs
   - nom (chaîne), slug (chaîne, unique), bio (texte), avatar (fichier), social_twitter (chaîne, nullable)
   - statut : brouillon/publié
   - Champs : id, create_at, update_at

2. Blog_Categories - taxonomie hiérarchique
   - nom (chaîne), slug (chaîne, unique), description (texte), catégorie_parent (plusieurs-à-un → Blog_Categories, nullable)
   - icône (chaîne, nom de l'icône), couleur (chaîne, hexadécimal)
   - Champs : id, sort_order

3. Blog_Tags - balises plates
   - nom (chaîne), slug (chaîne, unique), couleur (chaîne, hexadécimal)
   - Champs : identifiant

4. Blog_Posts - enregistrements parents (métadonnées uniquement, selon notre conception de schéma)
   - statut (brouillon/publié), publié_at (dateheure, nullable)
   - auteur (plusieurs-à-un → Blog_Authors), catégorie (plusieurs-à-un → Blog_Categories)
   - feature_image (fichier), Reading_time_minutes (entier)
   - is_featured (booléen), is_pillar (booléen)
   - Champs : id, create_at, update_at

5. Blog_Posts_Translations - contenu par langue (enregistrements enfants)
   - blog_posts_id (entier FK → Blog_Posts), langues_code (chaîne : en/ar/de/es/fr)
   - titre (chaîne), slug (chaîne), contenu (texte markdown)
   - extrait (texte, max 200 caractères), key_takeaways (tableau json, 3-5 éléments)
   - méta_titre (chaîne, ≤60), méta_description (chaîne, ≤160)
   - feature_image_alt (chaîne)
   - cta_headline (chaîne), cta_button_text (chaîne), cta_button_url (chaîne)
   - schema_markup (json - Article schema.org)
   - Champs : identifiant

6. Blog_Posts_Tags - jonction pour les articles plusieurs-à-plusieurs ↔ tag
   - blog_posts_id (FK → Blog_Posts), blog_tags_id (FK → Blog_Tags)
   - Champs : identifiant

Important :
- Utilisez create_collection() pour les 6 collections
- Chaque champ doit inclure le schéma : {} et la méta : {} dans la charge utile
- Définir TOUS les champs à l'avance (aucun champ incrémentiel n'est ajouté)
- Après avoir créé des collections, lancez au minimum 2 exemples d'articles de blog :
  * Post 1 : "Introduction à la sécurité de l'IA" - auteur=1, catégorie=33 (IA et LLM), publié
  * Post 2 : « Comprendre la conformité SOC 2 » – auteur = 1, catégorie = 37 (Conformité), brouillon
  * Pour chaque article, créez uniquement la traduction EN (ignorez AR/DE/ES/FR pour l'instant)
- Vérification de l'impression : répertoriez toutes les collections et leur nombre d'enregistrements

à partir de directus.client importer DirectusClient
importer le système d'exploitation

client = DirectusClient(
    url=os.getenv('DIRECTUS_URL'),
    token=os.getenv('DIRECTUS_ADMIN_TOKEN') # jeton d'administrateur pour les opérations de schéma
)

## 1. Blog_Auteurs
client.create_collection('Blog_Authors', champs=[
    {'field' : 'id', 'type' : 'entier', 'schema' : {'is_primary_key' : True, 'has_auto_increment' : True}, 'meta' : {'hidden' : True, 'interface' : 'numeric', 'readonly' : True}},
    {'field' : 'nom', 'type' : 'string', 'schema' : {}, 'meta' : {'interface' : 'input'}},
    {'field' : 'slug', 'type' : 'string', 'schema' : {'is_unique' : True}, 'meta' : {'interface' : 'input'}},
    {'field' : 'bio', 'type' : 'text', 'schema' : {}, 'meta' : {'interface' : 'textarea'}},
    {'field' : 'avatar', 'type' : 'file', 'schema' : {}, 'meta' : {'interface' : 'file', 'options' : {'accepted_files' : 'image/*'}}},
    {'field' : 'social_twitter', 'type' : 'string', 'schema' : {}, 'meta' : {'interface' : 'input'}},
    {'field' : 'status', 'type' : 'string', 'schema' : {}, 'meta' : {'interface' : 'select', 'options' : {'choices' : ['draft', 'published']}}},
    {'field' : 'created_at', 'type' : 'timestamp', 'schema' : {}, 'meta' : {'interface' : 'datetime', 'readonly' : True}},
    {'field' : 'updated_at', 'type' : 'timestamp', 'schema' : {}, 'meta' : {'interface' : 'datetime', 'readonly' : True}}
])

## 2. Blog_Catégories
client.create_collection('Blog_Categories', champs=[
    {'field' : 'id', 'type' : 'entier', 'schema' : {'is_primary_key' : True, 'has_auto_increment' : True}, 'meta' : {'hidden' : True, 'interface' : 'numeric', 'readonly' : True}},
    {'field' : 'nom', 'type' : 'string', 'schema' : {}, 'meta' : {'interface' : 'input'}},
    {'field' : 'slug', 'type' : 'string', 'schema' : {'is_unique' : True}, 'meta' : {'interface' : 'input'}},
    {'field' : 'description', 'type' : 'texte', 'schema' : {}, 'meta' : {'interface' : 'textarea'}},
    {'field' : 'parent_category', 'type' : 'entier', 'schema' : {}, 'meta' : {'interface' : 'relation', 'options' : {'rated_collection' : 'Blog_Categories'}}},
    {'field' : 'icon', 'type' : 'string', 'schema' : {}, 'meta' : {'interface' : 'input'}},
    {'field' : 'color', 'type' : 'string', 'schema' : {}, 'meta' : {'interface' : 'color'}},
    {'field' : 'sort_order', 'type' : 'entier', 'schema' : {}, 'meta' : {'interface' : 'numeric'}},
    {'field' : 'created_at', 'type' : 'timestamp', 'schema' : {}, 'meta' : {'interface' : 'datetime', 'readonly' : True}},
    {'field' : 'updated_at', 'type' : 'timestamp', 'schema' : {}, 'meta' : {'interface' : 'datetime', 'readonly' : True}}
])

## 3. Blog_Tags
client.create_collection('Blog_Tags', champs=[
    {'field' : 'id', 'type' : 'entier', 'schema' : {'is_primary_key' : True, 'has_auto_increment' : True}, 'meta' : {'hidden' : True, 'interface' : 'numeric', 'readonly' : True}},
    {'field' : 'nom', 'type' : 'string', 'schema' : {}, 'meta' : {'interface' : 'input'}},
    {'field' : 'slug', 'type' : 'string', 'schema' : {'is_unique' : True}, 'meta' : {'interface' : 'input'}},
    {'field' : 'color', 'type' : 'string', 'schema' : {}, 'meta' : {'interface' : 'color'}},
    {'field' : 'created_at', 'type' : 'timestamp', 'schema' : {}, 'meta' : {'interface' : 'datetime', 'readonly' : True}}
])

## 4. Blog_Posts - enregistrement de métadonnées parent
client.create_collection('Blog_Posts', champs=[
    {'field' : 'id', 'type' : 'entier', 'schema' : {'is_primary_key' : True, 'has_auto_increment' : True}, 'meta' : {'hidden' : True, 'interface' : 'numeric', 'readonly' : True}},
    {'field' : 'status', 'type' : 'string', 'schema' : {}, 'meta' : {'interface' : 'select', 'options' : {'choices' : ['draft', 'published']}}},
    {'field' : 'published_at', 'type' : 'timestamp', 'schema' : {}, 'meta' : {'interface' : 'datetime', 'readonly' : False}},
    {'field' : 'auteur', 'type' : 'entier', 'schema' : {}, 'meta' : {'interface' : 'relation', 'options' : {'rated_collection' : 'Blog_Authors'}}},
    {'field' : 'category', 'type' : 'entier', 'schema' : {}, 'meta' : {'interface' : 'relation', 'options' : {'rated_collection' : 'Blog_Categories'}}},
    {'field' : 'featured_image', 'type' : 'file', 'schema' : {}, 'meta' : {'interface' : 'file', 'options' : {'accepted_files' : 'image/*'}}},
    {'field' : 'reading_time_minutes', 'type' : 'entier', 'schema' : {}, 'meta' : {'interface' : 'numeric'}},
    {'field' : 'is_featured', 'type' : 'boolean', 'schema' : {}, 'meta' : {'interface' : 'boolean'}},
    {'field' : 'is_pillar', 'type' : 'boolean', 'schema' : {}, 'meta' : {'interface' : 'boolean'}},
    {'field' : 'created_at', 'type' : 'timestamp', 'schema' : {}, 'meta' : {'interface' : 'datetime', 'readonly' : True}},
    {'field' : 'updated_at', 'type' : 'timestamp', 'schema' : {}, 'meta' : {'interface' : 'datetime', 'readonly' : True}}
])

## 5. Blog_Posts_Translations - contenu par langue
client.create_collection('Blog_Posts_Translations', champs=[
    {'field' : 'id', 'type' : 'entier', 'schema' : {'is_primary_key' : True, 'has_auto_increment' : True}, 'meta' : {'hidden' : True, 'interface' : 'numeric', 'readonly' : True}},
    {'field' : 'blog_posts_id', 'type' : 'entier', 'schema' : {}, 'meta' : {'interface' : 'relation', 'options' : {'relied_collection' : 'Blog_Posts'}}},
    {'field' : 'code_langues', 'type' : 'string', 'schema' : {}, 'meta' : {'interface' : 'select', 'options' : {'choices' : ['en', 'ar', 'de', 'es', 'fr']}}},
    {'field' : 'titre', 'type' : 'string', 'schema' : {'is_required' : True}, 'meta' : {'interface' : 'input'}},
    {'field' : 'slug', 'type' : 'string', 'schema' : {'is_required' : True, 'is_unique' : True}, 'meta' : {'interface' : 'input'}},
    {'field' : 'content', 'type' : 'text', 'schema' : {}, 'meta' : {'interface' : 'markdown'}},
    {'field' : 'extrait', 'type' : 'text', 'schema' : {}, 'meta' : {'interface' : 'textarea'}},
    {'field' : 'key_takeaways', 'type' : 'json', 'schema' : {}, 'meta' : {'interface' : 'list'}},
    {'field' : 'meta_title', 'type' : 'string', 'schema' : {}, 'meta' : {'interface' : 'input'}},
    {'field' : 'meta_description', 'type' : 'texte', 'schema' : {}, 'meta' : {'interface' : 'textarea'}},
    {'field' : 'featured_image_alt', 'type' : 'text', 'schema' : {}, 'meta' : {'interface' : 'textarea'}},
    {'field' : 'cta_headline', 'type' : 'string', 'schema' : {}, 'meta' : {'interface' : 'input'}},
    {'field' : 'cta_button_text', 'type' : 'string', 'schema' : {}, 'meta' : {'interface' : 'input'}},
    {'field' : 'cta_button_url', 'type' : 'string', 'schema' : {}, 'meta' : {'interface' : 'input'}},
    {'field' : 'schema_markup', 'type' : 'json', 'schema' : {}, 'meta' : {'interface' : 'json'}},
    {'field' : 'created_at', 'type' : 'timestamp', 'schema' : {}, 'meta' : {'interface' : 'datetime', 'readonly' : True}},
    {'field' : 'updated_at', 'type' : 'timestamp', 'schema' : {}, 'meta' : {'interface' : 'datetime', 'readonly' : True}}
])

## 6. Blog_Posts_Tags - table de jonction
client.create_collection('Blog_Posts_Tags', champs=[
    {'field' : 'id', 'type' : 'entier', 'schema' : {'is_primary_key' : True, 'has_auto_increment' : True}, 'meta' : {'hidden' : True, 'interface' : 'numeric', 'readonly' : True}},
    {'field' : 'blog_posts_id', 'type' : 'entier', 'schema' : {}, 'meta' : {'interface' : 'relation', 'options' : {'relied_collection' : 'Blog_Posts'}}},
    {'field' : 'blog_tags_id', 'type' : 'entier', 'schema' : {}, 'meta' : {'interface' : 'relation', 'options' : {'rated_collection' : 'Blog_Tags'}}},
    {'field' : 'created_at', 'type' : 'timestamp', 'schema' : {}, 'meta' : {'interface' : 'datetime', 'readonly' : True}}
])

## Données d'échantillon de départ
## 1. Créer un auteur (s'il n'existe pas)
author = client.insert({'name' : 'Alex Chen', 'slug' : 'alex-chen', 'bio' : 'Ingénieur en sécurité chez Ainex.', 'statut' : 'publié'}, collection='Blog_Authors')
auteur_id = auteur['id']

## 2. Créer une catégorie
category = client.insert({'name' : 'AI & LLM', 'slug' : 'ai-llms', 'description' : 'Articles sur la sécurité de l'IA et les LLM.', 'sort_order' : 1}, collection='Blog_Categories')
catégorie_id = catégorie['id']

## 3. Créer un enregistrement d'article de blog parent
post = client.insert({
    'statut' : 'publié',
    'auteur' : auteur_id,
    'catégorie' : id_catégorie,
    'reading_time_minutes' : 8,
    'is_featured' : faux,
    'publié_à' : '2026-05-03T10:00:00.000Z'
}, collection='Blog_Posts')
post_id = post['id']

## 4. Créer une traduction en anglais
client.insert({
    'blog_posts_id' : post_id,
    'code_langues' : 'fr',
    'title' : 'Introduction à la sécurité de l'IA',
    'slug' : 'introduction à la sécurité ai',
    'content': '# Fondements de la sécurité de l'IA\n\nCeci est un exemple d'article sur la sécurisation des systèmes d'IA...\n\n## Risques clés\n\n- Injection rapide\n- Fuite de données\n- Empoisonnement du modèle\n\n## Meilleures pratiques\n\nToujours valider les entrées, l'exécution du modèle sandbox et surveiller les anomalies.',
    'extrait': 'Un guide convivial pour les débutants pour comprendre et atténuer les risques du système d'IA.',
    'key_takeaways' : ['Les systèmes d'IA sont vulnérables aux attaques par injection rapide', 'Toujours valider et nettoyer les entrées du modèle', 'Surveiller le comportement anormal du modèle'],
    'meta_title' : 'Introduction à la sécurité de l'IA - Guide Ainex',
    'meta_description': 'Découvrez les principes fondamentaux de la sécurité de l'IA, les menaces courantes et les meilleures pratiques pour protéger vos applications LLM.',
    'featured_image_alt': 'Visualisation abstraite de la sécurité des réseaux neuronaux',
    'cta_headline': 'Prêt à sécuriser votre IA ?',
    'cta_button_text': 'Commencer',
    'cta_button_url' : '/get-started',
    'schema_markup' : {
        '@context' : 'https://schema.org',
        '@type' : 'Article',
        'headline' : 'Introduction à la sécurité de l'IA',
        'auteur' : {'@type' : 'Personne', 'nom' : 'Alex Chen'},
        'date de publication' : '2026-05-03T10:00:00.000Z',
        'description' : "Un guide convivial pour les débutants pour comprendre et atténuer les risques du système d'IA."
    }
}, collection='Blog_Posts_Translations')

print(f"✅ Backend du blog créé ! ID de publication : {post_id}")

Créez un backend de commerce électronique de production avec Directus. Créez ces collections :

1. **Produits** - articles du catalogue
   - titre, slug (unique), description (texte), statut (projet/disponible/out_of_stock)
   - price_cents (entier), compare_price_cents (entier nullable), cost_cents (entier)
   - sku (unique), code-barres (nullable), poids_grammes (entier)
   - Inventory_quantity, low_stock_threshold (par défaut 10)
   - feature_image (fichier), images (M2M via jonction)
   - catégorie (M2O → Catégories), tags (M2M → Tags via jonction)
   - publié_à

2. **Catégories** - taxonomie imbriquée
   - nom, slug (unique), description, parent_category (nullable M2O self)
   - image (fichier), sort_order

3. **Balises** - balises de produits
   - nom, slug (unique), couleur (hex)

4. **Clients** - comptes
   - email (unique), prénom, nom, téléphone
   - default_shipping_address (json), default_billing_address (json)
   - total_spent_cents, order_count, last_order_at (nullable)
   - statut (actif/bloqué), notes

5. **Commandes** - transactions
   - numéro_commande (unique), statut (en attente/en traitement/expédié/livré/annulé)
   - client (M2O → Clients)
   - subtotal_cents, tax_cents, shipping_cents, total_cents, discount_cents
   - adresse_expédition, adresse_facturation (json)
   - payment_status (payé/remboursé/échoué), payment_method (stripe/paypal/manuel)
   - payment_intent_id (nullable), tracking_number (nullable)
   - notes, Cancelled_at (nullable)

6. **Order_Items** - éléments de campagne (table de jonction Commandes ↔ Produits)
   - commande (M2O → Commandes), produit (M2O → Produits)
   - quantité, unit_price_cents, total_price_cents
   - nom_variante (chaîne, nullable)

7. **Inventory_Adjustments** - journal d'audit
   - produit (M2O → Produits), motif (réapprovisionnement/vente/retour/audit/ajustement)
   - delta_quantity, previous_quantity, new_quantity
   - reference_id (nullable - liens vers la commande/ajustement), notes

8. **Collections** - regroupements organisés
   - nom, slug (unique), handle (chaîne conviviale pour l'API)
   - type (manuel/automatique), règles (json pour les règles automatiques)
   - sort_order, publié (booléen)

9. **Réductions** - codes promotionnels
   - code (unique, nullable pour automatique), type (pourcentage/fixe)
   - valeur (int - pourcentage ou cents), max_uses, used_count
   - valid_from, valid_until (nullable)
   - apply_to (all/categories/products), applicable_product_ids (tableau json)
   - min_order_amount_cents (nullable), Exclure_sale_items (booléen)

Contraintes :
- Utilisez create_collection() pour les 9 collections + tables de jonction explicites (Products_Images si nécessaire)
- Chaque champ : incluez le schéma : {} et la méta : {} à l'avance
- Utilisez les types de champs Directus appropriés : entier, chaîne, texte, booléen, date/heure, json, fichier, pivot
- Ajouter des index uniques sur slug, sku, order_number
- Seed : créez 3 exemples de produits avec des exemples d'images (utilisez les ID de fichier si disponibles), lien vers la catégorie
- Vérifier : appelez get_collections() et imprimez le nombre d'enregistrements
- Afficher le script Python complet

Créez un backend CRM avec Directus :

1. Entreprises
   - nom, domaine (unique), secteur d'activité, taille (1-10/11-50/51-200/200+)
   - site Web, téléphone, adresse (json), annual_revenue_cents (nullable)
   - propriétaire (M2O → Utilisateurs), statut (lead/client/prospect/baratté)
   - last_contacted_at, notes (texte)

2. Contacts
   - prénom, nom, email (unique), téléphone, titre_emploi
   - entreprise (M2O → Entreprises), propriétaire (M2O → Utilisateurs)
   - statut (actif/inactif/lead), favorite_contact (email/téléphone/linkedin)
   - linkedin_url, notes

3. Interactions
   - contact (M2O → Contacts), tapez (appel/e-mail/réunion/note)
   - direction (entrant/sortant), durée_minutes (entier)
   - résumé (texte), next_steps (texte), due_date (nullable)
   - Related_deal (M2O → Offres nullables)

4. Offres
   - titre, value_cents, étape (proposition/négociation/closed_won/closed_lost)
   - probabilité (0-100), close_date (attendu)
   - contact (M2O → Contacts), propriétaire (M2O → Utilisateurs)
   - remarques

Contraintes :
- Utilisez create_collection() pour les 4
- Tous les champs standards : id, Create_at, Update_at automatiquement ajoutés
- Relations configurées correctement (les FK sont des entiers)
- Seed : 2 entreprises, 4 contacts, 3 interactions, 1 deal

{
    'field' : 'price_cents',
    'type' : 'entier',
    'schema' : {'is_required' : True}, # ← toujours inclure ceci
    'meta' : {'interface' : 'numeric'} # ← toujours inclure ceci
}

{ Blog_Posts_Translations { identifiant blog_posts_id } }

client.get_expanded(
    field=['id', 'title', 'blog_posts_id.id', 'blog_posts_id.status'],
    collection='Blog_Posts_Translations',
    limite=50
)
## Renvoie les dicts : blog_posts_id = {'id' : '5', 'status' : 'published'}

client.insert({
    'blog_posts_id' : int(post_id), # PAS post_id
    'code_langues' : 'fr',
    ...
}, collection='Blog_Posts_Translations')

## FAUX : Le PATCH direct sur Blog_Posts échoue
client.update(post_id, {'tags': [1, 2, 3]}, collection='Blog_Posts') # ❌ 403

## CORRECT : Insérer dans la table de jonction
pour tag_id dans [1, 2, 3] :
    client.insert({'blog_posts_id' : post_id, 'blog_tags_id' : tag_id}, collection='Blog_Posts_Tags')

## Étape 1 : parent (métadonnées uniquement)
post = client.insert({
    'statut' : 'publié',
    'auteur' : auteur_id,
    'catégorie' : id_catégorie,
    'reading_time_minutes' : 8
}, collection='Blog_Posts')

post_id = post['id']

## Étape 2 : traduction (contenu réel)
client.insert({
    'blog_posts_id' : post_id,
    'code_langues' : 'fr',
    'title' : 'Mon message',
    'slug' : 'mon-post',
    'content': '# Bonjour tout le monde...',
    ...
}, collection='Blog_Posts_Translations')

## Étape A : Créer (risque de troncature)
trans = client.insert({ ... initial_fields ..., 'content': 'short placeholder' }, collection='Blog_Posts_Translations')
trans_id = trans['id']

## Étape B : CORRIGER le contenu complet (contourne la troncature)
client.update(trans_id, {'content': full_markdown_body}, collection='Blog_Posts_Translations')

## Envoyer un enregistrement de test minimal
test = {'statut' : 'projet', 'auteur' : 1, 'catégorie' : 33}
test_record = client.insert(test, collection='Blog_Posts')
test_id = test_record['id']

## En cas de succès, supprimez-le
client.delete(test_id, hard=True, collection='Blog_Posts')
print('✅ Accès en écriture confirmé')

## Égal
résultats = client.get(
    champs=['id', 'titre', 'statut'],
    filters={'statut' : {'_eq' : 'publié'}},
    collection='Blog_Posts',
    limite=10
)

## Pas égal
drafts = client.get(filters={'status' : {'_neq' : 'published'}}, collection='Blog_Posts')

## Contient (insensible à la casse)
recherche = client.get(
    filters={'title' : {'_icontains' : 'sécurité'}},
    collection='Blog_Posts'
)

## Dans la liste
résultats = client.get(
    filters={'category': {'_in': [33, 37, 42]}},
    collection='Blog_Posts'
)

## Supérieur à
cher = client.get(
    filters={'price_cents' : {'_gt' : 10000}},
    collection='Produits'
)

## Vérification nulle
non contacté = client.get(
    filters={'last_contacted_at' : {'_null' : True}},
    collection='Contacts'
)

## Combiné (ET ensemble)
résultats = client.get(
    filtres={
        'statut' : {'_eq' : 'publié'},
        'catégorie' : {'_in' : [33, 37]},
        'published_at' : {'_not_null' : Vrai}
    },
    collection='Blog_Posts'
)

## Récupérer les publications avec l'auteur, la catégorie et les balises
enregistrements = client.get_expanded(
    champs=[
        'identifiant', 'titre', 'statut',
        'auteur.id', 'auteur.nom', 'auteur.email', # relation M2O
        'category.id', 'category.name', # relation M2O
        'tags.id', 'tags.name', 'tags.slug' # M2M via jonction
    ],
    collection='Blog_Posts',
    limite=20
)
## Résultat : chaque enregistrement a des dicts imbriqués comme {'author' : {'id' : 1, 'name' : 'Alex'}, 'tags' : [{'id' : 5, 'name' : 'AI'}, ...]}

client.insert({
    'adresse_d'expédition' : {
        'rue' : '123 Tech Blvd',
        'ville' : 'Dubaï',
        'pays' : 'EAU',
        'code_postal' : '00000'
    },
    'métadonnées' : {
        'utm_source' : 'newsletter',
        'campaign_id' : 'Q2-2026-ai-launch'
    }
}, collection='Commandes')

client = DirectusClient(
    url=os.getenv('DIRECTUS_URL'),
    token=os.getenv('DIRECTUS_API_TOKEN'), # pour CRUD
    admin_token=os.getenv('DIRECTUS_ADMIN_TOKEN') # pour le schéma
)

## Créer une nouvelle collection
client.create_collection('TEST_Items', champs=[
    {'field' : 'id', 'type' : 'entier', 'schema' : {'is_primary_key' : True, 'has_auto_increment' : True}, 'meta' : {'hidden' : True, 'interface' : 'numeric', 'readonly' : True}},
    {'field' : 'nom', 'type' : 'string', 'schema' : {}, 'meta' : {'interface' : 'input'}},
    {'champ' : 'valeur', 'type' : 'entier', 'schéma' : {}, 'méta' : {'interface' : 'numérique'}}
])

## Ajouter un champ à la collection existante (à utiliser avec prudence - peut corrompre le schéma GraphQL)
client.create_field('TEST_Items', 'description', 'text', meta={'interface' : 'textarea'})

## Liste toutes les collections
collections = client.get_collections()
print(collections) # ['Blog_Posts', 'Blog_Authors', ...]

## Obtenir le schéma de collecte
schéma = client.get_collection_schema('Blog_Posts')
print(schema['fields'].keys()) # dict_keys(['id', 'status', 'author', ...])

#1. Démarrez votre terminal (avec les tokens Directus en env)
$export DIRECTUS_URL="https://hub.aratech.ae"
$ export DIRECTUS_API_TOKEN="sZk-st..." # jeton utilisateur
$ export DIRECTUS_ADMIN_TOKEN="ad-..." # jeton d'administrateur

## 2. Lancer l'agent Hermès
$ hermès

## 3. Donnez l'invite (copier-coller d'en haut)
Vous : Construisez-moi un backend de blog avec Directus. Créez ces collections : ...

## 4. L'agent réfléchit, génère un script, exécute
🤖 Agent : Création de Blog_Authors... ✅
   Création de Blog_Catégories... ✅
   Création de Blog_Tags... ✅
   Création de Blog_Posts... ✅
   Création de Blog_Posts_Translations... ✅
   Création de Blog_Posts_Tags... ✅
   Seeding 2 exemples de posts... ✅
   
   Vérification :
   - Blog_Posts : 2 enregistrements
   - Blog_Posts_Translations : 2 enregistrements (en uniquement)
   - Blog_Auteurs : 1 enregistrement
   - Blog_Catégories : 1 enregistrement
   - Blog_Tags : 0 enregistrements
   
   ✅ Backend échafaudé avec succès ! Votre panneau d'administration Directus sur https://hub.aratech.ae/admin affiche désormais toutes les collections renseignées.

## 5. Vous avez terminé. Vérifiez l'interface utilisateur ou la requête d'administration :
$ python3 -c "de directus.client import DirectusClient; c = DirectusClient(); print(c.get(collection='Blog_Posts', limit=3))"