Inicio Rápido

Inicio rápido con LIOP en menos de 5 minutos mediante el SDK de TypeScript

El ecosistema @nekzus/liop está diseñado para ser potente pero familiar. Si has construido servidores para MCP, la transición a LIOP es casi directa.

En esta guía, crearemos un Servidor LIOP que expone una herramienta y un Cliente que la invoca.

Internamente, LIOP compila la lógica en módulos aislados y la distribuye por la malla. El SDK gestiona el transporte gRPC y P2P subyacente y provee métodos estándar de registro e invocación de herramientas.

¿Desarrollas en Rust? LIOP ofrece crates nativos en Rust (liop-client y liop-core) para software de sistemas, módulos WASI huésped y agentes de baja latencia. Consulta la Visión General del SDK de Rust para instrucciones de configuración con Cargo y ejemplos de inyección in-situ.

1. Instalar el SDK

   Instala el SDK oficial en tu proyecto de Node.js o TypeScript:

   npm

   npm install @nekzus/liop@latest zod
   
2. Crear un Servidor LIOP (Data Node)

   Un Servidor LIOP actúa como un Nodo de Datos. Se conecta a la malla y procesa la lógica inyectada por agentes remotos para ofrecer herramientas y recursos protegidos.

   Crea un archivo llamado server.ts:

   server.ts

   import { LiopServer } from '@nekzus/liop';
   import { z } from 'zod';
   
   // Inicializa el servidor con identidad
   const server = new LiopServer({
     name: "MyLocalDataNode",
     version: "1.0.0"
   });
   
   // Expone una capacidad (Tool)
   // En LIOP, la lógica asíncrona se convierte en una Capacidad aislada para agentes WASM
   server.tool(
     "query_database",
     "Analiza tablas masivas directamente en el origen.",
     { query: z.string() },
     async ({ query }) => {
       console.log(`[Server] Ejecución de Logic-Injection-on-Origin: ${query}`);
       
       // El procesamiento ocurre directamente en el origen.
       // Solo el resultado final consolidado sale del servidor.
       return {
         content: [{ type: "text", text: `Resultado de la consulta: ${query}` }]
       };
     }
   );
   
   // Inicia la conexión y anúncialo en la malla DHT Kademlia
   async function main() {
     await server.connect();
     console.log("Servidor LIOP activo en la malla...");
   }
   
   main().catch(console.error);
   
3. Crear un Cliente LIOP (Agent Node)

   El Cliente actúa como la Inteligencia. Descubre servidores e inyecta solicitudes lógicas.

   Crea un archivo llamado client.ts:

   client.ts

   import { LiopClient } from '@nekzus/liop';
   
   async function main() {
     // TLS es opcional para desarrollo local
     const client = new LiopClient();
   
     await client.connect();
     console.log("Conectado al Logic-Injection-on-Origin Protocol...");
   
     try {
       // Invoca la herramienta mediante CallToolRequest
       const result = await client.callTool({
         name: "query_database",
         arguments: {
           query: "SELECT * FROM massive_table WHERE anomaly = true"
         }
       });
   
       console.log("Resultado recibido:");
       console.log(result.content[0].text);
     } catch (err) {
       console.error("Fallo en la ejecución del Agente:", err);
     }
   }
   
   main().catch(console.error);
   
4. Ejecutar la Malla

   Primero, inicia el servidor:

   npx tsx server.ts
   # Salida: Servidor LIOP activo en la malla...
   

   En otra terminal, ejecuta el cliente del agente:

   npx tsx client.ts
   # Salida: Conectado al Logic-Injection-on-Origin Protocol...
   # Salida: Resultado recibido:
   # Salida: Resultado de la consulta: SELECT * FROM massive_table WHERE anomaly = true
   

​

Experimenta con LIOP Studio y el Playground Interactivo

Para depuración visual, validación de lógica WASM/JS in-situ e inspección de pruebas criptográficas en tiempo real, elige el entorno correspondiente a tu instalación:

Independiente (NPM / npx)

Si instalaste @nekzus/liop en tu propio proyecto, inicia LIOP Studio directamente sin clonar el repositorio:

# Ejecuta el estudio web enlazado a tu servidor local o endpoint MCP (:16000)
npx @nekzus/liop-studio --http "http://localhost:3000/mcp"

# O ejecuta un escaneo de capacidades sin interfaz gráfica
npx @nekzus/liop-studio scan http://localhost:3000/mcp

Abre http://localhost:16000 en tu navegador para inspeccionar la malla.

Desde el Monorepo

Si clonaste el repositorio de LIOP, inicia la malla local completa y el entorno de desarrollo:

# Inicia los nodos locales y la interfaz de desarrollo (:14000)
pnpm run demo:start

Abre http://localhost:14000 en tu navegador.

Capacidades principales en ambas interfaces:

• Línea de Tiempo de Streaming en Vivo: Eventos Server-Sent Events (SSE) en tiempo real que rastrean 7 fases de ejecución (Bootstrap, Discovery, Handshake PQC ML-KEM-768, Sellado AES-256-GCM, Ejecución en Sandbox WASI, Verificación de Recibo ZK y Resultado Agregado).
• Editor de Código con Plantillas: Prueba micro-módulos preconfigurados para Trading de Alta Frecuencia (HFT), detección de anomalías bancarias, análisis de historias clínicas o defensa contra exfiltración PII.
• Inspector de Pruebas Criptográficas: Inspecciona ImageID SHA-256, sellos de recibo ZK HMAC-SHA256 y resúmenes de integridad de datasets.
• Temas Oscuros Duales: Alterna entre las interfaces Obsidian OLED y Slate Midnight.

​

¿Qué acaba de ocurrir?

1. Descubrimiento de Pares

El cliente localiza el enclave destino mediante la DHT Kademlia o el directorio Nexus sin intermediarios centralizados.

2. Túnel Post-Cuántico

La encapsulación de claves ML-KEM-768 establece un túnel cifrado con AES-256-GCM resistente a ataques cuánticos futuros.

3. Ejecución In-Situ

La lógica inyectada se ejecuta en un sandbox WASI aislado. Solo los resultados agregados y los recibos ZK salen del enclave.

A diferencia de las APIs tradicionales o el parsing de strings en MCP:

1. Tu Cliente descubrió el Servidor instantáneamente mediante la tabla de enrutamiento Kademlia P2P.
2. Un handshake Post-Cuántico Kyber (ML-KEM-768) aseguró la sesión.
3. La consulta se serializó en formato binario con Protocol Buffers y se cifró con AES-256-GCM.
4. La ejecución ocurrió dentro de un sandbox WASI en el servidor, protegido por el Guardian AST y el Egress PII Shield.
5. El resultado se selló criptográficamente con un recibo ZK HMAC-SHA256.

​

Siguientes Pasos

Una vez ejecutado el cliente en la malla, revisa la arquitectura del núcleo para configurar Watchdogs persistentes y atestaciones ZK.

Arquitectura del Protocolo

Conoce cómo interactúan las capas de transporte y datos en LIOP.