> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreflux.org/llms.txt
> Use this file to discover all available pages before exploring further.
# Getting Started
> Go from zero to your first working LoT Action in under 15 minutes.
**Like installing an app on your router instead of your phone.** LoT Actions run directly inside the broker -- your logic executes at the edge without an external script or server.
## Prerequisites
Before you begin, ensure you have:
* **A running Coreflux Broker** — See the [Installation Guide](/v2.0/quick-start/installation) if you haven't set one up yet
* **VS Code** with the LoT Notebooks extension *or* access to the [Coreflux HUB](/v2.0/coreflux-hub/overview) in your browser — see the [VS Code Setup Guide](/v2.0/quick-start/vscode) for the extension
* **Basic MQTT knowledge** — Understanding of topics, publish/subscribe patterns
***
Ready? Here's what you'll build and deploy.
## Your First LoT Action in 15 Minutes
> **Concept Refresher**: You are about to write an action that lives and runs **inside** the broker, not on your laptop.
Let's create a **simulated temperature sensor** that publishes a temperature reading every 5 seconds. You'll see data on a topic as soon as you deploy—no external input required. This keeps the whole guide in a single "temperature monitoring" flow.
### Understanding the Action
LoT Actions have three parts:
1. **Definition** — `DEFINE ACTION `
2. **Trigger** — When to run (`ON EVERY `, `ON TOPIC ""`, or `ON CHANGE ""` for value-change-only)
3. **Logic** — What to do (publish data, conditional logic, etc.)
Here's what we're building:
```lot Temperature Simulator wrap theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
DEFINE ACTION TemperatureSimulator
ON EVERY 5 SECONDS DO
PUBLISH TOPIC "sensors/zone1/temperature" WITH "{\"temperature\": 72}"
```
| Line | What it does |
| ------------------------------------------------ | -------------------------------------------------------------- |
| `DEFINE ACTION TemperatureSimulator` | Creates an action named "TemperatureSimulator" |
| `ON EVERY 5 SECONDS DO` | Sets a time-based trigger (runs every 5 seconds) |
| `PUBLISH TOPIC ... WITH "{\"temperature\": 72}"` | Publishes a JSON payload with temperature in Fahrenheit (72°F) |
Quotes inside strings must be escaped with backslashes (e.g. `"{\"temperature\": 72}"`).
For a complete reference on triggers, operations, and advanced patterns, see the [Actions documentation](/v2.0/lot-language/actions/overview).
### Deploy the Action
If you have the Coreflux HUB running—either as the Docker container with the HUB ports exposed, or the standalone desktop app for Windows or Linux—you can deploy actions directly from the HUB. See [Coreflux HUB Overview](/v2.0/coreflux-hub/overview) for full documentation.
In your browser, open `http://localhost:8080` if the broker runs on your machine, or `http://:8080` using the IP address of the machine where the broker is running.
In the top navigation, select **LoT**, then **LoT Editor**, and open the **Actions** tab. Click **+ New Action**.
Paste the following code (no `-addAction` prefix needed—the HUB handles registration):
```lot wrap theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
DEFINE ACTION TemperatureSimulator
ON EVERY 5 SECONDS DO
PUBLISH TOPIC "sensors/zone1/temperature" WITH "{\"temperature\": 72}"
```
You will see a confirmation and the action will appear in the Actions list. The action is now deployed and running on the broker.
The VS Code extension provides syntax highlighting, auto-completion, and real-time validation for LoT actions. See the [LoT Notebooks Setup Guide](/v2.0/quick-start/vscode) for full installation and configuration details.
Open the extension panel, search for 'LoT Notebooks', and install.
Click on File > New File..., give it it to a descriptive name (e.g., temperature-monitor).
Enter your broker credentials (host, port, username, password) and click Connect.
If you haven't changed your broker credentials, use these defaults:
| Setting | Value |
| -------- | ----------------------------------- |
| Host | `localhost` or your server IP |
| Port | `1883` (unencrypted) / `8883` (TLS) |
| Username | `root` |
| Password | `coreflux` (change immediately!) |
Create a new code block and add your code.
```lot wrap theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
DEFINE ACTION TemperatureSimulator
ON EVERY 5 SECONDS DO
PUBLISH TOPIC "sensors/zone1/temperature" WITH "{\"temperature\": 72}"
```
Click the **Run Button** on that specific cell to publish the action to your broker.
If you're using any external MQTT client, publish to the system command topic:
Connect to your broker with your credentials.
Publish the following to `$SYS/Coreflux/Command`:
```lot wrap theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
-addAction DEFINE ACTION TemperatureSimulator
ON EVERY 5 SECONDS DO
PUBLISH TOPIC "sensors/zone1/temperature" WITH "{\"temperature\": 72}"
```
Subscribe to `$SYS/Coreflux/Command/Output` — you should see:
```text wrap theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
Action 'TemperatureSimulator' added successfully
```
Note the `-addAction` prefix — this tells Coreflux to register the action definition that follows.
### Verify It's Running
If you deployed via the HUB, verify using the built-in Data Viewer. In the top navigation, select **MQTT**, then **Data Viewer**. In the Topic Tree, navigate to **sensors** → **zone1** → **temperature**. You should see `{"temperature": 72}` arriving every 5 seconds in the payload viewer.
The LoT extension automatically shows debug values for MQTT topics, so you can verify in two ways:
If the action appears in your Actions list under the Coreflux Entities tab, it should be running.
After deploying, the extension automatically subscribes to the action's topics and displays live MQTT messages. You should see temperature readings (e.g. `{"temperature": 72}`) on `sensors/zone1/temperature` arriving every 5 seconds.
Subscribe to `sensors/zone1/temperature`. You should see temperature readings arriving every 5 seconds:
```json wrap theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
{"temperature": 72}
```
**Congratulations!** Your first LoT Action is live.
## Example Real Scenario: Temperature Alarm
Now let's create a **reactive action** that transforms sensor data and checks thresholds. This demonstrates data transformation and conditional logic—common patterns in industrial monitoring.
This action runs **only when a message arrives** on `sensors/+/temperature`. After you deploy it, you will see no output until something publishes to that topic—for example, the Temperature Simulator from the previous section (if both are running), or a manual publish from the HUB Data Viewer or any MQTT client.
Here's what the action does each time a new temperature reading arrives:
1. **Trigger** — The action fires whenever a message is published to any topic matching `sensors/+/temperature` (e.g. `sensors/zone1/temperature`).
2. **Extract** — It reads the `temperature` value (in Fahrenheit) from the incoming JSON payload.
3. **Convert** — It transforms Fahrenheit to Celsius using the standard formula: `(F − 32) × 5 / 9`.
4. **Decide** — If the Celsius value exceeds 35 °C, it publishes an alert to `alerts/high_temp`. Otherwise, it publishes the normalized Celsius reading to `sensors/normalized`.
```lot wrap theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
DEFINE ACTION TemperatureAlarm
ON TOPIC "sensors/+/temperature" DO
SET "temp_f" WITH (GET JSON "temperature" IN PAYLOAD AS DOUBLE)
SET "temp_c" WITH (({temp_f} - 32) * 5 / 9)
IF {temp_c} > 35 THEN
PUBLISH TOPIC "alerts/high_temp" WITH ("Alert: " + {temp_c} + "°C exceeds threshold")
ELSE
PUBLISH TOPIC "sensors/normalized" WITH {temp_c}
```
The `{}` denotes variable substitution, and expressions must be wrapped in parentheses. The `+` in the topic pattern is a single-level MQTT wildcard -- it matches any value in that position (e.g. `sensors/zone1/temperature`, `sensors/zone2/temperature`).
### Deploy and Test
Deploy this action using the same method as above (Coreflux HUB, VS Code extension, or MQTT client). Once deployed, use the steps below to verify reactive logic.
### How to Test the Logic
The action subscribes to any topic matching `sensors/+/temperature` (e.g. `sensors/zone1/temperature`). It expects a JSON payload with a `temperature` key (Fahrenheit). It then converts to Celsius and either publishes an alert (if > 35°C) or the normalized value.
| Role | Topic | Description |
| ------------------- | --------------------------- | -------------------------------------------------------------------- |
| **Input** | `sensors/zone1/temperature` | Publish test payloads here (must match `sensors/+/temperature`) |
| **Output (normal)** | `sensors/normalized` | Receives the Celsius value when temperature is at or below 35°C |
| **Output (alert)** | `alerts/high_temp` | Receives the alert message when temperature exceeds 35°C (e.g. 95°F) |
**Sample payloads (copy-paste):**
* **Below threshold** — publish to `sensors/zone1/temperature`:
```json wrap theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
{"temperature": 77}
```
Expect: a message on `sensors/normalized` with the Celsius value (about 25).
* **Above threshold** — publish to `sensors/zone1/temperature`:
```json wrap theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
{"temperature": 95}
```
Expect: a message on `alerts/high_temp` with text like "Alert: 35°C exceeds threshold".
In **LoT** → **LoT Editor** → **Actions**, create a new action or open an existing one, paste the Temperature Alarm code, and save. Confirm it appears in the Actions list.
Select **MQTT** → **Data Viewer**. In the Topic Tree, watch `sensors/normalized` and `alerts/high_temp` (add them to your tracked view if needed).
In the **Publish** panel, set the topic to `sensors/zone1/temperature` and paste one of the sample JSON payloads above. Click publish. If the Temperature Simulator is still running, it already publishes every 5 seconds—you will see results on `sensors/normalized` (72°F is below 35°C).
Select the output topic in the tree and verify the payload in the viewer (normalized value or alert text).
Paste the action code in a LoT cell and run it. Confirm success in the Actions list.
After deploying, the extension automatically subscribes to the action's output topics and displays their values. Look for messages on `sensors/normalized` and `alerts/high_temp` once test data is published.
Use the HUB Data Viewer, the VS Code extension publish tools, or any MQTT client to publish one of the sample JSON payloads above to `sensors/zone1/temperature`. If the Temperature Simulator from the previous section is still running, it already publishes every 5 seconds and you will see results on `sensors/normalized` (72°F is below 35°C). Check the topic tree displayed below the code cell to see incoming values update in real time.
Check that the corresponding output topic received the expected message (normalized value or alert).
Publish the action to `$SYS/Coreflux/Command` with the `-addAction` prefix. Confirm "Action 'TemperatureAlarm' added successfully" on `$SYS/Coreflux/Command/Output`.
Subscribe to `sensors/normalized` and `alerts/high_temp` so you can see responses.
Publish to topic `sensors/zone1/temperature` with payload `{"temperature": 77}` or `{"temperature": 95}` (use one of the sample payloads above).
You should see a message on `sensors/normalized` (for 77°F) or on `alerts/high_temp` (for 95°F).
This confirms your broker transforms data and applies conditional logic in real time.
### Clean Up (Optional)
To remove the test action:
In **LoT** → **LoT Editor** → **Actions**, select the action in the list and use the **delete** control. Confirm deletion—the action is removed from the broker immediately.
On the Coreflux Entities tab, right-click the desired action in your Actions list and select **"Remove"**.
Publish to `$SYS/Coreflux/Command`:
```text wrap theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
-removeAction TemperatureAlarm
```
## Quick Examples
Looking for inspiration? Check out the [**Language of Things Training Repository**](https://github.com/CorefluxCommunity/Language-Of-Things-Training) for common patterns like:
* **Topic-Based Triggers**: Echo messages between topics
* **State Machines**: Toggle switches and conditional logic
* **Event Counters**: Track and aggregate system events
Explore a collection of ready-to-use LoT Action examples and templates.
## Troubleshooting
* Verify the broker is running and you're connected
* Check `$SYS/Coreflux/Command/Output` for error messages
* Ensure proper indentation in your LoT action (use consistent tabs or spaces)
* Confirm the action appears in `$SYS/Coreflux/Actions` or in the HUB LoT Editor Actions list
* Verify the broker hostname/IP and port are correct
* Check that port 1883 (or 8883 for TLS) is open
* Confirm your username and password are correct
* If using TLS, ensure certificates are properly configured
* Verify you're subscribed to the exact topic (including case sensitivity)
* Check if any Rules are blocking access to the topic
* Use wildcards (`+` or `#`) to debug topic hierarchies
## Next Steps
Now that you have a working setup, explore the core LoT components:
React to events and publish data. Create time-based automations or respond to topic changes.
Understand the core concepts and architecture of the Language of Things.
## Why This Guide?
This is the fastest way to validate your Coreflux setup: in under 15 minutes you'll have a live LoT (Language of Things) Action running inside your broker—proof that your installation works and logic executes at the edge. New to Coreflux? Start with the [Overview](../index).