Lokaler KI MCP-Server

1. Setup lokale KI (Ollama)

Zunächst benötigen wir ein lokales KI-Modell. Hierzu verwenden wir https://ollama.com/. Ollama ist eine Open-Source-Software, die es dir ermöglicht, LLMs lokal auf deinem Rechner laufen zu lassen — ohne Cloud, ohne Registrierung.

Das Setup ist denkbar einfach. Zuallererst müssen wir Ollama herunterladen, installieren und starten: https://ollama.com/download.

Nun öffnen wir ein neues Terminal und führen das Modell qwen3:30b aus. Für das Testen, ob die Installation erfolgreich war, kann man auch jedes andere Modell ausführen: ollama run <model>. Eine Liste der Ollama-Modelle gibt es hier.

Ich habe mich für das qwen3:30b-Modell entschieden, da es Tool-Calls unterstützt und wir das für unseren MCP-Server benötigen.

Hinweis: qwen3:30b benötigt eine starke GPU / viel RAM.

Auf schwächerer Hardware empfiehlt sich z. B. qwen3:0.6b.

ollama run qwen3:0.6b

Wenn Ollama läuft, solltet ihr einen Chatbot im Terminal sehen:

ollama run qwen3:30b
>>> Send a message (/? for help)

Um das Ganze zu testen, starten wir eine einfache Anfrage:

"""Übersetze mir folgende Sprichwörter und Wörter wortwörtlich ins Englische:
- Das ist nicht das Gelbe vom Ei
- Fuchsteufelswild
- Ich glaube, mein Schwein pfeift.
- Holla, die Waldfee!"""

Ergebnis:

- That is not the yellow from the egg
- Fox devil wild
- I believe, my pig whistles
- Holla, the forest fairy

Das funktioniert also schon mal.

Hinweis: """ zeigt dem Modell, dass wir einen mehrzeiligen Input übergeben möchten, bevor die Anfrage gelesen wird.

Da wir jetzt wissen, dass unser Modell funktioniert, können wir den Chat mit /bye beenden.

---

2. Setup Chat-Interface (Tome)

Ein Chatbot in der Konsole ist zwar praktisch, aber umständlich. Für mehrzeilige Eingaben müssen wir """ verwenden, und wir müssen uns selbst um den MCP-Client kümmern — also denjenigen, der unsere MCP-Server konsumiert und das MCP-Protokoll erfüllt.

Hier kommt Tome ins Spiel. Tome ist ebenfalls Open-Source und bietet eine Chat-Oberfläche, die mit unserer lokalen KI funktioniert. Außerdem können wir unsere MCP-Server mit einer einfachen Konfiguration einbinden.

https://gettome.app/

Zuerst installieren wir Tome über die Website. Nach der Installation starten wir die App. Tome findet die installierten Ollama-Modelle automatisch im Hintergrund und wählt eines aus.

Damit ist Tome installiert — jetzt können wir unseren MCP-Server aufsetzen.

---

3. MCP-Server

Wir haben jetzt unsere lokale KI und unser lokales Chat-Interface. Nun geben wir unserem Chatbot neue Funktionalität über einen MCP-Server.

KIs können vieles, aber sie sind an ihre Trainingsdaten gebunden — das heißt, sie können z. B. das aktuelle Wetter nicht herausfinden (außer sie verfügen über einen MCP-Server, der ihnen ermöglicht, das Web zu durchsuchen). Neben Ereignissen, von denen eine KI keine Kenntnis haben kann, fallen ihr manchmal triviale Aufgaben überraschend schwer.

Fragen wir zum Beispiel unseren Chatbot:

Wie oft kommt der Buchstabe t in dem Wort 'Ratttattta' vor?

Kommt er meistens auf eine falsche Lösung. In meinem Fall:

Der Buchstabe "t" kommt in dem Wort "Ratttattta" 5 Mal vor.

Begründung:
R - a - t - t - t - a - t - t - a
→ Die Buchstaben t befinden sich an den Positionen 3, 4, 5, 7 und 8.

Antwort: 5

Um das Problem des Buchstabenzählens zu lösen, setzen wir dafür einen MCP-Server auf.

Das ist definitiv Overkill für dieses Problem und hat wenig mit echten Anwendungsfällen zu tun — aber es verdeutlicht, wozu MCP-Server da sind: der KI neue Funktionalität zu geben. Sei es Buchstaben zählen, automatisch Bestellungen anlegen, Daten aus Datenbanken ziehen und verarbeiten und vieles mehr.

---

3.1 Projektstruktur

Für den MCP-Server setzen wir ein einfaches TypeScript-Projekt mit folgender Struktur auf:

letter-counting-mcp-server/
├── src/
│   └── index.ts
├── package.json
├── tsconfig.json

3.2 Code

index.ts

Die folgende Datei erzeugt zunächst einen MCP-Server, registriert anschließend ein Tool zum Zählen von Buchstaben und stellt diesen Server dann über Standard-Ein und -Ausgabe bereit.

#!/usr/bin/env node
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

// MCP Server erstellen
const server = new McpServer({
  name: "letter-counting-mcp-server",
  version: "1.0.0",
  description: "MCP server for counting letters in words",
});

// Tool registrieren
server.registerTool(
  "count_specific_letter",
  {
    title: "Count Specific Letter",
    description:
      "Count how many times a specific letter appears in a word (case-insensitive)",
    inputSchema: {
      word: z.string().min(1).describe("The word to search in"),
      letter: z.string().length(1).describe("The letter to count"),
    },
  },
  async ({ word, letter }) => {
    let count = 0;
    const lowerCaseLetter = letter.toLowerCase();

    for (const char of word.toLowerCase()) {
      if (char === lowerCaseLetter) count++;
    }

    return {
      content: [
        {
          type: "text",
          text: `The letter "${letter}" appears ${count} time(s) in the word "${word}".`,
        },
      ],
    };
  }
);

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
}

main().catch((error) => {
  console.error("Failed to start Letter Counting MCP Server:", error);
  process.exit(1);
});

Der Server wird hier über StdioServerTransport gestartet. Die Kommunikation läuft also über die Standard-Ein und -Ausgabe des Prozesses. Diese Methode eignet sich hervorragend für lokale Integrationen, CLI-Tools und schnelle Experimente, da sie keinerlei Netzwerk-Konfiguration benötigt.

package.json

{
  "name": "letter-counting-mcp-server",
  "version": "1.0.0",
  "description": "A TypeScript MCP server that provides letter counting functionality for words",
  "main": "dist/index.js",
  "type": "module",
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js",
    "watch": "tsx watch src/index.ts"
  },
  "devDependencies": {
    "@types/node": "^24.9.2",
    "tsx": "^4.0.0",
    "typescript": "^5.0.0"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.0.0",
    "zod": "^3.22.0"
  }
}

tsconfig.json

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "node",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "outDir": "./dist",
    "rootDir": "./src"
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

Zum Initialisieren und bauen des Projekts müssen wir einmal die Abhängigkeiten installieren und den Code zu JavaScript kompilieren.

cd <pfad/zum/mcp/server>
npm install
npm run build

4. MCP-Server in Tome einbinden

Nachdem der Code erstellt und kompiliert wurde, öffnen wir Tome und navigieren zum Bereich für MCP-Server. Dort fügen wir einen neuen Eintrag hinzu und tragen den Befehl ein, mit dem unser kompiliertes Skript gestartet wird:

node <pfad/zum/mcp/server>/dist/index.js

Tome erkennt den Server und stellt alle Funktionen, die der Server anbietet, im Chat zur Verfügung.

---

5. Test

Um unseren Server mit unserem LLM zu testen, führen wir folgenden Prompt aus:

Wie oft kommt der Buchstabe t in dem Wort 'Ratttattta' vor? Benutze den letter counting mcp server.

Es ist wichtig, das Modell explizit anzuweisen, das Tool zu verwenden, da es die Aufgabe sonst selbst lösen möchte. Mit aktivem Tool-Aufruf wird die Anfrage korrekt verarbeitet und der MCP-Server übernimmt die Zählung.

6. Fazit

Wir haben nun einen lokalen MCP-Server erstellt, der einem Sprachmodell zusätzliche Funktionalität bereitstellt, und diesen Server in eine lokale Chat-Umgebung eingebunden.

Obwohl unser Beispiel bewusst einfach gewählt ist, lässt sich das Prinzip problemlos auf deutlich komplexere Aufgaben übertragen. Diese Architektur erlaubt es, Sprachmodelle gezielt zu erweitern, ohne sensible Daten einem externen Cloud-Dienst anvertrauen zu müssen.

Insbesondere in Umgebungen, in denen Datenschutz und lokale Kontrolle eine zentrale Rolle spielen, bietet dieser Ansatz eine flexible und sichere Grundlage für den Einsatz moderner KI-Systeme.

Zudem wird es dadurch möglich, klar definierte Prozesse über natürliche Sprache zu steuern, was sowohl die Bedienbarkeit als auch die Automatisierung interner Abläufe erheblich erleichtert.