KI-Agenten-Workflows mit Web MCP aufbauenLive-Webzugang für Agenten

Wer schon einmal einen KI-Agenten mit dem offenen Web verbunden hat, weiß, wo es hakt. Der Agent denkt zuverlässig, doch sobald er echten Seiteninhalt benötigt, stößt er an eine Wand: Die Seite wird clientseitig gerendert, das HTML ist ein Wirrwarr, oder die Anfrage wird abgeblockt, bevor auch nur ein Datenfetzen zurückkommt. Die Lösung ist kein cleverer Prompt. Sie besteht darin, dem Agenten ein Werkzeug zu geben, das auf Abruf strukturierte Webdaten liefert, und ihn selbst entscheiden zu lassen, wann er es aufruft.

Genau das bietet der Crawlbase Web MCP-Server. Diese Anleitung zeigt, wie man KI-Agenten-Workflows rund um das Crawlbase Web MCP aufbaut: die Planungsschleife des Agenten, die MCP-Tool-Aufrufe zum Scrapen und Crawlen, und ein konkretes End-to-End-Beispiel, das eine URL entgegennimmt, die gerenderte Seite abruft und eine strukturierte Antwort zurückgibt. Kein eigener Scraping-Code, kein Proxy-Pool zu betreuen, keine in den Agenten eingebackenen Parsing-Regeln.

Was das Crawlbase Web MCP einem Agenten hinzufügt

MCP, das Model Context Protocol, ist der offene Standard, der es einem Sprachmodell erlaubt, externe Werkzeuge über eine konsistente Schnittstelle aufzurufen. Ein MCP-Server veröffentlicht eine Reihe von Tools, und jeder MCP-fähige Client (Claude Desktop, Cursor, n8n oder ein eigener Agent) kann sie entdecken und aufrufen. Der Crawlbase MCP-Server veröffentlicht Web-Zugriffs-Tools, sodass der Agent jede öffentliche URL so lesen kann, wie es ein echter Browser täte.

Unter der Haube werden diese Tools von derselben Crawling API angetrieben, die auch den Rest von Crawlbase antreibt. Das bedeutet, der Agent erbt JavaScript-Rendering, Rotation von Residential-IPs, Anti-Bot-Behandlung, Wiederholungsversuche und saubere Ausgabe, ohne dass er davon überhaupt weiß. Aus Sicht des Agenten hat er einfach ein Tool aufgerufen und lesbaren Inhalt zurückbekommen. Für eine umfassendere Übersicht über das, was der Server exponiert, siehe unsere Einführung in das Crawlbase MCP.

Das Web MCP stellt typischerweise zwei Tools bereit, nach denen Ihr Agent greifen wird:

• crawl ruft eine einzelne URL ab und gibt die gerenderte Seite als sauberes Markdown oder HTML zurück, bereit für das Modell zum Lesen.
• crawl_markdown (oder eine Screenshot-/Strukturvariante, je nach Ihrem Server-Build) liefert denselben Inhalt auf lesbaren Text gekürzt, was den Token-Verbrauch bei langen Seiten niedrig hält.

Die Agentenschleife, Schritt für Schritt

Ein Agenten-Workflow ist eine Schleife, keine gerade Linie. Das Modell plant, wählt ein Tool, liest das Ergebnis und entscheidet, ob es genug zum Antworten hat oder einen weiteren Aufruf braucht. Mit dem eingebundenen Web MCP sieht diese Schleife so aus:

• Aufgabe empfangen. Der Agent erhält eine Anweisung, die in der Regel eine URL oder ein Recherchethema enthält.
• Planen. Er überlegt, ob er aus seinem Wissen heraus antworten kann oder Live-Webdaten benötigt.
• MCP-Tool aufrufen. Wenn er die Seite braucht, ruft er crawl mit der Ziel-URL auf.
• Ergebnis lesen. Crawlbase gibt sauberen, gerenderten Inhalt zurück, den das Modell als Tool-Ausgabe aufnimmt.
• Entscheiden. Genug zum Antworten? Es schreibt die strukturierte Antwort. Noch nicht? Es läuft zurück und crawlt eine weitere URL oder verfeinert die Abfrage.
• Zurückgeben. Es übergibt ein sauberes, strukturiertes Ergebnis in der von Ihnen gewünschten Form.

Die wichtige Verschiebung ist, dass die Entscheidung zum Scrapen vom Agenten getroffen wird, nicht von Ihnen hartcodiert. Sie beschreiben das Ziel; der Agent bestimmt, welche Seiten er braucht und wann er sie abruft.

Schritt 1: Den Crawlbase Web MCP-Server starten

Jeder MCP-Client verbindet sich über einen kleinen Konfigurationsblock mit dem Server. Sie verweisen den Client auf das Crawlbase MCP-Paket und übergeben Ihr Token über die Umgebung. Hier ist eine typische Konfiguration für einen Desktop-MCP-Client.

{
  "mcpServers": {
    "crawlbase": {
      "command": "npx",
      "args": ["-y", "@crawlbase/mcp"],
      "env": {
        "CRAWLBASE_TOKEN": "YOUR_CRAWLBASE_JS_TOKEN"
      }
    }
  }
}

Verwenden Sie hier Ihr JavaScript-(JS-)Token. Crawlbase gibt zwei Token-Typen aus: Das normale Token ruft statisches HTML ab, während das JS-Token die Seite zuerst in einem echten Browser rendert. Da die meisten crawlenswerten Seiten clientseitig gerendert werden, ist das JS-Token die sichere Standardwahl für Agenten-Arbeit. Beide Token erhalten Sie nach der Registrierung im Dashboard.

Wenn Sie statt eines Desktop-Clients eine Agenten-Plattform wie n8n betreiben, verbinden Sie sich über HTTP mit einem gehosteten MCP-Endpunkt, anstatt den Prozess lokal zu starten. Das vollständige n8n-Setup wird in n8n mit dem Crawlbase Web MCP verbinden beschrieben; der Rest dieser Anleitung baut den Agenten im Code auf, damit Sie die Schleife direkt nachvollziehen können.

Schritt 2: Den Agenten bauen, der die MCP-Tools aufruft

Verbinden Sie nun einen echten Agenten mit dem Server. Das folgende Muster verwendet Python mit einer MCP-Client-Bibliothek und einem Tool-aufrufenden Modell. Der Agent verbindet sich mit dem Crawlbase MCP-Server, erkennt die verfügbaren Tools und übergibt sie dem Modell, damit es selbst entscheiden kann, wann es crawlen soll.

import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

server = StdioServerParameters(
    command="npx",
    args=["-y", "@crawlbase/mcp"],
    env={"CRAWLBASE_TOKEN": "YOUR_CRAWLBASE_JS_TOKEN"},
)

async def connect():
    async with stdio_client(server) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            tools = await session.list_tools()
            print([t.name for t in tools.tools])
            return session

asyncio.run(connect())

Die Ausführung gibt die Tool-Namen aus, die der Server bereitstellt, und bestätigt damit, dass der Agent crawl und seine Geschwister sehen kann, bevor das Modell aufgefordert wird, sie zu nutzen. Dieser Discovery-Schritt macht den Workflow portierbar: Tauschen Sie später einen anderen MCP-Server ein, und der Agent passt sich an die gefundenen Tools an.

Schritt 3: Dem Modell eine Tool-Aufruf-Schleife geben

Sobald die Session aktiv ist, ist die Schleife einfach. Sie geben dem Modell die Aufgabe und die Tool-Liste, lassen es einen Tool-Aufruf ausgeben, führen diesen Aufruf gegen den MCP-Server aus, speisen das Ergebnis zurück und wiederholen das, bis das Modell aufhört, Tools aufzurufen, und seine Antwort schreibt.

async def run_agent(session, model, task):
    messages = [{"role": "user", "content": task}]
    tools = (await session.list_tools()).tools

    while True:
        reply = await model.chat(messages, tools=tools)

        if not reply.tool_calls:
            return reply.content

        for call in reply.tool_calls:
            result = await session.call_tool(call.name, call.arguments)
            messages.append({
                "role": "tool",
                "tool_call_id": call.id,
                "content": result.content,
            })

Diese while-Schleife ist der gesamte Agent. Das Modell plant, ruft crawl auf, wenn es die Seite benötigt, liest das von Crawlbase zurückgegebene Markdown und antwortet entweder oder crawlt erneut. Sie sagen ihm nie, welche URL es abrufen soll oder wann; Sie beschreiben das Ergebnis und es findet seinen eigenen Weg dorthin.

Schritt 4: Den Agenten mit einem System-Prompt steuern

Die einzige Stelle, an der Unklarheit entsteht, ist, ob das Modell dem Tool überhaupt vertraut. Eine kurze, explizite System-Nachricht beseitigt den Zweifel und sichert eine konsistente Ausgabeform.

SYSTEM = """You are a web research assistant with crawl tools.

Always use the crawl tool to read a URL before answering about it.
Never guess page contents from memory. After crawling, extract only
the fields requested and return them as structured JSON."""

task = (
    "Crawl https://www.example-store.com/product/123 and return "
    "the product name, price, rating, and a one-line summary."
)

Damit produziert ein einzelner Lauf ein sauberes Objekt: Der Agent crawlt die Seite, liest den von Crawlbase zurückgegebenen gerenderten Inhalt und gibt genau die angeforderten Felder aus. Das ist derselbe Gedanke hinter strukturierter KI-Datenextraktion, außer dass das Modell selbst entscheidet, wann es nach der Seite greift.

Ein konkreter Workflow: Wettbewerber-Preisbeobachtung

Verbinden Sie die Teile zu einem Workflow, den Sie tatsächlich einsetzen würden. Angenommen, Sie möchten täglich eine Handvoll Produktseiten von Wettbewerbern prüfen: aktueller Preis, Verfügbarkeit und etwaige Aktionsbanner. Sie geben dem Agenten die Liste und lassen ihn sie abarbeiten.

urls = [
    "https://competitor-a.com/p/widget",
    "https://competitor-b.com/p/widget",
]

async def price_watch(session, model):
    rows = []
    for url in urls:
        task = f"Crawl {url}. Return price, in_stock, promo as JSON."
        rows.append(await run_agent(session, model, task))
    return rows

Jede Iteration durchläuft die vollständige Agentenschleife: Das Modell crawlt die URL über das MCP-Tool, Crawlbase rendert sie und rotiert die IP, und der Agent gibt eine strukturierte Zeile zurück. Die Ausgabe ist ein sauberes Array, das Sie mit dem gestrigen Lauf vergleichen, in eine Tabelle pushen oder bei einer Preisänderung als Alarm auslösen können.

Das gleiche Grundgerüst eignet sich ohne Umschreiben für andere Aufgaben. Tauschen Sie den Aufgaben-String aus und Sie haben einen Nachrichtenmonitor, einen Recherche-Assistenten, der Notizen über mehrere Quellen sammelt, oder einen Lead-Anreicherungsschritt über öffentliche Unternehmensseiten. Da der Agent über ein stabiles Tool mit Crawlbase kommuniziert, erfordert das Zielen auf eine neue Website keinerlei neue API-Verdrahtung. Mehr dazu, wo das einzuordnen ist, bietet die Übersicht zu KI-Proxy-Anwendungsfällen.

Crawls für schwierige Seiten optimieren

Die meisten Seiten lassen sich mit Standardeinstellungen sauber crawlen, aber schwere Single-Page-Apps brauchen manchmal einen Hinweis. Die MCP-Tools akzeptieren dieselben Warte-Optionen, die die Crawling API verwendet, sodass Sie sie in den Tool-Argumenten übergeben können, wenn eine Seite spät rendert. Zwei sind besonders relevant: ein Ajax-Wait-Flag, das auf asynchronen Inhalt wartet, und ein Page-Wait-Wert in Millisekunden für eine feste Pause nach dem Laden.

{
  "url": "https://www.example-store.com/product/123",
  "ajax_wait": true,
  "page_wait": 5000
}

Wenn Ergebnisse dünn ausfallen, erhöhen Sie zuerst page_wait, bevor Sie zu anderem greifen. Sie können den Agenten diese Werte selbst setzen lassen, indem Sie die Seite im System-Prompt beschreiben ("für langsame Single-Page-Apps auf Ajax-Inhalt warten"), oder sie in einem Wrapper hardcodieren, wenn Sie wissen, dass das Ziel schwer ist. In jedem Fall bleiben das Rendering, die Rotation und das Retry-Verhalten auf der Crawlbase-Seite; der Agent liest nur das Ergebnis.

Falls eine Website so feindlich ist, dass selbst gerenderte Crawls scheitern, bietet der Smart AI Proxy einen einzigen rotierenden Endpunkt, über den Anfragen geleitet werden, und die Crawling API gibt vorverarbeitetes JSON für populäre Seiten zurück, wenn Sie das Parsen durch das Modell ganz umgehen möchten. Beide teilen dieselbe Infrastruktur, auf der die MCP-Tools basieren.

Den Workflow zuverlässig halten

Einige Gewohnheiten halten einen Agenten-Workflow in der Produktion gesund. Fügen Sie nach jedem Lauf eine Prüfung hinzu, damit ein fehlgeschlagener Crawl sichtbar wird, statt still eine leere Zeile zu produzieren. Passen Sie das Anfrage-Tempo an, wenn Sie viele URLs in einer Schleife durchlaufen, statt alle auf einmal abzufeuern. Speichern Sie die strukturierte Ausgabe irgendwo, in einer Datenbank oder auch einer Tabelle, damit Sie zurückblicken und im Laufe der Zeit vergleichen können. Und passen Sie den Prompt je nach Ziel an: Eine generische Anweisung über sehr unterschiedliche Sites liefert meist schwächere Ergebnisse als ein paar site-spezifische Zeilen.

Wenn ein Agent meldet, dass "keine Tools verwendet wurden", bedeutet das fast immer, dass das Modell nicht zuversichtlich war, ob es crawlen sollte. Die System-Nachricht zu straffen und sicherzustellen, dass die URL klar in der Aufgabe steht, behebt das Problem. Bei Verbindungsproblemen prüfen Sie, ob der MCP-Server läuft, bestätigen Sie, dass das Token in der Umgebung gesetzt ist, und listen Sie die Tools zuerst auf, um zu beweisen, dass der Handshake funktioniert, bevor Sie das Modell debuggen.

Häufig gestellte Fragen

Was ist das Crawlbase Web MCP und wie verwendet es ein Agent?

Das Crawlbase Web MCP ist ein Model Context Protocol-Server, der Web-Zugriffs-Tools, hauptsächlich ein Crawl-Tool, für jeden MCP-fähigen KI-Agenten bereitstellt. Der Agent verbindet sich mit dem Server, erkennt die Tools und ruft sie auf, wenn er Live-Seiteninhalt benötigt. Jeder Aufruf wird von der Crawling API unterstützt, sodass der Agent gerenderten, sauberen Inhalt erhält, ohne Scraping-Code schreiben zu müssen.

Brauche ich das normale Token oder das JS-Token für Agenten-Workflows?

Verwenden Sie das JS-Token für Agenten-Arbeit. Das normale Token ruft statisches HTML ab, das bei modernen clientseitig gerenderten Sites eine leere Hülle ist. Das JS-Token rendert die Seite in einem echten Browser, bevor es zurückgegeben wird, sodass der vom Agenten gelesene Inhalt tatsächlich die Daten enthält. Beide Token erhalten Sie nach der Registrierung im Crawlbase-Dashboard.

Welche KI-Agenten und Plattformen funktionieren mit dem Crawlbase Web MCP?

Jeder MCP-kompatible Client funktioniert, einschließlich Claude Desktop, Cursor, Windsurf und Agenten-Plattformen wie n8n, sowie eigene Agenten, die Sie mit einer MCP-Client-Bibliothek bauen. Solange der Client sich mit dem Server verbinden und Tools aufrufen kann, kann er die Crawlbase-Crawl-Tools nutzen.

Kann der Agent JavaScript-lastige Sites ohne zusätzliches Setup scrapen?

Ja. Das Crawl-Tool rendert JavaScript automatisch über die Crawling API, sodass der Agent vollständig gerenderten Inhalt erhält, ohne dass Sie Puppeteer oder Selenium betreiben. Für Seiten, die spät laden, übergeben Sie ajax_wait und einen größeren page_wait in den Tool-Argumenten, und die API wartet, bis der Inhalt erscheint.

Wie wird das Blockieren vermieden?

Die MCP-Tools leiten durch die Crawling API, die Residential-IPs rotiert, Browser-Fingerprinting verwaltet und Anti-Bot-Challenges sowie Wiederholungsversuche serverseitig behandelt. Der Agent sieht diese Mechanismen nie; er erhält einfach sauberen Inhalt zurück. Halten Sie Ihre Anfragerate vernünftig, wenn Sie viele URLs in einer Schleife durchlaufen, und der Workflow bleibt gesund.

Worin unterscheidet sich das von einem einfachen HTTP-Anfrage-Tool für den Agenten?

Ein rohes HTTP-Tool gibt zurück, was der Server sendet, was bei den meisten modernen Sites eine ungerenderte Hülle oder eine Sperrseite ist. Das Crawlbase MCP-Tool rendert die Seite hinter einer vertrauenswürdigen IP und gibt beim ersten Aufruf fertigen Inhalt zurück, sodass der Agent seine Züge mit echten Daten verbringt statt mit wiederholten fehlgeschlagenen Fetches.

IK

Ian Kalvin

Technical Support Engineer · Crawlbase

Technical Support Engineer bei Crawlbase, der von der Front darüber schreibt, was beim Scraping und bei Proxy-Setups im Produktivbetrieb tatsächlich kaputtgeht.

NZ

Neil Zamora

Senior Architect · Crawlbase

Senior Architect bei Crawlbase mit Fokus auf den Systemen hinter großflächigem Crawling: Proxy-Rotation, Anti-Bot-Resilienz und den APIs, die diese Komplexität verbergen.