Qwen Code über MCP mit Tools verbinden

Qwen Code kann über das Model Context Protocol (MCP)  mit externen Tools und Datenquellen verbunden werden. MCP-Server gewähren Qwen Code Zugriff auf deine Tools, Datenbanken und APIs.

Was du mit MCP machen kannst

Mit verbundenen MCP-Servern kannst du Qwen Code bitten:

• Mit Dateien und Repos zu arbeiten (lesen/suchen/schreiben, abhängig von den aktivierten Tools)
• Datenbanken abzufragen (Schema-Inspektion, Queries, Reporting)
• Interne Dienste zu integrieren (deine APIs als MCP-Tools kapseln)
• Workflows zu automatisieren (wiederkehrende Aufgaben als Tools/Prompts bereitstellen)

Schnellstart

Qwen Code lädt MCP-Server aus mcpServers in deiner settings.json. Du kannst Server auf zwei Arten konfigurieren:

• Durch direktes Bearbeiten von settings.json
• Durch Verwendung von qwen mcp-Befehlen (siehe CLI-Referenz)

Füge deinen ersten Server hinzu

1. Füge einen Server hinzu (Beispiel: Remote-HTTP-MCP-Server):

qwen mcp add --transport http my-server http://localhost:3000/mcp

2. Öffne den MCP-Verwaltungsdialog, um Server anzuzeigen und zu verwalten:

qwen mcp

3. Starte Qwen Code im selben Projekt neu (oder starte es, falls es noch nicht läuft) und fordere das Modell dann auf, Tools von diesem Server zu verwenden.

Wo die Konfiguration gespeichert wird (Scopes)

Die meisten Nutzer benötigen nur diese beiden Scopes:

• Projekt-Scope (Standard): .qwen/settings.json im Projektstammverzeichnis
• User-Scope: ~/.qwen/settings.json für alle Projekte auf deinem Rechner

In den User-Scope schreiben:

qwen mcp add --scope user --transport http my-server http://localhost:3000/mcp

Server konfigurieren

Transport wählen

Konfiguration über settings.json vs. qwen mcp add

Beide Ansätze erzeugen dieselben mcpServers-Einträge in deiner settings.json – verwende die Methode, die dir besser gefällt.

Stdio-Server (lokaler Prozess)

JSON (.qwen/settings.json):

{
  "mcpServers": {
    "pythonTools": {
      "command": "python",
      "args": ["-m", "my_mcp_server", "--port", "8080"],
      "cwd": "./mcp-servers/python",
      "env": {
        "DATABASE_URL": "$DB_CONNECTION_STRING",
        "API_KEY": "${EXTERNAL_API_KEY}"
      },
      "timeout": 15000
    }
  }
}

CLI (schreibt standardmäßig in den Projekt-Scope):

qwen mcp add pythonTools -e DATABASE_URL=$DB_CONNECTION_STRING -e API_KEY=$EXTERNAL_API_KEY \
  --timeout 15000 python -m my_mcp_server --port 8080

HTTP-Server (Remote-Streamable-HTTP)

JSON:

{
  "mcpServers": {
    "httpServerWithAuth": {
      "httpUrl": "http://localhost:3000/mcp",
      "headers": {
        "Authorization": "Bearer your-api-token"
      },
      "timeout": 5000
    }
  }
}

CLI:

qwen mcp add --transport http httpServerWithAuth http://localhost:3000/mcp \
  --header "Authorization: Bearer your-api-token" --timeout 5000

SSE-Server (Remote-Server-Sent-Events)

JSON:

{
  "mcpServers": {
    "sseServer": {
      "url": "http://localhost:8080/sse",
      "timeout": 30000
    }
  }
}

CLI:

qwen mcp add --transport sse sseServer http://localhost:8080/sse --timeout 30000

Sicherheit und Kontrolle

Trust (Bestätigungen überspringen)

• Server-Trust (trust: true): Umgeht Bestätigungsabfragen für diesen Server (sparsam verwenden).

OAuth-Authentifizierung

Qwen Code unterstützt OAuth 2.0-Authentifizierung für MCP-Server. Dies ist nützlich beim Zugriff auf Remote-Server, die eine Authentifizierung erfordern.

Grundlegende Verwendung

Wenn du einen MCP-Server mit OAuth-Credentials hinzufügst, verwaltet Qwen Code den Authentifizierungsablauf automatisch:

qwen mcp add --transport sse oauth-server https://api.example.com/sse/ \
  --oauth-client-id your-client-id \
  --oauth-redirect-uri https://your-server.com/oauth/callback \
  --oauth-authorization-url https://provider.example.com/authorize \
  --oauth-token-url https://provider.example.com/token

Wichtig: Konfiguration der Redirect-URI

Der OAuth-Ablauf erfordert eine Redirect-URI, an die der Autorisierungsanbieter den Authentifizierungscode sendet.

• Lokale Entwicklung: Standardmäßig verwendet Qwen Code http://localhost:7777/oauth/callback. Dies funktioniert, wenn Qwen Code auf deinem lokalen Rechner mit einem lokalen Browser ausgeführt wird.

• Remote-/Cloud-Deployments: Wenn Qwen Code auf Remote-Servern, Cloud-IDEs oder Webterminals läuft, funktioniert die standardmäßige localhost-Redirect-URI nicht. Du MUSST --oauth-redirect-uri so konfigurieren, dass es auf eine öffentlich zugängliche URL verweist, die den OAuth-Callback empfangen kann.

Beispiel für Remote-Server:

qwen mcp add --transport sse remote-server https://api.example.com/sse/ \
  --oauth-redirect-uri https://your-remote-server.example.com/oauth/callback

Manuelle Konfiguration über settings.json

Du kannst OAuth auch konfigurieren, indem du settings.json direkt bearbeitest:

{
  "mcpServers": {
    "oauthServer": {
      "url": "https://api.example.com/sse/",
      "oauth": {
        "enabled": true,
        "clientId": "your-client-id",
        "clientSecret": "your-client-secret",
        "authorizationUrl": "https://provider.example.com/authorize",
        "tokenUrl": "https://provider.example.com/token",
        "redirectUri": "https://your-server.com/oauth/callback",
        "scopes": ["read", "write"]
      }
    }
  }
}

OAuth-Konfigurationseigenschaften:

Token-Verwaltung

OAuth-Tokens werden automatisch:

• Sicher gespeichert in ~/.qwen/mcp-oauth-tokens.json
• Aktualisiert, wenn sie abgelaufen sind (falls Refresh-Tokens verfügbar sind)
• Validiert vor jedem Verbindungsversuch

Verwende den Befehl /mcp auth innerhalb von Qwen Code, um die OAuth-Authentifizierung interaktiv zu verwalten.

Tool-Filterung (Tools pro Server erlauben/verweigern)

Verwende includeTools / excludeTools, um die von einem Server bereitgestellten Tools einzuschränken (aus Sicht von Qwen Code).

Beispiel: Nur wenige Tools einschließen:

{
  "mcpServers": {
    "filteredServer": {
      "command": "python",
      "args": ["-m", "my_mcp_server"],
      "includeTools": ["safe_tool", "file_reader", "data_processor"],
      "timeout": 30000
    }
  }
}

Globale Allow-/Deny-Listen

Das mcp-Objekt in deiner settings.json definiert globale Regeln für alle MCP-Server:

• mcp.allowed: Allow-Liste von MCP-Servernamen (Keys in mcpServers)
• mcp.excluded: Deny-Liste von MCP-Servernamen

Beispiel:

{
  "mcp": {
    "allowed": ["my-trusted-server"],
    "excluded": ["experimental-server"]
  }
}

Fehlerbehebung

• Server zeigt „Disconnected“ in qwen mcp list an: Überprüfe, ob die URL/das Befehl korrekt ist, und erhöhe dann timeout.
• Stdio-Server startet nicht: Verwende einen absoluten command-Pfad und überprüfe cwd/env erneut.
• Umgebungsvariablen in JSON werden nicht aufgelöst: Stelle sicher, dass sie in der Umgebung existieren, in der Qwen Code läuft (Shell- und GUI-App-Umgebungen können sich unterscheiden).

Referenz

settings.json-Struktur

Serverspezifische Konfiguration (mcpServers)

Füge ein mcpServers-Objekt zu deiner settings.json-Datei hinzu:

// ... file contains other config objects
{
  "mcpServers": {
    "serverName": {
      "command": "path/to/server",
      "args": ["--arg1", "value1"],
      "env": {
        "API_KEY": "$MY_API_TOKEN"
      },
      "cwd": "./server-directory",
      "timeout": 30000,
      "trust": false
    }
  }
}

Konfigurationseigenschaften:

Erforderlich (eine der folgenden):

Optional:

MCP-Server mit qwen mcp verwalten

Du kannst MCP-Server immer durch manuelles Bearbeiten von settings.json konfigurieren, aber die CLI ist in der Regel schneller.

Server hinzufügen (qwen mcp add)

qwen mcp add [options] <name> <commandOrUrl> [args...]

--oauth-*-Flags gelten nur für --transport sse und --transport http. Eine Kombination mit --transport stdio wird abgelehnt.

Server entfernen (qwen mcp remove)

qwen mcp remove <name>