• v0.6.0 RC1 — Release Candidate 1! Plugin-based extensions system with 26+ built-in extensions, 12 AI providers, drop-in plugin architecture, and a fully revamped WebUI with Extensions Manager and improved notification sounds. Docker images are coming with the full release!

• PLEASE NOTE - There are new requirements and new config options - v0.6.0 updates many required library versions and brings us into alignment with the 2.7 branch of the Meshtastic Python library! Old configs should work out of the box - but there are new config flags and a new "description" feature for custom commands in commands_config.json. Read the changelogs.

• Having issues getting up and running? As of v0.6.0 I have created a custom GPT with Open-AI to assist anyone having problems - give it a try! - https://chatgpt.com/g/g-68d86345f4c4819183c417b3790499c7-mesh-api-setup-assistant

MESH-API is an experimental project that bridges Meshtastic LoRa mesh networks with powerful AI chatbots and 3rd party APIs.

Most projects in this space stop at being "AI chatbot integrations" — but MESH-API is much more than that.

• Full Router / Mesh Operator
  MESH-API isn’t just talking to an LLM. It’s a protocol bridge and mesh backbone, designed to let LoRa networks, online (or offline) services, and APIs talk to each other in real time.

• Not a One-Trick Pony
  Where other tools simply connect to AI, MESH-API is built to route, translate, and post messages between different systems and services — making it a true hub for both on-grid and off-grid communication.

• Expandable by Design
  Any software with a working API can be integrated. That means you can merge in external services, dashboards, or automation platforms, extending the mesh far beyond its original scope.

• AI-Powered Off-Grid Networks
  MESH-API provides the foundation for self-sufficient LoRa mesh networks enhanced with AI, ensuring communication, automation, and decision-making remain possible — even without the internet.

In short, MESH-API bridges the gap between mesh services and online/locally hosted services, making it a powerful backbone for resilient, intelligent LoRa networks.

Disclaimer:
This project is NOT ASSOCIATED with the official Meshtastic Project. It is provided solely as an extension to add AI and advanced features to your Mesh network.

Release Candidate Warning:
This version (v0.6.0 RC1) is a release candidate — nearly feature-complete and approaching the full release. While significantly more stable than earlier pre-releases, some features may still have rough edges. Please avoid relying on it for mission‑critical tasks or emergencies. Always have backup communication methods available and use responsibly.

I am one robot using other robots to write this code. Some features are still untested in the field. Check the GitHub issues for fixes or feedback!

The Meshtastic logo trademark is the trademark of Meshtastic LLC.

• Plugin-Based Extensions System (New in v0.6.0)
  • 26+ built-in extensions across 5 categories: Communication, Notifications, Emergency/Weather, Ham Radio/Off-Grid, and Smart Home.
  • Drop-in plugin architecture — add or remove extensions by copying a folder. No core code changes required.
  • Extensions can register slash commands, react to emergencies, observe messages, expose HTTP endpoints, and run background services.
  • WebUI Extensions Manager — view, enable/disable, and configure extensions from the dashboard.
  • See the Extensions Reference section below for full details on all built-in extensions, or Developing Custom Extensions to build your own.
• Multiple AI Providers
  • Support for Local models (LM Studio, Ollama), OpenAI, Claude, Gemini, Grok, OpenRouter, Groq, DeepSeek, Mistral, generic OpenAI-compatible endpoints, and Home Assistant integration.
• Home Assistant Integration
  • Seamlessly forward messages from a designated channel to Home Assistant’s conversation API. Optionally secure the integration using a PIN.
• NASA Space Weather Monitoring
  • Track geomagnetic storms, solar flares, coronal mass ejections, and more via NASA's DONKI API. Auto-broadcast significant events to the mesh with configurable Kp index and flare class thresholds. Slash commands: /spaceweather, /solarflare, /geomagstorm.
• n8n Workflow Automation
  • Bidirectional bridge with n8n — forward mesh messages and emergencies to n8n webhook triggers, receive workflow outputs on the mesh, list active workflows, and trigger them via slash commands. Enables powerful no-code automation pipelines for your mesh network.
• Advanced Slash Commands
  • Built‑in commands: suffixed /about-XY, /help-XY, /motd-XY, /whereami-XY, /nodes-XY, AI commands with your unique suffix (e.g., /ai-XY, /bot-XY, /query-XY, /data-XY), unsuffixed /test, and unsuffixed /emergency (or /911), plus custom commands via commands_config.json.
  • Commands are now case‑insensitive for improved mobile usability.
  • New: a per-install randomized alias (e.g. /ai-9z) is generated on first run to reduce collisions when multiple bots exist on the same mesh or MQTT network. You can change it in config.json (field ai_command). All AI commands require this suffix, and other built‑ins (except emergency/911) also require your suffix.
  • Strongly encouraged: customize your commands in commands_config.json to avoid collisions with other users.
• Emergency Alerts
  • Trigger alerts that are sent via Twilio SMS, SMTP Email, and, if enabled, Discord.
  • Emergency notifications include GPS coordinates, UTC timestamps, and user messages.
• Enhanced REST API & WebUI Dashboard
  • A modern three‑column layout showing direct messages, channel messages, and available nodes. Stacks on mobile; 3‑wide on desktop. Controls (Suffix, Commands, Config, Logs) live in the “Send a Message” header (top‑right).
  • Additional endpoints include /messages, /nodes, /connection_status, /logs, /logs_stream, /send, /ui_send, /commands_info (JSON commands list), and a new /discord_webhook for inbound Discord messages.
  • UI customization through settings such as theme color, hue rotation, notification sounds (built-in beep or custom file), and volume control.
  • Config Editor (WebUI): Click the “Config” button in the header to view/edit config.json, commands_config.json, and motd.json in a tabbed editor. JSON is validated before saving; writes are atomic. Some changes may require a restart to take effect.
  • Emoji enhancements: each message has a React button that reveals a compact, hidden emoji picker; choosing an emoji auto‑sends a reaction (DM or channel). The send form includes a Quick Emoji bar that inserts emojis into your draft (does not auto‑send).
  • Extensions Manager (WebUI): Click the "Extensions" button to view extension status, enable/disable extensions, edit extension configs, and hot-reload all extensions — all from the browser.
• Improved Message Chunking & Routing
  • Automatically splits long AI responses into configurable chunks with delays to reduce radio congestion.
  • Configurable flags control whether the bot replies to broadcast channels and/or direct messages.
  • New: LongFast (channel 0) response toggle — by default the bot will NOT respond on LongFast to avoid congestion. Enable ai_respond_on_longfast only if your local mesh agrees.
  • Etiquette: Using AI bots on public LongFast is discouraged; keep it off unless you’re on an isolated/private mesh with community consent.
• Robust Error Handling & Logging
  • Uses UTC‑based timestamps with an auto‑truncating script log file (keeping the last 100 lines if the file grows beyond 100 MB).
  • Enhanced error detection (including specific OSError codes) and graceful reconnection using threaded exception hooks.
• Discord Integration Enhancements
  • Route messages to and from Discord.
  • New configuration options and a dedicated /discord_webhook endpoint allow for inbound Discord message processing.
  • MQTT-aware response gating: set respond_to_mqtt_messages to true in config.json if you want the bot to respond to messages that arrive via MQTT. Off by default to prevent multiple server responses.
  • User‑initiated only: The AI does not auto‑message or greet new nodes; it responds only to explicit user input.
• Commands modal & startup helper
  • WebUI includes a Commands modal (button in the “Send a Message” header) that lists available commands with descriptions.
  • The current alias suffix and a one‑line commands list are printed at startup for easy reference.
• Windows & Linux Focused
  • Official support for Windows environments with installation guides; instructions for Linux available now - MacOS coming soon!

An example of an awesome Raspberry Pi 5 powered mini terminal - running MESH-API & Ollama with HomeAssistant integration!

• Top case model here by oinkers1: https://www.thingiverse.com/thing:6571150
• Bottom Keyboard tray model here by mr_tbot: https://www.thingiverse.com/thing:7084222
• Keyboard on Amazon here: https://a.co/d/2dAC9ph

Note: The extensions system and all corresponding extensions are new and largely untested. Please report any issues on GitHub so they may be investigated and addressed.

Complete reference for all built-in extensions included with MESH-API.
Each extension is a self-contained plugin in the extensions/ directory with its own config.json, extension.py, and __init__.py.

Quick start: Enable any extension by setting "enabled": true in its config.json file and restarting MESH-API.

• Communication Extensions: Discord · Slack · Telegram · Matrix · Signal · Mattermost · Zello · MQTT (Extension) · Webhook Generic · IMAP · Mastodon · n8n
• Notification Extensions: Apprise · Ntfy · Pushover · PagerDuty · OpsGenie
• Emergency & Weather Extensions: NWS Alerts · OpenWeatherMap · USGS Earthquakes · GDACS · Amber Alerts · NASA Space Weather
• Ham Radio & Off-Grid Extensions: Winlink · APRS · BBS
• Smart Home Extensions: Home Assistant (Extension)

Bidirectional bridge between Meshtastic mesh and a Discord channel.

Commands:

Config (extensions/discord/config.json):

Hooks: on_message (forwards mesh→Discord), on_emergency (posts alerts), Flask route /discord_webhook.

Bidirectional Slack integration using Bot API and incoming webhooks.

Commands:

Config (extensions/slack/config.json):

Hooks: on_message, on_emergency.

Bidirectional Telegram bot bridge using the Bot API with getUpdates long-polling.

Commands:

Config (extensions/telegram/config.json):

Hooks: on_message, on_emergency.

Bidirectional Matrix (Element) bridge using the Client-Server API.

Commands:

Config (extensions/matrix/config.json):

Hooks: on_message, on_emergency.

Bidirectional Signal bridge using the signal-cli-rest-api.

Commands:

Config (extensions/signal/config.json):

Hooks: on_message, on_emergency.

Bidirectional Mattermost bridge using REST API + incoming webhook.

Commands:

Config (extensions/mattermost/config.json):

Hooks: on_message, on_emergency.

Outbound message forwarding to Zello Work PTT channels.

Commands:

Config (extensions/zello/config.json):

Hooks: on_message, on_emergency.

Bidirectional MQTT messaging with JSON payloads and optional TLS.

Commands:

Config (extensions/mqtt/config.json):

Hooks: on_message, on_emergency.

Fully configurable bidirectional HTTP webhook with HMAC verification.

Commands:

Config (extensions/webhook_generic/config.json):

Hooks: on_message, on_emergency. Flask route for inbound webhooks.

Inbound email monitoring with subject/sender filtering.

Commands:

Config (extensions/imap/config.json):

Hooks: on_emergency (none — inbound only).

Fediverse / Mastodon bridge for posting toots and reading timeline from the mesh.

Commands:

Config (extensions/mastodon/config.json):

Hooks: on_emergency (auto-post).

Bidirectional workflow automation bridge with n8n. Forward mesh messages and emergencies to n8n webhook triggers, receive messages from n8n workflows, query instance status, and list or trigger workflows from the mesh.

Commands:

Config (extensions/n8n/config.json):

Hooks: on_message, on_emergency. Flask route for inbound webhooks.

Universal notification gateway supporting 100+ services through URL-based configuration.

Commands:

Config (extensions/apprise/config.json):

Apprise URL examples: slack://token, telegram://bot_token/chat_id, discord://webhook_id/webhook_token, etc. See Apprise docs for 100+ supported services.

Hooks: on_emergency.

Push notifications via ntfy.sh with SSE-based inbound subscription.

Commands:

Config (extensions/ntfy/config.json):

Hooks: on_emergency.

Push notifications via the Pushover API with priority levels.

Commands:

Config (extensions/pushover/config.json):

Hooks: on_emergency.

PagerDuty incident management — trigger, acknowledge, and resolve incidents from the mesh.

Commands:

Config (extensions/pagerduty/config.json):

Hooks: on_emergency, on_message (keyword matching).

Atlassian OpsGenie alert management from the mesh.

Commands:

Config (extensions/opsgenie/config.json):

Hooks: on_emergency, on_message (keyword matching).

National Weather Service severe weather alerts with zone-based filtering.

Commands:

Config (extensions/nws_alerts/config.json):

Hooks: on_emergency (none — outbound broadcast only).

Weather data including current conditions, forecasts, and severe weather alerts.

Commands:

Config (extensions/openweathermap/config.json):

Hooks: on_emergency (none — outbound only).

USGS earthquake monitoring with magnitude and radius filtering.

Commands:

Config (extensions/usgs_earthquakes/config.json):

Hooks: on_emergency (none — outbound only).

Global Disaster Alerting Coordination System — monitors 6 disaster types worldwide.

Commands:

Config (extensions/gdacs/config.json):

Disaster type codes: EQ = Earthquake, TC = Tropical Cyclone, FL = Flood, VO = Volcano, DR = Drought, WF = Wildfire.

Hooks: on_emergency (none — outbound only).

Missing person alerts (AMBER, Silver, Blue) from the NWS CAP feed with state filtering.

Commands:

Config (extensions/amber_alerts/config.json):

Hooks: on_emergency (none — outbound only).

NASA DONKI (Database Of Notifications, Knowledge, Information) space weather monitor — tracks geomagnetic storms, solar flares, coronal mass ejections, and more.

Commands:

Config (extensions/nasa_space_weather/config.json):

Event Types:

Hooks: on_emergency (none — outbound only).

Winlink Global Radio Email gateway for ham radio operators.

Commands:

Config (extensions/winlink/config.json):

Integration methods (priority order): Winlink REST API → Pat local client → RMS gateway.

Hooks: on_emergency (forwards emergency to default address).

Automatic Packet Reporting System integration for position and message bridging.

Commands:

Config (extensions/aprs/config.json):

Note: Transmitting on APRS requires a valid amateur radio licence.

Hooks: None (command-driven + background listener).

Full-featured Bulletin Board System with SQLite store-and-forward messaging.

Commands:

Config (extensions/bbs/config.json):

Database: SQLite (bbs.db) stored in the extension directory. Three tables: boards, messages, private_messages. Automatic cleanup runs every 6 hours.

Hooks: None (fully command-driven).

Routes mesh messages to the Home Assistant Conversation API as an AI provider.

This extension functions as an AI provider — when ai_provider is set to "home_assistant" in the main config.json, AI queries are routed through HA's conversation API.

Config (extensions/home_assistant/config.json):

Hooks: AI provider via get_ai_response().

Listing Extensions: Use the /extensions command on the mesh to see all loaded extensions and their status.

Enabling/Disabling: Edit the extension's config.json and set "enabled": true or "enabled": false, then restart MESH-API.

Extension Loading: Extensions are automatically discovered from the extensions_path directory (default: ./extensions). Each subfolder containing an extension.py file is loaded. Folders starting with _ (like _example) are skipped.

A step-by-step guide for building custom extensions for the MESH-API plugin system.

MESH-API uses a plugin-based extension system where each extension is a self-contained Python package that lives in the extensions/ directory. Extensions can:

• Register slash commands accessible from the mesh network
• Send and receive messages to/from the mesh
• React to emergency broadcasts
• Observe all inbound mesh messages
• Expose HTTP endpoints via Flask
• Run background threads for polling external services
• Act as AI providers

Extensions are automatically discovered and loaded at startup. No changes to core code are required.

1. Copy the template:

   cp -r extensions/_example extensions/my_extension

2. Edit the three files:

   • __init__.py — leave empty (marks the folder as a Python package)
   • config.json — define your settings (must include "enabled": true)
   • extension.py — implement your extension class

3. Restart MESH-API — your extension is auto-discovered and loaded.

4. Verify — send /extensions on the mesh to see it listed.

Every extension lives in its own subfolder under extensions/:

extensions/
├── base_extension.py        # Abstract base class (DO NOT MODIFY)
├── loader.py                 # Extension loader (DO NOT MODIFY)
├── __init__.py
└── my_extension/             # Your extension folder
    ├── __init__.py           # Empty file (required)
    ├── config.json           # Extension configuration
    └── extension.py          # Extension implementation

Naming Rules:

• Folder names must be valid Python identifiers (lowercase, underscores OK)
• Folders starting with _ are skipped by the loader (used for templates)
• The class inside extension.py must subclass BaseExtension
• Class name convention: <Name>Extension (e.g. MyExtension)

Every extension inherits from BaseExtension. Here's the complete API:

Constructor (automatic):

def __init__(self, extension_dir: str, app_context: dict):

You do not override __init__. The base class handles:

• self.extension_dir — absolute path to your extension's folder
• self.app_context — shared dict with core helpers (see below)
• self._config — loaded from your config.json

Required Properties (must override):

Built-in Properties (inherited):

Lifecycle Hooks:

Message Hooks:

Flask Integration:

Helper Methods:

app_context Dict:

The app_context dict provides access to core functionality:

1. Create the folder structure:

extensions/my_sensor/
├── __init__.py          # Empty
├── config.json
└── extension.py

2. Define config.json:

{
  "enabled": true,
  "sensor_url": "http://localhost:9000/api/reading",
  "poll_interval_seconds": 300,
  "broadcast_channel_index": 0,
  "unit": "°F"
}

The only required key is "enabled". Everything else is up to you.

3. Implement extension.py:

"""My Sensor extension — reads temperature from a local sensor API."""

import threading
import time

try:
    import requests
except ImportError:
    requests = None

from extensions.base_extension import BaseExtension


class MySensorExtension(BaseExtension):

    @property
    def name(self) -> str:
        return "My Sensor"

    @property
    def version(self) -> str:
        return "1.0.0"

    @property
    def commands(self) -> dict:
        return {
            "/temp": "Read the current temperature",
        }

    def on_load(self) -> None:
        self._stop = threading.Event()
        self.log(f"My Sensor loaded. URL: {self.config.get('sensor_url')}")

    def on_unload(self) -> None:
        self._stop.set()
        self.log("My Sensor unloaded.")

    def handle_command(self, command: str, args: str,
                       node_info: dict) -> str | None:
        if command == "/temp":
            return self._read_sensor()
        return None

    def _read_sensor(self) -> str:
        url = self.config.get("sensor_url", "")
        unit = self.config.get("unit", "°F")
        if not url:
            return "Sensor URL not configured."
        try:
            resp = requests.get(url, timeout=5)
            data = resp.json()
            temp = data.get("temperature", "?")
            return f"🌡️ Current temperature: {temp}{unit}"
        except Exception as exc:
            return f"⚠️ Sensor error: {exc}"

4. Test it:

1. Restart MESH-API
2. Send /extensions on mesh — should show "My Sensor v1.0.0 [enabled]"
3. Send /temp — should return the temperature reading

handle_command(command, args, node_info) → str | None

The most commonly used hook. Called when a mesh user sends one of your registered commands.

def handle_command(self, command: str, args: str, node_info: dict) -> str | None:
    if command == "/mycmd":
        sender = node_info.get("shortname", "?")
        return f"Hello {sender}! You said: {args}"
    return None  # Not our command

node_info dict:

{
    "node_id": "!abcd1234",      # Hex node ID
    "shortname": "ABC",          # 4-char node short name
    "longname": "Alpha Bravo",   # Full node name
    "channel_index": 0,          # Channel the message arrived on
    "is_direct": False,          # True if DM, False if broadcast
}

Return value:

• str — text sent back to the mesh (broadcast or DM depending on context)
• None — command not handled, loader passes to next extension

on_message(message, metadata)

Read-only observer hook. Called for every inbound mesh message. Use for logging, analytics, keyword scanning, or triggering side-effects.

def on_message(self, message: str, metadata: dict | None = None) -> None:
    if "help" in message.lower():
        self.log(f"Help request detected: {message}")

Do NOT return a response from on_message. Use handle_command for responses, or send_to_mesh() for async replies.

on_emergency(message, gps_coords)

Called when /emergency or /911 is triggered on the mesh.

def on_emergency(self, message: str, gps_coords: dict | None = None) -> None:
    lat = gps_coords.get("lat", "?") if gps_coords else "?"
    lon = gps_coords.get("lon", "?") if gps_coords else "?"
    self.log(f"EMERGENCY at {lat},{lon}: {message}")
    # Forward to your external service here

send_message(message, metadata)

Outbound hook. Called by the loader when the core wants to push a message to external services.

def send_message(self, message: str, metadata: dict | None = None) -> None:
    requests.post("https://example.com/api", json={"text": message})

register_routes(app)

Register Flask HTTP endpoints for inbound webhooks or APIs.

def register_routes(self, app) -> None:
    @app.route("/my_extension/webhook", methods=["POST"])
    def my_webhook():
        from flask import request, jsonify
        data = request.get_json()
        message = data.get("message", "")
        self.send_to_mesh(message, channel_index=0)
        return jsonify({"status": "ok"})

Reading Config:

api_key = self.config.get("api_key", "")
interval = int(self.config.get("poll_interval", 60))

Updating Config at Runtime:

self._config["last_check"] = "2025-01-01T00:00:00Z"
self._save_config()  # Writes to config.json on disk

Config Best Practices:

• Always provide defaults with .get(key, default)
• Include "enabled": false as the first key
• Use descriptive key names: poll_interval_seconds, broadcast_channel_index
• Document every key in your extension's comments or README

Extensions can expose HTTP endpoints. The Flask app is passed to register_routes():

def register_routes(self, app) -> None:
    @app.route("/my_ext/data", methods=["GET"])
    def my_data():
        from flask import jsonify
        return jsonify({"status": "ok", "extension": self.name})

    @app.route("/my_ext/inbound", methods=["POST"])
    def my_inbound():
        from flask import request
        data = request.get_json(force=True)
        text = data.get("message", "")
        if text:
            self.send_to_mesh(text)
        return "OK", 200

Rules:

• Use unique route paths prefixed with your extension name
• Import Flask utilities inside the route functions (avoid circular imports)
• Keep route handlers lightweight

Many extensions need to poll external services. Use daemon threads:

import threading
import time

class MyExtension(BaseExtension):
    def on_load(self) -> None:
        self._stop = threading.Event()
        self._thread = threading.Thread(
            target=self._poll_loop,
            daemon=True,
            name="my-ext-poll",
        )
        self._thread.start()

    def on_unload(self) -> None:
        self._stop.set()
        if self._thread.is_alive():
            self._thread.join(timeout=10)

    def _poll_loop(self) -> None:
        time.sleep(10)  # Initial delay to let system stabilize

        while not self._stop.is_set():
            try:
                data = self._fetch_data()
                if data:
                    self.send_to_mesh(f"New data: {data}")
            except Exception as exc:
                self.log(f"Poll error: {exc}")

            # Interruptible sleep (checks stop event every second)
            interval = int(self.config.get("poll_interval_seconds", 60))
            for _ in range(interval):
                if self._stop.is_set():
                    break
                time.sleep(1)

Thread Safety Tips:

• Use threading.Lock() if shared state is accessed from multiple threads
• Use threading.Event() for clean shutdown signaling
• Use interruptible sleep pattern (loop with 1-second sleeps)
• Always set daemon=True so threads don't prevent exit
• Give threads descriptive names

1. Guard imports — wrap optional dependencies in try/except:

   try:
       import requests
   except ImportError:
       requests = None

2. Handle errors gracefully — never let exceptions crash the main process:

   try:
       result = self._call_api()
   except Exception as exc:
       return f"⚠️ Error: {exc}"

3. Respect mesh bandwidth — keep messages short (< 230 chars if possible). The mesh has limited capacity.

4. De-duplicate — track seen message IDs to avoid broadcasting the same alert twice:

   if msg_id in self._seen_ids:
       return
   self._seen_ids.add(msg_id)

5. Clean up in on_unload() — stop threads, close sockets, flush buffers.

Naming Conventions:

• Folder: snake_case (e.g. my_extension)
• Class: PascalCaseExtension (e.g. MyExtension)
• Commands: /<lowercase> — avoid collisions with built-in commands
• Config keys: snake_case with descriptive names

Message Formatting — Use emoji prefixes for visual scanning on small screens:

• 📡 — radio/connectivity
• 🚨 — alerts/emergencies
• ✅ — success/confirmation
• ⚠️ — warnings/errors
• 📋 — lists/info
• 📧 — email/messages
• 🌡️ — weather/sensors

1. Set "enabled": true in your extension's config.json
2. Restart MESH-API
3. Check the logs for [ext:YourName] entries
4. Send /extensions to verify it's loaded
5. Test each command from a mesh node

Your self.log() calls appear in the MESH-API script log with the prefix [ext:YourName]. Check the WebUI Logs panel or the log file.

Extension not loading:

• Check that extension.py exists in the folder
• Ensure __init__.py exists (even if empty)
• Verify the class inherits from BaseExtension
• Check that name and version properties are defined
• Folder names starting with _ are ignored intentionally
• Check logs for import errors

Commands not responding:

• Verify commands property returns a dict with your command
• Check handle_command() matches the exact command string
• Make sure no other extension registers the same command
• Confirm "enabled": true in your config.json

send_to_mesh not working:

• Ensure app_context contains a valid interface
• Check that the mesh interface is connected
• Verify channel index is valid for your mesh configuration

Config not loading:

• Validate JSON syntax in config.json (use a JSON linter)
• Check file permissions
• Look for log entries about config load failures

The extensions/ directory includes 25+ working extensions you can reference:

• API Integration Workflow (Planned)

  • A guided workflow for adding new API integrations, including configuration templates, validation checks, and safe test routes before production use.
  • Goal: make it easier to connect external services without editing core code.

• MeshCore Routing Support (Coming Soon)

• WebUI Extensions Manager
  • New "Extensions" button in the dashboard toolbar opens a full Extensions Manager modal.
  • View all available extensions with color-coded status indicators (green=active, yellow=enabled but not loaded, grey=disabled).
  • Enable/disable extensions directly from the WebUI — toggles are saved to each extension's config.json.
  • Inline JSON config editor for each extension — edit and save any extension's configuration without touching the filesystem.
  • Hot-Reload button to live-reload all extensions without restarting the server.
  • New REST API endpoints: GET /extensions/status, GET/PUT /extensions/config/<slug>, POST /extensions/toggle/<slug>, POST /extensions/reload.
• Incoming Message Sound — Fixed & Improved
  • The notification sound system has been completely rewritten. Previously, the <audio> element was configured but .play() was never called — sounds were non-functional.
  • New built-in two-tone notification beep using the Web Audio API (no external files required).
  • Sound plays automatically when new inbound messages arrive (not for outgoing/WebUI/system messages).
  • New UI Settings controls: enable/disable toggle, volume slider, sound type selector (built-in beep vs. custom file), and a "Test Sound" button.
  • First page load silently seeds the seen-message set so existing messages don't trigger sounds.
• Config Modal Alignment
  • Updated config editor help text to reflect the new extension system — removed legacy Discord/Home Assistant references from config.json help.
  • Added note directing users to the Extensions button for extension configuration.
• Docker Preparation
  • Updated Dockerfile to include the extensions/ directory and all built-in extensions.
  • Updated docker-compose.yml with optional extensions volume mount.
  • Docker images coming with the full v0.6.0 release!
• Version Bump
  • Updated all version references (banner, footer, README, scripts) to v0.6.0 RC1.

• Plugin-Based Extensions System
  • Brand new drop-in plugin architecture with 26+ built-in extensions across 5 categories: Communication, Notifications, Emergency/Weather, Ham Radio/Off-Grid, and Smart Home.
  • Extensions can register slash commands, react to emergencies, observe all mesh messages, expose HTTP endpoints via Flask, and run background polling threads.
  • Each extension is fully self-contained with its own config.json — no core code changes required to add, remove, or configure extensions.
  • New /extensions mesh command to list all loaded extensions and their status.
  • ⚠️ The extensions system and all corresponding extensions are new and largely untested. Please report any issues on GitHub so they may be investigated and addressed.
• 12 AI Providers
  • Added support for Claude, Gemini, Grok, OpenRouter, Groq, DeepSeek, Mistral, and a generic OpenAI-compatible endpoint option — in addition to existing LM Studio, OpenAI, Ollama, and Home Assistant providers.
  • All OpenAI-compatible providers share a unified helper for consistent behavior and error handling.
• Extension Categories
  • Communication (12): Discord, Slack, Telegram, Matrix, Signal, Mattermost, Zello, MQTT, Webhook Generic, IMAP, Mastodon, n8n
  • Notifications (5): Apprise, Ntfy, Pushover, PagerDuty, OpsGenie
  • Emergency/Weather (6): NWS Alerts, OpenWeatherMap, USGS Earthquakes, GDACS, Amber Alerts, NASA Space Weather
  • Ham Radio/Off-Grid (3): Winlink, APRS, BBS (SQLite store-and-forward)
  • Smart Home (1): Home Assistant (AI provider extension)
• Backward Compatibility
  • Legacy Discord and Home Assistant configuration keys in the main config.json are automatically migrated to their respective extension configs on first load.
  • Old configs should work out of the box with the new extension system.
• Developer Documentation
  • Full extension development guide with base class API reference, step-by-step tutorial, hook reference, configuration patterns, Flask route examples, background thread patterns, best practices, and troubleshooting.

• New /nodes-XY command
  • Reports online nodes (heard within the last window) and total known nodes.
• Online window config
  • New nodes_online_window_sec setting controls the online window (default 2 hours).
• Ollama stability limit
  • New ollama_max_parallel setting caps concurrent Ollama requests (default 1).
• AI command matching improvements
  • /ai-XY works reliably in channels; legacy /aiXY is also accepted for compatibility.

• Mesh safety defaults
  • LongFast (channel 0) responses are OFF by default; enable ai_respond_on_longfast only if your mesh agrees.
  • MQTT response gating: new respond_to_mqtt_messages flag (default false) to prevent multiple servers from replying at once over MQTT.
  • Community note: Using AI bots on public LongFast channels is generally frowned upon because it increases congestion for everyone. The toggle remains available for isolated/private deployments or special cases, but it is off by default.
• Bot‑loop prevention
  • All AI replies now start with a tiny fixed marker m@i (≤ 3 chars). Other MESH‑AI instances ignore messages that begin with this marker.
  • Each instance also remembers node IDs that send AI‑tagged messages and ignores further requests from those nodes to mitigate bot‑to‑bot chatter.
• User‑initiated only
  • No features are planned that allow the AI to auto‑respond to “join/arrive” events or otherwise talk without an explicit message from a legitimate user.
• Per‑install command alias
  • On first run, a randomized alias (e.g. /ai-9z) is generated and saved as ai_command in config.json. Use it to avoid collisions; you can change it anytime.
  • Strongly encouraged: customize your commands in commands_config.json to minimize collisions on shared meshes/MQTT.
• No chain‑of‑thought on mesh
  • A global sanitizer removes any “thinking”/reasoning content before sending. This includes XML‑style tags (e.g. <thinking>…</thinking>), fenced blocks, YAML/JSON meta fields, and heading lines.
  • Applied consistently across all providers (LM Studio, OpenAI, Ollama) and Home Assistant so only final answers are transmitted.
• Ollama reliability
  • Added keep‑alive and request options, simple retries on transient failures, and response normalization plus sanitization for cleaner output.
• WebUI
  • Fixed ticker behavior: it now correctly honors read/unread state for both DMs and channel messages, and dismissals persist across refreshes.
  • Refined layout: Direct Messages, Channel Messages, and Available Nodes order; mobile stacking with 3‑wide desktop; controls moved to the “Send a Message” header (top‑right).
  • New Commands modal overlay: quickly view available commands and descriptions (via the Commands button). Backed by a lightweight JSON endpoint (/commands_info).
  • Scrollable panels with sensible max heights; on mobile, each panel can be collapsed/expanded for easier navigation.
  • Footer badge: "MESH-API v0.6.0" and "by: MR-TBOT".
  • Emoji reactions: every message now includes a React button that toggles a hidden emoji picker; picking an emoji auto‑sends a reaction (works for both DMs and channel messages).
  • Quick Emoji bar: the “Send a Message” form includes common emojis; clicking inserts into your draft at the cursor without auto‑sending.
  • Reaction feedback: React buttons show Sending/Sent/Failed states and temporarily disable during send to prevent accidental double‑presses.
• Docs & help
  • Updated README and in‑app /help to highlight safety defaults, MQTT gating, and your unique alias.
  • New config keys summarized above; defaults favor safety and reduce congestion.

• REBRANDED TO MESH-API
• WebUI Enhancements
  • Node Search added for easier node management.
  • Channel Message Organization with support for custom channels in config.json.
  • Revamped DM threaded messaging system.
  • Location Links for nodes with available location data via Google Maps.
  • Timezone Selection for accurate incoming message timestamps.
  • Custom Local Sounds for message notifications (no longer relying on hosted files).
  • Logs Page Auto-Refresh for live updates.
• Baudrate Adjustment
  • Configurable baud rate in config.json for longer USB connections (e.g., roof nodes).
• LM Studio Model Selection
  • Support for selecting models when multiple are loaded in LM Studio, enabling multi-model instances.
• Protobuf Noise Debugging
  • Moved any protobuf-related errors behind debug logs as they do not affect functionality.
  • Can be enabled by setting "debug": true in config.json to track.
• Updated Docker Support
  • Updated Docker configuration to always pull/build the latest Meshtastic-Python libraries, ensuring compatibility with Protobuf versions.

• Initial Ubuntu & Ollama Unidecode Support: -
  • User @milo_o - Thank you so much! I have merged your idea into the main branch - hoping this works as expected for users - please report any problems! - #19
• Emergency Email Google Maps Link:
  • Emergency email now includes a Google Maps link to the sender's location, rather than just coordinates. - Great call, @Nlantz79! (Remember - this is only as accurate as the sender node's location precision allows!)

• Error Handling (ongoing):
  • Trying a new method to handle WinError exceptions - which though much improved in v0.4.0 - still occur under the right connection circumstances - especially over Wi-Fi.
    (UPDATE: My WinError issues were being caused by a combination of low solar power, and MQTT being enabled on my node. MQTT - especially using LongFast is very intense on a node, and can cause abrupt connection restarts as noted here: meshtastic/meshtastic#901 - but - now the script is super robust regardless for handling errors!)
• Emergency Email Subject:
  • Email Subject now includes the long name, short name & Node ID of the sending node, rather than just the Node ID.
• INITIAL Docker Support

• Logging & Timestamps:
  • Shift to UTC‑based timestamps and enhanced log management.
• Discord Integration:
  • Added configuration for inbound/outbound Discord message routing.
  • Introduced a new /discord_webhook endpoint for processing messages from Discord.
• Emergency Notifications:
  • Expanded emergency alert logic to include detailed context (GPS data, UTC time) and Discord notifications.
• Sending and receiving SMS:
  • Send SMS using /sms <+15555555555> <message>
  • Config options to either route incoming Twilio SMS messages to a specific node, or a channel index.
• Command Handling:
  • Made all slash commands case‑insensitive to improve usability.
  • Enhanced custom command support via commands_config.json with dynamic AI prompt insertion.
• Improved Error Handling & Reconnection:
  • More granular detection of connection errors (e.g., specific OSError codes) and use of a global reset event for reconnects.
• Code Refactoring:
  • Overall code improvements for maintainability and clarity, with additional debug prints for troubleshooting.

• WebUI Overhaul:
  • Redesigned three‑column dashboard showing channel messages, direct messages, and node list.
  • New send‑message form with toggleable modes (broadcast vs. direct), dynamic character counting, and message chunk preview.
• Improved Error Handling & Stability:
  • Redirected stdout/stderr to a persistent script.log file with auto‑truncation.
  • Added a connection monitor thread to detect disconnections and trigger automatic reconnects.
  • Implemented a thread exception hook for better error logging.
• Enhanced Message Routing & AI Response Options:
  • Added configuration flags (reply_in_channels and reply_in_directs) to control AI responses.
  • Increased maximum message chunks (default up to 5) for longer responses.
  • Updated slash command processing (e.g., added /about) and support for custom commands.
• Expanded API Endpoints:
  • New endpoints: /nodes, updated /connection_status, and /ui_send.
• Additional Improvements:
  • Robust Home Assistant integration and basic emergency alert enhancements.

• Expanded Configuration & JSON Files
  • New config.json fields
    • Added debug toggle for verbose debugging.
    • Added options for multiple AI providers (lmstudio, openai, ollama), including timeouts and endpoints.
    • Introduced Home Assistant integration toggles (home_assistant_enabled, home_assistant_channel_index, secure pin, etc.).
    • Implemented Twilio and SMTP settings for emergency alerts (including phone number, email, and credentials).
    • Added Discord webhook configuration toggles (e.g., enable_discord, discord_send_emergency, etc.).
    • Several new user-configurable parameters to control message chunking (chunk_size, max_ai_chunks, and chunk_delay) to reduce radio congestion.
• Support for Multiple AI Providers
  • Local Language Models (LM Studio, Ollama) and OpenAI (GPT-3.5, etc.) can be selected via ai_provider.
  • Behavior is routed depending on which provider you specify in config.json.
• Home Assistant Integration
  • Option to route messages on a dedicated channel directly to Home Assistant’s conversation API.
  • Security PIN requirement can be enabled, preventing unauthorized control of Home Assistant.
• Improved Command Handling
  • Replaced single-purpose code with a new, flexible commands system loaded from commands_config.json.
  • Users can define custom commands that either have direct string responses or prompt an AI.
  • Built-in commands now include /ping, /test, /emergency, /whereami, /help, /motd, and more.
• Emergency Alert System
  • /emergency (or /911) triggers optional Twilio SMS, SMTP email, and/or Discord alerts.
  • Retrieves node GPS coordinates (if available) to include location in alerts.
• Improved Message Chunking & Throttling
  • Long AI responses are split into multiple smaller segments (configurable via chunk_size & max_ai_chunks).
  • Delays (chunk_delay) between chunks to avoid flooding the mesh network.
• REST API Endpoints (via built-in Flask server)
  • GET /messages: Returns the last 100 messages in JSON.
  • GET /dashboard: Displays a simple HTML dashboard showing the recently received messages.
  • POST /send: Manually send messages to nodes (direct or broadcast) from external scripts or tools.
• Improved Logging and File Structure
  • messages.log for persistent logging of all incoming messages, commands, and emergencies.
  • Distinct JSON config files: config.json, commands_config.json, and motd.json.
• Refined Startup & Script Structure
  • A new Run MESH-API - Windows.bat script for straightforward Windows startup.
  • Added disclaimers for alpha usage throughout the code.
  • Streamlined reconnection and exception handling logic with more robust error-handling.
• General Stability & Code Quality Enhancements
  • Thorough refactoring of the code to be more modular and maintainable.
  • Better debugging hooks, improved concurrency handling, and safer resource cleanup.

1. Download/Clone

• Clone the repository or copy the mesh-api folder to your Desktop. (Rename and remove "-main" tag from the folder name if downloading as ZIP)

2. Install Dependencies:
   • Create a virtual environment:

   cd path\to\mesh-api python -m venv venv venv\Scripts\activate

   - Upgrade pip and install required packages:
   ```bash
   pip install --upgrade pip
   pip install -r requirements.txt
   

3. Configure Files:
   • Edit config.json, commands_config.json, and motd.json as needed. Refer to the Configuration section below.
4. Start the Bot:

• Run the bot by double‑clicking Run MESH-API - Windows.bat or by executing:

  python mesh-api.py

5. Access the WebUI Dashboard:
   • Open your browser and navigate to http://localhost:5000/dashboard.

1. Download/Clone

• Clone the repository or copy the mesh-api folder to your preferred directory:

  git clone https://github.com/mr-tbot/mesh-api.git
  cd mesh-api

2. Create and Activate a Virtual Environment Named mesh-api:

   • Create the virtual environment:

   python3 -m venv mesh-api

   - Activate the virtual environment:
   ```bash
   source mesh-api/bin/activate
   

3. Install Dependencies:

   • Upgrade pip and install the required packages:

     pip install --upgrade pip
     pip install -r requirements.txt

4. Configure Files:

   • Edit config.json, commands_config.json, and motd.json as needed. Refer to the Configuration section in the documentation for details.

5. Start the Bot:

   • Run the bot by executing:

   python mesh-api.py

6. Access the WebUI Dashboard:

   • Open your browser and navigate to http://localhost:5000/dashboard.

1. Prerequisites

   • Docker installed on your host (Linux, macOS, Windows or Raspberry Pi). (Current Images Built for Linux x86 & ARM64 Raspberry Pi)
   • Docker support is currently untested on Windows & MacOS, and the Raspberry Pi image remains fresh and untested - please report back!
   • A Meshtastic device connected via USB, WiFi, or Bluetooth (BLE)
   • If needed,uncomment USB sections and set identifiers such as /dev/ttyUSB0 or \\.\COM3.

2. Prepare the Volume Structure

   • In the root of your project directory:

• Extract the "docker-required-volumes.zip" - The included "config" & "logs" folders should be within your "mesh-api folder"
• This file structure differs from the standard release to accommodate volumes for docker
• These files are placed in order to prevent docker from replacing these with directories on first start and throwing errors.
• Make any changes to config files as needed before moving forward.

File structure should look like this:

mesh-api/
├── config/
│   ├── config.json
│   ├── commands_config.json
│   └── motd.json
└── logs/
 ├── script.log
 ├── messages.log
 └── messages_archive.json

3. Pull & run the Docker Image using docker-compose
   • An example docker-compose-yaml is included in the github repository - please adjust as needed.
   • From the project directory, run:

docker pull mrtbot/mesh-api:latest docker-compose up -d

4. Access the WebUI Dashboard:
   • Open your browser and navigate to http://localhost:5000/dashboard.

• Interacting with the AI:
  • Use your randomized alias shown at startup (e.g., /ai-9z) — AI commands require the suffix: /ai-9z, /bot-9z, /query-9z, /data-9z followed by your message.
  • To avoid collisions (multiple bots responding), prefer your unique alias and/or customize commands in commands_config.json.
  • For direct messages, simply DM the AI node if configured to reply.
• Location Query:
  • Send /whereami-XY (replace XY with your suffix) to retrieve the node’s GPS coordinates (if available).
• Emergency Alerts:
  • Trigger an emergency using /emergency <message> or /911 <message>.
    • These commands send alerts via Twilio, SMTP, and Discord (if enabled), including GPS data and timestamps.
• Sending and receiving SMS:
  • Send SMS using your suffixed command, e.g., /sms-9z <+15555555555> <message>
  • Config options to either route incoming Twilio SMS messages to a specific node, or a channel index.
• Home Assistant Integration:
  • When enabled, messages sent on the designated Home Assistant channel (as defined by "home_assistant_channel_index") are forwarded to Home Assistant’s conversation API.
  • In secure mode, include the PIN in your message (format: PIN=XXXX your message).
• WebUI Messaging:
  • Use the dashboard’s send‑message form to send broadcast or direct messages. The mode toggle and node selection simplify quick replies.

• Open the dashboard and click the “Config” button in the header (next to Commands/Logs).
• A tabbed editor appears with three files:
  • config.json — core app settings (providers, timeouts, routing, integrations, etc.)
  • commands_config.json — custom slash commands and AI prompts
  • motd.json — the Message of the Day string shown in the UI
• Make edits and click Save. The editor validates JSON before saving (for JSON files) and writes changes atomically to prevent partial/corrupted updates.
• All config.json options are available here since the editor loads and saves the full file.
• Changes to some settings may require restarting the app/container to take effect (e.g., provider, connectivity, or Discord/Twilio credentials).
• Security note: If you expose the WebUI beyond localhost, protect access to the dashboard since configuration files may contain secrets (API keys, tokens).

The Config Editor includes a grouped help panel. These are the main groups and what they cover:

• Core: AI provider selection, system prompt, alias suffix, AI node name, local location string.
• Diagnostics: debug logging and message log limits.
• Providers: LM Studio, OpenAI, Ollama, and Home Assistant settings.
• Connectivity: WiFi, serial, or mesh interface options and advanced node overrides.
• Policy: Reply behavior and MQTT response gating.
• Performance: Chunk sizing and delays for radio-friendly responses.
• Channels: Friendly channel names and /nodes-XY online window.
• Integrations: Home Assistant, Discord, Twilio, and SMTP credentials and routing. (future home of API integration settings)

• AI responses include a very short prefix marker m@i at the start of the message body. This is not configurable on purpose and is capped at 3 characters to conserve airtime.
• Other MESH-API instances will ignore messages that start with this marker, preventing bots from talking to each other.
• Each instance also tracks node IDs that have sent AI-tagged messages and ignores further messages from those nodes.

• Bot‑looping happens when two or more automated agents see each other’s messages as prompts and keep replying back and forth without a human in the loop.
• On a constrained LoRa mesh, this can quickly saturate airtime (especially on LongFast), drain batteries, and crowd out legitimate traffic.
• Loops can be surprisingly hard to break because:
  • Messages may be re‑broadcast via MQTT and multiple gateways, multiplying replies.
  • Nodes can buffer/retry after brief outages, re‑triggering the loop even if you silence one side.
  • Different bots might parse/quote each other in ways that keep producing “valid” prompts.
• MESH‑API mitigations:
  • A fixed 3‑char marker (m@i) at the start of AI replies so other instances will ignore them.
  • A memory of node IDs that have emitted AI‑tagged messages to avoid engaging those nodes.
  • Conservative defaults: no LongFast replies by default and MQTT response gating disabled by default.
  • Policy: the AI never initiates conversations or responds to arrival/presence events—only explicit human messages.

The MESH-API server (running on Flask) exposes the following endpoints:

• GET /messages
  Retrieve the last 100 messages in JSON format.
• GET /nodes
  Retrieve a live list of connected nodes as JSON.
• GET /connection_status
  Get current connection status and error details.
• GET /logs
  View a styled log page showing uptime, restarts, and recent log entries.
• GET /logs_stream
  Stream recent logs in JSON for lightweight polling.
• GET /dashboard
  Access the full WebUI dashboard.
• GET /commands_info
  Retrieve a JSON list of available commands and descriptions (used by the in‑app Commands modal).
• GET /config_editor/load
  Load the current contents of config.json, commands_config.json, and motd.json for the WebUI Config Editor.
• POST /config_editor/save
  Save updates to the above files. Payload is validated (JSON where applicable) and written atomically. Some settings require an app restart to apply.
• POST /send and POST /ui_send
  Send messages programmatically.
• POST /discord_webhook
  Receive messages from Discord (if configured).

Your config.json file controls core MESH-API settings — connection, AI, messaging, and emergency alerts. Integration-specific settings (Discord, Home Assistant, Slack, Telegram, etc.) are now configured per-extension in extensions/<name>/config.json. See the Extensions System section and the WebUI Extensions Manager for details.

Below is the default config.json with inline explanations:

{
  "debug": false,                          // Enable verbose debug logging
  "use_mesh_interface": false,             // Set true to use the Meshtastic mesh interface
  "use_wifi": false,                       // Set true to connect to your node via WiFi instead of serial
  "wifi_host": "MESHTASTIC NODE IP HERE",  // IP address of your Meshtastic device (WiFi mode)
  "wifi_port": 4403,                       // TCP port for WiFi connection (default 4403)

  "use_bluetooth": false,                   // Set true to connect to your node via Bluetooth Low Energy (BLE)
  "ble_address": "",                        // BLE MAC address or UUID of your node (leave empty for auto-scan)

  "extensions_path": "./extensions",       // Path to the extensions directory

  "ai_respond_on_longfast": false,         // Do NOT auto-respond on LongFast (channel 0) — enable only with mesh/community consent
  "respond_to_mqtt_messages": false,       // If true, the bot responds to messages that arrived via MQTT (off by default to prevent multi-replies)

  "nodes_online_window_sec": 7200,         // Time window (seconds) for /nodes-XY online count

  "serial_port": "/dev/ttyUSB0",           // Serial port if using USB (e.g., /dev/ttyUSB0 on Linux, COMx on Windows)
  "serial_baud": 460800,                   // Baud rate for serial connections (lower for long USB runs)

  "ai_command": "",                        // Randomized per-install AI command suffix (e.g., "/ai-9z") — generated on first run to prevent collisions
  "ai_provider": "lmstudio, openai, ollama, claude, gemini, grok, openrouter, groq, deepseek, mistral, or openai_compatible",
  "system_prompt": "You are a helpful assistant responding to mesh network chats. Respond in as few words as possible while still answering fully.",

  // --- LM Studio ---
  "lmstudio_url": "http://localhost:1234/v1/chat/completions",
  "lmstudio_chat_model": "MODEL IDENTIFIER HERE",
  "lmstudio_embedding_model": "TEXT EMBEDDING MODEL IDENTIFIER HERE",
  "lmstudio_timeout": 60,

  // --- OpenAI ---
  "openai_api_key": "",
  "openai_model": "gpt-4.1-mini",
  "openai_timeout": 60,

  // --- Ollama ---
  "ollama_url": "http://localhost:11434/api/generate",
  "ollama_model": "llama3",
  "ollama_timeout": 60,
  "ollama_max_parallel": 1,               // Max concurrent Ollama requests (useful on low-power hardware)
  "ollama_options": {},                    // Optional generation overrides (e.g., {"num_ctx": 2048, "temperature": 0.2})
  "ollama_keep_alive": "10m",             // Keep model loaded for this duration; "0" to unload immediately

  // --- Claude ---
  "claude_api_key": "",
  "claude_model": "claude-sonnet-4-20250514",
  "claude_timeout": 60,

  // --- Gemini ---
  "gemini_api_key": "",
  "gemini_model": "gemini-2.0-flash",
  "gemini_timeout": 60,

  // --- Grok ---
  "grok_api_key": "",
  "grok_model": "grok-3",
  "grok_timeout": 60,

  // --- OpenRouter ---
  "openrouter_api_key": "",
  "openrouter_model": "openai/gpt-4.1-mini",
  "openrouter_timeout": 60,

  // --- Groq ---
  "groq_api_key": "",
  "groq_model": "llama-3.3-70b-versatile",
  "groq_timeout": 60,

  // --- DeepSeek ---
  "deepseek_api_key": "",
  "deepseek_model": "deepseek-chat",
  "deepseek_timeout": 60,

  // --- Mistral ---
  "mistral_api_key": "",
  "mistral_model": "mistral-small-latest",
  "mistral_timeout": 60,

  // --- OpenAI-Compatible (any provider with an OpenAI-compatible API) ---
  "openai_compatible_api_key": "",
  "openai_compatible_url": "",
  "openai_compatible_model": "",
  "openai_compatible_timeout": 60,

  // --- Channel names ---
  "channel_names": {
    "0": "LongFast",
    "1": "Channel 1",
    "2": "Channel 2",
    "3": "Channel 3",
    "4": "Channel 4",
    "5": "Channel 5",
    "6": "Channel 6",
    "7": "Channel 7",
    "8": "Channel 8",
    "9": "Channel 9"
  },

  "reply_in_channels": true,              // Allow AI to reply in broadcast channels
  "reply_in_directs": true,               // Allow AI to reply in direct messages

  "chunk_size": 200,                      // Maximum size for message chunks (bytes)
  "max_ai_chunks": 5,                     // Maximum number of chunks per AI response
  "chunk_delay": 10,                      // Delay (seconds) between chunks to reduce congestion

  "local_location_string": "@ YOUR LOCATION HERE",  // Location label for your node
  "ai_node_name": "Mesh-API-Alpha",       // Display name for your AI node

  "force_node_num": null,                 // Override the node number (null = auto-detect)
  "max_message_log": 0,                   // Max messages to log (0 = unlimited)

  // --- Emergency Alerts: Twilio SMS ---
  "enable_twilio": false,
  "enable_smtp": false,
  "alert_phone_number": "+15555555555",
  "twilio_sid": "TWILIO_SID",
  "twilio_auth_token": "TWILIO_AUTH_TOKEN",
  "twilio_from_number": "+14444444444",
  "twilio_inbound_target": "channel",      // "channel" or "node" for inbound SMS routing
  "twilio_inbound_channel_index": 1,
  "twilio_inbound_node": "!FFFFFFFF",

  // --- Emergency Alerts: SMTP Email ---
  "smtp_host": "SMTP HOST HERE",
  "smtp_port": 465,                       // 465 for SSL, 587 for TLS
  "smtp_user": "SMTP USER HERE",
  "smtp_pass": "SMTP PASS HERE",
  "alert_email_to": "ALERT EMAIL HERE"
}

Note: Discord, Home Assistant, Slack, Telegram, and all other integration-specific settings have been moved to the Extensions System. Each extension has its own config.json under extensions/<name>/. You can manage them via the WebUI Extensions Manager or by editing the files directly.

Home Assistant is now an extension. Configure it in extensions/home_assistant/config.json or via the WebUI Extensions Manager. See Extensions System for details.

• Enable: Set "enabled": true in extensions/home_assistant/config.json.
• Configure: Set the url, token, channel_index, and timeout fields in the extension config.
• Security (Optional): Enable "enable_pin": true and set "secure_pin" in the extension config.
• Routing: Messages on the designated channel are forwarded to Home Assistant. When PIN mode is enabled, include your PIN in the format PIN=XXXX your message.

Set "ai_provider" in config.json to one of the 12 supported providers, then fill in the corresponding API key / URL / model fields:

• LM Studio: "ai_provider": "lmstudio" — configure lmstudio_url, and optionally set lmstudio_chat_model / lmstudio_embedding_model if using multiple models.
• OpenAI: "ai_provider": "openai" — provide openai_api_key and choose a model (default gpt-4.1-mini).
• Ollama: "ai_provider": "ollama" — configure URL, model, and optional generation overrides via ollama_options.
• Claude: "ai_provider": "claude" — provide claude_api_key (default model claude-sonnet-4-20250514).
• Gemini: "ai_provider": "gemini" — provide gemini_api_key (default model gemini-2.0-flash).
• Grok: "ai_provider": "grok" — provide grok_api_key (default model grok-3).
• OpenRouter: "ai_provider": "openrouter" — provide openrouter_api_key (default model openai/gpt-4.1-mini).
• Groq: "ai_provider": "groq" — provide groq_api_key (default model llama-3.3-70b-versatile).
• DeepSeek: "ai_provider": "deepseek" — provide deepseek_api_key (default model deepseek-chat).
• Mistral: "ai_provider": "mistral" — provide mistral_api_key (default model mistral-small-latest).
• OpenAI-Compatible: "ai_provider": "openai_compatible" — provide openai_compatible_url, openai_compatible_api_key, and openai_compatible_model for any provider with an OpenAI-compatible API.

All providers have a configurable _timeout (default 60 seconds).

• Enable Email Alerts:
  • Set "enable_smtp": true in config.json.
• Configure SMTP:
  • Provide the following settings in config.json:
    • "smtp_host" (e.g., smtp.gmail.com)
    • "smtp_port" (use 465 for SSL or another port for TLS)
    • "smtp_user" (your email address)
    • "smtp_pass" (your email password or app-specific password)
    • "alert_email_to" (recipient email address or list of addresses)
• Behavior:
  • Emergency emails include a clickable Google Maps link (generated from available GPS data) so recipients can quickly view the sender’s location.
• Note:
  • Ensure your SMTP settings are allowed by your email provider (for example, Gmail may require an app password and proper security settings).

Discord is now an extension. Configure it in extensions/discord/config.json or via the WebUI Extensions Manager. The setup steps below for creating a Discord bot and permissions still apply.

• Access the Developer Portal:
  Go to the Discord Developer Portal and sign in with your Discord account.
• Create a New Application:
  Click on "New Application," give it a name (e.g., MESH-API Bot), and confirm.
• Add a Bot to Your Application:
  • Select your application, then navigate to the Bot tab on the left sidebar.
  • Click on "Add Bot" and confirm by clicking "Yes, do it!"
  • Customize your bot’s username and icon if desired.

• Required Permissions:
  Your bot needs a few basic permissions to function correctly:
  • View Channels: So it can see messages in the designated channels.
  • Send Messages: To post responses and emergency alerts.
  • Read Message History: For polling messages from a channel (if polling is enabled).
  • Manage Messages (Optional): If you want the bot to delete or manage messages.
• Permission Calculator:
  Use a tool like Discord Permissions Calculator to generate the correct permission integer.
  For minimal functionality, a permission integer of 3072 (which covers "Send Messages," "View Channels," and "Read Message History") is often sufficient.

• Generate an Invite Link:
  Replace YOUR_CLIENT_ID with your bot’s client ID (found in the General Information tab) in the following URL:

  https://discord.com/api/oauth2/authorize?client_id=YOUR_CLIENT_ID&permissions=3072&scope=bot

• Invite the Bot:
  Open the link in your browser, select the server where you want to add the bot, and authorize it. Make sure you have the “Manage Server” permission in that server.

Update extensions/discord/config.json with the following keys (or use the WebUI Extensions Manager):

{
  "enabled": true,
  "webhook_url": "YOUR_DISCORD_WEBHOOK_URL",
  "receive_enabled": true,
  "bot_token": "YOUR_BOT_TOKEN",
  "channel_id": "YOUR_CHANNEL_ID",
  "inbound_channel_index": 1,
  "send_ai": true,
  "send_emergency": true
}

• webhook_url:
  Create a webhook in your desired Discord channel (Channel Settings → Integrations → Webhooks) and copy its URL.
• bot_token & channel_id:
  Copy your bot’s token from the Developer Portal and enable message polling by specifying the channel ID where the bot should read messages.
  To get a channel ID, enable Developer Mode in Discord (User Settings → Advanced → Developer Mode) then right-click the channel and select "Copy ID."

• Enable Message Polling:
  Set "receive_enabled": true in the extension config to allow the bot to poll for new messages.
• Routing:
  The "inbound_channel_index" key determines the mesh channel used by MESH-API for routing incoming Discord messages.

• Restart MESH-API (or hot-reload via the WebUI Extensions Manager).
• Check Bot Activity:
  Verify that the bot is present in your server, that it can see messages in the designated channel, and that it can send responses.
• Emergency Alerts & AI Responses:
  Confirm that emergency alerts and AI responses are being posted in Discord as per your extension configuration.

• Permissions Issues:
  If the bot isn’t responding or reading messages, double-check that its role on your server has the required permissions.
• Channel IDs & Webhook URLs:
  Verify that you’ve copied the correct channel IDs and webhook URLs (ensure no extra spaces or formatting issues).
• Bot Token Security:
  Keep your bot token secure. If it gets compromised, regenerate it immediately from the Developer Portal.

• Enable Twilio:
  • Set "enable_twilio": true in config.json.
• Configure Twilio Credentials:
  • Provide your Twilio settings in config.json:
    • "twilio_sid": "YOUR_TWILIO_SID"
    • "twilio_auth_token": "YOUR_TWILIO_AUTH_TOKEN"
    • "twilio_from_number": "YOUR_TWILIO_PHONE_NUMBER"
    • "alert_phone_number": "DESTINATION_PHONE_NUMBER" (the number to receive emergency SMS)
• Usage:
  • When an emergency is triggered, the bot sends an SMS containing the alert message (with a Google Maps link if GPS data is available).
• Tip:
  • Follow Twilio's setup guide to obtain your SID and Auth Token, and ensure that your phone numbers are verified.

• Logging & Archives:

  • Script logs are stored in script.log and message logs in messages.log.
  • An archive is maintained in messages_archive.json to keep recent messages.

• Device Connection:

  • Configure the connection method for your Meshtastic device by setting either the "serial_port" or enabling "use_wifi" along with "wifi_host" and "wifi_port".
  • For Bluetooth Low Energy (BLE) connections, set "use_bluetooth": true and optionally provide "ble_address" with the device MAC address or UUID. Leave "ble_address" empty for auto-scan. Requires the bleak Python package.
  • Alternatively, enable "use_mesh_interface" if applicable.
  • Connection priority: WiFi TCP > Bluetooth BLE > MeshInterface > USB Serial.
  • Baud Rate is optionally set if you need - this is for longer USB runs (roof nodes connected via USB) and bad USB connections.

• Message Routing & Commands:

  • Custom commands can be added in commands_config.json.
  • The WebUI Dashboard (accessible at http://localhost:5000/dashboard) displays messages and node status.

• AI Provider Settings:

  • Adjust "ai_provider" and related API settings (timeouts, models, etc.) for any of the 12 supported providers: LM Studio, OpenAI, Ollama, Claude, Gemini, Grok, OpenRouter, Groq, DeepSeek, Mistral, or any OpenAI-compatible endpoint.

• Extensions:

  • Integration-specific settings (Discord, Home Assistant, Slack, Telegram, etc.) are configured per-extension in extensions/<name>/config.json. Use the WebUI Extensions Manager to enable, disable, and configure extensions without editing files directly.

• Security:

  • If using the Home Assistant extension with PIN protection, follow the specified format (PIN=XXXX your message) to ensure messages are accepted.

• Testing:

  • You can test SMS sending with your suffixed /sms-XY command or trigger an emergency alert to confirm that Twilio and email integrations are functioning.

• Release Candidate Notice:
  This release (v0.6.0 RC1) is a release candidate — nearly feature-complete and approaching the full release with Docker images. The extensions system has been tested but some extensions may still have edge cases. Please report any issues on GitHub so they may be investigated and addressed. Field testing is recommended before production use.
• Feedback & Contributions:
  Report issues or submit pull requests on GitHub. Your input is invaluable.
• Use Responsibly:
  Modifying this code for nefarious purposes is strictly prohibited. Use at your own risk.

• BTC:
  bc1qalnp0xze5t9nner2754k2pj7yjhkrt3uzvzdvt
• ETH:
  0xAd640c506f5d2368cAF420a117380820C0C5F61C
• XRP:
  rpciwKrQSaRZ1UjPunH8vLJhoM2s4NaYoL
• DOGE:
  DM79aRx58J6RYuWakHjiELWbNJkTTDj1cv

MESH-API v0.6.0 RC1 is the release candidate — almost ready for the full release and Docker images! This build adds a WebUI Extensions Manager, fixed incoming message notifications, and Docker preparation on top of the powerful 25+ extension plugin system, 12 AI providers, and safer defaults. Whether you’re chatting directly with your node, integrating with Home Assistant, or leveraging multi‑channel alerting (Twilio, Email, Discord), this release offers the most comprehensive and extensible off-grid AI assistant experience yet. Please report any issues on GitHub so they may be investigated and addressed.

Enjoy tinkering, stay safe, and have fun!
Please share your feedback or report issues on GitHub.