Jak wdrożyć bezpieczny serwer MCP Genkit w Cloud Run

1. Wprowadzenie

Przegląd

W tym laboratorium utworzysz i wdrożysz serwer Model Context Protocol (MCP). Serwery MCP są przydatne, ponieważ zapewniają LLM dostęp do narzędzi i usług zewnętrznych. Skonfigurujesz ją jako bezpieczną usługę przygotowaną do zastosowań produkcyjnych w Cloud Run, do której można uzyskać dostęp z wielu klientów. Następnie połączysz się ze zdalnym serwerem MCP z interfejsu wiersza poleceń Gemini.

Jakie zadania wykonasz

Do utworzenia serwera MCP zoo, który ma 2 narzędzia: get_animals_by_species i get_animal_details, użyjemy Genkit. Genkit umożliwia szybkie tworzenie serwerów i klientów MCP w Node.js.

Grafika serwera MCP w zoo

Czego się nauczysz

  • wdrożyć serwer MCP w Cloud Run;
  • Zabezpiecz punkt końcowy serwera, wymagając uwierzytelniania wszystkich żądań, aby tylko autoryzowani klienci i agenci mogli się z nim komunikować.
  • Nawiązywanie połączenia z bezpiecznym punktem końcowym serwera MCP za pomocą interfejsu wiersza poleceń Gemini

2. Konfiguracja projektu

  1. Jeśli nie masz jeszcze konta Google, musisz je utworzyć.
    • Używaj konta osobistego zamiast konta służbowego lub szkolnego. Konta służbowe i szkolne mogą mieć ograniczenia, które uniemożliwiają włączenie interfejsów API potrzebnych do tego ćwiczenia.
  2. Zaloguj się w konsoli Google Cloud.
  3. Włącz płatności w konsoli Google Cloud.
  4. Utwórz nowy projekt lub użyj już istniejącego.
    • Jeśli zobaczysz błąd dotyczący limitu projektu, użyj ponownie istniejącego projektu lub usuń go, aby utworzyć nowy.

3. Otwórz edytor Cloud Shell

  1. Kliknij ten link, aby przejść bezpośrednio do edytora Cloud Shell
  2. Jeśli w dowolnym momencie pojawi się prośba o autoryzację, kliknij Autoryzuj, aby kontynuować. Kliknij, aby uwierzytelnić się w Cloud Shell
  3. Jeśli terminal nie pojawi się u dołu ekranu, otwórz go:
    • Kliknij Wyświetl.
    • Kliknij TerminalOtwieranie nowego terminala w edytorze Cloud Shell.
  4. W terminalu ustaw projekt za pomocą tego polecenia:
    • Format:
      gcloud config set project [PROJECT_ID]
    • Przykład:
      gcloud config set project lab-project-id-example
    • Jeśli nie pamiętasz identyfikatora projektu:
      • Aby wyświetlić listę wszystkich identyfikatorów projektów, użyj tego polecenia:
        gcloud projects list | awk '/PROJECT_ID/{print $2}'
      Ustawianie identyfikatora projektu w terminalu edytora Cloud Shell
  5. Powinien wyświetlić się ten komunikat:
    Updated property [core/project].
    Jeśli widzisz symbol WARNING i pojawia się pytanie Do you want to continue (Y/n)?, prawdopodobnie identyfikator projektu został wpisany nieprawidłowo. Naciśnij n, a następnie Enter i spróbuj ponownie uruchomić polecenie gcloud config set project.

4. Włącz interfejsy API

W terminalu włącz interfejsy API:

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

Jeśli pojawi się prośba o autoryzację, kliknij Autoryzuj, aby przejść dalej. Kliknij, aby uwierzytelnić się w Cloud Shell

Wykonanie tego polecenia może potrwać kilka minut, ale powinno ostatecznie wyświetlić komunikat o sukcesie podobny do tego:

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

5. Przygotowywanie projektu JavaScript

  1. Utwórz folder o nazwie mcp-on-cloudrun, w którym będzie przechowywany kod źródłowy do wdrożenia:
    mkdir mcp-on-cloudrun && cd mcp-on-cloudrun
  2. Utwórz projekt Node.js za pomocą narzędzia npm, aby wygenerować plik package.json:
    npm init es6 -y
    Polecenie npm init tworzy plik package.json na potrzeby projektu.
  3. Zainstaluj zależności @modelcontextprotocol/sdk, express i zod:
    npm install @modelcontextprotocol/sdk express zod

6. Tworzenie serwera MCP zoo

Aby zapewnić przydatny kontekst do ulepszania korzystania z LLM z MCP, skonfiguruj serwer MCP w usłudze Zoo za pomocą Genkit – standardowej platformy do pracy z protokołem Model Context Protocol. Genkit umożliwia szybkie tworzenie serwerów i klientów MCP w Node.js. Ten serwer MCP dostarcza dane o zwierzętach w fikcyjnym zoo. Dla uproszczenia przechowujemy dane w pamięci. W przypadku serwera MCP w środowisku produkcyjnym warto udostępniać dane ze źródeł takich jak bazy danych lub interfejsy API.

  1. Aby dodać Genkit jako zależność w pliku package.json, uruchom to polecenie:
    npm install genkit
    Spowoduje to dodanie do projektu pliku package-lock.json.
  2. Aby dodać bibliotekę Genkit AI MCP do pliku package.json, uruchom to polecenie:
    npm install @genkit-ai/mcp
  3. Utwórz i otwórz nowy plik index.js z kodem źródłowym serwera MCP:
    cloudshell edit index.js
    Polecenie cloudshell edit otworzy plik index.js w edytorze nad terminalem.
  4. Dodaj do pliku index.js ten kod źródłowy serwera MCP zoo:
    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}`);
});

Kod jest gotowy. Czas wdrożyć serwer MCP w Cloud Run.

7. Wdrażanie w Cloud Run

Teraz wdróż serwer MCP w Cloud Run bezpośrednio z kodu źródłowego.

  1. Utwórz konto usługi o nazwie mcp-server-sa:
    gcloud iam service-accounts create mcp-server-sa --display-name="MCP Server Service Account"
  2. Uruchom polecenie gcloud, aby wdrożyć aplikację w Cloud Run.
    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
    Użyj flagi --no-allow-unauthenticated, aby wymagać uwierzytelniania. Jest to ważne ze względów bezpieczeństwa. Jeśli nie wymagane jest uwierzytelnianie, każdy może wywołać serwer MCP i potencjalnie uszkodzić system.
  3. Potwierdź utworzenie nowego repozytorium Artifact Registry. Ponieważ po raz pierwszy wdrażasz w Cloud Run kod źródłowy, zobaczysz:
    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)?
    Wpisz Y i naciśnij Enter. Spowoduje to utworzenie repozytorium Artifact Registry na potrzeby wdrożenia. Jest to wymagane do przechowywania kontenera Docker serwera MCP na potrzeby usługi Cloud Run.
  4. Po kilku minutach zobaczysz komunikat podobny do tego:
    Service [zoo-mcp-server] revision [zoo-mcp-server-12345-abc] has been deployed and is serving 100 percent of traffic.

Serwer MCP został wdrożony. Teraz możesz z niej korzystać.

8. Dodawanie zdalnego serwera MCP do interfejsu wiersza poleceń Gemini

Po wdrożeniu zdalnego serwera MCP możesz połączyć się z nim za pomocą różnych aplikacji, takich jak Google Code Assist czy interfejs wiersza poleceń Gemini. W tej sekcji nawiążemy połączenie z nowym zdalnym serwerem MCP za pomocą interfejsu wiersza poleceń Gemini.

  1. Przyznaj kontu użytkownika uprawnienia do wywoływania zdalnego serwera MCP.
    gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
    --member=user:$(gcloud config get-value account) \
    --role='roles/run.invoker'
  2. Zapisz dane logowania do Google Cloud i numer projektu w zmiennych środowiskowych, aby użyć ich w pliku ustawień Gemini:
    export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
export ID_TOKEN=$(gcloud auth print-identity-token)
  3. Otwórz plik ustawień interfejsu wiersza poleceń Gemini
    cloudshell edit ~/.gemini/settings.json
  4. Zastąp plik ustawień interfejsu wiersza poleceń Gemini, aby dodać serwer MCP Cloud Run
    {
    "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. Uruchamianie interfejsu wiersza poleceń Gemini w Cloud Shell
    gemini
    Aby zaakceptować niektóre ustawienia domyślne, może być konieczne naciśnięcie Enter.Widok początkowy interfejsu wiersza poleceń Gemini
  2. Poproś Gemini o wyświetlenie narzędzi MCP dostępnych w kontekście.
    /mcp
  3. Poproś Gemini o znalezienie czegoś w zoo
    Where can I find penguins?
    Interfejs wiersza poleceń Gemini powinien wiedzieć, że ma używać zoo-remote serwera MCP, i zapyta, czy chcesz zezwolić na wykonanie MCP.
  4. Użyj strzałki w dół, a następnie naciśnij Enter, aby wybrać.
    Yes, always allow all tools from server "zoo-remote"
    Gemini CLI allow zoo remote tools

Wynik powinien zawierać prawidłową odpowiedź i pole wyświetlania wskazujące, że użyto serwera MCP.

Wyświetlanie wyniku serwera MCP w interfejsie wiersza poleceń Gemini

Udało Ci się! Udało Ci się wdrożyć zdalny serwer MCP w Cloud Run i przetestować go za pomocą interfejsu wiersza poleceń Gemini.

Gdy chcesz zakończyć sesję, wpisz /quit, a potem naciśnij Enter, aby zamknąć interfejs wiersza poleceń Gemini.

Debugowanie

Jeśli zobaczysz błąd podobny do tego:

🔍 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.

Prawdopodobnie token identyfikatora wygasł i wymaga ponownego ustawienia ID_TOKEN.

  1. Wpisz /quit, a potem naciśnij Enter, aby zamknąć interfejs wiersza poleceń Gemini.
  2. Ustawianie projektu w terminalu 
    gcloud config set project [PROJECT_ID]
  3. Ponownie uruchom polecenie danych logowania Google Cloud, aby uzyskać nowy ID_TOKEN, ponieważ Twój mógł wygasnąć. 
    export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
export ID_TOKEN=$(gcloud auth print-identity-token)

9. (Opcjonalnie) Sprawdzanie wywołań narzędzi w logach serwera

Aby sprawdzić, czy serwer MCP Cloud Run został wywołany, przejrzyj logi usługi.

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

Powinien pojawić się dziennik wyjściowy z potwierdzeniem, że wywołano narzędzie. 🛠️

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. (Opcjonalnie) Dodaj prompt MCP do serwera

Prompt MCP może przyspieszyć pracę w przypadku promptów, których często używasz, ponieważ tworzy skrót dla dłuższego prompta.

Interfejs wiersza poleceń Gemini automatycznie przekształca prompty MCP w niestandardowe polecenia z ukośnikiem, dzięki czemu możesz wywołać prompta MCP, wpisując /prompt_name, gdzie prompt_name to nazwa prompta MCP.

Utwórz prompt MCP, aby szybko znaleźć zwierzę w zoo, wpisując /find animal w interfejsie wiersza poleceń Gemini.

  1. Dodaj ten kod do pliku index.js nad wierszem // Create Genkit MCP server wrapper: 
    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. Ponowne wdrażanie aplikacji w Cloud Run 
    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. Odświeżanie ID_TOKEN na zdalnym serwerze MCP 
    export ID_TOKEN=$(gcloud auth print-identity-token)
  4. Po wdrożeniu nowej wersji aplikacji uruchom interfejs wiersza poleceń Gemini. 
    gemini
  5. W prompcie użyj nowego polecenia niestandardowego, które zostało utworzone: 
    /find --animal="lions"

Powinno się pojawić, że interfejs wiersza poleceń Gemini wywołuje narzędzie get_animals_by_species i formatuje odpowiedź zgodnie z instrukcjami w promptcie MCP.

╭───────────────────────────╮
│  > /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. (Opcjonalnie) Użyj Gemini Flash Lite, aby uzyskać szybsze odpowiedzi

Interfejs wiersza poleceń Gemini umożliwia wybór używanego modelu.

  • Gemini 2.5 Pro to najnowocześniejszy model myślący od Google, który potrafi rozumować w przypadku złożonych problemów związanych z kodem, matematyką i naukami przyrodniczymi, techniką, inżynierią i matematyką, a także analizować duże zbiory danych, bazy kodu i dokumenty przy użyciu długiego kontekstu.
  • Gemini 2.5 Flash to najlepszy model Google pod względem stosunku ceny do wydajności, który oferuje wszechstronne możliwości. 2.5 Flash najlepiej sprawdza się w przypadku przetwarzania na dużą skalę, zadań o krótkim czasie oczekiwania i dużej liczbie, które wymagają myślenia, oraz w przypadku zastosowań związanych z agentami.
  • Gemini 2.5 Flash Lite to najszybszy model flash firmy Google zoptymalizowany pod kątem niskich kosztów i wysokiej przepustowości.

Ponieważ prośby związane ze znalezieniem zwierząt w zoo nie wymagają myślenia ani rozumowania, spróbuj przyspieszyć działanie, używając szybszego modelu.

Utwórz prompt MCP, aby szybko znaleźć zwierzę w zoo, wpisując /find animal w interfejsie wiersza poleceń Gemini.

  1. Po wdrożeniu nowej wersji aplikacji uruchom interfejs wiersza poleceń Gemini. 
    gemini --model=gemini-2.5-flash-lite
  2. W prompcie użyj nowego polecenia niestandardowego, które zostało utworzone: 
    /find --animal="lions"

Nadal powinna być widoczna informacja, że interfejs wiersza poleceń Gemini wywołuje narzędzie get_animals_by_species i formatuje odpowiedź zgodnie z instrukcjami w prompcie MCP, ale odpowiedź powinna pojawić się znacznie szybciej.

╭───────────────────────────╮
│  > /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.

Cele dodatkowe, które pozwolą Ci sprawdzić swoje możliwości

Aby podnieść sobie poprzeczkę, spróbuj wykonać te same czynności, aby utworzyć prompta, który będzie zwracać ciekawe fakty na temat konkretnych gatunków zwierząt w zoo.

Możesz też sprawdzić swoją wiedzę, wymyślając narzędzie, z którego będziesz często korzystać, i wdrażając drugi zdalny serwer MCP. Następnie dodaj go do ustawień interfejsu wiersza poleceń Gemini, aby sprawdzić, czy działa.

Debugowanie

Jeśli zobaczysz błąd podobny do tego:

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

Spróbuj uruchomić polecenie /mcp. Jeśli zwróci ono wartość zoo-remote - Disconnected, może być konieczne ponowne wdrożenie lub ponowne uruchomienie tych poleceń:

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. Podsumowanie

Gratulacje! Udało Ci się wdrożyć bezpieczny zdalny serwer MCP i nawiązać z nim połączenie.

Przejdź do następnego laboratorium

Ten moduł jest pierwszym z trzech modułów w tej serii. W drugim laboratorium użyjesz utworzonego serwera MCP z agentem ADK.

Używanie serwera MCP w Cloud Run z agentem ADK

(Opcjonalnie) Zwalnianie miejsca

Jeśli nie chcesz kontynuować pracy w kolejnym laboratorium i chcesz zwalniać miejsce, możesz usunąć projekt w chmurze, aby uniknąć dodatkowych opłat.

Cloud Run nie nalicza opłat, gdy usługa nie jest używana, ale może zostać pobrana należność za przechowywanie obrazu kontenera w Artifact Registry. Usunięcie projektu w chmurze spowoduje zaprzestanie naliczania opłat za wszelkie zasoby wykorzystywane w ramach tego projektu.

Jeśli chcesz, usuń projekt:

gcloud projects delete $GOOGLE_CLOUD_PROJECT

Możesz też usunąć niepotrzebne zasoby z dysku Cloud Shell. Możesz:

  1. Usuń katalog projektu ćwiczeń z programowania: 
    rm -rf ~/mcp-on-cloudrun
  2. Ostrzeżenie! Tej czynności nie można cofnąć. Jeśli chcesz usunąć wszystko z Cloud Shell, aby zwolnić miejsce, możesz usunąć cały katalog domowy. Upewnij się, że wszystko, co chcesz zachować, jest zapisane w innym miejscu. 
    sudo rm -rf $HOME