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 spezielle Spanner Erweiterung für die Gemini CLI zu verwenden. 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 Vorteile bei der Einrichtung 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, der entwickelt wurde, um KI-Agenten mit Ihren Daten zu verbinden. Sie übernimmt Aufgaben wie die Authentifizierung und das Verbindungspooling, sodass Sie direkt in Ihrer IDE mit 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 mit der 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 Erweiterung spanner enthält 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-Projekt aus oder erstellen Sie eines. Google Cloud

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

Spanner-Instanz einrichten

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

  2. Erstellen oder wählen Sie eine Spanner-Instanz und ‑Datenbank aus.

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

    • Cloud Spanner-Datenbankleser (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 so konfigurieren, dass sie eine Verbindung zu Ihrer Spanner-Instanz herstellen. 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. Standardmäßig wird googlesql verwendet, wenn nichts angegeben ist.
  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 /extensions Befehl, 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. So ist es nicht erforderlich, einen MCP-Server manuell zu konfigurieren. Die Anleitung zum manuellen Konfigurieren eines MCP-Servers finden Sie jedoch weiterhin im folgenden Abschnitt:


1. Installieren Sie die Gemini Code Assist-Erweiterung in VS Code.
2. Aktivieren Sie den Agentenmodus und wechseln Sie das Agentenmodell zu Gemini.
3. Erstellen Sie im Stammverzeichnis Ihres Projekts einen Ordner mit dem Namen .gemini und darin eine Datei settings.json.
4. Fügen Sie der Datei settings.json eine der folgenden Konfigurationen basierend auf Ihrem Spanner-Dialekt hinzu.
5. Ersetzen Sie die folgenden Variablen durch Ihre Werte:
  • PROJECT_ID: Ihre Google Cloud Projekt-ID.
  • INSTANCE_NAME: der Name Ihrer Spanner-Instanz.
  • DATABASE_NAME: der 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. Standardmäßig wird googlesql verwendet, wenn nichts angegeben ist.
  3. Starten Sie den Agent: 
    claude
  4. Installieren Sie das Plug-in: 
    /plugin install spanner@claude-plugins-official

Codex

  1. Installieren Sie den Data Agent Kit Marketplace: 
    codex plugin marketplace add GoogleCloudPlatform/data-agent-kit
  2. Installieren Sie das Spanner-Plug-in: 
    codex plugin install spanner@data-agent-kit
  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. Standardmäßig wird googlesql verwendet, wenn nichts angegeben ist.
  4. Optional. Aktualisieren Sie den Marketplace: 
    codex plugin marketplace upgrade data-agent-kit

Claude for Desktop


1. Öffnen Sie Claude for 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 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. Starten Sie Claude for 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 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"
      }
    }
  }
}

Nachdem die Verbindung zum Server hergestellt 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 > Cursor-Einstellungen > MCP auf. Wenn die Verbindung zum Server hergestellt wurde, 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 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: 

{
  "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 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"
      }
    }
  }
}

Verbindung mit Antigravity herstellen

Sie können Spanner auf folgende Arten mit Antigravity verbinden:

  • Über den MCP Store
  • Über eine benutzerdefinierte Konfiguration

MCP Store

Die empfohlene Methode, eine Verbindung zu Antigravity herzustellen, ist die Verwendung des integrierten MCP Store.

  1. Öffnen Sie Antigravity und dann den Agentenbereich des Editors.
  2. Klicken Sie oben im Bereich auf das Menüsymbol 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, stehen die Ressourcen und Skills des Servers für den Editor zur Verfügung.

Benutzerdefinierte Konfiguration

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

  1. Öffnen Sie Antigravity und dann den Agentenbereich des Editors.
  2. Klicken Sie oben im Bereich auf das Menüsymbol und wählen Sie MCP-Server aus.
  3. Klicken Sie auf MCP-Server verwalten > Rohkonfiguration ansehen , um die Datei mcp_config.json 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 für den Editor zur Verfügung.

Ersetzen Sie Folgendes:

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

Mit der Data Agent Kit-Erweiterung in VS Code eine Verbindung zu Spanner herstellen

Mit der Google Cloud Data Agent Kit-Erweiterung können Sie Ihre Spanner-Datenbank verwalten und Abfragen für Ihre Spanner-Daten in Ihrer bevorzugten IDE ausführen. Visual Studio Code und alle IDEs, die auf VS Code basieren, werden unterstützt.

Diese Erweiterung bietet Funktionen zur Datenermittlung und ‑exploration, mit denen Sie Fragen zu Ihren Spanner-Daten in natürlicher Sprache stellen können. So müssen Sie nicht mehr zwischen Spanner-Befehlszeilentools und Ihrer Entwicklungsumgebung wechseln. Das Data Agent Kit bietet auch CLI-Plug-ins, die Sie mit Ihren Google Cloud Ressourcen verwenden können.

Weitere Informationen finden Sie unter Übersicht über die Data Agent Kit-Erweiterung für VS Code.