Open Source · Apache-2.0·v0.9.8

Edge AI that runs
your IoT

An open-source platform that puts a local LLM in charge of your devices — autonomous control, multi-protocol bridges, and a real automation engine. Fully on-premise, fully offline.

Download Star on GitHub

25+ extensions·7 IoT bridges·128+ device types·10+ LLM backends

NeoMind — Dashboard

AI Chat

Devices

TRY IT — LIVE

See it think, watch it act

The on-device LLM reasons, picks the right tools, and acts on real hardware — no cloud, no config. Try a request below.

neomind — edge agent

local · offline

Hi — I'm running on your edge box. Ask me anything about your devices, or try an example below.

CAPABILITIES

One agent, every device, fully on-prem

A local LLM reasons about your IoT fleet, calls tools, and takes real actions — no cloud round-trip, no data leaving your network.

Agent Control

The agent understands intent, executes commands, creates rules, and reports back. Interact via chat, API, or event triggers.

"Turn off all lights in building B after 8pm"

Local LLM at the Edge

Run multimodal models locally via Ollama on Jetson, Pi, or any edge hardware. Zero cloud dependency, full data sovereignty, sub-100ms latency.

OllamaQwen3-VLGemma 4+10+ backends

7 IoT Protocol Bridges

Modbus, BACnet, OPC-UA, ONVIF, LoRaWAN, Home Assistant — unified under one platform with bidirectional data flow.

Process-Isolated Extensions

Runtime Protocol v3 with process isolation. Native, WASM, and React dashboard components — 25 official extensions, sandboxed with crash protection.

JSON Rules Engine

Declarative automations in pure JSON. Describe them in natural language, the LLM generates the rule.

Persistent Memory

Three-tier memory (short / session / knowledge). Vector search across devices, rules, and history.

Multimodal Vision

Send images in chat — analyze equipment, run YOLO detection, read meters via OCR.

DEPLOYMENT

Edge-first, everywhere-capable

NeoMind lives on the edge device — your Jetson, Pi, or NG4500 — running the runtime, vision, I/O, and peer sync right there. It reaches cameras and sensors over LAN, Wi-Fi, Wi-Fi HaLow, or LoRaWAN — covering every range from your desk to across town. No cloud round-trip, no protocol bridges.

NeoMindon Jetson · Pi · NG4500

Edge AI Platform

Agent RuntimeLocal LLM agent

Vision AIOn-device perception

Local StorageVector DB · cache

Device I/OSensors · actuators

Event EngineTriggers · rules

Peer SyncmDNS · event mesh

LANwired

Wi-Fi~50m

Wi-Fi HaLow~1km+

LoRaWAN~5km

NE101

NE503

NE301

Temp

Humidity

Meter

Gas

Vibration

Power

Intrusion

Access

Alarm

Display

Audio

Light

NeoMindon Jetson · Pi · NG4500

Edge AI Platform

Capabilities · on-device

Agent Runtime

Vision AI

Local Storage

Device I/O

Event Engine

Peer Sync

Transports · range

LANwired

Wi-Fi~50m

Wi-Fi HaLow~1km+

LoRaWAN~5km

Devices

NE101Bullet cam

NE503NeoEye cam

NE301PTZ cam

Also reaches

Temp

Humidity

Meter

Gas

Vibration

Power

Intrusion

Access

Alarm

Display

Audio

Light

One binary, every platformPre-built binaries for Jetson, Pi, NG4500, x86 Linux, macOS, Windows. Download, run — no Docker, no install scripts.

5m to 5km, one runtimeLAN for the box next door, Wi-Fi for cameras in the building, Wi-Fi HaLow for sensors across campus, LoRaWAN for meters 5km out.

Agent identifies, you confirmPoint NeoMind at a device — the agent identifies it, picks the protocol driver, generates the config. Minutes, not days.

Edge logic, cloud orchestrationEdge closes the loop locally — perception, automation, device I/O. Cloud handles dashboards, fleet management, model lifecycle.

ECOSYSTEM

Connect everything

Devices, protocols, and clouds — all unified under one autonomous agent at the center.

Camera

Sensor

PLC

Gateway

Actuator

Extensions

MQTT

Cloud LLMOptional

Local LLM

NeoMindLLM + Automation

Extensions

Protocol bridges

128+

Device types

126

Milesight sensors

Industrial protocols, unified

One platform, bidirectional data flow across every major IoT standard.

MQTT

embedded

Modbus

TCP/RTU

LoRaWAN

ChirpStack

BACnet

HVAC

ONVIF

IP cameras

OPC-UA

SCADA

Home Assistant

3000+ entities

MARKETPLACE

Extend NeoMind, build apps

Capability extensions add new AI, voice, and protocol skills. Dashboard components render your data the way you want. Both are open, shareable, and install in one click.

Extend NeoMind

Process-isolated, sandboxed extensions. Add AI vision, voice, e-paper, weather — or write your own.

Extensions repo

YOLO Video V2

YOLO Video V2 extension for NeoMind.

Streams Frames Detections

YOLO Device Inference

YOLO Device Inference extension for NeoMind.

Detections Latency

Image Analyzer V2

Image Analyzer V2 extension for NeoMind.

Objects Classes

Face Recognition

Face Recognition extension for NeoMind.

Gallery Matches

OCR Device Inference

OCR Device Inference extension for NeoMind.

Text Confidence

Locate Anything V2

Locate Anything V2 extension for NeoMind.

Grounding OCR

Home Assistant Bridge

Home Assistant Bridge extension for NeoMind.

3000+ entities

Modbus Bridge

Modbus Bridge extension for NeoMind.

Registers Coils

LoRaWAN Bridge

LoRaWAN Bridge extension for NeoMind.

NS Decoders

BACnet Bridge

BACnet Bridge extension for NeoMind.

Devices COV

ONVIF Bridge

ONVIF Bridge extension for NeoMind.

Cameras PTZ

OPC-UA Bridge

OPC-UA Bridge extension for NeoMind.

Nodes Subscriptions

Uink-RMS Bridge

Uink-RMS Bridge extension for NeoMind.

E-Paper Push

Voice Assistant

Voice Assistant extension for NeoMind.

ASR LLM TTS

SenseVoice ASR

SenseVoice ASR extension for NeoMind.

Multilingual Real-time

CosyVoice 3

CosyVoice 3 extension for NeoMind.

Streaming Cloning

Moss TTS Nano

Moss TTS Nano extension for NeoMind.

Lightweight Low-footprint

Voice Edge TTS

Voice Edge TTS extension for NeoMind.

Fast Start Edge-optimized

Stream Player

Stream Player extension for NeoMind.

RTSP/RTMP/HLS

Weather Forecast V2

Weather Forecast V2 extension for NeoMind.

Temp Humidity Wind

Build apps

Built-in React widgets shipped with NeoMind — drag, drop, bind to devices. Build your own and share with the community.

Component repo

Value Card

Single value with unit, prefix, suffix and trend

LED Indicator

Status light with value-to-state mapping

Sparkline

Mini trend chart of recent metric history

Progress Bar

Linear / circular progress with thresholds

Line Chart

Time-series line chart, multi-source

Bar Chart

Vertical / horizontal / stacked bars

Pie Chart

Donut or pie for part-to-whole

Toggle Switch

On/off control bound to device commands

Image Display

Image from URL or data source, zoomable

Image History

Historical frames with slider navigation

Map Display

Interactive map with device markers

Video Display

RTSP / HLS / WebRTC / camera streams

Web Display

Sandboxed iframe for web content

Markdown

Render markdown with syntax highlighting

Agent Monitor

AI agent status, stats and execution log

AI Analyst

AI analysis of images / metrics in a chat

Clockcommunity

Real-time clock with timezone and 12/24h

NE101 Panelcommunity

CamTalk sensing camera panel

3D Viewercommunity

Interactive GLB / GLTF model viewer

Weather Cardcommunity

Current conditions + 3-day forecast

Gaugecommunity

Analog dial gauge with custom range

Status Gridcommunity

Multi-device status table with sorting

25 extensions and 20+ dashboard components — open source

All extensions run in their own process, sandboxed from the core runtime. Build your own and share with the community.

USE CASES

Three angles, one edge-first runtime

NeoMind runs the same local LLM across three complementary patterns — vision with memory, real-time streams, and sensor/control loops. Pick an angle to see how the pieces fit.

Rich Vision AI

On-device models turn every frame into structured data — bounding boxes, OCR readings, classification counts. Detection, text, and recognition running locally, frame by frame.

YOLO detection & tracking
OCR (PaddleOCR-VL)
Classification & counting

Memory-Enabled LLM

The local LLM is not just a text generator — it remembers history, calls tools, compares against past events, and writes structured status reports and operational rules.

Long-term memory of past events
Tool calls (memory · shell · devices)
Learns & updates decision rules

NeoMind dashboard — detection, OCR, classification across water meters, vehicles, and trash bins — Every camera feed runs through local vision models — bounding boxes on vehicles and bins, OCR on meter faces, per-class counts plotted over time.

NeoMind agent task panel — memory call, shell tool, historical context, structured report — Each capture becomes a task: the agent calls memory + shell tools, references past events from days ago, and writes a structured report with operational rules.

Water Meter OCRVehicle CountingTrash Bin AnalysisShelf DetectionConstruction Log

FOR DEVELOPERS

Built in Rust, extensible by design

A process-isolated extension SDK, an event-driven core, and an AI-assisted authoring workflow. Ship a new capability in minutes.

$curl -fsSL https://raw.githubusercontent.com/camthink-ai/NeoMind/main/scripts/install.sh | sh

Linux · macOS · Windows

RAM (local LLM)

8 GB+ · 16 GB recommended

GPU (optional)

CUDA / Apple Silicon

Install & run

One-line server install, or clone and run from source.

Build an extension

Process-isolated SDK — declare metadata, implement the trait, ship.

bash — quickstart.sh
# 1. Install Ollama + pull a model
curl -fsSL https://ollama.com/install.sh | sh
ollama pull qwen3.5:4b

# 2. Clone & run the server
git clone https://github.com/camthink-ai/NeoMind.git
cd NeoMind && cargo run -p neomind-cli -- serve
# → API on http://localhost:9375

rust — my_extension.rs
use neomind_extension_sdk::prelude::*;

struct WeatherExtension;

declare_extension!(
    WeatherExtension,
    metadata: ExtensionMetadata {
        name: "weather.sensor".into(),
        version: "1.0.0".into(),
        ..
    },
);

impl Extension for WeatherExtension {
    fn metrics(&self) -> &[MetricDefinition] {
        &[MetricDefinition {
            name: "temperature".into(),
            data_type: MetricDataType::Float,
            ..Default::default()
        }]
    }
}

Rust 1.85+ workspace, zero external deps Cross-platform: macOS · Windows · Linux desktop (Tauri 2.x) Single binary server, systemd-ready, port 9375 Claude Code skill: /neomind-extension scaffolds a full extension

Process-isolated · sandboxed from the core runtime FFI exports via neomind_export!() macro Hot-reload without restarting the server Cross-platform build: 6 targets from one Cargo.toml

AI-ASSISTED AUTHORING

Scaffold an extension with Claude Code

Run the /neomind-extension skill inside Claude Code. The agent reads SDK conventions, writes the Rust crate + manifest, builds it, and installs it — your extension is live in minutes, not days.

Reads SDK metadata and conventions automatically
Writes Cargo.toml, src/lib.rs, and extension.json
Builds, installs, and hot-reloads in-process

claude — ~/neomind-weathersonnet

✓Claude Code · /neomind-extension skill loaded

❯/neomind-extension weather-sensor

→ a temperature + humidity sensor extension

✦I'll scaffold a weather sensor extension. Reading the SDK conventions first…

Readsdk/extension-sdk/README.md

Writesrc/lib.rs82 lines

WriteCargo.toml14 lines

Writeextension.json8 lines

Bashcargo build --release✓ compiled

Bashneomind-cli ext install ./weather-sensor✓ installed

✦weather.sensor v1.0.0 is live — 2 metrics registered, process-isolated, hot-reloadable.

❯

Read the docs & build your first extension

Full SDK reference, device-type JSON guide, and dashboard component authoring — on the wiki.

Extension guide

FAQ

Questions, answered

An open-source, edge-deployed LLM agent platform for IoT. You control devices, create automations, and query system status through natural language — running a local LLM, fully offline.

Yes. With Ollama as the LLM backend, NeoMind runs completely offline — perfect for edge deployments, secure environments, or strict data-privacy requirements. All processing happens locally.

Ollama (recommended for edge), llama.cpp, OpenAI, Anthropic Claude, Google Gemini, xAI Grok, DeepSeek, Qwen, GLM, MiniMax, and any OpenAI-compatible endpoint. Switch providers anytime.

MQTT is built in (embedded broker, no external service). Modbus TCP/RTU, LoRaWAN, BACnet/IP, ONVIF, OPC-UA, and Home Assistant are added via open-source bridge extensions.

The Rules Engine defines automations as pure JSON — declarative trigger, condition, and actions, no DSL parser. Example: {"trigger":{"trigger_type":"data_change"},"condition":{"condition_type":"comparison","source":"device:sensor-01:temperature","operator":"greater_than","threshold":30},"actions":[{"type":"notify","message":"Temp high: {value}°C","severity":"critical"}]}. You can also describe rules in natural language and the LLM generates the JSON.

Extensions add capabilities as native libraries (.so/.dylib/.dll) or WASM modules, process-isolated with crash protection. They share the device type system and can ship dashboard cards. NeoMind ships an extension-development skill — open the repo in Claude Code and scaffold one in minutes.

Yes — Apache-2.0. Source on GitHub. Community contributions for device types, extensions, and core features are welcome.

Run AI at the edge,
on your own terms

Download NeoMind, connect your devices, and let the local LLM handle the rest — fully on-premise, fully offline.

Download NeoMind Star on GitHub Read the docs

Edge AI that runsyour IoT