Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

LLMs mit MCP mit Cloud Storage verbinden

In dieser Anleitung erfahren Sie, wie Sie Cloud Storage mit integrierten Entwicklungsumgebungen (IDEs) und Entwicklertools verbinden. Dazu führen Sie mit der MCP Toolbox für Datenbanken einen lokalen MCP-Server auf Ihrem Computer aus.

Die MCP Toolbox für Datenbanken ist ein Open-Source-Repository mit Connectors für Datenbanken und Datenspeicher, darunter Cloud Storage, BigQuery, AlloyDB, Spanner und Cloud SQL. Die Toolbox unterstützt die OAuth2- und OIDC-Authentifizierung und ist in Open Telemetry für die Beobachtbarkeit eingebunden. Mit der Cloud Storage-Toolbox-Integration können Sie ein LLM verwenden, um die folgenden Aktionen auszuführen:

Buckets erstellen, auflisten und löschen.
Bucket- und Objektmetadaten abrufen.
IAM-Richtlinien (Identity and Access Management) für Ihre Buckets abrufen.
Objekte lesen, schreiben, hochladen und herunterladen.
Objekte kopieren oder verschieben.

In dieser Anleitung wird der Verbindungsprozess für die folgenden IDEs und Tools beschrieben:

Cursor
Windsurf (ehemals Codeium)
Visual Studio Code (Copilot)
Cline (VS Code-Erweiterung)
Claude für den Computer
Claude-Code
Antigravity

Hinweis

Wählen Sie in der Google Cloud Console auf der Seite für die Projektauswahl ein-Projekt aus oder erstellen Sie eines Google Cloud .
Achten Sie darauf, dass die Abrechnung für Ihr Google Cloud Projekt aktiviert ist.
Aktivieren Sie die Cloud Storage API im Google Cloud Projekt.
Konfigurieren Sie die erforderlichen Rollen und Berechtigungen, um diese Aufgabe auszuführen. Der Nutzer, der die LLM-Agenten aufruft, benötigt die folgenden Rollen auf Bucket- oder Projektebene:
- Zum Auflisten, Erstellen und Löschen leerer Buckets: Storage-Administrator (roles/storage.admin)
- Zum Auflisten, Lesen und Abrufen von Objekt- oder Bucket-Metadaten: Storage-Objekt-Betrachter (roles/storage.objectViewer)
- Zum Schreiben von Inhalten in ein Objekt oder zum Hochladen eines Objekts: Storage-Objekt-Ersteller (roles/storage.objectCreator)
- Zum Kopieren, Verschieben oder Löschen von Objekten: Storage-Objekt-Administrator (roles/storage.objectAdmin)
Konfigurieren Sie Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC) für Ihre Umgebung.

Mit Antigravity verbinden

Sie verbinden Cloud Storage mit Antigravity über eine benutzerdefinierte Konfiguration. In diesem Zusammenhang ist ein benutzerdefinierter MCP-Server ein Server, den Sie manuell konfigurieren, indem Sie Ihre Konfigurationsdatei (z. B. mcp_config.json) bearbeiten. Diese manuelle Konfiguration wird verwendet, anstatt den Server direkt aus dem integrierten MCP Store-Katalog zu installieren.

So konfigurieren Sie einen benutzerdefinierten MCP-Server:

Prüfen Sie, ob npx installiert und auf Ihrem System richtig konfiguriert ist. Führen Sie dazu npx --version in Ihrem Terminal aus. Wenn Sie Node.js installieren müssen, das npx enthält, lesen Sie die Anleitung zum Herunterladen und Installieren von Node.js und npm.
Öffnen Sie Antigravity und rufen Sie den MCP Store über das Drop-down-Menü „...“ oben im Agentenbereich des Editors auf.
Klicken Sie auf MCP-Server und dann auf MCP-Server verwalten > Rohkonfiguration ansehen, um die Datei mcp_config.json zu öffnen.

Fügen Sie die folgende Konfiguration hinzu, ersetzen Sie den Platzhalter durch Ihre Projekt-ID und speichern Sie die Datei:

{
  "mcpServers": {
    "storage": {
      "command": "npx",
      "args": ["-y","@toolbox-sdk/server","--prebuilt","cloud-storage","--stdio"],
      "env": {
          "CLOUD_STORAGE_PROJECT": "PROJECT_ID"
      }
    }
  }
}

MCP-Toolbox installieren

Die Toolbox ist ein Open-Source-Model Context Protocol (MCP)-Server, der lokal auf Ihrem Computer ausgeführt wird. Der lokale Server verwaltet die Kommunikation zwischen Ihrer IDE und Cloud Storage. Diese Verbindung bietet eine sichere und effiziente Umgebung für Ihre KI-Tools.

Laden Sie die aktuelle Version der MCP Toolbox als Binärprogramm herunter. Wählen Sie das Binärprogramm aus, das Ihrem Betriebssystem und Ihrer CPU-Architektur entspricht. Sie müssen die MCP Toolbox ab Version 1.2.0 verwenden:
linux/amd64
curl -O https://storage.googleapis.com/mcp-toolbox-for-databases/VERSION/linux/amd64/toolbox
Ersetzen Sie VERSION durch die MCP Toolbox-Version, z. B. v1.2.0.
macOS darwin/arm64
curl -O https://storage.googleapis.com/mcp-toolbox-for-databases/VERSION/darwin/arm64/toolbox
Ersetzen Sie VERSION durch die MCP Toolbox-Version, z. B. v1.2.0.
macOS darwin/amd64
curl -O https://storage.googleapis.com/mcp-toolbox-for-databases/VERSION/darwin/amd64/toolbox
Ersetzen Sie VERSION durch die MCP Toolbox-Version, z. B. v1.2.0.
windows/amd64
curl -O https://storage.googleapis.com/mcp-toolbox-for-databases/VERSION/windows/amd64/toolbox
Ersetzen Sie VERSION durch die MCP Toolbox-Version, z. B. v1.2.0.
So machen Sie die Binärdatei ausführbar:
```
chmod +x toolbox
```
Installation prüfen:
```
./toolbox --version
```

Informationen zum Einrichten der Toolbox mit einem Container-Image oder Homebrew finden Sie auf der Seite Toolbox installieren.

Clients und Verbindungen einrichten

In diesem Abschnitt wird beschrieben, wie Sie Cloud Storage mit Ihren Tools verbinden, nachdem Sie die MCP Toolbox installiert haben.

Claude-Code

Installieren Sie Claude Code.
Erstellen Sie im Stammverzeichnis Ihres Projekts eine .mcp.json-Datei, falls sie noch nicht vorhanden ist.
Fügen Sie die Konfiguration hinzu, ersetzen Sie die Platzhalter durch Ihre Werte und speichern Sie die Datei:
```
        {
          "mcpServers": {
            "storage": {
              "command": "./PATH/TO/toolbox",
              "args": ["--prebuilt","cloud-storage","--stdio"],
              "env": {
                "CLOUD_STORAGE_PROJECT": "PROJECT_ID"
              }
            }
          }
        }
        
```
Ersetzen Sie die folgenden Variablen durch Ihre Werte:
- ./PATH/TO/toolbox: Der Pfad zu Ihrer toolbox-Binärdatei.
- CLOUD_STORAGE_PROJECT: Die Umgebungsvariable, die die Google Cloud Projekt-ID angibt.
- PROJECT_ID: Ihre Google Cloud Projekt-ID.
Starten Sie Claude Code neu, um die neuen Einstellungen zu laden. Wenn Claude Code wieder geöffnet wird, erkennt die Anwendung den konfigurierten MCP-Server.

Claude für den Computer

Öffnen Sie Claude für Desktop und rufen Sie die Einstellungen auf.
Klicken Sie auf dem Tab Entwickler auf Konfiguration bearbeiten, um die Konfigurationsdatei zu öffnen.
Fügen Sie die Konfiguration hinzu, ersetzen Sie die Platzhalter durch Ihre Werte und speichern Sie die Datei:
```
        {
          "mcpServers": {
            "storage": {
              "command": "./PATH/TO/toolbox",
              "args": ["--prebuilt","cloud-storage","--stdio"],
              "env": {
                "CLOUD_STORAGE_PROJECT": "PROJECT_ID"
              }
            }
          }
        }
        
```
Ersetzen Sie die folgenden Variablen durch Ihre Werte:
- ./PATH/TO/toolbox: Der Pfad zu Ihrer toolbox-Binärdatei.
- CLOUD_STORAGE_PROJECT: Die Umgebungsvariable, die die Google Cloud Projekt-ID angibt.
- PROJECT_ID: Ihre Google Cloud Projekt-ID.
Starten Sie Claude für den Computer neu.
Auf dem neuen Chatbildschirm wird ein Hammersymbol (MCP) mit dem neuen MCP-Server angezeigt.

Cline

Öffnen Sie die Cline-Erweiterung in VS Code und klicken Sie auf das Symbol MCP-Server.
Klicken Sie auf MCP-Server konfigurieren , um die Konfigurationsdatei zu öffnen.
Fügen Sie die folgende Konfiguration hinzu, ersetzen Sie die Platzhalter durch Ihre Werte und speichern Sie die Datei:
```
        {
          "mcpServers": {
            "storage": {
              "command": "./PATH/TO/toolbox",
              "args": ["--prebuilt","cloud-storage","--stdio"],
              "env": {
                "CLOUD_STORAGE_PROJECT": "PROJECT_ID"
              }
            }
          }
        }
        
```
Ersetzen Sie die folgenden Variablen durch Ihre Werte:
- ./PATH/TO/toolbox: Der Pfad zu Ihrer toolbox-Binärdatei.
- CLOUD_STORAGE_PROJECT: Die Umgebungsvariable, die die Google Cloud Projekt-ID angibt.
- PROJECT_ID: Ihre Google Cloud Projekt-ID.

Nachdem die Verbindung zum Server hergestellt wurde, wird ein grüner aktiver Status angezeigt.

Cursor

Erstellen Sie das Verzeichnis .cursor im Stammverzeichnis Ihres Projekts, falls es noch nicht vorhanden ist.
Erstellen Sie die Datei .cursor/mcp.json, falls sie noch nicht vorhanden ist, und öffnen Sie sie.
Fügen Sie die folgende Konfiguration hinzu, ersetzen Sie die Platzhalter durch Ihre Werte und speichern Sie die Datei:
```
        {
          "mcpServers": {
            "storage": {
              "command": "./PATH/TO/toolbox",
              "args": ["--prebuilt","cloud-storage","--stdio"],
              "env": {
                "CLOUD_STORAGE_PROJECT": "PROJECT_ID"
              }
            }
          }
        }
        
```
Ersetzen Sie die folgenden Variablen durch Ihre Werte:
- ./PATH/TO/toolbox: Der Pfad zu Ihrer toolbox-Binärdatei.
- CLOUD_STORAGE_PROJECT: Die Umgebungsvariable, die die Google Cloud Projekt-ID angibt.
- PROJECT_ID: Ihre Google Cloud Projekt-ID.
Öffnen Sie Cursor und rufen Sie Einstellungen > Cursor-Einstellungen > MCP auf. Wenn die Verbindung zum Server hergestellt wurde, wird ein grüner aktiver Status angezeigt.

Visual Studio Code (Copilot)

Öffnen Sie VS Code und erstellen Sie im Stammverzeichnis Ihres Projekts das Verzeichnis .vscode, falls es noch nicht vorhanden ist.
Erstellen Sie die Datei .vscode/mcp.json, falls sie noch nicht vorhanden ist, und öffnen Sie sie.
Fügen Sie die folgende Konfiguration hinzu, ersetzen Sie die Platzhalter durch Ihre Werte und speichern Sie die Datei:
```
        {
          "mcpServers": {
            "storage": {
              "command": "./PATH/TO/toolbox",
              "args": ["--prebuilt","cloud-storage","--stdio"],
              "env": {
                "CLOUD_STORAGE_PROJECT": "PROJECT_ID"
              }
            }
          }
        }
        
```
Ersetzen Sie die folgenden Variablen durch Ihre Werte:
- ./PATH/TO/toolbox: Der Pfad zu Ihrer toolbox-Binärdatei.
- CLOUD_STORAGE_PROJECT: Die Umgebungsvariable, die die Google Cloud Projekt-ID angibt.
- PROJECT_ID: Ihre Google Cloud Projekt-ID.
Aktualisieren Sie das VS Code-Fenster. Die MCP-kompatible Erweiterung erkennt die Konfiguration automatisch und startet den Server.

Windsurf

Öffnen Sie Windsurf und rufen Sie den Cascade-Assistenten auf.
Klicken Sie auf das MCP-Symbol und dann auf Konfigurieren, um die Konfigurationsdatei zu öffnen.
Fügen Sie die folgende Konfiguration hinzu, ersetzen Sie die Platzhalter durch Ihre Werte und speichern Sie die Datei:
```
        {
          "mcpServers": {
            "storage": {
              "command": "./PATH/TO/toolbox",
              "args": ["--prebuilt","cloud-storage","--stdio"],
              "env": {
                "CLOUD_STORAGE_PROJECT": "PROJECT_ID"
              }
            }
          }
        }
        
```
Ersetzen Sie die folgenden Variablen durch Ihre Werte:
- ./PATH/TO/toolbox: Der Pfad zu Ihrer toolbox-Binärdatei.
- CLOUD_STORAGE_PROJECT: Die Umgebungsvariable, die die Google Cloud Projekt-ID angibt.
- PROJECT_ID: Ihre Google Cloud Projekt-ID.

Vordefinierte Tools

Nachdem Sie die MCP Toolbox mit Cloud Storage verbunden haben, verwendet Ihr Agent die folgenden vordefinierten Tools:

list_buckets: Listet Cloud Storage-Buckets im konfigurierten Projekt auf.
list_objects: Listet Objekte in einem Bucket mit optionaler Präfix- und Trennzeichenfilterung auf.
get_bucket_metadata: Gibt Metadaten für einen Bucket zurück.
get_bucket_iam_policy: Gibt die IAM-Richtlinienbindungen für einen Bucket zurück.
get_object_metadata: Gibt Metadaten für ein Objekt zurück.
read_object: Liest ein UTF-8-Textobjekt (oder einen Bytebereich). Die Größe ist auf 8 MiB begrenzt. Binärobjekte werden abgelehnt.
download_object: Lädt ein Objekt in einen lokalen Pfad herunter.
create_bucket: Erstellt einen Bucket im konfigurierten Projekt.
delete_bucket: Löscht einen leeren Bucket.
upload_object: Lädt eine lokale Datei in ein Objekt hoch.
write_object: Schreibt Textinhalte direkt in ein Objekt.
copy_object: Kopiert ein Objekt in ein Zielobjekt.
move_object: Benennt ein Objekt innerhalb desselben Buckets atomar um.
delete_object: Löscht ein Objekt.