> ## Documentation Index
> Fetch the complete documentation index at: https://nekzus-32.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# LiopServer

> Construyendo Nodos de Datos autónomos y migrando herramientas MCP heredadas

La clase `LiopServer` es el corazón del Nodo de Datos. Representa la infraestructura host que orquesta de manera segura las intenciones entrantes de Logic-Injection-on-Origin provenientes de Agentes remotos.

En lugar de escribir entornos de ejecución personalizados para gestionar WebAssembly, aislamiento y redes, tú defines funciones sencillas en JavaScript/TypeScript. El SDK abstrae el complejo sandboxing automáticamente.

## Inicialización y Configuración

Creas un Nodo de Datos indicándole a la red P2P quién eres y proporcionando las propiedades de configuración, como controles de seguridad de datos.

```typescript theme={null}
import { LiopServer, PII_PRESETS } from "@nekzus/liop";

const server = new LiopServer(
  {
    name: "EnterpriseDatabaseNode",
    version: "3.2.0",
  },
  {
    // Identificador único para resolución determinista de tokens
    tokenSlug: "BANK",
    // Escala el descifrado y el sandboxing WASI a través de todos los núcleos de CPU
    workerPool: { enabled: true, maxThreads: 16, maxHeapMb: 128 },
    // Configuración estricta de seguridad y prevención de fugas de datos
    security: {
      piiPatterns: [
        ...PII_PRESETS.US_COMPLIANT,
        /[A-Z]{3}-\d{5}/
      ],
      forbiddenKeys: ["password", "ssn", "secret_token"],
      enableNerScanning: true,
      rateLimit: { maxPerWindow: 30, windowMs: 60_000 }
    },
    // Clasificación del dominio de datos para la taxonomía de la Malla
    taxonomy: {
      domain: "healthcare",
      clearanceTier: 3,
      executionTypes: ["aggregation", "analytics"]
    }
  }
);
```

### Opciones de Configuración

Al instanciar un `LiopServer`, el segundo parámetro permite definir características avanzadas del nodo:

* **`tokenSlug` (Resolución Determinista de Tokens):** Cadena canónica (ej. `"BANK"`) que permite a los agentes remotos resolver de forma segura el token de acceso PQC desde su entorno host (`LIOP_TOKEN_<tokenSlug>`). Debe cumplir con la expresión regular `/^[A-Z][A-Z0-9_]*$/`.
* **`workerPool.maxHeapMb` (Defensa Heap):** Tamaño máximo del heap V8 en megabytes por thread worker (por defecto: `64`). También configurable vía la variable de entorno `LIOP_WORKER_MAX_HEAP_MB`. Previene ataques DoS de tipo Heap Bomb terminando workers que excedan el límite de memoria.
* **`security.forbiddenKeys` (Egress Filter):** Un array de strings. Si el modelo intenta devolver un JSON que contiene cualquiera de estas llaves (ej., `"password"`), el Egress Filter destruirá la respuesta antes de que abandone el servidor.
* **`security.piiPatterns` (Sanitización):** Arrays de `PiiRule`. Puedes usar presets (`PII_PRESETS.GLOBAL_STRICT`, `EU_GDPR`, `US_COMPLIANT`) y combinarlos con regex personalizadas. El motor intercepta cualquier salida que coincida con patrones sensibles.
* **`security.enableNerScanning` (Detección NLP):** Cuando es `true`, activa el escaneo de Reconocimiento de Entidades Nombradas vía la librería NLP `compromise` para detectar nombres de personas, ubicaciones y organizaciones en los valores de salida. Añade \~10ms de latencia. Por defecto: `false`.
* **`security.rateLimit` (Ventana Deslizante):** Configura el limitador de tasa por herramienta para prevenir ataques de micro-exfiltración. `maxPerWindow` (por defecto: `30`) and `windowMs` (por defecto: `60000`) definen los parámetros de la ventana deslizante.
* **`taxonomy` (Clasificación de Dominio):** Metadatos opcionales que clasifican el dominio de datos del servidor (`domain`), el nivel de autorización de seguridad expresado como un `number` (`clearanceTier`), y los tipos de ejecución soportados (`executionTypes`). Estos metadatos se anuncian en la DHT y se usan para enrutamiento inteligente.
* **Estructura Dinámica de Retorno (Auto-i18n) \[PLANIFICADO]:** Esta funcionalidad está en el roadmap. Cuando se implemente, el `LiopServer` inyectará automáticamente directivas *Dynamic Return Structure* en los payloads, obligando a la IA a respetar y devolver las llaves JSON exactamente en el mismo idioma nativo que utilizó el cliente al hacer la solicitud, eliminando la necesidad de librerías de internacionalización (i18n) en tu frontend.

## Creando Capacidades (Tools)

En MCP, estas se llaman Tools (Herramientas). En LIOP, nos referimos a ellas como **Capacidades** (Capabilities).

Para el desarrollador, definir una Capacidad en LIOP se ve virtualmente idéntico a definir una Tool de MCP. Proporcionas un nombre, una descripción, un esquema Zod para seguridad de tipos y un manejador (handler) de ejecución.

```typescript theme={null}
import { z } from "zod";

server.tool(
  "analyze_employee_data",
  "Analiza información sensible de nómina dentro del Sandbox.",
  { department: z.string() },
  async ({ department }) => {
    // La lógica inyectada del Agente se detiene aquí.
    // El Nodo de Datos ejecuta la solicitud local bajo sus propios permisos.
    const result = await database.query(department);

    return {
      content: [{ type: "text", text: `Nómina evaluada: ${result.summary}` }]
    };
  }
);
```

### En qué se diferencia de MCP

Si el código se ve exactamente igual, ¿qué lo hace LIOP?

1. **Sin Polling:** El Nodo de Datos anuncia el esquema de `analyze_employee_data` criptográficamente sobre la DHT de Kademlia. El Agente sabe instantáneamente que el esquema existe sin desperdiciar una petición de red preguntando por `listTools()`.
2. **Transporte Binario:** Cuando el Agente invoca esta herramienta, los parámetros (ej., `department: "HR"`) son comprimidos en bytes puros de Protobuf, omitiendo JSON por completo.

## Exponiendo Esquemas de Datos (Resources)

Los Servidores LIOP también pueden exponer **Recursos** (datos estáticos, esquemas o descripciones) que los Agentes pueden descubrir para entender la forma y estructura de los datos que van a analizar *antes* de inyectar su lógica. Esto permite una verdadera autonomía *Zero-Shot*.

```typescript theme={null}
server.resource(
  "Employee Records Schema",
  "liop://schema/employee_records",
  "El esquema JSON exacto que representa las bases de datos de empleados.",
  "application/json",
  JSON.stringify(EmployeeSchema)
);
```

Estos recursos son puenteados impecablemente a los LLMs genéricos mediante los métodos estándar de MCP `resources/list` y `resources/read`.

## Planificación de IA Avanzada (Prompts y Autonomía)

Al igual que MCP, LIOP soporta nativamente **Prompts**—instrucciones conversacionales con plantillas que ayudan a los Agentes a funcionar antes de inyectar su Logic-Injection-on-Origin.

```typescript theme={null}
server.prompt(
  "analyze_codebase",
  "Instruye al agente sobre cómo recorrer el código de forma segura.",
  [
    { name: "language", description: "Lenguaje objetivo (ej., rust, ts)", required: true }
  ],
  (request) => ({
    description: "Codebase Analysis Prompts",
    messages: [
      { role: "user", content: { type: "text", text: `Analiza el código en ${request.arguments?.language} de forma segura.`} }
    ]
  })
);
```

### Autonomía Zero-Shot (El Analista Ciego)

LIOP incluye de fábrica un System Prompt Maestro de grado industrial diseñado para enseñar y adiestrar a LLMs genéricos (como Claude o GPT-4) sobre cómo generar lógica `.wasm` o JavaScript dinámicamente sin alucinar y respetando estrictamente los límites del Sandbox del Nodo.

Puedes activar este adiestramiento estructural explícitamente:

```typescript theme={null}
server.enableZeroShotAutonomy();
```

Esto registrará automáticamente el prompt inteligente `liop_blind_analyst` en la Malla, inyectando tu *Data Dictionary* directamente en el contexto del modelo.

## Seguridad y Gestión de Memoria

Cuando un Nodo de Datos recibe un payload `.wasm` o `.js`, el módulo **`GuardianTS`** somete su Árbol de Sintaxis Abstracta (AST) a una Inspección Heurística de Tiempo-Cero para garantizar seguridad absoluta.

Antes de que cualquier módulo WebAssembly sea siquiera instanciado o ejecutado, `GuardianTS` escanea todas sus importaciones. Rechaza estrictamente cualquier payload que intente enlazarse a APIs no autorizadas del host. Solamente las APIs estándar de WASI (`wasi_snapshot_preview1`) y las funciones nativas en sandbox de `LIOP` son permitidas, previniendo categóricamente escapes de la sandbox.

Esta pesada evaluación de AST se cachea agresivamente en memoria `O(1)` para permitir ejecuciones subsiguientes ultra veloces de exactamente la misma lógica.

Si te encuentras desplegando parches de seguridad *Zero-Day* en el host de ejecución o necesitas invalidar forzosamente la memoria del Nodo, puedes purgar el almacenamiento en caché del AST de forma manual y síncrona:

```typescript theme={null}
server.clearAstCache();
```

## Conectando Servidores MCP Heredados (Legacy)

El objetivo principal de LIOP es una rápida adopción por parte de la industria. Si has pasado meses construyendo un servidor estándar del Protocolo de Contexto de Modelos (MCP), no necesitas reescribirlo para unirte a la red.

El `@nekzus/liop` incluye el `LiopMcpBridge`.

Este poderoso adaptador intercepta las peticiones binarias entrantes de la malla LIOP, las traduce a estándar JSON-RPC 2.0 localmente, las reenvía a tu Servidor MCP sin modificar vía stdio o SSE, y empaqueta la respuesta estándar de MCP de vuelta hacia la red P2P ultra rápida.

```typescript theme={null}
import { LiopMcpBridge } from "@nekzus/liop/bridge";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

// Tu implementación estándar de MCP heredado
const mcpServer = new McpServer({ name: "LegacyWeatherApp", version: "1.0" });

// Envuélvelo en el Puente LIOP con opciones completas
const bridge = new LiopMcpBridge(mcpServer, {
  publishToMesh: true,             // Anunciar este servidor en la DHT P2P
  meshIdentity: "WeatherNode_01",  // Identificador único del nodo
  serverInfo: { name: "WeatherBridge", version: "2.0" },  // Sobrescribir identidad
  security: {                      // Protección PII/egress opcional
    forbiddenKeys: ["api_key", "internal_token"],
    piiPatterns: [...] 
  }
});

// Inicia el puente
await bridge.connect();
```

Tu aplicación heredada es ahora completamente accesible para Agentes de IA Web3, descentralizados y Post-Cuánticos en todo el mundo sin cambiar una sola línea de tu lógica MCP original.

## API de Runtime y Ciclo de Vida

Además de `connect()`, `LiopServer` expone métodos de bajo nivel para ciclo de vida e inspección de malla:

```typescript theme={null}
// Bootstrap explícito de la malla (mismo comportamiento que el alias connect)
await server.connectToMesh({
  port: 50051,
  meshConfig: {
    bootstrapNodes: ["/ip4/1.2.3.4/tcp/4001/p2p/PEER_ID"],
    listenAddresses: ["/ip4/0.0.0.0/tcp/0"],
    identityPath: "~/.liop/identity.json"
  }
});

const info = server.getServerInfo();
const meshNode = server.getMeshNode();
const grpcPort = server.getBoundPort();

// Cierre ordenado para tests y apagado de procesos en producción
await server.close();
```

## Iniciando el Servidor

Una vez que tus herramientas, watchdogs y puentes están configurados, lanzas el Nodo de Datos vinculándolo a la red:

```typescript theme={null}
await server.connect();
console.log(`Logic Node online. Escuchando Wasms entrantes...`);
```