Tienda-Educativa-MCP
by jorgektch
README.md
<!-- .slide: class="cover" -->
<div class="cover-card">
<p class="cover-kicker" data-config="eyebrow">TALLER PRÁCTICO · PYTHON · MCP</p>
<h1 class="cover-title" data-config="title">Tu Primer Servidor MCP</h1>
<p class="cover-description" data-config="subtitle">Expón herramientas, recursos y prompts a aplicaciones de IA.</p>
<div class="cover-separator"></div>
<p class="cover-author" data-config="name">Jorge Jesús Quispe Villaverde</p>
<p class="cover-role" data-config="role">AI Engineer · Applied AI Researcher · AI Mentor</p>
<div class="contact-row" aria-label="Contacto del expositor">
<a class="contact-email" data-config="email" href="mailto:jorgektch@gmail.com">jorgektch@gmail.com</a>
<div class="contact-socials" aria-label="Redes del expositor">
<a class="social-icon" data-social="github" href="https://github.com/jorgektch" aria-label="GitHub"><i class="fa-brands fa-github" aria-hidden="true"></i><span class="social-label">GitHub</span></a>
<a class="social-icon" data-social="instagram" href="https://www.instagram.com/jorgektch" aria-label="Instagram"><i class="fa-brands fa-instagram" aria-hidden="true"></i><span class="social-label">Instagram</span></a>
<a class="social-icon" data-social="tiktok" href="https://www.tiktok.com/@jorgektch" aria-label="TikTok"><i class="fa-brands fa-tiktok" aria-hidden="true"></i><span class="social-label">TikTok</span></a>
<span class="social-handle" data-config="handle">/jorgektch</span>
</div>
</div>
</div>
<div class="readme-only">
<p><strong>Tercer taller de la serie:</strong> una fuente Markdown para documentación y 49 diapositivas interactivas. Aprenderás a crear un servidor MCP oficial v2 con herramientas, recursos, prompts y un cliente real sin usar modelos comerciales.</p>
<p><a href="https://jorgektch.github.io/tu-primer-servidor-mcp/">▶ Presentación</a> · <a href="https://jorgektch.github.io/tu-primer-servidor-mcp/demo/">🧪 Simulador visual (no conecta a MCP)</a> · <a href="notebooks/01_tu_primer_servidor_mcp.ipynb">📓 Notebook</a> · <a href="docs/REFERENCIAS.md">📚 Fuentes oficiales</a> · <a href="docs/GUIA_DEL_INSTRUCTOR.md">🎓 Guía del instructor</a>.</p>
<p><strong>Ruta:</strong> función Python → contrato Tools/Resources/Prompts → servidor MCP → cliente stdio → Inspector → HTTP local → evaluación y seguridad. Requiere <strong>Python 3.11+</strong> para el SDK v2; los tests de catálogo y la demo web funcionan sin claves ni SDK.</p>
<p><strong>Inicio rápido:</strong> <code>python 01_python_sin_mcp.py</code>, <code>pip install -r requirements.txt</code>, <code>python 02_probar_cliente_mcp.py</code>. Los precios e inventario son ficticios; no se realizan compras.</p>
<p><strong>Continuidad:</strong> <a href="https://github.com/jorgektch/tu-primera-red-neuronal">Tu Primera Red Neuronal</a> → <a href="https://github.com/jorgektch/tu-primer-agente-ia">Tu Primer Agente de IA</a> → <a href="https://github.com/jorgektch/tu-primer-servidor-mcp">Tu Primer Servidor MCP</a>.</p>
</div>
Note: Introducir MCP como un protocolo de interacción. El servidor no es un modelo y no toma decisiones autónomas.
---
## 02 · Un problema de integración
Tenemos una tienda ficticia que sabe responder sobre **stock y precios**.
| Antes | Ahora |
|:--|:--|
| Cada app importa funciones Python | Varias apps pueden descubrir capacidades mediante MCP |
| Integración específica | Contrato de interacción común |
| La documentación se mantiene a mano | Schemas y capacidades se descubren |
**Pregunta:** ¿cómo permitir que otro cliente utilice esas funciones sin copiarlas?
Note: Pedir una propuesta antes de nombrar el protocolo.
---
## 03 · Objetivos del taller
1. Explicar la diferencia entre **host, cliente y servidor MCP**.
2. Construir **Tools, Resources y Prompts** con el SDK oficial.
3. Ejecutar un cliente real por **stdio** y observar sus resultados.
4. Probar **Streamable HTTP** e Inspector en desarrollo local.
5. Validar seguridad, entradas y contratos sin usar ningún LLM.
**Producto final:** servidor de inventario + cliente real + pruebas + demo conceptual.
Note: Distinguir cliente real de demo web ilustrativa.
---
## 04 · Ruta de siete módulos
```mermaid
flowchart LR
A["1 · Fundamentos"] --> B["2 · Python puro"]
B --> C["3 · Contratos MCP"]
C --> D["4 · Servidor"]
D --> E["5 · Cliente e Inspector"]
E --> F["6 · Seguridad y pruebas"]
F --> G["7 · Integración y retos"]
```
Note: Dar un panorama del flujo, sin saltar todavía al código.
---
## 05 · De la serie al servidor MCP
```mermaid
flowchart LR
NN["Red neuronal<br/>Aprender patrones"] --> AG["Agente de IA<br/>Decidir herramientas"]
AG --> MCP["Servidor MCP<br/>Exponer herramientas"]
MCP --> APP["Clientes y hosts<br/>Consumir capacidades"]
```
**No son equivalentes:** una red aprende parámetros; el agente puede decidir; el servidor MCP publica capacidades pero no necesita un LLM.
Note: Recordar los dos talleres previos.
---
## 06 · ¿Qué es Model Context Protocol?
**MCP es un protocolo abierto para conectar aplicaciones de IA con herramientas y fuentes de contexto**, mediante una interfaz estandarizada.
- **No** es un modelo de lenguaje.
- **No** es por sí mismo un agente autónomo.
- **No** equivale a una base de datos o a REST.
- Sí define cómo **descubrir, invocar y consumir** capacidades.
Lectura: [documentación oficial de MCP](https://modelcontextprotocol.io/).
Note: No confundir la metáfora de conector universal con garantías de autorización.
---
## 07 · Host, cliente y servidor
```mermaid
flowchart LR
U["Usuario"] --> H["HOST<br/>Aplicación / IDE"]
H --> C["CLIENTE MCP<br/>Habla el protocolo"]
C <-->|"MCP"| S["SERVIDOR MCP<br/>Python"]
S --> L["Catálogo ficticio"]
H -. "Opcional" .-> LLM["Modelo de IA"]
```
**Host:** aplicación que integra los servicios. **Cliente:** conexión MCP que usa el host. **Servidor:** expone capacidades. El modelo es opcional para este taller.
Note: Enfatizar dónde está el control y el aislamiento.
---
## 08 · Tres primitivas principales
| Primitiva | Qué expone | Uso habitual |
|:--|:--|:--|
| **Tool** | Función invocable | Consultar stock, cotizar |
| **Resource** | Información por URI | Catálogo, ficha de producto |
| **Prompt** | Mensaje reutilizable | Guion de cotización |
**Matiz:** el host decide qué publicar y permitir; una aplicación/usuario/modelo puede iniciar su uso según su interfaz. Las tres no son sinónimos.
Note: Evitar simplificar la gobernanza como propiedad exclusiva del LLM.
---
## 09 · El protocolo no es el transporte
```mermaid
flowchart TB
P["Operaciones MCP<br/>tools/list · tools/call · resources/read · prompts/get"]
P --> T{Transporte}
T --> STD["stdio<br/>Proceso local"]
T --> HTTP["Streamable HTTP<br/>Servicio remoto/local"]
STD --> S["Mismo servidor lógico"]
HTTP --> S
```
**stdio** es ideal para programas locales; **Streamable HTTP** para un endpoint. SSE independiente es un transporte heredado.
Note: SSE no es la recomendación para nuevas integraciones.
---
## 10 · Concepto JSON-RPC
Una llamada MCP puede transportarse como **mensajes estructurados**, con identificadores de solicitudes y resultados.
```json
{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"consultar_stock","arguments":{"producto":"bicicleta"}}}
```
**Ilustración conceptual:** el SDK maneja formato, versiones y transporte; no hace falta construir a mano estos mensajes.
Note: No presentar el ejemplo como una traza literal de v2 en todos los transportes.
---
## 11 · MCP v2: cuidado con tutoriales antiguos
El SDK oficial de Python tiene una **línea estable v2**, con cambios respecto a v1:
```python
# v2 (este taller)
from mcp.server import MCPServer
mcp = MCPServer("Tienda-Educativa-MCP")
```
Los tutoriales antiguos pueden usar `from mcp.server.fastmcp import FastMCP`.
**Requisito:** Python 3.11+ y dependencias `mcp[cli]>=2,<3`.
[Guía de migración oficial](https://py.sdk.modelcontextprotocol.io/migration/).
Note: Mencionar que la compatibilidad del cliente/host depende del protocolo que soporte.
---
## 12 · Preparación del entorno
```bash
python --version
python -m venv .venv
# Windows: .venv\Scripts\Activate.ps1
# macOS/Linux: source .venv/bin/activate
python -m pip install -r requirements.txt
```
**Sin API keys:** no necesitas Gemini, OpenRouter ni Claude para construir y probar el servidor.
**Antes de instalar:** ejecuta `python 01_python_sin_mcp.py`.
Note: Python 3.11 o superior; si Windows usa py -3.12, adaptar comandos.
---
## 13 · Primero: la lógica de negocio
```python
from catalogo import consultar_stock, cotizar_producto
print(consultar_stock("bicicletas"))
print(cotizar_producto("bicicleta", 2))
```
**Resultado:** stock 3; cotización de **S/ 1700.00** (sin compra).
Esto todavía **no es MCP**: son funciones Python normales. Esa separación permite probarlas sin instalar el SDK.
Note: Ejecutar función delante de los asistentes antes de crear servidor.
---
## 14 · Un solo catálogo ficticio
| Producto | Stock | Precio |
|:--|--:|--:|
| Bicicleta | 3 | S/ 850.00 |
| Casco | 0 | S/ 120.00 |
| Candado | 5 | S/ 45.00 |
| Luz | 8 | S/ 35.00 |
`data/inventario.json` es la fuente compartida por Python y la demostración web.
*Para evitar errores monetarios, guardamos precios como enteros de céntimos.*
Note: No se realizan cambios ni ventas reales.
---
## 15 · La validación es parte del diseño
```mermaid
flowchart TD
I["Entrada de la herramienta"] --> V{¿Válida?}
V -->|No| E["Error de dominio controlado"]
V -->|Sí| P{¿Existe producto?}
P -->|No| E
P -->|Sí| ST{¿Alcanza stock?}
ST -->|No| E
ST -->|Sí| R["Cotización ficticia"]
```
*Una herramienta debe validar sus argumentos incluso cuando los proponga un modelo.*
Note: El modelo no es una barrera de seguridad.
---
## 16 · Las herramientas como contrato
Una **Tool** publica nombre, descripción, tipos de entrada y un resultado.
```python
@mcp.tool()
def consultar_stock(producto: str) -> dict:
"""Consulta unidades disponibles de un producto ficticio."""
return catalogo.consultar_stock(producto)
```
El SDK usa los tipos y el docstring para generar los esquemas del catálogo de herramientas.
Note: Observar qué cambia al agregar el decorador.
---
## 17 · El esquema de entrada
Para `cotizar_producto(producto: str, cantidad: int)`, un cliente puede descubrir:
```json
{
"type": "object",
"properties": {
"producto": {"type": "string"},
"cantidad": {"type": "integer"}
},
"required": ["producto", "cantidad"]
}
```
*Esquema simplificado para enseñanza; el SDK puede añadir metadatos.*
Note: Inspeccionar el schema efectivo usando Inspector o Client.list_tools.
---
## 18 · El servidor inicial
```python
from mcp.server import MCPServer
mcp = MCPServer("Tienda-Educativa-MCP")
@mcp.tool()
def consultar_precio(producto: str) -> dict:
"""Precio unitario en PEN del catálogo simulado."""
return catalogo.consultar_precio(producto)
if __name__ == "__main__":
mcp.run() # stdio
```
El archivo completo está en [`servidor_mcp.py`](servidor_mcp.py).
Note: Mostrar la diferencia entre importar el módulo y ejecutar el servidor.
---
## 19 · Arquitectura del código
```mermaid
flowchart TB
C["cliente_mcp.py<br/>Cliente real"] <-->|"stdio / HTTP"| S["servidor_mcp.py<br/>SDK MCP v2"]
S --> B["catalogo.py<br/>Reglas de negocio"]
B --> D[("data/inventario.json<br/>Datos ficticios")]
W["demo/ · navegador"] -. "Simula visualmente<br/>sin MCP" .-> D
```
**Regla de arquitectura:** el SDK solo publica las funciones; la lógica está aislada y testeable.
Note: El explorador web NO es una implementación del protocolo.
---
## 20 · Resources: información, no acciones
```python
@mcp.resource("inventario://catalogo")
def recurso_catalogo() -> str:
"""Catálogo simulado de solo lectura."""
return json.dumps(catalogo.inventario(), ensure_ascii=False)
```
Un Resource se identifica mediante una **URI** y el cliente puede obtener su contenido.
Ejemplo: `inventario://catalogo`.
Note: Un Resource es una forma de exponer contexto, no equivalente a ejecutar una compra.
---
## 21 · Resource Templates
```python
@mcp.resource("inventario://producto/{producto}")
def recurso_producto(producto: str) -> str:
"""Información de un producto específico."""
...
```
- Recurso fijo: `inventario://catalogo`.
- Plantilla de recurso: `inventario://producto/{producto}`.
- Lectura concreta: `inventario://producto/bicicleta`.
Se descubren con operaciones distintas: `resources/list` y `resources/templates/list`.
Note: Comparar en el Inspector las dos listas.
---
## 22 · Prompts: guías reutilizables
```python
@mcp.prompt()
def guion_cotizacion(producto: str, cantidad: str) -> str:
"""Construye una guía de cotización ficticia."""
return f"Cotiza {cantidad} unidad(es) de {producto}..."
```
El cliente puede descubrir y solicitar esta plantilla con `prompts/list` y `prompts/get`.
**No confundir:** el Prompt no consulta el catálogo ni genera por sí solo una respuesta de un LLM.
Note: Un prompt ayuda a estructurar el trabajo del host.
---
## 23 · Mapa de capacidades publicadas
```mermaid
flowchart TB
SERVER["Nuestro servidor MCP"] --> TOOLS["Tools"]
SERVER --> RES["Resources"]
SERVER --> PR["Prompts"]
TOOLS --> T1["consultar_stock"]
TOOLS --> T2["consultar_precio"]
TOOLS --> T3["cotizar_producto"]
RES --> R1["inventario://catalogo"]
RES --> R2["inventario://producto/{producto}"]
PR --> P1["guion_cotizacion"]
```
3 herramientas + 1 recurso fijo + 1 plantilla + 1 prompt.
Note: Repasar quién consume cada primitiva.
---
## 24 · Por qué usar stdio primero
```mermaid
sequenceDiagram
participant H as Cliente Python
participant S as Servidor MCP (subproceso)
H->>S: Inicia proceso y conexión stdio
H->>S: tools/list
S-->>H: Descripciones y schemas
H->>S: tools/call cotizar_producto(...)
S-->>H: Cotización estructurada
H->>S: Cierra stdin / conexión
```
**Importante:** la salida estándar pertenece al protocolo. Para depurar, registra mensajes en `stderr`.
Note: No añadir print de inicialización al servidor.
---
## 25 · Cliente MCP: descubrimiento
```python
from mcp import Client, StdioServerParameters
params = StdioServerParameters(
command="python", args=["servidor_mcp.py"]
)
async with Client(params) as client:
tools = await client.list_tools()
print([t.name for t in tools.tools])
```
El script real usa `sys.executable` y ruta absoluta para funcionar también en Windows.
Note: El cliente se conecta sin API keys ni LLM.
---
## 26 · Cliente MCP: ejecutar herramientas
```python
resultado = await client.call_tool(
"cotizar_producto", {"producto": "bicicletas", "cantidad": 2}
)
if resultado.is_error:
print("La herramienta devolvió un error")
else:
print(resultado.structured_content)
```
`structured_content` es la salida legible por programas; los bloques de `content` se orientan al consumidor de contenido.
Note: Explicar que un error controlado de negocio no implica error del protocolo.
---
## 27 · Cliente MCP: Resources y Prompts
```python
recursos = await client.list_resources()
plantillas = await client.list_resource_templates()
documento = await client.read_resource("inventario://catalogo")
prompts = await client.list_prompts()
guion = await client.get_prompt(
"guion_cotizacion", {"producto":"bicicleta", "cantidad":"2"}
)
```
Todas las llamadas pasan por el cliente real del SDK.
Note: Mostrar el archivo cliente_mcp.py completo.
---
## 28 · Demostración real en consola
```bash
python 01_python_sin_mcp.py
python -m pip install -r requirements.txt
python 02_probar_cliente_mcp.py
```
El cliente debe mostrar:
- 3 Tools, el Resource y el Prompt.
- `total` igual a **S/ 1700.00** para 2 bicicletas.
- Un recurso leído mediante su URI.
[Ver los scripts](cliente_mcp.py) · [Conectar a un host real](docs/CONEXION_HOSTS.md).
Note: Una llamada MCP no consume tokens de un modelo si no hay un LLM.
---
## 29 · Inspector: observar antes de integrar
```bash
mcp dev servidor_mcp.py
```
En **MCP Inspector**, inspecciona las pestañas **Tools**, **Resources**, **Resource Templates** y **Prompts**.
Prueba `cotizar_producto` con `producto=bicicleta` y `cantidad=2`.
**Nota:** Inspector utiliza herramientas de desarrollo y puede requerir Node.js; no es una web pública del repositorio.
Note: Primero explicar cómo detener Inspector y revisar permisos locales.
---
## 30 · Streamable HTTP: segunda opción
```bash
# Terminal 1: endpoint local
mcp run servidor_mcp.py --transport streamable-http
# Terminal 2: cliente
python cliente_mcp.py --http http://127.0.0.1:8000/mcp
```
En HTTP existe un endpoint; en stdio existe un subproceso. **El catálogo de capacidades es el mismo.**
No expongas este ejemplo sin autenticación a redes públicas.
Note: El comando de CLI y endpoint responden a SDK v2; verificar logs si cambia el puerto.
---
## 31 · Comparación de transportes
| Propiedad | stdio | Streamable HTTP |
|:--|:--|:--|
| Alcance | Local / subprocess | Puerto HTTP |
| Inicio | Host lanza servidor | Servidor persistente |
| Seguridad | Permisos del proceso | TLS, autenticación y red |
| Taller | Primer paso | Ampliación local |
**SSE** como transporte independiente está supersedido para desarrollos nuevos.
Note: No confundir un endpoint HTTP con una API REST genérica.
---
## 32 · ¿Dónde entra un agente de IA?
```mermaid
flowchart TD
U["Usuario pregunta por precios"] --> H["Host con modelo opcional"]
H --> LLM["LLM: decide usar una herramienta"]
LLM --> CL["Cliente MCP"]
CL --> S["Servidor MCP: tools/call"]
S --> DAT["Inventario ficticio"]
DAT --> S --> CL --> LLM
LLM --> R["Respuesta al usuario"]
```
**El servidor no llama al modelo ni decide qué vender.** El host conserva el control.
Note: Conectar el taller anterior de agentes con este servidor.
---
## 33 · Un servidor, varios clientes
```mermaid
flowchart LR
A["Host A<br/>IDE"] --> C1["Cliente MCP A"]
B["Host B<br/>App docente"] --> C2["Cliente MCP B"]
C1 --> S["Servidor MCP<br/>contrato común"]
C2 --> S
S --> D[("Inventario simulado")]
```
Un SDK reduce el esfuerzo de integración; **no elimina** permisos, autenticación ni compatibilidad entre hosts.
Note: Hay varias conexiones; no confundirlo con una única sesión global.
---
## 34 · Amenazas: los inputs no son confiables
```mermaid
flowchart LR
USER["Entrada controlada por usuario/LLM"] --> VALID["Validar tipos y límites"]
VALID --> AUTH["Comprobar permisos"]
AUTH --> ACTION["Ejecutar capacidad mínima"]
ACTION --> OUT["Respuesta limitada"]
BAD["Sin validación"] -. "Riesgo" .-> ACTION
```
**Nunca** ejecutes comandos, rutas de archivo o URLs arbitrarias recibidas de herramientas sin restricciones explícitas.
Note: Mencionar inyección de prompts y datos no confiables.
---
## 35 · Seguridad para nuestro proyecto
- **Sin secretos** en README, JSON, notebooks ni demo.
- **Solo lectura:** ninguna herramienta modifica el inventario.
- **Validación:** cantidad entera de 1 a 100 y productos de catálogo.
- **Datos mínimos:** errores sin rutas internas ni stack traces.
- **Sin acceso a sistema de archivos arbitrario** ni comandos shell.
- **HTTP solo local:** añadir controles de autorización si se despliega.
Consulta [Seguridad](docs/SEGURIDAD.md).
Note: Usar ejemplos concretos sin exponer tokens.
---
## 36 · Errores: negocio vs protocolo
| Tipo | Ejemplo | Tratamiento |
|:--|:--|:--|
| Dominio | Casco sin stock | Resultado `ok:false`, código |
| Validación | Cantidad = 0 | Rechazar cantidad |
| MCP | Tool desconocida | `is_error` o error del protocolo |
| Infraestructura | Proceso no inicia | Revisar dependencias / logs |
**Regla:** el cliente inspecciona `is_error` y la salida estructurada antes de utilizar un resultado.
Note: Destacar dónde se registran los errores.
---
## 37 · Matriz de evaluación reproducible
| Caso | Resultado esperado |
|:--|:--|
| Cotizar 2 bicicletas | S/ 1700.00 |
| Consultar casco | 0 unidades |
| Cotizar 1 casco | `STOCK_INSUFICIENTE` |
| Consultar patineta | `PRODUCTO_NO_ENCONTRADO` |
| Cantidad 0 o booleana | `CANTIDAD_INVALIDA` |
| Leer inventario | 4 productos |
Ejecuta `python -m unittest discover -s tests -p 'test_mcp_*.py' -v`.
Note: Las pruebas de lógica offline no necesitan SDK.
---
## 38 · Pruebas en tres capas
```mermaid
flowchart TB
A["Capa 1 · Catálogo Python puro"] --> B["Capa 2 · Cliente MCP en proceso"]
B --> C["Capa 3 · stdio real e Inspector"]
A --> A1["Sin SDK ni red"]
B --> B1["SDK v2 instalado"]
C --> C1["Verificación de transporte"]
```
En CI se instala el SDK v2 para comprobar **descubrimiento, ejecución y recursos**; la demo web solo verifica el flujo conceptual.
Note: Una prueba en proceso no sustituye del todo a un test stdio.
---
## 39 · Laboratorio visual sin LLM
Abre [**Explorador didáctico**](demo/) y observa las llamadas del cliente:
1. `tools/list`: descubre capacidades.
2. `tools/call`: cotiza bicicletas o consulta stock.
3. `resources/read`: inspecciona el catálogo.
4. `prompts/get`: ve una plantilla preparada.
**La demo web es una simulación del intercambio, no conecta con el proceso MCP real.**
Note: Explicar sin ambigüedad la separación entre simulación y servidor.
---
## 40 · Reto 1 · Agrega una herramienta
Implementa `obtener_categoria(producto: str)` que retorne la categoría desde el catálogo.
**Criterios:**
- Debe consultar `catalogo.py`.
- Debe registrar `@mcp.tool()`.
- Debe dar error controlado para productos desconocidos.
- Debe aparecer en `list_tools()`.
Consulta los [retos](ejercicios/retos.md), pero inténtalo antes de abrir las soluciones.
Note: Pensar primero en el contrato y la prueba.
---
## 41 · Reto 2 · Crea otro recurso
Expón un recurso inmutable `inventario://politicas` que explique que todo es una simulación.
**Preguntas:**
- ¿Qué URI usarías?
- ¿En qué se diferencia de un Prompt?
- ¿Quién debería poder leerlo?
- ¿Cómo comprobarías que no tiene datos privados?
Note: Los recursos son contenido; no darles efectos secundarios.
---
## 42 · Reto 3 · Prueba con Inspector
Completa una tabla de observaciones:
| Operación | ¿Qué observa el cliente? |
|:--|:--|
| `tools/list` | Nombres, descripciones y schemas |
| `tools/call` | Salida estructurada |
| `resources/read` | Contenido del recurso |
| `prompts/get` | Mensaje renderizado |
Entrega una captura **sin credenciales ni rutas sensibles**.
Note: No requiere conectar ningún modelo externo.
---
## 43 · Reto 4 · Modela los límites
Analiza estos intentos:
- `cotizar_producto("casco", 1)`.
- `cotizar_producto("bicicleta", 0)`.
- `cotizar_producto("bicicleta", true)`.
- `cotizar_producto("patineta", 2)`.
- Solicitud para borrar o alterar inventario.
**Debate:** ¿cuál es un error de dominio, cuál de validación y cuál requiere una capacidad que no existe?
Note: El servidor no puede ni debe inventar una herramienta de venta.
---
## 44 · Propuesta de integración real
```mermaid
flowchart TD
LLM["Host/agente opcional"] --> CLIENT["Cliente MCP"]
CLIENT --> SERVER["Servidor MCP"]
SERVER --> BIZ["Dominio y servicios"]
BIZ --> DATA[("Fuente de datos")]
GUARD["Autenticación / autorización / auditoría"] -.-> SERVER
EVAL["Pruebas de contrato y seguridad"] -.-> CLIENT
```
**Para producción:** autorización específica, registros, observabilidad, límites y aislamiento según riesgos.
Note: Esta es arquitectura objetivo, no función incluida en el taller.
---
## 45 · Tres talleres, una ruta formativa
| Taller | Pregunta principal | Entregable |
|:--|:--|:--|
| [Tu Primera Red Neuronal](https://github.com/jorgektch/tu-primera-red-neuronal) | ¿Cómo aprende un modelo? | MLP desde cero |
| [Tu Primer Agente de IA](https://github.com/jorgektch/tu-primer-agente-ia) | ¿Cómo usa herramientas? | Agente Python con LLM |
| **Tu Primer Servidor MCP** | ¿Cómo se publican capacidades interoperables? | Servidor y cliente MCP |
Son complementarios, pero ninguno depende obligatoriamente del anterior.
Note: Reforzar que MCP no necesita LLM para ejecutarse.
---
## 46 · Referencias: especificación y SDK
Fuentes verificables para lo implementado:
- [MCP — introducción y arquitectura](https://modelcontextprotocol.io/).
- [SDK oficial de Python v2 — primeros pasos](https://py.sdk.modelcontextprotocol.io/get-started/first-steps/).
- [Tools, Resources y Prompts](https://py.sdk.modelcontextprotocol.io/servers/tools/).
- [Cliente oficial y transporte stdio](https://py.sdk.modelcontextprotocol.io/client/transports/).
- [Guía de migración v1 → v2](https://py.sdk.modelcontextprotocol.io/migration/).
- [Buenas prácticas de seguridad](https://modelcontextprotocol.io/specification/).
Bibliografía ampliada en [docs/REFERENCIAS.md](docs/REFERENCIAS.md).
Note: Aclarar que nuestros diagramas son originales, no reproducciones de la especificación.
---
## 47 · Checklist de salida
- [ ] Explico **host, cliente y servidor**.
- [ ] Ejecuto `01_python_sin_mcp.py` sin dependencias.
- [ ] Registro y descubro **Tools, Resources y Prompts**.
- [ ] Ejecuto `02_probar_cliente_mcp.py` por stdio.
- [ ] Reviso las pruebas offline y de SDK.
- [ ] Distingo la demo web simulada del cliente MCP real.
- [ ] Reconozco límites de seguridad y permisos.
Note: Diferenciar comprensión conceptual de ejecución comprobada.
---
## 48 · ¿Qué construimos?
**Una biblioteca de negocio reutilizable, un servidor MCP y un cliente MCP real.**
```mermaid
flowchart LR
A["catalogo.py"] --> S["servidor_mcp.py"]
S --> C["cliente_mcp.py"]
C --> H["Aplicación host opcional"]
```
**Sin modelo ni API keys.** El siguiente paso es conectar estas capacidades a un host con políticas de seguridad adecuadas.
Note: Resumir en 30 segundos y proponer una extensión.
---
## 49 · Cierre · Tu Primer Servidor MCP
**Aprendiste a exponer capacidades, no a delegar decisiones ciegamente.**
[Repositorio del taller](https://github.com/jorgektch/tu-primer-servidor-mcp) · [Demo conceptual](demo/) · [Ejercicios](ejercicios/retos.md) · [Guía docente](docs/GUIA_DEL_INSTRUCTOR.md)
**Write once. Document and present anywhere.**
Note: Invitar a modificar una herramienta y agregar una prueba.
This server cannot be deployed
Maintenance
ActivityMaintained
ResponsivenessNo recent community issues