### Start Proxus Platform with Docker Compose

Source: https://proxus.io/docs/getting-started/installation/on-premise-deployment-with-docker

This command initiates the Proxus platform by starting all defined services in detached mode. It requires Docker and Docker Compose to be installed. Administrative privileges might be necessary.

```bash
docker-compose -p "proxus" up -d
```

--------------------------------

### Manual Proxus IIoT Setup for Linux/macOS (wget)

Source: https://proxus.io/docs/getting-started/installation/on-premise-deployment-with-docker

Manually downloads the docker-compose.yml file and configuration files into a 'Configs' directory using wget. Requires wget to be installed.

```bash
BASE_URL="https://raw.githubusercontent.com/proxusiiotplatform/docs/main/"
CONFIGS_DIR="Configs"

# Download Compose File
wget -O docker-compose.yml "${BASE_URL}docker-compose.yml"

# Create Config Directory
mkdir -p "${CONFIGS_DIR}"

# Download Config Files
for file in dashboard.yml datasource.yml dotnet-otel-dashboard.json \
jaeger-ui.json logs-dashboard.json loki.yml \
otel-collector-config.yml prometheus.yml grafana.ini \
accounts.conf hub.conf; do
wget -O "${CONFIGS_DIR}/${file}" "${BASE_URL}Configs/${file}"
done
```

--------------------------------

### Example MQTT Topics for UNS

Source: https://proxus.io/docs/core-concepts/unified-namespace

Provides concrete examples of MQTT topics following the defined UNS structure. These examples illustrate how real-time metric values (telemetry) and device status (state) are published for a specific sensor within a hierarchical context.

```text
v1/acme/newyork/assembly/line01/robot_a/temp_sensor_01/telemetry/temperature
v1/acme/newyork/assembly/line01/robot_a/temp_sensor_01/state/_status
```

--------------------------------

### Configure IBM DB2 Connection - Example

Source: https://proxus.io/docs/integrations/outbound-connectors/databases/db2

Provides an example configuration for connecting to an IBM DB2 database. This includes server address, port, database name, username, and password.

```text
Server=192.168.1.100
Port=50000
Database=PROXUS
User=db2admin
Password=*****
```

--------------------------------

### Manual Proxus IIoT Setup for Linux/macOS (curl)

Source: https://proxus.io/docs/getting-started/installation/on-premise-deployment-with-docker

Manually downloads the docker-compose.yml file and configuration files into a 'Configs' directory using curl. Requires curl to be installed.

```bash
CONFIGS_DIR="Configs"
BASE_URL="https://raw.githubusercontent.com/proxusiiotplatform/docs/main/"

# Download Compose File
curl -LO "${BASE_URL}docker-compose.yml"

# Create Config Directory
mkdir -p "${CONFIGS_DIR}"

# Download All Configs
curl -L "${BASE_URL}Configs/{dashboard.yml,datasource.yml,dotnet-otel-dashboard.json,jaeger-ui.json,logs-dashboard.json,loki.yml,otel-collector-config.yml,prometheus.yml,grafana.ini,accounts.conf,hub.conf}" -o "${CONFIGS_DIR}/#1"
```

--------------------------------

### Firebird Database Configuration Example

Source: https://proxus.io/docs/integrations/outbound-connectors/databases/firebird

An example configuration for connecting Proxus IO to a Firebird database. This includes server address, database path, username, and password.

```ini
Server=192.168.1.100
Database=/var/firebird/proxus.fdb
User=SYSDBA
Password=*****
```

--------------------------------

### Agent Configuration Examples

Source: https://proxus.io/docs/developer-api/mcp-server

Configuration examples for integrating Proxus MCP server with various AI agents.

```APIDOC
## Agent Configuration

### OpenAI Codex CLI

Add to `~/.codex/config.toml`:

```toml
[mcp_servers.proxus]
url = "http://localhost:8080/mcp"
```

**Usage in Codex:**

```
› connect to proxus mcp server
› Admin password empty

• Called proxus.auth_login({"userName":"Admin","password":""})
• Connected. Token valid for 25 minutes.

› analyze telemetry data for the last 24 hours

• Called proxus.telemetry_devices({"hours":24})
• Called proxus.telemetry_stats({"hours":24})
```

### Gemini CLI

Add to `~/.gemini/settings.json`:

```json
{
  "mcpServers": {
    "proxus": {
      "httpUrl": "http://localhost:8080/mcp"
    }
  }
}
```

**Usage in Gemini:**

```
gemini "analyze recent telemetry data"
```

The Gemini CLI uses `~/.gemini/settings.json` for configuration. After adding the server, it will be available for all Gemini-powered tools.

### Claude Desktop

Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):

```json
{
  "mcpServers": {
    "proxus": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "http://your-proxus-server:8080/mcp", "--transport", "sse-only"]
    }
  }
}
```

### Cursor IDE

Add to `.cursor/mcp.json` in your project:

```json
{
  "mcpServers": {
    "proxus": {
      "url": "http://localhost:8080/mcp"
    }
  }
}
```
```

--------------------------------

### Authenticate and Get Devices using cURL

Source: https://proxus.io/docs/developer-api/rest-api

This section provides cURL examples for both obtaining a JWT token and then using that token to retrieve a list of devices from the API. It illustrates a common two-step process for accessing platform resources.

```bash
# Get JWT token
curl -X POST https://<your-server-url>/api/Authentication/Authenticate \
  -H "Content-Type: application/json" \
  -d '{"userName": "<username>", "password": "<password>"}'
```

```bash
# Get Devices
curl -X GET https://<your-server-url>/api/odata/Device \
  -H "Authorization: Bearer <jwt_token>"
```

--------------------------------

### Custom Python Agent Example

Source: https://proxus.io/docs/developer-api/mcp-server

Example of how to use the Proxus IO client library in Python to interact with the API.

```APIDOC
## Custom Python Agent

### Description
An example Python script demonstrating how to use the `mcp` client library to connect to the Proxus IO API, authenticate, and retrieve device telemetry.

### Method
N/A (Python Script)

### Endpoint
N/A (Python Script)

### Parameters
N/A (Python Script)

### Request Example
```python
from mcp import ClientSession
from mcp.client.http import HttpClient

async def query_proxus():
    async with HttpClient("http://localhost:8080/mcp") as client:
        session = ClientSession(client)
        await session.initialize()
        
        # Login
        result = await session.call_tool("auth_login", {
            "userName": "Admin",
            "password": ""
        })
        
        # Get device telemetry
        devices = await session.call_tool("telemetry_devices", {
            "hours": 24
        })
        
        print(devices)
```

### Response
N/A (Python Script)
```

--------------------------------

### Fatek PLC Communication Setup

Source: https://proxus.io/docs/connecting-data/protocols/other/fatek

This section outlines the supported protocols, connection parameters, and address syntax for communicating with Fatek PLCs via Proxus.

```APIDOC
## Connect Fatek PLC

Proxus communicates with Fatek PLCs using the native Fatek ASCII protocol (over TCP).

### Supported Protocols

| Protocol Type             | Series      | Connection        | Port |
| ------------------------- | ----------- | ----------------- | ---- |
| `FATEK_Program_OverTcp` | FBs, B1, B1z | Ethernet / Serial | `500` |

### Connection Parameters

| Parameter        | Type   | Required | Default | Description              |
| ---------------- | ------ | -------- | ------- | ------------------------ |
| **Host**         | string | Yes      | -       | PLC IP Address           |
| **Port**         | int    | No       | `500`   | Default Port             |
| **Station**      | byte   | No       | `1`     | Station Number           |
| **ConnectTimeout** | int    | No       | `3000`  | Connection timeout (ms) |

### Address Syntax

Fatek addressing is straightforward and matches the ladder logic references.

| Area           | Prefix | Description   | Example |
| -------------- | ------ | ------------- | ------- |
| **Register**   | `R`    | 16-bit Word   | `R0`, `R100` |
| **Data Register**| `D`    | 32-bit Word   | `D0`, `D100` |
| **Internal Relay**| `M`    | Bit           | `M0`, `M100` |
| **Input**      | `X`    | Input Bit     | `X0`, `X10` |
| **Output**     | `Y`    | Output Bit    | `Y0`, `Y10` |
| **Timer**      | `T`    | Timer         | `T0`    |
| **Counter**    | `C`    | Counter       | `C0`    |
```

--------------------------------

### Manual Proxus IIoT Setup for Windows (PowerShell)

Source: https://proxus.io/docs/getting-started/installation/on-premise-deployment-with-docker

Manually downloads the docker-compose.yml file and configuration files into a 'Configs' directory using PowerShell. Requires Invoke-WebRequest.

```powershell
$b = "https://raw.githubusercontent.com/proxusiiotplatform/docs/main/"
$c = "Configs"

Invoke-WebRequest "${b}docker-compose.yml" -OutFile "docker-compose.yml"
New-Item -ItemType Directory -Force -Path $c

"dashboard.yml datasource.yml dotnet-otel-dashboard.json jaeger-ui.json logs-dashboard.json loki.yml otel-collector-config.yml prometheus.yml grafana.ini accounts.conf hub.conf".Split() | ForEach-Object {
    Invoke-WebRequest "${b}Configs/$_" -OutFile "${c}/$_"
}
```

--------------------------------

### Initialize Request

Source: https://proxus.io/docs/developer-api/mcp-server

Example of an initialize request payload for establishing a connection with the API.

```APIDOC
## Initialize Request

### Description
An example JSON-RPC request payload used to initialize a client session with the MCP API.

### Method
POST

### Endpoint
`http://your-server:8080/mcp`

### Request Body
- **jsonrpc** (string) - Required - Specifies the JSON-RPC version, should be `"2.0"`.
- **id** (integer) - Required - A unique identifier for the request.
- **method** (string) - Required - The method to call, should be `"initialize"`.
- **params** (object) - Required - Parameters for the initialize method.
  - **protocolVersion** (string) - Required - The protocol version string.
  - **clientInfo** (object) - Optional - Information about the client.
    - **name** (string) - Required - The name of the client application.
    - **version** (string) - Required - The version of the client application.
  - **capabilities** (object) - Optional - Client capabilities.

### Request Example
```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "initialize",
  "params": {
    "protocolVersion": "2024-11-05",
    "clientInfo": {"name": "my-agent", "version": "1.0"},
    "capabilities": {}
  }
}
```

### Response
#### Success Response (200)
- **jsonrpc** (string) - The JSON-RPC version.
- **id** (integer) - The request ID.
- **result** (object) - The result of the initialization.

#### Response Example
```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {}
}
```
```

--------------------------------

### Configure HTTPS with PFX Certificate - TOML

Source: https://proxus.io/docs/administration/tls-certificates

Example TOML configuration for setting up HTTPS ports and specifying a PFX certificate file and its password for the Proxus Platform.

```toml
[Service]
UI-HTTPS-Port = "8443"
WEBApi-HTTPS-Port = "8445"
Server-HTTPS-Port = "8447"
SSL-Certificate-Name = "example.pfx"
SSL-Certificate-Password = "change-me"
```

--------------------------------

### Configure MySQL Connection - Proxus IO

Source: https://proxus.io/docs/integrations/outbound-connectors/databases/mysql

Example configuration for connecting Proxus IO to a MySQL database. This includes server address, port, database name, username, and password.

```plaintext
Server=192.168.1.100
Port=3306
Database=proxus
User=proxus
Password=*****
```

--------------------------------

### Automated Proxus IIoT Installation Script

Source: https://proxus.io/docs/getting-started/installation/on-premise-deployment-with-docker

This script automatically downloads necessary files and sets up the directory structure for Proxus IIoT. It is designed for Linux and macOS environments and requires curl.

```bash
curl -fsSL https://proxus.io/install.sh | bash
```

--------------------------------

### C# MQTT Bridge Implementation for AWS IoT

Source: https://proxus.io/docs/developer-api/sdk-reference/example-mqtt-bridge

This C# code snippet demonstrates how to implement an MQTT bridge using the Proxus SDK to connect to AWS IoT. It shows how to override configuration properties, subscribe to internal data, listen for cloud commands, and handle message publishing and receiving.

```csharp
using MQTTnet;
using Proxus.SDK.BaseFunctions;
using Proxus.Common.Messages;
using Proxus.Common;

namespace MyProject.Functions
{
    public class AwsBridge : FunctionBase
    {
        // 1. Override Configuration Properties
        protected override string MqttBrokerHost => "a3xyz-ats.iot.us-east-1.amazonaws.com";
        protected override int MqttBrokerPort => 8883;
        protected override string MqttBrokerUser => null; // Using Certs in prod

        public AwsBridge(object sys, object log, object config) : base(sys, log, config) { }

        protected override void OnStarted()
        {
            // 2. Subscribe to Internal Data
            Subscriptions?.Add(new SubscriptionContext {
                Type = typeof(TransportData),
                Topics = (HashSet<string>) ["Gen_01"]
            });

            // 3. Listen to Cloud Commands
            SubscribeToMqttTopic("cmd/reset");

            base.OnStarted();
        }

        // Internal -> External
        protected override void OnMessageReceive(FunctionContext ctx)
        {
            if (ctx.Message is TransportData data)
            {
                var temp = data.GetPayloadValueByName<double>("Temperature");
                string json = $"{{"device": "{data.Topic}", "val": {temp}}}";
                
                PublishMqttMessage("dt/telemetry", json);
            }
        }

        // External -> Internal
        protected override void HandleMqttMessage(MqttApplicationMessage message)
        {
            string cmd = message.ConvertPayloadToString();
            LogInformation($"Cloud Command Received: {cmd}");

            if (cmd == "RESET_COUNTER")
            {
                // Logic to reset local state or write to PLC
            }
        }
    }
}
```

--------------------------------

### Get Telemetry Table Schema

Source: https://proxus.io/docs/developer-api/mcp-server

Provides the schema definition for the ClickHouse DeviceRawData table, including column types and descriptions, along with example queries.

```python
schema_telemetry()
```

--------------------------------

### FunctionBase OnStarted Initialization (C#)

Source: https://proxus.io/docs/developer-api/sdk-reference

Demonstrates the `OnStarted` method in C# for initializing subscriptions, configuring cache, and scheduling background tasks within the Proxus SDK. It's crucial to call `base.OnStarted()` to ensure internal setup is completed.

```csharp
protected override void OnStarted() {
    // 1. Define Subscriptions
    Subscriptions?.Add(new SubscriptionContext {
        Type = typeof(TransportData),
        Topics = (HashSet<string>) ["*"] // Listen to all local devices
    });

    // 2. Configure Cache (Optional)
    EnableCacheWithExpirationTime = TimeSpan.FromSeconds(10);

    // 3. Schedule Background Tasks
    ExecuteScheduledTask(TimeSpan.FromSeconds(5), MyPeriodicTask);

    base.OnStarted(); // Important: Triggers the internal setup
}
```

--------------------------------

### Manual Proxus IIoT Setup for Windows (Command Prompt)

Source: https://proxus.io/docs/getting-started/installation/on-premise-deployment-with-docker

Manually downloads the docker-compose.yml file and configuration files into a 'Configs' directory using curl in the Windows Command Prompt. Requires curl.

```batch
@echo off
SET BASE_URL=https://raw.githubusercontent.com/proxusiiotplatform/docs/main/
SET CONFIGS_DIR=Configs

curl -sS -LO %BASE_URL%docker-compose.yml
IF NOT EXIST "%CONFIGS_DIR%" mkdir "%CONFIGS_DIR%"

curl -sS -L %BASE_URL%Configs/dashboard.yml -o %CONFIGS_DIR%/dashboard.yml
curl -sS -L %BASE_URL%Configs/datasource.yml -o %CONFIGS_DIR%/datasource.yml
curl -sS -L %BASE_URL%Configs/dotnet-otel-dashboard.json -o %CONFIGS_DIR%/dotnet-otel-dashboard.json
curl -sS -L %BASE_URL%Configs/jaeger-ui.json -o %CONFIGS_DIR%/jaeger-ui.json
curl -sS -L %BASE_URL%Configs/logs-dashboard.json -o %CONFIGS_DIR%/logs-dashboard.json
curl -sS -L %BASE_URL%Configs/loki.yml -o %CONFIGS_DIR%/loki.yml
curl -sS -L %BASE_URL%Configs/otel-collector-config.yml -o %CONFIGS_DIR%/otel-collector-config.yml
curl -sS -L %BASE_URL%Configs/prometheus.yml -o %CONFIGS_DIR%/prometheus.yml
curl -sS -L %BASE_URL%Configs/grafana.ini -o %CONFIGS_DIR%/grafana.ini
curl -sS -L %BASE_URL%Configs/accounts.conf -o %CONFIGS_DIR%/accounts.conf
curl -sS -L %BASE_URL%Configs/hub.conf -o %CONFIGS_DIR%/hub.conf
```

--------------------------------

### Anomaly Detection Pre-filter Example

Source: https://proxus.io/docs/automation-logic/rules-engine/expression-syntax

This example shows how to use criteria expressions as a pre-filter for the Anomaly Detection mode. Only data matching the specified payload key ('Vibration') will be fed into the statistical model.

```Rule Expression
[Payload][Key='Vibration']
```

--------------------------------

### Get Gateways with cURL

Source: https://proxus.io/docs/developer-api/rest-api

This snippet retrieves a list of all gateways from the ProXus.io API using cURL. It sends a GET request to the /api/odata/Gateway endpoint, including the JWT token in the Authorization header.  The response contains a JSON array of gateway objects.

```bash
curl -X GET https://<your-server-url>/api/odata/Gateway \
  -H "Authorization: Bearer <jwt_token>" \
  -H "Content-Type: application/json"
```

--------------------------------

### Wildcard MQTT Subscriptions for UNS

Source: https://proxus.io/docs/core-concepts/unified-namespace

Demonstrates how to use wildcard characters in MQTT subscriptions to efficiently subscribe to data within the UNS. These examples show how to retrieve all data from a specific site, all telemetry from a particular area across different lines, or all status updates from a specific line.

```text
v1/acme/newyork/#
v1/acme/+/assembly/+/+/+/telemetry/#
v1/acme/newyork/assembly/line01/+/+/state/_status
```

--------------------------------

### Get Devices with cURL

Source: https://proxus.io/docs/developer-api/rest-api

This snippet retrieves a list of all devices from the ProXus.io API using cURL. It sends a GET request to the /api/odata/Device endpoint, including the JWT token in the Authorization header.  The response contains a JSON array of device objects.

```bash
curl -X GET https://<your-server-url>/api/odata/Device \
  -H "Authorization: Bearer <jwt_token>" \
  -H "Content-Type: application/json"
```

--------------------------------

### Get Gateways with Python

Source: https://proxus.io/docs/developer-api/rest-api

This snippet retrieves a list of all gateways from the ProXus.io API using Python and the requests library. It sends a GET request to the /api/odata/Gateway endpoint, including the JWT token in the Authorization header. The response is parsed as JSON and contains an array of gateway objects.

```python
# List all gateways
gateways_url = "https://<your-server-url>/api/odata/Gateway"
gateways_response = requests.get(gateways_url, headers=headers)
gateways = gateways_response.json()
```

--------------------------------

### Get Devices with Python

Source: https://proxus.io/docs/developer-api/rest-api

This snippet retrieves a list of all devices from the ProXus.io API using Python and the requests library. It sends a GET request to the /api/odata/Device endpoint, including the JWT token in the Authorization header. The response is parsed as JSON and contains an array of device objects.

```python
# List all devices
devices_url = "https://<your-server-url>/api/odata/Device"
headers = {
    "Authorization": f"Bearer {token}",
    "Content-Type": "application/json"
}

devices_response = requests.get(devices_url, headers=headers)
devices = devices_response.json()
```

--------------------------------

### Modbus Address Conversion and Syntax

Source: https://proxus.io/docs/connecting-data/protocols/modbus-guide

Learn how to convert device datasheet addresses to Proxus format and understand the supported address syntax.

```APIDOC
## Converting Datasheet Addresses

### Common Datasheet Formats

| Datasheet Format | Meaning | Proxus Format |
|---|---|---|
| `40001` | Holding Register 1 | `x=3;0` |
| `40100` | Holding Register 100 | `x=3;99` |
| `30001` | Input Register 1 | `x=4;0` |
| `30100` | Input Register 100 | `x=4;99` |
| `00001` | Coil 1 | `x=1;0` |
| `10001` | Discrete Input 1 | `x=2;0` |
| `HR100` / `4x100` | Holding Register 100 | `x=3;99` |
| `IR50` / `3x50` | Input Register 50 | `x=4;49` |

**Note:** Most device datasheets use **1-based** addressing, but Modbus protocol uses **0-based** addressing. Always subtract 1 from datasheet addresses.

### Conversion Formula

`Proxus Address = Datasheet Address - Base - 1`

Where Base:
* 40001 series → Base = 40000 (Holding Registers, FC03)
* 30001 series → Base = 30000 (Input Registers, FC04)
* 10001 series → Base = 10000 (Discrete Inputs, FC02)
* 00001 series → Base = 0 (Coils, FC01)

### Address Syntax

#### Basic Format

`{address}`

Example: `100` reads register 100 using the default function code (03 for Holding Registers).

#### Extended Format

`s={station};x={function};{address}`

| Component | Description | Values |
|---|---|---|
| `s=` | Station/Slave ID | 1-255 |
| `x=` | Function Code | 1, 2, 3, 4 |
| `w=` | Write Function Code (optional) | 5, 6, 15, 16 |
| `{address}` | Register address | 0-65535 |

### Examples

| Address | Description |
|---|---|
| `100` | Register 100, default function code |
| `x=3;100` | Holding Register 100 (FC03) |
| `x=4;100` | Input Register 100 (FC04) |
| `s=2;100` | Register 100 on Slave ID 2 |
| `s=2;x=3;100` | Holding Register 100 on Slave ID 2 |
| `s=5;x=4;500` | Input Register 500 on Slave ID 5 |
```

--------------------------------

### Get Gateways with JavaScript

Source: https://proxus.io/docs/developer-api/rest-api

This snippet retrieves a list of all gateways from the ProXus.io API using JavaScript and the fetch API. It sends a GET request to the /api/odata/Gateway endpoint, including the JWT token in the Authorization header. The response is parsed as JSON and contains an array of gateway objects.

```javascript
// List all gateways
const gatewaysResponse = await fetch('https://<your-server-url>/api/odata/Gateway', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${token}`,
    'Content-Type': 'application/json'
  }
});

const gateways = await gatewaysResponse.json();
```

--------------------------------

### MQTT Client Operations in C#

Source: https://proxus.io/docs/edge-scripting/csharp-functions

Illustrates how to use the managed MQTT client to publish messages to an external broker and subscribe to external topics. Message reception is handled within the OnMessageReceive method.

```csharp
// Publish to an external broker
PublishMqttMessage("external/topic", "payload");

// Subscribe to external topic (handled in OnMessageReceive)
SubscribeToMqttTopic("external/command");
```

--------------------------------

### Get Devices with JavaScript

Source: https://proxus.io/docs/developer-api/rest-api

This snippet retrieves a list of all devices from the ProXus.io API using JavaScript and the fetch API. It sends a GET request to the /api/odata/Device endpoint, including the JWT token in the Authorization header. The response is parsed as JSON and contains an array of device objects.

```javascript
// List all devices
const devicesResponse = await fetch('https://<your-server-url>/api/odata/Device', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${token}`,
    'Content-Type': 'application/json'
  }
});

const devices = await devicesResponse.json();
```

--------------------------------

### Example SMS Notification Configuration

Source: https://proxus.io/docs/integrations/notifications/sms

This is an example configuration for sending SMS notifications using Twilio. It includes essential parameters like Account SID, Auth Token, sender ('From') and recipient ('To') phone numbers, and the message body. The 'Body' parameter supports dynamic content like timestamps.

```text
AccountSid = ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
AuthToken = ********
From = +15551234567
To = +15559876543
Body = ALERT: Pressure exceeded threshold at {timestamp}
```

--------------------------------

### OPC UA Node Addressing

Source: https://proxus.io/docs/connecting-data/protocols/opc-ua-guide

Information on how to address nodes in OPC UA, including supported formats, namespace indexing, and examples.

```APIDOC
## Node Addressing

Proxus supports all standard OPC UA Node ID formats.

### Node ID Formats

- **String**: Prefix `s=`, Example: `ns=2;s=Device1.TagA`
- **Numeric**: Prefix `i=`, Example: `ns=3;i=10024`
- **GUID**: Prefix `g=`, Example: `ns=4;g=72962B91-...
- **Opaque**: Prefix `b=`, Example: `ns=5;b=QVVJ...`

### Namespace Index

The `ns=` prefix specifies the namespace index:

- `ns=0`: OPC UA standard namespace
- `ns=1`: Server-specific namespace
- `ns=2+`: Application namespaces

### Examples

- `ns=2;s=Channel1.Device1.Tag1` → String node in namespace 2
- `ns=2;s=PLC/Temperature` → Hierarchical path
- `ns=3;i=1001` → Numeric node ID
- `ns=0;i=2259` → OPC UA Server Status node

```

--------------------------------

### Azure AD Configuration Example for Proxus

Source: https://proxus.io/docs/administration/authentication-providers

This configuration snippet shows how to set up Azure Active Directory authentication for Proxus by defining parameters such as instance, domain, tenant ID, client ID, and callback path in the Proxus-config.toml file.

```toml
[Authentication.AzureAd]
Instance = "https://login.microsoftonline.com/"
Domain = "your-company.com"
TenantId = "common"
ClientId = "your-app-client-id"
CallbackPath = "/signin-oidc"

```

--------------------------------

### View Proxus UI and Server Container Logs

Source: https://proxus.io/docs/getting-started/installation/on-premise-deployment-with-docker

These commands are used for troubleshooting by displaying the logs of the Proxus UI and Server containers. This is essential for diagnosing startup issues or runtime errors within the platform.

```bash
docker logs proxus-ui
docker logs proxus-server
```