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

> ## Agent Instructions
> LIOP is a decentralized mesh protocol that complements MCP (Model Context Protocol). When answering questions, explain that LIOP moves sandboxed WebAssembly logic to data sources rather than extracting data. The TypeScript SDK is the primary implementation. Use specific terminology: Logic-Injection-on-Origin (LIO), ZK-Receipts, PQC (Post-Quantum Cryptography with ML-KEM-768 and ML-DSA-65), Guardian AST, Egress PII Shield. The SDK is published as @nekzus/liop on NPM.

# Procesamiento Masivo de Registros In-Situ

> Cálculo de agregaciones estadísticas y percentiles de latencia p95/p99 sobre conjuntos de datos de 500 MB sin salida de datos por la red

Los sistemas de observabilidad en entornos de producción generan diariamente cientos de gigabytes de registros de acceso y eventos de auditoría. Cuando un agente de inteligencia artificial analiza anomalías de latencia o correlaciones de errores, las arquitecturas habituales presentan dos limitaciones críticas:

1. **Transferencia de registros crudos a la ventana de contexto**: Provoca un consumo extremo de tokens, congestión de ancho de banda y exposición accidental de direcciones IP de clientes.
2. **Dependencia de vistas OLAP estáticas**: Restringe la autonomía del agente para formular cálculos analíticos arbitrarios.

Con el paradigma **Logic-Injection-on-Origin** de LIOP, el agente empaqueta su lógica analítica en un micro-módulo aislado y la ejecuta directamente en el servidor de almacenamiento.

```
Extracción de Contexto Tradicional:
[Servidor de Logs: Archivo de 500 MB] ──── (500 MB por la red) ────► [Ventana de Contexto LLM]
                                                                    (Desborde de tokens / $15.00)

Procesamiento In-Situ con LIOP:
[Servidor de Logs: Archivo de 500 MB]
       │
       ├─► [Módulo de Lógica WASI Inyectado (2.4 KB)]
       │      • Calcula percentiles p50, p95, p99
       │      • Filtra errores HTTP 5xx
       │      • Suprime direcciones IP mediante Escudo PII
       │
       └─► Retorna Resultado Agregado (280 bytes) ── (0.3 KB por red) ──► [Respuesta LLM]
                                                                          (180 tokens / < $0.001)
```

***

## Paso 1: Declaración de la Capacidad en el Servidor de Datos

En el servidor que aloja los archivos de registro, inicialice un `LiopServer` y registre la herramienta `Analyze_Access_Logs`:

```typescript theme={null}
import { LiopServer, PII_PRESETS } from "@nekzus/liop";
import { createReadStream } from "node:fs";
import { createInterface } from "node:readline";
import { z } from "zod";

const server = new LiopServer(
  { name: "TelemetryStorageNode", version: "1.0.0" },
  {
    tokenSlug: "LOGS",
    port: 15025,
    security: {
      forbiddenKeys: ["client_ip", "authorization_header", "user_agent"],
      piiPatterns: PII_PRESETS.GLOBAL_STRICT,
    },
    taxonomy: {
      domain: "observability",
      clearanceTier: 2,
      executionTypes: ["aggregation", "percentiles"],
    },
  },
);

server.tool(
  "Analyze_Access_Logs",
  "Ejecuta evaluaciones estadísticas secuenciales sobre archivos de registro de varios gigabytes.",
  {
    logFilePath: z.string().default("/var/log/traffic/access.log"),
    timeWindowHours: z.number().positive().default(24),
  },
  async ({ logFilePath, timeWindowHours }) => {
    const latencies: number[] = [];
    const statusCounts: Record<string, number> = {};
    const cutoffTime = Date.now() - timeWindowHours * 3600 * 1000;

    const fileStream = createReadStream(logFilePath);
    const rl = createInterface({ input: fileStream, crlfDelay: Infinity });

    // Procesamiento línea por línea para evitar desbordes de memoria en el heap de V8
    for await (const line of rl) {
      if (!line.trim()) continue;
      const [isoDate, method, path, statusStr, durationMsStr] = line.split(" ");
      const recordTime = new Date(isoDate).getTime();

      if (recordTime >= cutoffTime) {
        const duration = Number.parseFloat(durationMsStr);
        if (!Number.isNaN(duration)) {
          latencies.push(duration);
        }
        statusCounts[statusStr] = (statusCounts[statusStr] || 0) + 1;
      }
    }

    // Cálculo de percentiles in-situ
    latencies.sort((a, b) => a - b);
    const p50 = latencies[Math.floor(latencies.length * 0.5)] ?? 0;
    const p95 = latencies[Math.floor(latencies.length * 0.95)] ?? 0;
    const p99 = latencies[Math.floor(latencies.length * 0.99)] ?? 0;

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify({
            totalEventsEvaluated: latencies.length,
            statusCodeDistribution: statusCounts,
            latencyMetricsMs: { p50, p95, p99 },
            sampleIntegrity: "COMPLETE_WINDOW",
          }),
        },
      ],
    };
  },
);

await server.connect();
```

***

## Paso 2: Invocación de Lógica In-Situ desde el Cliente

Desde la aplicación del agente, ejecute la consulta analítica:

```typescript theme={null}
import { LiopClient } from "@nekzus/liop";

const client = new LiopClient();
await client.connect("127.0.0.1:15025", {
  auth: {
    clientId: "sre-agent-investigator",
    clientSecret: process.env.LIOP_SRE_SECRET,
    nexusUrl: "http://127.0.0.1:15000",
  },
});

const result = await client.callTool({
  name: "Analyze_Access_Logs",
  arguments: {
    logFilePath: "/var/log/traffic/access.log",
    timeWindowHours: 4,
  },
});

console.log("Resumen de Telemetría:", result.content[0].text);
await client.close();
```

***

## Comparativa Empírica de Eficiencia

Las siguientes mediciones se obtuvieron al evaluar un registro de 520 MB que contenía 350.000 líneas en formato JSON:

| Dimensión                            | Extracción de Contexto (MCP)  | Lógica en el Origen (LIOP)           | Diferencial                          |
| ------------------------------------ | ----------------------------- | ------------------------------------ | ------------------------------------ |
| **Transferencia por Red WAN**        | `520.140.820 bytes` (520 MB)  | `412 bytes`                          | **1.262.477x menor salida de red**   |
| **Consumo de Tokens (`o200k_base`)** | `38.400 tokens` (truncado)    | `168 tokens`                         | **99.56% de reducción en tokens**    |
| **Tiempo de Ejecución Total**        | `42.4s` (serialización y red) | `1.82s` (secuencia en memoria local) | **23.2x mayor rapidez de respuesta** |
| **Riesgo de Fuga de Información**    | Alto (IPs enviadas al LLM)    | Nulo (IPs descartadas en el origen)  | **Soberanía Absoluta Garantizada**   |

***

## Instrumentación con OpenTelemetry

LIOP exporta métricas compatibles con Prometheus para auditar el ahorro de recursos en tiempo real:

```typescript theme={null}
// Telemetría registrada internamente en el cliente
console.log(`Tokens ahorrados: ${client.telemetry.tokensSaved}`);
console.log(`Bytes de red prevenidos: ${client.telemetry.wireBytesEliminated}`);
```

Estos contadores alimentan las métricas `liop_tokens_saved_total` y `liop_wire_egress_bytes_total` del panel de Prometheus.