Every Instrument Speaks Its Own Language: Introducing LabMCP

To get a Mettler Toledo balance to report its weight over a serial cable, you send it SI. To set an IKA hotplate to 60 °C, you send OUT_SP_1 60. A Lake Shore temperature controller wants KRDG? A, and an Atlas Scientific pH probe is calibrated with Cal,mid,7.00. Every instrument in your lab speaks its own language, written down in a manual that can run to hundreds of pages, with its own cable settings, its own line endings and its own idea of what an error message should look like.

That is a big part of why so much lab work is still done by hand. Automating even a simple routine (weigh, heat, stir, log until stable) means learning each dialect, writing the glue code, and then trusting a script someone wrote three years ago that nobody wants to touch. Meanwhile, AI assistants have become genuinely useful for planning experiments and analyzing data, but they stop at the edge of the bench. They can tell you what to do with the stirrer, but they can't turn it on.

Today we are releasing LabMCP, a free and open-source collection of connectors that let an AI assistant operate your lab instruments. You describe what you want in plain language, and the assistant weighs, heats, stirs, pumps, measures and logs for you. It stays inside safety limits you set, it keeps a record of every command it sends, and every connector has a practice mode, so you can try all of it today without plugging anything in.

What LabMCP is

LabMCP is built on the Model Context Protocol (MCP), an open standard that lets AI apps plug into outside tools. The easiest way to think of MCP is as USB for AI: any app that supports it can use any MCP connector. LabMCP provides one connector per family of instruments. Each connector is a small program that runs on the computer attached to the instrument and knows that instrument's command language, so the AI never has to guess it.

The important design choice is that the assistant can only do what a connector offers. The IKA connector, for example, offers actions such as reading the temperature, setting a temperature, starting the stirrer, waiting until the plate is at temperature and stopping everything. Each request is checked against your limits before anything goes down the cable. The AI is choosing from a menu that was written from the manufacturer's manual, not improvising commands.

The first release has 32 connectors with 411 actions between them, spanning biology, chemistry, physics, health and engineering, plus four universal protocols that reach many more instruments. They work with Claude Desktop, Claude Code, Cursor, VS Code, Codex, Windsurf and any other app that supports MCP, and they are released under the Apache 2.0 license.

What it looks like at the bench

Here is the request from the video. Picture a balance, a hotplate stirrer and a pH probe connected to one computer, and this typed into the chat:

Tare the balance, then heat the stirrer to 60 °C at 400 rpm and log the pH every 30 s until it's stable. Tell me when to add the reagent.

The assistant breaks that into steps. It tares the balance, sets the stirring speed and the temperature (pausing for your approval on both, because they are hazardous actions), starts logging pH, and watches the readings as they come in. Once the pH settles, it tells you so in plain terms, something like "pH has been 7.41 ± 0.01 for 3 minutes. Ready for the reagent." You didn't write a line of code or open a manual.

What makes this more than a remote control is that the analysis happens in the same conversation as the measurement. The assistant has the data the moment it is collected, so you can ask for things that used to mean exporting a CSV and opening another program:

• Electrochemistry: "Run cyclic voltammograms from −0.2 to 0.6 V at 25, 50, 100 and 200 mV/s, extract the anodic peak currents, and check whether they scale with the square root of scan rate."
• Physics: "Sweep the lock-in reference from 1 to 100 kHz in 40 log-spaced steps and fit the resonance. Then ramp the cryostat to 10 K at 2 K/min and repeat at 50 K and 100 K."
• Bioprocess: "Infuse 2 mL of media at 0.5 mL/min, then log the bioreactor pH and dissolved oxygen every minute for an hour and flag any drift."
• Microscopy: "Autofocus, take a z-stack around the current focus and tell me which slice is sharpest, then run a time-lapse every five minutes and report how much the signal bleaches."
• Mass spectrometry: "Build a randomized LC-MS worklist for these 48 samples with a blank and a QC injection every eight runs, and export it for MassLynx. Then give me a quick QC of last night's run."
• Engineering: "Step the flow controller through 10, 20 and 50 sccm of N₂ and log the upstream pressure at each setpoint. Stop and close the valve if pressure goes above 30 psia."

Several of those involve more than one instrument, and that is where LabMCP starts to feel different from vendor software. Add one connector per instrument to your AI app and the assistant sees them all at once, so a single request can weigh on one, heat on another and log from a third, the way you would if you had three pairs of hands.

What's covered

The universal connectors are worth a second look, because they cover far more than the table can name. If your instrument's manual talks about "SCPI commands" or "Modbus registers," there is a good chance one of them can drive it today. That covers a large share of bench multimeters, oscilloscopes and power supplies, and many PID temperature controllers and chillers. They come with the same practice mode, read-only mode and command log as the named connectors, plus limits and allowed commands that you define for your own instrument.

Mass spectrometry needed a different approach. None of the major vendors ships an MCP connector, and their acquisition interfaces are Windows-only and license-gated. So LabMCP reads LC-MS data through open formats (converting vendor files with free converters you install yourself, such as ProteoWizard's msconvert), builds sample worklists as import files for MassLynx, SCIEX OS, MassHunter and Xcalibur without ever starting a run, and offers a thin adapter for Thermo's Instrument API for labs that hold that license. Where a manufacturer does publish its own connector, as Keysight and Rohde & Schwarz do, we point you to it rather than build a second one.

Built for real labs: you stay in charge

An AI that can switch on a hotplate should make you a little nervous. It makes us nervous too, which is why so much of LabMCP is about safety. The protection works in layers, and none of them depends on the AI behaving well:

• Practice first. Every connector has a simulator that answers the way the real instrument does, down to the exact replies on the wire, so you can rehearse an experiment end to end with nothing plugged in. The connector always reports whether it is simulated and tells the assistant to label practice data that way, so a rehearsal doesn't get mistaken for a result.
• Start read-only. In read-only mode the assistant can watch every reading but can't change a setting. Stop and switch-off actions stay available.
• Set limits for today's experiment, not just the instrument. A setting like max_temperature_c=60 keeps the hotplate below your solvent's boiling point. A request over the limit is refused inside the connector, with a message that ends "Nothing was sent to the instrument." Because the check runs in the connector rather than in the model, no amount of clever prompting gets around it.
• Approve hazardous actions yourself. Of the 411 actions, 63 are marked hazardous because they heat, move, dispense or switch something on. Your AI app asks you before running each one, and we recommend leaving "always allow" off for them.
• Stop is always there. Every connector that can heat, move or power something has a stop or switch-off action, and it is never hidden, not even in read-only mode. Where an instrument has its own protection, LabMCP uses it: the IKA connector can arm the hotplate's communication watchdog, so if the computer, the cable or the software fails, the hotplate switches itself off.
• Every command is on the record. Each command sent and each reply received is logged, like a lab notebook that writes itself. Ask the assistant to show you the log, or save it to a file alongside your results.

These layers add to your instrument's own protection; they don't replace it. Keep the interlocks and over-temperature cut-offs on, follow your institution's safety rules, and supervise anything hazardous. LabMCP is a research tool, not a certified safety system or a medical device, and it is not validated for GxP or clinical use. The safety guide is short, and worth reading before you connect anything that gets hot, moves or carries current.

Why not just ask the AI to write the code?

AI assistants are good at writing instrument scripts now, so it is a fair question. The trouble is that a script written on the spot starts from scratch every time. It has no safety limits, no record of what it sent and no practice mode, and one small mistake (the wrong line ending, a unit off by a factor of a thousand, a speed meant for a different model) goes straight to the hardware. You also have to check its work against a manual you were hoping not to read.

LabMCP does that careful work once, for everyone. Each connector is written from the manufacturer's published manual and tested against a simulator of that instrument. As part of this release we checked every connector against its vendor's documentation a second time, then reviewed the whole codebase for logic and safety bugs, a pass that added about 280 regression tests. That is effort no one should have to repeat for every experiment.

It also complements our open-source Scientific Agent Skills library. Skills give any agent that supports them the know-how for a piece of science, from drafting an Opentrons protocol to analyzing a proteomics run. LabMCP gives the agent a safe way to act on the instruments that do the work.

Try it in 10 minutes, no instrument needed

You need a Mac, Windows or Linux computer and an AI app that supports MCP. Claude Desktop is the easiest place to start, and setup for Claude Code, Cursor, VS Code, Codex and Windsurf is in the docs.

1. Install uv, a free program that downloads and runs LabMCP for you. It takes one line in a terminal, and the README has the line for your system.

2. Add a practice balance. In Claude Desktop, open Settings → Developer → Edit Config, paste the following, save, and restart the app.

   {
     "mcpServers": {
       "balance": {
         "command": "uvx",
         "args": ["labmcp-mettler-toledo", "--simulate"]
       }
     }
   }
   

3. Ask. Try "What instrument is connected? Tare it, then log the weight every second for 10 seconds." The first request can take a minute while the connector downloads.

For a whole practice lab, the examples folder sets up six simulated instruments at once: a balance, a hotplate stirrer, a pH probe, a syringe pump, a potentiostat and a spectrometer. When you're ready for the real thing, it is one change in the same file. Plug the instrument in, run uvx labmcp ports to find its address, and replace --simulate with --address followed by that address.

A few practical questions

Do I need to know how to program? No. You install uv once and paste a few lines into your AI app's settings, and LabMCP downloads and runs everything else.

Which computer does it run on? The one physically connected to the instrument, by USB, serial cable or network. You can reach it from another computer, and the docs show how to do that through an SSH tunnel or VPN without exposing instrument control to the internet.

Does my data leave the lab? LabMCP itself runs on your computer and talks to the instruments directly. Your AI app sends results to its AI provider, just as it does with anything else you type into it, so follow your institution's data policies.

What does it cost? Nothing. LabMCP is free and open source, though your AI app may need its own subscription.

Help us verify it on real hardware

We want to be clear about where the project stands. All 32 connectors are currently marked simulated: each was built from the manufacturer's published manual and tested thoroughly against its simulator, but none has yet been confirmed on a real instrument. A connector earns hardware-verified status only when someone who owns the instrument confirms it works, and that is where we need your help.

If you have one of these instruments, the most valuable contribution needs no code at all. Run the connection check, try a few requests, and file a short report. If your instrument isn't covered yet, request it or upvote an existing request. Next on our list are PyLabRobot backends for Hamilton and Tecan liquid handlers and plate readers, Thorlabs and Zaber motion stages, Zurich Instruments lock-ins, Knauer HPLC pumps, and Watlow and Eurotherm controllers.

The science, not the serial port

Every lab has instruments that could do more if they were easier to talk to: the balance that only ever gets read by eye, the potentiostat run one scan at a time, the circulator nobody has scripted because the manual is in a binder somewhere. LabMCP is our attempt to give the whole bench one language, and to make it the one you already use.

LabMCP is on GitHub. Start in practice mode, connect a real instrument when you're ready, and if it helps your work, star the repo so other scientists can find it. We would love to hear what you connect first, in the repo's issues or at contact@k-dense.ai.