--- title: "Integration von Bright Data MCP mit LangGraph" slug: langgraph-with-web-mcp date: 2026-01-21T09:20:34+00:00 modified: 2026-01-21T09:20:36+00:00 permalink: https://brightdata.de/blog/ai/langgraph-with-web-mcp type: blog --- [ Blog ](https://brightdata.de/blog "Blog") / [AI](https://brightdata.de/blog/ai) [AI](https://brightdata.de/blog/ai) # Integration von Bright Data MCP mit LangGraph Erstellen Sie einen LangGraph-KI-Rechercheagenten mit Live-Zugriff auf Webdaten über Bright Data Web MCP, der über Such-, Scraping- und Browser-Automatisierungsfunktionen verfügt. 13 min lesen [ ![Bright Data favicon](https://media.brightdata.de/2021/05/favicon_512.svg) ](https://brightdata.com/blog/authors/dimitrije-stamenic) [Dimitrije Stamenic ](https://brightdata.com/blog/authors/dimitrije-stamenic) ![LangGraph with Bright Data MCP](https://media.brightdata.de/2026/01/LangGraph-with-Bright-Datas-Web-MCP.png) Dieser Leitfaden zeigt Ihnen, wie Sie [Bright Data MCP](/ai/mcp-server) mit LangGraph verbinden können, um einen KI-Rechercheagenten zu erstellen, der Live-Webdaten suchen, scrapen und auswerten kann. In diesem Leitfaden erfahren Sie, wie Sie: - einen LangGraph-Agenten erstellen, der seine eigene Schlussfolgerungsschleife steuert - Diesem Agenten mit Bright Data [Bright Data MCP Free Tier](/blog/ai/web-mcp-free-tier) Live-Webzugriff gewähren - Such- und Extraktionstools in einen funktionierenden Agenten einbinden - Diesen Agenten mit Browser-Automatisierung mithilfe der Premium-Tools von Bright Data MCP zu aktualisieren ## Einführung in LangGraph [Mit LangGraph](https://www.langchain.com/langgraph) können Sie LLM-Anwendungen erstellen, bei denen der Kontrollfluss explizit und leicht überprüfbar ist und nicht in Eingabeaufforderungen oder Wiederholungsversuchen verborgen ist. Jeder Schritt wird zu einem Knoten. Jeder Übergang wird von Ihnen definiert. Der Agent läuft als Schleife. Das LLM-Modell liest den aktuellen Status und antwortet entweder oder fragt nach einem Tool. Wenn es ein Tool (wie die Websuche) aufruft, wird das Ergebnis wieder zum Status hinzugefügt, und das Modell trifft erneut eine Entscheidung. Wenn es über genügend Informationen verfügt, endet die Schleife. ![Simple LangGraph Agent Diagram](https://media.brightdata.com/2026/01/BJ_gfKsBZx.png)Dies ist der wesentliche Unterschied zwischen Workflows und Agenten. Ein Workflow folgt festen Schritten. Ein Agent wiederholt in einer Schleife: entscheiden, handeln, beobachten, erneut entscheiden. Diese Schleife ist die gleiche Grundlage, die auch in [agentenbasierten RAG-Systemen](/blog/ai/agentic-rag) verwendet wird, bei denen die Abfrage dynamisch statt an festen Punkten erfolgt. LangGraph bietet Ihnen eine strukturierte Möglichkeit, diese Schleife mit Speicher, Toolaufruf und expliziten Stoppbedingungen aufzubauen. Sie können jede Entscheidung des Agenten sehen und steuern, wann er stoppt. ## Warum Bright Data MCP mit LangGraph verwenden LLMs denken gut, aber sie können nicht sehen, was gerade im Web passiert. Ihr Wissen endet zum Zeitpunkt des Trainings. Wenn ein Agent also aktuelle Daten benötigt, neigt das Modell dazu, die Lücke durch Vermutungen zu füllen. Bright Data MCP bietet Ihrem Agenten direkten Zugriff auf Live-Webdaten über Such- und Extraktionstools. Anstatt zu raten, stützt das Modell seine Antworten auf reale, aktuelle Quellen. LangGraph macht diesen Zugriff in einer Agentenumgebung nutzbar. Ein Agent muss entscheiden, wann er genug weiß und wann er weitere Daten abrufen muss. Mit Bright Data MCP kann der Agent bei der Beantwortung einer Frage auf die tatsächlich verwendeten Quellen verweisen, anstatt sich auf sein Gedächtnis zu verlassen. Dadurch sind die Ergebnisse vertrauenswürdiger und leichter zu debuggen. ## So verbinden Sie Bright Data MCP mit einem LangGraph-Agenten LangGraph steuert die Agentenschleife. Bright Data MCP ermöglicht dem Agenten den Zugriff auf Live-Webdaten. Nun müssen beide nur noch miteinander verbunden werden, ohne die Komplexität zu erhöhen. In diesem Abschnitt richten Sie ein minimales Python-Projekt ein, stellen eine Verbindung zum Bright Data MCP-Server her und machen dessen Tools für einen LangGraph-Agenten verfügbar. ### Voraussetzungen Um diesem Tutorial folgen zu können, benötigen Sie: - Python-Versionen 3.11+ - Bright Data-Konto - OpenAI Platform-Konto ### Schritt 1: OpenAI-API-Schlüssel generieren Der Agent benötigt einen LLM-API-Schlüssel, um zu entscheiden, wann Tools verwendet werden sollen. In dieser Konfiguration stammt dieser Schlüssel von OpenAI. Erstellen Sie einen API-Schlüssel über das OpenAI-Plattform-Dashboard. Öffnen Sie die Seite „API-Schlüssel” und klicken Sie auf „Neuen geheimen Schlüssel erstellen”. ![OpenAI Platform API Keys](https://media.brightdata.com/2026/01/SJfzfFsB-g.png)Dadurch wird ein neues Fenster geöffnet, in dem Sie Ihren Schlüssel einrichten können. ![OpenAI Platform Create New Secret Key](https://media.brightdata.com/2026/01/S1sVbsjHbl.png)Behalten Sie die Standardeinstellungen bei, benennen Sie den Schlüssel optional und klicken Sie auf „Geheimen Schlüssel erstellen”. ![OpenAI Secret Key Generated](https://media.brightdata.com/2026/01/BkOrWsirZg.png)Kopieren Sie den Schlüssel und bewahren Sie ihn sicher auf. Sie fügen ihn in den nächsten Schritten zur Umgebungsvariablen `OPENAI_API_KEY` hinzu. Mit diesem Schlüssel kann LangGraph das LLM-Modell aufrufen, das entscheidet, wann Web-MCP-Tools aufgerufen werden sollen. ### Schritt 2: Bright Data API-Token generieren Als Nächstes benötigen Sie einen API-Token von Bright Data. Dieser Token authentifiziert Ihren Agenten beim Web-MCP-Server und ermöglicht ihm, Such- und Scraping-Tools aufzurufen. Generieren Sie das Token im Bright Data-Dashboard. Öffnen Sie „Kontoeinstellungen“, gehen Sie zu „Benutzer und API-Schlüssel“ und klicken Sie auf „+ Schlüssel hinzufügen“. ![Bright Data Dashboard - Add key](https://media.brightdata.com/2026/01/ByVUZosB-e.png)Behalten Sie für diese Anleitung einfach die Standardeinstellungen bei und klicken Sie auf „Speichern“: ![Bright Data Dashboard Create A Key](https://media.brightdata.com/2026/01/BJGDWssBZe.png)Kopieren Sie den Schlüssel und bewahren Sie ihn sicher auf. Sie fügen ihn in den nächsten Schritten zur Umgebungsvariablen `BRIGHTDATA_TOKEN` hinzu. Dieser Token gibt Ihrem Agenten die Berechtigung, über Bright Data MCP auf Live-Webdaten zuzugreifen. ### Schritt 3: Einrichten eines einfachen Python-Projekts Erstellen Sie ein neues Projektverzeichnis und eine virtuelle Umgebung: ```none mkdir webmcp-langgraph-demo cd webmcp-langgraph-demo python3 -m venv webmcp-langgraph-venv ``` Aktivieren Sie die virtuelle Umgebung: ```none source webmcp-langgraph-venv/bin/activate ``` Dadurch bleiben Abhängigkeiten isoliert und Konflikte mit anderen Projekten werden vermieden. Installieren Sie bei aktiver Umgebung nur die erforderlichen Abhängigkeiten. Es handelt sich um dieselben MCP-Adapter, die auch in [den LangChain- und LangGraph-Integrationen von Bright Data](/blog/ai/langchain-mcp-adapters-with-web-mcp) verwendet werden, sodass die Einrichtung auch bei Wachstum Ihres Agenten konsistent bleibt: ```none pip install langgraph langchain langchain-openai langchain-mcp-adapters python-dotenv ``` Erstellen Sie eine `.env` -Datei, um Ihre API-Schlüssel zu speichern: ```none touch .env ``` Fügen Sie den OpenAI-API-Schlüssel und den Bright Data-Schlüssel in die `.env` -Datei ein: ```none OPENAI_API_KEY="Ihr-OpenAI-API-Schlüssel" BRIGHTDATA_TOKEN="Ihr-BrightData-API-Schlüssel" ``` Behalten Sie den Namen `OPENAI_API_KEY` unverändert bei. LangChain liest ihn automatisch, sodass Sie den Schlüssel nicht im Code übergeben müssen. Erstellen Sie abschließend eine einzelne Python-Datei und definieren Sie die Systemaufforderung, die die Rolle, die Grenzen und die Regeln für die Verwendung des Tools durch den Agenten festlegt: ```none # webmcp-langgraph-demo.py-Datei SYSTEM_PROMPT = """Sie sind ein Web-Rechercheassistent. Aufgabe: - Recherchieren Sie das Thema des Benutzers anhand der Google-Suchergebnisse und einiger Quellen. - Geben Sie 6–10 einfache Stichpunkte zurück. - Fügen Sie eine kurze Liste „Quellen:“ mit nur den von Ihnen verwendeten URLs hinzu. Verwendung der Tools: - Rufen Sie zunächst das Suchtool auf, um Google-Ergebnisse zu erhalten. - Wählen Sie 3–5 seriöse Ergebnisse aus und scrapen Sie diese. - Wenn das Scraping fehlschlägt, versuchen Sie es mit einem anderen Ergebnis. Einschränkungen: - Verwenden Sie maximal 5 Quellen. - Bevorzugen Sie offizielle Dokumente oder Primärquellen. - Arbeiten Sie zügig: kein tiefes Crawling. """ ``` ### Schritt 4: LangGraph-Knoten einrichten Dies ist der Kern des Agenten. Sobald Sie diesen Kreislauf verstanden haben, ist alles andere nur noch eine Frage der Umsetzung. Bevor Sie Code schreiben, ist es hilfreich, die Agentenschleife zu verstehen, die Sie erstellen möchten. Das Diagramm zeigt eine einfache LangGraph-Agentenschleife: Das Modell liest den aktuellen Zustand, entscheidet, ob es externe Daten benötigt, ruft bei Bedarf ein Tool auf, beobachtet das Ergebnis und wiederholt dies, bis es eine Antwort geben kann. ![Simple LangGraph Agent Diagram](https://media.brightdata.com/2026/01/HJaPWjiH-x.png)Um diese Schleife zu implementieren, benötigen Sie zwei Knoten (einen LLM-Knoten und einen Tool-Ausführungsknoten) sowie eine Routing-Funktion, die entscheidet, ob fortgefahren oder beendet und eine endgültige Antwort gegeben wird. Der **LLM-Knoten** sendet den aktuellen Konversationsstatus und die Systemregeln an das Modell und gibt entweder eine Antwort oder Tool-Aufrufe zurück. Der entscheidende Punkt ist, dass jede Modellantwort an `MessagesState` angehängt wird, sodass spätere Schritte sehen können, was das Modell entschieden hat und warum. ```none def make_llm_call_node(llm_with_tools): async def llm_call(state: MessagesState): messages = [SystemMessage(content=SYSTEM_PROMPT)] + state["messages"] ai_message = await llm_with_tools.ainvoke(messages) return {"messages": [ai_message]} return llm_call ``` Der **Tool-Ausführungsknoten** führt alle vom Modell angeforderten Tools aus und zeichnet die Ausgaben als Beobachtungen auf. Durch diese Trennung bleibt das Schlussfolgern im Modell und die Ausführung im Code. ```none def make_tool_node(tools_by_name: dict): async def tool_node(state: MessagesState): last_ai_msg = state["messages"][-1] tool_results = [] for tool_call in last_ai_msg.tool_calls: tool = tools_by_name.get(tool_call["name"]) if not tool: tool_results.append( ToolMessage( content=f"Tool not found: {tool_call['name']}", tool_call_id=tool_call["id"], ) ) continue # MCP-Tools sind in der Regel asynchron. observation = ( await tool.ainvoke(tool_call["args"]) if hasattr(tool, "ainvoke") else tool.invoke(tool_call["args"]) ) tool_results.append( ToolMessage( content=str(observation), tool_call_id=tool_call["id"], ) ) return {"messages": tool_results} return tool_node ``` Schließlich entscheidet die Routing-Regel, ob der Graph weiterlaufen oder stoppen soll. In der Praxis beantwortet sie eine einzige Frage: Hat das Modell Tools angefordert? ```none def should_continue(state: MessagesState) -> Literal["tool_node", END]: last_message = state["messages"][-1] if getattr(last_message, "tool_calls", None): return "tool_node" return END ``` ### Schritt 5: Alles miteinander verbinden Alles in diesem Schritt befindet sich innerhalb der Funktion `main()`. Hier konfigurieren Sie Anmeldedaten, stellen eine Verbindung zu Bright Data MCP her, binden Tools, erstellen den Graphen und führen eine Abfrage aus. Beginnen Sie damit, die Umgebungsvariablen zu laden und `BRIGHTDATA_TOKEN` zu lesen. Dadurch bleiben die Anmeldedaten aus dem Quellcode heraus und es kommt zu einem schnellen Fehler, wenn das Token fehlt. ```none # Umgebungsvariablen aus .env laden load_dotenv() # Bright Data-Token lesen bd_token = os.getenv("BRIGHTDATA_TOKEN") if not bd_token: raise ValueError("Missing BRIGHTDATA_TOKEN") ``` Erstellen Sie als Nächstes einen `MultiServerMCPClient` und verweisen Sie ihn auf den Web-MCP-Endpunkt. Dieser Client verbindet den Agenten mit Live-Webdaten. ```none # Mit dem Bright Data MCP-Server verbinden client = MultiServerMCPClient({ "bright_data": { "url": f"https://mcp.brightdata.com/mcp?token={bd_token}", "transport": "streamable_http", } }) ``` > **Hinweis:** Bright Data MCP verwendet Streamable HTTP als Standardtransport, was das Streaming und die Wiederholungsversuche von Tools im Vergleich zu [älteren SSE-basierten Setups](/blog/ai/sse-vs-streamable-http) vereinfacht. Aus diesem Grund standardisieren die meisten neueren MCP-Integrationen diesen Transport. Rufen Sie dann die verfügbaren MCP-Tools ab und indizieren Sie sie nach Namen. Der Tool-Ausführungsknoten verwendet diese Zuordnung, um Aufrufe weiterzuleiten. ```none # Alle verfügbaren MCP-Tools abrufen (Suchen, Scrapen usw.) tools = await client.get_tools() tools_by_name = {tool.name: tool for tool in tools} ``` Initialisieren Sie das LLM und binden Sie die MCP-Tools daran. Dadurch wird der Aufruf von Tools ermöglicht. ```none # Initialisieren Sie das LLM und erlauben Sie ihm, MCP-Tools aufzurufen. llm = ChatOpenAI(model="gpt-4.1-mini", temperature=0) llm_with_tools = llm.bind_tools(tools) ``` Erstellen Sie nun den zuvor gezeigten LangGraph-Agenten. Erstellen Sie einen `StateGraph(MessagesState)`, fügen Sie die LLM- und Tool-Knoten hinzu und verbinden Sie die Kanten so, dass sie der Schleife entsprechen. ```none # Erstellen Sie den LangGraph-Agenten. graph = StateGraph(MessagesState) graph.add_node("llm_call", make_llm_call_node(llm_with_tools)) graph.add_node("tool_node", make_tool_node(tools_by_name)) # Graph-Ablauf: # START → LLM → (tools?) → LLM → END graph.add_edge(START, "llm_call") graph.add_conditional_edges("llm_call", should_continue, ["tool_node", END]) graph.add_edge("tool_node", "llm_call") agent = graph.compile() ``` Führen Sie den Agenten schließlich mit einer echten Eingabeaufforderung aus. Legen Sie ein `recursion_limit` fest, um Endlosschleifen zu verhindern. ```none # Beispiel für eine Rechercheanfrage topic = "Was ist Bright Data MCP?" # Starten Sie den Agenten result = await agent.ainvoke( { "messages": [ HumanMessage(content=f"Recherchieren Sie dieses Thema:n{topic}") ] }, # Endlosschleifen verhindern config={"recursion_limit": 12}) # Die endgültige Antwort ausgeben print(result["messages"][-1].content) ``` So sieht das in `main()` aus: ```none async def main(): # Umgebungsvariablen aus .env laden load_dotenv() # Bright Data-Token lesen bd_token = os.getenv("BRIGHTDATA_TOKEN") if not bd_token: raise ValueError("Missing BRIGHTDATA_TOKEN") # Mit dem Bright Data MCP-Server verbinden client = MultiServerMCPClient({ "bright_data": { "url": f"https://mcp.brightdata.com/mcp?token={bd_token}", "transport": "streamable_http", } }) # Alle verfügbaren MCP-Tools abrufen (suchen, scrapen usw.) tools = await client.get_tools() tools_by_name = {tool.name: tool for tool in tools} # Initialisiere das LLM und erlaube ihm, MCP-Tools aufzurufen. llm = ChatOpenAI(model="gpt-4.1-mini", temperature=0) llm_with_tools = llm.bind_tools(tools) # LangGraph-Agent erstellen graph = StateGraph(MessagesState) graph.add_node("llm_call", make_llm_call_node(llm_with_tools)) graph.add_node("tool_node", make_tool_node(tools_by_name)) # Graph-Ablauf: # START → LLM → (tools?) → LLM → END graph.add_edge(START, "llm_call") graph.add_conditional_edges("llm_call", should_continue, ["tool_node", END]) graph.add_edge("tool_node", "llm_call") agent = graph.compile() # Beispiel für eine Rechercheanfrage topic = "Was ist das Model Context Protocol (MCP) und wie wird es mit LangGraph verwendet?" # Agent ausführen result = await agent.ainvoke( { "messages": [ HumanMessage(content=f"Recherchiere dieses Thema:n{topic}") ] }, # Endlosschleifen verhindern config={"recursion_limit": 12} ) # Die endgültige Antwort ausgeben print(result["messages"][-1].content) ``` > **Hinweis:** Eine vollständige, ausführbare Version dieses Agenten finden Sie in diesem [GitHub-Repository](https://github.com/stamd/brightdata-web-mcp-langgraph-demo/tree/main). Klonen Sie das Repo, fügen Sie Ihre API-Schlüssel zu einer `.env-Datei` hinzu und führen Sie das Skript aus, um die vollständige LangGraph + Bright Data MCP-Schleife in Aktion zu sehen. ## Verwendung von kostenpflichtigen Web-MCP-Tools zur Überwindung von Herausforderungen beim Web-Scraping mit Browser-Automatisierung Statisches Scraping funktioniert nicht mehr, sobald Sie über servergerenderte Seiten hinausgehen und zu JavaScript-lastigen oder interaktionsgesteuerten Websites gelangen. Dies ist dieselbe Unterscheidung [zwischen statisch und dynamisch](/blog/web-data/static-vs-dynamic-content), die darüber entscheidet, wann Sie einen echten Browser anstelle von rohem HTML benötigen. Es versagt auch auf Seiten, die echte Benutzerinteraktion erfordern (unendliches Scrollen, buttongesteuerte Paginierung), wo [die Browser-Automatisierung](/blog/proxy-101/browser-automation-explained) die einzige zuverlässige Option ist. Bright Data MCP bietet Browser-Automatisierung und erweitertes Scraping-Browser als MCP-Tools an. Für den Agenten sind dies lediglich zusätzliche Optionen, wenn einfachere Tools nicht ausreichen. ### Browser-Automatisierungstools in Bright Data MCP aktivieren Da die Browser-Automatisierungstools von Bright Data MCP nicht in der kostenlosen Version enthalten sind, müssen Sie zunächst im Menü „Abrechnung” in der linken Seitenleiste Guthaben auf Ihr Bright Data-Konto laden. Aktivieren Sie anschließend die Browser-Automatisierungstools-Gruppe für Ihre MCP-Einrichtung. Öffnen Sie den Abschnitt „MCP” und klicken Sie auf „Bearbeiten”: ![Bright Data MCP Settings](https://media.brightdata.com/2026/01/BknKZooS-e.png)Aktivieren Sie nun einfach „Browser-Automatisierung“ und klicken Sie auf „Weiter zur Konfiguration“: ![Enabling Browser Automation Tools Group](https://media.brightdata.com/2026/01/SkEqWjoHZg.png)Behalten Sie die Standardeinstellungen bei und klicken Sie auf „Kopieren & Schließen“: ![Bright Data MCP Configuration](https://media.brightdata.com/2026/01/rkCqbioHbx.png)Nach der Aktivierung werden diese Tools neben den Such- und Scrape-Tools angezeigt, wenn der Agent `client.get_tools()` aufruft. ### Erweitern Sie den vorhandenen LangGraph-Agenten für Browser-Automatisierungstools Der entscheidende Punkt hierbei ist einfach: Sie ändern Ihre LangGraph-Architektur nicht. Ihr Agent kann bereits: - Entdeckt Tools dynamisch - bindet sie an das Modell - leitet die Ausführung über dieselbe `LLM -> Tool ->` Beobachtungsschleife Durch das Hinzufügen von Browser-Automatisierungstools ändert sich lediglich, welche Tools verfügbar sind. In der Praxis ändert sich lediglich die MCP-Verbindungs-URL. Anstatt eine Verbindung zum Basis-Endpunkt herzustellen, fordern Sie die erweiterten Scraping- und Browser-Automatisierungstool-Gruppen an: ```none # Erweiterte Scraping- und Browser-Automatisierung aktivieren "url": f"https://mcp.brightdata.com/mcp?token={bd_token}&groups=advanced_scraping,browser" ``` Wenn Sie das Skript erneut ausführen, gibt `client.get_tools()` zusätzliche browserbasierte Tools zurück. Das Modell kann diese auswählen, wenn das statische Scraping dünne oder unvollständige Ergebnisse liefert. ## Fazit LangGraph bietet Ihnen eine klare, überprüfbare Agentenschleife mit Status-, Routing- und Stoppbedingungen, die Sie selbst steuern können. Bright Data MCP ermöglicht dieser Schleife einen zuverlässigen Zugriff auf echte Webdaten, ohne die Scraping-Logik in Prompts oder Code zu verschieben. Das Ergebnis ist eine klare Trennung der Aufgabenbereiche. Das Modell entscheidet, was zu tun ist. LangGraph entscheidet, wie die Schleife abläuft. Bright Data kümmert sich um die Suche, Extraktion und Blockierung. Wenn etwas fehlschlägt, können Sie sehen, wo und warum es fehlgeschlagen ist. Ebenso wichtig ist, dass diese Konfiguration Sie nicht in eine Sackgasse führt. Sie können mit einfachen Web-MCP-Tools für schnelle Recherchen beginnen und zu kostenpflichtigen Web-MCP-Tools wechseln, wenn das statische Web-Scraping nicht mehr funktioniert. Die Agent-Architektur bleibt unverändert. Nur die Reichweite des Agenten wird erweitert. Vertrieb kontaktierenGratis testen![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Inhaltsverzeichnis [ ](https://news.ycombinator.com/submitlink?t=Integration+von+Bright+Data+MCP+mit+LangGraph&u=https://brightdata.de/blog/ai/langgraph-with-web-mcp) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Integration+von+Bright+Data+MCP+mit+LangGraph&url=https://brightdata.de/blog/ai/langgraph-with-web-mcp) [ ](http://www.reddit.com/submit?title=Integration+von+Bright+Data+MCP+mit+LangGraph&url=https://brightdata.de/blog/ai/langgraph-with-web-mcp) ## Das könnte Sie auch interessieren [ ![OpenHuman with Bright Data](https://media.brightdata.de/2026/09/OpenHuman-with-Bright-Data.png) ](https://brightdata.de/blog/ai/openhuman-with-bright-data "Produktionsreifer Web-Zugriff in OpenHuman über die Bright Data CLI") [AI ![Antonello Zanini](https://media.brightdata.de/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Produktionsreifer Web-Zugriff in OpenHuman über die Bright Data CLI Integrieren Sie die Bright Data CLI mit OpenHuman, um produktionsreifen Web-Zugriff und Datenerhebung für KI-Agenten zu ermöglichen. 09-Sep-2026 12 min lesen ](https://brightdata.de/blog/ai/openhuman-with-bright-data) [ ![Multimodal Web Scraping with MiniMax](https://media.brightdata.de/2026/09/Multimodal-Web-Scraping-with-MiniMax.png) ](https://brightdata.de/blog/web-data-de/multimodal-web-scraping-with-minimax "Multimodales Web-Scraping mit MiniMax") [Web Data ![Antonello Zanini](https://media.brightdata.de/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Multimodales Web-Scraping mit MiniMax Kombinieren Sie Bright Data Web Unlocker mit MiniMax M3 Vision, um strukturierte Daten aus Bildern und Webseiten-Screenshots zu extrahieren. 09-Sep-2026 4 min lesen ](https://brightdata.de/blog/web-data-de/multimodal-web-scraping-with-minimax) [ ![The 10 Best CLI Tools for Codex in 2026](https://media.brightdata.de/2026/08/The-10-Best-CLI-Tools-for-Codex-in-2026.png) ](https://brightdata.de/blog/ai/best-cli-tools-for-codex "Die 10 besten CLI-Tools für Codex im Jahr 2026 – Getestet & Bewertet") [AI ![Daniel Shashko](https://media.brightdata.de/2022/04/Daniel-Shashko-2-50x50.png) Daniel Shashko Web Data & AI Expert ### Die 10 besten CLI-Tools für Codex im Jahr 2026 – Getestet & Bewertet Die 10 CLI-Tools, die Codex schneller und leistungsfähiger machen, beginnend mit dem Bright Data CLI für echten Web-Zugriff aus der Sandbox heraus. 06-Sep-2026 20 min lesen ](https://brightdata.de/blog/ai/best-cli-tools-for-codex)