Quick Start Guide¶

Introduction¶

Overview¶

You've come to the right place to start ! Follow this quick start guide and build your first Application during the next hour.

By the end of this quick start guide you will have achieved the following steps;

This course will require you to use your own computer and the Kelvin UI.

Outlined here are the tools required for each step.

Quick Start Task¶

The Python program we will create and package as an Application will continuously monitor a temperature sensor (known as a Data Stream) on a motor (known as an Asset).

If the upper temperature threshold is breached, then the app will automatically generate a new Control Change packaged into a Recommendation that will have a new optimized motor speed setpoint to maintain a lower motor temperature.

Then using the Kelvin UI, the Operations Team will be able to set the parameters of the Application to decide whether the recommendation is automatically accepted, where the control change will be immediately applied to the motor, or an approval has to be manually added to the recommendation before the control change is done.

The Technology¶

The Kelvin SDK is a Python-based software development kit designed to make it easier to create, test, and deploy Applications. These apps are purpose-built for optimizing the performance of assets, enabling you to develop solutions that can improve operational efficiency.

An Application is a custom Python application developed using the Kelvin SDK. It is designed to apply specific business logic, models and algorithms to optimize the performance of multiple assets. By delivering actionable recommendations and making control adjustments, an Application helps to enhance asset efficiency and performance.

Full Source Code¶

You can also get the full source code for this quick start guide at Kelvin's Github App Samples.

1. Your Workspace¶

Installation¶

Before you can start you need to setup your computer with all the development tools required to make Applications.

The list of software required for development and testing is;

There is detailed step-by-step documentation available on how to install all the software and tools required for each OS type.

• Windows
• MacOS
• Ubuntu

Login¶

Once everything is installed, then you need to login to your Kelvin Platform from the terminal.

The Kelvin SDK will then attempt to log you into two systems;

• Kelvin Platform
• Kelvin Docker Registry

1

sudo usermod -aG docker $USER

1

sudo dseditgroup -o edit -a $USER -t user docker

Using Username and Password¶

1

kelvin auth login <kelvin-platform-url>

You will be asked for your login, password and 2fa code.

When you are logged in you will see the following;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

$ kelvin auth login
[kelvin.sdk][2025-03-17 12:09:12][I] Refreshing metadata..
Platform: <KELVIN-PLATFORM-URL>
Enter your username: <USERNAME>
Enter your password: <PASSWORD>
Enter 2 Factor Authentication (2FA) one-time password (blank if not required): <2FA>
[kelvin.sdk][2025-03-17 12:09:53][I] Attempting to log on "<KELVIN-PLATFORM-URL>"
[kelvin.sdk][2025-03-17 12:09:57][R] Successfully logged on "<KELVIN-PLATFORM-URL>" as "<USERNAME>"
[kelvin.sdk][2025-03-17 12:09:58][I] Attempting to log on "<KELVIN-PLATFORM-URL>" Docker registry
Login Succeeded

Using SSO via Browser¶

If your organization uses Single Sign-On (SSO), you can login through your browser instead of entering credentials in the terminal.

1

kelvin auth login --browser <kelvin-platform-url>

This will open your default browser where you can authenticate using your organization's SSO provider. Once authentication is complete, the CLI will automatically receive the login session.

When you are logged in you will see the following;

1
2
3
4
5

$ kelvin auth login
[kelvin.sdk][2025-03-17 12:09:12][I] Refreshing metadata..
[kelvin.sdk][2026-03-10 19:18:53][I] Waiting for authentication...
Opening in existing browser session.
[kelvin.sdk][2026-03-10 19:18:57][R] Login successful.

With your workspace setup, now we can start with creating your first Application.

2. Create Application¶

On this page you will learn how to create and configure an Application.

Video Guide¶

Watch this quick start guide performed in real time in less than 8 minutes.

Written Guide¶

Create Folder¶

Type the following command to create an Application:

1

kelvin app create doc-demo-event-detection

Kelvin SDK will create a new folder named after the project name and automatically create the required files and add a sample Python program for reference. You can now open the folder in your favorite IDE (like Visual Studio Code) and start to modify the files.

Below is a brief description of each file.

kelvin-python-sdk

Inputs and Outputs¶

The Application stands out for its seamless integration with streaming data. As a developer, you're given a simplified interface. Simply define:

• Inputs: The streaming data your app will consume.
• Outputs: The streaming data your app will produce.

Kelvin takes care of the rest, ensuring reliable communication, fault-tolerance, data serialization, and data integrity.

Data Types¶

When declaring your inputs and outputs you will need to define the data_type.

Check out our concepts page to understand what a data_type is and what options you have available.

Define Inputs¶

Inputs are specified within the app.yaml file. Each input requires:

• A unique name to identify the input. This will be used in the Python code to reference the input. It must contain only lowercase alphanumeric characters. The characters ., _ and - are allowed to separate words instead of a space BUT can not be at the beginning or end of the name.
• An expected data type, which can be: number, boolean, string or an object. All are self-explanatory except object

For this guide, the Event Detection Application is monitoring a motor's temperature.

Edit the app.yaml and add the following input:

1
2
3
4

data_streams:
  inputs:
    - data_type: number
      name: motor_temperature

Define Outputs¶

Outputs, similar to inputs, are defined in the app.yaml file. Each output needs:

• A unique name to identify the output. This will be used in the Python code to reference the output. It must contain only lowercase alphanumeric characters. The characters ., _ and - are allowed to separate words instead of a space BUT can not be at the beginning or end of the name.
• An expected data type, which can be: number, boolean, string.

Additionally, some outputs might initiate control changes. For instance, the Event Detection Application determines a need to modify a motor speed.

Edit the app.yaml and add the following output:

1
2
3
4

control_changes:
  outputs:
    - name: motor_speed_set_point
      data_type: number

App Parameters¶

Application App Parameters allow developers to create dynamic, updatable variables that Operations can edit in the Kelvin UI.

The value of each App Parameter is unique to each Asset in an Application, allowing Operations to set different values for each Asset individually.

Define App Parameters¶

Application App Parameters are defined in three sections in the app.yaml file;

• parameters defines the name and type of the App Parameter.
• ui_schemas is a link to a JSON file containing all the information about how to display App Parameters in the Kelvin UI.
• defaults / parameters define the default values assigned to each Asset when it is first created or when an Application update introduces a new App Parameter to existing Assets.

App Parameters and default values are also defined in the app.yaml file as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

ui_schemas:
  parameters: "ui_schemas/parameters.json"

parameters:
  - name: closed_loop
    data_type: boolean
  - name: speed_decrease_set_point
    data_type: number
  - name: temperature_max_threshold
    data_type: number

defaults:
  parameters:
    closed_loop: false
    speed_decrease_set_point: 1000
    temperature_max_threshold: 59

The actual schema on how App Parameters will look and act in the Kelvin UI is kept in a JSON file.

ui_schemas/parameters.json

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

{
    "type": "object",
    "properties": {
        "closed_loop": {
            "type": "boolean",
            "title": "Closed Loop"
        },
        "speed_decrease_set_point": {
            "type": "number",
            "title": "Speed Decrease SetPoint",
            "minimum": 1000,
            "maximum": 3000
        },
        "temperature_max_threshold": {
            "type": "number",
            "title": "Temperature Max Threshold",
            "minimum": 50,
            "maximum": 100
        }
    },
    "required": [
        "closed_loop",
        "speed_decrease_set_point",
        "temperature_max_threshold"
    ]
}

Which will be displayed on the Kelvin UI as:

Final app.yaml¶

Your final app.yaml file with Inputs, Outputs and App Parameters should look like:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

spec_version: 5.0.0
type: app

name: event-detection
title: Event Detection
description: Monitors if a motor is overheating. If so, it will send a Control Change/Recommendation to reduce the Motor Speed.
version: 1.0.0
category: smartapp

flags:
  enable_runtime_update:

    # enables configuration updates in runtime
    configuration: false

    # enables deployment of more assets in runtime
    resources: false # default false

    # enables app parameters updates in runtime
    parameters: true # default true

    # enables asset properties updates in runtime
    resource_properties: true # default true

data_streams:
  inputs:
    - name: motor_temperature
      data_type: number

control_changes:
  outputs:
    - name: motor_speed_set_point
      data_type: number

parameters:
  - name: closed_loop
    data_type: boolean
  - name: speed_decrease_set_point
    data_type: number
  - name: temperature_max_threshold
    data_type: number

ui_schemas:
  configuration: "ui_schemas/configuration.json"
  parameters: "ui_schemas/parameters.json"

defaults:
  parameters:
    closed_loop: false
    speed_decrease_set_point: 1000
    temperature_max_threshold: 59

Next, we'll proceed to the Python code.

Python Code¶

The main.py file defines the code that will be executed by the Application. In the case of the Event Detection Application we want the code to be like this:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

from datetime import timedelta

from kelvin.application import KelvinApp
from kelvin.message import ControlChange, Recommendation
from kelvin.krn import KRNAssetDataStream, KRNAsset

app = KelvinApp()

# Wait for Data Stream Messages
@app.stream(inputs=["motor_temperature"])
async def handle_specific_inputs(msg) -> None:

    asset = msg.resource.asset
    value = msg.payload

    print(f"\nReceived Motor Temperature | Asset: {asset} | Value: {value}")

    # Check if the Temperature is above the Max Threshold
    if value > app.assets[asset].parameters["temperature_max_threshold"]:

        # Build Control Change Object
        control_change = ControlChange(
            resource=KRNAssetDataStream(asset, "motor_speed_set_point"),
            payload=app.assets[asset].parameters["speed_decrease_set_point"],
            expiration_date=timedelta(minutes=10)
        )

        if app.assets[asset].parameters["closed_loop"]:
            # Publish Control Change
            await app.publish(control_change)

            print(f"\nPublished Motor Speed SetPoint Control Change: {control_change.payload}")
        else:
            # Build and Publish Recommendation
            await app.publish(
                Recommendation(
                    resource=KRNAsset(asset),
                    type="decrease_speed",
                    control_changes=[control_change]
                )
            )

            print(f"\nPublished Motor Speed SetPoint (Control Change) Recommendation: {control_change.payload}") 


app.run()

Code Explanation¶

This script establishes a connection to the Kelvin system and uses a stream decorator to listen for motor_temperature messages. The script continuously monitors incoming motor temperature data and reacts according to predefined parameters.

1. Temperature Monitoring: The script listens for new incoming motor temperature messages which triggers running the handle_specific_inputs function.

2. Threshold Check: Upon receiving a temperature message, the script compares the temperature value (payload) to a predefined threshold, specified by the temperature_max_threshold App Parameter.

3. Control Action: If the received temperature exceeds the temperature_max_threshold, the script triggers an action based on the closed_loop parameter:

   • closed_loop=True: The script sends a direct Control Change command to the Kelvin system to adjust the motor speed to the value specified by speed_decrease_set_point.

   • closed_loop=False: The script sends a Recommendation to adjust the motor speed to the speed_decrease_set_point value, without making the change directly. This Recommendation will be shown on the Kelvin UI for users to accept or reject.

4. Continuous Operation: The stream decorator will continue to monitor for new incoming messages while the app.run() will keep your Application running indefinitely.

Once you have successfully created your first Application, it's crucial to test it locally to ensure it works as expected. Local testing allows you to catch and fix issues early, improving the quality and reliability of your app.

Let's now move on to testing this Application.

3. Test Application¶

In the Kelvin SDK there is a test tool to help you ingest data to the inputs and debug the outputs to test the performance of your Application. Some of the features include:

• Ingest Simulated Data: Inject random values at a specified interval to the app inputs using the command kelvin app test simulator
• Ingest CSV file: Read a CSV file and send the data to the app inputs using the command kelvin app test csv
• Verify outputs: Verify the outputs of the app like control changes and recommendations

Testing with historical CSV file¶

The Kelvin SDK test csv tool is designed to allow testers to ingest messages from a CSV file for testing purposes.

CSV Tool Overview¶

The test csv tool supports a variety of options to customize its behavior. Below is a list of the available options:

CSV File Structure¶

To structure the CSV file for your application, please follow the rules outlined below:

1. Timestamp Column:

   • The first column should be labeled as timestamp.
   • The timestamp should follow one of the supported formats by the Arrow library. Examples of accepted formats include:
     • YYYY-MM-DD HH:mm:ss
     • YYYY/M/D HH:mm
     • YYYYDDDD HH:mm
     • Other Arrow-compatible formats

2. Asset Column:

   Note

   If you use the --asset-count option, then this asset column and external asset CSV file will be ignored.

   • Optionally include an asset column to link it to a list of assets and their properties stored in another CSV file, as specified by the --asset option.
   • During testing, the asset name in the CSV column will be matched with the asset name in the external asset CSV file, injecting all associated asset properties.

   The asset CSV file contains the asset name and associated properties.

   The first column (Name ID) must contain the asset names, and any subsequent columns should define property names and their corresponding values, with each column representing one property.

   Example of an asset CSV file with asset names and the properties diameter and type:

   Testing Data CSV File Example
   1 2 3 4	Name ID,diameter,type asset1,47,plunger asset2,23.1,motor (...)

3. Input Columns:

   Note

   If you do not use the --asset option mentioned above then you can define the number of assets to test using the --asset-count option.

   • Include additional columns for each input defined in your app.yaml file. These columns represent the various data stream inputs your application receives.
   • Example input columns might include:
     • motor_temperature
     • pressure
     • gas_flow

4. Optional App Parameters:

   • If you have optional app parameters defined in your app.yaml file, include them as additional columns. These parameters can be useful for evaluating different operational behaviors.
   • Example optional parameter columns might include:
     • temperature_max_threshold
     • speed_decrease_set_point
     • closed_loop

Download CSV Test File¶

Now that you're familiar with the basics of the test csv tool, it's time to put the Event Detection Application to the test using a CSV file.

Download the CSV file from the link below and save it to your local machine:

Download test.csv

The CSV file you downloaded contains the following data:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

timestamp,motor_temperature
2023-10-27 10:00:01.0,50
2023-10-27 10:00:02.0,51
2023-10-27 10:00:03.0,52
2023-10-27 10:00:04.0,53
2023-10-27 10:00:05.0,54
2023-10-27 10:00:06.0,55
2023-10-27 10:00:07.0,56
2023-10-27 10:00:08.0,57
2023-10-27 10:00:09.0,58
2023-10-27 10:00:10.0,59
2023-10-27 10:00:11.0,60

You can view the guide in our video tutorial or read our step by step written guide.

After successfully testing your Application, we can now move onto packaging and uploading it to your Kelvin Cloud instance.

4. Upload Application¶

Now it is time to build your image and upload it to the Kelvin Cloud instance.

The App Registry is a centralized repository that stores all the Applications you create. Once uploaded, you can deploy your Application to any Kelvin Edge cluster connected to your Kelvin Cloud instance.

Let's start by making sure your Application is ready for upload.

Prerequisites¶

The main section in the app.yaml file defines crucial attributes such as the unique name, display name, description, and version of your app. Below is an example of what your app.yaml file might look like:

1
2
3
4

name: event-detection
title: Event Detection
description: Monitors if a motor is overheating. If so, it will send a Control Change to reduce the Motor Speed.
version: 1.0.0

SDK Login¶

Before uploading your app, you need to login the SDK with your Kelvin Cloud credentials.

Open a terminal and run the following command:

1

kelvin auth login <url.kelvin.ai>

And type in your Kelvin Cloud credentials when prompted.

Build (optional)¶

Before uploading, you have the option to build your application to verify that all components compile successfully.

Open a terminal in the directory where your app and its associated files are located, and run the following command:

1

kelvin app build

Upload¶

Uploading your app is straightforward and requires just a single command. Open a terminal in the directory where your app and its associated files are located, and run the following command:

1

kelvin app upload

As the command runs, you will observe the app being packaged and subsequently uploaded to the App Registry. Here's a sample output:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

[kelvin.sdk][2025-10-03 20:53:51][R] Image successfully built: "event-detection:1.0.0"
[kelvin.sdk][2025-10-03 20:53:51][I] Pushing application content to "https://<url.kelvin.ai>"
       [elapsed: 00:19] - [Layer: 2e1bc7550524] - [Pushed]
       [elapsed: 00:19] - [Layer: f15701d79da8] - [Layer already exists]
[kelvin.sdk][2025-10-03 20:54:10][R] Application "event-detection:1.0.0" successfully pushed to registry "https://<url.kelvin.ai>"
[kelvin.sdk][2025-10-03 20:54:10][R]

            Application successfully uploaded:
                Name: event-detection
                Version: 1.0.0

The next step is to configure your Kelvin Cloud instance to simulate a real-world edge deployment.

5. Configure Application¶

In this section, you will learn how to configure your Kelvin Cloud instance. We will configure the environment to simulate a real-world scenario. Here is a high-level overview of the steps involved:

• Importing Assets: An Asset in Kelvin denotes a digital representation of a physical or virtual equipment. Each asset is characterized by a set of properties that detail its attributes and by datastreams, which are channels of continuous or time-stamped data related to the asset's operation or state

• Importing Data Streams: Data streams are the primary source of data for Applications. They represent the real-time data generated by assets and are used as inputs to the Application to generate actionable recommendations and control system adjustments.

• CSV Connection: A connection in Kelvin is a data source that provides a data stream feed to Applications. In this guide, we will create a CSV connection that will continuously replay a CSV timeseries file.

Video Guide¶

Watch this quick start guide performed in real time in less than 6 minutes.

Written Guide¶

Import Assets¶

In this brief demo you can see how to do this;

Open your browser and navigate to https://<instance>.kelvin.ai. Login with your credentials and you will be presented with the Kelvin UI.

Click on the Asset Management section on the left navigation menu

And then click on the Import Assets button on the top right of the page.

In the popup, you will have the option to download the sample template that gives you the structure you need to follow. Go ahead and click on the Download Template button and save the file.

Modify the template with the following data (or just download our ready made CSV file):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

Display Name,Name ID,Asset Type Name ID,Field,Manufacturer
Motor #01,motor_01,motor,Eagle Ford,Siemens
Motor #02,motor_02,motor,Permian,ABB
Motor #03,motor_03,motor,Williston,Schneider
Motor #04,motor_04,motor,Williston,Siemens
Motor #05,motor_05,motor,Williston,ABB

...

Motor #30,motor_30,motor,Eagle Ford,Schneider

A brief explanation of the columns in the CSV file:

• Display Name: The name of the asset as it will appear in the Kelvin UI.
• Name ID: A unique identifier for the asset.
• Asset Type Name ID: The type of asset (e.g., motor, pump, compressor).
• Field: This is an optional Asset Property with metadata where the asset is located.
• Manufacturer: This is an optional Asset Property with metadata about the manufacturer of the asset.

You can add as many additional Asset Properties as needed, like Location, PLC Type, Well Depth, Motor Configuration, etc.

Next, let's import the assets into your Kelvin Cloud instance.

Upload the previously downloaded assets.csv file and click Next.

The contents of the file will be validated to make sure there are no errors. If there are any errors, you will be prompted to correct them before proceeding. Next, click on the Import button.

You will then see the assets you imported in the Asset Management section.

Import Data Streams¶

In this brief demo you can see how to do this;

Go to the Kelvin UI. Click on the Data Streams section on the left navigation menu and then click on the Import Data Streams button on the top right of the page.

In the popup, you will have the option to download the sample template that gives you the structure you need to follow. Go ahead and click on the Download Template button and save the file.

Modify the template with the following data (or just download our ready made CSV file):

1
2
3

Display Name,Name ID,Type,Data Type ID,Unit Name ID,Semantic Type ID
Motor Speed SP,motor_speed_set_point,measurement,number,revolution_per_minute,angular_velocity
Motor Temperature,motor_temperature,measurement,number,degree_celsius,temperature

A brief explanation of the columns in the CSV file:

Next, let's import the data streams into your Kelvin Cloud instance.

Upload the previously downloaded datastreams.csv file and click Next.

The contents of the file will be validated to make sure there are no errors. If there are any errors, you will be prompted to correct them before proceeding. Next, click on the Import button.

You should see the data streams you imported in the Data Streams section.

Create a CSV Connection¶

Go to the Kelvin UI. Click on the Connections section on the left navigation menu

And then click on the Create Connection button on the top right of the page.

Step 1

Select Import Data and Control Setpoints and click Next.

Step 2

Select the Kelvin CSV Publisher Connector option, select a Version and click Next.

Step 3

Drag and drop or select your file to upload.

Modify the template with the following data (or just download our ready made CSV file):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

timestamp,motor_temperature,motor_speed_set_point
2024-05-20 20:19:30,50.57,1615
2024-05-20 20:19:35,73.48,
2024-05-20 20:19:40,59.28,
2024-05-20 20:19:45,64.45,
2024-05-20 20:19:50,75.59,
2024-05-20 20:19:55,67.27,

...

2024-05-21 10:12:40,72.48,
2024-05-21 10:12:45,57.3,

A brief explanation of the columns in the CSV file:

• timestamp: The timestamp of the data point. There are a number of different formats that are accepted.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

"YYYY-MM-DD",
"YYYY-MM-DD HH:mm",
"YYYY-MM-DD HH:mm:ss",
"YYYY/MM/DD",
"YYYY/MM/DD HH:mm",
"YYYY/MM/DD HH:mm:ss",
"YYYY.MM.DD",
"YYYY.MM.DD HH:mm",
"YYYY.MM.DD HH:mm:ss",
"YYYYMMDD",
"YYYYMMDD HH:mm",
"YYYYMMDD HH:mm:ss",
"YYYY-MM-DDTHH:mm:ss",
"YYYY-MM-DDTHH:mm:ss.SSS",
"YYYY-MM-DDTHH:mm:ssZ",
"YYYY-MM-DDTHH:mm:ss±HH:mm",

• motor_temperature: The motor temperature data stream.
• motor_speed_set_point: The motor speed set point data stream. We start with an initial value and leave the rest of the values empty, which means the set point will remain constant. This set point will be changed by our Event Detection Application.

When you have selected the file, it will be validated before the Next button is activated.

Once validated you can click Next.

Step 4

Select the Asset where the data will be sent to.

When ready click Next.

Step 5

In Step 5 you have a range of options available.

Make sure all the options have a green check mark next to it.

For this example we will only highlight some key areas to be aware;

Information

Type in a memorable name in the Display Name text input. You can use any letters, numbers and special characters.

Configuration

Configure the CSV Publisher connection to be CSV Playback and Replay File as Yes.

IO Mapping

For each Data Stream column name in the uploaded file, select the Data Stream on the Kelvin Platform where the data in the rows will be sent.

Cluster

Then select which Cluster to deploy the new Connector to.

Optionally you can also select the Node in the Cluster. If you do not then the system will automatically assign the Node.

Click on the Create button to deploy the connection.

Wait a few seconds for the connection to be deployed and you should see the connection status change to Running.

Then if you are interested, proceed to click on the connection name to see the connection details. This will show you the data stream feed and when the data stream values were last updated.

The next step is to deploy your Application to the assets.

6. Deploy Application¶

Now that you have your first Application uploaded, you can deploy it to the assets that you previously created in your Kelvin Cloud instance.

Video Guide¶

Watch this quick start guide performed in real time in less than 2 minutes.

Written Guide¶

Open your browser and navigate to https://<instance>.kelvin.ai. Login with your credentials and you will be presented with the Kelvin UI.

Go to Applications and select the Event Detection app you just uploaded.

The next step is to deploy the app to assets. Click on the Workloads tab an then on the Deploy Workload button.

Choose the app latest version and then click the Next button.

Select the assets you want to deploy to the app. In this case we will select the assets with the name Beam Pump #02 and Beam Pump #03 and then click the Next button.

In step three there are a number of settings available. We will only focus on two of the areas;

Cluster

Select the cluster to deploy the workload assets to.

IO Mapping

Now we'll map the asset data streams to the Application inputs and outputs. This entails channeling the live data from the assets directly into the application.

Kelvin will oversee the data routing to the Application; your role is to ensure the correct data stream is selected to feed into the Application inputs.

For the Event Detection Application, we have a singular input named motor_temperature. Thus, we'll be selecting the Temperature data stream from the asset.

Like the input, the output should already be automatically selected to the closest type of Data Stream name available. Normally this should be ok.

And the final step is to click on the Deploy button to deploy the app to the assets.

You can observe the workload being deployed to the assets. And in a couple of seconds the app will be running for the assets.

Now that you have your first Application deployed to your assets, you can visualize the recommendations, control changes and monitor the logs and telemetry of your app.

7. Monitor Application¶

Now that your Application has been successfully deployed, it's time to see it in action. We'll guide you through how to visualize the recommendations and data, as well as provide troubleshooting with logs and telemetry of your Application.

Visualize Application Recommendations¶

To visualize the recommendations made by your Application, go the the Application details.

And click on the Assets tab.

The Last Recommendation column shows you the latest Recommendation for each Asset:

You can see the recommendation in the Asset list.

There is also a View More button to the right of the recommendation which you can see the details of the recommendation.

Visualize Application Inputs and Outputs¶

Another important aspect of seeing your app in action is to visualize the data that your Application is processing.

For that task, you can use the Data Explorer, a powerful tool that allows you to plot timeseries data and also visualize the control changes published by your Application.

To do this, go to the Assets tab

And click on Data Explorer button at the top or a Data Explorer Icon on the Asset row you want to visualize the data.

This will open Data Explorer with the asset automatically selected.

To understand more about the Data Explorer page

Troubleshoot: Visualize Application Logs¶

Application logs are automatically uploaded to the Kelvin Cloud.

To see the app logs, click on the Workload tab and then on the wanted workload name.

The Logs tab is automatically selected and will show you the logs.

Troubleshoot: Visualize Application Telemetry¶

Another aspect of monitoring your Application is to monitor telemetry data.

Applications automatically upload information related to CPU, Memory and Network usage. These metrics can be used to assess the performance of your app and to debug any issues.

To see the app logs, click on the Workload tab and then on the wanted workload name.

Then click on the Telemetry tab which will show you the telemetry for the workload.

All done!¶

Congratulations! You've successfully created, uploaded and deployed your first Application. You are now ready to start exploring other topics within Kelvin.

8. Quick Start Quiz¶

Test Your Knowledge¶

How Did You Do?¶