Sicheren Genkit-MCP-Server in Cloud Run bereitstellen

1. Einführung

Übersicht

In diesem Lab erstellen und stellen Sie einen MCP-Server (Model Context Protocol) bereit. MCP-Server sind nützlich, um LLMs Zugriff auf externe Tools und Dienste zu ermöglichen. Sie konfigurieren ihn als sicheren, produktionsbereiten Dienst in Cloud Run, auf den von mehreren Clients aus zugegriffen werden kann. Anschließend stellen Sie über die Gemini CLI eine Verbindung zum Remote-MCP-Server her.

Aufgaben

Wir verwenden Genkit, um einen Zoo-MCP-Server mit zwei Tools zu erstellen: get_animals_by_species und get_animal_details. Mit Genkit lassen sich MCP-Server und ‑Clients schnell mit Node.js erstellen.

Grafik zum MCP-Server für einen Zoo

Lerninhalte

  • MCP-Server in Cloud Run bereitstellen
  • Sichern Sie den Endpunkt Ihres Servers, indem Sie für alle Anfragen eine Authentifizierung verlangen. So können nur autorisierte Clients und Agents mit ihm kommunizieren.
  • Verbindung von der Gemini CLI zu Ihrem sicheren MCP-Serverendpunkt herstellen

2. Projekt einrichten

  1. Wenn Sie noch kein Google-Konto haben, müssen Sie ein Google-Konto erstellen.
    • Verwenden Sie stattdessen ein privates Konto. Bei Arbeitskonten und Konten von Bildungseinrichtungen kann es Einschränkungen geben, die verhindern, dass Sie die für dieses Lab erforderlichen APIs aktivieren.
  2. Melden Sie sich in der Google Cloud Console an.
  3. Aktivieren Sie die Abrechnung in der Cloud Console.
    • Die Cloud-Ressourcen, die für dieses Lab benötigt werden, sollten weniger als 1 $kosten.
    • Sie können die Schritte am Ende dieses Labs ausführen, um Ressourcen zu löschen und so weitere Kosten zu vermeiden.
    • Neue Nutzer haben Anspruch auf die kostenlose Testversion mit einem Guthaben von 300$.
  4. Erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt wieder.
    • Wenn Sie eine Fehlermeldung zum Projektkontingent sehen, verwenden Sie ein vorhandenes Projekt wieder oder löschen Sie ein vorhandenes Projekt, um ein neues zu erstellen.

3. Cloud Shell-Editor öffnen

  1. Klicken Sie auf diesen Link, um direkt zum Cloud Shell-Editor zu gelangen.
  2. Wenn Sie heute an irgendeinem Punkt zur Autorisierung aufgefordert werden, klicken Sie auf Autorisieren, um fortzufahren. Klicken Sie, um Cloud Shell zu autorisieren.
  3. Wenn das Terminal nicht unten auf dem Bildschirm angezeigt wird, öffnen Sie es:
    • Klicken Sie auf Ansehen.
    • Klicken Sie auf TerminalNeues Terminal im Cloud Shell-Editor öffnen.
  4. Legen Sie im Terminal Ihr Projekt mit diesem Befehl fest:
    • Format:
      gcloud config set project [PROJECT_ID]
    • Beispiel:
      gcloud config set project lab-project-id-example
    • Wenn Sie sich nicht an Ihre Projekt-ID erinnern können:
      • Sie können alle Ihre Projekt-IDs mit folgendem Befehl auflisten:
        gcloud projects list | awk '/PROJECT_ID/{print $2}'
      Projekt-ID im Cloud Shell Editor-Terminal festlegen
  5. Es sollte folgende Meldung angezeigt werden:
    Updated property [core/project].
    Wenn Sie WARNING sehen und Do you want to continue (Y/n)? gefragt werden, haben Sie die Projekt-ID wahrscheinlich falsch eingegeben. Drücken Sie n, dann Enter und versuchen Sie, den Befehl gcloud config set project noch einmal auszuführen.

4. APIs aktivieren

Aktivieren Sie die APIs im Terminal:

gcloud services enable \
  run.googleapis.com \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com

Wenn Sie zur Autorisierung aufgefordert werden, klicken Sie auf Autorisieren, um fortzufahren. Klicken Sie, um Cloud Shell zu autorisieren.

Es kann einige Minuten dauern, bis dieser Befehl ausgeführt wird. Wenn die Ausführung erfolgreich war, erhalten Sie eine Meldung, die ungefähr so aussieht:

Operation "operations/acf.p2-73d90d00-47ee-447a-b600" finished successfully.

5. JavaScript-Projekt vorbereiten

  1. Erstellen Sie einen Ordner mit dem Namen mcp-on-cloudrun, um den Quellcode für die Bereitstellung zu speichern:
    mkdir mcp-on-cloudrun && cd mcp-on-cloudrun
  2. Erstellen Sie mit dem Tool npm ein Node.js-Projekt, um eine package.json-Datei zu generieren:
    npm init es6 -y
    Mit dem Befehl npm init wird eine package.json-Datei für Ihr Projekt erstellt.
  3. Installieren Sie die Abhängigkeiten @modelcontextprotocol/sdk, express und zod:
    npm install @modelcontextprotocol/sdk express zod

6. MCP-Server für den Zoo erstellen

Um wertvollen Kontext für die Verbesserung der Verwendung von LLMs mit MCP zu liefern, richten Sie einen Zoo-MCP-Server mit Genkit ein. Genkit ist ein Standard-Framework für die Arbeit mit dem Model Context Protocol. Mit Genkit lassen sich MCP-Server und ‑Clients schnell mit Node.js erstellen. Dieser MCP-Server enthält Daten zu den Tieren in einem fiktiven Zoo. Der Einfachheit halber speichern wir die Daten im Arbeitsspeicher. Für einen Produktions-MCP-Server sollten Sie wahrscheinlich Daten aus Quellen wie Datenbanken oder APIs bereitstellen.

  1. Führen Sie den folgenden Befehl aus, um Genkit als Abhängigkeit in der Datei package.json hinzuzufügen:
    npm install genkit
    Dadurch wird Ihrem Projekt eine package-lock.json-Datei hinzugefügt.
  2. Führen Sie den folgenden Befehl aus, um die Genkit AI MCP-Bibliothek in der Datei package.json hinzuzufügen:
    npm install @genkit-ai/mcp
  3. Erstellen und öffnen Sie eine neue index.js-Datei für den MCP-Server-Quellcode:
    cloudshell edit index.js
    Mit dem Befehl cloudshell edit wird die Datei index.js im Editor über dem Terminal geöffnet.
  4. Fügen Sie der Datei index.js den folgenden Quellcode für den Zoo-MCP-Server hinzu:
    import express from 'express';
import { genkit, z } from 'genkit';
import { createMcpServer } from '@genkit-ai/mcp';
import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';

// Dictionary of animals at the zoo
const ZOO_ANIMALS = [
    {
        "species": "lion",
        "name": "Leo",
        "age": 7,
        "enclosure": "The Big Cat Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "lion",
        "name": "Nala",
        "age": 6,
        "enclosure": "The Big Cat Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "lion",
        "name": "Simba",
        "age": 3,
        "enclosure": "The Big Cat Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "lion",
        "name": "King",
        "age": 8,
        "enclosure": "The Big Cat Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "penguin",
        "name": "Waddles",
        "age": 2,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "penguin",
        "name": "Pip",
        "age": 4,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "penguin",
        "name": "Skipper",
        "age": 5,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "penguin",
        "name": "Chilly",
        "age": 3,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "penguin",
        "name": "Pingu",
        "age": 6,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "penguin",
        "name": "Noot",
        "age": 1,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "elephant",
        "name": "Ellie",
        "age": 15,
        "enclosure": "The Pachyderm Sanctuary",
        "trail": "Savannah Heights"
    },
    {
        "species": "elephant",
        "name": "Peanut",
        "age": 12,
        "enclosure": "The Pachyderm Sanctuary",
        "trail": "Savannah Heights"
    },
    {
        "species": "elephant",
        "name": "Dumbo",
        "age": 5,
        "enclosure": "The Pachyderm Sanctuary",
        "trail": "Savannah Heights"
    },
    {
        "species": "elephant",
        "name": "Trunkers",
        "age": 10,
        "enclosure": "The Pachyderm Sanctuary",
        "trail": "Savannah Heights"
    },
    {
        "species": "bear",
        "name": "Smokey",
        "age": 10,
        "enclosure": "The Grizzly Gulch",
        "trail": "Polar Path"
    },
    {
        "species": "bear",
        "name": "Grizzly",
        "age": 8,
        "enclosure": "The Grizzly Gulch",
        "trail": "Polar Path"
    },
    {
        "species": "bear",
        "name": "Barnaby",
        "age": 6,
        "enclosure": "The Grizzly Gulch",
        "trail": "Polar Path"
    },
    {
        "species": "bear",
        "name": "Bruin",
        "age": 12,
        "enclosure": "The Grizzly Gulch",
        "trail": "Polar Path"
    },
    {
        "species": "giraffe",
        "name": "Gerald",
        "age": 4,
        "enclosure": "The Tall Grass Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "giraffe",
        "name": "Longneck",
        "age": 5,
        "enclosure": "The Tall Grass Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "giraffe",
        "name": "Patches",
        "age": 3,
        "enclosure": "The Tall Grass Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "giraffe",
        "name": "Stretch",
        "age": 6,
        "enclosure": "The Tall Grass Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "antelope",
        "name": "Speedy",
        "age": 2,
        "enclosure": "The Tall Grass Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "antelope",
        "name": "Dash",
        "age": 3,
        "enclosure": "The Tall Grass Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "antelope",
        "name": "Gazelle",
        "age": 4,
        "enclosure": "The Tall Grass Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "antelope",
        "name": "Swift",
        "age": 5,
        "enclosure": "The Tall Grass Plains",
        "trail": "Savannah Heights"
    },
    {
        "species": "polar bear",
        "name": "Snowflake",
        "age": 7,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "polar bear",
        "name": "Blizzard",
        "age": 5,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "polar bear",
        "name": "Iceberg",
        "age": 9,
        "enclosure": "The Arctic Exhibit",
        "trail": "Polar Path"
    },
    {
        "species": "walrus",
        "name": "Wally",
        "age": 10,
        "enclosure": "The Walrus Cove",
        "trail": "Polar Path"
    },
    {
        "species": "walrus",
        "name": "Tusker",
        "age": 12,
        "enclosure": "The Walrus Cove",
        "trail": "Polar Path"
    },
    {
        "species": "walrus",
        "name": "Moby",
        "age": 8,
        "enclosure": "The Walrus Cove",
        "trail": "Polar Path"
    },
    {
        "species": "walrus",
        "name": "Flippers",
        "age": 9,
        "enclosure": "The Walrus Cove",
        "trail": "Polar Path"
    }
];

// Initialize Genkit
const ai = genkit({});

// Define tools using Genkit
ai.defineTool(
    {
        name: 'get_animals_by_species',
        description: "Retrieves all animals of a specific species from the zoo. Can also be used to collect the base data for aggregate queries of animals of a specific species - like counting the number of penguins or finding the oldest lion.",
        inputSchema: z.object({ species: z.string() }),
    },
    async ({ species }) => {
        console.log(`>>> 🛠️ Tool: 'get_animals_by_species' called for '${species}'`);
        const animals = ZOO_ANIMALS.filter(animal => animal.species.toLowerCase() === species.toLowerCase());
        return animals;
    }
);

ai.defineTool(
    {
        name: 'get_animal_details',
        description: "Retrieves the details of a specific animal by its name.",
        inputSchema: z.object({ name: z.string() }),
    },
    async ({ name }) => {
        console.log(`>>> 🛠️ Tool: 'get_animal_details' called for '${name}'`);
        const animal = ZOO_ANIMALS.find(a => a.name.toLowerCase() === name.toLowerCase());
        return animal;
    }
);

// Create Genkit MCP server wrapper
const mcpWrapper = createMcpServer(ai, {
    name: 'zoo-animal-server',
    version: '1.0.0',
});

// HTTP server mode
const app = express();
app.use(express.json());

// Initialize Genkit MCP server once
const mcpServerPromise = mcpWrapper.setup().then(() => mcpWrapper.server);

app.post('/mcp', async (req, res) => {
    console.log('/mcp Received:', req.body);
    console.log('Using HTTP transport mode.');

    const server = await mcpServerPromise;

    const transport = new StreamableHTTPServerTransport({
        sessionIdGenerator: undefined,
    });

    if (!server) {
        console.error('MCP Server not initialized correctly.');
        res.sendStatus(500);
        return;
    }

    await server.connect(transport);
    await transport.handleRequest(req, res, req.body);

    res.on('close', () => {
        console.log('Request closed');
        transport.close();
    });
});

app.get('/mcp', async (req, res) => {
    console.log('Received GET MCP request');
    res.sendStatus(405);
});

app.delete('/mcp', async (req, res) => {
    console.log('Received DELETE MCP request');
    res.sendStatus(405);
});

// Start the server
const PORT = process.env.PORT || 8080;
app.listen(PORT, () => {
    console.log(`Zoo Animal MCP server listening on port ${PORT}`);
});

Ihr Code ist fertig! Jetzt ist es an der Zeit, den MCP-Server in Cloud Run bereitzustellen.

7. In Cloud Run bereitstellen

Stellen Sie nun einen MCP-Server direkt aus dem Quellcode in Cloud Run bereit.

  1. Erstellen Sie ein Dienstkonto mit dem Namen mcp-server-sa:
    gcloud iam service-accounts create mcp-server-sa --display-name="MCP Server Service Account"
  2. Führen Sie den Befehl gcloud aus, um die Anwendung in Cloud Run bereitzustellen.
    gcloud run deploy zoo-mcp-server \
    --service-account=mcp-server-sa@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com \
    --no-allow-unauthenticated \
    --region=europe-west1 \
    --source=. \
    --labels=dev-tutorial=codelab-mcp
    Verwenden Sie das Flag --no-allow-unauthenticated, um eine Authentifizierung zu erzwingen. Das ist aus Sicherheitsgründen wichtig. Wenn Sie keine Authentifizierung benötigen, kann jeder Ihren MCP-Server aufrufen und möglicherweise Ihr System beschädigen.
  3. Bestätigen Sie die Erstellung eines neuen Artifact Registry-Repositorys. Da Sie zum ersten Mal aus Quellcode in Cloud Run bereitstellen, wird Folgendes angezeigt:
    Deploying from source requires an Artifact Registry Docker repository to store built containers. A repository named 
[cloud-run-source-deploy] in region [europe-west1] will be created.

Do you want to continue (Y/n)?
    Geben Sie Y ein und drücken Sie die Enter-Taste. Dadurch wird ein Artifact Registry-Repository für Ihr Deployment erstellt. Dies ist erforderlich, um den Docker-Container des MCP-Servers für den Cloud Run-Dienst zu speichern.
  4. Nach einigen Minuten wird eine Meldung wie die folgende angezeigt:
    Service [zoo-mcp-server] revision [zoo-mcp-server-12345-abc] has been deployed and is serving 100 percent of traffic.

Sie haben Ihren MCP-Server bereitgestellt. Jetzt können Sie es verwenden.

8. Remote-MCP-Server zur Gemini CLI hinzufügen

Nachdem Sie einen Remote-MCP-Server erfolgreich bereitgestellt haben, können Sie mit verschiedenen Anwendungen wie Google Code Assist oder der Gemini CLI eine Verbindung zu ihm herstellen. In diesem Abschnitt stellen wir mit der Gemini CLI eine Verbindung zu Ihrem neuen Remote-MCP-Server her.

  1. Gewähren Sie Ihrem Nutzerkonto die Berechtigung, den Remote-MCP-Server aufzurufen.
    gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
    --member=user:$(gcloud config get-value account) \
    --role='roles/run.invoker'
  2. Speichern Sie Ihre Google Cloud-Anmeldedaten und die Projektnummer in Umgebungsvariablen, um sie in der Gemini-Einstellungsdatei zu verwenden:
    export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
export ID_TOKEN=$(gcloud auth print-identity-token)
  3. Gemini CLI-Einstellungsdatei öffnen
    cloudshell edit ~/.gemini/settings.json
  4. Datei mit Gemini CLI-Einstellungen ersetzen, um den Cloud Run-MCP-Server hinzuzufügen
    {
    "ide": {
        "hasSeenNudge": true
    },
    "mcpServers": {
        "zoo-remote": {
            "httpUrl": "https://zoo-mcp-server-$PROJECT_NUMBER.europe-west1.run.app/mcp",
            "headers": {
                "Authorization": "Bearer $ID_TOKEN"
            }
        }
    },
    "security": {
        "auth": {
            "selectedType": "cloud-shell"
        }
    }
}

  1. Gemini CLI in Cloud Shell starten
    gemini
    Möglicherweise müssen Sie Enter drücken, um einige Standardeinstellungen zu übernehmen.Gemini CLI – Startansicht
  2. Gemini die MCP-Tools auflisten lassen, die ihm im Kontext zur Verfügung stehen
    /mcp
  3. Gemini bitten, etwas im Zoo zu finden
    Where can I find penguins?
    Die Gemini CLI sollte wissen, dass sie den zoo-remote-MCP-Server verwenden soll, und Sie fragen, ob Sie die Ausführung von MCP zulassen möchten.
  4. Verwenden Sie den Abwärtspfeil und drücken Sie dann die Enter-Taste, um eine Option auszuwählen.
    Yes, always allow all tools from server "zoo-remote"
    Gemini CLI-Tools für Zoo-Remote zulassen

Die Ausgabe sollte die richtige Antwort und ein Feld mit dem Hinweis enthalten, dass der MCP-Server verwendet wurde.

Gemini CLI: Ergebnis des Zoo-MCP-Servers anzeigen

Sie haben es geschafft! Sie haben einen Remote-MCP-Server erfolgreich in Cloud Run bereitgestellt und mit der Gemini CLI getestet.

Wenn Sie die Sitzung beenden möchten, geben Sie /quit ein und drücken Sie dann Enter, um die Gemini CLI zu schließen.

Debugging

Wenn Sie einen Fehler wie diesen sehen:

🔍 Attempting OAuth discovery for 'zoo-remote'...
❌ 'zoo-remote' requires authentication but no OAuth configuration found
Error connecting to MCP server 'zoo-remote': MCP server 'zoo-remote' requires authentication. Please configure OAuth or check server settings.

Wahrscheinlich ist das ID-Token abgelaufen und muss noch einmal festgelegt werden.ID_TOKEN

  1. Geben Sie /quit ein und drücken Sie dann Enter, um die Gemini CLI zu beenden.
  2. Projekt im Terminal festlegen 
    gcloud config set project [PROJECT_ID]
  3. Führen Sie den Befehl für die Google Cloud-Anmeldedaten noch einmal aus, um einen neuen ID_TOKEN zu erhalten, da Ihrer möglicherweise abgelaufen ist. 
    export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
export ID_TOKEN=$(gcloud auth print-identity-token)

9. (Optional) Tool-Aufrufe in Serverlogs überprüfen

Prüfen Sie die Dienstlogs, um zu sehen, ob Ihr Cloud Run-MCP-Server aufgerufen wurde.

gcloud run services logs read zoo-mcp-server --region europe-west1 --limit=5

Sie sollten ein Ausgabelog sehen, das bestätigt, dass ein Toolaufruf erfolgt ist. 🛠️

2025-08-05 19:50:31 INFO:     169.254.169.126:39444 - "POST /mcp/ HTTP/1.1" 200 OK
2025-08-05 19:50:31 [INFO]: Processing request of type CallToolRequest
2025-08-05 19:50:31 [INFO]: >>> 🛠️ Tool: 'get_animals_by_species' called for 'penguin'

10. Optional: MCP-Aufforderung zum Server hinzufügen

Mit einem MCP-Prompt können Sie Ihren Workflow für häufig ausgeführte Prompts beschleunigen, indem Sie eine Kurzform für einen längeren Prompt erstellen.

Die Gemini CLI wandelt MCP-Prompts automatisch in benutzerdefinierte Schrägstrichbefehle um. Sie können einen MCP-Prompt also aufrufen, indem Sie /prompt_name eingeben, wobei prompt_name der Name Ihres MCP-Prompts ist.

Erstellen Sie einen MCP-Prompt, damit Sie ein Tier im Zoo schnell finden können, indem Sie /find animal in die Gemini CLI eingeben.

  1. Fügen Sie diesen Code in Ihre index.js-Datei über der Zeile // Create Genkit MCP server wrapper ein: 
    ai.definePrompt(
    {
        name: 'find',
        description: 'Find which exhibit and trail a specific animal is located.',
        inputSchema: z.object({ animal: z.string() }),
    },
    async ({ animal }) => {
        console.log(`>>> 💬 Prompt: 'find' called'`);
        return {
            messages: [
                {
                    role: 'user',
                    content: [
                        { text: `Please find the exhibit and trail information for ${animal} in the zoo. Respond with '[animal] can be found in the [exhibit] on the [trail].' Example: Penguins can be found in The Arctic Exhibit on the Polar Path.` }
                    ]
                }
            ]
        };
    }
);
  2. Anwendung in Cloud Run neu bereitstellen 
    gcloud run deploy zoo-mcp-server \
    --service-account=mcp-server-sa@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com \
    --no-allow-unauthenticated \
    --region=europe-west1 \
    --source=. \
    --labels=dev-tutorial=codelab-mcp
  3. ID_TOKEN für Ihren Remote-MCP-Server aktualisieren 
    export ID_TOKEN=$(gcloud auth print-identity-token)
  4. Nachdem die neue Version Ihrer Anwendung bereitgestellt wurde, starten Sie die Gemini CLI. 
    gemini
  5. Verwenden Sie im Prompt den neuen benutzerdefinierten Befehl, den Sie erstellt haben: 
    /find --animal="lions"

Sie sollten sehen, dass die Gemini CLI das get_animals_by_species-Tool aufruft und die Antwort gemäß dem MCP-Prompt formatiert.

╭───────────────────────────╮
│  > /find --animal="lion"  │
╰───────────────────────────╯

 ╭───────────────────────────────────────────────────────────────────────────────────────────────────╮
 │ ✔  get_animals_by_species (zoo-remote MCP Server) get_animals_by_species (zoo-remote MCP Server)  │
 │                                                                                                   │
 │    [{"species":"lion","name":"Leo","age":7,"enclosure":"The Big Cat                               │
 │    Plains","trail":"Savannah                                                                      │
 │    Heights"},{"species":"lion","name":"Nala","age":6,"enclosure":"The Big Cat                     │
 │    Plains","trail":"Savannah                                                                      │
 │    Heights"},{"species":"lion","name":"Simba","age":3,"enclosure":"The Big Cat                    │
 │    Plains","trail":"Savannah                                                                      │
 │    Heights"},{"species":"lion","name":"King","age":8,"enclosure":"The Big Cat                     │
 │    Plains","trail":"Savannah Heights"}]                                                           │
 ╰───────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ Lions can be found in The Big Cat Plains on the Savannah Heights.

11. Optional: Gemini Flash Lite für schnellere Antworten verwenden

Mit der Gemini CLI können Sie das verwendete Modell auswählen.

  • Gemini 2.5 Pro ist das hochmoderne Denkmodell von Google, das in der Lage ist, komplexe Probleme in Code, Mathematik und MINT zu lösen sowie große Datensätze, Codebasen und Dokumente mit langem Kontext zu analysieren.
  • Gemini 2.5 Flash ist das Modell von Google mit dem besten Preis-Leistungs-Verhältnis und bietet vielseitige Funktionen. 2.5 Flash eignet sich am besten für die Verarbeitung im großen Maßstab, Aufgaben mit niedriger Latenz und hohem Volumen, die Denkprozesse erfordern, sowie für agentische Anwendungsfälle.
  • Gemini 2.5 Flash Lite ist das schnellste Flash-Modell von Google, das für Kosteneffizienz und hohen Durchsatz optimiert ist.

Da für die Anfragen zum Auffinden der Zootiere kein Denken oder Schlussfolgern erforderlich ist, können Sie versuchen, die Dinge zu beschleunigen, indem Sie ein schnelleres Modell verwenden.

Erstellen Sie einen MCP-Prompt, damit Sie ein Tier im Zoo schnell finden können, indem Sie /find animal in die Gemini CLI eingeben.

  1. Nachdem die neue Version Ihrer Anwendung bereitgestellt wurde, starten Sie die Gemini CLI. 
    gemini --model=gemini-2.5-flash-lite
  2. Verwenden Sie im Prompt den neuen benutzerdefinierten Befehl, den Sie erstellt haben: 
    /find --animal="lions"

Sie sollten weiterhin sehen, dass die Gemini CLI das Tool get_animals_by_species aufruft und die Antwort wie im MCP-Prompt angegeben formatiert, aber die Antwort sollte viel schneller angezeigt werden.

╭───────────────────────────╮
│  > /find --animal="lion"  │
╰───────────────────────────╯

 ╭───────────────────────────────────────────────────────────────────────────────────────────────────╮
 │ ✔  get_animals_by_species (zoo-remote MCP Server) get_animals_by_species (zoo-remote MCP Server)  │
 │                                                                                                   │
 │    [{"species":"lion","name":"Leo","age":7,"enclosure":"The Big Cat                               │
 │    Plains","trail":"Savannah                                                                      │
 │    Heights"},{"species":"lion","name":"Nala","age":6,"enclosure":"The Big Cat                     │
 │    Plains","trail":"Savannah                                                                      │
 │    Heights"},{"species":"lion","name":"Simba","age":3,"enclosure":"The Big Cat                    │
 │    Plains","trail":"Savannah                                                                      │
 │    Heights"},{"species":"lion","name":"King","age":8,"enclosure":"The Big Cat                     │
 │    Plains","trail":"Savannah Heights"}]                                                           │
 ╰───────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ Lions can be found in The Big Cat Plains on the Savannah Heights.

Hochgesteckte Ziele, um dich selbst herauszufordern

Als zusätzliche Herausforderung können Sie versuchen, mit denselben Schritten einen Prompt zu erstellen, mit dem Sie interessante Fakten über bestimmte Tierarten im Zoo erhalten.

Oder Sie können sich eine Idee für ein Tool überlegen, das Sie häufig verwenden würden, und einen zweiten Remote-MCP-Server bereitstellen, um das Gelernte zu testen. Fügen Sie sie dann Ihren Gemini CLI-Einstellungen hinzu, um zu sehen, ob sie funktioniert.

Debugging

Wenn Sie einen Fehler wie diesen sehen:

✕ Unknown command: /find --animal="lions"

Führen Sie /mcp aus. Wenn zoo-remote - Disconnected ausgegeben wird, müssen Sie die Bereitstellung möglicherweise noch einmal durchführen oder die folgenden Befehle noch einmal ausführen:

gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
    --member=user:$(gcloud config get-value account) \
    --role='roles/run.invoker'

export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
export ID_TOKEN=$(gcloud auth print-identity-token)

12. Fazit

Glückwunsch! Sie haben einen sicheren Remote-MCP-Server erfolgreich bereitgestellt und eine Verbindung dazu hergestellt.

Mit dem nächsten Lab fortfahren

Dieses Lab ist das erste von drei Labs. Im zweiten Lab verwenden Sie den MCP-Server, den Sie mit einem ADK-Agenten erstellt haben.

MCP-Server in Cloud Run mit einem ADK-KI-Agenten verwenden

Optional: Bereinigen

Wenn Sie nicht mit dem nächsten Lab fortfahren und die erstellten Ressourcen bereinigen möchten, können Sie Ihr Cloud-Projekt löschen, um zusätzliche Gebühren zu vermeiden.

Während für Cloud Run keine Kosten anfallen, wenn der Dienst nicht verwendet wird, wird Ihnen dennoch das Speichern des Container-Images in Artifact Registry möglicherweise in Rechnung gestellt. Durch das Löschen des Cloud-Projekts wird die Abrechnung für alle in diesem Projekt verwendeten Ressourcen beendet.

Wenn Sie möchten, können Sie das Projekt löschen:

gcloud projects delete $GOOGLE_CLOUD_PROJECT

Möglicherweise möchten Sie auch unnötige Ressourcen von Ihrer Cloud Shell-Festplatte löschen. Sie haben folgende Möglichkeiten:

  1. Löschen Sie das Codelab-Projektverzeichnis: 
    rm -rf ~/mcp-on-cloudrun
  2. Warnung! Diese Aktion kann nicht rückgängig gemacht werden. Wenn Sie alles in Ihrer Cloud Shell löschen möchten, um Speicherplatz freizugeben, können Sie Ihr gesamtes Basisverzeichnis löschen. Achten Sie darauf, dass alles, was Sie behalten möchten, an einem anderen Ort gespeichert ist. 
    sudo rm -rf $HOME