How to Install LM Studio Locally

Tool overview

LM Studio is a desktop app for running local language models without needing the command line. It combines a model browser, a chat interface, hardware settings, document chat, and a local API server in one app.

It is one of the easiest starting points for offline AI because you can search for models, download them, load them, adjust settings, and start a local server from a graphical interface.

Step-by-step setup

Step 1: Download and install LM Studio

Go to the official LM Studio downloads page and download the installer for your platform.

On Windows:

1. Download the Windows installer.
2. Run it.
3. Open LM Studio from the Start menu.

On macOS:

1. Download the macOS build for your chip.
2. Open the downloaded file.
3. Move LM Studio into Applications if prompted.
4. Launch the app.

On Linux:

1. Download the Linux build from LM Studio.
2. Make it executable if needed.
3. Launch it from your desktop environment or terminal.

For a normal user, there is no CLI step required.

Step 2: Download your first model

Open LM Studio and use the model search or discover area. Look for a model that fits your hardware.

For a first run, choose:

• A smaller instruct model instead of a very large one.
• A quantized model that fits comfortably in RAM or VRAM.
• A model with a clear license and model card.
• A model intended for chat or instruction following.

If you are unsure, start small. A model that fits well and responds reliably is more useful than a model that nearly crashes your machine.

Step 3: Load the model and chat offline

After the download finishes:

1. Select the model.
2. Load it into a chat.
3. Send a short test prompt.
4. Adjust context length only if you understand the memory cost.
5. Save any useful presets.

Once the model file is downloaded, normal chat can run locally. Features that require online search, downloads, or external services still need network access.

Step 4: Configure GPU acceleration

LM Studio usually detects available acceleration options and can automatically choose reasonable settings. You can also adjust GPU offload manually.

Use these practical rules:

• If the app is slow, try increasing GPU offload.
• If the model fails to load, reduce GPU offload or use a smaller model.
• If the system becomes unstable, reduce context length and model size.
• Keep GPU drivers current, especially on Windows.
• On Apple Silicon, unified memory is shared by the whole system, not reserved only for the model.

Do not force the largest possible model on a laptop just because it downloads successfully. Loading, context, and generation all use memory.

Step 5: Start the local API server

LM Studio can serve local models through API endpoints. In the app, open the developer or local server area, load a model, and start the server.

The common OpenAI-compatible base URL is:

http://localhost:1234/v1

Many tools expect an API key even when the local server does not need a real secret. In those cases, use a placeholder such as:

lm-studio

Example with the OpenAI Python SDK:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:1234/v1",
    api_key="lm-studio",
)

response = client.chat.completions.create(
    model="local-model",
    messages=[
        {"role": "user", "content": "Write a one-sentence test response."}
    ],
)

print(response.choices[0].message.content)

Use the model ID shown by LM Studio if your client requires an exact model name.

Step 6: Connect LM Studio to other local tools

Any app that supports OpenAI-compatible endpoints can often use LM Studio with:

Base URL: http://localhost:1234/v1
API key: lm-studio
Model: the loaded LM Studio model ID

This can work with local agent tools, code assistants, RAG apps, and custom scripts. The model must be loaded and the server must be running before the client connects.

If the other tool runs in Docker, use a host-reachable address instead of plain localhost. On Docker Desktop, that often means:

http://host.docker.internal:1234/v1

Step 7: Chat with local documents

LM Studio can attach documents to chats and use local document context. This is useful for asking questions about PDFs, notes, specs, and drafts without sending the document to a cloud model.

For best results:

• Start with one document.
• Use clear questions.
• Keep context size reasonable.
• Use a model strong enough for document reasoning.
• Watch memory use when attaching large files.

Document chat is local, but the quality still depends on parsing, context length, model capability, and the document itself.

Common problems

The model will not load

Use a smaller model, lower quantization memory requirements, reduce context length, or reduce GPU offload. Also check free disk space and system RAM.

LM Studio is slow

Try a smaller model, enable more GPU offload if available, close memory-heavy apps, and reduce context length.

The API server is unreachable

Make sure the server is started inside LM Studio and the model is loaded. Test:

curl http://localhost:1234/v1/models

If a Docker app needs to reach LM Studio on the host, use a host bridge address such as host.docker.internal.

CUDA or GPU acceleration does not work

Update GPU drivers and restart LM Studio. If acceleration still fails, run a smaller model on CPU first to confirm the app itself works.

Security notes

LM Studio is local-first, but a local server is still a server.

Use these rules:

• Keep the server bound to localhost for normal use.
• Do not expose port 1234 publicly.
• Only enable local network serving when you need another trusted device to connect.
• Be careful with documents that contain secrets.
• Check model licenses before commercial use.

Background, planning, and caveats

Approximate planning cost (U.S.)

LM Studio is free to run locally, but planning costs are still real:

• Hardware: desktop/laptop CPU, RAM, and VRAM requirements depend on model size.
• Storage: model files are large, and local prompts/chat caches can grow.
• Optional network/API costs: only when you add cloud models or external provider tooling.
• Optional managed alternatives: if you do not want to run local hardware, compare managed AI tools instead of a local LLM host.

For local-only workloads, this is usually the lowest-cost route; managed options are usually faster to scale but introduce subscription and usage charges.

Cost breakdown

• one-time local setup:
  • workstation or device upgrade,
  • local SSD space,
  • local backup destination.
• recurring local setup:
  • electricity and hardware maintenance,
  • optional API usage when calling external providers.

Data persistence and backups

Treat downloaded models and server config as deployable assets:

• keep DATA_DIR (if set) under versioned backup,
• export or back up model catalogs and preference profiles if they take time to rebuild,
• snapshot chat and document folders if they include work artifacts.

Credential handling

• Keep external provider keys out of desktop settings screens and scripts.
• Create separate client secrets per app when connecting LM Studio as an API backend.
• Rotate any generated placeholder API key values in environments where network access is enabled.

Security risk and operational cautions

• A local OpenAI-compatible endpoint is often considered internal only; binding to more than localhost increases risk.
• Document prompts may include sensitive text; review content policies before connecting external tools.
• Lock your local machine user account and keep auto-start settings intentional.

Questions before installing

• Do you need to serve many devices or just one machine?
• What model size can your memory and VRAM sustain under sustained load?
• Can you accept the rebuild cost if a model download is corrupted and needs re-download?

Red flags

• Ignoring minimum hardware guidance for your platform.
• Running unsupported CPU-only large models without a recovery path.
• Keeping production-like credentials in local test defaults.

Rollback and update guidance

For rollback:

• keep a clean backup of working model files and app settings,
• remove only one layer at a time when changing model/runtime configuration.

For updates:

• update LM Studio via app updates,
• re-test core prompts after model upgrades,
• keep known-good models installed for quick fallback when a new release changes behavior.

Bottom line

LM Studio is the easiest local LLM path for users who want a desktop app instead of terminal commands. Install the app, download a model that fits your hardware, load it, and start the local server only when another app needs API access. For OpenAI-compatible clients, use http://localhost:1234/v1.