Postmans Model Context Protocol (MCP) Server Integration mit GitHub Copilot und CLI

Die Welt der KI entwickelt sich rasant weiter und mit ihr die Art und Weise, wie wir mit APIs und Infrastrukturen interagieren. Bei Infralovers freuen wir uns darauf, zu erforschen, wie die neuen MCP-Server (Model Context Protocol) von Postman die Art und Weise revolutionieren können, wie wir KI in unsere Infrastruktur-Management-Tools integrieren, insbesondere mit GitHub Copilot und Command-Line-Interfaces (CLI).

Was ist das Model Context Protocol (MCP)?

Das Model Context Protocol ist ein offener Standard, der KI-Systemen ermöglicht, sicher auf externe Datenquellen und Tools zuzugreifen und mit ihnen zu interagieren. Stellen Sie es sich als universellen Übersetzer vor, der KI-Modellen wie GitHub Copilot ermöglicht, Ihre spezifischen Tools, APIs und Datenquellen in Echtzeit zu verstehen und mit ihnen zu arbeiten.

MCP-Server fungieren als Vermittler, die standardisierte Schnittstellen für KI-Systeme bereitstellen, um mit verschiedenen Services zu interagieren – von Cloud-Infrastruktur-Anbietern wie HCP Terraform (früher als Terraform Cloud bekannt) bis hin zu Container-Orchestrierungsplattformen wie Kubernetes und Messaging-Plattformen wie Discord.

Postmans MCP-Server-Revolution

Postman hat die Möglichkeit eingeführt, benutzerdefinierte MCP-Server zu erstellen, die REST-API-Sammlungen als MCP-Tools bereitstellen. Das bedeutet, Sie können jetzt:

• API-Sammlungen in KI-zugängliche Tools transformieren
• GitHub Copilot ermöglichen, direkt mit Ihren APIs zu interagieren
• Wiederverwendbare, intelligente API-Workflows erstellen
• Die Lücke zwischen manuellem Testing und automatisierter KI-Unterstützung schließen

Sehen wir uns ein praktisches Beispiel mit unserer HCP Terraform MCP-Server-Implementierung an.

Praxisbeispiel: HCP Terraform MCP-Server

In unserer Implementierung haben wir einen MCP-Server erstellt, der HashiCorp HCP Terraform APIs bereitstellt. Dieser Server bietet Tools für:

• Abrufen von Organisationsinformationen
• Verwalten von Workspaces
• Zugriff auf Nutzungsdaten und Abonnement-Details
• Überwachung von Audit-Trails

Dieser MCP-Server wurde mittels Postmans neuer Funktion generiert, die es erlaubt, MCP-Server spontan aus bestehenden API-Sammlungen zu erstellen.

Dafür müssen wir einfach zu Postmans neuem MCP Generator gehen und die Sammlung auswählen, die wir in einen MCP-Server umwandeln möchten.

Nach der Generierung kann der MCP-Server heruntergeladen, lokal ausgeführt oder sogar einfach in einen Docker-Container für die Bereitstellung in jeder Umgebung umgewandelt werden.

Server-Architektur

Der heruntergeladene MCP-Server folgt einer sauberen, modularen Architektur:

postman-terraform-mcp-server/
├── index.js              # Einstiegspunkt
├── mcpServer.js          # Kern-MCP-Server-Logik
├── package.json          # Abhängigkeiten
├── Dockerfile            # Containerisierung
├── README.md             # Dokumentation
├── lib/                  # Geteilte Bibliotheken
├── commands/             # CLI-Befehle
└── tools/
    └── hashicorp/
        └── hashicorp-terraform-cloud/
            ├── get-organization-info.js
            ├── get-all-workspaces.js
            ├── get-subscription.js
            └── [zusätzliche API-Tools...]

Jede Tool-Datei entspricht einem spezifischen HCP Terraform API-Endpunkt, automatisch aus Postman-Sammlungen generiert.

Integrationsmethode 1: MCP-Server mit Postman verwenden

Postmans MCP-Server können direkt in der Postman-Anwendung verwendet werden. Dafür müssen wir:

1. Die Abhängigkeiten installieren:

   1# Navigieren Sie zu Ihrem MCP-Server-Verzeichnis-Root
   2cd /pfad/zu/postman-terraform-mcp-server
   3
   4# Abhängigkeiten installieren
   5npm install
   

2. Die API-Schlüssel in der .env-Datei konfigurieren:

   1HASHICORP_API_KEY=ihr-hcp-terraform-api-schluessel
   

3. Öffnen Sie Postman und navigieren Sie zu dem Workspace, in dem Sie die MCP-Anfrage erstellen möchten.

4. Klicken Sie auf die Schaltfläche "New" und wählen Sie "MCP Request" aus dem Menü.

5. Wählen Sie die Kommunikationsmethode für den MCP-Server:

   • STDIO: Für Standard-Input/Output-Kommunikation.
   • HTTP: Für streamfähiges HTTP mit Server-Sent Events (SSE).

6. Geben Sie den Server-Befehl und die Argumente (für STDIO) oder die URL (für HTTP mit SSE) ein.

Alle diese Schritte sind detailliert in der README.md Datei des MCP-Servers dokumentiert, den wir zuvor generiert haben.

Nach der Konfiguration können Sie Anfragen direkt von Postman an den MCP-Server stellen.

Integrationsmethode 2: MCP-Server mit GitHub Copilot in VS Code verwenden

Eine der mächtigsten Integrationen ist die Verbindung Ihres MCP-Servers mit GitHub Copilot in VS Code. So richten Sie es ein:

1. MCP-Server konfigurieren

Stellen Sie zunächst sicher, dass Ihr MCP-Server läuft und zugänglich ist:

1# Navigieren Sie zu Ihrem MCP-Server-Verzeichnis
2cd /pfad/zu/postman-terraform-mcp-server
3
4# Abhängigkeiten installieren
5npm install

2. VS Code MCP-Integration konfigurieren

Fügen Sie den folgenden JSON-Block zu Ihrer User Settings (JSON)-Datei in VS Code hinzu. Sie können dies tun, indem Sie die Befehlspalette (Cmd/Ctrl + Shift + P) öffnen und "Preferences: Open User Settings (JSON)" auswählen.

 1{
 2  "mcp": {
 3      "inputs": [
 4      {
 5          "type": "promptString",
 6          "id": "api-key",
 7          "description": "API Key",
 8          "password": true
 9      }
10      ],
11      "servers": {
12          "<server_name>": {
13              "command": "node",
14              "args": ["<absoluter/pfad/zu/mcpServer.js>"],
15              "env": {
16                  "<API_KEY>": "${input:api-key}"
17              }
18          }
19      }
20  }
21}

Ersetzen Sie <server_name> durch einen Namen für Ihren MCP-Server und geben Sie die absoluten Pfade zu Ihrer Node.js-Ausführbaren Datei und dem MCP-Server-Skript an. Ersetzen Sie <API_KEY> durch den Umgebungsvariablennamen, den Ihr MCP-Server erwartet (z.B. HASHICORP_API_KEY).

Im Fall unseres Terraform MCP-Servers könnte es so aussehen:

 1{
 2  "mcp": {
 3      "inputs": [
 4      {
 5          "type": "promptString",
 6          "id": "hashicorp-api-key",
 7          "description": "HashiCorp API Key",
 8          "password": true
 9      }
10      ],
11      "servers": {
12          "terraform": {
13              "command": "node",
14              "args": ["/pfad/zu/postman-terraform-mcp-server/mcpServer.js"],
15              "env": {
16                  "HASHICORP_API_KEY": "${input:hashicorp-api-key}"
17              }
18          }
19      }
20  }
21}

3. Interaktive KI-Abfragen

Nach der Konfiguration können Sie mit GitHub Copilot über natürlichsprachliche Abfragen interagieren, die Ihre Terraform-Infrastruktur nutzen:

Beispiel-Interaktion:

Benutzer: "Welche Workspaces haben wir in unserer Infralovers-Organisation?"

GitHub Copilot: Lassen Sie mich Ihre HCP Terraform Organisation überprüfen...
[Ruft bb7_get_all_workspaces mit orgName: "Infralovers" auf]

Ergebnis: 43 Workspaces gefunden, einschließlich:
- VPC- und Netzwerk-Infrastruktur
- Zertifikatsverwaltung
- Trainingsumgebungen
- Produktions-Workloads

Integrationsmethode 3: MCP-CLI für direkte Abfragen verwenden

Anstatt Postman oder GitHub Copilot zu verwenden, können Sie auch mit Ihrem MCP-Server über die CLI interagieren. Dies ist beispielsweise mit dem mcp-cli Tool möglich, das es ermöglicht, Abfragen direkt gegen Ihre MCP-Server zu stellen.

Die MCP CLI bietet eine Befehlszeilenschnittstelle für die Interaktion mit MCP-Servern.

Installation und Einrichtung

1# Repository klonen:
2git clone https://github.com/chrishayuk/mcp-cli
3cd mcp-cli
4# Paket mit Entwicklungsabhängigkeiten installieren:
5pip install -e ".[cli,dev]"
6# CLI ausführen:
7mcp-cli --help

Nach der Installation können Sie Ihre MCP-Server-Verbindung in der server_config.json-Datei konfigurieren:

 1  {
 2    "mcpServers": {
 3      "terraform": {
 4        "command": "<absoluter/pfad/zu/node>",
 5        "args": ["<absoluter/pfad/zu/mcpServer.js>"],
 6        "env": {
 7          "HASHICORP_API_KEY": "<ihr-hcp-terraform-api-schluessel>"
 8        }
 9      }
10    }
11  }

Stellen Sie sicher, dass Sie die Pfade und den API-Schlüssel durch Ihre tatsächlichen Werte ersetzen.

Abfragen ausführen

Mit der MCP CLI können Sie nun mit Ihrem MCP-Server über einfache Befehle chatten.

1mcp-cli chat --server terraform

Sie können dann Abfragen eingeben wie:

Welche Workspaces haben wir in unserer Infralovers-Organisation?

Die MCP CLI wird Ihre Anfrage verarbeiten, das entsprechende MCP-Tool aufrufen und die Ergebnisse direkt in Ihrem Terminal zurückgeben.

 1╭─ ⚡ Streaming • 939 chunks • 19.4s • 16.0 words/s • 148 chars/s ─────────────────────────────────────────────────────────────────────────╮
 2│ Here are your Terraform workspaces in the organization "Infralovers":                                                                    │
 3│                                                                                                                                          │
 4│   1 Workspace Name: one                                                                                                               │
 5│      • ID: ws-dsfgsadg                                                                                                          │
 6│      • Terraform Version: 1.7.5                                                                                                          │
 7│      • Environment: default                                                                                                              │
 8│      • Locked: Yes                                                                                                                       │
 9│      • Resource Count: 6                                                                                                                 │
10│   2 Workspace Name: two                                                                                                              │
11│      • ID: ws-dfsgdfsg                                                                                                           │
12│      • Terraform Version: latest                                                                                                         │
13│      • Environment: default                                                                                                              │
14│      • Locked: No                                                                                                                        │
15│      • Resource Count: 9                                                                                                                 │
16│   3 Workspace Name: three                                                                                                         │
17│      • ID: ws-fdsgdfsg                                                                                                           │
18│      • Terraform Version: latest                                                                                                         │
19│      • Environment: default                                                                                                              │
20│      • Locked: No                                                                                                                        │
21│      • Resource Count: 3                                                                                                                 │
22...

Fazit: Die Zukunft der API-Entwicklung

Postmans MCP-Server-Funktionen stellen einen grundlegenden Wandel dar, wie wir über API-Entwicklung, -Testing und -Integration denken. Durch die Überbrückung der Lücke zwischen statischer API-Dokumentation und dynamischen, KI-zugänglichen Tools ermöglichen MCP-Server:

• Intuitivere API-Interaktionen durch natürliche Sprache
• Nahtlose Integration zwischen Entwicklungstools und KI-Assistenten
• Echtzeit-Datenzugriff für bessere Entscheidungsfindung
• Automatisierte Workflows, die sich an verändernde Infrastruktur anpassen

Wie wir an unserem HCP Terraform Beispiel gesehen haben, sind die praktischen Anwendungen grenzenlos – von Infrastruktur-Management über Service-Monitoring bis hin zu automatisiertem Testing und intelligentem Debugging.

Bringen Sie Ihre KI-Engineering-Fähigkeiten auf die nächste Stufe

Bei Infralovers befähigt unser aktualisiertes AI Essentials for Engineers Training Sie dazu, KI in Ihre Engineering-Workflows zu integrieren, mit praktischer Erfahrung in Large Language Models (LLMs), Retrieval-Augmented Generation (RAG) und KI-Agenten. Sie erhalten eine solide Grundlage in KI-Konzepten, ethischen und regulatorischen Überlegungen (einschließlich des EU AI Act) und praktische Fähigkeiten mit Tools wie LangChain, OpenAI, Ollama und LightRAG.

Der Kurs bietet auch eine tiefgreifende, praktische Abdeckung des Model Context Protocol (MCP) und zeigt Ihnen, wie Sie KI mit realen APIs und Infrastruktur verbinden können. Schließen Sie sich Entwicklern weltweit an, die ihre Karriere mit praktischer, KI-getriebener Engineering-Expertise vorantreiben.

Erfahren Sie mehr über unser AI Essentials for Engineers Training