Vibe-Coding un backend en 2026: cómo Directus y la habilidad nikola66 convierten el lenguaje natural en esquemas de producción

# Opción A: Instalar desde PyPI (cuando se publique)
pip instalar directus-habilidad

## Opción B: Clonar y usar directamente (actual)
clon de git https://github.com/nikola66/directus-skill.git
## Copie el paquete en su proyecto o agréguelo a sys.path

habilidades de hermes instalar directo

Las habilidades de npx agregan nikola66/directus-skill

exportar DIRECTUS_URL="https://hub.aratech.ae"
exportar DIRECTUS_API_TOKEN="user_token_here" # operaciones CRUD
export DIRECTUS_ADMIN_TOKEN="admin_token_here" # Gestión de esquemas

Constrúyeme un backend [TIPO] con Directus. Crea estas colecciones:

1. [Nombre de la colección] - [propósito]
   - nombre_campo (tipo), campo2 (tipo), ...
   - relaciones: [detalles de la relación]

2. [Nombre de la colección] - ...
   ...

Después de crear todas las colecciones:
- Verifique llamando a get_collections() e imprimiendo la lista
- Semillas [N] registros de muestra para cada colección
- Generar el script Python completo

Constrúyeme un backend de blog multilingüe con Directus. Crea estas colecciones:

1. Blog_Authors - perfiles de autor
   - nombre (cadena), slug (cadena, único), biografía (texto), avatar (archivo), social_twitter (cadena, anulable)
   - estado: borrador/publicado
   - Campos: id, creado_at, actualizado_at

2. Blog_Categories: taxonomía jerárquica
   - nombre (cadena), slug (cadena, único), descripción (texto), parent_category (varios a uno → Blog_Categories, anulable)
   - icono (cadena, nombre del icono), color (cadena, hexadecimal)
   - Campos: id, sort_order

3. Blog_Tags: etiquetas planas
   - nombre (cadena), slug (cadena, único), color (cadena, hexadecimal)
   - Campos: identificación

4. Blog_Posts: registros principales (solo metadatos, según nuestro diseño de esquema)
   - estado (borrador/publicado), publicado_en (fecha y hora, anulable)
   - autor (varios a uno → Blog_Authors), categoría (varios a uno → Blog_Categories)
   - imagen_presentada (archivo), minutos_tiempo_lectura (entero)
   - is_featured (booleano), is_pillar (booleano)
   - Campos: id, creado_at, actualizado_at

5. Blog_Posts_Translations: contenido por idioma (registros secundarios)
   - blog_posts_id (entero FK → Blog_Posts), idiomas_code (cadena: en/ar/de/es/fr)
   - título (cadena), slug (cadena), contenido (texto de rebajas)
   - extracto (texto, máximo 200 caracteres), key_takeaways (matriz json, 3-5 elementos)
   - meta_title (cadena, ≤60), meta_description (cadena, ≤160)
   -feature_image_alt (cadena)
   - cta_headline (cadena), cta_button_text (cadena), cta_button_url (cadena)
   - esquema_markup (json - Artículo esquema.org)
   - Campos: identificación

6. Blog_Posts_Tags: unión para publicaciones de muchos a muchos ↔ etiqueta
   - blog_posts_id (FK → Blog_Posts), blog_tags_id (FK → Blog_Tags)
   - Campos: identificación

Importante:
- Utilice create_collection() para las 6 colecciones.
- Cada campo debe incluir esquema: {} y meta: {} en la carga útil
- Defina TODOS los campos por adelantado (no se agregan campos incrementales)
- Después de crear colecciones, genere un mínimo de 2 publicaciones de blog de muestra:
  * Publicación 1: "Introducción a la seguridad de la IA" - autor=1, categoría=33 (IA y LLM), publicada
  * Publicación 2: "Comprensión del cumplimiento de SOC 2" - autor=1, categoría=37 (Cumplimiento), borrador
  * Para cada publicación, cree solo traducción EN (omita AR/DE/ES/FR por ahora)
- Verificación de impresión: enumera todas las colecciones y sus recuentos de registros

desde directus.client importar DirectusClient
importar sistema operativo

cliente = DirectusCliente(
    url=os.getenv('DIRECTUS_URL'),
    token=os.getenv('DIRECTUS_ADMIN_TOKEN') # token de administrador para operaciones de esquema
)

## 1. Blog_Autores
client.create_collection('Blog_Authors', campos=[
    {'field': 'id', 'type': 'integer', 'schema': {'is_primary_key': True, 'has_auto_increment': True}, 'meta': {'hidden': True, 'interface': 'numeric', 'readonly': True}},
    {'campo': 'nombre', 'tipo': 'cadena', 'esquema': {}, 'meta': {'interfaz': 'entrada'}},
    {'field': 'slug', 'type': 'string', 'schema': {'is_unique': True}, 'meta': {'interface': 'input'}},
    {'campo': 'bio', 'tipo': 'texto', 'esquema': {}, 'meta': {'interfaz': 'textarea'}},
    {'campo': 'avatar', 'tipo': 'archivo', 'esquema': {}, 'meta': {'interfaz': 'archivo', 'opciones': {'accepted_files': 'image/*'}}},
    {'campo': 'social_twitter', 'tipo': 'cadena', 'esquema': {}, 'meta': {'interfaz': 'entrada'}},
    {'campo': 'estado', 'tipo': 'cadena', 'esquema': {}, 'meta': {'interfaz': 'seleccionar', 'opciones': {'opciones': ['borrador', 'publicado']}}},
    {'field': 'created_at', 'type': 'timestamp', 'schema': {}, 'meta': {'interface': 'datetime', 'readonly': True}},
    {'campo': 'updated_at', 'tipo': 'marca de tiempo', 'esquema': {}, 'meta': {'interfaz': 'fecha y hora', 'solo lectura': Verdadero}}
])

## 2. Blog_Categorías
client.create_collection('Categorías_Blog', campos=[
    {'field': 'id', 'type': 'integer', 'schema': {'is_primary_key': True, 'has_auto_increment': True}, 'meta': {'hidden': True, 'interface': 'numeric', 'readonly': True}},
    {'campo': 'nombre', 'tipo': 'cadena', 'esquema': {}, 'meta': {'interfaz': 'entrada'}},
    {'field': 'slug', 'type': 'string', 'schema': {'is_unique': True}, 'meta': {'interface': 'input'}},
    {'campo': 'descripción', 'tipo': 'texto', 'esquema': {}, 'meta': {'interfaz': 'textarea'}},
    {'field': 'parent_category', 'type': 'integer', 'schema': {}, 'meta': {'interface': 'relation', 'options': {' related_collection': 'Blog_Categories'}}},
    {'campo': 'icono', 'tipo': 'cadena', 'esquema': {}, 'meta': {'interfaz': 'entrada'}},
    {'campo': 'color', 'tipo': 'cadena', 'esquema': {}, 'meta': {'interfaz': 'color'}},
    {'field': 'sort_order', 'type': 'integer', 'schema': {}, 'meta': {'interface': 'numeric'}},
    {'field': 'created_at', 'type': 'timestamp', 'schema': {}, 'meta': {'interface': 'datetime', 'readonly': True}},
    {'campo': 'updated_at', 'tipo': 'marca de tiempo', 'esquema': {}, 'meta': {'interfaz': 'fecha y hora', 'solo lectura': Verdadero}}
])

## 3. Etiquetas de blog
client.create_collection('Blog_Tags', campos=[
    {'field': 'id', 'type': 'integer', 'schema': {'is_primary_key': True, 'has_auto_increment': True}, 'meta': {'hidden': True, 'interface': 'numeric', 'readonly': True}},
    {'campo': 'nombre', 'tipo': 'cadena', 'esquema': {}, 'meta': {'interfaz': 'entrada'}},
    {'field': 'slug', 'type': 'string', 'schema': {'is_unique': True}, 'meta': {'interface': 'input'}},
    {'campo': 'color', 'tipo': 'cadena', 'esquema': {}, 'meta': {'interfaz': 'color'}},
    {'campo': 'created_at', 'tipo': 'marca de tiempo', 'esquema': {}, 'meta': {'interfaz': 'fecha y hora', 'solo lectura': Verdadero}}
])

## 4. Blog_Posts: registro de metadatos principal
client.create_collection('Blog_Posts', campos=[
    {'field': 'id', 'type': 'integer', 'schema': {'is_primary_key': True, 'has_auto_increment': True}, 'meta': {'hidden': True, 'interface': 'numeric', 'readonly': True}},
    {'campo': 'estado', 'tipo': 'cadena', 'esquema': {}, 'meta': {'interfaz': 'seleccionar', 'opciones': {'opciones': ['borrador', 'publicado']}}},
    {'field': 'published_at', 'type': 'timestamp', 'schema': {}, 'meta': {'interface': 'datetime', 'readonly': False}},
    {'campo': 'autor', 'tipo': 'entero', 'esquema': {}, 'meta': {'interfaz': 'relación', 'opciones': {' related_collection': 'Blog_Authors'}}},
    {'campo': 'categoría', 'tipo': 'entero', 'esquema': {}, 'meta': {'interfaz': 'relación', 'opciones': {' related_collection': 'Blog_Categories'}}},
    {'campo': 'featured_image', 'tipo': 'archivo', 'esquema': {}, 'meta': {'interfaz': 'archivo', 'opciones': {'accepted_files': 'imagen/*'}}},
    {'campo': 'reading_time_ Minutes', 'tipo': 'entero', 'esquema': {}, 'meta': {'interfaz': 'numérico'}},
    {'campo': 'is_featured', 'tipo': 'booleano', 'esquema': {}, 'meta': {'interfaz': 'booleano'}},
    {'campo': 'is_pillar', 'tipo': 'booleano', 'esquema': {}, 'meta': {'interfaz': 'booleano'}},
    {'field': 'created_at', 'type': 'timestamp', 'schema': {}, 'meta': {'interface': 'datetime', 'readonly': True}},
    {'campo': 'updated_at', 'tipo': 'marca de tiempo', 'esquema': {}, 'meta': {'interfaz': 'fecha y hora', 'solo lectura': Verdadero}}
])

## 5. Blog_Posts_Translations: contenido por idioma
client.create_collection('Blog_Posts_Translations', campos=[
    {'field': 'id', 'type': 'integer', 'schema': {'is_primary_key': True, 'has_auto_increment': True}, 'meta': {'hidden': True, 'interface': 'numeric', 'readonly': True}},
    {'field': 'blog_posts_id', 'type': 'integer', 'schema': {}, 'meta': {'interface': 'relation', 'options': {' related_collection': 'Blog_Posts'}}},
    {'field': 'languages_code', 'type': 'string', 'schema': {}, 'meta': {'interface': 'select', 'options': {'choices': ['en', 'ar', 'de', 'es', 'fr']}}},
    {'campo': 'título', 'tipo': 'cadena', 'esquema': {'is_required': Verdadero}, 'meta': {'interfaz': 'entrada'}},
    {'field': 'slug', 'type': 'string', 'schema': {'is_required': True, 'is_unique': True}, 'meta': {'interface': 'input'}},
    {'campo': 'contenido', 'tipo': 'texto', 'esquema': {}, 'meta': {'interfaz': 'markdown'}},
    {'campo': 'extracto', 'tipo': 'texto', 'esquema': {}, 'meta': {'interfaz': 'textarea'}},
    {'campo': 'key_takeaways', 'tipo': 'json', 'esquema': {}, 'meta': {'interfaz': 'lista'}},
    {'campo': 'meta_title', 'tipo': 'cadena', 'esquema': {}, 'meta': {'interfaz': 'entrada'}},
    {'campo': 'meta_descripción', 'tipo': 'texto', 'esquema': {}, 'meta': {'interfaz': 'textarea'}},
    {'campo': 'featured_image_alt', 'tipo': 'texto', 'esquema': {}, 'meta': {'interfaz': 'textarea'}},
    {'campo': 'cta_headline', 'tipo': 'cadena', 'esquema': {}, 'meta': {'interfaz': 'entrada'}},
    {'campo': 'cta_button_text', 'tipo': 'cadena', 'esquema': {}, 'meta': {'interfaz': 'entrada'}},
    {'campo': 'cta_button_url', 'tipo': 'cadena', 'esquema': {}, 'meta': {'interfaz': 'entrada'}},
    {'campo': 'schema_markup', 'tipo': 'json', 'esquema': {}, 'meta': {'interfaz': 'json'}},
    {'field': 'created_at', 'type': 'timestamp', 'schema': {}, 'meta': {'interface': 'datetime', 'readonly': True}},
    {'campo': 'updated_at', 'tipo': 'marca de tiempo', 'esquema': {}, 'meta': {'interfaz': 'fecha y hora', 'solo lectura': Verdadero}}
])

## 6. Blog_Posts_Tags - tabla de unión
client.create_collection('Blog_Posts_Tags', campos=[
    {'field': 'id', 'type': 'integer', 'schema': {'is_primary_key': True, 'has_auto_increment': True}, 'meta': {'hidden': True, 'interface': 'numeric', 'readonly': True}},
    {'field': 'blog_posts_id', 'type': 'integer', 'schema': {}, 'meta': {'interface': 'relation', 'options': {' related_collection': 'Blog_Posts'}}},
    {'field': 'blog_tags_id', 'type': 'integer', 'schema': {}, 'meta': {'interface': 'relation', 'options': {' related_collection': 'Blog_Tags'}}},
    {'campo': 'created_at', 'tipo': 'marca de tiempo', 'esquema': {}, 'meta': {'interfaz': 'fecha y hora', 'solo lectura': Verdadero}}
])

## Datos de muestra de semillas
## 1. Crear autor (si no existe)
autor = client.insert({'nombre': 'Alex Chen', 'slug': 'alex-chen', 'bio': 'Ingeniero de seguridad en Ainex.', 'status': 'publicado'}, colección = 'Blog_Authors')
autor_id = autor['id']

## 2. Crear categoría
categoría = client.insert({'nombre': 'AI y LLM', 'slug': 'ai-llms', 'descripción': 'Artículos sobre seguridad de IA y LLM.', 'sort_order': 1}, colección = 'Blog_Categories')
categoría_id = categoría['id']

## 3. Crear un registro de publicación de blog para padres
publicación = cliente.insertar({
    'estado': 'publicado',
    'autor': autor_id,
    'categoría': categoría_id,
    'tiempo_lectura_minutos': 8,
    'is_featured': Falso,
    'publicado_en': '2026-05-03T10:00:00.000Z'
}, colección='Blog_Posts')
post_id = publicación['id']

## 4. Crear traducción al inglés
cliente.insertar({
    'blog_posts_id': post_id,
    'languages_code': 'es',
    'title': 'Introducción a la seguridad de la IA',
    'slug': 'introducción-a-la-seguridad-ai',
    'content': '# Fundamentos de seguridad de IA\n\nEste es un artículo de muestra sobre cómo proteger los sistemas de IA...\n\n## Riesgos clave\n\n- Inyección rápida\n- Fuga de datos\n- Envenenamiento de modelos\n\n## Mejores prácticas\n\nSiempre valide las entradas, la ejecución del modelo de espacio aislado y monitoree las anomalías.',
    'excerpt': 'Una guía para principiantes para comprender y mitigar los riesgos del sistema de IA.',
    'key_takeaways': ['Los sistemas de IA son vulnerables a ataques de inyección rápida', 'Validar y desinfectar siempre las entradas del modelo', 'Monitorear el comportamiento anómalo del modelo'],
    'meta_title': 'Introducción a la Seguridad de la IA - Guía Ainex',
    'meta_description': 'Aprenda los fundamentos de la seguridad de la IA, las amenazas comunes y las mejores prácticas para proteger sus aplicaciones LLM.',
    'featured_image_alt': 'Visualización abstracta de la seguridad de las redes neuronales',
    'cta_headline': '¿Listo para proteger tu IA?',
    'cta_button_text': 'Comenzar',
    'cta_button_url': '/empezar',
    'schema_markup': {
        '@context': 'https://schema.org',
        '@tipo': 'Artículo',
        'headline': 'Introducción a la seguridad de la IA',
        'autor': {'@tipo': 'Persona', 'nombre': 'Alex Chen'},
        'fecha de publicación': '2026-05-03T10:00:00.000Z',
        'description': 'Una guía para principiantes para comprender y mitigar los riesgos del sistema de IA.'
    }
}, colección='Blog_Posts_Translations')

print(f"✅ ¡Blog backend creado! ID de publicación: {post_id}")

Cree un backend de comercio electrónico de producción con Directus. Crea estas colecciones:

1. **Productos** - artículos del catálogo
   - título, slug (único), descripción (texto), estado (borrador/disponible/agotado)
   - price_cents (entero), compare_price_cents (entero anulable), cost_cents (entero)
   - sku (único), código de barras (anulable), peso_gramos (entero)
   - cantidad_inventario, umbral_bajo_stock (predeterminado 10)
   - feature_image (archivo), imágenes (M2M a través de unión)
   - categoría (M2O → Categorías), etiquetas (M2M → Etiquetas vía cruce)
   - publicado_en

2. **Categorías** - taxonomía anidada
   - nombre, slug (único), descripción, parent_category (m2o anulable)
   - imagen (archivo), sort_order

3. **Etiquetas** - etiquetas de productos
   - nombre, babosa (única), color (hexadecimal)

4. **Clientes** - cuentas
   - correo electrónico (único), nombre, apellido, teléfono
   - dirección_de_envío_predeterminada (json), dirección_de_facturación_predeterminada (json)
   - total_spent_cents, order_count, last_order_at (anulable)
   - estado (activo/bloqueado), notas

5. **Pedidos** - transacciones
   - número de pedido (único), estado (pendiente/procesando/enviado/entregado/cancelado)
   - cliente (M2O → Clientes)
   - subtotal_cents, tax_cents, envío_cents, total_cents, descuento_cents
   - dirección_envío, dirección_facturación (json)
   - estado_pago (pagado/reembolsado/fallido), método_pago (stripe/paypal/manual)
   - Payment_intent_id (anulable), número_seguimiento (anulable)
   - notas, cancelled_at (anulable)

6. **Order_Items** - artículos de línea (tabla de unión Pedidos ↔ Productos)
   - pedido (M2O → Pedidos), producto (M2O → Productos)
   - cantidad, centavos de precio unitario, centavos de precio total
   - nombre_variante (cadena, anulable)

7. **Ajustes_de_inventario** - registro de auditoría
   - producto (M2O → Productos), motivo (reposición/venta/devolución/auditoría/ajuste)
   - cantidad_delta, cantidad_anterior, cantidad_nueva
   - reference_id (anulable - enlaces a pedido/ajuste), notas

8. **Colecciones**: agrupaciones seleccionadas
   - nombre, slug (único), identificador (cadena compatible con API)
   - tipo (manual/automático), reglas (json para reglas automáticas)
   - sort_order, publicado (booleano)

9. **Descuentos** - códigos promocionales
   - código (único, anulable para automático), tipo (porcentaje/fijo)
   - valor (int - porcentaje o centavos), max_uses, used_count
   - valid_from, valid_until (anulable)
   - se aplica_a (todos/categorías/productos), aplicables_producto_ids (matriz json)
   - min_order_amount_cents (anulable), excluir_sale_items (booleano)

Restricciones:
- Utilice create_collection() para las 9 colecciones + tablas de unión explícitas (Products_Images si es necesario)
- Cada campo: incluya esquema: {} y meta: {} al principio
- Utilice los tipos de campo Directus adecuados: entero, cadena, texto, booleano, fecha y hora, json, archivo, pivote
- Agregar índices únicos en slug, sku, número_pedido
- Semilla: cree 3 productos de muestra con imágenes de muestra (use ID de archivo si están disponibles), enlace a la categoría
- Verificar: llame a get_collections() e imprima el recuento de registros
- Generar el script Python completo

Cree un backend de CRM con Directus:

1. Empresas
   - nombre, dominio (único), industria, tamaño (1-10/11-50/51-200/200+)
   - sitio web, teléfono, dirección (json), ingresos_anuales_centavos (anulable)
   - propietario (M2O → Usuarios), estado (cliente potencial/cliente/prospecto/desechado)
   - last_contacted_at, notas (texto)

2. Contactos
   - nombre, apellido, correo electrónico (único), teléfono, puesto de trabajo
   - empresa (M2O → Empresas), propietario (M2O → Usuarios)
   - estado (activo/inactivo/cliente potencial), contacto_preferido (correo electrónico/teléfono/linkedin)
   - linkedin_url, notas

3. Interacciones
   - contacto (M2O → Contactos), tipo (llamada/correo electrónico/reunión/nota)
   - dirección (entrante/saliente), duración_minutos (entero)
   - resumen (texto), próximos_pasos (texto), fecha_de_vencimiento (anulable)
   - related_deal (M2O → Ofertas anulables)

4. Ofertas
   - título, valor_centavos, etapa (propuesta/negociación/ganado_cerrado/perdido_cerrado)
   - probabilidad (0-100), fecha_de_cierre (esperada)
   - contacto (M2O → Contactos), propietario (M2O → Usuarios)
   - notas

Restricciones:
- Utilice create_collection() para los 4
- Todos los campos estándar: id, creado_at, actualizado_at agregados automáticamente
- Relaciones configuradas correctamente (los FK son números enteros)
- Semilla: 2 empresas, 4 contactos, 3 interacciones, 1 trato

{
    'campo': 'precio_centavos',
    'tipo': 'entero',
    'schema': {'is_required': True}, # ← siempre incluye esto
    'meta': {'interface': 'numeric'} # ← siempre incluye esto
}

{ Blog_Posts_Translations { id blog_posts_id } }

cliente.get_expanded(
    campos = ['id', 'título', 'blog_posts_id.id', 'blog_posts_id.status'],
    colección = 'Blog_Posts_Translations',
    límite=50
)
## Devuelve dictados: blog_posts_id = {'id': '5', 'status': 'publicado'}

cliente.insertar({
    'blog_posts_id': int(post_id), # NO post_id
    'languages_code': 'es',
    ...
}, colección='Blog_Posts_Translations')

## INCORRECTO: El PATCH directo en Blog_Posts falla
client.update(post_id, {'etiquetas': [1, 2, 3]}, colección='Blog_Posts') # ❌ 403

## CORRECTO: Insertar en la mesa de unión
para tag_id en [1, 2, 3]:
    client.insert({'blog_posts_id': post_id, 'blog_tags_id': tag_id}, colección='Blog_Posts_Tags')

## Paso 1: padre (solo metadatos)
publicación = cliente.insertar({
    'estado': 'publicado',
    'autor': autor_id,
    'categoría': categoría_id,
    'tiempo_lectura_minutos': 8
}, colección='Blog_Posts')

post_id = publicación['id']

## Paso 2: traducción (contenido real)
cliente.insertar({
    'blog_posts_id': post_id,
    'languages_code': 'es',
    'título': 'Mi publicación',
    'babosa': 'mi-publicación',
    'content': '#Hola mundo...',
    ...
}, colección='Blog_Posts_Translations')

## Paso A: Crear (riesgo de truncamiento)
trans = client.insert({... campos_iniciales..., 'contenido': 'marcador de posición corto' }, colección='Blog_Posts_Translations')
trans_id = trans['id']

## Paso B: PATCH contenido completo (evita el truncamiento)
client.update(trans_id, {'content': full_markdown_body}, colección='Blog_Posts_Translations')

## Enviar un registro de prueba mínimo
prueba = {'estado': 'borrador', 'autor': 1, 'categoría': 33}
test_record = client.insert (prueba, colección = 'Blog_Posts')
test_id = test_record['id']

## Si tiene éxito, elimínelo
client.delete(test_id, hard=True, colección='Blog_Posts')
print('✅ Acceso de escritura confirmado')

## Igual
resultados = cliente.get(
    campos = ['id', 'título', 'estado'],
    filtros={'status': {'_eq': 'publicado'}},
    colección = 'Blog_Posts',
    límite=10
)

## No igual
borradores = client.get(filters={'status': {'_neq': 'published'}}, collection='Blog_Posts')

## Contiene (no distingue entre mayúsculas y minúsculas)
buscar = cliente.get(
    filtros = {'título': {'_icontains': 'seguridad'}},
    colección = 'Blog_Posts'
)

## En la lista
resultados = cliente.get(
    filtros = {'categoría': {'_in': [33, 37, 42]}},
    colección = 'Blog_Posts'
)

## Mayor que
caro = cliente.get(
    filtros={'price_cents': {'_gt': 10000}},
    colección='Productos'
)

## Verificación nula
no contactado = cliente.get(
    filtros = {'last_contacted_at': {'_null': Verdadero}},
    colección='Contactos'
)

## Combinado (Y juntos)
resultados = cliente.get(
    filtros={
        'estado': {'_eq': 'publicado'},
        'categoría': {'_in': [33, 37]},
        'published_at': {'_not_null': Verdadero}
    },
    colección = 'Blog_Posts'
)

## Obtener publicaciones con autor, categoría y etiquetas
registros = client.get_expanded(
    campos=[
        'id', 'título', 'estado',
        'autor.id', 'autor.nombre', 'autor.correo electrónico', # relación M2O
        'categoría.id', 'categoría.nombre', # relación M2O
        'tags.id', 'tags.name', 'tags.slug' # M2M mediante unión
    ],
    colección = 'Blog_Posts',
    límite=20
)
## Resultado: cada registro tiene dictados anidados como {'autor': {'id': 1, 'nombre': 'Alex'}, 'etiquetas': [{'id': 5, 'nombre': 'AI'}, ...]}

cliente.insertar({
    'dirección_envío': {
        'calle': '123 Tech Blvd',
        'ciudad': 'Dubái',
        'país': 'EAU',
        'código_postal': '00000'
    },
    'metadatos': {
        'utm_source': 'boletín',
        'campaign_id': 'Q2-2026-ai-launch'
    }
}, colección='Pedidos')

cliente = DirectusCliente(
    url=os.getenv('DIRECTUS_URL'),
    token=os.getenv('DIRECTUS_API_TOKEN'), # para CRUD
    admin_token=os.getenv('DIRECTUS_ADMIN_TOKEN') # para esquema
)

## Crea una nueva colección
client.create_collection('TEST_Items', campos=[
    {'field': 'id', 'type': 'integer', 'schema': {'is_primary_key': True, 'has_auto_increment': True}, 'meta': {'hidden': True, 'interface': 'numeric', 'readonly': True}},
    {'campo': 'nombre', 'tipo': 'cadena', 'esquema': {}, 'meta': {'interfaz': 'entrada'}},
    {'campo': 'valor', 'tipo': 'entero', 'esquema': {}, 'meta': {'interfaz': 'numérico'}}
])

## Agregar un campo a la colección existente (úselo con precaución, puede dañar el esquema GraphQL)
client.create_field('TEST_Items', 'descripción', 'texto', meta={'interfaz': 'textarea'})

## Listar todas las colecciones
colecciones = client.get_collections()
print(colecciones) # ['Blog_Posts', 'Blog_Authors', ...]

## Obtener esquema de colección
esquema = client.get_collection_schema('Blog_Posts')
print(esquema['campos'].keys()) # dict_keys(['id', 'estado', 'autor', ...])

## 1. Inicie su terminal (con tokens Directus en env)
$ exportar DIRECTUS_URL="https://hub.aratech.ae"
$ export DIRECTUS_API_TOKEN="sZk-st..." # token de usuario
$ export DIRECTUS_ADMIN_TOKEN="anuncio-..." # token de administrador

## 2. Inicie el agente Hermes
$hermes

## 3. Da el mensaje (copia y pega desde arriba)
Tú: Constrúyeme un backend de blog con Directus. Crea estas colecciones:...

## 4. El agente piensa, genera script y ejecuta
🤖 Agente: Creando Blog_Autores... ✅
   Creando Blog_Categorías... ✅
   Creando Blog_Tags... ✅
   Creando publicaciones_de_blog... ✅
   Creando Blog_Publicaciones_Traducciones... ✅
   Creando etiquetas_publicaciones_blog... ✅
   Sembrando 2 publicaciones de muestra... ✅
   
   Verificación:
   - Blog_Posts: 2 registros
   - Blog_Posts_Translations: 2 registros (solo en inglés)
   - Blog_Autores: 1 registro
   - Blog_Categories: 1 registro
   - Blog_Tags: 0 registros
   
   ✅ ¡Backend andamiado exitosamente! Su panel de administración de Directus en https://hub.aratech.ae/admin ahora muestra todas las colecciones completas.

## 5. Ya terminaste. Verifique la interfaz de usuario del administrador o consulte:
$ python3 -c "de directus.client importar DirectusClient; c = DirectusClient(); print(c.get(colección='Blog_Posts', límite=3))"