Ihr erstes MCP-Gateway

Einführung

Ein Agent-Gateway verdient seinen Unterhalt durch den Agent-Datenverkehr, und die häufigste Form davon ist das Model Context Protocol (MCP) – also die Aufrufe, die ein Agent tätigt, um Tools zu ermitteln und aufzurufen. In diesem Tutorial wird ein MCP-Server hinter dem Gateway eingerichtet, das Sie in Teil 2 installiert haben, und anschließend werden dessen Tools über einen Endpunkt ermittelt und aufgerufen.

Sie werden einen Beispiel-MCP-Server bereitstellen und ihn über einen AgentGatewayBackend, eine Route zuweisen und ein Tool über den Proxy aufrufen.

Schritt 1 – Einrichten eines MCP-Beispielservers

Dieser MCP-Server stellt einen einzigen abrufen Tool, das eine Webseite abruft. Beachten Sie das appProtocol: agentgateway.dev/mcp im Dienst – das teilt agentgateway mit, dass das Backend MCP verwendet.

kubectl apply -f- <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mcp-website-fetcher
spec:
  selector:
    matchLabels:
      app: mcp-website-fetcher
  template:
    metadata:
      labels:
        app: mcp-website-fetcher
    spec:
      containers:
      - name: mcp-website-fetcher
        image: ghcr.io/peterj/mcp-website-fetcher:main
        imagePullPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  name: mcp-website-fetcher
  labels:
    app: mcp-website-fetcher
spec:
  selector:
    app: mcp-website-fetcher
  ports:
  - port: 80
    targetPort: 8000
    appProtocol: agentgateway.dev/mcp
EOF

Schritt 2 – Mit einem AgentgatewayBackend verfügbar machen

Die AgentGatewayBackend In dieser Ressource wird beschrieben, wie Sie ein Agent-Backend registrieren. Für MCP geben Sie ein oder mehrere Ziele an; hier verweist ein einzelnes statisches Ziel auf den Dienst:

kubectl apply -f- <<'EOF'
apiVersion: agentgateway.dev/v1alpha1
kind: AgentgatewayBackend
metadata:
  name: mcp-backend
spec:
  mcp:
    targets:
    - name: mcp-target
      static:
        backendRef:
          name: mcp-website-fetcher
        port: 80
        protocol: SSE
EOF

Bestätigen Sie, dass es akzeptiert wurde:

kubectl get agentgatewaybackend mcp-backend

NAME          AKZEPTIERT   ALTER
mcp-backend   Ja       4s

Schritt 3 – Eine Route hinzufügen

Anfragen unter /mcp am Gateway zum Backend. Da das Backend ein AgentGatewayBackend, das backendRef nennt seine Gruppe und Art:

kubectl apply -f- <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: mcp
spec:
  parentRefs:
    - name: agentgateway-proxy
      namespace: agentgateway-system
  rules:
    - matches:
      - path:
          type: PathPrefix
          value: /mcp
      backendRefs:
      - name: mcp-backend
        group: agentgateway.dev
        kind: AgentgatewayBackend
EOF

Schritt 4 – Verbindung zum MCP-Endpunkt herstellen

Portweiterleitung für den Proxy einrichten:

kubectl port-forward deployment/agentgateway-proxy -n agentgateway-system 8080:80

Das Gateway stellt MCP nun über Streamable HTTP unter http://localhost:8080/mcp. Ein Roh- initialisieren Der Aufruf bestätigt, dass der Server über den Proxy erreichbar ist:

curl -s -X POST localhost:8080/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"1.0"}}}'

data: {"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"2025-06-18","capabilities":{"tools":{"listChanged":false}},"serverInfo":{"name":"mcp-website-fetcher","version":"1.14.1"}}}

Schritt 5 – Ein Tool suchen und aufrufen

Verwenden Sie die MCP Inspector -Befehlszeilenschnittstelle, um die vom Gateway bereitgestellten Tools aufzulisten:

npx @modelcontextprotocol/inspector@0.21.2 --cli http://localhost:8080/mcp \
  --transport http --method tools/list

{
  "tools": [
    {
      "name": "fetch",
      "description": "Fetches a website and returns its content",
      "inputSchema": {
        "type": "object",
        "properties": { "url": { "type": "string", "description": "URL to fetch" } },
        "required": [ "url" ]
      }
    }
  ]
}

Rufen Sie nun das Tool über das Gateway auf:

npx @modelcontextprotocol/inspector@0.21.2 --cli http://localhost:8080/mcp \
  --transport http --method tools/call --tool-name fetch --tool-arg url=https://example.com

{
  "content": [
    { "type": "text", "text": "<!doctype html><html lang=\"en\"><head><title>Example Domain</title>..." }
  ],
  "isError": false
}

Das Tool wurde ausgeführt und gab die Seite zurück, die über das Agentgateway weitergeleitet wurde.

Was das Gateway zusätzlich bietet

Ein einzelnes AgentGatewayBackend Es können mehrere MCP-Ziele aufgeführt werden, sodass das Gateway viele MCP-Server hinter einem Endpunkt bündelt. Die Agenten stellen eine Verbindung zu diesem einen Endpunkt her und erkennen dort jedes Tool, und Sie erhalten einen einzigen Punkt, an dem Sie Zugriffskontrollen durchführen und Protokolle zur Überwachung erstellen können – das Thema von Teil 6 dieser Reihe.

Aufräumen

kubectl delete httproute mcp
kubectl delete agentgatewaybackend mcp-backend
kubectl delete deployment,service mcp-website-fetcher

Wie geht es weiter?

Sie haben einen Tool-Aufruf über das Gateway geleitet. Als Nächstes wird das Gateway vor den Modellanbietern geschaltet: Sie leiten den LLM-Datenverkehr über die verschiedenen Anbieter – einschließlich eines Modells, das auf Ihrem eigenen Rechner läuft –, ohne Ihre Anwendung ändern zu müssen.

Als Nächstes in dieser Reihe: Weiterleitung von LLM-Datenverkehr über verschiedene Anbieter hinweg.

Zusammenfassung

• Ein AgentGatewayBackend mit mcp.targets registriert einen oder mehrere MCP-Server; kennzeichnen Sie den Backend-Dienst mit appProtocol: agentgateway.dev/mcp.
• Ein HTTPRoute dessen backendRef bezeichnet die agentgateway.dev/AgentGatewayBackend Die Gruppe/Art ordnet es dem Gateway zu.
• Das Gateway stellt MCP über Streamable HTTP bereit; Clients initialisieren, Werkzeuge/Listeund tools/call über einen Endpunkt.
• Ein Endpunkt für viele Server ist der Punkt, an dem später die Zugriffskontrolle und die Protokollierung von Prüfvorgängen ansetzen.