DEV Community

Ming
Ming

Posted on

NeoMind: A Rust-Powered Edge AI Platform That Talks to Your IoT Devices

#rust #iot #ai #opensource

NeoMind: A Rust-Powered Edge AI Platform That Talks to Your IoT Devices

Talk to your devices in natural language. The AI understands your intent, queries device states, creates automation rules, and takes action — all on your own hardware, with zero cloud dependency.

The Problem We're Solving

Edge AI is stuck between two extremes. On one side, you have cloud-first platforms that ship every sensor reading to a remote server — introducing latency, bandwidth costs, and privacy concerns that make industrial customers cringe. On the other, you have bare-metal inference frameworks that run a single model well but offer no device management, no automation, no natural language interface.

What's missing is the middleware layer — something that sits on your edge hardware, connects to real devices, runs intelligent agents, and lets operators interact with the whole system conversationally. That's what NeoMind is.

What Is NeoMind?

NeoMind is an open-source, edge-deployed AI platform built in Rust. It brings together:

  • LLM-powered agents that run directly on your hardware (via Ollama or cloud backends)
  • Device connectivity through MQTT, BLE, and Webhook protocols
  • A JSON rule engine for automation with recursive conditions and debouncing
  • Real-time dashboards with drag-and-drop widgets
  • 22 official extensions spanning vision AI (YOLO, face recognition, OCR), voice (TTS/ASR), and IoT bridges (Home Assistant, Modbus, BACnet, ONVIF, OPC-UA, LoRaWAN)

All packaged in a single binary. No Docker Compose. No external database. No message broker to install.

# One command. Everything runs.
curl -fsSL https://raw.githubusercontent.com/camthink-ai/NeoMind/main/scripts/install.sh | sh
Enter fullscreen mode Exit fullscreen mode

Architecture: Single-Process, Self-Contained

NeoMind's most distinctive design choice is its single-process architecture. The API server (Axum), embedded MQTT broker, redb storage, rule engine, AI agent runtime, and extension runner all live in one process.

┌──────────────────────────────────────────────────────────┐
│               Desktop App / Web UI                       │
│                React 18 + TypeScript                     │
├──────────────────────────────────────────────────────────┤
│              Tauri 2.x / Browser                         │
└────────────────────────┬─────────────────────────────────┘
                         │ REST / WebSocket / SSE
                         ▼
┌──────────────────────────────────────────────────────────┐
│                   API Gateway (Axum)                      │
│  ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐            │
│  │  Auth  │ │Devices │ │Automate│ │Messages│            │
│  └────────┘ └────────┘ └────────┘ └────────┘            │
├──────────────────────────────────────────────────────────┤
│                     Event Bus                             │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌────────────┐ │
│  │ Devices  │ │Automation│ │ AI Agent │ │ Extensions │ │
│  │ MQTT/BLE │ │ Rules    │ │ Chat     │ │ Isolated   │ │
│  │ Webhook  │ │ Transform│ │ Tools    │ │ Native+WASM│ │
│  └──────────┘ └──────────┘ │ Memory   │ └────────────┘ │
│                            └──────────┘                  │
├──────────────────────────────────────────────────────────┤
│                  Storage Layer (redb)                     │
│  Time-Series │ State │ LLM Memory │ Push Logs            │
└──────────────────────────────────────────────────────────┘
Enter fullscreen mode Exit fullscreen mode

Why this matters:

  • Deployment simplicity — cargo run and you're done. No orchestrating 12 microservices.
  • Resource efficiency — One process shares memory, file descriptors, and connection pools. Critical on constrained edge hardware.
  • Operational clarity — One log stream, one PID to monitor, one binary to update.

Three Design Philosophies

1. Edge-First, Cloud-Optional

NeoMind defaults to local LLMs via Ollama — your data never leaves your LAN. When you need frontier-model capabilities, switch to OpenAI, Anthropic, Google, or any OpenAI-compatible endpoint with a single config change. The agent runtime is backend-agnostic.

This isn't just a privacy play. For industrial IoT deployments on factory floors or remote campuses, reliable internet isn't guaranteed. NeoMind works fully offline.

2. Crash-Isolated Extensions

Extensions run in separate processes and communicate with the core via FFI with capability-based permissions. If your YOLO object detection extension crashes, the main service and all other extensions are completely unaffected.

This is modeled after Erlang's "let it crash" philosophy, adapted for a Rust codebase where the core itself rarely crashes — but third-party extensions might.

3. Type-Safe End-to-End

The Rust backend provides compile-time guarantees across the entire stack. Agent CLI commands dispatch in-process with structured data types — no fragile string parsing, no eval(), no shell injection vectors.

AI Agents: More Than a Chatbot

NeoMind's AI layer goes beyond simple Q&A:

  • Natural Language Chat — Conversational interface to query device states, create automation rules, and control hardware. "Turn off all cameras on Floor 3 after 10 PM" becomes a real command.
  • Autonomous Agents — Scheduled or event-driven agents that monitor telemetry, analyze patterns, and trigger actions independently. Think: "Watch the temperature sensors and alert me if any reading exceeds 30°C for more than 5 minutes."
  • Multi-tier Memory — Profile memory, knowledge base, task history, and session context with automatic extraction and compression. The AI remembers your facility layout and past incidents.
  • Skill System — YAML + Markdown skill files that guide agent behavior for specific scenarios. Write a skill for "factory floor safety check" and the agent follows it precisely.

Supported backends include Ollama, OpenAI, Anthropic, Google, xAI, Qwen, DeepSeek, GLM, MiniMax, and any OpenAI-compatible endpoint.

Device Management: MQTT, BLE, and Beyond

NeoMind treats IoT devices as first-class citizens:

  • Embedded MQTT Broker — with mTLS and CA certificate support. Your devices connect directly, no external broker needed.
  • BLE Provisioning — Zero-touch device setup via Bluetooth (Tauri native + Web Bluetooth). Walk up to a device, pair, configure.
  • Auto-Discovery — Plug in a new device and NeoMind detects it, registers its type, and offers AI-assisted onboarding.
  • Custom Device Types — Define metrics and commands via JSON type definitions. No code changes required.

The extension ecosystem adds bridges for Home Assistant (3000+ entity integrations), Modbus (TCP/RTU PLCs), BACnet (building automation), ONVIF (IP cameras), OPC-UA (industrial servers), and LoRaWAN (ChirpStack/TTN sensors).

Automation Without Code

The JSON rule engine supports recursive conditions with comparison, range, and logical operators:

{
  "condition": {
    "source": "device:sensor:temperature",
    "operator": "greater_than",
    "threshold": 30
  },
  "actions": [
    {"type": "notify", "channel": "slack", "message": "Temperature alert!"},
    {"type": "execute", "command": "device:fan:turn_on"}
  ],
  "cooldown": 300,
  "for_duration": 60
}
Enter fullscreen mode Exit fullscreen mode

Combine rules with data transforms (JavaScript-based virtual metrics) and scheduled AI agents to build sophisticated automation pipelines — all without writing backend code.

22 Extensions and Growing

The extension marketplace ships with production-ready integrations:

Category Extensions
Vision YOLO object detection, face recognition, OCR, visual grounding
Voice CosyVoice TTS, voice cloning, multilingual ASR, voice assistant pipeline
IoT Bridges Home Assistant, Modbus, BACnet, ONVIF, OPC-UA, LoRaWAN
Utilities Weather forecast, stream player, WASM demo

Each extension is process-isolated with capability-based permissions. Build your own following the Extension Development Guide.

Cross-Platform: Desktop, Server, Mobile

NeoMind ships native desktop apps via Tauri 2.x for macOS (Apple Silicon + Intel), Windows, and Linux. The responsive web UI is optimized for phone and tablet. Server deployments support Docker, systemd, and nginx reverse proxy.

# Docker — multi-arch, pulls official image
docker run -d --name neomind \
  -p 9375:9375 -p 1883:1883 \
  -v neomind-data:/app/data \
  camthink/neomind:latest
Enter fullscreen mode Exit fullscreen mode

Get Started

Contributing

NeoMind is open source and actively seeking contributors. Four ways to get involved:

  1. Build an Extension — New AI models, data sources, or integrations
  2. Add a Device Type — Define metrics and commands for your IoT hardware
  3. Create a Dashboard Widget — Reusable React components for the community
  4. Core Contributions — Rust backend, React frontend, documentation

NeoMind is developed by CamThink AI. Licensed under Apache 2.0.

Top comments (0)