Lerne, wie du mit IBM Bob einen eigenen Model Context Protocol (MCP)-Server erstellst, der KI-Modelle mit externen Tools und Datenquellen verbindet. Behandelt werden Advanced-Modus, Freigabe-Workflow und MCP-Konfiguration in diesem praxisnahen Tutorial.

In diesem Tutorial verwendest du IBM Bob, um einen eigenen MCP-Server zu erstellen, der schreibgeschützten Zugriff auf arXiv bietet – ein Open-Access-Repository für wissenschaftliche Arbeiten. Optional kannst du den Server erweitern und in einen watsonx Orchestrate-KI-Agenten integrieren.

Das Model Context Protocol (MCP) ist ein offener Standard, der es großen Sprachmodellen (LLMs) ermöglicht, über eine einheitliche Client-Server-Architektur mit externen Tools, Datenquellen und Content-Repositories zu kommunizieren. Vor MCP benötigte jeder KI-Assistent eine eigene Integration für jedes externe Tool, mit Function Calling ohne Interoperabilität. MCP definiert stattdessen ein einheitliches JSON-RPC-2.0-Protokoll, das jeder MCP-Host nutzen kann, um sich mit jedem MCP-Server zu verbinden.

Voraussetzungen

Dieses Tutorial erstellt einen TypeScript-MCP-Server, der die arXiv-API abfragt. Vorkenntnisse in TypeScript oder MCP-Integration sind nicht erforderlich.

Für dieses Tutorial benötigst du:

IBM Bob IDE

Lade die IBM Bob-Anwendung herunter und installiere sie auf deinem Computer. Bob ist eine eigenständige IDE-Anwendung und keine Erweiterung.

Node.js

Installiere Node.js 22 oder höher, um den TypeScript-MCP-Server lokal zu erstellen und auszuführen.

Workspace einrichten

Starte IBM Bob, öffne das MCP-Einstellungsfenster und bereite ein Arbeitsverzeichnis für das Serverprojekt vor.

IBM Bob starten

Starte die IBM Bob-Anwendung auf deinem Computer.

Bob-Chat-Panel öffnen

Falls das Chat-Panel noch nicht geöffnet ist, klicke auf das Bob-Symbol neben der Navigationsleiste oder nutze die Tastenkombination Option + Command + B (Mac) oder Ctrl + Alt + B (Windows).

MCP-Einstellungsfenster öffnen

Klicke auf das Zahnrad-Symbol in der oberen rechten Ecke des Chat-Fensters und wähle dann MCP in der linken Seitenleiste.

Im MCP-Einstellungsfenster kannst du die Zugriffskontrolle verwalten, indem du Server aktivierst oder deaktivierst, bestimmte Tools automatisch genehmigst, und eigene Integrationen mit dem MCP SDK erstellst.

Global: Gespeichert in mcp_settings.json, gilt für alle Workspaces.
Projekt: Gespeichert in .bob/mcp.json im Projektstamm, per Versionskontrolle mit deinem Team teilbar. Einstellungen auf Projektebene überschreiben globale Einstellungen.

Automatische Genehmigung konfigurieren

Stelle im Bob-Chat sicher, dass die Berechtigungen für automatische Genehmigung direkt unterhalb des Chat-Eingabefelds auf „Read" (Lesen) gesetzt sind. Diese Konfiguration erlaubt Bob, deine Dateien und Verzeichnisinhalte einzusehen, während jeder Befehl vor der Ausführung deine Überprüfung und Genehmigung erfordert.

Projektverzeichnis öffnen

Wenn du ein bevorzugtes Verzeichnis für das Projekt hast, öffne es in der IDE. Du kannst Bob auch bitten, das im Chat-Fenster zu erledigen.

Virtuelle Python-Umgebung einrichten

Es ist üblich, virtuelle Python-Umgebungen zu erstellen, um die Abhängigkeiten eines Projekts zu isolieren und Konflikte zwischen verschiedenen Projekten zu vermeiden. Wechsle Bob in den Agent-Modus, den Modus, der Terminal-Befehle lesen, schreiben und ausführen kann, und erstelle dann die Umgebung.

Virtuelle Umgebung erstellen und aktivieren

Gib im Bob-Chat-Panel den folgenden Prompt ein:

In this directory, activate a Python virtual environment.

Bob führt eine Reihe von Terminal-Befehlen aus. Genehmige jeden Befehl, wenn du dazu aufgefordert wirst. Die Befehle erstellen eine neue virtuelle Umgebung im Verzeichnis venv/ und aktivieren sie.

Bauplan für den MCP-Server erstellen

In den Plan-Modus wechseln

Klicke auf die Schaltfläche direkt unterhalb des Chat-Eingabefelds, um den Interaktionsmodus auf Plan zu ändern. In diesem Modus kann Bob einen strukturierten Plan für den MCP-Server erstellen, bevor Code geschrieben wird.

Server-Anforderungen einreichen

Reiche mit aktiver virtueller Umgebung den folgenden Prompt bei Bob ein. Konkrete Anforderungen von Anfang an geben Bob genug Kontext, um einen vollständigen Plan zu formulieren, bevor Code geschrieben wird:

Create an MCP server named arxiv-server that provides read-only access to arXiv. The server should:
- Expose one tool, search_papers, for querying arXiv papers by keyword
- Accept a query string and an optional max_results parameter (default 5, max 20)
- Limit results to paper metadata and abstracts (no PDFs)
- Return title, authors, publication date, abstract, and arXiv URL for each result
- Normalize responses into a clean, structured JSON schema
- Handle API errors and empty results gracefully, returning a clear message instead of failing
- Use TypeScript/Node.js with the stdio transport
- Use the arXiv API v2, which requires no authentication

Bob erstellt eine strukturierte Aufgabenliste, die Projekt-Scaffolding, MCP-Server-Implementierung, Installation von Abhängigkeiten, Serverkonfiguration und Tests umfasst. Beachte, dass Bob automatisch Fehlerbehandlung und Authentifizierungsaspekte plant. Auch wenn die Ziel-API (arXiv) keinen Schlüssel benötigt, gibt Bob an, wo Anmeldedaten für Server injiziert werden, die einen erfordern.

Falls Bob Rückfragen stellt, beantworte sie so gut du kannst oder weise Bob an, vernünftige Annahmen zu treffen.

MCP-Server erstellen und überprüfen

Sobald du den Plan überprüft und genehmigt hast, wechsle in den Agent-Modus, um jeden Schritt auszuführen. Dein Ergebnis und die Reihenfolge können leicht vom folgenden Beispiel abweichen, da Bob Antworten in Echtzeit generiert.

Weise Bob an, den Server mit dem folgenden Prompt zu erstellen:

Implement the plan.

Zunächst erstellt Bob das Projektgerüst und führt mkdir -p arxiv-server/src aus, um das Projektverzeichnis anzulegen.

Als Nächstes generiert Bob arxiv-server/package.json, den Node.js-Konfigurationshub, der die Metadaten, Skripte und Abhängigkeiten des Projekts deklariert:

{
  "name": "arxiv-server",
  "version": "0.1.0",
  "description": "MCP server for read-only access to arXiv papers",
  "type": "module",
  "bin": {
    "arxiv-server": "./build/index.js"
  },
  "scripts": {
    "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
    "prepare": "npm run build",
    "watch": "tsc --watch"
  },
  "keywords": ["mcp", "arxiv", "research", "papers"],
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.0.4",
    "axios": "^1.7.9",
    "zod": "^3.24.1"
  },
  "devDependencies": {
    "@types/node": "^22.10.5",
    "typescript": "^5.7.3"
  }
}

Bob erstellt außerdem arxiv-server/tsconfig.json, um den TypeScript-Compiler zu konfigurieren:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./build",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,
    "declaration": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "build"]
}

Als Nächstes erstellt Bob die Hauptserver-Datei unter arxiv-server/src/index.ts. Diese Datei registriert das Tool search_arxiv beim MCP SDK, implementiert XML-zu-JSON-Parsing für arXiv-API-Antworten, erzwingt Ergebnislimits und startet den Server auf dem STDIO-Transport – dem lokalen, latenzarmen Transport-Typ, der für Server geeignet ist, die auf demselben Rechner wie der MCP-Host laufen.

Der server.tool()-Aufruf des MCP SDK ist der primäre Integrationspunkt. Er macht das Tool für jeden MCP-Client verfügbar.

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

interface ArxivEntry {
  id: string;
  title: string;
  summary: string;
  authors: Array<{ name: string }>;
  published: string;
  updated: string;
  categories: string[];
  primary_category: string;
  links: Array<{ href: string; rel: string; type?: string }>;
}

interface ArxivSearchResult {
  entries: ArxivEntry[];
  totalResults: number;
  startIndex: number;
  itemsPerPage: number;
}

const server = new McpServer({ name: "arxiv-server", version: "0.1.0" });

const arxivApi = axios.create({
  baseURL: 'http://export.arxiv.org/api',
  timeout: 30000,
});

server.tool(
  "search_arxiv",
  {
    query: z.string().describe("Search query (supports arXiv query syntax)"),
    max_results: z.number().min(1).max(50).optional()
      .describe("Maximum results to return (1–50, default: 10)"),
    start: z.number().min(0).optional()
      .describe("Starting index for pagination (default: 0)"),
    sort_by: z.enum(["relevance", "lastUpdatedDate", "submittedDate"]).optional(),
    sort_order: z.enum(["ascending", "descending"]).optional()
  },
  async ({ query, max_results = 10, start = 0, sort_by = "relevance", sort_order = "descending" }) => {
    try {
      const params: Record<string, string | number> = {
        search_query: query,
        start: Math.max(start, 0),
        max_results: Math.min(max_results, 50),
        ...(sort_by && { sortBy: sort_by }),
        ...(sort_order && { sortOrder: sort_order }),
      };
      const response = await arxivApi.get('/query', { params });
      return {
        content: [{ type: "text", text: formatSearchResults(parseArxivXML(response.data)) }],
      };
    } catch (error) {
      if (axios.isAxiosError(error)) {
        return {
          content: [{ type: "text", text: `arXiv API error: ${error.response?.data?.message ?? error.message}` }],
          isError: true,
        };
      }
      throw error;
    }
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);
console.error('arXiv MCP server running on stdio');

Das Flag isError: true im catch-Block ist das MCP-Standard-Fehlerbehandlungsmuster. Es signalisiert dem MCP-Client, dass der Tool-Aufruf fehlgeschlagen ist, ohne den Serverprozess zu beenden.

Als nächsten Schritt installiert Bob die Abhängigkeiten im Verzeichnis arxiv-server, indem er cd arxiv-server && npm install ausführt.

Server im Projektbereich registrieren

Bob registriert einen neuen Server nicht automatisch. Weise Bob an, ihn explizit hinzuzufügen, und gib den Projektbereich an, damit die Konfiguration in .bob/mcp.json gespeichert wird und über die Versionskontrolle mit deinem Team geteilt werden kann.

Bob anweisen, den Server zu registrieren

Gib im Bob-Chat-Panel den folgenden Prompt ein:

Register the arxiv-server as an MCP server at project scope. Build it first if needed, then add it to .bob/mcp.json.

Generierte Konfiguration überprüfen

Bob schreibt folgendes in .bob/mcp.json im Projektstamm. Die Felder command und args teilen dem MCP-Client mit, wie der Serverprozess über den STDIO-Transport gestartet wird.

{
  "mcpServers": {
    "arxiv-server": {
      "command": "node",
      "args": ["${workspaceFolder}/arxiv-server/build/index.js"]
    }
  }
}

Bestätigen, dass der Server geladen ist

Bob lädt die MCP-Konfiguration nach dem Schreiben dieser Datei automatisch neu. Öffne das MCP-Einstellungsfenster (Zahnrad-Symbol > MCP), um zu bestätigen, dass der arxiv-server aufgeführt und aktiviert ist, bevor du fortfährst. Falls er nicht erscheint, klicke auf das Neuladen-Symbol neben der Serverliste.

Bob neu starten

Starte Bob neu, damit der Server läuft und bereit ist, Anfragen entgegenzunehmen.

MCP-Server testen

Mit dem registrierten Server führt Bob automatisch zwei Validierungsabfragen gegen das Tool search_arxiv aus.

Die erste Abfrage sucht nach drei Quantum-Computing-Papieren, sortiert nach Relevanz. Die zweite sucht nach zwei Machine-Learning-Papieren, sortiert nach absteigendem Einreichungsdatum. Beide werden erfolgreich ausgeführt und bestätigen, dass das Tool erreichbar ist und die Fehlerbehandlung des Servers verschiedene Parameterkombinationen korrekt verwaltet.

Führe nun deine eigenen Abfragen durch, um zu überprüfen, dass Bob die richtigen Parameter aus natürlicher Sprache extrahiert. Ein Beispiel für einen Prompt im Bob-Chat-Panel:

What are the latest papers on LLM agent tracing?

Server dokumentieren

Open-Source-MCP-Server-Implementierungen enthalten in der Regel Dokumentation, damit andere schnell loslegen können. Bitte Bob, diese zu erstellen:

In this directory, create a README.md file to document this MCP server.
Include setup and usage instructions.

Bob erstellt eine umfassende README.md, die Installation, Konfiguration für mehrere MCP-Hosts (IBM Bob, Claude Desktop, Cursor, Claude Code), Authentifizierungshinweise für Server, die API-Schlüssel benötigen, Muster für den lokalen Dateizugriff und Tipps zur Fehlersuche abdeckt.

Ressourcen bereinigen

Dieses Tutorial erstellt lokale Dateien und eine Serverregistrierung. Entferne sie, wenn du den arXiv-MCP-Server nicht weiter verwenden möchtest.

Öffne das MCP-Einstellungsfenster in Bob (Zahnrad-Symbol > MCP) und deaktiviere oder lösche den Eintrag arxiv-server. Alternativ kannst du den Block arxiv-server direkt aus mcp_settings.json (globaler Bereich) oder .bob/mcp.json (Projektbereich) entfernen.

Nächste Schritte

In diesem Tutorial hast du IBM Bob verwendet, um einen TypeScript-MCP-Server zu erstellen, ihn mit STDIO-Transport zu konfigurieren und mit Live-arXiv-Abfragen zu testen – alles über natürliche Spracheingaben.

Derselbe Workflow gilt für komplexere MCP-Server-Implementierungen: Server, die sich mit Datenbanken, lokalen Dateien oder anderen externen Datenquellen verbinden. Server, die Authentifizierung benötigen, erfordern Anmeldedaten als Umgebungsvariablen in der MCP-Konfigurations-JSON. Für Remote-Deployments ersetze den STDIO-Transport durch SSE.

Erfahre mehr über Bobs Code-Review-Funktion, um Probleme vor dem Commit deines Server-Codes zu erkennen.

Erfahre mehr über Modi, um zu verstehen, wann Advanced, Code, Ask und andere Bob-Personas eingesetzt werden.

Erkunde die MCP-Konfiguration für Details zu globalem vs. Projektbereich, automatisch genehmigten Tools und SSE-Transport-Einrichtung.

Arbeite die Tutorial-Serie „Erste Schritte mit IBM Bob" durch, um weiter zu lernen.

MCP-Server mit IBM Bob erstellen