Adapters Overview

Connecting Web2, Web3, and legacy systems to NTL

Adapters are the compatibility boundary where NTL interfaces with existing systems. They translate between NTL’s signal-based transport and traditional protocols.

Think of adapters as the peripheral nervous system — they interface with the external world using whatever language external systems speak, while internally everything is neural signals.

Architecture

External World                    NTL Network
─────────────                    ───────────
                  ┌──────────┐
HTTP Request  ──▶ │          │ ──▶ Signal
                  │ Adapter  │
HTTP Response ◀── │          │ ◀── Signal
                  └──────────┘

Chain TX      ──▶ ┌──────────┐ ──▶ Signal
                  │ Adapter  │
Chain Event   ◀── └──────────┘ ◀── Signal

gRPC Call     ──▶ ┌──────────┐ ──▶ Signal
                  │ Adapter  │
gRPC Response ◀── └──────────┘ ◀── Signal

Adapter Types

Web2 Adapter

Translates HTTP, gRPC, WebSocket, and GraphQL into NTL signals. This is how existing web applications, APIs, and services connect to NTL without modification.

Web2 Adapter Reference →

Web3 Adapter

Interfaces with blockchain networks, decentralized identity (DID), and token systems. Signals can carry chain-verifiable payloads, initiate smart contract calls, and verify identity through decentralized mechanisms.

Web3 Adapter Reference →

Legacy API Adapter

A specialized adapter for connecting legacy REST/SOAP APIs that can’t be modified. The adapter wraps existing API endpoints and exposes them as NTL signal handlers.

Legacy API Adapter Reference →

The Adapter Contract

All adapters implement the Adapter trait:

trait Adapter {
    /// Translate an external request into an NTL signal
    fn ingest(&self, external: ExternalPayload) -> Result<Signal>;

    /// Translate an NTL signal into an external response
    fn emit(&self, signal: Signal) -> Result<ExternalPayload>;

    /// The external protocol this adapter speaks
    fn protocol(&self) -> Protocol;

    /// Health check
    fn health(&self) -> AdapterHealth;
}

Building Custom Adapters

NTL ships with Web2, Web3, and Legacy adapters. For specialized protocols, you can build custom adapters:

struct MqttAdapter {
    broker: MqttClient,
    node: NtlNode,
}

impl Adapter for MqttAdapter {
    fn ingest(&self, external: ExternalPayload) -> Result<Signal> {
        let mqtt_msg = MqttMessage::from_bytes(&external.data)?;
        Ok(Signal::data(mqtt_msg.topic)
            .with_payload(mqtt_msg.payload)
            .with_weight(0.5))
    }

    fn emit(&self, signal: Signal) -> Result<ExternalPayload> {
        let topic = signal.signal_type.to_string();
        let payload = signal.payload.to_bytes()?;
        Ok(ExternalPayload::mqtt(topic, payload))
    }

    fn protocol(&self) -> Protocol {
        Protocol::Custom("mqtt".into())
    }

    fn health(&self) -> AdapterHealth {
        AdapterHealth::from(self.broker.is_connected())
    }
}

Adapter as API Gateway

For organizations migrating from traditional architectures, NTL adapters can function as an API gateway — accepting REST/GraphQL traffic on the outside while internally routing through the neural transfer layer. This allows incremental adoption without rewriting existing clients.

Existing Mobile App ──HTTP──▶ Web2 Adapter ──Signal──▶ NTL Network
Existing Web App ──GraphQL──▶ Web2 Adapter ──Signal──▶ NTL Network
New AI Agent ────────Signal──▶ NTL Network (native)