Matlab Deploy AI Model Agent Skill

> Generate C/C++ or CUDA code from an AI model (PyTorch, LiteRT) using MATLAB Coder or GPU Coder. Use when the user wants to integrate an AI model into an application with code generation as the end goal — generating MEX, CUDA MEX, static library, dynamic library, or executable — or using the model in Simulink for simulation and code generation. This skill currently documents the PyTorch ExportedProgram (.pt2) workflow via loadPyTorchExportedProgram; LiteRT is already supported by the product (loadLiteRTModel, R2026a+) but detailed guidance has not yet been added to this skill. invoke, codegen, MEX, CUDA, GPU, C, C++, deploy, AI model, deep learning model, LiteRT, TFLite, TensorFlow Lite, Simulink, slbuild, PyTorch ExportedProgram block, MATLAB Function block, dlosslib.

17k tokens

context cost

the whole folder, loaded on every use

files

instructions only

copies elsewhere

how many repositories repackaged it

865

stars on the repo

on the repository, not the skill itself

Install

one command, takes just this skill from the repository

npx skills add https://github.com/matlab/matlab-agentic-toolkit --skill matlab-deploy-ai-model

The instruction itself

17 sections, as written by the author

Generate C/C++/CUDA Code from an AI Model

Generate deployable C/C++ or CUDA code from an AI model using MATLAB Coder or

GPU Coder. The workflow follows a common pattern regardless of model framework:

load, inspect, write entry-point, generate MEX, verify, then generate production code.

When to Use

User wants to generate C/C++/CUDA code from an AI model (PyTorch, LiteRT)
User has a model file (.pt2, .tflite) and wants to load it into MATLAB
User wants MEX acceleration for an AI model
User wants to generate CUDA code or GPU-accelerated MEX from an AI model
User wants to deploy an AI model to hardware
User wants to use a PyTorch or LiteRT model in Simulink (simulation or code generation)
User wants to verify AI model numerics between the source framework and MATLAB

When NOT to Use

General MATLAB Coder usage (codegen syntax, config tuning, writing codegen-ready code)
Editable dlnetwork for Deep Learning Toolbox workflows (quantization, compression, transfer learning) — use importNetworkFromPyTorch which returns a dlnetwork for PyTorch models. For deployment of an editable dlnetwork with model compression (INT8 quantization via dlquantizer, pruning, projection) or exportNetworkToSimulink workflows — use matlab-deploy-embedded-ai (Pattern 1).
Training or fine-tuning — this skill is for inference code generation only

Supported Frameworks

|-----------|-------------|---------------|--------|

For PyTorch-specific details (API routing, entry-point pattern, export workflow,

data layout, common mistakes): see references/pytorch-workflow.md.

Generic Workflow

The code generation workflow follows the same steps for any framework:

1. Load and Inspect

Load the model and check its input/output specifications to determine expected

shapes and types.

2. Write Entry-Point Function

Create a codegen-compatible entry-point function that:

Loads the model from a file path
Runs inference on an input
Returns the output

The model file path must be wrapped with coder.Constant so it's known at

compile time.

3. Verify Numerics

Compare MATLAB inference output against the source framework to confirm correct

loading. Use the same input data in both environments and compare with tolerance.

4. Generate MEX (First!)

Always generate MEX before lib/exe to verify on the host machine:

CPU MEX:

cfg = coder.config("mex");
codegen -config cfg -args {coder.Constant("model_file"), input} entryPoint

CUDA MEX (GPU acceleration):

cfg = coder.gpuConfig("mex");
codegen -config cfg -args {coder.Constant("model_file"), input} entryPoint

For CPU MEX SIMD acceleration (SIMDAcceleration = 'Full' for AVX2 on

Intel/AMD), see references/codegen-performance-options.md. For the DNN-

inference-specific MEX AVX2 ceiling, see references/dnn-codegen-options.md.

5. Verify MEX Output

Compare MEX output against MATLAB reference using matlab.unittest with

tolerance:

refOut = entryPoint("model_file", input);
mexOut = entryPoint_mex("model_file", input);
testCase = matlab.unittest.TestCase.forInteractiveUse;
testCase.verifyThat(mexOut, matlab.unittest.constraints.IsEqualTo(refOut, ...
    'Within', matlab.unittest.constraints.AbsoluteTolerance(single(1e-5))));

6. Generate Library/Executable

Once MEX is verified, generate production code:

cfgLib = coder.config("lib");
cfgLib.TargetLang = "C++";  % set to "C++" for C++ output; default is "C"
codegen -config cfgLib -args {coder.Constant("model_file"), input} entryPoint

For DLL: coder.config("dll"). For executable: coder.config("exe").

CUDA variants: Replace coder.config with coder.gpuConfig.

Performance tuning:

Generic knobs (SIMD instruction sets, reduction-loop vectorization,

multithreaded loops, MATLAB Coder ↔ Simulink Coder naming duality): see

references/codegen-performance-options.md.

DNN-inference-specific knobs (DLTargetLibrary / DeepLearningConfig to

disable third-party DL libraries, LargeConstantGeneration to serialize

weights to data files): see references/dnn-codegen-options.md.

7. Use in Simulink

For Simulink integration, use the dedicated PyTorch ExportedProgram block from

dlosslib — set ModelFilePath to the .pt2 file and it auto-detects

input/output shapes. No entry-point function or coder.Constant needed.

Pre/post-processing can be done with Simulink blocks around the dedicated block.

If you need everything in a single block, use a MATLAB Function block with

loadPyTorchExportedProgram + invoke (same pattern as the entry-point, but

the model path is a string literal — no coder.Constant).

Both paths support slbuild code generation (requires fixed-step solver + ERT

or GRT target). See references/simulink-workflow.md for full details.

8. Deploy to Hardware (Optional — requires Embedded Coder)

For embedded deployment, use the same entry-point function with an Embedded Coder

configuration. See the matlab-deploy-embedded-code skill for ERT config,

hardware settings, PIL/SIL verification, and target-specific options.

Ask the user to install the skill if it is not installed

Key Functions

|----------|---------|---------|-------|

Conventions

Always check the model's input specifications for correct input shape and type
Always generate MEX first, verify, then proceed to lib/exe
Always use coder.Constant for the model file path argument
Input data is typically single-precision (check model input specs to confirm)
Do NOT use importNetworkFromPyTorch for code generation workflows — it returns dlnetwork for the DLT path

References

references/pytorch-workflow.md — Full PyTorch-specific workflow: API routing,

entry-point pattern, export guidance, common mistakes, and conventions. Consult

for any PyTorch/.pt2 model code generation task. Links to deeper PyTorch

references (API signatures, data layout, numeric verification, supported models).

references/export-pytorch-models.md — Exporting an eager-mode PyTorch model to

.pt2 with torch.export (upstream of loading). Consult when the user has a

PyTorch model but no .pt2 file yet, or hits torch.export SerializeError /

kwarg-mismatch errors. Links to pytorch-export-patterns.md (per-source

templates) and pytorch-export-gotchas.md (torch 2.11 serialization fixes).

references/simulink-workflow.md — Simulink integration: dedicated PyTorch

ExportedProgram block (Path A) vs MATLAB Function block (Path B), block mask

parameters, code generation config, and key differences from command-line codegen.

references/codegen-performance-options.md — GENERIC codegen tuning

(not AI-specific). SIMD instruction sets (InstructionSetExtensions for

lib/exe/slbuild, SIMDAcceleration for MEX), reduction-loop vectorization

(OptimizeReductions), OpenMP multi-threading (EnableOpenMP MATLAB Coder

/ MultiThreadedLoops Simulink Coder), and the MATLAB Coder ↔ Simulink

Coder property naming table.

references/dnn-codegen-options.md — DNN-INFERENCE-SPECIFIC codegen

options: DLTargetLibrary / DeepLearningConfig('none') for the plain-C

DL path, LargeConstantGeneration for serializing large DNN weights to

data files, and MEX SIMD ceiling in a DNN-inference context. Read this

when the generic file's knobs need DNN-specific framing (e.g., "the MEX

SIMD cap matters because inference is the target").

Other skills for the same job

different authors, same section of the catalogue

LLM App Patterns

by ComeOnOliver

×2

Production-ready patterns for building LLM applications. Covers RAG pipelines, agent architectures, prompt IDEs, and LLMOps monitoring. Use when designing AI applications, implementing RAG, building agents, or setting up LLM observability.

Build production ML systems with PyTorch 2.x, TensorFlow, and modern ML frameworks. Implements model serving, feature engineering, A/B testing, and monitoring. Use PROACTIVELY for ML model deployment, inference optimization, or production ML infrastructure.

World-class ML engineering skill for productionizing ML models, MLOps, and building scalable ML systems. Expertise in PyTorch, TensorFlow, model deployment, feature stores, model monitoring, and ML infrastructure. Includes LLM integration, fine-tuning, RAG systems, and agentic AI. Use when deploying ML models, building ML platforms, implementing MLOps, or integrating LLMs into production systems.

Expert in Langfuse - the open-source LLM observability platform. Covers tracing, prompt management, evaluation, datasets, and integration with LangChain, LlamaIndex, and OpenAI. Essential for debugging, monitoring, and improving LLM applications in production. Use when: langfuse, llm observability, llm tracing, prompt management, llm evaluation.

Use this skill for reinforcement learning tasks including training RL agents (PPO, SAC, DQN, TD3, DDPG, A2C, etc.), creating custom Gym environments, implementing callbacks for monitoring and control, using vectorized environments for parallel training, and integrating with deep RL workflows. This skill should be used when users request RL algorithm implementation, agent training, environment design, or RL experimentation.

35k tokens scripts

Pinecone

by Orchestra-Research

×1

Managed vector database for production AI applications. Fully managed, auto-scaling, with hybrid search (dense + sparse), metadata filtering, and namespaces. Low latency (<100ms p95). Use for production RAG, recommendation systems, or semantic search at scale. Best for serverless, managed infrastructure.

Deploy, evaluate, fine-tune, and manage Foundry agents end-to-end with azd: hosted agent scaffold/run/deploy, prompt agent create, batch eval, continuous eval, prompt optimizer, Agent Optimizer scaffold, agent.yaml, dataset curation from traces, model fine-tuning (SFT/DPO/RFT). USE FOR: azd ai agent, azd provision/deploy, deploy agent, hosted agent, create agent, add tool to agent, invoke agent, evaluate agent, continuous eval, continuous monitoring, agent CI/CD, optimize prompt, improve prompt, optimize agent instructions, agent optimizer, deploy model, Foundry project, RBAC, role assignment, permissions, quota, capacity, region, troubleshoot agent, deployment failure, AI Services, create Foundry resource, provision, knowledge index, customize deployment, onboard, availability, fine-tune, SFT, DPO, RFT, training-data, grader, distillation, fine-tuned model, large file upload. DO NOT USE FOR: Azure Functions, App Service, general Azure deploy (use azure-deploy), general Azure prep (use azure-prepare).

285k tokens scripts