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. Mit dieser Erweiterung müssen Sie keine separate Serververbindung einrichten. Sie können Gemini Code Assist so konfigurieren, dass die Gemini CLI verwendet wird. Dadurch erhalten Sie ä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-Agenten mit Ihren Daten verbinden können. Sie übernimmt Aufgaben wie die Authentifizierung und das Verbindungspooling, sodass Sie direkt von Ihrer IDE aus 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 mit der MCP Toolbox zusätzliche Funktionen bietet. Die Erweiterung bietet einen Installationsprozess und eine Reihe von Tools sowie detaillierte Informationen zur Installation, Konfiguration und zu Anwendungsbeispielen. 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 Tools zum Auflisten von Tabellen und zum Ausführen von SQL- und SQL-DQL-Anweisungen.

Tools Beispiel für einen Prompt in natürlicher Sprache
list_tables Welche Tabellen habe ich in meiner Spanner-Instanz?
execute_sql Testdaten in die Tabelle „products“ einfügen.
execute_sql_dql Welche Produkte der Kategorie „electronics“ werden in Amerika verkauft?

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-Datenbanknutzer (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

Agententool einrichten

In diesem Abschnitt wird beschrieben, wie Sie verschiedene Entwicklertools so konfigurieren, dass sie eine Verbindung zu Ihrer Spanner-Instanz herstellen. Wählen Sie Ihr Agententool 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:
    3.   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: Ihre Google Cloud Projekt-ID.
    • INSTANCE_NAME: Name Ihrer Spanner-Instanz.
    • DATABASE_NAME: Name Ihrer Spanner-Datenbank.
    • DIALECT_NAME: Ihr Spanner-SQL Dialekt. Akzeptiert googlesql oder postgresql. Wenn nicht definiert, wird standardmäßig auf googlesql gesetzt.
  4. Starten Sie die Gemini CLI im interaktiven Modus: 
        gemini
    Die CLI lädt automatisch die Spanner-Erweiterung für die Gemini CLI und die zugehörigen Tools, mit denen Sie mit Ihrer Datenbank interagieren können.

Gemini Code Assist

Wir empfehlen dringend, Gemini Code Assist so zu konfigurieren, dass die Gemini CLI verwendet wird. So müssen Sie keinen MCP-Server manuell konfigurieren. Die Anleitung zum manuellen Konfigurieren eines MCP-Servers finden Sie jedoch 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 des 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: Name Ihrer Spanner-Instanz.
  • 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. Erstellen Sie im Stammverzeichnis des Projekts die Datei .mcp.json, falls sie noch nicht vorhanden ist.
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"
      }
    }
  }
}

Claude für den Computer


1. Öffnen Sie Claude für den Computer 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 für den Computer 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 im Stammverzeichnis des Projekts das Verzeichnis .cursor, 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 das Verzeichnis .vscode im Stammverzeichnis des Projekts, 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 zum Herstellen einer Verbindung zu Antigravity ist die Verwendung des integrierten MCP Store.

  1. Öffnen Sie Antigravity und dann das Agentenfeld des Editors.
  2. Klicken Sie oben im Feld 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 Tools 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 das Agentenfeld des Editors.
  2. Klicken Sie oben im Feld 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 Tools des Spanner-Servers für den Editor zur Verfügung.

Ersetzen Sie Folgendes:

  • PROJECT_ID: Ihre Google Cloud Projekt-ID.
  • INSTANCE_NAME: Name Ihrer Spanner-Instanz.
  • 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.