> For the complete documentation index, see [llms.txt](https://nx.docs.scailable.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://nx.docs.scailable.net/ai-manager-v6.1.4/ai-accelerators-support/advanced/memryx-support.md).

# MemryX Support

## Summary

| AI Accelerator | Support Level | CPU Architecture | Operating System           | API/driver version |
| -------------- | ------------- | ---------------- | -------------------------- | ------------------ |
| MX3            | Experimental  | x86\_64          | Ubuntu 22.04, Ubuntu 24.04 | 2.2.0              |

## Introduction: About MemryX

MemryX, Inc. builds Edge AI acceleration hardware designed for efficient, scalable deployment. MemryX’s AI accelerator chips, known as MXAs, offer server-like performance and accuracy at low power and low cost and are well-positioned for Edge AI applications, including autonomous driving, robotics, machine vision, and more.

The MemryX MX3 M.2 AI Accelerator module has an M-key 2280 form factor and includes 4 MXA chips. This production module is now supported by the AI Manager.

<figure><img src="/files/7bc0eaaac043d2b6f08b08a8f384db25e1aff19b" alt="MemryX logo" width="200"><figcaption></figcaption></figure>

## Workflow

The AI Manager simplifies the process of securely deploying your AI models on MemryX MX3 devices with the following steps:

1. Install all necessary software dependencies.
2. Install the Nx Meta Mediaserver on your machine and choose the MemryX runtime option.
3. Upload your model to the AI Manager Cloud for compilation.
4. Compile and install the required post-processor.
5. Set up your inference pipeline.

## Hardware and Software Requirements

**Hardware Requirements:**

* Find detailed hardware requirements on the MemryX Developer Hub: see [resource](https://developer.memryx.com/get_started/install_hardware.html) for installation requirements and recommendations.
* In general, any modern x86\_64 system with AVX2 and a suitable M.2 slot should work well with the MX3.

The MemryX driver and runtime libraries, which support multiple CPU and distribution combinations, are provided via the apt package repository.

**Software Requirements:**

* Ubuntu 22.04 LTS
* Ubuntu 24.04 LTS

## Installation Steps

Follow the runtime installation steps from the MemryX Developer Hub: [Installation Instructions](https://developer.memryx.com/get_started/install_runtime.html)

The instructions guide you through installing the MemryX runtime and drivers, both required to use the device with the AI Manager.

After installing the drivers and runtime, a system reboot is required. After rebooting, return to Step 7 of the Developer Hub installation steps to install the MemryX utilities and plugins, which are required for use with the AI Manager.

## Verify Installation

To verify your MemryX installation, power on your system and run the following command:

```bash
ls /dev/memx*
```

The command should return the following to indicate that a single MemryX module is properly installed and ready to use:

```
/dev/memx0
```

To verify the installation further, run a workload on the accelerator module using the [Hello, MXA!](https://developer.memryx.com/get_started/hello_mxa.html) tutorial on the MemryX Developer Hub.

## Getting Started

This guide walks you through deploying the **YOLOv8m** model on a MemryX MX3 M.2 module using the AI Manager.

Before starting, become familiar with the AI Manager and the process of running models on a CPU. See the [configuration section](https://nx.docs.scailable.net/nx-ai-manager/configure-the-plugin) for a refresher.

This guide uses the following resources:

* **Nx Meta:** Use the Nx Meta 6.1.2 version or later, which you can download from [here](https://beta.networkoptix.com/beta-builds/metavms/6.1.2.42601/index.html), and install and configure as outlined [here](https://nx.docs.scailable.net/nx-ai-manager/install-network-optix).
* **ONNX Model:** The model is available at [model.zip](https://drive.google.com/file/d/1Fc-AvmEpvBxmj7Vz1BHJHcC5tKkyfZWk/view?usp=sharing)
* **Post-processor**: The post-processor source is available at [post\_processor.zip](https://drive.google.com/file/d/1J3Iyt3x8usG5oN6P_W7OHbFfLiLsUhoR/view?usp=drive_link)

## Upload Model to AI Manager Cloud

Upload your ONNX model to the [AI Manager Cloud](https://admin.sclbl.nxvms.com/) following the steps outlined in [the upload section](https://nx.docs.scailable.net/nx-ai-cloud/upload-your-model).

Enable the **MemryX** conversion option in the model upload form and set the correct normalization values, as shown below.

<figure><img src="/files/DxgTvD6JCe1tHL5Pc8Xt" alt="AI Manager Cloud model upload form with the MemryX conversion option enabled and normalization values set"><figcaption><p>Enable MemryX conversion and set normalization values in the upload form</p></figcaption></figure>

The cloud platform will automatically convert the standard ONNX model into an MX3-compatible binary in the background. The model is ready for deployment once its status updates to **ok**, as shown below:

<figure><img src="/files/92c0e4d3bc2325e3f137059ffbcbe2d24780fc31" alt="AI Manager Cloud model listing showing the MemryX conversion status as ok"><figcaption><p>Model ready for deployment once the status shows ok</p></figcaption></figure>

## Select the MemryX Runtime

The AI Manager provides native support for multiple AI accelerators. To route inference to the chip, select the **MemryX** runtime in the AI Manager settings page:

<figure><img src="/files/8bc3c64bbeeab44a9197ad466323e7e53b220b5a" alt="AI Manager plugin settings with the MemryX runtime selected"><figcaption><p>Select the MemryX runtime to route inference to the chip</p></figcaption></figure>

## Install Post-Processor

Models running on the MX3 require an **external post-processor** to translate raw network output tensors (e.g., probability matrices) back into meaningful Nx metadata, such as object bounding boxes and classifications.

To deploy the provided YOLOv8m example, complete the following steps to compile and install the external C/C++ post-processor directly on the Nx Meta Mediaserver machine:

1. Extract the post-processor source code archive.
2. Execute the provided compilation script compile\_install.sh. This builds the post-processor and automatically copies its config.json definition into the AI Manager's post-processors directory:

```bash
bash ./compile_install.sh
```

To apply the change, restart the Nx VMS server. Instructions are available in [this section](https://nx.docs.scailable.net/support-and-troubleshooting/troubleshooting/controlling-the-server-and-the-plugin#restarting-the-server).

## Configure Pipeline

Within the Nx Meta Client, [configure the pipeline](https://nx.docs.scailable.net/nx-ai-cloud/use-your-model) as shown in the image below:

<figure><img src="/files/Hu76aZ5dvO0eb6VNAeR9" alt="AI Manager pipeline configuration for a MemryX-compiled model"><figcaption><p>Configure the inference pipeline for the compiled model</p></figcaption></figure>

## Enable Inference on Camera

The final step is to activate inference for your camera by toggling the **Device Active** switch on the AI Manager settings page (as shown below).

<figure><img src="/files/3a36743bd6926d4986e3d8b230cccf7b9d9b1364" alt="AI Manager settings page with the Device Active switch toggled on"><figcaption><p>Toggle Device Active to start inference on the camera</p></figcaption></figure>

Inference results appear in the desktop client once the "Objects" tab is enabled.

<figure><img src="/files/63eec9197385999850b227aef792c03d0384bb6f" alt="Objects tab options in the desktop client&#x27;s right pane"><figcaption><p>Activate the Objects tab to see inference results</p></figcaption></figure>

To enable model inference on multiple cameras, repeat steps 4 and 5 for each camera.

## Supported Models

An extensive list of supported models can be found in the [MemryX Model Explorer](https://developer.memryx.com/model_explorer/models.html).

MemryX does not provide a curated model zoo. Instead, BF16 activations let a wide variety of models run out-of-the-box without manual quantization or modification.

The MemryX Model Explorer is a great resource to characterize the types of supported model architectures, but users are certainly not limited to this selection of models.

## Monitoring: Monitor Pipeline Throughput

To see the number of frames the AI Manager is processing for a camera, enable the model FPS event. You can find detailed instructions on this page: [Show AI inference framerate on video](https://nx.docs.scailable.net/nx-ai-manager/howtos/show-ai-inference-framerate-on-video).

## Monitoring: Monitor Chip Metrics

**Chip Temperatures**

Two methods are available for viewing chip temperatures. The C++ MxAccl API provides two functions for temperature monitoring.

Use the following function to monitor the temperature of each chip on the specified device ([docs](https://developer.memryx.com/api/accelerator/cpp.html#_CPPv4N2MX7Runtime10MxAcclBase21get_chip_temperaturesEi)):

```c++
std::vector get_chip_temperatures(int device_id = 0)
```

To see the maximum chip temperature across all chips on the device, use ([docs](https://developer.memryx.com/api/accelerator/cpp.html#_CPPv4N2MX7Runtime10MxAcclBase19get_max_temperatureEi)):

```c++
float get_max_temperature(int device_id = 0)
```

To monitor temperatures from the terminal, run the following command to check all chips on the device:

```bash
cat /sys/memx0/temperature
```

For continuous monitoring from the terminal, try the following command to view updated temperatures in 1-second intervals:

```bash
watch -n 1 cat /sys/memx0/temperature
```

Temperature measurements are in degrees Celsius.

**Chip Utilization**

The C++ MxAccl API uses a metric referred to as ‘pressure’, which serves to approximate the throughput utilization of a given model on the device. Read more about the pressure metric in the [pressure metric documentation](https://developer.memryx.com/api/accelerator/cpp.html#_CPPv4N2MX7Runtime10MxAcclBase12get_pressureEi).

Use the following C++ function to retrieve the MXA’s current pressure status ([docs](https://developer.memryx.com/api/accelerator/cpp.html#_CPPv4N2MX7Runtime10MxAcclBase12get_pressureEi)):

```c++
MX::Types::Pressure get_pressure(int device_id = 0)
```

To monitor utilization continuously from the terminal, use the following command with 1-second intervals:

```bash
watch -n 1 cat /sys/memx0/utilization
```

The percentage in this file is not measured the same way as the pressure metric described above; it approximates the current core utilization.

## Troubleshooting: Missing Bounding-Boxes

If you are not seeing bounding boxes visualized in the desktop client, check the following potential factors:

* **Model Accuracy:** The model might not be accurate enough for the specific environment where it is deployed.
* **Corrupted Configuration:** If the pipeline configuration has become corrupted, try re-installing the post-processor and reconfiguring the pipeline.
* **Throughput Saturation:** If you assign the pipeline to too many high-framerate streams, the pipeline throughput may become significantly lower than the stream framerate. This causes the AI Manager to drop most frames. To troubleshoot this, disable the AI Manager integration on all but one camera and gradually increase the number of cameras until you identify the machine's saturation limit.
* **Pipeline Incompatibility:** If a camera on the server is assigned a model that is not compatible with the MemryX chip, the AI Manager integration will stop working for *all* cameras across the server. Verify that all cameras have the correct pipeline assigned. If any camera has an incompatible model, disable the AI Manager integration for that camera.

## Technical Support

For technical questions, use the following support channels:

* MemryX Developer Support: [MemryX Developer Community Forum](https://community.memryx.com/t/welcome-to-memryx-developer-community/5)

{% tabs %}
{% tab title="Nx Witness" %}

* Nx Customer Support Portal: <https://support.networkoptix.com/>
  {% endtab %}

{% tab title="Nx Meta" %}

* Nx Customer Support Portal: <https://support.networkoptix.com/>
  {% endtab %}

{% tab title="Generic" %}

* Contact your reseller for platform support.
  {% endtab %}
  {% endtabs %}