DEV Community: udiko

How to Run OpenHands with a Local LLM Using LM Studio

udiko — Mon, 14 Apr 2025 01:46:09 +0000

This guide will walk you through how to run OpenHands locally and integrate it with LM Studio, a local language model interface. This setup lets you use OpenHands with an offline LLM, giving you a privacy-friendly and powerful AI development environment.

What is OpenHands?

OpenHands is a visual development tool for building AI workflows, agents, and automation systems. It offers an intuitive UI to define complex AI interactions without writing code.

What is LM Studio?

LM Studio is a desktop app that allows you to run large language models (LLMs) locally on your machine using GGUF (GPT-style) models. It supports models like Mistral, Qwen, Llama, etc., and exposes an OpenAI-compatible API to use those models with other apps.

Why Run Both OpenHands and LM Studio Locally?

Running both tools locally offers multiple advantages, especially in privacy-sensitive or regulated environments:

Data Privacy & Security
Your prompts, code, and data never leave your machine—essential when working with confidential or proprietary information.
Compliance with Security Policies
Some organizations do not allow sending code, user data, or logs to external APIs like OpenAI or Anthropic. Local setup helps you stay compliant.
Offline Development
You can work without internet access, which is helpful in restricted environments or when on the move.
Cost
There's no pay-per-token usage.
Custom Model Control
You can run models fine-tuned to your needs and switch between different LLMs as required.

Prerequisites

Make sure you have the following installed:

Docker Desktop
LM Studio (latest version recommended)
A modern GPU or strong CPU for running large models locally (depending on your chosen model). In this guide, I'm using a MacBook Pro with an M1 Max chip and 32GB of RAM.

Step-by-Step Setup

1. Create the Docker Compose file for running OpenHands locally

Create a file named docker-compose.yml with the following content:

version: "3.8"

services:
  openhands-app:
    image: docker.all-hands.dev/all-hands-ai/openhands:0.32
    container_name: openhands-app
    environment:
      SANDBOX_RUNTIME_CONTAINER_IMAGE: docker.all-hands.dev/all-hands-ai/runtime:0.32-nikolaik
      LOG_ALL_EVENTS: "true"
    ports:
      - "3000:3000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ~/.openhands-state:/.openhands-state
    extra_hosts:
      - "host.docker.internal:host-gateway"
    restart: unless-stopped
    pull_policy: always

2. Start OpenHands

Run the following command in your terminal from the same directory as the docker-compose.yml file:

docker compose up

After a few moments, OpenHands will be running locally.

3. Open the OpenHands UI

Visit the following URL in your browser:

http://localhost:3000

Connect OpenHands to LM Studio

Once OpenHands is running, you’ll need to configure it to use LM Studio as your local LLM provider. Lets install LLM first.

4. Install a Compatible LLM in LM Studio

In LM Studio:

Go to the "Models" tab.
Install a model with good coding capabilities. For Mac with 32GB a good one is: qwen2.5-coder-14b-instruct
Once installed, increase the context length to 16384 tokens in the model settings.
Start the model and ensure it’s running on the OpenAI-compatible local server (default port is 1234).

5. Configure the LLM Provider in OpenHands

In OpenHands:

Click on your avatar or settings menu.
Go to "LLM Providers".
Click "Advanced".
Custom Model: lm_studio/qwen2.5-coder-14b-instruct OR follow the guide here to configure it: LiteLLM - LM Studio Setup
Base URL: http://LOCAL_IP:1234/v1 This tells the OpenHands container to connect to LM Studio running on your host machine.
Click save.

6. Authenticate with GitHub (If Using a Repo)

To pull a repo into OpenHands:

Go to the settings and connect your GitHub account.
Add a GitHub Personal Access Token with appropriate read access.

7. Create a Project in OpenHands

Go back to the main dashboard.
Click “New Project”.
Select a repository (if applicable).
Open the workspace and start building with your offline LLM!

Final Thoughts

OpenHands is in Early Stages:
OpenHands is still in its early development stages. While it's a promising tool, don’t expect a fully polished experience just yet. You may encounter occasional bugs or limitations as new features are added and refined.
Local LLM Limitations:
While running an LLM locally gives you more privacy and control, the performance and sophistication of locally-run models may not match the capabilities of cloud-based models like OpenAI or Anthropic. For tasks requiring advanced reasoning or up-to-date knowledge, cloud-based services might still be the better choice.
Start Small with Clear Tasks:
It's best to focus on small, well-defined tasks when working with OpenHands and local LLMs. This helps avoid overwhelming the system and ensures that you can iterate and test your workflows more efficiently.

vscode recommended extensions

udiko — Tue, 24 May 2022 18:35:01 +0000

docx to pdf with Node.js

udiko — Thu, 28 Apr 2022 13:03:30 +0000

Most of the npms didnt works for me but this one do the job:

npm i convert-multiple-files

convert.ts:

import { convertWordFiles } from 'convert-multiple-files';

const docToPdf = async (filePath: string, outputDir: string): Promise<string> => await convertWordFiles(filePath, 'pdf', outputDir);

export {
    docToPdf
};

const outputFile = await docToPdf('file.docx', './outFolder');

Migrate to typescript

udiko — Sat, 23 Apr 2022 17:41:50 +0000

To add typescript first you need to install the package

npm i typescript -g

Run tsc -v to see the typescript version

Add configuration file tsconfig.json to root folder of the project

{
    "compilerOptions": {
      "outDir": "./built",
      "allowJs": true,
      "target": "es5"
    },
    "include": ["./src/**/*", "./tests/**/*"]
}

In this example the build includes src & tests folder, support commonjs and allow js files

Run tsc from console, after few seconds you will see the output files under built folder

Remove this folder from git by adding built to .gitignore file.

The built folder also annoying you on search, navigation etc.
Its better to remove it from vs code by adding

 "files.exclude": {
        "built/": true
    }

to .vscode/settings.json file

Now, you can start convert your files gradually:

Take one js file from your project & change the extension to ts (or tsx for jsx).

Add ts syntax to the file to be sure you running right. For example:

const testFunc = async (name) => {

to:

const testFunc = async (name: string) => {

run tsc to see the output file

Under development its better to run watcher that convert the ts files on-the-fly.

In vs code press CTRL+SHIFT+B to choose one of the option:
tsc: build and tsc: watch

You can watch the code and run in under built folder.

For build/tests configuration change the path to built in package.json file.

Adding serverless support

If you are using sls to deploy the project Add this plugin to the project:

Serverless Typescripts plugin

Put - serverless-plugin-typescript at the top of plugins section: The order matter!

One disadvantage for putting rendered js files on aws lambda its that you cant edit the code on Lambda Code source section.

Converting Mocha framework to typescript

install npm i --save-dev @types/mocha

Add for each test file import 'mocha'; so typescript will know describe, it etc.

ESLint

You will have to run npm init @eslint/config again for supporting typescript

Example of config file .eslintrc.json:

{
    "env": {
        "es2021": true,
        "node": true
    },
    "extends": [
        "airbnb-base"
    ],
    "parser": "@typescript-eslint/parser",
    "parserOptions": {
        "ecmaVersion": "latest",
        "sourceType": "module"
    },
    "plugins": [
        "@typescript-eslint"
    ],
    "rules": {
        "linebreak-style": "off",
        "import/extensions": "off",
        "import/no-unresolved": "off",
        "comma-dangle": "off",
        "indent": ["error", 4],
        "no-plusplus": "off",
        "no-promise-executor-return": "off",
        "no-await-in-loop": "off",
        "import/prefer-default-export": "off",
        "lines-between-class-members": "off",
        "max-len": ["error", 150]
    }
}

And adding to package.json:

"scripts": {
    "lint": "eslint src/**/*.ts"
  }

Running npm run lint should execute the eslint with typescript support.

Debugging typescript

Very useful tool is ts-node

npm i -D ts-node

Running ts-node index.ts will compile it on the fly & debugging act like regular javaScript

Copy Non JS files

tsc will copy only js/ts files so if your project includes other files (xml, json etc.) you need to explicitly copy it:

you can use npm for copy files:

npm i -D copyfiles

and adding post build stage:


"scripts": {
    "build": "tsc",
    "copyNonJsFiles": "copyfiles --error ./src/**/*.xml ./dist",
    "postbuild": "npm run copyNonJsFiles",
  }

postbuild will run automatically after tsc

Debug mocha tests with vscode

udiko — Thu, 03 Feb 2022 10:40:33 +0000

To debug mocha.js in vscode select run & debug

If you dont have launch.json file press create a launch.json file for creating it.

Press add configuration

Select Mocha Tests

The json should looks like:

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "args": [
                "-u",
                "tdd",
                "--timeout",
                "999999",
                "--colors",
                "${workspaceFolder}/test"
            ],
            "internalConsoleOptions": "openOnSessionStart",
            "name": "Mocha Tests",
            "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
            "request": "launch",
            "skipFiles": [
                "<node_internals>/**"
            ],
            "type": "pwa-node"
        },

        {
            "type": "pwa-node",
            "request": "launch",
            "name": "Launch Program",
            "skipFiles": [
                "<node_internals>/**"
            ],
            "program": "${file}"
        }
    ]
}

Add to "args":

"--file", "${workspaceFolder}/test-folder/setup.js", "${workspaceFolder}/test-folder/**/*.spec.js",

and run

If you get Process exited with code 1 remove the

    "--require",
    "esm",

DEV Community: udiko

How to Run OpenHands with a Local LLM Using LM Studio

What is OpenHands?

What is LM Studio?

Why Run Both OpenHands and LM Studio Locally?

Prerequisites

Step-by-Step Setup

1. Create the Docker Compose file for running OpenHands locally

2. Start OpenHands

3. Open the OpenHands UI

Connect OpenHands to LM Studio

4. Install a Compatible LLM in LM Studio

5. Configure the LLM Provider in OpenHands

6. Authenticate with GitHub (If Using a Repo)

7. Create a Project in OpenHands

Final Thoughts

vscode recommended extensions

ESLint

Path Intellisense

Prettier

docx to pdf with Node.js

Migrate to typescript

Adding serverless support

Converting Mocha framework to typescript

ESLint

Debugging typescript

Copy Non JS files

Debug mocha tests with vscode