Einen KI-Assistenten über MCP anbinden

MCP (Model Context Protocol) gibt deinem Assistenten zusätzliche Werkzeuge. Mit Guard.ch bedient er einen isolierten Cloud-Browser wie ein Mensch: echte Maus- und Tastatureingaben mit menschlichem Timing, sodass die Seite eine Besucherin oder einen Besucher sieht, keine Automatisierung. Er kann Seiten öffnen und lesen, klicken, Formulare ausfüllen, Dateien hochladen und Screenshots machen. Den Ausgangsstandort wählst du.

Für den Browser brauchst du keinen lokalen Dienst und keinen Treiber. Guard.ch stellt den Browser, verwaltet die Sitzung und bietet dir eine Live-Ansicht, in der du jederzeit übernehmen kannst. Das Modell bleibt bei deinem Client; hier musst du keinen Modellschlüssel hinterlegen.

Was du brauchst

Endpunkt

https://api.guard.ch/mcp

Transport

Streamable HTTP, jede Anfrage für sich

Authentifizierung

Anmeldung mit deinem Guard.ch-Konto (OAuth) oder ein App-Schlüssel im Header

Plan

Ein Plan mit programmatischem Zugriff; die 30-tägige Testphase enthält ihn

Browser

Verfügbare Chromium-Browser; standardmässig Chrome

Parallelität

Bis zu drei gleichzeitige Sitzungen pro Person, gemeinsam mit ihren Agenten

Verbundene Apps und App-Schlüssel

• Anmelden ist der Standard. Fast jeder Client meldet sich selbst über OAuth an. Nach deinem Konto fragt nur die Seite von Guard.ch; dein Passwort sieht der Client nie. Die wenigen, die das nicht können, und dein eigener Code nutzen stattdessen einen App-Schlüssel.
• Erst prüfen, dann erlauben. Die Seite nennt die App, wer sie veröffentlicht hat und wohin sie zurückkehrt. Eine App, die sich selbst registriert hat, ist als ungeprüft markiert; erlaube sie nur, wenn du sie gerade selbst verbinden wolltest.
• Jederzeit trennen. Verbundene Apps stehen im Reiter «Agenten». Trennst du eine, verliert sie sofort jeden Zugriff, auch mitten im Gespräch.
• App-Schlüssel für Automatisierung. Skripte, Pipelines und Clients, die sich nicht anmelden können, nutzen einen App-Schlüssel aus dem Reiter «Apps». Ein eigener Schlüssel pro Client lässt sich gezielt widerrufen, ohne die anderen zu unterbrechen.
• Schlüssel laufen ab und sind nur einmal sichtbar. Ein Schlüssel läuft nach einem Jahr ohne Nutzung ab oder an einem festen Datum deiner Wahl. Angezeigt wird er nur beim Erstellen; einen verlorenen Schlüssel widerrufst du und ersetzt ihn.

Endpunkt und Authentifizierung

Der Server spricht Model Context Protocol über Streamable HTTP. Jede Anfrage steht für sich; dein Client kann daher neu starten, ohne dass der Server einen Gesprächszustand vorhalten muss.

https://api.guard.ch/mcp

Clients mit MCP-Autorisierung verbinden sich allein mit der URL: Der Server beantwortet die erste Anfrage mit einer Anmeldeaufforderung, und der Client öffnet die Anmeldeseite von Guard.ch. Für Automatisierung schickst du stattdessen einen App-Schlüssel in einem dieser Header. In die URL gehört er nie, dort nimmt ihn der Server auch nicht an:

• Authorization: Bearer YOUR_API_KEY als Bearer-Token.
• x-api-key: YOUR_API_KEY für Clients, die den Authorization-Header nicht setzen können.

Konfigurationen im Überblick

{
  "mcpServers": {
    "guardch": {
      "url": "https://api.guard.ch/mcp"
    }
  }
}

claude mcp add --scope user --transport http guardch https://api.guard.ch/mcp

codex mcp add guardch --url https://api.guard.ch/mcp
codex mcp login guardch

gemini mcp add --scope user --transport http guardch https://api.guard.ch/mcp

copilot mcp add --transport http guardch https://api.guard.ch/mcp

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "guardch": {
      "type": "remote",
      "url": "https://api.guard.ch/mcp"
    }
  }
}

extensions:
  guardch:
    name: guardch
    type: streamable_http
    uri: https://api.guard.ch/mcp
    enabled: true
    timeout: 300

amp mcp add guardch https://api.guard.ch/mcp

qwen mcp add --scope user --transport http guardch https://api.guard.ch/mcp

droid mcp add guardch https://api.guard.ch/mcp --type http

{
  "mcp": {
    "guardch": {
      "type": "http",
      "url": "https://api.guard.ch/mcp",
      "oauth": true
    }
  }
}

{
  "mcpServers": {
    "guardch": {
      "url": "https://api.guard.ch/mcp"
    }
  }
}

{
  "guardch": {
    "url": "https://api.guard.ch/mcp"
  }
}

{
  "mcpServers": {
    "guardch": {
      "url": "https://api.guard.ch/mcp"
    }
  }
}

{
  "servers": {
    "guardch": {
      "type": "http",
      "url": "https://api.guard.ch/mcp"
    }
  }
}

devin mcp add --scope user guardch https://api.guard.ch/mcp
devin mcp login guardch

{
  "context_servers": {
    "guardch": {
      "url": "https://api.guard.ch/mcp"
    }
  }
}

{
  "servers": {
    "guardch": {
      "url": "https://api.guard.ch/mcp"
    }
  }
}

{
  "mcpServers": {
    "guardch": {
      "type": "streamableHttp",
      "url": "https://api.guard.ch/mcp"
    }
  }
}

{
  "mcp": {
    "guardch": {
      "type": "remote",
      "url": "https://api.guard.ch/mcp"
    }
  }
}

name: guardch
version: 1.0.0
schema: v1
mcpServers:
  - name: guardch
    type: streamable-http
    url: https://api.guard.ch/mcp
    requestOptions:
      headers:
        Authorization: "Bearer YOUR_API_KEY"

{
  "mcpServers": {
    "guardch": {
      "url": "https://api.guard.ch/mcp",
      "oauthScopes": [
        "mcp"
      ]
    }
  }
}

{
  "mcpServers": {
    "guardch": {
      "url": "https://api.guard.ch/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

{
  "mcpServers": {
    "guardch": {
      "type": "streamable-http",
      "url": "https://api.guard.ch/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

{
  "mcpServers": {
    "guardch": {
      "url": "https://api.guard.ch/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

{
  "tools": [
    {
      "type": "mcp",
      "server_label": "guardch",
      "server_url": "https://api.guard.ch/mcp",
      "authorization": "YOUR_API_KEY",
      "require_approval": "never"
    }
  ]
}

{
  "mcp_servers": [
    {
      "type": "url",
      "url": "https://api.guard.ch/mcp",
      "name": "guardch",
      "authorization_token": "YOUR_API_KEY"
    }
  ],
  "tools": [
    {
      "type": "mcp_toolset",
      "mcp_server_name": "guardch"
    }
  ]
}

from agents.mcp import MCPServerStreamableHttp

guardch = MCPServerStreamableHttp(
    name="guardch",
    params={"url": "https://api.guard.ch/mcp", "headers": {"Authorization": "Bearer YOUR_API_KEY"}},
)

import { createMCPClient } from "@ai-sdk/mcp";

const guardch = await createMCPClient({
  transport: {
    type: "http",
    url: "https://api.guard.ch/mcp",
    headers: { Authorization: "Bearer YOUR_API_KEY" },
  },
});

from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({
    "guardch": {
        "transport": "http",
        "url": "https://api.guard.ch/mcp",
        "headers": {"Authorization": "Bearer YOUR_API_KEY"},
    }
})

{
  "mcpServers": {
    "guardch": {
      "type": "http",
      "url": "https://api.guard.ch/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Browser und Standort wählen

image wählt beim Erstellen einen verfügbaren Chromium-Browser. Ohne Angabe startet Chrome. Firefox und Tor lassen sich nicht programmatisch steuern; bei einer Anfrage danach zeigt Guard.ch die unterstützten Browser-Kennungen an. Mit screen, language und keyboard_layout legst du beim Start Bildschirmgrösse, Browsersprache und Tastaturlayout fest.

Mit country wählst du ein Land oder eine Stadt als Ausgangsstandort (us, de, us-dal). residential nutzt, sofern verfügbar, eine Residential-Adresse; mit proxy verwendest du deinen eigenen Proxy. In einer laufenden Sitzung ändert browser_session_update den Standort.

Zusehen und übernehmen

Zu jeder Sitzung gehört eine Live-Ansicht, und die Sitzungen deiner Agenten stehen im Reiter Agenten deines Dashboards. Öffne eine davon, und du bist in derselben Ansicht, die auch ein Mensch nutzt: Die Seite läuft live, und beenden kannst du die Sitzung von dort ebenfalls.

Die Steuerung läuft automatisch: Die Aktionen des Assistenten steuern den Browser. Willst du eingreifen, übernimmst du mit dem Button in der Live-Ansicht. Dann hält der Assistent an und sagt es dir: Seine Aktionen melden user_in_control, lesen kann er weiterhin. Bist du fertig, gibst du die Steuerung zurück und bittest ihn, im selben Browser weiterzumachen. Bei einer Anmeldung oder einem Captcha bittet er dich mit browser_ask_user um Hilfe.

Analyse neben der Seite

In einem Chromium-Browser kann die Analyse von Guard.ch neben der Seite mitlaufen: Anfragen, Weiterleitungsketten, Antwort-Header, Konsolenausgabe, Sicherheitsprobleme, Downloads, Formulare, Cookies und Speicher, erkannte Technologien und Tracker, WHOIS-, IP- und Zertifikatsabfragen auf Zuruf, dazu eine Einschätzung pro Host mit ihren Quellen.

Mit browser_session_update und analysis: true oder analysis: false schaltest du die Live-Analyse für eine Sitzung deines Kontos ein oder aus, egal ob du sie in der App gestartet hast oder der Assistent. In der Live-Ansicht geht das ebenfalls. Die Ergebnisse kannst du live mitlesen; im Dashboard erscheint die Sitzung als Untersuchung. Eine Sitzung in einem Browser ohne Analyse-Unterstützung antwortet mit analysis_unavailable.

Wie sich die Sitzungen verhalten

• Sitzungen können automatisch starten. Das erste Seiten-Tool öffnet eine, wenn unter dieser Verbindung keine läuft. Laufen mehrere, wird ein Aufruf ohne session_id abgelehnt statt geraten. So landet ein beiläufiger Aufruf nie im falschen Browser.
• Sitzungen werden automatisch beendet. Du legst keine Laufzeit fest. Eine Sitzung endet wenige Minuten nach dem letzten Tool-Aufruf oder nachdem sich ein CDP-Client getrennt hat, spätestens 18 Stunden nach dem Start. Beendest du sie selbst, ist der Platz sofort frei.
• Wiederholungen sind ungefährlich. Ein Idempotenzschlüssel liefert bei einem erneuten Erstellungsaufruf die erfolgreiche Antwort zurück, statt einen zweiten Browser zu öffnen. Das hilft bei Queues und wiederholten Jobs.
• Mensch und Agent teilen ein Konto. Dein Assistent kann deine in der App gestarteten Sitzungen auflisten, steuern und beenden; du kannst dasselbe mit seinen Sitzungen tun. Schliesst er eine deiner Sitzungen, endet auch die Live-Ansicht. Gib Sitzungen Namen, damit ihr sie auseinanderhalten könnt.
• Zugriff nur auf dein Konto. Jedes Tool arbeitet nur auf deinen eigenen Sitzungen. Sitzungen anderer Mitglieder sind über den Server weder sichtbar noch erreichbar.

Grenzen und Absagen

• Programmatischer Zugriff hängt am Plan. Ohne ihn antwortet jeder Aufruf mit einem Hinweis auf ein Upgrade statt mit einem Ergebnis. Beide bezahlten Pläne haben ihn, die 30-tägige Testphase ebenfalls.
• Bis zu drei gleichzeitige Sitzungen pro Person. Agenten-Sitzungen teilen sich diese Plätze mit deinen eigenen Sitzungen. Sind alle drei belegt, wird eine neue Sitzung abgelehnt statt eingereiht.
• Keine Gebühr pro Tool-Aufruf. Dein Plan muss programmatischen Zugriff enthalten. Für einzelne Tool-Aufrufe fällt keine zusätzliche Gebühr an. Residential-Ausgänge zählen zum Datenvolumen des Workspaces.
• Das Erstellen ist ratenbegrenzt. Limits pro Minute, Stunde und Tag schützen die Plattform vor zu vielen neuen Sitzungen. Prüfe den Antwortstatus und verzögere weitere Versuche, wenn ein Limit erreicht ist.
• Gespeichert wird nichts. Eine geschlossene Sitzung ist weg, mitsamt allem, was sie gesehen hat. Die Liste behält 30 Tage an Einträgen (was lief, wann, wie lange), nie die Seiten selbst.

Die Tools für deinen Assistenten

Der Server stellt 28 Tools mit dem Präfix browser_ bereit, die den Browser wie ein Mensch bedienen: jeder Klick, jeder Tastendruck und jedes Scrollen ist echte Maus- und Tastatureingabe mit menschlichem Timing, sodass Websites eine Besucherin oder einen Besucher sehen, keine Automatisierung. Ein Assistent kann direkt mit browser_navigate beginnen: Guard.ch startet bei Bedarf eine Sitzung und liefert einen Accessibility-Snapshot mit Referenzen für weitere Aktionen, und die Pixel von browser_screenshot sind die x/y-Koordinaten für browser_click, browser_hover, browser_drag und browser_scroll.

Sicherheit

• Erlaube nur Apps, die du selbst verbunden hast. Eine verbundene App handelt für dein Konto, bis du sie im Reiter «Agenten» trennst.
• Ein App-Schlüssel ist wie ein Passwort: Bewahre ihn im Schlüsselspeicher deines Clients oder in einer Umgebungsvariable auf, nie in einer geteilten Konfigurationsdatei oder einem Link. Schick ihn nur im Header mit; in einer URL lehnt der Server ihn ab. Wird er offengelegt, widerrufe ihn im Reiter «Apps».
• Seiten laden in unserer Infrastruktur, nie auf dem Rechner, auf dem der Assistent läuft, und nie in einem Browserprofil von dir: Jede Sitzung ist ein Wegwerf-Container.
• Der MCP-Server nutzt kein eigenes Modell. Er gibt die angeforderten Ergebnisse an deinen Client zurück; welches Modell sie verarbeitet, bestimmst du dort.
• Agenten-Sitzungen stehen ebenfalls im Dashboard. Du kannst live zusehen und sie jederzeit selbst beenden.
• Alles läuft über TLS, und für die Sitzungen gilt derselbe AVV wie für den Rest des Produkts.

Wenn etwas klemmt

Prüfe bei Problemen zuerst diese häufigen Ursachen:

Der Client zeigt keine Tools. Er hat seine Konfiguration nicht neu gelesen. Starte ihn nach dem Eintragen neu und prüf, ob wirklich der /mcp-Endpunkt oben eingetragen ist und nicht die REST-Basis.

Jeder Aufruf antwortet mit einem Upgrade-Hinweis. Das angemeldete Konto hat keinen Plan mit programmatischem Zugriff. Starte die Testphase, oder frag einen Workspace-Manager nach einem Platz.

Ein Aufruf wird als mehrdeutige Sitzung abgelehnt. Unter dieser Verbindung laufen zwei oder mehr Sitzungen, und Guard.ch rät nicht, welche gemeint ist. Lass sie auflisten und gib die session_id von da an ausdrücklich mit.

Eine neue Sitzung wird abgelehnt. Entweder sind alle drei Sitzungsplätze des Kontos belegt, oder das gewünschte Browser-Image lässt sich nicht programmatisch steuern. Die Antwort nennt den Grund und welche Browser-Images du stattdessen verwenden kannst.

Der Zugriff hörte mitten im Gespräch auf. Die App wurde getrennt, oder ihr App-Schlüssel wurde widerrufen, hat sein Ablaufdatum erreicht oder war ein Jahr lang ungenutzt. Melde dich im Client erneut an oder leg einen neuen Schlüssel an.

Die Anmeldeseite kommt nicht weiter. Eine Anmeldeanfrage läuft nach wenigen Minuten ab und lässt sich nur einmal beantworten. Starte das Verbinden in deinem Client neu.

Dieselben Browser ohne MCP

Ein Client, der kein MCP spricht, erstellt dieselben Sitzungen über REST und hängt Playwright oder Puppeteer an den CDP-Endpunkt, den jede zurückgibt. Diesen Weg beschreibt die API-Anleitung.