#Large Language Model (LLM)

0 Seguidores · 9 Publicaciones

Un modelo de lenguaje extenso (LLM por sus siglas en inglés) es un modelo de inteligencia artificial diseñado para comprender y generar texto similar al humano basado en grandes cantidades de datos de entrenamiento.

Artículo Alberto Fuentes · sep 12, 2025 5m read

En el artículo anterior vimos cómo construir un agente de IA de atención al cliente con smolagents e InterSystems IRIS, combinando SQL, RAG con búsquedas vectoriales e interoperabilidad.

En ese caso, utilizamos modelos en la nube (OpenAI) para el LLM y los embeddings.

En esta ocasión daremos un paso más: ejecutar el mismo agente, pero con modelos locales gracias a Ollama.


¿Por qué ejecutar modelos en local?

El uso de LLMs en la nube es la opción más sencilla para empezar:

  • ✅ Modelos ya optimizados y mantenidos
  • ✅ Fácil acceso con una simple API
  • ✅ Servicio serverless: no necesitas preocuparte por el hardware ni mantenimiento
  • ❌ Costes por uso
  • ❌ Dependencia de servicios externos
  • ❌ Restricciones de privacidad al enviar datos

En cambio, al correr modelos en local conseguimos:

  • ✅ Control total sobre los datos y el entorno
  • ✅ Sin costes variables por uso
  • ✅ Posibilidad de hacer fine tuning o adaptar modelos con técnicas como LoRA (Low-Rank Adaptation), que permite entrenar algunas capas del modelo para ajustarlo a tu dominio concreto sin necesidad de reentrenarlo entero
  • ❌ Mayor consumo de recursos en tu servidor
  • ❌ Limitaciones en tamaño/modelos dependiendo del hardware

Ahí es donde entra en juego Ollama.


¿Qué es Ollama?

Ollama es una herramienta que facilita la ejecución de modelos de lenguaje y embeddings en tu propio ordenador con una experiencia muy simple:

  • Descargas modelos con un ollama pull
  • Los ejecutas de forma local, expuestos como una API HTTP
  • Los puedes integrar directamente en tus aplicaciones, igual que harías con OpenAI

En resumen: la misma API que usarías en la nube, pero corriendo en tu portátil o servidor.


Configuración básica de Ollama

Primero, instala Ollama desde su web y verifica que funciona:

ollama --version

Después, descarga un par de modelos:

# Descargar un modelo de embeddings
ollama pull nomic-embed-text:latest

# Descargar un modelo de lenguaje
ollama pull llama3.1:8b

# Ver todos los modelos disponibles
ollama list

Puedes probar embeddings directamente con un curl:

curl http://localhost:11434/api/embeddings -d '{
  "model": "nomic-embed-text:latest",
  "prompt": "Ollama hace sencillo ejecutar LLMs en local."
}'

Usar Ollama en el agente de IRIS

El repositorio Customer Support Agent Demo incluye ya la configuración para Ollama. Sólo necesitas:

  1. Descargar los modelos necesarios para ejecutarlos en Ollama Yo he utilizado nomic-embed-text para los embeddings de las búsquedas vectoriales y devstral como LLM.

  2. Configurar IRIS para utilizar embeddings de Ollama con el modelo local:

INSERT INTO %Embedding.Config (Name, Configuration, EmbeddingClass, VectorLength, Description)
  VALUES ('ollama-nomic-config', 
          '{"apiBase":"http://host.docker.internal:11434/api/embeddings", 
            "modelName": "nomic-embed-text:latest"}',
          'Embedding.Ollama', 
          768,  
          'embedding model in Ollama');
  1. Ajustar el tamaño de las columnas para almacenar vectores en las tablas del ejemplo (el modelo local tiene un tamaño diferente de vectores que el de OpenAI original).
ALTER TABLE Agent_Data.Products DROP COLUMN Embedding;
ALTER TABLE Agent_Data.Products ADD COLUMN Embedding VECTOR(FLOAT, 768);

ALTER TABLE Agent_Data.DocChunks DROP COLUMN Embedding;
ALTER TABLE Agent_Data.DocChunks ADD COLUMN Embedding VECTOR(FLOAT, 768);
  1. Configurar el fichero de entorno .env para indicar los modelos que queremos utilizar:
OPENAI_MODEL=devstral:24b-small-2505-q4_K_M
OPENAI_API_BASE=http://localhost:11434/v1
EMBEDDING_CONFIG_NAME=ollama-nomic-config
  1. Actualizar los embeddings

Como tenemos un modelo de embedding diferente del original, debemos actualizar los embeddings utilizando el modelo local nomic-embed-text

python scripts/embed_sql.py
  1. Ejecutar el agente para que haga uso de la nueva configuración

El código ya utilizará la configuración para que tanto los embeddings como el LLM se sirvan desde el endpoint local.

Con esta configuración podrás hacer preguntas como:

  • “¿Dónde está mi pedido #1001?”
  • “¿Cuál es el plazo de devolución?"

Y el agente utilizará:

  • SQL de IRIS para datos estructurados
  • Búsquedas vectoriales con embeddings de Ollama (local)
  • Interoperabilidad para simular llamadas a APIs externas
  • Un LLM local para planificar y generar código que llame a las herramientas necesarias para obtener la respuesta

Conclusión

Gracias a Ollama, podemos ejecutar nuestro Agente de Atención al Cliente con IRIS sin depender de la nube:

  • Privacidad y control de los datos
  • Coste cero por token
  • Flexibilidad total para probar y adaptar modelos (LoRA)

¿El reto? Necesitas una máquina con suficiente memoria y CPU/GPU para correr modelos grandes. Pero para prototipos y pruebas, es una opción muy potente y práctica.


Referencias útiles

0
0 29
Artículo Alberto Fuentes · sep 1, 2025 7m read

Las preguntas de atención al cliente pueden abarcar datos estructurados (pedidos, productos 🗃️), conocimiento no estructurado (docs/FAQs 📚) y otros sistemas integrados (actualizaciones de envío 🚚). En este post vamos a construir un agente de IA compacto que cubre los tres—usando:

  • 🧠 Python + smolagents para orquestar el “cerebro” del agente
  • 🧰 InterSystems IRIS para SQL, Búsqueda Semántica (RAG) e Interoperabilidad (una API de seguimiento de envío simulada)

⚡ TL;DR (versión express)

  • Construye un Agente de Atención al Cliente funcional con Python + smolagents orquestando herramientas sobre InterSystems IRIS (SQL, Búsqueda Semántica/RAG, Interoperabilidad con una API simulada).
  • Responde preguntas reales (p. ej., “¿Se entregó el pedido #1001?”“¿Cuál es el plazo de devolución?”) combinando tablas, documentos y llamadas de interoperabilidad.
  • Inicia IRIS en Docker, carga el esquema y datos de ejemplo, prepara los embeddings de los documentos para RAG, registra herramientas (SQL/RAG/API) y ejecuta el agente por línea de comando o interfaz gráfica.

image


🧭 Lo que vas a construir

Un Agente de Atención al Cliente capaz de:

  • 🔎 Consultar datos estructurados (clientes, pedidos, productos, envíos) vía SQL
  • 📚 Recuperar conocimiento no estructurado (FAQs y documentos) con RAG sobre IRIS Vector Search (Búsqueda Vectorial)
  • 🔌 Llamar a una API de seguimiento envío (simulada) mediante el framework de Interoperabilidad de IRIS, con Visual Trace para inspeccionar cada llamada

Arquitectura (resumida)

Usuario ➜ Agente (smolagents CodeAgent)
               ├─ Herramienta SQL ➜ Tablas en IRIS
               ├─ Herramienta RAG ➜ Búsqueda Vectorial en IRIS (embeddings + chunks)
               └─ Herramienta Seguimiento Envío ➜ Interoperabilidad IRIS (simulada) ➜ Visual Trace

¿Conoces smolagents? Es un framework ligero de agentes de Hugging Face en el que el modelo planifica y utiliza tus herramientas; como alternativas, puedes considerar LangGraph y LlamaIndex.


🧱 Prerrequisitos

  • 🐍 Python 3.9+
  • 🐳 Docker para ejecutar IRIS en un contenedor
  • 🧑‍💻 VS Code para revisar el código
  • 🔑 Clave de API de OpenAI (para el LLM y los embeddings) — o ejecútalo localmente con Ollama si lo prefieres

1) 🧩 Clona el repositorio y prepara un entorno Python

git clone https://github.com/intersystems-ib/customer-support-agent-demo
cd customer-support-agent-demo

python -m venv .venv
# macOS/Linux
source .venv/bin/activate
# Windows (PowerShell)
# .venv\Scripts\Activate.ps1

pip install -r requirements.txt
cp .env.example .env   # añade tu clave de OpenAI

2) 🐳 Arranca InterSystems IRIS (Docker)

docker compose build
docker compose up -d

Abre el Management Portal (http://localhost:52773 en esta demo).


3) 🗃️ Carga los datos estructurados (SQL)

Desde el SQL Explorer de IRIS o tu cliente SQL favorito:

LOAD SQL FROM FILE '/app/iris/sql/schema.sql' DIALECT 'IRIS' DELIMITER ';';
LOAD SQL FROM FILE '/app/iris/sql/load_data.sql' DIALECT 'IRIS' DELIMITER ';';

Este es el esquema que acabas de cargar: image

Ejecuta algunas consultas para familiarizarte con los datos. El agente usará estas tablas para resolver preguntas:

-- Listado de clientes
SELECT * FROM Agent_Data.Customers;

-- Pedidos de un cliente
SELECT o.OrderID, o.OrderDate, o.Status, p.Name AS Product
FROM Agent_Data.Orders o
JOIN Agent_Data.Products p ON o.ProductID = p.ProductID
WHERE o.CustomerID = 1;

-- Info de envío de un pedido
SELECT * FROM Agent_Data.Shipments WHERE OrderID = 1001;

✅ Si ves filas, tu parte estructurada está lista.


4) 📚 Añade conocimiento no estructurado con Vector Search (RAG)

Crea una configuración de embeddings (el ejemplo usa un modelo de OpenAI; ajústalo a tu gusto):

INSERT INTO %Embedding.Config
  (Name, Configuration, EmbeddingClass, VectorLength, Description)
VALUES
  ('my-openai-config',
   '{"apiKey":"YOUR_OPENAI_KEY","sslConfig":"llm_ssl","modelName":"text-embedding-3-small"}',
   '%Embedding.OpenAI',
   1536,
   'a small embedding model provided by OpenAI');

¿Quieres los pasos y opciones exactos? Consulta la documentación

Después, genera los embeddings del contenido de ejemplo:

python scripts/embed_sql.py

Comprueba que los embeddings están en las tablas:

SELECT COUNT(*) AS ProductChunks FROM Agent_Data.Products;
SELECT COUNT(*) AS DocChunks     FROM Agent_Data.DocChunks;

🔎 Bonus: Búsqueda híbrida + vectorial directamente desde SQL con EMBEDDING()

Una gran ventaja de IRIS es que puedes hacer búsqueda semántica (vectorial) dentro de SQL y mezclarla con filtros clásicos—sin microservicios extra. La función EMBEDDING() de SQL crea al vuelo el vector de tu texto de búsqueda y puedes compararlo con vectores almacenados usando operaciones como VECTOR_DOT_PRODUCT.

Ejemplo A — Búsqueda híbrida de productos (filtro por precio + ranking semántico):

SELECT TOP 3
    p.ProductID,
    p.Name,
    p.Category,
    p.Price,
    VECTOR_DOT_PRODUCT(p.Embedding, EMBEDDING('headphones with ANC', 'my-openai-config')) score
FROM Agent_Data.Products p
WHERE p.Price < 200
ORDER BY score DESC

Ejemplo B — Búsqueda semántica de fragmentos de documentos (ideal para alimentar RAG):

SELECT TOP 3
    c.ChunkID  AS chunk_id,
    c.DocID      AS doc_id,
    c.Title         AS title,
    SUBSTRING(c.ChunkText, 1, 400) AS snippet,
    VECTOR_DOT_PRODUCT(c.Embedding, EMBEDDING('warranty coverage', 'my-openai-config')) AS score
FROM Agent_Data.DocChunks c
ORDER BY score DESC

¿Por qué es potente? Puedes pre-filtrar por precio, categoría, idioma, tenant, fechas, etc., y luego ordenar por similitud semántica—todo en una sola sentencia SQL.


5) 🔌 Conecta una API de envíos (mock) con Interoperability

El proyecto expone un pequeño endpoint /api/shipping/status a través de la Interoperabilidad de IRIS — perfecto para simular llamadas “del mundo real”:

curl -H "Content-Type: application/json" \
  -X POST \
  -d '{"orderStatus":"Processing","trackingNumber":"DHL7788"}' \
  http://localhost:52773/api/shipping/status

Ahora abre Visual Trace en el Portal para ver el flujo de mensajes paso a paso (como el radar de un aeropuerto ✈️).


6) 🤖 Conoce al agente (smolagents + tools)

Echa un vistazo a estos archivos:

  • agent/customer_support_agent.py — inicia un CodeAgent y registra las herramientas
  • agent/tools/sql_tool.py — utilidades SQL parametrizadas
  • agent/tools/rag_tool.py — búsqueda vectorial + recuperación de documentos
  • agent/tools/shipping_tool.py — llamadas al endpoint de Interoperability

El CodeAgent planifica qué pasos dar y genera código que llama a tus herramientas. Tú pones las herramientas; él pone el cerebro con un modelo LLM.


7) ▶️ Ejecútalo

Modo one-shot (pruebas rápidas)

python -m cli.run --email alice@example.com --message "Where is my order #1001?"
python -m cli.run --email alice@example.com --message "Show electronics that are good for travel"
python -m cli.run --email alice@example.com --message "Was my headphones order delivered, and what’s the return window?"

CLI interactivo

python -m cli.run --email alice@example.com

Web UI (Gradio)

python -m ui.gradio
# open http://localhost:7860

🛠️ ¿Cómo funciona?

Flujo del agente (simplificado):

  1. 🧭 Planifica cómo resolver la pregunta y qué herramientas usar: p. ej., “comprobar estado del pedido → buscar política de devoluciones”.

  2. 🛤️ Llama a las herramientas según se necesite

    • 🗃️ SQL para clientes/pedidos/productos
    • 📚 RAG sobre embeddings para FAQs/docs (recuerda que puedes prototipar RAG directamente en SQL con EMBEDDING() + operaciones vectoriales como arriba)
    • 🔌 Interoperability API para estado de envíos
  3. 🧩 Sintetiza: compone una respuesta clara y precisa.

Añade o cambia herramientas según crezca tu caso de uso: promociones, garantías, inventario, etc.


🎁 Resumen

Ya tienes un Agente de Atención al Cliente compacto que combina:

  • 🧠 Razonamiento LLM (smolagents CodeAgent)
  • 🗃️ Datos estructurados (IRIS SQL)
  • 📚 Conocimiento no estructurado (IRIS Vector Search + RAG) — con el plus de que EMBEDDING() te permite búsqueda híbrida + vectorial directamente desde SQL
  • 🔌 Llamadas a sistemas en vivo (IRIS Interoperability + Visual Trace)
1
1 60
Artículo Alberto Fuentes · abr 9, 2025 4m read

Si queréis saber por ejemplo si ya está implementada una clase sobre un tema en concreto, ahora es posible haciendo una simple pregunta en lenguaje natural. Descargad y ejecutad la aplicación https://openexchange.intersystems.com/package/langchain-iris-tool para conocer todo sobre vuestras clases de proyecto en un chat.

Instalación:

$ git clone https://github.com/yurimarx/langchain-iris-tool.git
$ docker-compose build
$ docker-compose up -d

Uso:

1. Abrid la URL [http://localhost:8501](http://localhost:8501).  

0
0 56
Artículo Luis Angel Pérez Ramos · abr 1, 2025 6m read

¡Acabo de caer en la cuenta de que nunca terminé esta serie de artículos!

En el artículo de hoy vamos a echar un vistazo a la producción que se encarga de extraer los diagnósticos en CIE-10 más similares a nuestro texto, de tal forma que podamos seleccionar la opción más adecuada desde nuestro frontend.

Buscando similitudes de diagnósticos:

Desde la pantalla que nos muestra las solicitudes de diagnósticos recibidas en HL7 en nuestra aplicación podremos buscar cuales son los diagnósticos CIE-10 más próximos al texto introducido por el profesional.

0
0 50
InterSystems Official Jose-Tomas Salvador · feb 12, 2025

Nos han desbordado las previsiones. Así que, ante el éxito de asistencia y todos los comentarios recibidos, os anuncio una nueva convocatoria extraordinaria del curso: Desarrollo de asistentes virtuales con RAG. ¡Mantenemos el precio promocional reducido! (plazas limitadas).

1
0 69
Artículo Rolano Rebelo · dic 5, 2024 4m read

🌍 Inclusión e Innovación en la Educación 🌍
Nuestro proyecto reimagina el aprendizaje para todos los estudiantes, con un enfoque en la accesibilidad y experiencias interactivas. Diseñado con el objetivo de hacer que la educación sea atractiva e inclusiva, esta herramienta está creada para apoyar a estudiantes de todas las habilidades en el aprendizaje de material complejo de forma intuitiva.

💡 Lo que hace
Esta aplicación educativa transforma presentaciones de lecciones en sesiones de estudio interactivas:

0
0 62
Artículo Jose-Tomas Salvador · nov 18, 2024 2m read

La inteligencia artificial generativa es una inteligencia artificial capaz de generar texto, imágenes u otros datos utilizando modelos generativos, a menudo en respuesta a indicaciones o "prompts". Los modelos de IA generativa aprenden los patrones y la estructura de sus datos de entrenamiento y luego generan nuevos datos con características similares.

0
0 154
Artículo Luis Angel Pérez Ramos · oct 22, 2024 5m read

Bienvenidos a la tercera y última entrega de nuestros artículos dedicados al desarrollo de aplicaciones RAG basadas en modelos LLM. En este artículo final veremos sobre nuestro pequeño proyecto de ejemplo como podemos encontrar el contexto más adecuado a la pregunta que deseamos enviar a nuestro modelo LLM y para ellos haremos uso de la funcionalidad de búsquedas vectoriales incluida en IRIS.

Búsquedas vectoriales

2
0 255
Artículo Alberto Fuentes · ago 16, 2024 5m read

image

Hola Comunidad,

En este artículo, voy a presentar mi aplicación iris-RAG-Gen .

Iris-RAG-Gen es una aplicación generativa AI Retrieval-Augmented Generation (RAG) que aprovecha la funcionalidad de IRIS Vector Search para personalizar ChatGPT con la ayuda del framework web Streamlit, LangChain, y OpenAI. La aplicación utiliza IRIS como almacén de vectores.

image

Características de la aplicación

  • Ingesta de documentos (PDF o TXT) en IRIS
  • Chatear con el documento ingerido seleccionado
  • Borrar Documentos ingerido
  • OpenAI ChatGPT
0
0 102