Nexus - AI Task Orchestrator

62-mcp-debugging
Procedimiento: Depuraci├│n de MCP y Sistema de Instrucciones

Mantenimiento
1 plugin(s)
Titulo
Descripcion
Contenido Markdown
17634 caracteres
# Procedimiento: Depuraci├│n de MCP y Sistema de Instrucciones

## Metadata
- **ID**: PROC-62
- **Frecuencia**: Bajo demanda
- **Duraci├│n estimada**: 15-60 minutos
- **Requiere**: Acceso a Redis, SQL Server, API local
- **Dependencias**: App BigCommerceApi running
- **Bloquea**: Testing de MCP

## Objetivo

Depurar problemas del sistema MCP (Model Context Protocol), incluyendo:
- Session Instructions System
- Feedback System
- Sales Mode / Active Customer
- Redis session flags
- SQL database tables

## Credenciales y Endpoints

### API Key de Pruebas
```
F8026DF8-DAC4-4252-B7DF-FCBC644CEED7
```
- Customer: DMI_TEST
- Scopes: Todos los scopes disponibles
- Uso: Solo para testing local/desarrollo

### Redis
```
Host: 51.75.141.94
Port: 6379
Password: SCqCeETZ1epoaKIvM2Wi
```

### SQL Server (Base de datos IA)
```
Server: api.dmi.es
Database: IA
User: sa
Password: Met@fr@me640
```

### Endpoint Local
```
http://localhost:8080/mcp/tools/{tool_name}
```

## Herramientas Disponibles

### 1. redis-tool (C:\Repositorios\api-bigcommerce\redis-tool)

Herramienta .NET para gestionar claves Redis relacionadas con MCP.

```bash
# Buscar todas las claves MCP/session
cd /c/Repositorios/api-bigcommerce/redis-tool && dotnet run

# Limpiar flag de instrucciones (para re-testear primera llamada)
cd /c/Repositorios/api-bigcommerce/redis-tool && dotnet run -- --clear-instructions

# Borrar todas las claves encontradas (PELIGROSO en producci├│n)
cd /c/Repositorios/api-bigcommerce/redis-tool && dotnet run -- --delete
```

Patrones que busca:
- `*mcp*` - Claves de cach├® de cat├ílogo, columnas
- `*sales:session*` - Sesiones de comerciales y flags de instrucciones
- `*instructions*` - Flags de instrucciones enviadas

### 2. sqlcmd (SQL Server)

```bash
# Verificar base de datos IA existe
sqlcmd -S api.dmi.es -U sa -P "Met@fr@me640" -Q "SELECT name FROM sys.databases WHERE name = 'IA'" -h -1

# Listar tablas en IA
sqlcmd -S api.dmi.es -U sa -P "Met@fr@me640" -d IA -Q "SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE' ORDER BY TABLE_NAME" -h -1

# Ver instrucciones de sesi├│n
sqlcmd -S api.dmi.es -U sa -P "Met@fr@me640" -d IA -Q "SELECT * FROM SessionInstructions WHERE IsActive = 1"

# Ver feedback events
sqlcmd -S api.dmi.es -U sa -P "Met@fr@me640" -d IA -Q "SELECT TOP 10 * FROM AiFeedbackEvent ORDER BY OccurredAt DESC"
```

### 3. curl (API Testing)

```bash
# Test b├ísico de herramienta MCP
curl -s -X POST "http://localhost:8080/mcp/tools/catalog_columns_list" \
  -H "Content-Type: application/json" \
  -H "X-Api-Key: F8026DF8-DAC4-4252-B7DF-FCBC644CEED7" \
  -d '{}'

# Listar herramientas disponibles
curl -s http://localhost:8080/mcp/tools \
  -H "X-Api-Key: F8026DF8-DAC4-4252-B7DF-FCBC644CEED7"

# Test feedback system
curl -s -X POST "http://localhost:8080/mcp/tools/feedback_event_record" \
  -H "Content-Type: application/json" \
  -H "X-Api-Key: F8026DF8-DAC4-4252-B7DF-FCBC644CEED7" \
  -d '{"conversation_id":"test-123","event_type":"product_selected"}'
```

## Escenarios de Depuraci├│n

### A. Session Instructions No Aparecen

**S├¡ntomas**: Primera llamada MCP no incluye `_sessionContext`

**Diagn├│stico**:
```bash
# 1. Verificar si el flag ya existe en Redis
cd /c/Repositorios/api-bigcommerce/redis-tool && dotnet run 2>&1 | grep instructions

# 2. Si existe, limpiar el flag
cd /c/Repositorios/api-bigcommerce/redis-tool && dotnet run -- --clear-instructions

# 3. Si no existe en Redis, verificar MemoryCache (reiniciar app)
# Matar proceso en puerto 8080 y reiniciar
netstat -aon | grep 8080  # Obtener PID
cmd //c "taskkill /PID {PID} /F"
cd /c/Repositorios/api-bigcommerce/src/src/BigCommerceApi && dotnet run --urls=http://localhost:8080 &
```

**Key Redis**: `sales:session:{apikey}:instructions_sent`
- Prefix: `sales:session:` (configurado en SalesSessionOptions)
- TTL: 8 horas (configurable)

### B. Instrucciones Vac├¡as

**S├¡ntomas**: `_sessionContext.instructions` est├í vac├¡o

**Diagn├│stico**:
```bash
# Verificar tabla SessionInstructions tiene datos
sqlcmd -S api.dmi.es -U sa -P "Met@fr@me640" -d IA -Q "SELECT COUNT(*) as Total, SUM(CASE WHEN IsActive=1 THEN 1 ELSE 0 END) as Activas FROM SessionInstructions"

# Ver instrucciones por tipo
sqlcmd -S api.dmi.es -U sa -P "Met@fr@me640" -d IA -Q "SELECT InstructionType, COUNT(*) as Cnt FROM SessionInstructions WHERE IsActive=1 GROUP BY InstructionType"
```

### C. Feedback No Se Guarda

**S├¡ntomas**: Llamadas a `feedback_event_record` no persisten

**Diagn├│stico**:
```bash
# Verificar tabla AiFeedbackEvent
sqlcmd -S api.dmi.es -U sa -P "Met@fr@me640" -d IA -Q "SELECT TOP 5 * FROM AiFeedbackEvent ORDER BY OccurredAt DESC"

# Verificar connection string IA est├í configurada
grep -r "ConnectionStrings.*IA" /c/Repositorios/api-bigcommerce/src/src/BigCommerceApi/appsettings*.json
```

### D. Active Customer No Persiste

**S├¡ntomas**: `sales_customer_set_active` no mantiene el cliente

**Diagn├│stico**:
```bash
# Buscar claves de sesi├│n de ventas
cd /c/Repositorios/api-bigcommerce/redis-tool && dotnet run 2>&1 | grep "sales:session"

# Key format: sales:session:{salesperson_use_code}
# Contiene JSON con: UseCode, Company, Cif, SetAtUtc
```

### E. App No Responde en Puerto 8080

```bash
# Verificar qu├® proceso usa el puerto
netstat -aon | grep 8080

# Matar proceso espec├¡fico (Windows)
cmd //c "taskkill /PID {PID} /F"

# Reiniciar app
cd /c/Repositorios/api-bigcommerce/src/src/BigCommerceApi && dotnet run --urls=http://localhost:8080 &

# Esperar a que est├® lista
timeout 20 sh -c 'until curl -sf http://localhost:8080/mcp/tools >/dev/null 2>&1; do echo -n .; sleep 1; done; echo " Ready!"'
```

## Flujo de Test Completo de Session Instructions

```bash
# 1. Limpiar estado previo
cd /c/Repositorios/api-bigcommerce/redis-tool && dotnet run -- --clear-instructions

# 2. Reiniciar app (limpia MemoryCache)
# [matar proceso existente primero si es necesario]
cd /c/Repositorios/api-bigcommerce/src/src/BigCommerceApi && dotnet run --urls=http://localhost:8080 &

# 3. Esperar a que est├® lista
sleep 10  # o usar el timeout con curl

# 4. Primera llamada - DEBE tener _sessionContext
echo "=== TEST 1: Primera llamada ==="
curl -s -X POST "http://localhost:8080/mcp/tools/catalog_columns_list" \
  -H "Content-Type: application/json" \
  -H "X-Api-Key: F8026DF8-DAC4-4252-B7DF-FCBC644CEED7" \
  -d '{}' | head -c 500
# Esperado: {"_sessionContext":{"instructions":"===...

# 5. Segunda llamada - NO debe tener _sessionContext
echo "=== TEST 2: Segunda llamada ==="
curl -s -X POST "http://localhost:8080/mcp/tools/catalog_columns_list" \
  -H "Content-Type: application/json" \
  -H "X-Api-Key: F8026DF8-DAC4-4252-B7DF-FCBC644CEED7" \
  -d '{}' | head -c 300
# Esperado: {"columns":[...  (sin _sessionContext)

# 6. Verificar flag en Redis
cd /c/Repositorios/api-bigcommerce/redis-tool && dotnet run 2>&1 | grep instructions
# Esperado: sales:session:f8026df8-dac4-4252-b7df-fcbc644ceed7:instructions_sent
```

## Tablas SQL Relevantes (Database: IA)

| Tabla | Prop├│sito |
|-------|-----------|
| `SessionInstructions` | Instrucciones globales y por cliente |
| `AiFeedbackEvent` | Eventos de feedback (clicks, errores, etc.) |
| `AiExplicitFeedback` | Ratings expl├¡citos del usuario |
| `AiConversationSummary` | Resumen de conversaciones finalizadas |
| `AiInteractionFeedback` | Feedback de interacciones espec├¡ficas |

### Estructura SessionInstructions
```sql
InstructionId       INT IDENTITY
CustomerCode        NVARCHAR(50) NULL     -- NULL = global
InstructionType     NVARCHAR(50)          -- empresa, marketing, comercial, producto, calidad
InstructionKey      NVARCHAR(100)
InstructionValue    NVARCHAR(MAX)
SortOrder           INT DEFAULT 0
IsActive            BIT DEFAULT 1
CreatedBy           NVARCHAR(100)
CreatedAtUtc        DATETIME2
UpdatedAtUtc        DATETIME2
```

## Claves Redis Importantes

| Patr├│n | Prop├│sito | TTL |
|--------|-----------|-----|
| `sales:session:{apikey}` | Customer activo del comercial | 8h sliding |
| `sales:session:{apikey}:instructions_sent` | Flag de instrucciones enviadas | 8h sliding |
| `mcp:catalog:base:{customer}:v1:{date}` | Cach├® de cat├ílogo | 1h |
| `mcp:columns:{customer}` | Cach├® de columnas | 24h |
| `mcp:catalog:categories:{customer}` | Cach├® de categor├¡as | 24h |

## Logs Relevantes

Los logs de session instructions aparecen con el logger `MCP.Instructions`:

```
TryInjectSessionInstructions: sessionStore=True, instructionsService=True
HasSentInstructions for F8026DF8: False
Instructions retrieved: total=5, textLength=1234
Session instructions injected for apiKey F8026DF8... (total=5, customer=0)
```

## Checklist de Depuraci├│n

- [ ] App est├í corriendo en puerto 8080
- [ ] Redis accesible (51.75.141.94:6379)
- [ ] SQL Server IA database accesible
- [ ] Tabla SessionInstructions tiene datos activos
- [ ] Flag de instructions_sent NO existe en Redis (para primera llamada)
- [ ] MemoryCache limpia (reiniciar app si es necesario)
- [ ] API Key de test v├ílida

## Gesti├│n Din├ímica de Permisos para Claude Code

### Filosof├¡a
En lugar de mantener una lista est├ítica exhaustiva, Claude Code debe **auto-gestionar** los permisos:

1. **Antes de ejecutar** un comando no trivial ÔåÆ verificar si existe permiso
2. **Si no existe** ÔåÆ a├▒adirlo al fichero de configuraci├│n
3. **Luego ejecutar** ÔåÆ sin interrupciones futuras para el mismo patr├│n

### Fichero de Configuraci├│n
```
.claude/settings.local.json
```

### Estructura Base
```json
{
  "permissions": {
    "allow": [],
    "deny": []
  }
}
```

### Comandos Triviales (NO requieren verificaci├│n previa)
- `ls`, `cat`, `head`, `tail`, `grep`, `echo`, `pwd`, `cd`
- `Read(*)` - lectura de ficheros
- Comandos informativos sin efectos secundarios

### Comandos que S├ì Requieren Gesti├│n de Permisos
| Categor├¡a | Patr├│n a A├▒adir | Ejemplo |
|-----------|-----------------|---------|
| SQL Server | `Bash(sqlcmd:*)` | Cualquier consulta SQL |
| .NET | `Bash(dotnet run:*)`, `Bash(dotnet build:*)`, `Bash(dotnet test:*)` | Compilar, ejecutar, testear |
| HTTP | `Bash(curl:*)` | Llamadas a APIs |
| Procesos | `Bash(netstat:*)`, `Bash(tasklist:*)`, `Bash(taskkill:*)` | Gesti├│n de procesos |
| Redis | `Bash(redis-cli:*)` | Operaciones Redis |
| Windows CMD | `Bash(cmd //c *)` | Comandos Windows nativos |
| PowerShell | `Bash(powershell:*)` | Scripts PowerShell |

### Flujo de Auto-Gesti├│n
```
ÔöîÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÉ
Ôöé  Claude Code quiere ejecutar: sqlcmd -S api.dmi.es ...     Ôöé
ÔööÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÿ
                              Ôöé
                              Ôû╝
ÔöîÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÉ
Ôöé  ┬┐Es comando trivial? (ls, cat, grep, etc.)                 Ôöé
Ôöé  ÔåÆ S├ì: Ejecutar directamente                                Ôöé
Ôöé  ÔåÆ NO: Continuar verificaci├│n                               Ôöé
ÔööÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÿ
                              Ôöé NO
                              Ôû╝
ÔöîÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÉ
Ôöé  Leer .claude/settings.local.json                           Ôöé
Ôöé  ┬┐Existe patr├│n que cubra este comando?                     Ôöé
Ôöé  ÔåÆ S├ì: Ejecutar directamente                                Ôöé
Ôöé  ÔåÆ NO: Continuar                                            Ôöé
ÔööÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÿ
                              Ôöé NO
                              Ôû╝
ÔöîÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÉ
Ôöé  1. Determinar patr├│n apropiado (ej: "Bash(sqlcmd:*)")      Ôöé
Ôöé  2. A├▒adir al array "allow" del fichero                     Ôöé
Ôöé  3. Guardar fichero                                         Ôöé
Ôöé  4. Ejecutar comando                                        Ôöé
ÔööÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÇÔöÿ
```

### Script de Verificaci├│n/Adici├│n (conceptual)
```bash
# Funci├│n que Claude Code deber├¡a ejecutar internamente
add_permission_if_missing() {
    local pattern="$1"
    local settings_file=".claude/settings.local.json"
    
    # Crear estructura base si no existe
    if [ ! -f "$settings_file" ]; then
        mkdir -p .claude
        echo '{"permissions":{"allow":[]}}' > "$settings_file"
    fi
    
    # Verificar si el patr├│n ya existe
    if ! grep -q "$pattern" "$settings_file"; then
        # A├▒adir el patr├│n (usando jq si disponible, o sed)
        jq ".permissions.allow += [\"$pattern\"]" "$settings_file" > tmp.$$.json \
            && mv tmp.$$.json "$settings_file"
        echo "Ô£ô Permiso a├▒adido: $pattern"
    fi
}
```

### Ejemplo de Fichero Auto-Generado

Despu├®s de una sesi├│n t├¡pica de depuraci├│n MCP:
```json
{
  "permissions": {
    "allow": [
      "Read(*)",
      "Bash(sqlcmd:*)",
      "Bash(dotnet run:*)",
      "Bash(dotnet build:*)",
      "Bash(curl:*)",
      "Bash(netstat:*)",
      "Bash(cmd //c \"taskkill*)",
      "Bash(cd /c/Repositorios/*)"
    ],
    "deny": []
  }
}
```

### Consideraciones de Seguridad

ÔÜá´©Å **Patrones que NUNCA auto-a├▒adir** (requieren confirmaci├│n expl├¡cita):
- `Bash(rm -rf:*)` - Borrado recursivo
- `Bash(format:*)` - Formateo de discos
- `Bash(*password*:*)` - Comandos con passwords en claro (aunque en este procedimiento es necesario)
- Cualquier comando que modifique datos de producci├│n

### Inicializaci├│n R├ípida

Para sesiones nuevas, se puede crear el fichero con los permisos base de este procedimiento:
```bash
mkdir -p .claude && cat > .claude/settings.local.json << 'EOF'
{
  "permissions": {
    "allow": [
      "Read(*)",
      "Bash(sqlcmd:*)",
      "Bash(dotnet:*)",
      "Bash(curl:*)",
      "Bash(netstat:*)",
      "Bash(tasklist:*)",
      "Bash(taskkill:*)",
      "Bash(redis-cli:*)",
      "Bash(cmd:*)",
      "Bash(cd:*)",
      "Bash(grep:*)"
    ]
  }
}
EOF
```


---

## Output Estructurado (Nexus)

Al finalizar, el agente DEBE generar un bloque JSON con el siguiente formato para que Nexus pueda procesarlo automaticamente:

```json
{
  "result": "success",
  "summary": "Ejecucion de PROC-62 completada. [Descripcion breve de resultados]",
  "metrics": {
    "issues_found": 0,
    "issues_resolved": 0,
    "issues_resolved": 3,
    "custom": {
      "procedure_specific_metric": "value"
    }
  },
  "backlog_items": [
    {
      "title": "Titulo del item de seguimiento",
      "description": "Descripcion detallada si se requiere accion futura",
      "priority": "medium",
      "type": "improvement",
      "tags": ["proc-62"]
    }
  ],
  "next_steps": [
    "Accion recomendada 1",
    "Accion recomendada 2"
  ],
  "warnings": [
    "Advertencias encontradas durante la ejecucion"
  ]
}
```

**Campos requeridos:**
- `result`: `"success"` | `"partial"` | `"failed"`
- `summary`: Resumen ejecutivo en 1-3 lineas

**Metricas especificas de este procedure:**
- issues_investigated, issues_resolved, time_to_resolution_min

**Criterios de resultado:**
- `success`: Procedimiento completado sin errores criticos
- `partial`: Completado con algunos problemas menores o items pendientes
- `failed`: Error critico o no se pudo completar

## Historial de Ejecuciones

| Fecha | Escenario | Resultado | Notas |
|-------|-----------|-----------|-------|
| 2024-12-27 | Test Session Instructions | OK | Primera implementaci├│n verificada |
| | | | |

## Mensaje de Finalizaci├│n

**IMPORTANTE - ACCI├ôN REQUERIDA AL FINALIZAR:**

Cuando hayas completado todos los pasos de este procedimiento, DEBES ejecutar el siguiente comando usando la herramienta Bash:

Ejecuta: `echo "====== PROCESO TERMINADO [$(date +%H%M%S)] ======" && echo "RESULTADO: MCP debuggeado, problema en [area], solucion aplicada"`

Sustituye [area] por el ├írea del problema (Redis, SQL, Tool, etc.).

## Notas

- El sistema usa MemoryCache como fallback si Redis no est├í disponible
- Las instrucciones se resetean cuando cambia el cliente activo (SetActiveCustomerAsync)
- Los flags de Redis tienen TTL de 8 horas por defecto
- La API key de pruebas F8026DF8-... est├í vinculada al customer DMI_TEST