Skip to content
Back to search

labview-mcp

The best way out there for any AI to connect to LabVIEW.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/Zuehlke/labview-mcp with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/Zuehlke/labview-mcp'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/zuehlke--labview-mcp/badge.svg)](/listings/zuehlke--labview-mcp)

HTML

<a href="/listings/zuehlke--labview-mcp"><img src="/api/listings/zuehlke--labview-mcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

**You need:** Windows x64, **[Claude Code](https://claude.com/claude-code) ≥ 2.1.224**, and **LabVIEW 2026 Q3**. LabVIEW has to be running before you use the tools, though not to install them.

Installation

Open a terminal in your LabVIEW project folder:

claude plugin marketplace add Zuehlke/labview-mcp
claude plugin install labview-mcp@zuehlke-labview

Update

Once installed, run these commands to update the plugin to the latest release:

claude plugin marketplace update zuehlke-labview
claude plugin update labview-mcp

That is the whole setup. No clone, no build, no config file to hand-edit. Claude Code pulls a prebuilt Windows binary from the [latest release](https://github.com/Zuehlke/labview-mcp/releases/latest) and you get the server, eight LabVIEW agents (`labview-vi-generator`, `labview-vi-editor`, `labview-doc-generator`, `labview-class-generator`, `labview-dqmh-module`, and one per unit-test framework), and an allow-list that lets reads run uninterrupted while every mutating tool still stops to ask.

Start LabVIEW, open Claude Code in your project, and try:

> *"Call `lvai_status` to check the LabVIEW connection, then tell me what `C:\path\to\My.vi` > does."*

On Claude Code older than 2.1.224 the install complains about an unsupported source type. Upgrade, or take the manual route. If you are not using the plugin, or you are driving this from something other than Claude, then Codex, Copilot, Cursor, a local LLM and a binary-only install on a machine with no repository are all covered in [docs/guide/install.md](docs/guide/install.md).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 35 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "zuehlke-labview",
  3. "owner": {
  4. "name": "Zühlke Engineering AG",
  5. "url": "https://github.com/Zuehlke/labview-mcp"
  6. },
  7. "description": "LabVIEW tooling for AI assistants, published by Zühlke Engineering AG.",
  8. "plugins": [
  9. {
  10. "name": "labview-mcp",
  11. "source": {
  12. "source": "archive",
  13. "url": "https://github.com/Zuehlke/labview-mcp/releases/latest/download/labview-mcp.zip"
  14. },
  15. "description": "Read, write and run LabVIEW 2026 code from an AI assistant — VIs as text via AIXML, palette and shipping-example search, and seven bundled LabVIEW agents. Windows x64 only.",
  16. "author": {
  17. "name": "Zühlke Engineering AG"
  18. },
  19. "homepage": "https://github.com/Zuehlke/labview-mcp",
  20. "repository": "https://github.com/Zuehlke/labview-mcp",
  21. "license": "MIT",
  22. "keywords": [
  23. "labview",
  24. "ni",
  25. "mcp",
  26. "vi",
  27. "aixml",
  28. "grpc",
  29. "test-automation",
  30. "windows"
  31. ],
  32. "category": "development"
  33. }
  34. ]
  35. }
README.md · README · 350 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # LabVIEW MCP (for all LV versions)
  2. <p align="center">
  3. <a href="https://github.com/Zuehlke/labview-mcp/releases/latest"><img src="https://img.shields.io/github/v/release/Zuehlke/labview-mcp?sort=semver&label=release" alt="Latest release"></a>
  4. <a href="https://github.com/Zuehlke/labview-mcp/actions/workflows/release.yml"><img src="https://img.shields.io/github/actions/workflow/status/Zuehlke/labview-mcp/release.yml?label=build" alt="Release build"></a>
  5. <a href="https://github.com/Zuehlke/labview-mcp/actions/workflows/verify-release.yml"><img src="https://img.shields.io/github/actions/workflow/status/Zuehlke/labview-mcp/verify-release.yml?label=verify%20release" alt="Verify release"></a>
  6. <a href="https://github.com/Zuehlke/labview-mcp/releases"><img src="https://img.shields.io/github/downloads/Zuehlke/labview-mcp/total" alt="Downloads"></a>
  7. <a href="docs/README.md"><img src="https://img.shields.io/badge/docs-read-blue" alt="Documentation"></a>
  8. <a href="LICENSE"><img src="https://img.shields.io/github/license/Zuehlke/labview-mcp" alt="MIT license"></a>
  9. <img src="https://img.shields.io/badge/LabVIEW-2020%2B-FFDB00" alt="LabVIEW 2020 or newer">
  10. <img src="https://img.shields.io/badge/platform-Windows%20x64-0078D6" alt="Windows x64">
  11. <a href="https://discord.gg/labview"><img src="https://img.shields.io/badge/Discord-%23zuehlke--labview--mcp-5865F2?logo=discord&logoColor=white" alt="Discord: #zuehlke-labview-mcp on the LabVIEW server"></a>
  12. </p>
  13. <p align="center">
  14. <img src="tools/labview-mcp-as-sketch.png" alt="Pencil sketch of a smiling AI assistant robot pointing at a LabVIEW run arrow" width="320">
  15. </p>
  16. **An AI assistant that can read, write and run the LabVIEW code on your machine.**
  17. [**Quickstart**](#quickstart) · [What you can ask for](#what-you-can-ask-for) · [Under the hood](#under-the-hood) · [Status](#status-research-grade-and-honest-about-it) · [Install another way](docs/guide/install.md) · [All the docs](docs/README.md)
  18. <details>
  19. <summary>⚠️☠️🚨 Read this before you let a robot touch your VIs ⚠️☠️🚨</summary>
  20. >
  21. > **Not affiliated with, endorsed by, or supported by NI or Emerson.** Nobody at NI asked for
  22. > this, nobody at NI owes you anything for it, and nobody at NI is on the hook when it misbehaves.
  23. >
  24. > **The plumbing is theirs, and it is public.** The server inside LabVIEW is
  25. > [ni/grpc-labview](https://github.com/ni/grpc-labview), NI's own open source, MIT licensed gRPC
  26. > stack. Nothing was cracked open to get here. It is a *generic* server, which is rather the
  27. > point: it serves whatever schema LabVIEW registers into it at runtime, and it ships with gRPC
  28. > reflection switched on so that a client can ask what that is. We asked. It answered.
  29. >
  30. > **What it happens to be serving is another matter.** `lvai.LVAI` is not a published NI API.
  31. > No `.proto` in the install, no documentation, no version policy, and no promise that any of
  32. > these RPCs will still be there next quarter. NI's own repo already warns that generated names
  33. > are subject to change and that none of it is covered by NI Technical Support. Believe them.
  34. > They are being polite about it.
  35. >
  36. > ### Therefore
  37. >
  38. > * **It will break, and probably on a Tuesday.** A LabVIEW update, a tweak to the AI feature, a
  39. > shifted comma in the AIXML dialect, a new .NET runtime, your MCP client developing opinions.
  40. > Any one of those is enough. After every LabVIEW upgrade, run `lvai_dump_schema` and find out
  41. > what moved while you were asleep.
  42. > * **When it breaks, it is not a LabVIEW bug.** Please do not open a ticket with NI about a tool
  43. > NI did not write and cannot see. That burns an engineer's afternoon and gets you nowhere.
  44. > Open an issue here instead, where somebody knows what actually happened.
  45. > * **Nobody is liable for the outcome.** Not NI, not Emerson, not Zühlke, not whoever last
  46. > touched `main`. Lost work, mangled projects, a generated VI that confidently drives real
  47. > hardware into a wall: all yours. See [`LICENSE`](LICENSE), specifically the part in shouty
  48. > capitals about no warranty of any kind.
  49. > * **This writes and runs code on your machine.** Work on copies. Commit first. Keep the
  50. > mutating tools behind a confirmation prompt, and do not allow-list the whole server just
  51. > because the prompts are irritating. They are irritating on purpose.
  52. >
  53. > LabVIEW, NI and ni.com are trademarks of National Instruments Corporation, used here only to
  54. > say which software this thing talks to.
  55. </details>
  56. ## What you can ask for
  57. A `.vi` is a binary file. You cannot grep it. A diff of two versions tells you only that they
  58. differ. No amount of clever prompting will get a language model to emit one. So the last few years
  59. of assistants writing everybody else's code politely skipped LabVIEW.
  60. LabVIEW MCP borrows the IDE's own hands. It drives a running LabVIEW, any version from 2020 (older not tested) on, and exposes it over
  61. [MCP](https://modelcontextprotocol.io), so a VI becomes something an assistant can read as text and
  62. produce as text. Once it is connected:
  63. | | |
  64. |---|---|
  65. | **Read** | *"What does this VI do?"* The block diagram comes back as text: nodes, wires, terminals, structures. A whole `.lvproj` or `.lvlib` too. |
  66. | **Write** | *"Give me a VI that reads this file and sorts it."* Generated, validated, saved as a real `.vi`. |
  67. | **Edit** | *"Add error handling to this VI."* The existing diagram is changed in place. |
  68. | **Run** | *"Does it actually work?"* Executed as a top-level VI, with the outputs read back. |
  69. | **Build** | A build specification in a project is executed and its output written. |
  70. | **Reuse** | Your installed palettes and NI's shipping examples are searchable, so the answer is an existing VI wherever one exists. OpenG, MGI and JKI are included if you have them. |
  71. | **Document** | A bundled agent turns a library, class or project into a Word document, with a structure diagram and a section per public VI. |
  72. Every item on that list is something the IDE could already do. The trick is that a text-shaped
  73. thing can now ask for it.
  74. ## Under the hood
  75. Four processes, all of them yours, none of them on the internet. The assistant talks to a small
  76. local translator, and the translator talks to LabVIEW.
  77. ```
  78. YOU
  79. │ "give me a VI that reads this CSV and sorts it"
  80. ▼
  81. ┌────────────────────────────┐
  82. │ AI CLIENT │ Claude Code · Claude Desktop · Cursor · Codex · Copilot,
  83. │ │ or your own agent wrapped around a local LLM.
  84. └─────────────┬──────────────┘
  85. │ MCP, spoken as JSON-RPC over stdin and stdout. The client starts
  86. │ the server as a child process and asks it, once per session,
  87. │ what it can do.
  88. ▼
  89. ┌────────────────────────────┐
  90. │ LabVIEW MCP │ LabVIEWMCP.exe, one Windows executable with 121 tools.
  91. │ │ This is where the knowledge lives: the AIXML dialect,
  92. │ the translator │ the palette and example indexes, the VI Server catalogue.
  93. └──────┬──────────────┬──────┘
  94. │ │
  95. ENGINE 1 ENGINE 2
  96. lvai.LVAI pylabview
  97. gRPC/HTTP-2 bundled. It opens the .vi
  98. on 127.0.0.1 container and rewrites it.
  99. │ │
  100. ▼ │
  101. ┌────────────────┐ │ The port is picked when LabVIEW starts and rediscovered
  102. │ LabVIEW.exe │ │ every session. You never configure it, and you cannot.
  103. │ ┌────────────┐ │ │
  104. │ │ lvai.LVAI │ │ │ The gRPC server runs INSIDE LabVIEW: NI's own grpc-labview,
  105. │ │ service │ │ │ loaded by the AI add-on. With LabVIEW closed, engine 1 is
  106. │ └────────────┘ │ │ unavailable, and engine 2 is what you have left.
  107. └───────┬────────┘ │
  108. │ │
  109. ▼ ▼
  110. ┌─────────────────────┐
  111. │ YourVI.vi │ a real binary VI on disk, openable in the IDE,
  112. └─────────────────────┘ indistinguishable from one you drew yourself
  113. ```
  114. ### One request, end to end
  115. Here is the whole conversation behind *"give me a VI that reads this CSV and sorts it"*. Watch how
  116. many of the arrows stop at the server.
  117. ```mermaid
  118. sequenceDiagram
  119. autonumber
  120. actor You
  121. participant C as AI client
  122. participant M as LabVIEW MCP
  123. participant L as LabVIEW.exe
  124. participant D as your project
  125. You->>C: "a VI that reads this CSV and sorts it"
  126. C->>M: lvai_example_index, lvai_palette_index
  127. M-->>C: has NI already written this? (from a disk cache)
  128. C->>M: lvai_aixml_reference
  129. M-->>C: terminal names, wiring grammar (from a doc inside the DLL)
  130. C->>M: lvai_convert_vi_to_aixml, on a VI that resembles it
  131. M->>L: ConvertVIToAIXML
  132. L-->>M: AIXML
  133. M-->>C: here is how NI wired theirs
  134. Note over C: the model writes the AIXML
  135. C->>M: lvai_check_aixml
  136. M-->>C: the faults LabVIEW would accept in silence
  137. C->>M: lvai_generate_vi
  138. M->>L: ValidateAIXML
  139. M->>L: ConvertAIXMLToVI
  140. L->>D: writes YourVI.vi
  141. M-->>C: saved, and here is the connector pane verdict
  142. C->>M: lvai_run_vi_and_read_values
  143. M->>L: run it, read every output back
  144. L-->>M: the values
  145. M-->>C: it works
  146. C-->>You: here is your VI
  147. ```
  148. Four of those calls reach LabVIEW. The rest the server answers out of a disk cache or out of a
  149. document compiled into its own DLL, which is why a session feels brisk right up to the generate
  150. step and then stops to think.
  151. Step 4 earns its place in there. Terminal names in AIXML are literal LabVIEW labels, and several of
  152. them are surprising: `Increment` is `x+1`, while `Greater?` is `x > y?` with the spaces. An
  153. assistant that guesses collects an error from the validator. An assistant that looks them up gets a
  154. VI.
  155. The generate step is the first one that writes anything, and it is the one your client should be
  156. asking you about. Reads carry `readOnlyHint` and can be allow-listed. Writes carry
  157. `destructiveHint` and prompt every time. The full loop, including the parts verification cannot
  158. see, is in [docs/guide/aixml-workflow.md](docs/guide/aixml-workflow.md).
  159. ### Two engines, because one of them needs a licence
  160. Engine 1 needs LabVIEW running. Engine 2 needs nothing at all, not LabVIEW, not a licence, not even
  161. a Python install, because a bundled copy of
  162. **[pylabview](https://github.com/mefistotelis/pylabview)** takes the `.vi` container apart and puts
  163. it back together itself. It reaches everything AIXML has no words for: icons, front-panel layout,
  164. decorations, `.ctl` files, connector-pane patterns, and the diagram of a VI whose constructs
  165. LabVIEW's own generator flatly refuses to read.
  166. The two have separate jobs, and the dependency runs one way:
  167. | | |
  168. |---|---|
  169. | **AIXML**, via LabVIEW | **Creates and names.** The only way to author a VI from nothing at all. |
  170. | **pylabview** | **Edits and reads.** It changes what is already there, byte for byte. It cannot invent a node or a wire. |
  171. `pylv_route` picks between them per VI and tells you why. Which turns out to matter more than it
  172. sounds. Measured across 900 VIs of a production codebase, only **15 %** can be regenerated through
  173. AIXML at all. Seventy per cent call the project's own subVIs, which the generator rejects outright.
  174. When you are editing existing code, pylabview is the normal route and AIXML is the exception.
  175. ## Status: research-grade, and honest about it
  176. This works, and it has never been near a production validation cycle. Everything documented in this
  177. repository was measured on a real installation, by its authors, on one station.
  178. What that means in practice: the writing tools overwrite a `.vi` without asking. Regenerating a VI
  179. throws away its diagram layout, its decorations and its icon. And the interface underneath is NI's
  180. private one, so a LabVIEW upgrade is a coin toss.
  181. **Work on copies. Commit first.** Version control is the only undo there is.
  182. The unabridged version is in **[docs/guide/safety.md](docs/guide/safety.md)**, including what
  183. `ApplyAIXMLToVI` does instead of working, and the one class of edit that took `LabVIEW.exe` down on
  184. load. Worth ten minutes before the first write.
  185. ## Quickstart
  186. **You need:** Windows x64, an MCP-capable AI client, and **LabVIEW 2020 or newer** (tested back
  187. to LabVIEW 2020). On LabVIEW 2026 Q3 the server can also use NI's own gRPC service; on older versions it works
  188. through the bundled pylabview engine and LabVIEW's ActiveX server instead, and picks that by itself.
  189. ### Installation, with any LLM
  190. Type the following into your LLM prompt:
  191. > Install the LabVIEW MCP from https://github.com/Zuehlke/labview-mcp.
  192. > Always use the latest release and configure the MCP to update automatically.
  193. ### Installation, with Claude Code
  194. With **[Claude Code](https://claude.com/claude-code) ≥ 2.1.224**, open a terminal in your LabVIEW
  195. project folder:
  196. ```powershell
  197. claude plugin marketplace add Zuehlke/labview-mcp
  198. claude plugin install labview-mcp@zuehlke-labview
  199. ```
  200. ### Update
  201. Once installed, run these commands to update the plugin to the latest release:
  202. ```powershell
  203. claude plugin marketplace update zuehlke-labview
  204. claude plugin update labview-mcp
  205. ```
  206. That is the whole setup. No clone, no build, no config file to hand-edit. Claude Code pulls a
  207. prebuilt Windows binary from the
  208. [latest release](https://github.com/Zuehlke/labview-mcp/releases/latest) and you get the server,
  209. eight LabVIEW agents (`labview-vi-generator`, `labview-vi-editor`, `labview-doc-generator`,
  210. `labview-class-generator`, `labview-dqmh-module`, and one per unit-test framework), and an
  211. allow-list that lets reads run uninterrupted while every mutating tool still stops to ask.
  212. Start LabVIEW, open Claude Code in your project, and try:
  213. > *"Call `pylv_status` to check the station, then tell me what `C:\path\to\My.vi`
  214. > does."*
  215. On Claude Code older than 2.1.224 the install complains about an unsupported source type. Upgrade,
  216. or take the manual route. If you are not using the plugin, or you are driving this from something
  217. other than Claude, then Codex, Copilot, Cursor, a local LLM and a binary-only install on a machine
  218. with no repository are all covered in [docs/guide/install.md](docs/guide/install.md).
  219. ## Where to go next
  220. | I want to… | Read |
  221. |---|---|
  222. | install some other way | [docs/guide/install.md](docs/guide/install.md) |
  223. | know what it can destroy before I let it | [docs/guide/safety.md](docs/guide/safety.md) |
  224. | see every tool, and which are safe to allow-list | [docs/guide/tools.md](docs/guide/tools.md) |
  225. | generate or edit a VI properly | [docs/guide/aixml-workflow.md](docs/guide/aixml-workflow.md) |
  226. | write AIXML by hand | [docs/aixml-reference.md](docs/aixml-reference.md) |
  227. | fix a connection that will not connect | [docs/guide/troubleshooting.md](docs/guide/troubleshooting.md) |
  228. | build, test, release, or find my way around | [CONTRIBUTING.md](CONTRIBUTING.md) |
  229. | have an assistant work in here without breaking things | [CLAUDE.md](CLAUDE.md) |
  230. Beyond the guides, [`docs/`](docs/) is a lab notebook. Fifty-odd pages of measurements, each one
  231. written up because it had just cost somebody an afternoon: crash signatures, the class and
  232. interface tooling, fifteen cold-build post-mortems, connector-pane tables.
  233. [`docs/README.md`](docs/README.md) sorts them by what you are trying to find out.
  234. ## Credits and third-party code
  235. ### pylabview, with thanks
  236. The `pylv_*` tools exist because of
  237. **[pylabview](https://github.com/mefistotelis/pylabview)**, and the debt is worth stating plainly.
  238. The hard part of this project's second engine was understanding LabVIEW's `RSRC` container and its
  239. object heaps well enough to take a `.vi` apart and put it back together byte-for-byte, and that was
  240. already solved there, by other people, years ago. Nothing in this repository reverse-engineers a
  241. `.vi` file format. It reads one through their work.
  242. Thank you to **Mefistotelis**, who wrote it. It is a decade of patient, unglamorous file-format
  243. archaeology, given away for free, and it turned "an assistant cannot edit a VI without a LabVIEW
  244. licence" into something that is simply not true any more.
  245. | | |
  246. |---|---|
  247. | Project | [mefistotelis/pylabview](https://github.com/mefistotelis/pylabview) |
  248. | Authors | Jessica Creighton (2013), Mefistotelis (2019 to 2020), as the licence names them |
  249. | Licence | MIT. Full text in `tools\pylabview\vendor\LICENSE-pylabview.txt` |
  250. | Pinned commit | `69768647c18d2d792a259b69884b2433761c3a4f` (2026-07-30) |
  251. | Local changes | **none**, as described below |
  252. **Upstream is vendored unmodified, deliberately.** `tools\pylabview\vendor\pylabview\` is
  253. byte-identical to that commit, so upstream fixes can be taken by copying the package over it.
  254. Everything this project needed on top was added from the outside instead. The primitive and
  255. terminal names pylabview does not carry are written in as inert XML comments by
  256. `experiments\pylabview\annotate_names.py`. The one upstream defect encountered was a crash on VIs
  257. whose probe table is not a `RepeatedBlock`, measured at 32 of 900 VIs in a production codebase, and
  258. it is applied to the assembled copy through `tools\pylabview\patches\patches.json` and never to
  259. `vendor\`. `tools\pylabview\VENDOR.md` has the provenance and the reasoning.
  260. If you use this server's editing tools, you are using their code. Please star their repository.
  261. ### NI's grpc-labview
  262. The `lvai.LVAI` transport is NI's own open-source
  263. [grpc-labview](https://github.com/ni/grpc-labview), which is what makes the interface reachable at
  264. all. The next section has the details.
  265. ## Where the interface comes from
  266. `labview_grpc_server.dll`, shipped in the `lvai` LVAddon, is NI's open-source
  267. [grpc-labview](https://github.com/ni/grpc-labview). It is a *generic* gRPC server, which is why no
  268. `.proto` ships with it: the schema is registered from LabVIEW at runtime.
  269. That server has **gRPC server reflection** compiled in, so the schema was recovered by asking the
  270. running LabVIEW itself. The result is in
  271. [`Protos/lvai_grpc_interface.proto`](src/LabVIEWMCP/Protos/lvai_grpc_interface.proto). It compiles
  272. with `protoc`, and its generated stubs return live data.
  273. `lvai_dump_schema` re-reads the schema from whatever LabVIEW is running, so you can catch drift
  274. instead of trusting this checked-in copy.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.