LM Studio plugins: which ones to install and comment

#Why plugins in LM Studio

LM Studio is an excellent local runtime: it downloads a GGUF or MLX, runs the model on your GPU or Apple chip, and exposes a chat interface or OpenAI-compatible API. But the basic chat remains limited to the text the model has in memory. No web access, no local file reading, no tool execution, and no integration with other applications.

The LM Studio plugins fill this gap. They let you extend the app without touching the inference engine: add tools the model can call during a conversation, transform prompts before they reach the model, and attach custom generation logic. Everything runs in the LM Studio process, so it all stays local—true to the app’s strict self-hosted approach.

#The 5 types of plugin components

An LM Studio plugin can provide five types of components. A single plugin can combine several, but each has a clearly defined role:

Tools Providers

Expose tools (functions) that the model can call during generation. This is the equivalent of “function calling”: the model decides when to call the tool, reads the result, and continues reasoning. Typical examples: reading a file, making an HTTP request, running a command, querying a database.

Prompt Preprocessors

They transform the prompt before it reaches the model. Useful for injecting context (RAG, summaries), masking PII, or rewriting the user's query in a format the model prefers.

Generators

Provide a custom generation backend instead of the default llama.cpp/MLX engine. Advanced use case: route certain requests to another runtime, a mock for testing, or a remote server you control.

Custom Configuration

Expose LM Studio config fields in the UI (toggles, sliders, text fields). The user configures the plugin without touching the code. The plugin reads these values at runtime.

Third-Party Dependencies

Lists the third-party npm packages required by the plugin. LM Studio installs them when building the plugin, in the integrated Node runtime.

#Install a plugin from the Hub

The simplest way to add a LM Studio plugin is through the official Hub. Every published plugin has a dedicated page with an “Add to LM Studio” button and a stable deeplink.

1. 01
   1. Find the plugin on lmstudio.ai

   Browse the LM Studio Hub to the page for the plugin you’re interested in. The canonical URL has the form `https://lmstudio.ai/<creator>/<plugin-name>`.
2. 02
   2. Click “Add to LM Studio”

   The button opens a deeplink that asks your local LM Studio app to install the plugin. If LM Studio is open, the installation takes a few seconds. Otherwise, the deeplink launches the app.
3. 03
   3. Check the plugin list

   Once installed, the plugin appears in LM Studio's Plugins section. You can enable it, configure it (if Custom Configuration is exposed), or disable it at any time.
4. 04
   4. Use the plugin

   LM Studio runs the plugin automatically when needed. For a Tools Provider, the tool becomes callable by the model during the chat. For a Prompt Preprocessor, the transformation is applied silently to every prompt.

#Connect an MCP server via mcp.json

MCP (Model Context Protocol) is an open standard that lets external servers expose tools usable by any compatible host. LM Studio has been an MCP Host since version 0.3.17. In practice, you can connect an MCP server (official or third-party), and its tools become available in the chat, exactly like the tools from a Tools Provider.

Version 0.3.18 brought two useful improvements: a button to force-restart an MCP server that has crashed, and a refresh button to reload the list of exposed tools without restarting the entire app.

Two ways to add an MCP server: a “Add to LM Studio” deeplink from the server page, or manually editing the `mcp.json` file. The second option goes through the “Program” tab in the right sidebar → `Install` button → `Edit mcp.json`.

{
  "mcpServers": {
    "hf-mcp-server": {
      "url": "https://huggingface.co/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_HF_TOKEN>"
      }
    }
  }
}

The `mcp.json` notation is compatible with Cursor's: if you already have an MCP file on the Cursor side, you can reuse the same blocks. Each entry under `mcpServers` describes a server (HTTP URL or local command, auth headers, environment variables).

#Create your plugin with the lmstudio-js SDK

To go beyond the existing lm studio plugins, LM Studio provides an official TypeScript/JavaScript SDK: `lmstudio-js`, published on npm as `@lmstudio/sdk`. The SDK covers the entire plugin API: component declaration, model access, config management, and communication with the app.

npm install @lmstudio/sdk --save

To start a plugin from scratch, the simplest approach is to use the `lms` CLI (included with LM Studio). Three commands cover most of the lifecycle:

1. 01
   1. lms create — initial scaffold

   Creates a new plugin folder with the expected structure: manifest, TypeScript code, and deps. You choose the main component type (Tools Provider, Prompt Preprocessor, Generator). The SDK and types are already wired up.
2. 02
   2. lms dev — development mode

   From the plugin folder, `lms dev` starts development mode. The code is rebuilt and reloaded on every save, and the plugin appears in the LM Studio app’s plugin list as if it were installed. Fast iteration, with no manual build/install cycle.
3. 03
   3. lms push — publish to the Hub

   When the plugin is ready, `lms push` publishes it to the LM Studio Hub. Anyone can install it via the deeplink `https://lmstudio.ai/<vous>/<nom-plugin>`. Versioning and metadata are managed by the project manifest.

#Security: sources, permissions, overconsumption

The LM Studio plugins and MCP servers expose the app’s process to third-party code. This is not trivial.

Arbitrary code

A local MCP can run any command on your OS. Read the code or trust the maintainer before installing.

File access

An MCP server with a `read_file` tool could potentially read everything your user can read. Restrict access through `allowed_tools` or with explicit paths on the server side.

Network access

An MCP can make outbound requests (potential exfiltration). Check the list of destinations in the config and block them through the firewall if needed.

Token overuse

MCPs designed for cloud models (large context windows, many tools) can inject a huge amount of context. On a smaller local model, this degrades performance and response quality.

Basic rule: a plugin/MCP you install must have an identifiable maintainer, an accessible repository, and a clear use case. When in doubt, read the code before clicking « Add to LM Studio ».

#Summer 2026 updates: v0.4.20, Linux, and Bionic

LM Studio 0.4.20 (July 22, 2026) primarily strengthens network usage: enterprise-oriented endpoints and « device » models that can be controlled remotely through LM Link. Nothing breaks for your existing plugins: the system remains JavaScript/TypeScript running on Node, with the same component families (tool provider, prompt preprocessor, generator, custom configuration) and the lms dev developer mode, which hot-reloads the plugin.

On Linux, plugins are stored in ~/.config/LMStudio/plugins—convenient for versioning them with git or syncing them across machines. The rest of the workflow (installation, MCP servers via mcp.json) is identical on Windows and macOS.

#Go further

Plugins and MCP servers turn LM Studio into a platform: the same local runtime can now power an enhanced chat, an autonomous agent, an assisted IDE, or a backend for your own apps. The right approach is to start small (one official MCP, one Hub plugin), understand how it behaves, then build your own Tools Provider when a specific need arises.

If you're just getting started with LM Studio, or want to use it as a backend for other tools, the guides below round out this overview.