Agentic commerce en PrestaShop 9.2: guía técnica

PrestaShop 9.2 ha traído tres piezas que cambian el juego: One Page Checkout, Ask AI y un servidor MCP para conectar la tienda con aplicaciones de IA. Pero conviene ser honestos: 9.2 no incluye «agentic commerce» para clientes finales. Incluye la base para construirlo. En esta guía técnica te explicamos qué hay, qué falta y cómo montar una integración real sin abrir la puerta a ciegas.

Está pensada para desarrolladores y agencias que ya trabajan con PrestaShop 9.x y quieren preparar una tienda para agentes de compra. Si solo buscas el concepto, empieza por qué es el agentic commerce.

1. Qué trae (y qué no) PrestaShop 9.2

Antes de escribir una línea, conviene separar las piezas:

2. Arquitectura de referencia

La integración que mejor funciona separa tres capas:

Agente del cliente (ChatGPT, Claude, app propia)
        │  MCP (Streamable HTTP + OAuth)
        ▼
PrestaShop MCP Server  ──►  Módulo MCP-compliant
        │                        │
        │                        ├─ search_products
        │                        ├─ get_product
        │                        ├─ check_stock
        │                        ├─ create_cart
        │                        └─ get_checkout_url
        ▼
PrestaShop 9.2 (catálogo, stock, carrito)
        │
        ▼
One Page Checkout (aprobación humana y pago)

La regla de oro: el agente nunca paga solo. Como mucho, prepara el carrito y devuelve una URL para que la persona revise y confirme. Así se evitan cargos no deseados y se mantiene la trazabilidad.

3. Requisitos y entorno

• PrestaShop 9.2 (o superior) y PHP 8.x soportado.
• HTTPS obligatorio: el MCP Server no está pensado para HTTP en producción.
• Webservices activados en Parámetros avanzados → Webservice.
• Cuenta de PrestaShop vinculada y módulos PrestaShop Account, MBO y EventBus.
• Un proveedor de IA con API key: OpenAI, Anthropic, Google, Mistral u OpenAI-compatible.
• Entorno de staging y copia de seguridad verificada.
• Acceso a un cliente MCP (Claude, ChatGPT, Cursor o CLI) para probar.

4. Instalar y configurar el MCP Server

El MCP Server se instala como módulo desde el Marketplace y arrastra dependencias. El orden importa:

4.1. Instala el módulo y sus dependencias

Desde Módulos → Gestor de módulos, instala PrestaShop MCP Server. A través de MBO se instalarán PrestaShop Account, PrestaShop EventBus y PrestaShop MCP Tools. Si falta alguno, el panel de Ask AI no funcionará.

4.2. Vincula tu cuenta

Conecta la tienda con tu cuenta de PrestaShop. El email que uses debe estar también en la página Members del MCP Server; si no, la autenticación OAuth fallará al conectar el agente.

4.3. Activa webservices

Ask AI y el MCP Server se apoyan en los webservices de PrestaShop. El módulo crea su propio token; no necesitas crear uno a mano. Activa el acceso desde la configuración del módulo.

4.4. Configura el proveedor de IA

En la configuración de Ask AI elige proveedor, pega la API key y guarda. La clave se almacena en tu servidor y se prueba al guardar. Compatibles: OpenAI, Anthropic, Google, Mistral y OpenAI-compatible.

5. Crear un módulo MCP-compliant

Para que el MCP Server descubra tus herramientas, el módulo debe declararse compatible. Crea un módulo normal y añade isMcpCompliant():

<?php
// modules/solusen_agentcommerce/solusen_agentcommerce.php

class Solusen_AgentCommerce extends Module
{
    public function __construct()
    {
        $this->name = 'solusen_agentcommerce';
        $this->tab = 'front_office_features';
        $this->version = '1.0.0';
        $this->author = 'Solusen';
        $this->need_instance = 0;
        $this->ps_versions_compliancy = ['min' => '9.2', 'max' => _PS_VERSION_];
        parent::__construct();

        $this->displayName = $this->l('Agent Commerce Tools');
        $this->description = $this->l('Herramientas MCP para agentes de compra.');
    }

    public function isMcpCompliant()
    {
        return true;
    }
}

Las herramientas deben vivir dentro de src/ y sus subcarpetas. El MCP Server ignora el código que esté fuera.

6. Definir herramientas con PHP attributes

Cada herramienta es un método PHP anotado con #[PsMcpTool] y un esquema de entrada con #[PsMcpSchema]. Empieza por lectura y añade escritura después.

6.1. Herramienta de búsqueda

<?php
// modules/solusen_agentcommerce/src/Mcp/ProductTools.php

namespace Solusen_AgentCommerce\Mcp;

use PrestaShop\Module\PsMcpServer\Server\Attributes\PsMcpTool;
use PrestaShop\Module\PsMcpServer\Server\Attributes\PsMcpSchema;
use PrestaShop\Module\PsMcpServer\Server\Attributes\PsMcpToolAnnotations;

class ProductTools
{
    #[PsMcpTool(
        name: 'search_products',
        title: 'Buscar productos',
        description: 'Busca productos activos y devuelve id, nombre, precio, stock y URL.',
        annotations: new PsMcpToolAnnotations(
            title: 'Buscar productos',
            readOnlyHint: true,
            destructiveHint: false,
            idempotentHint: true,
            openWorldHint: false,
        ),
    )]
    #[PsMcpSchema(
        properties: [
            'query' => ['type' => 'string', 'description' => 'Texto a buscar'],
            'limit' => ['type' => 'integer', 'description' => 'Máximo de resultados (1-20)'],
        ],
        required: ['query'],
    )]
    public function searchProducts(string $query, int $limit = 5): array
    {
        $limit = max(1, min(20, $limit));
        $context = \Context::getContext();
        $idLang = (int) $context->language->id;
        $idShop = (int) $context->shop->id;
        $sql = 'SELECT p.id_product, pl.name, p.price, ps.quantity, pl.link_rewrite'
             . ' FROM ' . _DB_PREFIX_ . 'product p'
             . ' INNER JOIN ' . _DB_PREFIX_ . 'product_lang pl'
             . ' ON (pl.id_product = p.id_product AND pl.id_lang = ' . $idLang . ' AND pl.id_shop = ' . $idShop . ')'
             . ' LEFT JOIN ' . _DB_PREFIX_ . 'product_shop ps'
             . ' ON (ps.id_product = p.id_product AND ps.id_shop = ' . $idShop . ')'
             . ' WHERE p.active = 1 AND pl.name LIKE "%' . pSQL($query) . '%"'
             . ' LIMIT ' . $limit;

        $rows = \Db::getInstance()->executeS($sql) ?: [];
        $base = $context->link->getBaseLink();

        return array_map(static function (array $row) use ($base): array {
            return [
                'id' => (int) $row['id_product'],
                'name' => $row['name'],
                'price' => (float) $row['price'],
                'stock' => (int) $row['quantity'],
                'url' => $base . $row['link_rewrite'],
            ];
        }, $rows);
    }
}

Es un ejemplo simplificado: en producción añade control multiidienda y multitienda, impuestos, combinaciones, imágenes y límites de resultados. No devuelvas datos internos que el agente no necesite.

6.2. Herramientas que sí merecen la pena

7. Carrito y checkout con aprobación

La forma más segura de cerrar la compra es no cerrarla: el agente prepara el carrito y devuelve una URL para que la persona revise y pague en tu tienda. Con One Page Checkout, el flujo queda en una sola pantalla.

# Respuesta de create_cart (ejemplo)
{
  "cart_id": 1842,
  "items": 2,
  "total": 129.80,
  "currency": "EUR",
  "checkout_url": "https://tienda.example/order?cart=1842",
  "requires_approval": true
}

• Marca requires_approval: true siempre que haya pago.
• No devuelvas tokens de pago ni datos de tarjeta al agente.
• Caduca los carritos creados por agentes tras un tiempo prudencial.
• Registra qué agente y qué usuario han generado cada carrito.
• Prueba el flujo con invitado y con cliente registrado.

8. Seguridad y permisos

Abrir herramientas a agentes es abrir endpoints. Trátalos como una API pública más:

• OAuth con scopes mínimos y usuarios en Members.
• Herramientas de escritura separadas de las de lectura y con validación adicional.
• Rate limiting en el servidor o en el WAF por IP y por cliente.
• Validación y saneado de todos los parámetros del agente.
• Logs de cada llamada: herramienta, parámetros, resultado y agente.
• Nada de secretos en el frontend ni en prompts.
• Copias de seguridad y staging antes de probar escrituras.

9. Probar con un agente

1. Copia la URL del MCP Server desde su configuración.
2. Añádela como conector MCP en Claude, ChatGPT, Cursor o tu cliente.
3. Autentica con OAuth y revisa que aparecen tus herramientas.
4. Prueba: «busca una chaqueta azul talla M», «¿hay stock?», «prepara un carrito».
5. Comprueba que el agente no puede pagar y que la URL de checkout funciona.
6. Revisa logs, latencia y errores antes de abrir a clientes.

10. Checklist de puesta en marcha

• PrestaShop 9.2 en staging, con backup probado.
• MCP Server, MCP Tools, Account y EventBus activos.
• Webservices y HTTPS correctos.
• Proveedor de IA configurado y key validada.
• Módulo MCP-compliant con herramientas de lectura.
• Carrito y checkout con aprobación humana.
• OAuth, scopes y rate limiting configurados.
• Logs y métricas activos.
• Pruebas con invitado y cliente registrado.
• Plan de mantenimiento y revisión mensual.

11. Preguntas frecuentes

12. Conclusión

PrestaShop 9.2 no te da el agentic commerce hecho, pero sí las piezas correctas: MCP Server, herramientas extensibles, One Page Checkout y una API moderna. La diferencia entre un piloto seguro y un problema de seguridad está en cómo expones esas piezas: lectura primero, escritura controlada, pago con aprobación y logs desde el día uno.

Si quieres, revisamos tu PrestaShop 9.2 y te decimos qué herramientas merecen la pena para tu catálogo, sin abrir la puerta a ciegas.