> ## 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.

# Inicio Rápido

> Comienza con LIOP en menos de 5 minutos usando 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.

<Note>
  Internamente, LIOP compila tu lógica a WebAssembly y la inyecta vía P2P. El SDK abstrae todo esto para que te enfoques en la lógica de negocio.
</Note>

## 1. Instalación

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

<CodeGroup>
  ```bash npm theme={null}
  npm install @nekzus/liop@latest zod
  ```

  ```bash pnpm theme={null}
  pnpm add @nekzus/liop@latest zod
  ```

  ```bash yarn theme={null}
  yarn add @nekzus/liop@latest zod
  ```
</CodeGroup>

## 2. Crear un Servidor LIOP (Data Node)

Un Servidor LIOP actúa como un Nodo de Datos. Se conecta a la malla y espera lógica inyectada de agentes remotos.

Crea un archivo llamado `server.ts`:

```typescript server.ts theme={null}
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)
server.tool(
  "query_database",
  "Analiza tablas masivas directamente en el origen.",
  { query: z.string() },
  async ({ query }) => {
    console.log(`[Server] Ejecutando Logic-Injection-on-Origin: ${query}`);
    
    // Aquí se procesarían los datos locales (ej. 5GB)
    // Solo el resultado final 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 escuchando 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 (intenciones).

Crea un archivo llamado `client.ts`:

```typescript client.ts theme={null}
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 usando 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:

```bash theme={null}
npx tsx server.ts
# Salida: Servidor LIOP escuchando en la malla...
```

En otra terminal, lanza el Agente:

```bash theme={null}
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
```

## 5. Experimenta con la UI Interactiva del Playground Web

Para depuración visual, probar lógica WASM/JS in-situ e inspeccionar pruebas criptográficas en tiempo real, inicia el **LIOP Web Playground**:

```bash theme={null}
# Iniciar la malla local completa + playground interactivo en Docker
pnpm run demo:start
```

Una vez en ejecución, abre **`http://localhost:14000`** en tu navegador:

* **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?

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 un formato **binario Protobuf** ultra compacto y se selló 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

Ahora que has ejecutado tu primera misión en la malla, explora la arquitectura para aprovechar Watchdogs y Pruebas ZK.

<Card title="Arquitectura del Core" icon="sitemap" href="/es/concepts/architecture">
  Aprende cómo la capa de datos y transporte se sinergizan en LIOP.
</Card>