DEV Community: Miguel Valerio Gutiérrez Pardo

Conectar un agente Python a SAP CAP desde un chatbot en SAPUI5

Miguel Valerio Gutiérrez Pardo — Wed, 23 Jul 2025 17:20:00 +0000

Hace unas semanas estuve buscando la forma de aunar SAP CAP con IA, que hoy en día está ya en todas partes. Se me ocurrió montar un Chatbot con un agente que posea ciertas capacidades para manejar los datos de la aplicación que he creado, aquí os dejo las movidas que se me ocurrieron montar :D

Backend

En SAP CAP tengo una app backend que expone entidades como Materials, Suppliers, PurchaseOrders, etc.
CAP está montado con autenticación básica y sirve como fuente de datos del agente.

Agente en Python con FastAPI + LangChain

El cerebro de la operación es un agente Python. Usa FastAPI para exponer un endpoint /ask, y LangChain para procesar preguntas del usuario, llamar al backend SAP CAP, y devolver una respuesta en lenguaje natural.
🔧 Herramientas expuestas

Usé @tool de LangChain para definir funciones específicas:

@tool
def get_material(material_name: str):
    """Get material details based on the material name"""
    url = f"{BASE_URL}/Materials?$filter=name eq '{material_name}'"
    response = requests.get(url, headers=headers, auth=auth)
    return response.json()

También se pueden crear materiales, consultar stock, proveedores, etc.

Endpoint principal /ask

@app.post("/ask")
async def ask_question(q: Question):
    response = agent.invoke(q.question)
    return {"answer": response}

Recibe una pregunta como:

{ "question": "¿Qué materiales hay en el centro 1000?" }

Y responde con texto como:

{ "answer": "Hay 57 materiales disponibles en el centro 1000. Ej: M-001, M-002." }

Interfaz conversacional con SAPUI5

En el frontend de la app, monté un chatbot simple usando componentes estándar de SAPUI5. Está dentro de un Panel lateral.
Quedó terriblemente feo, debería volver a echarle un vistazo y cambiarlo :)

XML de la vista

<Panel headerText="Virtual Assistant">
  <FlexBox direction="Column">
    <List items="{chatModel>/chat}">
      <CustomListItem>
        <HBox>
          <Text text="{chatModel>sender}: " class="chatSender"/>
          <Text text="{chatModel>message}" class="chatMessage"/>
        </HBox>
      </CustomListItem>
    </List>
    <HBox>
      <TextArea id="chatInput" placeholder="Write your message here..."/>
      <Button text="Enviar" press="onSendChat"/>
    </HBox>
  </FlexBox>
</Panel>

Lógica del controlador

onSendChat: async function () {
  const sMessage = this.byId("chatInput").getValue();
  const oModel = this.getView().getModel("chatModel");
  const aChat = oModel.getProperty("/chat");

  // Añadir mensaje del usuario
  aChat.push({ sender: "Tú", message: sMessage });
  oModel.setProperty("/chat", aChat);

  try {
    const res = await fetch("http://localhost:8000/ask", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ question: sMessage })
    });
    const data = await res.json();

    // Añadir respuesta del bot
    aChat.push({ sender: "Bot", message: data.answer.output });
    oModel.setProperty("/chat", aChat);
  } catch (e) {
    aChat.push({ sender: "Bot", message: "Error conectando con el asistente." });
    oModel.setProperty("/chat", aChat);
  }

  this.byId("chatInput").setValue(""); // Limpiar input
}

El chatbot es funcional, rápido, y permite integraciones conversacionales sobre SAP sin complicaciones.

El proyecto completo está en GitHub:
Betheval - MaterialFlow

Integrar SAP CAP con un agente inteligente en Python abre un mundo de posibilidades. Puedes construir asistentes conversacionales internos, interfaces más naturales para usuarios o incluso automatizar flujos complejos de negocio.

Construyendo un Chatbot con Ollama y SAP CAP: Frontend y Backend

Miguel Valerio Gutiérrez Pardo — Mon, 05 May 2025 20:39:32 +0000

Introducción

Alguna vez quisiste construir un chat interactivo con un modelo de lenguaje como Llama usando Ollama? En este artículo, te mostraré cómo crear un proyecto full stack que incluye un frontend dinámico y un backend basado en SAP CAP (Cloud Application Programming Model). ¡Vamos a ello!

Instalar Ollama

Para instalar Ollama, sigue estos pasos:

1. Descargar e instalar Ollama

Ve al sitio oficial de Ollama: https://ollama.com.
Descarga el instalador correspondiente a tu sistema operativo:

macOS: Descarga el archivo .dmg y sigue las instrucciones para instalarlo.
Windows: Descarga el archivo .exe y sigue las instrucciones del instalador.

2. Verificar la instalación

Una vez instalado, abre una terminal y ejecuta el siguiente comando para verificar que Ollama esté instalado correctamente:

ollama --version

Deberías ver la versión instalada de Ollama.

3. Configurar Ollama

Si necesitas configurar Ollama para que funcione con tu proyecto, asegúrate de que el servicio esté ejecutándose en el puerto correcto (por defecto, http://localhost:11434).

Puedes iniciar el servicio Ollama con:

ollama serve

Yo estoy usando este modelo: https://ollama.com/library/llama3.2:3b
Esto iniciará el servidor Ollama en tu máquina local.

Crear Backend

Vamos a crear un servicio SAP CAP lo más simple posible.
Lo ideal sería crear una clase o módulo y servicio con action, recoger el body con el prompt y pasarlo a llama, finalmente devolver el stream de respuestas, en caso de no necesitar un preprocesado de respuestas.

service ChatService {

    action chat(prompt: String) returns String;

}

try {
      const ollamaRes = await axios({
        method: "POST",
        url: "http://localhost:11434/api/chat",
        responseType: "stream",
        headers: {
          "Content-Type": "application/json",
        },
        data: {
          model: "llama3.2:3b",
          stream: true,
          messages: [{ role: "user", content: prompt }],
        },
      });

      // Detectamos cuando realmente se termina el stream
      finished(ollamaRes.data, () => {
        console.log("🧠 PROMPT:", prompt);
        console.log("💬 RESPUESTA COMPLETA:", fullResponse);
        console.log("✅ Fin real del stream");
        safeEnd();
      });
      let fullResponse = "";
      ollamaRes.data.on("data", (chunk) => {
        if (closed || ended) return;

        const lines = chunk.toString().split("\n").filter(Boolean);
        for (const line of lines) {
          if (closed || ended) break;

          try {
            const json = JSON.parse(line);
            const content = json.message?.content;
            if (content) {
              fullResponse += content;
              safeWrite(`data: ${content}`);
            }
          } catch (_) {
            // Línea malformada (keep-alive o vacía)
          }
        }
      });

Prueba backend

Crear Frontend

El objetivo es enviar los prompt del usuario, mostrar los mensajes del usuario y la respuesta que llega del servicio de SAP CAP de forma relativamente moderna.

Prueba frontend

Conclusiones

Lo más jodido es aprender a tratar los streams, personalmente no suelo trabajar con streams, es mas usual trabajar de forma en la que obtienes la respuesta completa, ollama tiene una cabecera para que se devuelva la respuesta de esta forma sin embargo me apetecía montar ese efecto de escritura cuando responde el bot.

Repo con mi código por si te sirve de algo :D https://github.com/Betheval/sap-cap-ollama-iachat

SAP CAP + RabbitMQ: Cómo hacer que tu backend hable con colas de mensajes

Miguel Valerio Gutiérrez Pardo — Sat, 12 Apr 2025 15:29:47 +0000

¿Desacoplar CAP? ¿Que en vez de peticiones directas, se manden mensajitos por una cola y así evitar cuellos de botella? Pues hoy te voy a contar cómo integrar SAP CAP con RabbitMQ, una de las soluciones de mensajería más usadas en el mundillo.

¿Qué vamos a montar?

Un proyecto SAP CAP (Node.js)
Un servidor RabbitMQ local o en Docker
Una integración para enviar mensajes desde CAP a una cola en RabbitMQ Opcional: un consumer para leer esos mensajes (porque está guay ver qué se recibe).

Requisitos previos

Node.js instalado
Docker (para RabbitMQ)
Proyecto CAP creado (cds init sap-cap-rabbitmq)
Cliente AMQP para Node.js (usaremos amqplib)

npm install amqplib

Levantando RabbitMQ con Docker

Si no tienes un RabbitMQ montado, en 5 segundos lo tienes:

docker run -d --hostname my-rabbit --name some-rabbit -p 5672:5672 -p 15672:15672 rabbitmq:3-management

La consola de administración estará en: http://localhost:15672
Usuario: guest / Contraseña: guest

Integrando SAP CAP con RabbitMQ

Vamos a crear un servicio en CAP que envíe mensajes a RabbitMQ.

Crea un módulo JS para la conexión /srv/cat-service.js

const cds = require('@sap/cds');
const amqp = require('amqplib');

module.exports = cds.service.impl(async function () {

    this.on('sendMessage', async (req) => {
        const { queue, message } = req.data;

        try {
            // Conectar a RabbitMQ
            const connection = await amqp.connect('amqp://localhost');
            const channel = await connection.createChannel();
            await channel.assertQueue(queue, { durable: false });

            console.log(`📤 Enviando mensaje a ${queue}...`);

            // Enviar el mensaje a la cola una vez
            channel.sendToQueue(queue, Buffer.from(message));
            console.log(`📤 Mensaje enviado a ${queue}: ${message}`);

            // Cerrar conexión
            await channel.close();
            await connection.close();
            console.log('🔌 Conexión cerrada');

            return `Mensaje enviado a ${queue}`;
        } catch (error) {
            console.error('❌ Error enviando mensaje:', error);
            return 'Error al enviar el mensaje';
        }
    });


});

Define la acción en tu CDS

/srv/cat-service.cds

using myapp from '../db/schema';

service MensajeriaService {
    entity Mensajes as projection on myapp.Mensajes;
    action sendMessage(queue: String, message: String) returns String;
}

Define la entidad mensaje

namespace myapp;

entity Mensajes {
    key ID : UUID;
    queue  : String;
    message: String;
}

Testea enviando un POST al servicio

curl -X POST http://localhost:4004/catalog/sendToQueue -H "Content-Type: application/json" -d '{"text": "¡Hola Rabbit!"}'

Verifica el mensaje en la consola de RabbitMQ

Entra en http://localhost:15672, busca la cola my_queue y verás tu mensaje esperando.

Opcional: Monta otro servicio para consumir de la cola de RabbitMQ, aquí te dejo un código de ejemplo.

const cds = require('@sap/cds');
const amqp = require('amqplib');

module.exports = cds.service.impl(async function () {
    const queue = 'myQueue'; // Nombre de la cola en RabbitMQ

    async function consumeMessages() {
        try {
            // Conectar a RabbitMQ
            const connection = await amqp.connect('amqp://localhost');
            const channel = await connection.createChannel();
            await channel.assertQueue(queue, { durable: false });

            console.log(`📥 [SAP CAP] Esperando mensajes en la cola: ${queue}...`);

            // Consumir mensajes de la cola
            channel.consume(queue, async (msg) => {
                if (msg !== null) {
                    const messageContent = msg.content.toString();
                    console.log(`✅ Mensaje recibido: ${messageContent}`);

                    // Aquí puedes procesar el mensaje, por ejemplo, guardarlo en la base de datos
                    const db = await cds.connect.to('db');
                    await db.run(INSERT.into('Mensajes').entries({
                        ID: cds.utils.uuid(),
                        queue: queue,
                        message: messageContent
                    }));

                    // Confirmar procesamiento del mensaje
                    channel.ack(msg);
                }
            });

        } catch (error) {
            console.error('❌ Error en el consumidor de RabbitMQ:', error);
        }
    }

    // Ejecutar el consumidor cuando arranque el servicio CAP
    consumeMessages();
});

Conclusión

Y listo. Ya tienes SAP CAP enviando mensajes a RabbitMQ. Esto viene genial para desacoplar procesos pesados o notificar a otros sistemas.
Aquí tienes dos proyectos CAP con los servicios que hablamos anteriormente por si necesitas alguna referencia. Enlace

Conectar SAP CAP con PostgreSQL en Docker

Miguel Valerio Gutiérrez Pardo — Sun, 09 Mar 2025 13:15:45 +0000

Si estás trabajando con SAP CAP y quieres usar PostgreSQL en lugar de SQLite, este post es para ti. Te voy a explicar paso a paso cómo conectar tu aplicación CAP con una base de datos PostgreSQL corriendo en Docker.

Requisitos previos

Antes de empezar, asegúrate de tener instalado:

Node.js y el framework @sap/cds
Docker y Docker Compose
Un editor (VS Code)

Si no tienes SAP CAP, instálalo con:

npm install -g @sap/cds-dk

Ahora que estás listo, vamos a levantar PostgreSQL con Docker.
Levantando PostgreSQL con Docker

Vamos a crear un docker-compose.yml para lanzar PostgreSQL:

version: '3'
services:
  postgres:
    image: postgres:latest
    container_name: cap_postgres
    restart: always
    environment:
      POSTGRES_USER: cap_user
      POSTGRES_PASSWORD: cap_pass
      POSTGRES_DB: cap_database
    ports:
      - "5432:5432"

Guarda este archivo y ejecuta:

docker-compose up -d

Esto va a levantar un contenedor con PostgreSQL corriendo en el puerto 5432.

Instalando el driver de PostgreSQL en SAP CAP

Ahora, toca decirle a CAP que vamos a usar PostgreSQL en lugar de la base de datos por defecto. Para eso, instalamos el driver:

npm install @cap-js/postgres

Configurando la conexión en package.json

Edita el archivo package.json y agrégale esto dentro de la sección cds.requires:

"cds": {
  "requires": {
    "db": {
      "kind": "postgres",
      "credentials": {
        "host": "localhost",
        "port": 5432,
        "database": "cap_database",
        "user": "cap_user",
        "password": "cap_pass"
      }
    }
  }
}

Esto le dice a CAP que la base de datos es PostgreSQL y le pasamos las credenciales.
Acuerdate de: https://cap.cloud.sap/docs/node.js/cds-env

Creando la base de datos en CAP

Ejecuta este comando para desplegar el esquema en PostgreSQL:

cds deploy --to postgres

si todo sale bien, verás algo como "Successfully deployed to PostgreSQL".

Ya tienes SAP CAP corriendo con PostgreSQL en Docker. Ahora puedes aprovechar PostgreSQL en tus proyectos CAP sin problemas.

Primeros pasos con SAP CAP: Crea tu primera API y servicio OData en minutos 🚀

Miguel Valerio Gutiérrez Pardo — Sun, 26 Jan 2025 17:13:12 +0000

1. Una pequeña introducción

Si estás buscando una forma sencilla de desarrollar APIs empresariales escalables con integración nativa en el ecosistema SAP, SAP CAP es para ti. Este tutorial te guiará desde la configuración inicial hasta tener un servicio OData funcional que puedas consumir.
SAP CAP es una herramienta que empodera a los desarrolladores para crear aplicaciones empresariales más rápido, con menos esfuerzo y de manera alineada con los ecosistemas SAP.
SAP CAP se basa en principios de desarrollo centrados en servicios (service-centric) y promueve las mejores prácticas de diseño, como el uso de Core Data Services (CDS) para modelar datos y generar servicios de forma declarativa.

2. Configuración del entorno

Siendo breve y simplificando, lo que vamos a crear es una aplicación backend JS basada en NodeJs usando el framework de SAP CAP.

Requisitos:
Node.js: https://nodejs.org/es
Instalar el CAP CLI con:

npm install -g @sap/cds-dk

Crea un nuevo proyecto:
cds init mi-primer-proyecto

cd mi-primer-proyecto
npm install

3. Desarrollar la aplicación

Crea un archivo en db/schema.cds con el siguiente contenido:

entity Books {
    key ID : Integer;
    title : String;
    author : String;
    stock : Integer;
}

En SAP CAP, una "entidad" es una representación de un conjunto de datos estructurados dentro del modelo de dominio. Es similar a una tabla en una base de datos relacional.
Muestra cómo probar la consistencia del modelo ejecutando:

cds watch

Esto levanta un servidor local de desarrollo, sin embargo no vas a poder exponer el modelo que creaste, necesitarás declarar un nuevo servicio.

Crea el archivo srv/cat-service.cds:

using { Books } from '../db/schema';

service CatalogService {
    entity BooksProjection as projection on Books;
}

Este archivo es la declaracion de un servicio llamado CatalogService.
Se está creando sobre Books una proyección llamada BooksProjection.
Una proyección permite seleccionar, filtrar o transformar datos de una entidad base, creando una vista personalizada de los datos.

4. Consume el servicio

Navega al endpoint generado automáticamente:
http://localhost:4004/
o también
http://localhost:4004/odata/v4/catalog/BooksProjection

Puedes usar Postman para hacer consultas:
GET http://localhost:4004/odata/v4/catalog/BooksProjection

$metadata

El endpoint $metadata devuelve un archivo en formato XML que incluye:

Entidades y sus propiedades
Relaciones entre entidades: Expone cómo las entidades están vinculadas (por ejemplo, relaciones uno a muchos).
Acciones y funciones: Si el servicio tiene lógica personalizada.
Tipos de datos complejos: Detalla tipos personalizados que no son simples.

5. Agregar datos

Para agregar datos rápidamente puedes usar el siguiente comando:
cds add data
Este código va a agregar un csv por cada entidad con las cabeceras, puedes rellenar estos csv con datos de prueba.

Este sería el resultado final cuando se consume el servicio:

Usando postman:

El servicio que se va a crear es OData, por lo tanto se puede filtrar usando los métodos de OData:

GET http://localhost:4004/odata/v4/catalog/BooksProjection?$filter=author eq 'J.D. Salinger'

Ahora que tienes un servicio básico funcionando, puedes extender tu aplicación conectándola a una base de datos como PostgreSQL, agregando lógica personalizada o incluso creando una interfaz Fiori Elements para visualizar los datos.