Skip to main content
Glama
lmstudio-ollama-mcp

lmstudio-ollama-mcp

by fthsrbst

lmstudio-ollama-mcp

npm install -g lmstudio-ollama-mcp
lmstudio-ollama-mcp doctor   # or: forge doctor
lmstudio-ollama-mcp "add unit tests for src/utils/logger.ts"

Lokal zuerst. Privat. Kostenlos. Keine API-Schlüssel erforderlich. Frontier-Modelle (GPT-4o, Claude 4) sind optional — sie werden nur als Planer eingesetzt, während kleine lokale Modelle die Arbeit erledigen. Der Alias forge / forgecode bewahrt das Muskelgedächtnis.


Warum lmstudio-ollama-mcp

Claude Code / Codex

lmstudio-ollama-mcp

Läuft auf

Cloud-API (kostenpflichtig, Daten verlassen den Rechner)

LM Studio · Ollama · llama.cpp (offline, privat)

Kosten

$ pro Token

$0 nach dem Modell-Download

Sub-Agenten

Single-threaded oder Cloud-Parallelität

Hardwarebewusste lokale Parallelität

Modellwahl

Herstellerabhängig

Beliebiges GGUF / OpenAI-kompatibles Modell

Hybrid-Modus

—

Frontier plant, lokale führen aus (optional)

Sandbox

Cloud-Container

Dein Dateisystem, deine Regeln

MCP

—

Bereit: Brücke lokaler Laufzeiten als MCP-Tools

In einem Satz: lmstudio-ollama-mcp bringt die agentische Schleife von Claude Code — lesen → planen → bearbeiten → verifizieren mit Tools — auf dein MacBook, mit einem intelligenten Router, der triviale Aufgaben an ein lokales 7B-Modell schickt und anspruchsvolles Denken nur bei Bedarf an ein Frontier-Modell.


Related MCP server: Shared Workspace MCP

Demo

# 1 — Diagnose
lmstudio-ollama-mcp doctor
# Hardware: Apple M3 (8 cores / 16GB) • Recommended: 8 agents
# ● lmstudio (LM Studio) http://localhost:1234/v1  available
#   models: gemma-3-12b-qat, qwen3-27b-ud-iq2_s …

lmstudio-ollama-mcp models
# ● lmstudio  ▸ gemma-3-12b-qat 6.5GB Q4_0
#             ▸ qwen3-27b 7.8GB IQ2_S

# 2 — One-shot
lmstudio-ollama-mcp "refactor src/providers into a registry + add tests. keep public API stable"

# 3 — Parallel (auto-splits into sub-agents)
lmstudio-ollama-mcp --parallel 4 "implement auth module, write tests, and update docs"
# forge alias also works:
forge --parallel 4 "implement auth module, write tests, and update docs"

# 4 — Force a specific model
lmstudio-ollama-mcp --model ollama:qwen2.5-coder:14b "explain this repo's error handling"
lmstudio-ollama-mcp --provider lmstudio --model gemma-3-12b "fix the failing test in tests/tools.test.ts"

# 5 — Interactive
lmstudio-ollama-mcp
# lmstudio-ollama-mcp> add dark mode to docs/index.html

Schnellstart

Voraussetzungen

  • Node.js >= 18

  • Eines davon:

    • LM Studio — Developer → Local Server → Start (Port 1234)

    • Ollama — ollama serve, dann ollama pull qwen2.5-coder:7b

    • llama.cpp — ./llama-server -m model.gguf --port 8080

Installation

npm install -g lmstudio-ollama-mcp
# aliases also available: forge, forgecode
# or one-off
npx lmstudio-ollama-mcp doctor

Erster Start

git clone https://github.com/your-org/your-project && cd your-project
lmstudio-ollama-mcp init   # creates lmstudio-ollama-mcp.json (also reads forgecode.json for compat)
lmstudio-ollama-mcp doctor # verify providers + hardware
lmstudio-ollama-mcp "list the codebase structure and suggest 3 small improvements"

Für den rein lokalen Modus sind keine API-Schlüssel nötig. Für den Hybrid-Modus (Frontier + lokal) folgende Umgebungsvariablen setzen:

export OPENAI_API_KEY=sk-...
export ANTHROPIC_API_KEY=sk-ant-...

Architektur

┌─────────────────────────────────────────────────────────┐
│  CLI  lmstudio-ollama-mcp "task"  •  doctor  •  models   │
│       aliases: forge, forgecode                         │
├─────────────────────────────────────────────────────────┤
│  Router  (strategy: auto | local-first | frontier-first)│
│  ├─ classify(prompt) → trivial | small | medium | large │
│  └─ thresholds.preferLocalFor: lint/format/test/search  │
├─────────────────────────────────────────────────────────┤
│  Orchestrator  (decompose → batch by deps → schedule)   │
│  ├─ Planner LLM decomposes goal → SubTasks[]            │
│  └─ Scheduler (hardware-aware p-limit, preserves order) │
├─────────────────────────────────────────────────────────┤
│  Agent Loop  (provider.chat ↔ tool executor)            │
│  ├─ Tools: read_file, write_file, edit_file, bash,      │
│  │        glob, grep, list_dir                           │
│  └─ Max 25 tool turns, exact-string edits               │
├─────────────────────────────────────────────────────────┤
│  Providers  (OpenAI-compatible)                         │
│  ├─ LM Studio  http://localhost:1234/v1  (+ fs scan)    │
│  ├─ Ollama     http://localhost:11434 (+ /api/tags)     │
│  ├─ llama.cpp  http://localhost:8080/v1                 │
│  └─ Frontier   OpenAI / Anthropic (optional)            │
├─────────────────────────────────────────────────────────┤
│  Hardware Detector  •  Scheduler                        │
│  cores × overcommit, free mem / perAgent → maxParallel │
│  Apple Silicon bonus, clamp 1..16                       │
└─────────────────────────────────────────────────────────┘

Datenfluss:

User prompt
  → Router.classify → pick provider+model (local for small, frontier for large)
  → If parallel & non-trivial: Orchestrator.decompose → 2-6 SubTasks
  → Scheduler.runAll(SubTasks) with maxParallel = f(cores, RAM)
  → Each SubTask → Agent(provider, model, ToolExecutor) → tool loop
  → Synthesis agent merges results
  → Final summary

Anbieter

Anbieter

Standard-URL

Erkennung

Hinweise

LM Studio

http://localhost:1234/v1

/v1/models + Scan ~/.lmstudio/models/**/*.gguf

Unterstützt reasoning_content (Gemma)

Ollama

http://localhost:11434

/api/tags nativ, Fallback /v1/models

ollama pull <model> erforderlich

llama.cpp

http://localhost:8080

/health + /v1/models

Beliebiges GGUF über llama-server

OpenAI

https://api.openai.com/v1

API

OPENAI_API_KEY setzen

Anthropic

https://api.anthropic.com

API

ANTHROPIC_API_KEY setzen

Alle Anbieter unterstützen OpenAI-kompatible Chat Completions mit tools (Function Calling). reasoning_content (Qwen/Gemma) wird automatisch normalisiert.

Benutzerdefinierten Endpunkt hinzufügen

// lmstudio-ollama-mcp.json
{
  "providers": {
    "my-local": { "type": "openai", "baseUrl": "http://192.168.1.10:1234/v1", "enabled": true }
  }
}

Parallele Sub-Agenten

Zerlegt komplexe Ziele in 2–6 unabhängige Teilaufgaben mithilfe eines Planungs-LLM (Frontier, falls verfügbar, sonst lokal). Die Ausführung wird durch die Hardware begrenzt:

// hardware/detector.ts — recommendParallelism()
cpuLimit = floor(cores * overcommit) - 1
memLimit = floor((totalGb*1024 - 2048) / perAgentMb)
maxParallel = min(cpuLimit, memLimit) + appleSiliconBonus
// clamp: 1..8 default, up to 16 on 64GB machines
lmstudio-ollama-mcp --parallel 8 "migrate codebase from Jest to Vitest"
# Decomposed:
#  t1 Explore & plan  →  search (routed to local 7B)
#  t2 Implement       →  code   (routed to local or frontier)
#  t3 Verify          →  test   (routed to local)
# Runner: Scheduler.runAll with p-limit = 8

Aufgaben mit dependsOn werden topologisch gebündelt — Batch N startet erst, nachdem N-1 abgeschlossen ist.

Freundlich zu lokalen Modellen: Triviale Aufgaben (lint, format, summarize, explain) werden immer lokal geroutet, unabhängig von der Strategie.


Konfiguration

Auflösung der Konfiguration: DEFAULT < ~/.lmstudio-ollama-mcp/config.json < ./lmstudio-ollama-mcp.json < Umgebungsvariablen.
Die alten ~/.forgecode/config.json- und forgecode.json/forge.json-Dateien werden weiterhin aus Kompatibilitätsgründen gelesen (der neue Pfad hat Vorrang).

lmstudio-ollama-mcp config --show   # resolved JSON
lmstudio-ollama-mcp config --path   # file locations
lmstudio-ollama-mcp init            # scaffold lmstudio-ollama-mcp.json

Referenz lmstudio-ollama-mcp.json

{
  "version": 1,
  "providers": {
    "lmstudio": { "type": "lmstudio", "baseUrl": "http://localhost:1234/v1", "enabled": true },
    "ollama":   { "type": "ollama",   "baseUrl": "http://localhost:11434",      "enabled": true },
    "llamacpp": { "type": "llamacpp", "baseUrl": "http://localhost:8080",       "enabled": true },
    "openai":   { "type": "openai",   "baseUrl": "https://api.openai.com/v1",   "apiKey": "sk-..." }
  },
  "router": {
    "strategy": "auto", // auto | local-first | frontier-first | local-only
    "frontierProvider": "openai",
    "frontierModel": "gpt-4o-mini",
    "thresholds": {
      "smallTaskMaxTokens": 2000,
      "preferLocalFor": ["lint","format","test","search","summarize","explain"]
    }
  },
  "hardware": {
    "maxParallelAgents": 4,      // auto if omitted
    "maxMemoryPerAgentMb": 1200,
    "cpuOvercommit": 1
  },
  "permissions": {
    "allowBash": true,
    "allowWriteOutsideWorkspace": false,
    "allowNetwork": true
  }
}

Strategien:

  • auto — trivial/klein → lokal, mittel/groß → Frontier, falls verfügbar, sonst lokal. (empfohlen)

  • local-first — nur mittel/groß geht an Frontier.

  • local-only — Frontier wird nie aufgerufen (air-gapped).

  • frontier-first — Frontier immer bevorzugen.


Werkzeuge

Agenten haben 7 Werkzeuge — dieselbe Oberfläche wie Claude Code, auf den Arbeitsbereich beschränkt:

Werkzeug

Beschreibung

read_file

Datei lesen (2-MB-Limit, sonst grep verwenden)

write_file

Datei erstellen/überschreiben (mkdir -p automatisch)

edit_file

Exakten String ersetzen (muss genau einmal vorkommen)

bash

Befehl ausführen (timeout 30s, 5-MB-Puffer)

glob

fast-glob-Suche

grep

Regex-Suche (überspringt node_modules/dist/.git)

list_dir

Verzeichnis auflisten

Sicherheit: Pfad-Ausbrüche werden blockiert, außer permissions.allowWriteOutsideWorkspace=true; gefährliche Befehle (rm -rf /) werden abgelehnt; große Ausgaben werden gekürzt (30k).


Vergleich: Wann welches Modell verwenden

Aufgabe

Warum lokal gewinnt

Beispiel

Lint / Format / grep

0,2 s vs. 2 s RTT

lmstudio-ollama-mcp "format src/**/*.ts with prettier"

Erklären / Zusammenfassen

Private Codebasis bleibt lokal

lmstudio-ollama-mcp "explain how auth works"

Kleine Änderungen

Keine Warteschlange, keine Kosten

lmstudio-ollama-mcp "add zod validation to src/config/schema.ts"

Großes Refactoring

Frontier plant, lokale führen parallel aus

lmstudio-ollama-mcp "migrate to ESM"

Anspruchsvolles Denken

70B / Frontier nötig

lmstudio-ollama-mcp --model openai:gpt-4o "design CRDT sync"


Entwicklung

npm install
npm run build        # tsc
npm test             # vitest
npm run dev -- doctor

Projektübersicht:

src/
  cli/            commander CLI + commands (doctor, models, config, init)
  config/         Zod schema + layered store (global ↔ project)
  hardware/       detector (cores/RAM/GPU) + p-limit scheduler
  providers/      base + openai-compatible + lmstudio/ollama/llamacpp + registry + router
  core/           Agent (tool loop) + Orchestrator (decompose + parallel)
  tools/          definitions + executor (fs/glob/grep/bash)
  utils/          logger, format
tests/            vitest suites (hardware, tools, router, config, providers)
docs/             GitHub Pages landing (WizardZ-inspired, lime/black)

Roadmap

  • Streaming-Ausgabe (--stream)

  • MCP-Server (Model Context Protocol) — lokale Modelle als MCP-Tools für andere Agenten bereitstellen

  • Persistenter Speicher (.lmstudio-ollama-mcp/memory.md)

  • lmstudio-ollama-mcp plan — Trockenlauf-Zerlegung ohne Ausführung

  • Vision-Modelle (Gemma 12B multimodal) für Screenshot-gesteuerte UI-Arbeit

  • hooks — Pre-/Post-Tool-Hooks

  • Windows- / Linux-GPU (CUDA/Vulkan) Scheduler-Hinweise


Mitwirken

PRs willkommen. Behalte die Kernprinzipien bei: lokal zuerst, minimale Abhängigkeiten, hardwarebewusst, kein KI-Schrott.

npm run build && npm test

Schlüsselwörter

lm-studio lmstudio ollama llama.cpp local-llm local-first coding-agent autonomous-agent claude-code codex sub-agents parallel-agents mcp model-context-protocol hardware-aware openai-compatible gguf agentic dev-tools ai-coding on-device-ai privacy


Lizenz

MIT — siehe LICENSE.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers