Quickstart

Start building with LIOP in under 5 minutes using the official TypeScript SDK

The Logic-Injection-on-Origin Protocol (LIOP) provides the @nekzus/liop package, offering an API surface familiar to MCP developers. If you have previously built servers for MCP, transitioning to LIOP follows the same architectural conventions.

In this guide, we’ll build a basic LIOP Server that exposes a tool, and a Client that invokes it.

Under the hood, LIOP compiles logic into sandboxed execution envelopes and dispatches it across the mesh. The SDK abstracts the underlying gRPC and P2P transport, exposing standard tool registration and execution methods.

Building in Rust? LIOP provides native Rust crates (liop-client and liop-core) for systems engineers, WASI guest filters, and low-latency agents. Check out the Rust SDK Overview for Cargo configuration and in-situ injection examples.

1. Install the SDK

   Install the official SDK in your Node.js or TypeScript project:

   npm

   npm install @nekzus/liop@latest zod
   
2. Create a LIOP Server (Data Node)

   A LIOP Server acts as a Data Node. It connects to the mesh and listens for incoming injected logic from remote agents, exposing secure tools and resources.

   Create a file named server.ts:

   server.ts

   import { LiopServer } from '@nekzus/liop';
   import { z } from 'zod';
   
   // Initialize the Server with identity
   const server = new LiopServer({
     name: "MyLocalDataNode",
     version: "1.0.0"
   });
   
   // Expose a tool. 
   // In LIOP, the async logic provided here is dynamically converted 
   // into an isolated Capability for incoming WASM Agents.
   server.tool(
     "query_database",
     "Analyzes database tables directly at the origin. Pass a SQL-like query string.",
     { query: z.string() },
     async ({ query }) => {
       console.log(`[Server] Executing Logic-Injection-on-Origin for query: ${query}`);
       
       // Processing happens directly at the origin.
       // Only the aggregated final result leaves the server.
       return {
         content: [{ type: "text", text: `Processed query results for: ${query}` }]
       };
     }
   );
   
   // Start the server and announce it to the Kademlia DHT Mesh
   async function main() {
     await server.connect();
     console.log("LIOP Server is listening on the Mesh...");
   }
   
   main().catch(console.error);
   
3. Create a LIOP Client (Agent Node)

   A LIOP Client acts as the Intelligence. It discovers servers on the mesh and injects compiled logic into them.

   Create a file named client.ts:

   client.ts

   import { LiopClient } from '@nekzus/liop';
   
   async function main() {
     // Initialize the Client (TLS options are optional for local development)
     const client = new LiopClient();
   
     // Connect to the mesh
     await client.connect();
     console.log("Joined LIOP Protocol...");
   
     // Discover the server's tools and invoke logic
     try {
       // Invoke the tool using a CallToolRequest
       const result = await client.callTool({
         name: "query_database",
         arguments: {
           query: "SELECT * FROM massive_table WHERE anomaly = true"
         }
       });
   
       console.log("Received verified result:");
       console.log(result.content[0].text);
     } catch (err) {
       console.error("Agent execution failed:", err);
     }
   }
   
   main().catch(console.error);
   
4. Run your Mesh

   First, start your isolated Server:

   npx tsx server.ts
   # Output: LIOP Server is listening on the Mesh...
   

   In a separate terminal, run the agent client:

   npx tsx client.ts
   # Output: Joined LIOP Protocol...
   # Output: Received verified result:
   # Output: Processed query results for: SELECT * FROM massive_table WHERE anomaly = true
   

Explore with LIOP Studio & Interactive Playground

For visual debugging, testing in-situ WASM/JS logic, and inspecting cryptographic proofs in real-time, choose the environment matching your setup:

Standalone (NPM / npx)

If you installed @nekzus/liop in your own project, launch LIOP Studio directly:

# Run the web studio targeting your local server or MCP endpoint (:16000)
npx @nekzus/liop-studio --http "http://localhost:3000/mcp"

# Or perform a headless capability scan
npx @nekzus/liop-studio scan http://localhost:3000/mcp

Open http://localhost:16000 in your browser to inspect the mesh.

From the Monorepo

If you cloned the LIOP repository, start the full local mesh and development playground:

# Start local mesh nodes and dev playground UI (:14000)
pnpm run demo:start

Open http://localhost:14000 in your browser.

Key inspection capabilities in both interfaces:

• Live Streaming Timeline: Real-time Server-Sent Events (SSE) tracking 7 execution phases (Bootstrap, Discovery, PQC ML-KEM-768 Handshake, AES-256-GCM Sealing, WASI Sandbox Execution, ZK-Receipt Verification, and Aggregated Output).
• Code Editor with Presets: Test ready-made micro-modules for High-Frequency Trading (HFT), Banking anomaly detection, Medical Records analysis, or PII exfiltration defense.
• Cryptographic Proof Inspector: Inspect SHA-256 ImageID, HMAC-SHA256 ZK-receipt seals, and dataset integrity digests.
• Dual Dark Themes: Toggle between OLED Obsidian and Slate Midnight UI themes.

What just happened?

1. Peer Discovery

Client locates the target enclave via Kademlia DHT or Nexus directory without centralized middlemen.

2. Quantum-Safe Tunnel

ML-KEM-768 key encapsulation establishes an AES-256-GCM encrypted tunnel resistant to harvest-now-decrypt-later attacks.

3. In-Situ Execution

Injected code executes inside an isolated WASI sandbox. Only aggregated output and ZK-Receipts egress the enclave.

Unlike legacy REST APIs or MCP string parsing:

1. Your Client discovered the Server instantly via a P2P Kademlia Routing Table.
2. A Post-Quantum Kyber Handshake (ML-KEM-768) secured the session.
3. The query was serialized into binary Protocol Buffers and sealed with AES-256-GCM.
4. The execution happened inside an isolated WASI Sandbox on the server, protected by the Guardian AST and Egress PII Shield.
5. The output was cryptographically sealed with an HMAC-SHA256 ZK-Receipt.

Next Steps

With the client verified on the mesh, review the core architecture to configure persistent Watchdogs and Zero-Knowledge receipts.

Core Architecture

Learn how the Data Layer and Transport Layer integrate in LIOP.