Spanner mit der MCP Toolbox for Databases, der Gemini-Befehlszeile und anderen Agents verwenden

In diesem Dokument wird beschrieben, wie Sie Ihre Spanner-Instanz mit verschiedenen Entwicklertools verbinden, die das Model Context Protocol (MCP) unterstützen.

Wir empfehlen die Verwendung der dedizierten Spanner-Erweiterung für die Gemini CLI. Die Erweiterung bündelt die zugrunde liegenden Skills direkt in der Erweiterung, was die Einrichtung und Konfiguration vereinfacht. Sie können Gemini Code Assist so konfigurieren, dass die Gemini CLI verwendet wird. Das bietet ähnliche Einrichtungsvorteile in Ihrer IDE. Weitere Informationen finden Sie unter Gemini CLI-Erweiterung – Spanner.

Alternativ können andere IDEs und Entwicklertools, die das MCP unterstützen, über die MCP Toolbox for Databases eine Verbindung herstellen. Die MCP Toolbox ist ein Open-Source-MCP-Server, mit dem Sie KI-Agents mit Ihren Daten verbinden können. Es übernimmt Aufgaben wie die Authentifizierung und das Verbindungs-Pooling, sodass Sie direkt über Ihre IDE in natürlicher Sprache mit Ihren Daten interagieren können.

Gemini CLI-Erweiterung in Spanner verwenden

Die Spanner-Integration mit der Gemini CLI erfolgt über eine Open-Source-Erweiterung, die im Vergleich zur Standardverbindung über die MCP-Toolbox zusätzliche Funktionen bietet. Die Erweiterung bietet einen optimierten Installationsprozess und eine Reihe von Skills, die auf MCP-Tools basieren. Wenn Sie die Gemini CLI-Erweiterung verwenden, müssen Sie die MCP Toolbox nicht installieren. Weitere Informationen finden Sie unter Gemini CLI-Erweiterung – Spanner.

Die spanner-Erweiterung umfasst Skills zum Auflisten von Tabellen und zum Ausführen von SQL- und SQL-DQL-Anweisungen.

Alle verfügbaren Skills finden Sie unter Spanner-Skills auf GitHub.

Hinweis

  1. Wählen Sie in der Google Cloud Console auf der Seite für die Projektauswahl ein Google Cloud -Projekt aus oder erstellen Sie eines.

  2. Achten Sie darauf, dass die Abrechnung für Ihr Projekt in Google Cloud aktiviert ist.

Spanner-Instanz einrichten

  1. Aktivieren Sie die Spanner API im Google Cloud Projekt.

  2. Spanner-Instanz und ‑Datenbank erstellen oder auswählen

  3. Konfigurieren Sie die erforderlichen Rollen und Berechtigungen, um diese Aufgabe auszuführen. Der Nutzer, der die LLM-Agents aufruft, benötigt die folgenden Rollen auf Datenbankebene:

    • Cloud Spanner-Datenbank-Leser (roles/spanner.databaseReader) zum Ausführen von DQL-Abfragen und zum Auflisten von Tabellen.

    • Cloud Spanner-Datenbank-Nutzer (roles/spanner.databaseUser) zum Ausführen von DML-Abfragen.

  4. Konfigurieren Sie Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC) für Ihre Umgebung.

MCP Toolbox installieren

  1. 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-Version 0.15.0 oder höher verwenden:

    linux/amd64

    curl -O https://storage.googleapis.com/mcp-toolbox-for-databases/version/linux/amd64/toolbox

    darwin/arm64

    curl -O https://storage.googleapis.com/mcp-toolbox-for-databases/version/darwin/arm64/toolbox

    darwin/amd64

    curl -O https://storage.googleapis.com/mcp-toolbox-for-databases/version/darwin/amd64/toolbox

    windows/amd64

    curl -O https://storage.googleapis.com/mcp-toolbox-for-databases/version/windows/amd64/toolbox

  2. So machen Sie die Binärdatei ausführbar:

    chmod +x toolbox

  3. Installation prüfen:

    ./toolbox --version

Clients und Verbindungen einrichten

In diesem Abschnitt wird beschrieben, wie Sie verschiedene Entwicklertools konfigurieren, um eine Verbindung zu Ihrer Spanner-Instanz herzustellen. Wählen Sie Ihren Client aus den folgenden Optionen aus:

Gemini CLI

  1. Installieren Sie die Gemini CLI.
  2. Installieren Sie die Spanner-Erweiterung für die Gemini CLI aus dem GitHub-Repository mit dem folgenden Befehl: 
    gemini extensions install https://github.com/gemini-cli-extensions/spanner
  3. Legen Sie die folgenden Umgebungsvariablen fest, um eine Verbindung zu Ihrer Spanner-Instanz herzustellen: 
    export SPANNER_PROJECT="PROJECT_ID"
export SPANNER_INSTANCE="INSTANCE_NAME"
export SPANNER_DATABASE="DATABASE_NAME"
export SPANNER_DIALECT="DIALECT_NAME"
     Ersetzen Sie Folgendes:
    • PROJECT_ID: Die Google Cloud Projekt-ID.
    • INSTANCE_NAME: Der Name der Spanner-Instanz.
    • DATABASE_NAME: Der Name der Spanner-Datenbank.
    • DIALECT_NAME: Der Spanner-SQL-Dialekt. Akzeptiert googlesql oder postgresql. Wenn kein Wert definiert ist, wird standardmäßig googlesql verwendet.
  4. Starten Sie die Gemini CLI im interaktiven Modus: 
    gemini

    Die CLI lädt automatisch die Spanner-Erweiterung für die Gemini CLI und ihre Skills, mit denen Sie mit Ihrer Datenbank interagieren können.

    Verwenden Sie in der Gemini CLI den Befehl /extensions, um zu prüfen, ob die Erweiterung installiert ist.

Gemini Code Assist

Wir empfehlen dringend, Gemini Code Assist so zu konfigurieren, dass die Gemini CLI verwendet wird, da bei diesem Ansatz kein MCP-Server manuell konfiguriert werden muss. Die Anleitung zum manuellen Konfigurieren eines MCP-Servers ist jedoch weiterhin im folgenden Abschnitt verfügbar:


1. Installieren Sie die Erweiterung Gemini Code Assist in VS Code.
2. Aktivieren Sie den KI-Agentenmodus und stellen Sie das KI-Agentenmodell auf Gemini um.
3. Erstellen Sie im Stammverzeichnis des Projekts einen Ordner mit dem Namen .gemini und darin eine Datei mit dem Namen settings.json.
4. Fügen Sie der Datei settings.json eine der folgenden Konfigurationen hinzu, die auf Ihrem Spanner-Dialekt basiert.
5. Ersetzen Sie die folgenden Variablen durch Ihre Werte:
  • PROJECT_ID: Projekt-ID in Google Cloud .
  • INSTANCE_NAME: Ihr Spanner-Instanzname.
  • DATABASE_NAME: Name Ihrer Spanner-Datenbank.
6. Speichern Sie die Datei.

Spanner mit GoogleSQL-Dialekt: 

{
  "mcpServers": {
    "spanner": {
      "command": "./PATH/TO/toolbox",
      "args": ["--prebuilt","spanner","--stdio"],
      "env": {
          "SPANNER_PROJECT": "PROJECT_ID",
          "SPANNER_INSTANCE": "INSTANCE_NAME",
          "SPANNER_DATABASE": "DATABASE_NAME"
      }
    }
  }
}

Spanner mit PostgreSQL-Dialekt: 

{
  "mcpServers": {
    "spanner": {
      "command": "./PATH/TO/toolbox",
      "args": ["--prebuilt","spanner-postgres","--stdio"],
      "env": {
          "SPANNER_PROJECT": "PROJECT_ID",
          "SPANNER_INSTANCE": "INSTANCE_NAME",
          "SPANNER_DATABASE": "DATABASE_NAME"
      }
    }
  }
}

Claude Code

  1. Installieren Sie Claude Code.
  2. Legen Sie die Umgebungsvariablen fest, um eine Verbindung zu Ihrer Spanner-Instanz herzustellen: 
    export SPANNER_PROJECT="PROJECT_ID"
export SPANNER_INSTANCE="INSTANCE_NAME"
export SPANNER_DATABASE="DATABASE_NAME"
export SPANNER_DIALECT="DIALECT_NAME"
     Ersetzen Sie Folgendes:
    • PROJECT_ID: Die Google Cloud Projekt-ID.
    • INSTANCE_NAME: Der Name der Spanner-Instanz.
    • DATABASE_NAME: Der Name der Spanner-Datenbank.
    • DIALECT_NAME: Der Spanner-SQL-Dialekt. Akzeptiert googlesql oder postgresql. Wenn kein Wert definiert ist, wird standardmäßig googlesql verwendet.
  3. Starten Sie den Agent: 
    claude
  4. Installieren Sie das Plug-in: 
    /plugin install spanner@claude-plugins-official

Codex

  1. Installieren Sie den Data Cloud-Plug-ins-Marketplace: 
    codex plugin marketplace add GoogleCloudPlatform/data-cloud-plugins
  2. Installieren Sie das Spanner-Plug-in: 
    codex plugin install spanner@data-cloud-plugins
  3. Konfigurieren Sie die Umgebungsvariablen, um eine Verbindung zu Ihrer Spanner-Instanz herzustellen: 
    export SPANNER_PROJECT="PROJECT_ID"
export SPANNER_INSTANCE="INSTANCE_NAME"
export SPANNER_DATABASE="DATABASE_NAME"
export SPANNER_DIALECT="DIALECT_NAME"
     Ersetzen Sie Folgendes:
    • PROJECT_ID: Die Google Cloud Projekt-ID.
    • INSTANCE_NAME: Der Name der Spanner-Instanz.
    • DATABASE_NAME: Der Name der Spanner-Datenbank.
    • DIALECT_NAME: Der Spanner-SQL-Dialekt. Akzeptiert googlesql oder postgresql. Wenn kein Wert definiert ist, wird standardmäßig googlesql verwendet.
  4. Optional. Aktualisieren Sie den Marketplace: 
    codex plugin marketplace upgrade data-cloud-plugins

Claude für den Computer


1. Öffnen Sie Claude für Desktop und rufen Sie die Einstellungen auf.
2. Klicken Sie auf dem Tab Entwickler auf Konfiguration bearbeiten, um die Konfigurationsdatei zu öffnen.
3. Fügen Sie je nach Spanner-Dialekt eine der folgenden Konfigurationen hinzu, ersetzen Sie die Umgebungsvariablen durch Ihre Werte und speichern Sie die Datei:

Spanner mit GoogleSQL-Dialekt: 

{
  "mcpServers": {
    "spanner": {
      "command": "./PATH/TO/toolbox",
      "args": ["--prebuilt","spanner","--stdio"],
      "env": {
          "SPANNER_PROJECT": "PROJECT_ID",
          "SPANNER_INSTANCE": "INSTANCE_NAME",
          "SPANNER_DATABASE": "DATABASE_NAME"
      }
    }
  }
}

Spanner mit PostgreSQL-Dialekt: 

{
  "mcpServers": {
    "spanner": {
      "command": "./PATH/TO/toolbox",
      "args": ["--prebuilt","spanner-postgres","--stdio"],
      "env": {
          "SPANNER_PROJECT": "PROJECT_ID",
          "SPANNER_INSTANCE": "INSTANCE_NAME",
          "SPANNER_DATABASE": "DATABASE_NAME"
      }
    }
  }
}

4. Starten Sie Claude für den Desktop neu.
5. Auf dem neuen Chatbildschirm wird ein Hammersymbol (MCP) mit dem neuen MCP-Server angezeigt.

Cline


1. Öffnen Sie die Cline-Erweiterung in VS Code und klicken Sie auf das Symbol MCP-Server.
2. Tippen Sie auf „MCP-Server konfigurieren“, um die Konfigurationsdatei zu öffnen.
3. Fügen Sie je nach Spanner-Dialekt eine der folgenden Konfigurationen hinzu, ersetzen Sie die Umgebungsvariablen durch Ihre Werte und speichern Sie die Datei:

Spanner mit GoogleSQL-Dialekt: 

{
  "mcpServers": {
    "spanner": {
      "command": "./PATH/TO/toolbox",
      "args": ["--prebuilt","spanner","--stdio"],
      "env": {
          "SPANNER_PROJECT": "PROJECT_ID",
          "SPANNER_INSTANCE": "INSTANCE_NAME",
          "SPANNER_DATABASE": "DATABASE_NAME"
      }
    }
  }
}

Spanner mit PostgreSQL-Dialekt: 

{
  "mcpServers": {
    "spanner": {
      "command": "./PATH/TO/toolbox",
      "args": ["--prebuilt","spanner-postgres","--stdio"],
      "env": {
          "SPANNER_PROJECT": "PROJECT_ID",
          "SPANNER_INSTANCE": "INSTANCE_NAME",
          "SPANNER_DATABASE": "DATABASE_NAME"
      }
    }
  }
}

Nachdem der Server erfolgreich verbunden wurde, wird ein grüner aktiver Status angezeigt.

Cursor


1. Erstellen Sie das Verzeichnis .cursor im Stammverzeichnis Ihres Projekts, falls es noch nicht vorhanden ist.
2. Erstellen Sie die Datei .cursor/mcp.json, falls sie noch nicht vorhanden ist, und öffnen Sie sie.
3. Fügen Sie eine der folgenden Konfigurationen basierend auf Ihrem Spanner-Dialekt hinzu, ersetzen Sie die Umgebungsvariablen durch Ihre Werte und speichern Sie die Datei:

Spanner mit GoogleSQL-Dialekt: 

{
  "mcpServers": {
    "spanner": {
      "command": "./PATH/TO/toolbox",
      "args": ["--prebuilt","spanner","--stdio"],
      "env": {
          "SPANNER_PROJECT": "PROJECT_ID",
          "SPANNER_INSTANCE": "INSTANCE_NAME",
          "SPANNER_DATABASE": "DATABASE_NAME"
      }
    }
  }
}

Spanner mit PostgreSQL-Dialekt: 

{
  "mcpServers": {
    "spanner": {
      "command": "./PATH/TO/toolbox",
      "args": ["--prebuilt","spanner-postgres","--stdio"],
      "env": {
          "SPANNER_PROJECT": "PROJECT_ID",
          "SPANNER_INSTANCE": "INSTANCE_NAME",
          "SPANNER_DATABASE": "DATABASE_NAME"
      }
    }
  }
}

4. Öffnen Sie Cursor und rufen Sie Einstellungen > Cursoreinstellungen > MCP auf. Wenn der Server verbunden ist, wird ein grüner aktiver Status angezeigt.

Visual Studio Code (Copilot)


1. Öffnen Sie VS Code und erstellen Sie im Stammverzeichnis Ihres Projekts das Verzeichnis .vscode, falls es noch nicht vorhanden ist.
2. Erstellen Sie die Datei .vscode/mcp.json, falls sie noch nicht vorhanden ist, und öffnen Sie sie.
3. Fügen Sie je nach Spanner-Dialekt eine der folgenden Konfigurationen hinzu, ersetzen Sie die Umgebungsvariablen durch Ihre Werte und speichern Sie die Datei:

Spanner mit GoogleSQL-Dialekt: 

{
  "servers": {
    "spanner": {
      "command": "./PATH/TO/toolbox",
      "args": ["--prebuilt","spanner","--stdio"],
      "env": {
        "SPANNER_PROJECT": "PROJECT_ID",
        "SPANNER_INSTANCE": "INSTANCE_NAME",
        "SPANNER_DATABASE": "DATABASE_NAME"
      }
    }
  }
}

Spanner mit PostgreSQL-Dialekt: 

{
  "servers": {
    "spanner": {
      "command": "./PATH/TO/toolbox",
      "args": ["--prebuilt","spanner-postgres","--stdio"],
      "env": {
        "SPANNER_PROJECT": "PROJECT_ID",
        "SPANNER_INSTANCE": "INSTANCE_NAME",
        "SPANNER_DATABASE": "DATABASE_NAME"
      }
    }
  }
}

Windsurf


1. Öffnen Sie Windsurf und rufen Sie den Cascade-Assistenten auf.
2. Klicken Sie auf das MCP-Symbol und dann auf Konfigurieren, um die Konfigurationsdatei zu öffnen.
3. Fügen Sie je nach Spanner-Dialekt eine der folgenden Konfigurationen hinzu, ersetzen Sie die Umgebungsvariablen durch Ihre Werte und speichern Sie die Datei:

Spanner mit GoogleSQL-Dialekt: 

{
  "mcpServers": {
    "spanner": {
      "command": "./PATH/TO/toolbox",
      "args": ["--prebuilt","spanner","--stdio"],
      "env": {
          "SPANNER_PROJECT": "PROJECT_ID",
          "SPANNER_INSTANCE": "INSTANCE_NAME",
          "SPANNER_DATABASE": "DATABASE_NAME"
      }
    }
  }
}

Spanner mit PostgreSQL-Dialekt: 

{
  "mcpServers": {
    "spanner": {
      "command": "./PATH/TO/toolbox",
      "args": ["--prebuilt","spanner-postgres","--stdio"],
      "env": {
          "SPANNER_PROJECT": "PROJECT_ID",
          "SPANNER_INSTANCE": "INSTANCE_NAME",
          "SPANNER_DATABASE": "DATABASE_NAME"
      }
    }
  }
}

Mit Antigravity verbinden

Sie haben folgende Möglichkeiten, Spanner mit Antigravity zu verbinden:

  • MCP Store verwenden
  • Benutzerdefinierte Konfiguration verwenden

MCP Store

Die empfohlene Methode zum Herstellen einer Verbindung zu Antigravity ist die Verwendung des integrierten MCP-Stores.

  1. Öffnen Sie Antigravity und dann das Agent-Steuerfeld des Editors.
  2. Klicken Sie oben im Bereich auf das Menü und wählen Sie MCP-Server aus.
  3. Suchen Sie in der Liste der verfügbaren Server nach Spanner und klicken Sie auf Installieren.
  4. Folgen Sie der Anleitung auf dem Bildschirm, um Antigravity den Zugriff auf Ihr Google Cloud-Projekt zu gewähren. So kann Antigravity auf die Spanner-Instanz in Ihrem Projekt zugreifen.

Nachdem Sie den Spanner-Server im MCP Store installiert haben, sind die Ressourcen und Skills des Servers für den Editor verfügbar.

Benutzerdefinierte Konfiguration

So stellen Sie eine Verbindung zu einem benutzerdefinierten MCP-Server her:

  1. Öffnen Sie Antigravity und dann das Agent-Steuerfeld des Editors.
  2. Klicken Sie oben im Bereich auf das Menü und wählen Sie MCP-Server aus.
  3. Klicken Sie auf MCP-Server verwalten > Rohkonfiguration ansehen, um die mcp_config.json-Datei zu öffnen.
  4. Fügen Sie die folgende Konfiguration hinzu, ersetzen Sie die Umgebungsvariablen durch Ihre Werte und speichern Sie die Datei.
{
  "mcpServers": {
    "spanner": {
      "command": "npx",
      "args": ["-y","@toolbox-sdk/server","--prebuilt","spanner","--stdio"],
      "env": {
          "SPANNER_PROJECT": "PROJECT_ID",
          "SPANNER_INSTANCE": "INSTANCE_NAME",
          "SPANNER_DATABASE": "DATABASE_NAME",
          "SPANNER_DIALECT": "DIALECT_NAME"
      }
    }
  }
}

Nachdem Sie den benutzerdefinierten MCP-Server konfiguriert haben, stehen die Ressourcen und Skills des Spanner-Servers im Editor zur Verfügung.

Ersetzen Sie Folgendes:

  • PROJECT_ID: Projekt-ID in Google Cloud .
  • INSTANCE_NAME: Ihr Spanner-Instanzname.
  • DATABASE_NAME: Name Ihrer Spanner-Datenbank.
  • DIALECT_NAME: Ihr Spanner-SQL-Dialekt. Akzeptiert googlesql oder postgresql. Wenn Sie keinen Dialekt angeben, wird standardmäßig googlesql verwendet.

Verbindung zu Spanner mit dem Data Agent Kit herstellen

Mit dem Google Cloud Data Agent Kit können Sie Ihre Spanner-Datenbank verwalten und Abfragen für Ihre Spanner-Daten in Ihrer bevorzugten IDE oder Ihrem bevorzugten Coding-Agent ausführen. Die Data Agent Kit-Erweiterung funktioniert mit Visual Studio Code und VS Code-basierten IDEs. Das Data Agent Kit-Plug-in funktioniert mit einer Reihe beliebter Programmieragenten, darunter Claude Code und Codex CLI.

Das Data Agent Kit bietet Funktionen zum Erkennen und Analysieren von Daten, mit denen Sie Fragen zu Ihren Spanner-Daten in natürlicher Sprache stellen können. So können Sie Kontextwechsel zwischen Spanner-Befehlszeilentools und Ihrer Entwicklungsumgebung vermeiden.

Weitere Informationen finden Sie unter Übersicht über das Data Agent Kit.