Noureddine RAMDI / Blackbox Node: offline AI assistant over LoRa mesh with local llama.cpp and ecash payments

Created Mon, 04 May 2026 10:23:01 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
1183 Words
github-stars javascript nodejs llama.cpp meshtastic loramesh cotprotocol cashu offlineai

wadadawadada/blackbox_node

Blackbox Node tackles a tough problem: getting AI-powered assistance and secure communications working in places with no internet or cloud infrastructure. It combines a local large language model (LLM) inference engine with a long-range, low-power LoRa mesh network to enable AI queries and map-object exchanges completely offline. This is designed for field operations, disaster response, and community mesh networks where connectivity is unreliable or nonexistent.

What Blackbox Node does and how it’s built

At its core, Blackbox Node is a self-hosted, offline-first command post accessible through a web UI. It runs on Node.js 18+ and Python 3.11+, with a local LLM powered by llama.cpp—a lightweight C++ implementation of LLaMA models. The system bootstraps itself by downloading a compatible llama.cpp runtime and a starter GGUF model on the first install, removing much of the setup friction.

The networking backbone is provided by Meshtastic, a LoRa mesh radio protocol that can cover 5 to 15+ kilometers in open terrain using inexpensive hardware ($20-$60). This mesh runs TAK/ATAK’s Cursor on Target (CoT) protocol, enabling map-object exchange for situational awareness. To handle the lossy nature of LoRa mesh links, Blackbox Node implements fountain transfer to reliably send large Cursor on Target payloads.

A distinctive feature is the integration of Cashu ecash tokens into this mesh network. These tokens enable text-based payments sent as plain messages over the radio, useful for micropayments or resource accounting in disconnected environments.

Under the hood, the architecture weaves together several components:

  • A Node.js backend hosting the web UI and orchestrating the local LLM runtime.
  • The llama.cpp server running locally to handle AI queries.
  • A Python-based Meshtastic bridge handling LoRa communications and TAK/CoT packet processing.
  • Fountain transfer protocols to ensure mesh reliability.
  • Cashu token management for ecash payments over the mesh.

This combination leverages open protocols and open-source tools to deliver an offline-capable AI assistant and situational awareness platform.

What stands out technically and the tradeoffs involved

The standout technical achievement is the seamless integration of a local LLM inference engine with a low-bandwidth, lossy mesh networking environment. Running AI queries over a LoRa mesh is unusual due to bandwidth and latency constraints, but Blackbox Node manages this by routing @bot/!ask commands through Meshtastic radios and serving them via a llama.cpp instance locally.

The llama.cpp integration is key: it allows running a Qwen2.5-3B-Instruct-Q5_K_M.gguf model (~2.3 GB) offline on commodity hardware, balancing model size with feasibility. The code automates downloading and bootstrapping to lower barriers.

Meshtastic LoRa mesh networking is a niche but practical choice for long-range, low-power communication ideal for remote or disaster scenarios. Using TAK/ATAK’s Cursor on Target protocol means this system fits into existing defense and emergency response workflows.

Fountain transfer is an elegant solution to the lossy nature of LoRa mesh links. Instead of retransmitting entire packets, fountain codes allow partial data to be reconstructed from any sufficient subset of received fragments, significantly improving reliability over lossy radio.

Integrating Cashu ecash tokens over the mesh is clever, enabling decentralized, offline micropayments as plain text messages. This adds a layer of economic interaction rarely seen in similar mesh setups.

The tradeoff includes the complexity of managing multiple runtimes (Node.js, Python, llama.cpp) and hardware dependencies like Meshtastic radios. Hardware costs are low but not zero, and setting up the mesh requires some domain knowledge.

Performance-wise, the local LLM inference and fountain transfer introduce latency compared to cloud AI, but this is an expected tradeoff for offline capability and mesh coverage. The model size is limited to keep it runnable on typical local nodes, which means less powerful AI compared to large cloud-hosted models.

Code quality appears solid, with clear bootstrap scripts for dependencies and runtime components. The system’s modular design means users can replace models or runtimes if desired, but the default experience is reasonably turnkey.

Quick start

Fast path

npm install
npm start

During npm install, the project bootstraps the local AI runtime automatically:

  • installs JavaScript dependencies
  • downloads a platform-matched llama.cpp runtime into ./llama/ if missing (Windows/Linux/macOS)
  • downloads a starter GGUF model into ./models/ if missing
  • attempts to install the Meshtastic Python package into ./pydeps/ if Python is available

That is enough for the web UI and local AI to start on a clean machine.

1. Prerequisites

Install these before anything else:

  • Node.js 18+ - main runtime
  • Python 3.11+ - Meshtastic radio bridge and TAK transport logic

Verify both are available:

node --version
python --version

2. Clone and install Node dependencies

git clone https://github.com/wadadawadada/blackbox_node.git
cd blackbox_node
npm install

This creates node_modules/ and runs the bootstrap installer for the local AI runtime.

3. Set up llama.cpp (manual fallback only)

Skip this step unless automatic bootstrap failed or you want to replace the runtime manually.

Otherwise, the llama/ folder must contain llama-server (llama-server.exe on Windows) and the companion runtime libraries from a matching prebuilt package in the llama.cpp releases page.

Extract llama-server (or llama-server.exe) and the bundled ggml/llama runtime libraries into ./llama/:

llama/
  llama-server(.exe)
  llama runtime libraries (.dll / .so / .dylib depending on OS)

Pick the build that matches your machine and OS/CPU:

  • No GPU -> ...-cpu-...
  • NVIDIA GPU -> ...-cuda-...
  • AMD / Intel GPU -> ...-vulkan-...
  • Apple Silicon (optional acceleration) -> ...-metal-...

4. Download a model (manual fallback only)

Skip this step unless automatic bootstrap failed or you want to add more models manually.

Otherwise, create the models/ folder and download at least one .gguf model file into it.

Verdict

Blackbox Node is a niche but practical tool for anyone needing AI assistance, map situational awareness, and micropayments in a fully offline, mesh network environment. It’s especially relevant for disaster response teams, field operators, and community mesh builders who cannot rely on internet connectivity.

The tradeoffs include hardware setup complexity, managing multiple runtimes, and constrained AI model size versus cloud alternatives. But the system delivers a rare capability: offline AI queries over a real-world, long-range mesh radio with integrated economic transactions.

If you’re building solutions for disconnected environments or experimenting with mesh networking and local AI inference, Blackbox Node offers a solid reference implementation with real-world protocols and an extensible architecture. It’s worth understanding even if you don’t adopt it wholesale, as it tackles a real problem with a practical, open-source approach.

→ GitHub Repo: wadadawadada/blackbox_node ⭐ 103 · JavaScript