Install Houtini LM for Claude Code and Remote LM Studio

How Houtini LM, Claude Code, and LM Studio fit together

It is important to understand the network boundary before installing anything. Houtini LM is an MCP server that Claude Code launches as a local stdio process. In other words, Claude Code communicates with Houtini LM through the process input and output streams. The documented installation does not start an inbound Houtini LM HTTP, TCP, or UDP listener.

Houtini LM then sends delegated work to an OpenAI-compatible HTTP endpoint. LM Studio can provide that endpoint on the same computer at http://localhost:1234. It can also run on another computer, such as a GPU workstation reachable at a LAN address like http://192.168.1.50:1234.

This produces a three-part workflow. Claude Code remains the orchestrator and decides when to call an MCP tool. Houtini LM packages the bounded task and communicates with the configured model endpoint. LM Studio performs inference with the model currently loaded in its server.

What work should be delegated?

Houtini LM is designed around bounded tasks that can be described with enough context in a single request. Examples include drafting tests, reviewing a contained piece of code, generating boilerplate, explaining a function, preparing a commit message, producing documentation, converting formats, or asking another model for a second opinion.

Delegation is less suitable when the task depends on broad architectural judgment, substantial project history, unrestricted filesystem access, or an extended chain of tool calls. A practical test is to ask whether a competent developer could complete the assignment from a precise brief and whether Claude can review the result before it is accepted.

Local inference may also be slower than a hosted frontier model. The project documentation reports that local inference can be several times slower, depending on the model and hardware. The useful trade-off is therefore not simply speed. It is the ability to direct bounded work to hardware or an endpoint that you control while reserving Claude Code for orchestration and review.

Prerequisites for the installation

Complete the following checks before adding the MCP server. Most startup failures in this workflow come from an unsupported Node.js version, an inactive LM Studio server, no model being loaded, or an endpoint that the Houtini LM process cannot reach.

Check the Node.js version

Open the same terminal environment from which you use Claude Code and run:

node --version

The result must be version 22.5 or newer. Version 22.13 or later is recommended because Houtini LM's model cache uses Node's built-in node:sqlite support. According to the project documentation, the MCP server can still run on an older supported Node.js release without that cache. Node.js versions below 22.5 do not meet the documented prerequisite.

Also confirm that npx is available:

npx --version

If either command is unavailable, repair or update the Node.js installation before continuing. Be aware that graphical applications and terminal sessions can inherit different environment variables. If Claude Code is started from a different shell or application launcher, it may not see the same Node.js executable that your current terminal sees.

Decide where LM Studio will run

Choose the simplest topology that meets your needs. Running everything on one computer removes network routing from the setup and is the best starting point. A LAN GPU host is useful when the model requires hardware installed in another workstation. A Localtonet tunnel is relevant only when the backend must be reached across separate networks.

Prepare the LM Studio model backend

Houtini LM does not include the language model itself. Before installing the MCP integration, LM Studio must have a suitable model available, the model must be loaded, and LM Studio's OpenAI-compatible server must be running.

Exact model selection depends on your hardware, available memory, context requirements, and the kind of work you intend to delegate. There is no single model that is correct for every installation. Smaller models may be easier to run, while larger models generally place greater demands on memory and inference time. Do not assume that a model will fit solely from its name. Check its actual memory requirements against the target computer.

Localhost versus a LAN address

The hostname localhost always refers to the computer on which the Houtini LM process is running. If Claude Code and Houtini LM run on your laptop while LM Studio runs on a GPU workstation, http://localhost:1234 points to the laptop, not the GPU workstation.

For a LAN deployment, use the model host's reachable LAN address instead. The project documentation provides http://192.168.1.50:1234 as an example. Replace that example with the real address assigned to your model host. LM Studio must also be configured to accept the intended network connection. The available binding controls can vary by LM Studio release, so confirm the setting in the installed version rather than assuming that the server listens beyond localhost.

Install Houtini LM in Claude Code

Once the LM Studio server is active, register Houtini LM with Claude Code. The official installation method uses the Claude CLI and runs the published package through npx.

claude mcp add houtini-lm -- npx -y @houtini/lm

With the default setup, Houtini LM expects LM Studio at http://localhost:1234. No endpoint environment variable is required when that is the correct address.

The -y argument allows npx to run the package without stopping for an interactive installation confirmation. On first launch, npx may need to obtain the package, so the environment must be able to access the relevant package registry.

Install with a LAN endpoint

If LM Studio runs on another computer on the same network, provide the endpoint when registering the MCP server:

claude mcp add houtini-lm -e HOUTINI_LM_ENDPOINT_URL=http://192.168.1.50:1234 -- npx -y @houtini/lm

Replace 192.168.1.50 with the actual LAN address of the model host. Do not copy the example unchanged unless that address genuinely belongs to your LM Studio computer.

Configuration for another MCP client

Houtini LM can also be launched by MCP clients that support a command-and-arguments server configuration. The essential process is npx with the arguments -y and @houtini/lm. A representative MCP configuration has this structure:

{
  "mcpServers": {
    "houtini-lm": {
      "command": "npx",
      "args": [
        "-y",
        "@houtini/lm"
      ]
    }
  }
}

Configuration file names, locations, environment-variable syntax, and reload behavior differ between MCP clients. Use the client's documented configuration mechanism rather than assuming that Claude Code's CLI command applies to every application.

Verify the local installation and delegation path

Verification should proceed one boundary at a time. Confirm the model first, then the Houtini LM process, and finally a real delegated task. This makes it easier to distinguish an MCP startup problem from an LM Studio connectivity or inference problem.

Houtini LM includes tools for general chat, structured prompts, and code-oriented work. Its documented design also provides response quality information so the orchestrating client can reason about conditions such as truncation, finish reason, detected thinking content, and estimated token use. These signals are useful, but they do not replace testing, code review, or validation against project requirements.

Use a deliberately simple first prompt

Your first request should make success or failure obvious. Give the model a short function and ask for a plain-language explanation, or provide a compact diff and ask for a draft commit message. State that the work should be delegated through Houtini LM. If the task is too broad, it becomes difficult to tell whether poor output comes from connectivity, model capability, insufficient context, or the task design itself.

Once the small test works, increase the workload gradually. Keep each delegated request self-contained. Houtini LM sends the supplied task to the model endpoint, so the backend does not automatically inherit Claude Code's entire conversation, unrestricted filesystem context, or all of Claude's tools.

Expose the remote LM Studio backend with Localtonet

Use this stage only after local or LAN delegation works. With Localtonet, the client on the model-host side establishes an outbound connection to one of our relay servers. This removes the need for inbound router port forwarding, a public IP address, VPN setup, or firewall changes solely to create the public tunnel.

The target is the LM Studio HTTP service, normally an IP address reachable from the Localtonet client and port 1234. The result is a public HTTPS URL. Houtini LM on the Claude Code computer then uses that URL through HOUTINI_LM_ENDPOINT_URL.

Available relay servers, regions, process types, and account capabilities can vary. Select them from the current Localtonet dashboard rather than copying a hardcoded server code or assuming that every option is included with every plan.

For the current dashboard workflow and available options, consult our Localtonet HTTP tunnel documentation. Exact custom-domain DNS instructions are not included here because they must be checked against the current dashboard and documentation.

Register Houtini LM with the tunnel URL

Use the same official installation pattern, replacing the endpoint value with the actual URL assigned to your running tunnel:

claude mcp add houtini-lm -e HOUTINI_LM_ENDPOINT_URL=https://your-assigned-hostname -- npx -y @houtini/lm

The hostname above is a placeholder, not a usable Localtonet address. Copy the real HTTPS URL from your tunnel configuration. Do not add an assumed path suffix unless Houtini LM or the backend documentation explicitly requires it.

A tunnel is available only while the selected Localtonet client is connected and that tunnel is running. LM Studio must also remain open, its model must remain loaded, and the model server must remain active. If any one of these components stops, remote inference will fail.

Security and operating practices for a remote model backend

An inference endpoint can consume substantial compute resources and may receive source code, prompts, diffs, documentation, or other project data. Treat it as a sensitive application interface rather than as a harmless development web page.

Minimize the exposed service

Point the tunnel only at the required LM Studio HTTP listener. Do not expose unrelated administration interfaces, file shares, remote desktops, or broad network services merely because they run on the same machine. The local target should be the narrowest address and port combination that supports the workflow.

Understand what data crosses the endpoint

A delegated request can include source code or other context necessary to complete the task. With a local LM Studio installation, inference remains on the model host, but the prompt still travels from the Houtini LM computer to that host. When a public tunnel connects separate networks, the request traverses that remote path. Decide whether the material is appropriate to transmit before delegating it.

Avoid placing secrets in prompts. Source files can contain API keys, connection strings, private certificates, customer information, or production credentials. Review the context supplied to a delegated task and remove sensitive values that the model does not need.

Operate the tunnel deliberately

Start the tunnel for the remote session and stop it when finished. Remember that a saved tunnel configuration is not necessarily running. Conversely, closing Claude Code does not necessarily stop a tunnel that remains active through the connected Localtonet client. Manage the two lifecycles separately.

Troubleshooting Houtini LM, LM Studio, and the tunnel

Claude Code cannot start Houtini LM

Recheck node --version in the same execution environment used by Claude Code. Houtini LM requires Node.js 22.5 or newer. Then confirm that npx --version succeeds and that the environment can obtain @houtini/lm. A shell where Node works does not guarantee that an application launched from a desktop icon inherits the same executable path.

The MCP server starts, but model requests fail

Confirm that LM Studio is still running, that a model is loaded, and that its server is active. Check the endpoint carefully. Use http://localhost:1234 only when LM Studio runs on the same computer as the Houtini LM process.

If the model is on another LAN computer, confirm that the address has not changed and that LM Studio accepts non-local connections. A service bound only to loopback cannot be reached through the host's LAN address.

The LAN endpoint works on the model host but not from Claude Code

Testing an address on the model host does not prove that another computer can reach it. Check that both devices have a valid route, that the selected address belongs to the correct interface, and that local security policy permits the connection. Do not disable broad firewall protections as a first response. Add only narrowly scoped access that is required and permitted by your environment.

The Localtonet URL does not respond

Work from the local service outward:

1. Confirm that LM Studio has a model loaded and its server is running.
2. Confirm that the Localtonet client device can reach the configured local target and port.
3. Confirm that the correct device token is connected.
4. Confirm that the tunnel was started, not merely created.
5. Confirm that the assigned public URL was copied exactly.
6. Confirm that the Localtonet client remains connected.

If the tunnel client runs on a different computer from LM Studio, 127.0.0.1 points to the tunnel client itself. In that topology, configure the local target with the LM Studio host's reachable LAN address.

Delegation works but the output is weak

Connectivity and answer quality are separate concerns. Make the task smaller, include the exact context required, state the desired output format, and ask for one well-defined result. A local model may be capable of drafting tests for one function but unreliable at planning a multi-module refactor.

Review the output for truncation and incomplete reasoning. Houtini LM provides quality metadata intended to help the orchestrator evaluate responses, but the final decision should still depend on tests and review. If a task repeatedly requires broad judgment, keep it with Claude instead of forcing delegation.

Requests time out or queue behind each other

A single-model server may not handle concurrent inference requests effectively. Houtini LM includes request serialization intended to prevent parallel calls from stacking timeouts against a single-model server. Long generations can still take time, especially on constrained hardware. Reduce the task size, output requirements, or model workload before assuming the network is at fault.

The workflow stopped after previously working

Check all independent lifecycle components. Claude Code must be able to launch npx, Houtini LM must have the intended endpoint configuration, LM Studio must be running with a loaded model, and the Localtonet client and tunnel must both be active for remote access. A restart, address change, model unload, or stopped tunnel can break an otherwise unchanged configuration.

Frequently asked questions