DEV Community: CAVEDU Educaion

Jetson AGX Orin and LangChain: Remote Access and AI Agent Projects on the MIC-733

CAVEDU Educaion — Fri, 13 Nov 2026 01:00:00 +0000

This Jetson AGX Orin LangChain tutorial demonstrates how to operate an Advantech MIC-733 remotely from a laptop and run Jupyter Notebook examples for Grove board control, voice interaction, news summaries, and product price searches.

Writing and photography: 郭俊廷 (CAVEDU)

Estimated time: 2 hours. Difficulty: 3/5.

Hardware: MIC-733-AO6A1 with a 64 GB NVIDIA Jetson AGX Orin, and a USB webcam with a microphone. The materials list names a C710; the voice example below uses a C170.

Hardware and workflow

This tutorial uses the Advantech MIC-733-AO6A1. Manufacturer highlights cited in the original article include up to 275 TOPS, a compact fanless design, four GbE ports with optional PoE, four USB 3.2 Gen 2 ports (10 Gbit/s), two mPCIe slots, two Nano SIM slots, Allxon remote monitoring and OTA deployment, and Microsoft Azure certification.

We will connect over SSH with MobaXterm, configure Wi-Fi, and use LangChain with the Arduino beginner kit to read sensors, control an LED, and interact through speech. We will also run environmental-news summarization and product-price lookup examples.

1. Connect to Jetson AGX Orin with MobaXterm

Download MobaXterm

A classroom or field setup may not have a separate monitor and keyboard. SSH lets you operate the MIC-733 from your laptop instead.

The original tutorial uses the v26.0 Portable Edition, available from the MobaXterm download page. Extract the archive and run the executable.

Connect the Ethernet cable

Connect your laptop to the MIC-733's LAN2 port with an Ethernet cable. In this classroom setup, LAN2 has already been configured with the shared-network address 10.42.0.1. Use this address for the SSH and web connections below; it is a property of this prepared setup, not a universal device default.

Start an SSH session

Run MobaXterm_Personal_26.0.exe.
If Windows displays the application's network-access prompt, the original walkthrough selects Allow access.
Choose Session > SSH.
Set Remote host to 10.42.0.1 and select OK.
In the prepared classroom image, both the username and password are mic-733ao. Use the credentials configured for your own device. Password characters are not displayed while typing in the terminal; press Enter after entering the password.

Configure Wi-Fi

The examples need Internet access for online data and model resources. Open the network manager:

sudo nmtui

Choose Activate a connection, select your Wi-Fi network, and enter its password. Press q when finished to leave the interface.

Test connectivity:

ping google.com

Receiving reply packets indicates that the connection is working.

2. Control a Grove board with LangChain

Connect the hardware and upload the firmware

Connect the Arduino beginner kit to a USB port on the MIC-733.

If a teaching assistant has already uploaded the firmware, skip the following upload steps:

Download llmcmd_blink.ino and the Hangeekduino graphical programming package.
Open the sketch using the included Arduino IDE. Select Tools > Board: Arduino/Genuino Uno.
Use Get Board Info to confirm the communication port, then click the upload arrow to flash the firmware.

Activate the Conda environment and launch Jupyter Notebook

In the remote terminal, enter the working directory and activate the prepared environment:

cd ~/Downloads/GROVE_AGENT_LOCAL/
conda activate Grove-Agent

For the remote setup in this tutorial, launch Jupyter with:

jupyter notebook --ip='*'

Open http://10.42.0.1:8888 in your laptop's browser. If the terminal displays a URL containing a token, use the complete access URL, including the token. The prepared classroom Jupyter setup may instead request its configured password, mic-733ao. These are classroom configuration details, not general Jupyter defaults. Keep this service on a trusted network and retain authentication.

Run the Grove example

Open Agent_Grove_Local_260907.ipynb.

Hardware detection: Run the first code cell. It detects the Arduino's USB serial port, for example Device: /dev/ttyUSB0. Update the program to match the port reported by your device.
Scenario analysis and control: Continue through the final cell. LangChain analyzes the environmental sensor readings, produces a risk assessment and care-related suggestions for the demonstration, and switches the board's LED on or off according to the result. Treat those suggestions as demonstration output rather than validated medical advice.

Before moving to another example, run the final disconnect cell to release the board, interrupt the kernel, or close the notebook. Otherwise, the serial port may remain occupied.

3. Add voice interaction

This example adds microphone input and synthesized speech so the agent can interact with the user through voice.

Prepare the microphone

Plug a USB webcam directly into the MIC-733, not into your laptop. The example uses the built-in microphone of a C170 webcam.

Run the speech notebook

Open Text_Speech_Local_260826.ipynb.

Test TTS: Run the text-to-speech cell and click Convert and Play (轉換並播放) to test audio output.
Record speech: Run through the fourth code cell and click Start Recording (開始錄音). In this setup, the webcam indicator lights while recording. Try a few times to become familiar with the timing.
Identify USB hardware: Check the Arduino connection reported by the system, such as /dev/ttyUSB0.
Model analysis and spoken response: The final cell takes the spoken request and uses the configured local model to analyze sensor data, assess the scenario, and generate suggestions followed by a spoken response. The original classroom example describes its model as “Gemma 26B”; check the actual installed model identifier and available memory in your environment.

4. Summarize environmental news and look up product prices

These examples demonstrate LangChain workflows for crawling data, organizing information, and producing structured analysis.

Activate Data-Agent and start Jupyter

Open a new terminal and run:

cd ~/Downloads/DataAgent
conda activate Data-Agent
jupyter notebook --ip='*'

Open the Jupyter interface at http://10.42.0.1:8888, using the address, port, and authentication information actually shown by your server.

Environmental-news recap

Open Agent_News_Recap_260828.ipynb. The aggregation and chart-output cells perform retrieval and summarization, so they can take longer to execute. Once completed, the notebook outputs charts and a written summary of the main points.

Automated two-stage price search

Open Agent_Price_List_260828.ipynb. When the last cell runs, the terminal displays a message equivalent to: The agent is starting a two-stage crawler for precise price lookup. Please wait...

After crawling completes, the page presents a structured list of product-price results.

Environment and software prerequisites

The MIC-733 used in this class was configured in advance with the required Conda environments and packages, Ollama, AI models, and other software. That preparation allows participants to begin directly with Jupyter Notebook exercises.

On a new device, first install and configure Conda, Jupyter Notebook, Ollama, the required AI models, and the remaining dependencies. You also need the example notebooks and classroom project files referenced above; this article describes how to operate that prepared environment rather than providing a complete fresh-install procedure.

Some images and hardware specifications in the original article reference the Advantech MIC-733 product page.

Translated into English from CAVEDU's original tutorial, originally published October 6, 2026. This link opens CAVEDU's website outside this platform. Author and photography credit: 郭俊廷. Minor clarifications identify classroom-specific settings and prerequisites; the example commands and filenames are preserved.

Build Your First Warehouse Scene in Isaac Sim with NVIDIA SimReady Assets

CAVEDU Educaion — Wed, 11 Nov 2026 01:00:00 +0000

Download two assets from Hugging Face, assemble a scene in the GUI, and verify that your USD stage reopens correctly.

Building a robotics environment can start with a small, concrete milestone: a warehouse scene that loads correctly, keeps its materials, and can be reopened later.

This CAVEDU tutorial uses a warehouse rack and a cardboard box from NVIDIA's SimReady Assets dataset. You will download the two asset folders, arrange one rack and three boxes in Isaac Sim, and save the result as warehouse_demo.usd.

Scene assembly uses Isaac Sim's graphical interface. You will use a terminal for asset downloads, but you do not need to write an Isaac Sim Python script.

The result is a static scene foundation. Dynamic physics is a separate verification step.

What SimReady does—and what you still need to check

A conventional 3D model may focus on geometry, appearance, and materials. Simulation workflows can also require collision geometry, mass, friction, or other properties.

SimReady assets are OpenUSD assets prepared for simulation workflows, but their capabilities vary. Check each asset's profile and contents against your intended task. The label alone does not guarantee identical rigid-body, collision, sensor, or articulation settings across assets.

For this exercise, the first goal is successful asset loading and scene assembly.

1. Prepare your environment

Install Isaac Sim on a supported workstation and check the requirements for your exact release. The original tutorial references Isaac Sim 6.x menu names, which can vary between versions.

Consult the Isaac Sim system requirements and workstation installation instructions before proceeding.

Install the Hugging Face Hub package:

python -m pip install -U huggingface_hub
hf --help

If your terminal cannot find hf, reopen it and check that the package was installed in the Python environment you are using. Also check your PATH.

2. Download only the two asset folders

Open the NVIDIA SimReady Assets dataset. This example uses:

Cardboard box: box_corrugated_brown_b20
Warehouse rack: rack_large_empty_a02

From your chosen project directory, run:

hf download nvidia/simready-assets --repo-type dataset --include "box_corrugated_brown_b20/**" --local-dir ./simready-demo
hf download nvidia/simready-assets --repo-type dataset --include "rack_large_empty_a02/**" --local-dir ./simready-demo

Check that these main USD files exist:

simready-demo/box_corrugated_brown_b20/simready_usd/sm_box_corrugated_brown_b20_01.usd
simready-demo/rack_large_empty_a02/simready_usd/sm_rack_large_empty_a02_01.usd

Keep the complete asset folders. The main USD files may reference textures, materials, payloads, and other dependencies. Copying only a main file can leave the scene incomplete. If the dataset changes, follow the actual downloaded structure.

3. Create a stage, ground plane, and lighting

In Isaac Sim:

Choose File > New to create a USD stage.
If the stage does not already contain a physics scene, choose Create > Physics > Physics Scene.
Add a floor with Create > Physics > Ground Plane.
If needed, add lighting through Create > Lights > Distant Light.

4. Reference and arrange the boxes

Choose File > Add Reference and select:

simready-demo/box_corrugated_brown_b20/simready_usd/sm_box_corrugated_brown_b20_01.usd

Confirm that the asset appears in the Stage panel and the viewport, with its materials visible. If you cannot find it in the viewport, select it in the Stage panel and press F to frame it.

Select the top-level box asset node and duplicate it twice. Use the Move Tool or Transform position fields to arrange three boxes without overlap.

5. Add the rack

Use File > Add Reference again and select:

simready-demo/rack_large_empty_a02/simready_usd/sm_rack_large_empty_a02_01.usd

Move the rack behind the boxes and adjust your view so the complete scene is visible. Check the stage units and transforms if object proportions look wrong.

Warehouse scene from the original CAVEDU tutorial.

6. Check physics before testing interactions

Pressing Play does not guarantee that the boxes will fall or collide correctly. Before testing those behaviors, inspect:

Whether the asset supports the intended simulation profile.
Whether rigid-body behavior is enabled and appropriate for the object.
Whether collision geometry exists.
Whether the object is configured as static or dynamic.
Whether the physics scene is configured correctly.

Visible geometry and collision boundaries can differ. Inspect existing settings before adding more physics components, so you do not duplicate configuration unnecessarily.

7. Save, reopen, and verify

Use File > Save As and save the stage to:

simready-demo/warehouse_demo.usd

Then choose File > Open and reopen that file.

Confirm that the rack, three boxes, ground plane, and lighting remain present; materials load correctly; and there are no missing-reference errors.

The stage still references external asset files. When moving the project to another computer, preserve the asset directories and valid reference paths, or use Isaac Sim's asset collection functionality to gather dependencies.

Troubleshooting

Symptom	First checks
`hf` is not found	Python environment, PATH, and a fresh terminal session
Asset is invisible	Main USD path, Stage node, and F to frame selection
Materials are missing	Complete asset folders, textures, and payloads
Scale looks wrong	Stage units and Transform scale
Assets disappear after reopening	Reference paths and external asset locations
No gravity or collisions	Physics Scene, rigid bodies, collision geometry, static settings, and asset profile

Where to go next

This scene can become the starting point for a supported robot arm and pick-and-place task, an AMR navigation environment, or a synthetic-data workflow using Isaac Sim Replicator. Those extensions require their own robot, controller, sensor, and physics setup.

For a first workshop or classroom exercise, keep the acceptance criteria concrete: the scene loads, its dependencies are intact, and it reopens successfully. That gives learners a reusable foundation for the next simulation task.

Adapted into English from our original illustrated CAVEDU tutorial in Traditional Chinese. This link opens the CAVEDU website outside this platform.

For robotics simulation workshops or training inquiries, contact the CAVEDU team. This link opens our company website outside this platform.

References

NVIDIA Jetson Agent Skills Tutorial: Installation and Hands-on Use with Cursor

CAVEDU Educaion — Mon, 09 Nov 2026 12:28:33 +0000

When developing AI on Jetson, a coding agent can help read device information, organize diagnostic results, prepare packages, and run tests. However, the right approach depends on the Jetson model, JetPack/L4T version, available memory, and runtime environment. Jetson Agent Skills organizes NVIDIA's Jetson workflows into agent-readable skills and helper scripts, allowing recommendations to reflect the current device rather than relying only on generic commands.

This tutorial brings together Jetson AI Lab's Jetson Agent Skills guide and AI-assisted development on NVIDIA Jetson tutorial. We first explain what the skills do, then connect to Jetson using Cursor Remote-SSH, install Device Skills, and get started with diagnostic and planning prompts.

What Are Jetson Agent Skills?

Agent Skills provide workflows and tool instructions for coding agents. Jetson Agent Skills can help inspect the device model, system version, memory, power configuration, and service status, then support package selection, inference deployment, or performance testing based on the device's conditions.

They do not replace the coding agent, NVIDIA documentation, or developer judgment. Always confirm the target device and check command results. This article focuses on Device Skills for a Jetson that is already running.

Jetson device family illustration from Jetson AI Lab.

Understand Device Skills vs. BSP Skills First

Jetson Device Skills: For a running Jetson. These support application development, system diagnostics, memory checks, package selection, and model inference. This is the collection we install here.
Jetson BSP Skills: For host-workstation platform tasks involving board support packages, custom carrier boards, pinmux, PCIe, camera configuration, building, and flashing. You do not need to install them first for ordinary application development.

If you simply want to run a model or inspect the system on an Orin or Thor, start with Device Skills. When modifying low-level hardware settings or building a custom platform, consult the Jetson BSP Skills project and the relevant hardware documentation.

A Recommended Workflow for Agent-assisted Development

Inspect: Read the Jetson model, JetPack/L4T version, available memory, power mode, and relevant services to establish its current state.
Plan: Compare packages, models, or configuration options against the device and task requirements. List the proposed commands and their possible effects.
Review, then execute: Understand operations such as package installation, disabling services, changing power settings, and rebooting before deciding whether to run them.
Verify: Use actual outputs, memory measurements, or performance tests to confirm that changes work. Do not assume success simply because the agent says it is done.

Jetson AI Lab's remote-development demonstration uses Codex with a Jetson Orin Nano, covering connection, skill installation, and device inspection. This article instead provides a Cursor example. Configuration interfaces and skill installation paths can differ between coding agents; check the version you are using.

Cover image from Jetson AI Lab's Codex remote-development tutorial. The following steps demonstrate Device Skills with Cursor. Source: AI-assisted development on NVIDIA Jetson.

Before You Start: Prepare Jetson and Your Development Environment

An NVIDIA Jetson device, such as an Orin-series device or Jetson Thor, that has completed initial setup, is running, and is connected to a network.
A Windows, macOS, or Linux development computer that can connect to Jetson over SSH.
Cursor installed, with Remote-SSH available. The commands in this article run in the remote terminal connected to Jetson.
Access from Jetson to GitHub to download the project. If you choose individual skill installation through the NVIDIA Agent Skills catalog, you also need Node.js and npm to provide npx.

Step 1: Connect to Jetson with Remote-SSH

Open Cursor on your development computer. Press Ctrl + Shift + P, or Cmd + Shift + P on macOS, to open the command palette.
Enter Remote-SSH: Connect to Host... and select that command.
Enter Jetson's SSH address, for example ssh jetson@192.168.1.42. Replace the username and IP address with your own.
On the first connection, select Linux, verify the host key as prompted, and sign in. If a host key is unfamiliar or has changed, confirm the device's identity before continuing.
After connecting, confirm that Cursor shows the SSH host and open the integrated terminal. Before running the remaining commands, make sure that the terminal is on Jetson rather than your development computer.

Conceptual illustration of Cursor Remote-SSH connecting to Jetson; not an actual software screenshot.

Step 2: Choose an Installation Method

Jetson AI Lab provides two entry points: select individual skills from the NVIDIA Agent Skills catalog, or install the full collection from the NVIDIA Jetson Device Skills project.

Install the skills in the environment where the agent will use them. For this Remote-SSH example, that means Jetson's remote terminal.

Option A: Install an Individual Skill from the NVIDIA Agent Skills Catalog

To start with read-only device diagnostics, run this command in the Jetson terminal to install jetson-diagnostic for Cursor:

npx skills@latest add nvidia/skills --skill jetson-diagnostic --agent cursor --yes

If you are unsure which skill to use, browse the NVIDIA catalog first. The CLI provides interactive options for the installation target:

npx skills@latest add nvidia/skills --list

Installing a single skill is a useful way to get started. For memory auditing, headless mode, package selection, or inference workflows, check the NVIDIA Agent Skills catalog for current skill names.

Option B: Install the Full Jetson Device Skills Collection

Run the following commands in Jetson's remote terminal:

git clone https://github.com/NVIDIA-AI-IOT/jetson-device-skills.git
cd jetson-device-skills
./install.sh --targets cursor

The installation script places the skills in a directory Cursor can read. To use the script's default installation targets across supported agents, run ./install.sh without arguments. To install for selected agents, consult the latest instructions in the official Jetson Device Skills project.

After installation, restart your Cursor Agent session and confirm that the skills are available in a location the agent can read.

Conceptual illustration of installing skill files in an agent-readable location on Jetson.

Step 3: Run Read-only Diagnostics Before Planning Changes

Open AI Chat in Cursor's sidebar. A common shortcut is Ctrl + L, or Cmd + L on macOS. First ask the agent to inspect the device without changing the system:

Read this Jetson's model, JetPack/L4T version, available memory, GPU utilization, power mode, and relevant services. List the inspection commands you use and their results, and identify your data sources. For this round, perform read-only checks only. Do not install packages or change system settings.

Conceptual illustration of an agent summarizing device diagnostics; not an actual operation screenshot.

After confirming the device information, ask for a plan that lists commands, trade-offs, and expected effects before execution:

Based on the device model, JetPack/L4T version, memory, and service status you just inspected, propose feasible options for switching to headless mode or deploying an LLM/VLM. First explain your reasoning, the required commands, possible effects, and how to revert the changes. Do not disable services, install packages, change settings, or reboot until I confirm.

Device support and actual performance vary with the model, JetPack/L4T version, model size, quantization method, and runtime environment. For inference options such as vLLM or llama.cpp, check compatibility first, then measure memory usage and performance on the target Jetson. Avoid copying another model's configuration without checking it.

Key Takeaways

Start with Jetson Device Skills for ordinary application development. BSP Skills cover host-side tasks such as custom platforms and flashing.
Install an individual skill through the NVIDIA Agent Skills catalog, or install the complete Device Skills collection from the official project.
When using Remote-SSH, make sure the terminal and skill installation location correspond to the intended Jetson and agent.
Follow the sequence inspect, plan, review and execute, then verify. Understand the effects before making system changes.

Jetson Agent Skills brings platform knowledge into a coding agent's workflow, helping developers experiment based on the actual device state. Always verify results using real Jetson outputs and tests, and let the developer decide whether to adopt a change.

English translation of CAVEDU's original Traditional Chinese article, published November 9, 2026. The link opens the CAVEDU website outside this platform. Original technical commands, reference links, and image credits are retained.