Skip to content

Commit 0e64e4e

Browse files
alcala28043alcala28043
committed
mcp y slm
1 parent ea54b6b commit 0e64e4e

4 files changed

+377
-0
lines changed

‎_posts/2025-04-14-mcp-model-context-protocol-el-estandar-abierto-para-agentes-ia-colaborativos.md‎

Lines changed: 219 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,219 @@
1+
---
2+
title: 'MCP (Model Context Protocol): El estándar abierto para agentes IA colaborativos'
3+
categories:
4+
- Desarrollo
5+
- Spring Framework
6+
tags:
7+
- Inteligencia Artificial
8+
- Spring
9+
- Desarrollo
10+
- Java
11+
- Spring AI
12+
- Optimización
13+
- Ollama
14+
- MCP
15+
image: assets/img/headers/mcp-model-context-protocol.png
16+
---
17+
18+
## 📌 ¿Qué es MCP?
19+
20+
**MCP (Model Context Protocol)** es un protocolo abierto basado en JSON que define cómo representar el contexto que se intercambia entre agentes de IA o con un modelo de lenguaje (LLM). Permite encapsular:
21+
22+
- El **rol** del agente
23+
- El **objetivo** general de la tarea
24+
- Los **datos de entrada**
25+
- El **historial** relevante de interacción
26+
- Las **instrucciones** precisas para el agente
27+
28+
A diferencia de los prompts planos, MCP ofrece estructura, trazabilidad y flexibilidad para orquestar flujos IA complejos.
29+
30+
---
31+
32+
## 🏗️ Origen de MCP: ¿Quién lo creó y por qué?
33+
34+
**MCP fue propuesto por [Lamini AI](https://lamini.ai)** como parte de su trabajo en modelos empresariales y sistemas multiagente. Su intención fue resolver problemas comunes en flujos IA:
35+
36+
- Pérdida de contexto entre pasos
37+
- Incompatibilidad entre agentes
38+
- Dificultad para auditar decisiones tomadas por IA
39+
- Dificultad para componer tareas complejas
40+
41+
### 🧑‍🔬 ¿Quién lo usa?
42+
43+
- **Lamini AI**: creador y usuario principal
44+
- **CrewAI**: framework para agentes colaborativos en Python (usa MCP como formato de paso entre agentes)
45+
- **Proyectos personalizados**: cualquier arquitectura modular con LLMs se beneficia de MCP (por ejemplo LangGraph, Semantic Kernel…)
46+
47+
### 📚 Especificación
48+
49+
Toda la especificación es pública y está disponible en GitHub:
50+
51+
👉 [https://github.com/lamini-ai/mcp](https://github.com/lamini-ai/mcp)
52+
53+
---
54+
55+
## 🧩 Estructura de un mensaje MCP
56+
57+
```json
58+
{
59+
"context": {
60+
"role": "Analista de datos",
61+
"objective": "Detectar anomalías en el informe mensual de ventas.",
62+
"input": {
63+
"data": "ventas_marzo.csv",
64+
"summary": "Informe mensual con KPIs de marzo."
65+
},
66+
"history": [
67+
{
68+
"sender": "User",
69+
"message": "¿Puedes revisar si hubo caídas significativas?"
70+
},
71+
{
72+
"sender": "Model",
73+
"message": "Se observó una caída del 18% en ventas del producto B."
74+
}
75+
]
76+
},
77+
"instructions": "Resume los hallazgos clave y recomienda acciones."
78+
}
79+
```
80+
81+
---
82+
83+
## 🚀 Casos de uso reales
84+
85+
- **Flujos multiagente IA**: Redactor → Editor → Revisor → Publicador
86+
- **Pipelines IA complejos**: extracción → análisis → visualización → resumen
87+
- **Chatbots empresariales**: donde cada turno del agente está ligado a contexto estructurado
88+
- **Orquestación IA modular con CrewAI, LangGraph**
89+
90+
---
91+
92+
## 🛠️ ¿Cómo implementar MCP en un backend Spring Boot?
93+
94+
Gracias a que MCP es simplemente JSON estructurado, puedes usarlo como un DTO estándar en tu backend Java.
95+
96+
---
97+
98+
### ✅ 1. Definir las clases MCP en Java
99+
100+
```java
101+
public class MCPMessage {
102+
private MCPContext context;
103+
private String instructions;
104+
}
105+
106+
public class MCPContext {
107+
private String role;
108+
private String objective;
109+
private Map<String, Object> input;
110+
private List<MCPHistory> history;
111+
}
112+
113+
public class MCPHistory {
114+
private String sender;
115+
private String message;
116+
}
117+
```
118+
119+
---
120+
121+
### ✅ 2. Crear un endpoint REST para recibir MCP
122+
123+
```java
124+
@RestController
125+
@RequestMapping("/api/mcp")
126+
public class MCPController {
127+
128+
@PostMapping("/process")
129+
public ResponseEntity<String> processMCP(@RequestBody MCPMessage message) {
130+
String rol = message.getContext().getRole();
131+
String objetivo = message.getContext().getObjective();
132+
String instrucciones = message.getInstructions();
133+
134+
// Aquí podrías procesar o delegar la tarea a un modelo
135+
return ResponseEntity.ok("Procesado: " + rol + " | " + objetivo + " | " + instrucciones);
136+
}
137+
}
138+
```
139+
140+
---
141+
142+
### ✅ 3. Convertir MCP a prompt para un modelo LLM
143+
144+
```java
145+
public String construirPrompt(MCPMessage mcp) {
146+
StringBuilder prompt = new StringBuilder();
147+
prompt.append("Rol: ").append(mcp.getContext().getRole()).append("\n");
148+
prompt.append("Objetivo: ").append(mcp.getContext().getObjective()).append("\n");
149+
prompt.append("Instrucciones: ").append(mcp.getInstructions()).append("\n\n");
150+
151+
if (mcp.getContext().getHistory() != null) {
152+
for (MCPHistory h : mcp.getContext().getHistory()) {
153+
prompt.append(h.getSender()).append(": ").append(h.getMessage()).append("\n");
154+
}
155+
}
156+
157+
return prompt.toString();
158+
}
159+
```
160+
161+
---
162+
163+
### ✅ 4. Llamar a un modelo Ollama o OpenAI desde Spring
164+
165+
```java
166+
public String enviarAPromptLLM(String prompt) {
167+
WebClient client = WebClient.create("http://localhost:11434"); // Ollama
168+
String response = client.post()
169+
.uri("/api/generate")
170+
.contentType(MediaType.APPLICATION_JSON)
171+
.bodyValue(Map.of("model", "llama3", "prompt", prompt))
172+
.retrieve()
173+
.bodyToMono(String.class)
174+
.block();
175+
176+
return response;
177+
}
178+
```
179+
180+
---
181+
182+
## 🔐 Buenas prácticas al usar MCP
183+
184+
- **Validar entrada**: asegúrate de que el JSON cumple con la estructura esperada.
185+
- **Limitar el historial**: para evitar inputs demasiado largos o costosos.
186+
- **Persistir MCPs**: para trazabilidad, debugging o auditoría.
187+
- **Sanitizar el input** si va a modelos sensibles (evitar inyecciones o exploits de prompt).
188+
189+
---
190+
191+
## ✅ Ventajas de MCP
192+
193+
| Característica | Beneficio |
194+
|----------------|-----------|
195+
| **Estructurado** | Fácil de validar y auditar |
196+
| **Reutilizable** | Permite compartir tareas entre agentes |
197+
| **Escalable** | Ideal para arquitecturas complejas |
198+
| **Agnóstico al modelo** | Funciona con cualquier LLM |
199+
| **Trazable** | Perfecto para sistemas empresariales o regulados |
200+
201+
---
202+
203+
## 📚 Recursos adicionales
204+
205+
- Repositorio oficial:
206+
🔗 [https://github.com/lamini-ai/mcp](https://github.com/lamini-ai/mcp)
207+
208+
- Frameworks relacionados:
209+
🔧 [https://docs.crewai.com](https://docs.crewai.com) (CrewAI)
210+
211+
---
212+
213+
## 🧠 Conclusión
214+
215+
**MCP (Model Context Protocol)** representa un paso adelante en cómo estructuramos la comunicación con agentes de IA. Si estás construyendo un sistema con múltiples modelos o pasos secuenciales (pipeline), **MCP te permitirá orquestar, auditar y escalar** tu solución de forma limpia y coherente.
216+
217+
Además, su integración en Spring Boot es directa y flexible, lo que lo convierte en una opción excelente para entornos empresariales robustos.
218+
219+
---

‎_posts/2025-04-15-slm-small-language-models-el-futuro-ligero-y-especializado-de-la-ia.md‎

Lines changed: 158 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,158 @@
1+
---
2+
title: 'SLM (Small Language Models): El Futuro Ligero y Especializado de la IA'
3+
categories:
4+
- Inteligencia Artificial
5+
- Aprendizaje
6+
tags:
7+
- Inteligencia Artificial
8+
- SLM
9+
- Optimización
10+
- Herramientas
11+
image: assets/img/headers/slm-small-language-models.png
12+
---
13+
14+
## Introducción
15+
16+
Durante años, los modelos de lenguaje grande (LLM) como GPT-4, PaLM o Claude han dominado el ecosistema de la inteligencia artificial. Estos modelos, con cientos de miles de millones de parámetros, han demostrado una capacidad sorprendente para comprender y generar lenguaje natural, resolver problemas complejos y asistir en tareas creativas o técnicas. Sin embargo, este poder tiene un coste significativo: computacional, energético, económico y ético.
17+
18+
En contraposición, surge una nueva tendencia con gran fuerza: los **Small Language Models (SLM)**, o Modelos de Lenguaje Pequeños. Lejos de ser simples versiones reducidas, los SLM están diseñados para ser más eficientes, especializados y privados, respondiendo a necesidades que los LLM no pueden cubrir adecuadamente.
19+
20+
En este artículo veremos en profundidad:
21+
22+
- Qué son los SLM y cómo se diferencian de los LLM
23+
- Ventajas clave de los SLM
24+
- Casos de uso reales
25+
- Ejemplos de SLM existentes
26+
- Técnicas de entrenamiento y optimización
27+
- Comparativas técnicas y benchmarks
28+
- El futuro de los SLM y su integración con agentes autónomos
29+
30+
---
31+
32+
## ¿Qué es un Small Language Model (SLM)?
33+
34+
Un **Small Language Model (SLM)** es un modelo de lenguaje entrenado con un número relativamente bajo de parámetros (entre 50 millones y 3 mil millones), optimizado para tareas específicas o entornos con restricciones computacionales.
35+
36+
A diferencia de los LLM, los SLM no buscan ser generalistas ni abarcar el conocimiento del mundo, sino resolver problemas concretos con una eficiencia radical.
37+
38+
### Características clave:
39+
40+
| Característica | SLM | LLM |
41+
|--------------------------|------------------------------|--------------------------------|
42+
| Tamaño de parámetros | 50M - 3B | 10B - 500B+ |
43+
| Uso de recursos | Bajo | Alto |
44+
| Entrenamiento | Más rápido, datasets específicos | Largo, con datasets masivos |
45+
| Capacidad de despliegue | Edge, local, on-device | Nube, clústeres, GPU farms |
46+
| Latencia | Baja | Alta (dependiendo del modelo) |
47+
| Privacidad | Alta (on-device) | Baja (requiere enviar datos) |
48+
49+
---
50+
51+
## ¿Por qué usar SLM en lugar de LLM?
52+
53+
### 1. **Costo y consumo energético**
54+
Los LLM requieren GPUs de alto rendimiento, grandes cantidades de memoria y una infraestructura compleja para su inferencia. Los SLM pueden correr en dispositivos modestos como Raspberry Pi, smartphones o servidores edge.
55+
56+
### 2. **Privacidad**
57+
SLM permite la inferencia local, sin necesidad de enviar datos sensibles a servidores externos. Ideal para salud, finanzas, defensa y entornos industriales.
58+
59+
### 3. **Especialización**
60+
Puedes entrenar un SLM en un dominio concreto: medicina, derecho, manufactura, etc., logrando resultados mejores que un LLM generalista en ese campo.
61+
62+
### 4. **Latencia y disponibilidad offline**
63+
Ideal para apps móviles, dispositivos IoT o entornos sin conectividad constante.
64+
65+
---
66+
67+
## Casos de uso reales
68+
69+
### Dispositivos embebidos / IoT
70+
- Comandos por voz en drones, wearables o electrodomésticos.
71+
- Interfaces conversacionales para maquinaria industrial.
72+
73+
### Aplicaciones móviles
74+
- Traducción offline.
75+
- Chatbots privados dentro de apps.
76+
- Asistentes especializados (fitness, nutrición, salud mental).
77+
78+
### Agentes autónomos
79+
- Agentes pequeños con razonamiento local, capaces de ejecutar instrucciones sin depender de la nube.
80+
81+
### Ciberseguridad y pentesting
82+
- Agentes SLM que analizan logs o vulnerabilidades directamente en dispositivos, sin comprometer datos.
83+
84+
---
85+
86+
## Modelos populares y herramientas
87+
88+
### 🔸 **Phi-2 (Microsoft)**
89+
- 2.7B parámetros.
90+
- Entrenado con datasets sintéticos de alta calidad.
91+
- Muy competitivo en benchmarks razonables.
92+
- Ideal para tareas razonadas tipo "Chain of Thought".
93+
94+
### 🔸 **Mistral 7B / Mixtral**
95+
- Aunque más grandes que un SLM típico, los modelos de Mistral han demostrado eficiencia en uso y posibilidad de ser "cuantizados" a formatos de bajo consumo.
96+
97+
### 🔸 **TinyLlama (1.1B)**
98+
- Entrenado desde cero en corpus optimizados.
99+
- Corre en CPU, Raspberry Pi, o incluso en navegadores vía WebAssembly.
100+
101+
### 🔸 **LLaMA 2 (7B) - Quantized**
102+
- Con técnicas como Q4_K_M se puede llevar a dispositivos modestos.
103+
- Base de muchos proyectos offline.
104+
105+
### 🔸 **Gemma (Google)**
106+
- Modelos abiertos y eficientes, con versiones de 2B ideales para uso local o entrenamiento en verticales.
107+
108+
---
109+
110+
## Técnicas de optimización y despliegue
111+
112+
### 🔹 Cuantización
113+
Reduce la precisión de los pesos (de float32 a int8, por ejemplo) sin pérdida significativa de rendimiento.
114+
115+
Herramientas:
116+
- `ggml`, `gptq`, `exllama`, `llm.cpp`, `AutoGPTQ`, `bitsandbytes`
117+
118+
### 🔹 Podado (Pruning)
119+
Se eliminan neuronas o conexiones poco relevantes para mejorar eficiencia.
120+
121+
### 🔹 Distillation
122+
Entrenar un modelo pequeño (estudiante) para imitar el comportamiento de uno grande (profesor), transfiriendo conocimiento de forma comprimida.
123+
124+
### 🔹 Fine-tuning con LoRA/QLoRA
125+
Adaptar modelos base pequeños a tareas concretas usando capas entrenables ligeras.
126+
127+
### 🔹 Instrucción tuning
128+
Ajustar el modelo con ejemplos tipo prompt/respuesta para tareas conversacionales.
129+
130+
---
131+
132+
## Comparativa de benchmarks
133+
134+
| Modelo | Tamaño | MMLU (%) | HumanEval (%) | ARC-Challenge (%) |
135+
|----------------|----------|----------|----------------|--------------------|
136+
| Phi-2 | 2.7B | 63.2 | 39.0 | 75.5 |
137+
| TinyLlama | 1.1B | 51.5 | 26.3 | 64.0 |
138+
| Mistral (7B) | 7B | 70+ | 47+ | 78+ |
139+
| GPT-3.5 Turbo | ~175B | 70-74 | 50-60 | 80+ |
140+
141+
👉 **Conclusión:** Algunos SLM bien entrenados se acercan al rendimiento de LLM en tareas razonables, especialmente cuando están ajustados a tareas específicas.
142+
143+
---
144+
145+
## El futuro de los SLM
146+
147+
La tendencia actual es clara: los SLM se están convirtiendo en los nuevos **agentes locales**, ejecutándose de forma privada y rápida en nuestros dispositivos. A medida que avanza la computación edge, los SLM permitirán crear asistentes personales, sistemas de IA embebidos en software de empresa, juegos con NPCs inteligentes sin conexión, e incluso agentes IA autónomos en drones o robots.
148+
149+
### Integración con agentes
150+
- **AutoGPT-like agents** con razonamiento local.
151+
- SLM + RAG (Retrieval-Augmented Generation) para sistemas QA especializados.
152+
- Orquestación de múltiples SLM especializados, cada uno experto en una función.
153+
154+
---
155+
156+
## Conclusión
157+
158+
Los **Small Language Models (SLM)** no son una moda pasajera, sino una evolución lógica en el desarrollo de IA. Permiten democratizar el acceso, respetar la privacidad, reducir costes y crear soluciones adaptadas a casos de uso reales. Aunque los LLM seguirán siendo importantes en centros de datos y tareas generalistas, el verdadero impacto transformador llegará cuando los SLM se integren en nuestro día a día, invisible, mejorando productos y experiencias sin comprometer nuestros datos ni requerir superordenadores.

‎assets/img/headers/mcp-model-context-protocol.png‎

1.6 MB
Loading

‎assets/img/headers/slm-small-language-models.png‎

1.64 MB
Loading

0 commit comments

Comments
 (0)