Symfony Profiler

[
  "data" => [
    [
      "id" => 268
      "uuid" => "186d16a8-f9a9-420f-9698-541b2fad8376"
      "locale" => "es"
      "status" => "published"
      "collection" => "blog"
      "created_at" => "2026-06-02T12:21:56+00:00"
      "updated_at" => "2026-06-02T12:21:56+00:00"
      "deleted_at" => null
      "published_at" => "2026-06-02T12:21:56+00:00"
      "scheduled_at" => null
      "creator" => null
      "updater" => null
      "assigned_to" => null
      "title" => "Comenzando con Jambo API en 5 minutos"
      "slug" => "comenzando-con-jambo-api"
      "excerpt" => "De una terminal vacía a APIs REST y GraphQL en producción en menos de cinco minutos — sin YAML, sin migraciones, sin controladores que andamiar. Aquí está todo el flujo, comando a comando."
      "body" => """
        <p>La mayoría de las guías de inicio asumen en voz baja una tarde de configuración. Jambo API se diseñó en torno a una promesa distinta: de una terminal vacía a un CMS headless listo para producción en menos de cinco minutos. Sin YAML que redactar, sin boilerplate que copiar, sin paso de build que vigilar. Este es todo el flujo, paso a paso.</p>\n
        \n
        <h2>1. Instalar en un comando</h2>\n
        <p>Todo empieza aquí:</p>\n
        <p><code>composer create-project jambostack/jambo-api</code></p>\n
        <p>Esa es toda la instalación. Un solo comando descarga el proyecto, instala las dependencias y prepara la base de datos. No hay archivos de configuración que editar a mano ni variables de entorno que descifrar antes de la primera ejecución. Si sabes ejecutar Composer, sabes ejecutar Jambo.</p>\n
        \n
        <h2>2. Crea tu primer proyecto</h2>\n
        <p>Abre <code>http://localhost:8080</code>, inicia sesión y crea un proyecto. Un "proyecto" en Jambo es un espacio de contenido aislado, con sus propias colecciones, contenido, biblioteca de medios y tokens de API. Crear uno toma unos treinta segundos, y puedes tener tantos como quieras — uno por cliente, por entorno o por aplicación.</p>\n
        \n
        <h2>3. Diseña tu esquema describiéndolo</h2>\n
        <p>Aquí es donde Jambo se aparta de todo CMS tradicional. Abre el <strong>Studio de Esquemas con IA</strong> y describe lo que necesitas en lenguaje natural:</p>\n
        <blockquote><em>"Necesito artículos de blog con título, cuerpo, imagen de portada, una relación de autor y categorías."</em></blockquote>\n
        <p>La IA genera el esquema completo — tipos de campo, relaciones, reglas de validación y valores por defecto sensatos. Revísalo, haz clic en <strong>Aplicar</strong> y luego en <strong>Guardar</strong>. Si prefieres construir a mano, el editor visual está justo al lado. En ambos casos describes una intención, no escribes archivos de migración.</p>\n
        \n
        <h2>4. Tu API está activa en el instante en que guardas</h2>\n
        <p>En cuanto se guarda tu esquema, Jambo genera automáticamente los endpoints REST <em>y</em> GraphQL. Sin paso de build. Sin reiniciar el servidor. Sin generación de código que ejecutar. Obtén tus datos de inmediato:</p>\n
        <p><code>GET /api/{project}/blog_posts?locale=es&status=published</code></p>\n
        <p>Recibes JSON limpio y paginado, con filtrado, ordenación, selección de idioma y expansión de relaciones integrados. El endpoint GraphQL está activo en el mismo momento, con un esquema que refleja tus colecciones exactamente.</p>\n
        \n
        <h2>5. Conecta cualquier cosa</h2>\n
        <p>Como la API es HTTP puro, funciona con lo que ya usas. Jambo también publica una especificación OpenAPI generada automáticamente y un SDK tipado, para que tu front-end obtenga autocompletado y seguridad de tipos gratis:</p>\n
        <ul>\n
        <li><strong>Next.js / React</strong> — fetch en server components o con tu capa de datos preferida.</li>\n
        <li><strong>Astro</strong> — carga el contenido en tiempo de build para sitios totalmente estáticos (este mismo sitio hace exactamente eso).</li>\n
        <li><strong>Vue / Nuxt / Svelte</strong> — cualquier cosa que hable HTTP es un cliente de primera clase.</li>\n
        </ul>\n
        \n
        <h2>Y ese es todo el flujo</h2>\n
        <p><strong>Sin migraciones que ejecutar. Sin controladores que andamiar. Sin middleware que configurar.</strong> Describiste un modelo de contenido y apareció una API versionada, multilingüe y totalmente documentada. Los cinco minutos que acabas de invertir son los mismos tanto si prototipas un proyecto personal como si levantas infraestructura de producción — Jambo no te obliga a elegir entre rápido y serio.</p>\n
        <p>Desde aquí, los siguientes pasos naturales son añadir idiomas, invitar a compañeros de equipo o apuntar un agente de IA a tu proyecto a través del servidor MCP nativo. Pero la API que necesitas ya está funcionando.</p>
        """
      "category" => [
        "tutorial"
      ]
      "field_published_at" => "2026-05-28T10:00:00+00:00"
      "author_name" => "Equipo Jambo"
      "_seo" => [
        "metaTitle" => null
        "metaDescription" => null
        "slug" => "entry-268"
        "canonicalUrl" => null
        "ogImage" => null
        "score" => null
        "openGraph" => [
          "title" => "Comenzando con Jambo API en 5 minutos"
          "description" => ""
          "image" => null
          "type" => "article"
          "siteName" => "Jambo"
        ]
        "twitter" => [
          "card" => "summary"
          "title" => "Comenzando con Jambo API en 5 minutos"
          "description" => ""
          "image" => null
        ]
        "structuredData" => [
          "@context" => "https://schema.org"
          "@type" => "Article"
          "headline" => ""
          "description" => ""
          "image" => null
          "datePublished" => "2026-06-02T12:21:56+00:00"
          "dateModified" => "2026-06-02T12:21:56+00:00"
        ]
        "hreflang" => [
          "en" => "https://example.com/blog/entry-268?locale=en"
          "fr" => "https://example.com/blog/entry-268?locale=fr"
          "es" => "https://example.com/blog/entry-268?locale=es"
          "ar" => "https://example.com/blog/entry-268?locale=ar"
          "x-default" => "https://example.com/blog/entry-268?locale=en"
        ]
      ]
    ]
    [
      "id" => 269
      "uuid" => "3fe73f86-afa5-41dc-93ea-3e31dda5c411"
      "locale" => "es"
      "status" => "published"
      "collection" => "blog"
      "created_at" => "2026-06-02T12:21:56+00:00"
      "updated_at" => "2026-06-02T12:21:56+00:00"
      "deleted_at" => null
      "published_at" => "2026-06-02T12:21:56+00:00"
      "scheduled_at" => null
      "creator" => null
      "updater" => null
      "assigned_to" => null
      "title" => "Por que integramos un servidor MCP en nuestro CMS"
      "slug" => "por-que-servidor-mcp-en-cms"
      "excerpt" => "Agentes de IA como Claude ahora pueden leer y escribir tu contenido directamente — sin webhooks, sin scraping, sin código pegamento frágil. Hicimos de Jambo el primer CMS que habla el Model Context Protocol de forma nativa. Aquí está el porqué y el cómo."
      "body" => """
        <p>El <strong>Model Context Protocol</strong> (MCP) se está convirtiendo rápidamente en la forma estándar en que los agentes de IA hablan con herramientas externas. En lugar de que cada integración reinvente su propio envoltorio de API, MCP ofrece a los agentes una manera uniforme de descubrir capacidades, inspeccionar la forma de los datos y actuar. Jambo es el primer CMS headless que implementa MCP de forma <em>nativa</em> — no como un plugin, sino como una pieza de primera clase de cada proyecto.</p>\n
        <p>Este artículo explica el problema que estábamos resolviendo, cómo funciona el servidor MCP de Jambo y qué desbloquea en la práctica.</p>\n
        \n
        <h2>El problema de IA + CMS hoy</h2>\n
        <p>Conectar un asistente de IA a una plataforma de contenido ha significado, hasta ahora, escribir código de integración a medida para cada caso de uso. Las opciones habituales son todas imperfectas:</p>\n
        <ul>\n
        <li>Los <strong>webhooks</strong> emiten eventos hacia fuera, pero el agente sigue necesitando manejadores específicos y no puede consultar ni explorar.</li>\n
        <li>Los <strong>envoltorios REST</strong> obligan a escribir y mantener a mano una definición de herramienta para cada endpoint, y luego sincronizarla a medida que el esquema evoluciona.</li>\n
        <li>El <strong>scraping de HTML</strong> es el peor de todos: frágil, lento y roto en cuanto cambia una plantilla.</li>\n
        </ul>\n
        <p>Los tres comparten el mismo defecto fatal — se rompen cuando cambia tu modelo de contenido. Y los modelos de contenido cambian constantemente. Ese es justamente el sentido de un CMS flexible.</p>\n
        \n
        <h2>Cómo funciona el servidor MCP de Jambo</h2>\n
        <p>Cada proyecto de Jambo expone un único endpoint MCP:</p>\n
        <p><code>POST /api/projects/{id}/mcp</code></p>\n
        <p>A través de él, un agente puede llamar a <code>tools/list</code> para descubrir todo lo que puede hacer y luego invocar esas herramientas. Como Jambo genera los esquemas dinámicamente, las herramientas MCP también se generan dinámicamente. El agente siempre ve la forma <em>actual</em> de tus datos:</p>\n
        <ul>\n
        <li><strong>Listar colecciones</strong> — el agente descubre qué tipos de contenido existen.</li>\n
        <li><strong>Inspeccionar campos</strong> — tipos, obligatoriedad, relaciones, enumeraciones, todo es introspeccionable.</li>\n
        <li><strong>Consultar contenido</strong> — con filtros, paginación y selección de idioma.</li>\n
        <li><strong>Crear y actualizar entradas</strong> — individuales o en lote, en cada idioma configurado.</li>\n
        </ul>\n
        <p>No hay código de integración que escribir ni nada que mantener sincronizado. Añade un campo en el editor de esquemas y aparecerá en las herramientas MCP en la siguiente petición. El contrato y el contenido permanecen alineados automáticamente.</p>\n
        \n
        <h2>Una sesión del mundo real</h2>\n
        <p>Esto es lo que permite, dicho en lenguaje natural al agente:</p>\n
        <blockquote>"Claude, mira el esquema de nuestro catálogo de productos y luego genera 20 fichas de producto realistas — nombres, descripciones y precios apropiados para una cafetería de especialidad. Publícalas en inglés y español."</blockquote>\n
        <p>El agente llama a <code>tools/list</code>, lee la definición de la colección <code>products</code>, entiende que <code>price</code> es un número y <code>description</code> texto enriquecido, genera contenido contextualmente apropiado y crea 40 entradas (20 × 2 idiomas) en unos segundos. No se escribió ningún código pegamento para esta tarea. Tampoco hará falta para la siguiente.</p>\n
        \n
        <h2>Conectar tu propio agente</h2>\n
        <p>Apunta cualquier cliente compatible con MCP al endpoint con un token de API del proyecto. Una configuración de cliente típica se ve así:</p>\n
        <p><code>{ "mcpServers": { "jambo": { "url": "https://api.jambostack.site/api/projects/{id}/mcp", "headers": { "Authorization": "Bearer TU_TOKEN" } } } }</code></p>\n
        <p>A partir de ahí, el agente descubre tus colecciones por sí mismo. El token delimita exactamente lo que puede ver y cambiar, de modo que mantienes el control.</p>\n
        \n
        <h2>Por qué importa</h2>\n
        <p>Creemos que el futuro interesante de la gestión de contenido no es un humano haciendo clic por un panel de administración — es describir una intención a un agente que entiende tu modelo de datos y actúa sobre él de forma segura. El MCP nativo es el sustrato que hace eso posible sin integraciones frágiles mantenidas a mano. Integrarlo en Jambo desde el principio era el paso obvio. No será el último CMS en ofrecer MCP — pero fue el primero.</p>
        """
      "category" => [
        "case_study"
      ]
      "field_published_at" => "2026-05-22T10:00:00+00:00"
      "author_name" => "Equipo Jambo"
      "_seo" => [
        "metaTitle" => null
        "metaDescription" => null
        "slug" => "entry-269"
        "canonicalUrl" => null
        "ogImage" => null
        "score" => null
        "openGraph" => [
          "title" => "Por que integramos un servidor MCP en nuestro CMS"
          "description" => ""
          "image" => null
          "type" => "article"
          "siteName" => "Jambo"
        ]
        "twitter" => [
          "card" => "summary"
          "title" => "Por que integramos un servidor MCP en nuestro CMS"
          "description" => ""
          "image" => null
        ]
        "structuredData" => [
          "@context" => "https://schema.org"
          "@type" => "Article"
          "headline" => ""
          "description" => ""
          "image" => null
          "datePublished" => "2026-06-02T12:21:56+00:00"
          "dateModified" => "2026-06-02T12:21:56+00:00"
        ]
        "hreflang" => [
          "en" => "https://example.com/blog/entry-269?locale=en"
          "fr" => "https://example.com/blog/entry-269?locale=fr"
          "es" => "https://example.com/blog/entry-269?locale=es"
          "ar" => "https://example.com/blog/entry-269?locale=ar"
          "x-default" => "https://example.com/blog/entry-269?locale=en"
        ]
      ]
    ]
    [
      "id" => 270
      "uuid" => "57743fa6-0063-4f7e-8662-9f3b2b140f1c"
      "locale" => "es"
      "status" => "published"
      "collection" => "blog"
      "created_at" => "2026-06-02T12:21:56+00:00"
      "updated_at" => "2026-06-02T12:21:56+00:00"
      "deleted_at" => null
      "published_at" => "2026-06-02T12:21:56+00:00"
      "scheduled_at" => null
      "creator" => null
      "updater" => null
      "assigned_to" => null
      "title" => "Symfony 8 + PHP 8.4: Por que PHP en 2026"
      "slug" => "symfony-8-php-84-por-que-php-2026"
      "excerpt" => "PHP impulsa el 75 % de la web y, aun así, queda fuera de las conversaciones sobre "stacks modernos". Con Symfony 8, los property hooks de PHP 8.4 y el JIT, ese reflejo lleva una década de retraso. Aquí están los números."
      "body" => """
        <p>Cuando contamos a los desarrolladores que Jambo está construido en PHP, la reacción casi siempre es la misma: una pausa cortés y luego una pregunta sobre por qué no usamos "simplemente Node". Es un instinto comprensible — y desactualizado por una década. El PHP que se ganó su reputación en 2010 no es el lenguaje que se publica en 2026.</p>\n
        <p>Así que en lugar de discutir, mostramos benchmarks. Este es el argumento a favor de PHP como lenguaje backend serio hoy, contado a través de las dos tecnologías que hacen rápido a Jambo: <strong>Symfony 8</strong> y <strong>PHP 8.4</strong>.</p>\n
        \n
        <h2>Symfony 8 y el componente Runtime</h2>\n
        <p>La mayor mejora de rendimiento del Symfony moderno es el componente <code>Runtime</code>. Tradicionalmente, cada petición PHP reiniciaba todo el framework: cargar el kernel, construir el contenedor, registrar los servicios y, por fin, atender la petición. Ese coste es invisible por petición pero brutal a escala.</p>\n
        <p>El componente Runtime, combinado con la precarga de OPcache, mantiene el contenedor compilado y el mapa de clases residentes en memoria. El resultado en nuestro hardware de referencia:</p>\n
        <ul>\n
        <li><strong>Arranque en frío:</strong> menos de 10 ms hasta un kernel listo</li>\n
        <li><strong>Respuesta de API:</strong> 15–30 ms para una consulta de colección filtrada típica</li>\n
        <li><strong>Memoria:</strong> ~12 MB por worker bajo carga</li>\n
        </ul>\n
        <p>Esas cifras compiten con — y a menudo superan — las plataformas CMS en Node equivalentes haciendo el mismo trabajo JSON-sobre-HTTP, sin las pausas del recolector de basura.</p>\n
        \n
        <h2>PHP 8.4 no es el lenguaje que recuerdas</h2>\n
        <p>Si tu imagen mental de PHP es tipado débil y sopa de arrays, las últimas versiones te sorprenderán. PHP 8.4 en particular cierra la brecha de ergonomía con TypeScript:</p>\n
        <ul>\n
        <li><strong>Property hooks</strong> — propiedades calculadas y protegidas sin getters y setters repetitivos.</li>\n
        <li><strong>Visibilidad asimétrica</strong> — <code>public private(set)</code> ofrece una propiedad de solo lectura desde fuera y escribible desde dentro, en una sola declaración.</li>\n
        <li><strong>Clases readonly</strong> — objetos de valor inmutables con una sola palabra clave.</li>\n
        <li><strong>Todo tipado</strong> — propiedades tipadas, tipos unión, enums y un JIT que convierte los caminos calientes en código máquina nativo.</li>\n
        </ul>\n
        <p>El día a día es un lenguaje analizable estáticamente, amigable con el IDE, que resulta ser más rápido de lo que sugiere su reputación de interpretado.</p>\n
        \n
        <h2>¿Entonces por qué no Node o Go?</h2>\n
        <p>Nos gustan ambos de verdad. Pero cada uno tiene un coste que importaba para un CMS:</p>\n
        <p><strong>Node</strong> ofrece un ecosistema enorme y agotador. La rotación de dependencias, los cambios que rompen compatibilidad y la eterna pregunta de en cuál de cinco bibliotecas competidoras confiar son un impuesto operativo real. Para un producto que debe ser estable durante años, esa rotación es un riesgo.</p>\n
        <p><strong>Go</strong> es excelente para servicios de forma fija. Pero Jambo genera esquemas dinámicamente en tiempo de ejecución — colecciones y campos definidos por los usuarios, no por nosotros. El tipado estático de Go choca de frente con eso, mientras que la flexibilidad en ejecución de PHP lo abraza.</p>\n
        <p>Y luego está <strong>Doctrine</strong>. Jambo usa un modelo Entidad-Atributo-Valor para almacenar los esquemas definidos por el usuario, y Doctrine ORM maneja ese patrón — con su identity map, carga diferida y herramientas de migración — con más madurez que cualquier cosa que encontramos en los mundos de Node o Go.</p>\n
        \n
        <h2>Veinte años de aburrida estabilidad</h2>\n
        <p>La verdad poco glamurosa es que Symfony lleva dos décadas publicando versiones predecibles y retrocompatibles. Hay una ruta de actualización documentada, una política de soporte a largo plazo y una comunidad que valora la estabilidad por encima de la novedad. Para una infraestructura que pretendes ejecutar en producción durante años, "aburrido" es una característica, no un compromiso.</p>\n
        <p>PHP en 2026 es rápido, estrictamente tipado y agradable de escribir. Las cejas que levantamos son un reflejo de otra época. Los benchmarks son de esta.</p>
        """
      "category" => [
        "news"
      ]
      "field_published_at" => "2026-05-15T10:00:00+00:00"
      "author_name" => "Equipo Jambo"
      "_seo" => [
        "metaTitle" => null
        "metaDescription" => null
        "slug" => "entry-270"
        "canonicalUrl" => null
        "ogImage" => null
        "score" => null
        "openGraph" => [
          "title" => "Symfony 8 + PHP 8.4: Por que PHP en 2026"
          "description" => ""
          "image" => null
          "type" => "article"
          "siteName" => "Jambo"
        ]
        "twitter" => [
          "card" => "summary"
          "title" => "Symfony 8 + PHP 8.4: Por que PHP en 2026"
          "description" => ""
          "image" => null
        ]
        "structuredData" => [
          "@context" => "https://schema.org"
          "@type" => "Article"
          "headline" => ""
          "description" => ""
          "image" => null
          "datePublished" => "2026-06-02T12:21:56+00:00"
          "dateModified" => "2026-06-02T12:21:56+00:00"
        ]
        "hreflang" => [
          "en" => "https://example.com/blog/entry-270?locale=en"
          "fr" => "https://example.com/blog/entry-270?locale=fr"
          "es" => "https://example.com/blog/entry-270?locale=es"
          "ar" => "https://example.com/blog/entry-270?locale=ar"
          "x-default" => "https://example.com/blog/entry-270?locale=en"
        ]
      ]
    ]
  ]
  "meta" => [
    "total" => 3
    "page" => 1
    "per_page" => 100
    "pages" => 1
  ]
]

[
  "json_encode_options" => 15
]