Jak wdrożyć bezpieczny serwer MCP w Cloud Run

1. Wprowadzenie

Przegląd

W tym ćwiczeniu utworzysz i wdrożysz serwer Model Context Protocol (MCP). Serwery MCP są przydatne do zapewniania LLM dostępu do narzędzi i usług zewnętrznych. Skonfigurujesz go jako bezpieczną usługę gotową do wdrożenia 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ń Antigravity.

Jakie zadania wykonasz

Użyjemy FastMCP, aby utworzyć serwer MCP zoo z 2 narzędziami: get_animals_by_species i get_animal_details. FastMCP to szybki sposób na tworzenie serwerów i klientów MCP w Pythonie.

Grafika serwera MCP w zoo

Czego się nauczysz

  • Wdrażanie serwera MCP w Cloud Run.
  • Zabezpieczanie punktu końcowego serwera przez wymaganie uwierzytelnienia w przypadku wszystkich żądań, aby tylko autoryzowani klienci i agenci mogli się z nim komunikować.
  • Łączenie się z bezpiecznym punktem końcowym serwera MCP z interfejsu wiersza poleceń Antigravity.

2. Konfiguracja projektu

  1. Jeśli nie masz jeszcze konta Google, musisz je utworzyć.
    • Użyj 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. Utwórz nowy projekt lub użyj istniejącego.
    • Jeśli zobaczysz błąd dotyczący limitu projektu, użyj 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 pojawia 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:
      • Możesz wyświetlić listę wszystkich identyfikatorów projektów za pomocą tego polecenia:
        gcloud projects list | awk '/PROJECT_ID/{print $2}'
      Ustawianie identyfikatora projektu w terminalu edytora Cloud Shell
  5. Powinien pojawić się ten komunikat:
    Updated property [core/project].
    Jeśli zobaczysz WARNING i pytanie Do you want to continue (Y/n)?, prawdopodobnie wpisano nieprawidłowy identyfikator projektu. Naciśnij n, a potem 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 kontynuować. Kliknij, aby uwierzytelnić się w Cloud Shell

Wykonanie tego polecenia może potrwać kilka minut, ale ostatecznie powinien się pojawić komunikat o powodzeniu podobny do tego:

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

5. Przygotuj projekt w Pythonie

  1. Utwórz folder o nazwie mcp-on-cloudrun, aby przechowywać kod źródłowy do wdrożenia:
    mkdir mcp-on-cloudrun && cd mcp-on-cloudrun
  2. Utwórz projekt w Pythonie za pomocą narzędzia uv, aby wygenerować plik pyproject.toml:
    uv init --description "Example of deploying an MCP server on Cloud Run" --bare --python 3.13
    Polecenie uv init tworzy plik pyproject.toml dla Twojego projektu.Aby wyświetlić zawartość pliku, uruchom to polecenie:
    cat pyproject.toml
    Dane wyjściowe powinny wyglądać tak:
    [project]
name = "mcp-on-cloudrun"
version = "0.1.0"
description = "Example of deploying an MCP server on Cloud Run"
requires-python = ">=3.13"
dependencies = []

6. Utwórz serwer MCP zoo

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

  1. Uruchom to polecenie, aby dodać FastMCP jako zależność w pliku pyproject.toml:
    uv add fastmcp==2.12.4 --no-sync
    Spowoduje to dodanie do projektu pliku uv.lock.
  2. Utwórz i otwórz nowy plik server.py z kodem źródłowym serwera MCP:
    cloudshell edit ~/mcp-on-cloudrun/server.py
    Polecenie cloudshell edit otworzy plik server.py w edytorze nad terminalem.
  3. Dodaj do pliku server.py ten kod źródłowy serwera MCP zoo:
    import asyncio
import logging
import os
from typing import List, Dict, Any

from fastmcp import FastMCP

logger = logging.getLogger(__name__)
logging.basicConfig(format="[%(levelname)s]: %(message)s", level=logging.INFO)

mcp = FastMCP("Zoo Animal MCP Server 🦁🐧🐻")

# Dictionary of animals at the zoo
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"
    }
]

@mcp.tool()
def get_animals_by_species(species: str) -> List[Dict[str, Any]]:
    """
    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.

    Args:
        species: The species of the animal (e.g., 'lion', 'penguin').

    Returns:
        A list of dictionaries, where each dictionary represents an animal
        and contains details like name, age, enclosure, and trail.
    """
    logger.info(f">>> 🛠️ Tool: 'get_animals_by_species' called for '{species}'")
    return [animal for animal in ZOO_ANIMALS if animal["species"].lower() == species.lower()]

@mcp.tool()
def get_animal_details(name: str) -> Dict[str, Any]:
    """
    Retrieves the details of a specific animal by its name.

    Args:
        name: The name of the animal.

    Returns:
        A dictionary with the animal's details (species, name, age, enclosure, trail)
        or an empty dictionary if the animal is not found.
    """
    logger.info(f">>> 🛠️ Tool: 'get_animal_details' called for '{name}'")
    for animal in ZOO_ANIMALS:
        if animal["name"].lower() == name.lower():
            return animal
    return {}

if __name__ == "__main__":
    port = int(os.getenv("PORT", 8080))
    logger.info(f"🚀 MCP server started on port {port}")
    asyncio.run(
        mcp.run_async(
            transport="http",
            host="0.0.0.0",
            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 i otwórz nowy plik Dockerfile do wdrożenia w Cloud Run:
    cloudshell edit ~/mcp-on-cloudrun/Dockerfile
  2. Dodaj do pliku Dockerfile ten kod, aby używać narzędzia uv do uruchamiania pliku server.py:
    # Use the official Python image
FROM python:3.13-slim

# Install uv
COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/

# Install the project into /app
COPY . /app
WORKDIR /app

# Allow statements and log messages to immediately appear in the logs
ENV PYTHONUNBUFFERED=1

# Install dependencies
RUN uv sync

EXPOSE $PORT

# Run the FastMCP server
CMD ["uv", "run", "server.py"]
  3. Utwórz konto usługi o nazwie mcp-server-sa:
    gcloud iam service-accounts create mcp-server-sa --display-name="MCP Server Service Account"
  4. Uruchom polecenie gcloud, aby wdrożyć aplikację w Cloud Run.
    cd ~/mcp-on-cloudrun
gcloud run deploy zoo-mcp-server \
    --service-account=mcp-server-sa@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com \
    --no-allow-unauthenticated \
    --region=us-west1 \
    --source=. \
    --labels=dev-tutorial=codelab-mcp
    Użyj flagi --no-allow-unauthenticated, aby wymagać uwierzytelnienia. Jest to ważne ze względów bezpieczeństwa. Jeśli nie będziesz wymagać uwierzytelnienia, każdy będzie mógł wywołać Twój serwer MCP i potencjalnie spowodować uszkodzenie systemu.
  5. Potwierdź utworzenie nowego repozytorium Artifact Registry. Ponieważ po raz pierwszy wdrażasz w Cloud Run z kodu źródłowego, zobaczysz:
    Deploying from source requires an Artifact Registry Docker repository to store built containers. A repository named
[cloud-run-source-deploy] in region [us-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 Dockera serwera MCP na potrzeby usługi Cloud Run.
  6. 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. Możesz go teraz używać.

8. Dodaj zdalny serwer MCP do interfejsu wiersza poleceń Antigravity

Po pomyślnym wdrożeniu zdalnego serwera MCP możesz się z nim połączyć za pomocą różnych aplikacji, takich jak Google Code Assist czy Antigravity CLI. W tej sekcji nawiążemy połączenie z nowym zdalnym serwerem MCP za pomocą Antigravity CLI.

  1. Przyznaj swojemu 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żywać ich w pliku ustawień Antigravity:
    export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
export ID_TOKEN=$(gcloud auth print-identity-token)
  3. Utwórz folder .gemini/antigravity-cli, jeśli nie został jeszcze utworzony.
    mkdir -p ~/.gemini/antigravity-cli
  4. Zapisz zdalny serwer MCP w pliku konfiguracji MCP interfejsu wiersza poleceń Antigravity:
    cat > ~/.gemini/antigravity-cli/mcp_config.json << EOF
{
    "mcpServers": {
        "zoo-remote": {
            "serverUrl": "https://zoo-mcp-server-${PROJECT_NUMBER}.us-west1.run.app/mcp",
            "headers": {
                "Authorization": "Bearer ${ID_TOKEN}"
            }
        }
    }
}
EOF
  5. Uruchom interfejs wiersza poleceń Antigravity:
    agy
  1. Uwierzytelnij się w Antigravity CLI. Podczas pierwszego uruchomienia wymagane jest uwierzytelnienie. Wybierz OAuth (naciśnij Enter).Ekran uwierzytelniania Antygravity
  2. Kliknij link (jeśli nie można kliknąć, zaznacz adres URL w Cloud Shell, aby go skopiować, a następnie wklej go w przeglądarce).
  3. Zaloguj się na konto Google.
  4. Skopiuj kod.
  5. Wklej kod w terminalu edytora Cloud Shell.
  6. Naciśnij Enter.Prośba o kod zabezpieczający Antigravity
  7. Naciśnij Enter, aby zaakceptować niektóre ustawienia domyślne.
  8. Poproś Antigravity CLI o wyświetlenie listy narzędzi MCP dostępnych w jego kontekście.
    /mcp
    Naciśnij ESC, aby wrócić do pola prompta.
  9. Poproś interfejs wiersza poleceń Antigravity o znalezienie czegoś w zoo.
    Where can I find penguins?
    Interfejs wiersza poleceń Antigravity powinien wiedzieć, że ma użyć serwera MCP zoo-remote, i zapyta, czy chcesz zezwolić na wykonanie MCP.
  10. Użyj strzałki w dół, a następnie naciśnij Enter, aby wybrać.
    Yes, always allow all tools from server "zoo-remote"
    Antigravity CLI allow zoo remote tools

Dane wyjściowe powinny zawierać prawidłową odpowiedź i pole wskazujące, że użyto serwera MCP.

Wynik polecenia Antigravity CLI show zoo mcp server

Udało się! Udało Ci się wdrożyć zdalny serwer MCP w Cloud Run i przetestować go za pomocą Antigravity CLI.

Gdy będziesz gotowy(-a) do zakończenia sesji, wpisz /exit i naciśnij Enter, aby zamknąć Antigravity CLI.

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 upłynął limit czasu tokena identyfikatora i trzeba ponownie ustawić ID_TOKEN.

  1. Wpisz /exit i naciśnij Enter, aby zamknąć Antigravity CLI.
  2. Ustaw projekt w terminalu. 
    gcloud config set project [PROJECT_ID]
  3. Uruchom ponownie polecenie danych logowania do Google Cloud, aby uzyskać nowy ID_TOKEN, ponieważ Twój mógł wygasnąć, i ponownie zapisz plik konfiguracji: 
    export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
export ID_TOKEN=$(gcloud auth print-identity-token)

cat > ~/.gemini/antigravity-cli/mcp_config.json << EOF

{ "mcpServers": { "zoo-remote": { "serverUrl": "https://zoo-mcp-server-${PROJECT_NUMBER}.us-west1.run.app/mcp", "headers": { "Authorization": "Bearer ${ID_TOKEN}" } } } } EOF ```

9. (Opcjonalnie) Sprawdź wywołania narzędzi w logach serwera

Aby sprawdzić, czy wywołano serwer MCP Cloud Run, sprawdź logi usługi.

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

Powinien się pojawić log potwierdzający, ż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 często używanych promptów, tworząc skrót do dłuższego prompta.

Interfejs wiersza poleceń Antigravity CLI automatycznie konwertuje prompty MCP na niestandardowe polecenia po ukośniku, dzięki czemu możesz wywołać prompt 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ń Antigravity.

  1. Dodaj ten kod do pliku server.py nad głównym zabezpieczeniem (if __name__ == "__main__":). 
    @mcp.prompt()
def find(animal: str) -> str:
    """
    Find which exhibit and trail a specific animal might be located.
    """

    return (
        f"Please find the exhibit and trail information for {animal} in the zoo. "
        f"Respond with '[animal] can be found in the [exhibit] on the [trail].'"
        f"Example: Penguins can be found in The Arctic Exhibit on the Polar Path."
    )
  2. Ponownie wdróż aplikację w Cloud Run. 
    gcloud run deploy zoo-mcp-server \
    --region=us-west1 \
    --source=. \
    --labels=dev-tutorial=codelab-mcp
  3. Odśwież ID_TOKEN i ponownie utwórz plik konfiguracji: 
    export ID_TOKEN=$(gcloud auth print-identity-token)
export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")

cat > ~/.gemini/antigravity-cli/mcp_config.json << EOF

{ "mcpServers": { "zoo-remote": { "serverUrl": "https://zoo-mcp-server-${PROJECT_NUMBER}.us-west1.run.app/mcp", "headers": { "Authorization": "Bearer ${ID_TOKEN}" } } } } EOF ```

  1. Po wdrożeniu nowej wersji aplikacji uruchom Antigravity CLI. 
    agy
  2. W prompcie użyj nowego utworzonego polecenia niestandardowego: 
    /find lions

Powinno się pojawić, że Antigravity CLI wywołuje narzędzie get_animals_by_species i formatuje odpowiedź zgodnie z instrukcjami prompta MCP.

╭───────────────────────────╮
│  > /find lions            │
╰───────────────────────────╯

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

Antigravity CLI umożliwia wybranie modelu i wysiłku.

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

W poprzedniej sekcji utworzyliśmy prompt MCP, aby szybko znaleźć zwierzę w zoo, wpisując /find animal w Antigravity CLI.

  1. Po wdrożeniu nowej wersji aplikacji uruchom Antigravity CLI. 
    agy --model=gemini-3.6-flash --effort=low
  2. W prompcie użyj nowego utworzonego polecenia niestandardowego: 
    /find lions

Powinno się nadal pojawiać, że Antigravity CLI wywołuje narzędzie get_animals_by_species i formatuje odpowiedź zgodnie z instrukcjami prompta MCP, ale odpowiedź powinna się pojawiać znacznie szybciej.

╭───────────────────────────╮
│  > /find lions            │
╰───────────────────────────╯

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

Debugowanie

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

✕ Unknown command: /find lions

Spróbuj uruchomić /mcp. Jeśli pojawi się zoo-remote - Disconnected, być może trzeba będzie ponownie wdrożyć lub ponownie uruchomić te polecenia:

 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)

cat > ~/.gemini/antigravity-cli/mcp_config.json << EOF
{
   "mcpServers": {
       "zoo-remote": {
           "serverUrl": "https://zoo-mcp-server-${PROJECT_NUMBER}.us-west1.run.app/mcp",
           "headers": {
               "Authorization": "Bearer ${ID_TOKEN}"
           }
       }
   }
}
EOF

12. Podsumowanie

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

Przejdź do następnego ćwiczenia

To ćwiczenie jest pierwszym z 3 części. W drugim ćwiczeniu użyjesz utworzonego serwera MCP z agentem ADK.

Używanie serwera MCP w Cloud Run z agentem ADK

(Opcjonalnie) Zwalnianie miejsca

Jeśli nie będziesz kontynuować ćwiczenia i chcesz zwolnić 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 powoduje zaprzestanie naliczania opłat za wszystkie 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 ćwiczenia: 
    rm -rf ~/mcp-on-cloudrun
  2. Ostrzeżenie! Tej czynności nie można cofnąć! Jeśli chcesz usunąć wszystko w Cloud Shell, aby zwolnić miejsce, możesz usunąć cały katalog domowy. Upewnij się, że wszystkie elementy, które chcesz zachować, są zapisane w innym miejscu. 
    sudo rm -rf $HOME