--- title: "Web-Scraping mit GLM: Text- und visuelle Datenextraktion" slug: web-scraping-with-glm date: 2026-09-16T11:16:46+00:00 modified: 2026-09-16T11:16:48+00:00 permalink: https://brightdata.de/blog/ai/web-scraping-with-glm type: blog --- [ Blog ](https://brightdata.de/blog "Blog") / [AI](https://brightdata.de/blog/ai) [AI](https://brightdata.de/blog/ai) # Web-Scraping mit GLM: Text- und visuelle Datenextraktion Verwenden Sie GLM-5.3 mit Bright Datas Web Unlocker für KI-gestütztes Web-Scraping. Extrahieren Sie automatisch Text- und visuelle Daten und umgehen Sie gängige Hindernisse. 5 min lesen [ ![Antonello Zanini](https://media.brightdata.de/2022/12/Antonello-Zanini-2-50x50.jpg) ](https://brightdata.com/blog/authors/antonello-zanini) [Antonello Zanini Technical Writer ](https://brightdata.com/blog/authors/antonello-zanini) ![Web Scraping with GLM](https://media.brightdata.de/2026/09/Web-Scraping-with-GLM.png) In diesem Artikel erfahren Sie: - Warum GLM-5.3 und GLM-5.3-Flash einen bedeutenden Fortschritt für KI-gestützte Web-Scraping-Aufgaben darstellen. - Die zentralen Hindernisse beim Aufbau von Web-Datenextraktionssystemen und wie die Bright Data Web Unlocker API diese löst. - Eine schrittweise Implementierung von KI-gestütztem Web-Scraping mit GLM in Python. - Wie man visuelles Web-Scraping mit den multimodalen Fähigkeiten von GLM-5.3 durchführt. Legen wir los! ## Vorteile von GLM-Modellen für die Web-Datenextraktion Moderne LLMs haben den Ansatz beim Web-Scraping revolutioniert. Anstatt manuelle Parsing-Routinen zur Verarbeitung von rohem HTML-Markup zu implementieren, können Sie ein KI-Modell nutzen, das die Extraktion automatisch übernimmt. Dies beseitigt die Anfälligkeit [CSS-Selektor-basierter Ansätze und XPath-Ausdrucksabgleiche](/blog/web-data/xpath-vs-css-selectors). Alles, was Sie brauchen, ist ein gut formulierter Prompt, der die benötigten Datenelemente spezifiziert. Mit wenigen Codezeilen können Sie das LLM anweisen, strukturierte Daten aus jeder Webseite zu identifizieren und zu extrahieren. Diese KI-gesteuerte Methodik erzeugt Web-Scraper, die bei Änderungen der Seitenstruktur wesentlich robuster sind. In diesem Kontext ist [GLM-5.3](https://z.ai/blog/glm-5.3) außergewöhnlich leistungsfähig bei textbasiertem Informationsabruf und strukturierter Datengenerierung. [GLM-5.3-Flash](https://z.ai/blog/glm-5.3-flash) bietet zusätzlich Vision-Funktionalität, die es ermöglicht, Webseiten-Screenshots und grafische Elemente zu analysieren. Für weiteren Kontext konsultieren Sie diese verwandten Ressourcen: 1. Allgemeine Prinzipien der [KI-gestützten Web-Scraping-Methodik](/blog/web-data/ai-web-scraping). 2. Anwendung von [KI für visuelle Datenextraktion über GPT Vision](/blog/ai/web-scraping-with-gpt-vision). ## Hauptherausforderungen beim KI-Web-Scraping KI-basierte Extraktion reduziert die Empfindlichkeit gegenüber Änderungen im Seiten-Markup. Dennoch sind die technischen Hauptherausforderungen beim KI-Web-Scraping weitgehend identisch mit denen beim [traditionellen Web-Scraping](/blog/web-data/web-scraping-challenges). Die Hauptprobleme bleiben JavaScript-Rendering, Anti-Bot-Erkennungssysteme, Device-Fingerprinting-Techniken, Anfrage-Ratenlimitierungen, CAPTCHAs und IP-Reputationsprobleme. Schließlich müssen Sie, bevor ein LLM eine Webseite verarbeiten kann, zunächst deren Inhalt abrufen. Dies erfordert den Umgang mit verschiedenen Schutzmaßnahmen, die programmatischen Zugriff verhindern sollen. KI-gestützte Extraktion beseitigt also nicht die grundlegende Schwierigkeit, Webseiteninhalt in großem Maßstab zu beschaffen. Sicher ist, dass das Hinzufügen von KI zum Prozess zusätzliche Überlegungen einführt. Insbesondere wird der Token-Verbrauch zu einem kritischen Faktor. Das Übertragen umfangreicher HTML-Dokumente an fortschrittliche Modelle wie [GLM-5.3 kann schnell erhebliche Kosten verursachen](https://openrouter.ai/z-ai/glm-5.3). Die optimale Lösung besteht darin, rohes HTML in ein LLM-optimiertes Markdown-Format umzuwandeln. Die Konvertierung von Webseiten in strukturiertes Markdown bewahrt wesentliche Informationen und die Layout-Hierarchie, während [unnötiger Token-Verbrauch drastisch reduziert wird](https://www.kaggle.com/code/brightdataml/benchmarking-ai-on-different-data-formats). Diese Transformation erhält Überschriften, nummerierte Listen, Bild-URLs und Bildunterschriften sowie Hyperlinks in einem Format, das LLMs effizient verarbeiten können. Weitere Details finden Sie in unserem [Tutorial zur HTML-zu-Markdown-Konvertierung](/blog/web-data/scrape-websites-to-markdown). ### Bright Data Web Unlocker API: Die Lösung [Bright Datas Web Unlocker API](/products/web-unlocker) bietet eine All-in-One-Lösung für die grundlegenden Herausforderungen des Web-Scrapings. Das gilt unabhängig davon, ob Sie traditionelles oder KI-gestütztes Parsing einsetzen möchten. Die Web Unlocker API funktioniert als Endpunkt, der eine Ziel-URL akzeptiert und deren gerenderten Inhalt zurückgibt, während alle Anti-Bot-Schutzmaßnahmen gehandhabt werden. Insbesondere [umgeht sie CAPTCHA-Schutzmaßnahmen](/products/web-unlocker/captcha-solver), verarbeitet JavaScript-intensive Seiten, umgeht Browser-Fingerprinting-Erkennung, rotiert IPs für Sie und vieles mehr. Erfahren Sie mehr über [Bright Datas Ansatz zur Anti-Bot-Umgehung](https://docs.brightdata.com/concepts/how-bright-data-handles-blocking). Darüber hinaus bietet die Web Unlocker API die Flexibilität, abgerufene Daten in mehreren Ausgabeformaten zurückzugeben, darunter: 1. [LLM-optimierte Markdown-Darstellung](https://docs.brightdata.com/scraping-automation/web-unlocker/features#scrape-as-markdown) 2. [Screenshot-Aufnahmen der gerenderten Seite](https://docs.brightdata.com/scraping-automation/web-unlocker/features#return-a-screenshot) Dadurch dienen die Antwortdaten von Web Unlocker API-Anfragen als ideale Eingabe für die anschließende text- oder visionsbasierte Datenextraktion mit LLMs wie GLM-5.3 und GLM-5.3-Flash. **Hinweis**: Die Web Unlocker API ist im [kostenlosen Tarif von Bright Data](https://docs.brightdata.com/general/account/billing-and-pricing/free-tier) enthalten, der 5.000 kostenlose Extraktionsanfragen pro Kalendermonat gewährt. Was die Web Unlocker API von [anderen Web-Scraping-APIs](/blog/web-data/best-web-scraping-apis) unterscheidet, ist die zugrunde liegende Enterprise-Infrastruktur von Bright Data. Dazu gehören [über 400 Millionen Residential-IPs](/proxy-types/residential-proxies), unbegrenzte Parallelität, 99,99 % Verfügbarkeit und eine Erfolgsrate von 99,95 %. Eine solche Infrastruktur ermöglicht zuverlässige, hochskalierbare programmgesteuerte Datenextraktion. ## So erstellen Sie einen KI-gestützten Web-Scraper mit GLM-5.3 in Python In diesem geführten Abschnitt lernen Sie, wie Sie ein Python-Skript entwickeln, das GLM-5.3 für KI-gestütztes Daten-Parsing nutzt. Das Skript konzentriert sich auf die Datenerhebung von [dieser spezifischen IKEA-Produktseite](https://www.ikea.com/us/en/p/kallax-shelf-unit-white-20631663/): ![Die Ziel-IKEA-Produktseite](https://media.brightdata.com/2026/09/s_6FB0F5024692B91859A75BD16655F25AA285B0BD9B0FDF3E4918A147DCEBE020_1788762050773_image.png)Der entscheidende Vorteil KI-basierter Datenanalyse besteht darin, dass derselbe Code auf alle IKEA-Produktseiten angewendet werden kann – unabhängig von deren individuellen Layouts oder Designvariationen. Der Arbeitsablauf wird sein: 1. Die Bright Data Web Unlocker API ruft die Ziel-IKEA-Produktseite ab und gibt deren Inhalt als LLM-optimiertes Markdown aus. 2. GLM-5.3 empfängt den Markdown-Inhalt über die OpenAI-kompatible Z.ai-API und extrahiert die Produktinformationen. 3. Die resultierende Ausgabe, die einem vordefinierten JSON-Schema entspricht, wird auf die Festplatte exportiert. **Hinweis**: Für Produktionssysteme, die strukturierte IKEA-Produktdaten in großem Maßstab benötigen, sollten Sie die [IKEA Scraper API von Bright Data](/products/web-scraper/ikea) verwenden. Folgen Sie den nachstehenden Anweisungen! ### Voraussetzungen Stellen Sie die Verfügbarkeit folgender Elemente sicher: - [Python 3.10 oder höher auf Ihrem System installiert](https://www.python.org/downloads/). - Ein aufgeladenes GLM-Konto mit einem [konfigurierten API-Schlüssel](https://docs.z.ai/guides/overview/quick-start). - Ein [Bright Data-Konto](/) mit einer Web Unlocker API und einem eingerichteten API-Schlüssel. – Konsultieren Sie die [Web Unlocker-Einrichtungsdokumentation](https://docs.brightdata.com/scraping-automation/web-unlocker/quickstart). – Folgen Sie der [offiziellen Anleitung zum Abrufen Ihres Bright Data API-Schlüssels](https://docs.brightdata.com/api-reference/authentication#how-do-i-generate-a-new-api-key). In diesem Leitfaden gehen wir davon aus, dass Ihre Web Unlocker API-Zone den Namen `web_unlocker` trägt: ![Beachten Sie die 'web_unlocker' Web Unlocker API](https://media.brightdata.com/2026/09/s_D54454B29C197607436216DCBC5E89672703EAC9B2F7B45AF3EE53B9B53E9CBC_1787157865431_image.png)Ihr Z.ai API-Schlüssel wird so aussehen: ![Beachten Sie den Z.ai API-Schlüssel](https://media.brightdata.com/2026/09/s_6FB0F5024692B91859A75BD16655F25AA285B0BD9B0FDF3E4918A147DCEBE020_1788768746761_image.png)### Schritt #1: Python-Projekt initialisieren Erstellen Sie ein neues Verzeichnis für Ihr GLM-Scraping-Projekt: ```none mkdir glm-scraper ``` Wechseln Sie in dieses Verzeichnis und fügen Sie eine Python-[virtuelle Umgebung](https://docs.python.org/3/library/venv.html) hinzu: ```none cd glm-scraper python -m venv .venv ``` Laden Sie das Projektverzeichnis in Ihren bevorzugten Python-Editor, z. B. [Visual Studio Code](https://code.visualstudio.com/docs/languages/python) oder [PyCharm](https://www.jetbrains.com/pycharm/download/#section=windows). Fügen Sie im Projektstamm eine `scraper.py`-Datei hinzu: ```none glm-scraper ├─── .venv/ └─── scraper.py # <----- ``` Diese Datei enthält den Python-Code für KI-gestützte Datenextraktion mit GLM-Modellen. Aktivieren Sie anschließend die virtuelle Umgebung. Auf Linux- oder macOS-Systemen führen Sie aus: ```none source .venv/bin/activate ``` Auf Windows-Plattformen führen Sie aus: ```none .venv\Scripts\activate ``` Nach der Aktivierung installieren Sie alle erforderlichen Projektabhängigkeiten: ```none pip install dotenv requests openai pydantic ``` Diese erforderlichen Pakete sind: - [`dotenv`](https://pypi.org/project/python-dotenv/): Verwaltung von Umgebungsvariablen zur Speicherung von API-Schlüsseln. - [`requests`](https://pypi.org/project/requests/): HTTP-Client für die Kommunikation mit der Bright Data Web Unlocker API. - [`openai`](https://pypi.org/project/openai/): OpenAI-kompatibler Client für den Zugriff auf die OpenAI-kompatiblen Z.ai APIs für GLM-Zugang. - [`pydantic`](https://pypi.org/project/pydantic/): Framework zur Datenmodell-Definition und -Validierung für das Ausgabeschema. Gut gemacht! Ihr Python-Projekt ist jetzt für Web-Scraping mit GLM bereit. ### Schritt #2: Umgebungsvariablen einlesen Ihr GLM-Scraper benötigt Authentifizierung bei externen Diensten, einschließlich der APIs von Bright Data und Z.ai. Diese Integrationen erfordern API-Schlüssel, die Sie aus Sicherheitsgründen niemals in Ihrem Quellcode offenlegen sollten. Pflegen Sie stattdessen Ihre API-Schlüssel in einer Umgebungskonfigurationsdatei und laden Sie sie während der Ausführung. Das `python-dotenv`-Paket vereinfacht diesen Prozess, indem es Ihnen ermöglicht, Umgebungsvariablen aus einer `.env`-Datei zu lesen. Fügen Sie zum Einstieg mit `python-dotenv` diesen Code am Anfang von `scraper.py` hinzu: ```none from dotenv import load_dotenv # Load the environment variables from the .env file load_dotenv() ``` Erstellen Sie dann eine `.env`-Datei im Projektstamm: ```none glm-scraper ├─── .venv/ ├─── .env # <----- └─── scraper.py ``` **Tipp**: Fügen Sie in einem echten Repository `.env` zu Ihrer `.gitignore`-Konfiguration hinzu, um versehentliche Credential-Exposition zu verhindern. Befüllen Sie sie mit Ihren API-Anmeldedaten: ```none BRIGHT_DATA_API_KEY="" ZAI_API_KEY="" ``` Ersetzen Sie: - `` durch Ihre Bright Data API-Anmeldedaten. - `` durch Ihren Z.ai API-Schlüssel. Laden Sie anschließend diese Umgebungsvariablen mit Pythons [`os.getenv()`](https://docs.python.org/3/library/os.html#os.getenv) in Ihr Skript: ```none import os # Loading the required secrets from the envs ZAI_API_KEY = os.environ.get("ZAI_API_KEY") BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY") ``` Ausgezeichnet! Sie haben jetzt sicheren Zugriff auf Ihre API-Schlüssel in Ihrem Python-Skript. ### Schritt #3: Ziel-Webseite im Markdown-Format mit der Web Unlocker API abrufen Die erste Phase des KI-gestützten Scrapings umfasst das Abrufen der Zielseite, idealerweise im LLM-fertigen Markdown-Format. Bright Datas Web Unlocker API bietet den einfachsten Weg, dies zu erreichen. Für weitere Anleitungen zur Web Unlocker-Integration [konsultieren Sie die offizielle Dokumentation](https://docs.brightdata.com/scraping-automation/web-unlocker/send-your-first-request#direct-api-access-recommended) oder untersuchen Sie [Bright Datas Python-Integrationsbeispiele](https://github.com/luminati-io/bright-data-web-unlocker-python-project). Verwenden Sie die `requests`-Bibliothek, um eine HTTP-`POST`-Anfrage an Web Unlocker zu senden und die Zielseite als Markdown abzurufen: ```none import requests # Set up the authentication headers for Web Unlocker headers = { "Content-Type": "application/json", "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}" } # Define the request payload for the Web Unlocker API call payload = { "zone": "web_unlocker", # Replace with your Web Unlocker zone name "url": "https://www.ikea.com/us/en/p/kallax-shelf-unit-white-20631663/", # The IKEA product page URL you want to scrape "format": "raw", "country": "us", "data_format": "markdown" # Request Markdown-formatted output } # Retrieve the unlocked content of the target page web_unlocker_response = requests.post( "https://api.brightdata.com/request", json=payload, headers=headers ) markdown_page = web_unlocker_response.text ``` Falls Sie mit der Python-HTTP-Syntax nicht vertraut sind, lesen Sie [unseren umfassenden Requests-Leitfaden](/blog/web-data/python-requests-guide). Beachten Sie den Parameter `data_format="markdown"` im Body. Diese Konfiguration weist die Web Unlocker API an, [die Webseite im Markdown-Format auszugeben](https://docs.brightdata.com/scraping-automation/web-unlocker/features#scrape-as-markdown), anstatt rohes HTML zu liefern. Geben Sie `markdown_page` aus, und Sie sehen: ![Die vom Web Unlocker API-Aufruf erzeugte Ausgabe](https://media.brightdata.com/2026/09/s_6FB0F5024692B91859A75BD16655F25AA285B0BD9B0FDF3E4918A147DCEBE020_1788772216654_image.png)Die zurückgegebene Ausgabe repräsentiert die Markdown-konvertierte Version Ihrer Ziel-IKEA-Produktseite. Beachten Sie, wie die Web Unlocker API die Hindernisse beim Abrufen von Webseiten bewältigt: 1. Zugriff auf die IKEA-Infrastruktur über Bright Datas Residential-Proxy-Netzwerk. 2. Verwaltung typischer Anti-Bot-Gegenmaßnahmen, wie IKEAs Anti-Scraping-Systeme. 3. Abruf des vollständig gerenderten Seiten-Markups. 4. Umwandlung des HTML in LLM-optimiertes Markdown und Rückgabe des Ergebnisses. Sie haben jetzt Seiteninformationen in einem perfekten Format für das textbasierte Daten-Parsing mit GLM-5.3. Bevor Sie fortfahren, definieren Sie die Ausgabestruktur, die GLM erzeugen soll! ### Schritt #4: Ausgabe-JSON-Schema definieren GLM-5.3 erzeugt wie die meisten anderen LLMs standardmäßig Textausgaben. Dies ist für Datenextraktions-Workflows suboptimal, bei denen das Ziel die Umwandlung von rohem Webinhalt in strukturierte Daten ist. Glücklicherweise unterstützt die GLM-5.3-API strukturierte Ausgaben durch den [JSON-Modus](https://docs.z.ai/guides/capabilities/struct-output). Diese Funktionalität ermöglicht es dem Modell, einen einfachen JSON-String zurückzugeben. **Hinweis**: Während Sie das Schema nicht direkt im `json_schema`-Argument angeben können, [wie es bei OpenAIs strukturierten Ausgaben möglich ist](https://developers.openai.com/api/docs/guides/structured-outputs?api-mode=responses), können Sie die gewünschte Antwortstruktur im Prompt erwähnen. Dies verpflichtet das Modell, einen JSON-String zu erzeugen, der diesem Format entspricht. Die bequemste Methode zur Definition strukturierter [JSON-Schemas](https://json-schema.org/) in Python ist [Pydantic](https://pydantic.dev/), das beliebteste Datenmodellierungs-Framework. Pydantic hilft Ihnen, Datenstrukturen über Python-Klassen darzustellen, die in das JSON-Schema-Format für die Z.ai-API konvertiert werden können. Beginnen Sie damit, die Ziel-IKEA-Seite zu untersuchen, um erforderliche Informationsfelder zu identifizieren. Definieren Sie für dieses Beispiel ein Pydantic-Modell, das IKEA-Produktdetails erfasst: ```none from pydantic import BaseModel, Field from typing import List, Optional class IkeaProduct(BaseModel): title: Optional[str] = Field(None, description="Full product title as displayed on the IKEA website") product_number: Optional[str] = Field(None, description="IKEA product article number, such as 304.247.75") product_type: Optional[str] = Field(None, description="General type of IKEA product, such as armchair, shelf unit, cabinet, or table") price: Optional[float] = Field(None, description="Current one-time purchase price") currency: Optional[str] = Field(None, description="Currency used for the displayed price, such as USD") color: Optional[str] = Field(None, description="Product color or finish, such as birch veneer or dark gray") dimensions: Optional[str] = Field(None, description="Overall product dimensions as displayed by IKEA, including width, depth, and height") materials: Optional[List[str]] = Field(None, description="Main materials used to manufacture the product") rating: Optional[float] = Field(None, description="Average customer rating, typically on a 5-point scale") review_count: Optional[int] = Field(None, description="Total number of customer reviews") series: Optional[str] = Field(None, description="IKEA product series the item belongs to, such as POÄNG") assembly_required: Optional[bool] = Field(None, description="Whether the product requires assembly") is_in_stock: Optional[bool] = Field(True, description="Whether the product is currently available for purchase") ``` Dieses Modell organisiert IKEA-Produktinformationen in [Pydantic-Felder](https://pydantic.dev/docs/validation/2.0/usage/types/types_fields/) mit expliziter Typisierung. GLM-5.3 wird passende Werte aus dem Seiteninhalt abrufen und sie als JSON-String-Antwort liefern, die diesem Schema entspricht. **Profi-Tipp**: Übergeben Sie das vom Web Unlocker API abgerufene Markdown an ein LLM und bitten Sie es, ein Pydantic-Modell zu erstellen, das alle Datenpunkte enthält, die Sie interessieren. Wunderbar! Sie besitzen jetzt alle notwendigen Komponenten für GLM-Web-Scraping. ### Schritt #5: GLM-5.3 für automatisiertes Daten-Parsing verwenden Die Z.ai-API ist mit den OpenAI Chat Completions- und Responses-Schnittstellen kompatibel, was den [Zugriff über das OpenAI Python SDK](https://docs.z.ai/guides/develop/openai/python#openai-python-sdk) ermöglicht. Konfigurieren Sie den OpenAI-Client mit Ihren Z.ai API-Anmeldedaten und der entsprechenden API-Basis-URL. ```none from openai import OpenAI # Initialize the OpenAI client for interacting with Z.ai API glm_client = OpenAI( api_key=ZAI_API_KEY, base_url="https://api.z.ai/api/paas/v4/", # OpenAI Chat Completions-compatible GLMM API base URL ) ``` Verwenden Sie dann den [Chat Completions-Endpunkt](https://docs.z.ai/api-reference/llm/chat-completion), um das extrahierte Markdown an GLM-5.3 zu übertragen: ```none import json # Prepare the scraping prompt with the output schema scraping_prompt = f""" Extract the IKEA product information from the given Markdown document and return it as structured data that conforms to the provided JSON schema. SCHEMA: {json.dumps(IkeaProduct.model_json_schema(), indent=2)} MARKDOWN: {markdown_page} """ # Perform web data parsing with GLM-5.3 response = glm_client.chat.completions.create( model="glm-5.3", messages=[ { "role": "user", "content": [ { "type": "text", "text": scraping_prompt, }, ], } ], response_format={"type": "json_object"} ) # Get the parsed data in a string matching the defined schema format product_data = response.choices[0].message.content ``` Beachten Sie, dass der Prompt Folgendes enthalten muss: 1. Ihre Web-Datenextraktionsanweisungen. 2. Das Ziel-JSON-Schema. 3. Den Markdown-Inhalt von Bright Datas Web Unlocker API. Der Parameter `response_format` aktiviert den JSON-Modus mit `{"type": "json_object"}`. Denken Sie daran, dass GLM-5.3 das Format `json_object` anstelle von `json_schema` unterstützt. Das ist ein entscheidender Unterschied zu einigen alternativen Modellen, wie beim [Web-Scraping mit Kimi](/blog/ai/web-scraping-with-kimi). **Hinweis**: Die [optionalen Parameter `thinking` und `reasoning_effort`](https://docs.z.ai/guides/capabilities/thinking-mode) aktivieren die erweiterten Reasoning-Fähigkeiten von GLM-5.3. Setzen Sie `reasoning_effort` auf `"max"`, um tiefes Reasoning für hochkomplexe Daten-Parsing-Aufgaben zu aktivieren. Dies ist besonders wertvoll, wenn Seiten mehrdeutige oder nicht standardmäßige Layouts enthalten. Das Ergebnis ist `product_data`, das einen JSON-String mit den extrahierten Informationen enthält, die gemäß Ihrem `IkeaProduct`-Modell strukturiert sind. Geben Sie es aus, und Sie sehen: ![Die erzeugten Daten sind JSON und entsprechen dem IkeaProduct-Modell](https://media.brightdata.com/2026/09/s_6FB0F5024692B91859A75BD16655F25AA285B0BD9B0FDF3E4918A147DCEBE020_1788770882538_image.png)Toll! Der einzige verbleibende Schritt ist, diese JSON-Daten auf die Festplatte zu speichern. ### Schritt #6: Gescrapte Daten auf die Festplatte speichern Validieren Sie vor dem Speichern von `product_data` in einer `product.json`-Datei die Antwort gegen das `IkeaProduct` Pydantic-Modell: ```none # Get the parsed data in the defined schema format product_data = response.choices[0].message.content # Validate the JSON string against the IkeaProduct schema product = IkeaProduct.model_validate_json(product_data) ``` Die [`model_validate_json()`](https://pydantic.dev/docs/validation/dev/api/pydantic/base_model/#pydantic.BaseModel.model_validate_json)-Methode überprüft, ob die LLM-Antwort dem erwarteten Pydantic-Schema entspricht. Wenn die Antwort ungültige Daten enthält oder nicht mit den definierten Feldtypen übereinstimmt, löst Pydantic einen Validierungsfehler aus, anstatt fehlerhafte Daten stillschweigend zu speichern. Speichern Sie es dann auf die Festplatte: ```none # Export the validated IkeaProduct object to a JSON file with open("product.json", "w", encoding="utf-8") as f: f.write(product.model_dump_json(indent=2)) ``` Dieser Code-Ausschnitt verwendet `product.model_dump_json()`, um das validierte `IkeaProduct`-Objekt zu serialisieren, und schreibt es dann in `product.json`. Die resultierende Datei enthält die strukturierten IKEA-Produktdaten, die von GLM-5.3 extrahiert wurden. Mission erfüllt! ### Schritt #7: Alles zusammenfügen Nachfolgend finden Sie die vollständige Implementierung Ihres GLM-Web-Scrapers für IKEA-Produktseiten: ```none # pip install dotenv requests openai pydantic from dotenv import load_dotenv import os import requests from pydantic import BaseModel, Field from typing import List, Optional from openai import OpenAI import json # Load the environment variables from the .env file load_dotenv() # Loading the required secrets from the envs BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY") ZAI_API_KEY = os.environ.get("ZAI_API_KEY") # The output schema for the product information class IkeaProduct(BaseModel): title: Optional[str] = Field(None, description="Full product title as displayed on the IKEA website") product_number: Optional[str] = Field(None, description="IKEA product article number, such as 304.247.75") product_type: Optional[str] = Field(None, description="General type of IKEA product, such as armchair, shelf unit, cabinet, or table") price: Optional[float] = Field(None, description="Current one-time purchase price") currency: Optional[str] = Field(None, description="Currency used for the displayed price, such as USD") images: Optional[List[str]] = Field(None, description="URLs of product images from the IKEA website") color: Optional[str] = Field(None, description="Product color or finish, such as birch veneer or dark gray") dimensions: Optional[str] = Field(None, description="Overall product dimensions as displayed by IKEA, including width, depth, and height") materials: Optional[List[str]] = Field(None, description="Main materials used to manufacture the product") visual_features: Optional[List[str]] = Field(None, description="Physical characteristics visible in the supplied product images, such as shape, components, finish, or configuration") rating: Optional[float] = Field(None, description="Average customer rating, typically on a 5-point scale") review_count: Optional[int] = Field(None, description="Total number of customer reviews") series: Optional[str] = Field(None, description="IKEA product series the item belongs to, such as POÄNG") designer: Optional[str] = Field(None, description="Designer credited by IKEA for the product") max_load: Optional[str] = Field(None, description="Maximum supported load, such as maximum load on a seat, shelf, or tabletop") care_instructions: Optional[List[str]] = Field(None, description="IKEA-recommended care and cleaning instructions") package_count: Optional[int] = Field(None, description="Number of packages included with the product") package_dimensions: Optional[List[str]] = Field(None, description="Dimensions of the product packaging") package_weight: Optional[str] = Field(None, description="Weight of the packaged product") assembly_required: Optional[bool] = Field(None, description="Whether the product requires assembly") assembly_instructions_url: Optional[str] = Field(None, description="URL to the official IKEA assembly instructions") safety_information: Optional[List[str]] = Field(None, description="Important safety information, such as wall anchoring or tipping requirements") good_to_know: Optional[List[str]] = Field(None, description="Additional IKEA product information and usage recommendations") compatible_series: Optional[List[str]] = Field(None, description="IKEA product series or furniture lines that the product is described as coordinating with") accessories: Optional[List[str]] = Field(None, description="Accessories or complementary IKEA products shown or recommended on the product page") category_path: Optional[List[str]] = Field(None, description="IKEA category breadcrumb path leading to the product") available_colors: Optional[List[str]] = Field(None, description="Other color or finish options available for the same product") is_in_stock: Optional[bool] = Field(True, description="Whether the product is currently available for purchase") # Set up the authentication headers for the Web Unlocker API headers = { "Content-Type": "application/json", "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}" } # Define the request payload for the Web Unlocker API scraping request payload = { "zone": "web_unlocker", # Replace with your Web Unlocker zone name "url": "https://www.ikea.com/us/en/p/kallax-shelf-unit-white-20631663/", # The IKEA product page URL you want to scrape "format": "raw", "country": "us", "data_format": "markdown" # To get the web page in Markdown } # Retrieve the Markdown content of the unlocked target page web_unlocker_response = requests.post( "https://api.brightdata.com/request", json=payload, headers=headers ) markdown_page = web_unlocker_response.text # Initialize the OpenAI client for Z.ai models glm_client = OpenAI( api_key=ZAI_API_KEY, base_url="https://api.z.ai/api/paas/v4/", ) # Prompt to LLM-powered web data parsing scraping_prompt = f""" Extract the IKEA product information from the given Markdown document and return it as structured data that conforms to the provided JSON schema. SCHEMA: {json.dumps(IkeaProduct.model_json_schema(), indent=2)} MARKDOWN: {markdown_page} """ # Perform web data scraping with GLM-5.3 response = glm_client.chat.completions.create( model="glm-5.3", messages=[ { "role": "user", "content": [ { "type": "text", "text": scraping_prompt, }, ], } ], response_format={"type": "json_object"}, ) # Get the parsed data in the defined schema format product_data = response.choices[0].message.content # Convert the JSON string into a validated IkeaProduct object product = IkeaProduct.model_validate_json(product_data) # Export the IkeaProduct object to a JSON file with open("product.json", "w", encoding="utf-8") as f: f.write(product.model_dump_json(indent=2)) ``` Führen Sie das Python-Skript in Ihrer aktivierten virtuellen Umgebung aus: ```none python scraper.py ``` Der Seitenabruf über die Web Unlocker API und die anschließende Verarbeitung durch GLM-5.3 nehmen Zeit in Anspruch. Seien Sie also geduldig, während die `product.json`-Datei erstellt wird. Sobald sie im Projektordner erscheint, öffnen Sie sie, und Sie sehen: ![Eine Teilansicht der 'product.json'-Datei mit den via GLM-5.3 gescrapten Daten](https://media.brightdata.com/2026/09/s_6FB0F5024692B91859A75BD16655F25AA285B0BD9B0FDF3E4918A147DCEBE020_1788763011161_image.png)Beachten Sie die Übereinstimmung zwischen den extrahierten Daten und den auf der ursprünglichen IKEA-Produktseite verfügbaren Informationen. Et voilà! Die Web Unlocker API hat IKEAs Anti-Bot-Schutzmaßnahmen bewältigt und den LLM-optimierten Markdown-Inhalt geliefert, während GLM-5.3 diesen Inhalt erfolgreich verarbeitet und in gut organisierte, strukturierte Daten umgewandelt hat. ## Visuelle Web-Datenextraktion mit GLM-5.3-Flash durchführen GLM-5.3 unterstützt nativ keine multimodalen Eingaben, d. h. es kann nur textbasierte Eingaben verarbeiten. Jedoch [unterstützen andere Modelle der GLM-Familie multimodale Eingaben](https://docs.z.ai/guides/overview/overview#vision-models), darunter GLM-5.3-Flash (sowie GLM-4.6V und andere). Anstatt dem LLM textuellen Seiteninhalt bereitzustellen, können Sie einen Screenshot oder ein Bild liefern und GLM-5.3-Flash bitten, strukturierte Informationen daraus zu extrahieren. Der Scraping-Ablauf bleibt weitgehend gleich: 1. Die Bright Data Web Unlocker API erstellt einen Screenshot der Ziel-IKEA-Seite. 2. GLM-5.3-Flash empfängt den Screenshot über die Z.ai-APIs und extrahiert Produktinformationen gemäß einem vordefinierten Schema. 3. Die extrahierten Daten werden validiert und als strukturiertes JSON gespeichert. **Hinweis**: Der Kernworkflow ändert sich kaum, daher konzentriert sich dieser Abschnitt auf die für die visuelle Datenextraktion erforderlichen Modifikationen. Alle zuvor beschriebenen Voraussetzungen und Einrichtungsschritte bleiben gültig. ### Schritt #1: Seiten-Screenshot abrufen Passen Sie die Web Unlocker API-Anfrage an, um einen Seiten-Screenshot anstelle von Markdown zu erhalten: ```none # Set up the authentication headers for Web Unlocker headers = { "Content-Type": "application/json", "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}" } # Define the request payload for the Web Unlocker API call payload = { "zone": "web_unlocker", # Replace with your Web Unlocker zone name "url": "https://www.ikea.com/us/en/p/kallax-shelf-unit-white-20631663/", # The IKEA product page URL you want to visually scrape "format": "raw", "country": "us", "data_format": "screenshot" # Get a screenshot of the web page } # Retrieve the screenshot of the unlocked target page web_unlocker_response = requests.post( "https://api.brightdata.com/request", json=payload, headers=headers ) page_screenshot = web_unlocker_response.content ``` Die wesentliche Änderung ist das Feld `data_format`, das nun auf `"screenshot"` konfiguriert ist. Dies [weist Web Unlocker an, einen Seiten-Screenshot zurückzugeben](https://docs.brightdata.com/scraping-automation/web-unlocker/features#return-a-screenshot). Die API-Antwort enthält Screenshot-Bilddaten im PNG-Format, die die vollständig gerenderte Seite repräsentieren. Exportieren Sie den Screenshot auf die Festplatte: ```none with open("screenshot.png", "wb") as f: f.write(page_screenshot) ``` Dieser optionale Schritt ist nützlich für die visuelle Inspektion der abgerufenen Seite und zur Fehlersuche in Extraktions-Workflows. Die Ausgabe wird eine `screenshot.png`-Datei sein: ![Die 'screenshot.png'-Datei mit dem IKEA-Produktseiten-Screenshot, erstellt von der Web Unlocker API](https://media.brightdata.com/2026/09/s_6FB0F5024692B91859A75BD16655F25AA285B0BD9B0FDF3E4918A147DCEBE020_1788774214051_image.png)Beachten Sie, wie Bright Datas Web Unlocker API einen Screenshot der vollständigen IKEA-Produktseite aufgenommen hat. Weiter geht’s! ### Schritt #2: Pydantic-Modell aktualisieren Durch die Analyse eines Seiten-Screenshots kann GLM-5.3-Flash visuelle Informationen identifizieren, die in der Markdown-Darstellung der Seite nicht verfügbar sind. Zum Beispiel kann es Text in visuellen Labels interpretieren (z. B. den Tag ‘Best seller’): ![Beachten Sie das visuelle Label 'Best seller'](https://media.brightdata.com/2026/09/s_6FB0F5024692B91859A75BD16655F25AA285B0BD9B0FDF3E4918A147DCEBE020_1788772124070_image.png)Gleichzeitig liefert ein Screenshot nicht alle Seiteninformationen. Felder wie `images` oder `assembly_instructions_url`, die über den Markdown-basierten Extraktions-Workflow zugänglich waren, können nicht aus visuellen Daten befüllt werden. Passen Sie dementsprechend das `IkeaProduct` Pydantic-Modell für die visuelle Verarbeitung an: ```none class IkeaProduct(BaseModel): title: Optional[str] = Field(None, description="Full product title as displayed on the IKEA website") product_type: Optional[str] = Field(None, description="General type of product, such as an armchair, shelf unit, cabinet, or table") price: Optional[float] = Field(None, description="Current displayed numerical price") currency: Optional[str] = Field(None, description="Currency used for the displayed price, such as USD") is_best_seller: Optional[bool] = Field(False, description="Whether a best-seller or top-seller badge is displayed") badge_label: Optional[str] = Field(None, description="Promotional or product badge displayed on the page, such as Top Seller") delivery_options: Optional[List[str]] = Field(None, description="Delivery or fulfillment options displayed on the page") color: Optional[str] = Field(None, description="Selected product color or finish, such as white or birch veneer") visual_aspects: Optional[str] = Field(None, description="Description of the physical characteristics visible in the product images, such as shape, components, finish, or configuration") dimensions: Optional[str] = Field(None, description="Overall product dimensions as displayed on the IKEA website") rating: Optional[float] = Field(None, description="Average customer rating, typically on a 5-point scale") review_count: Optional[int] = Field(None, description="Total number of customer reviews displayed") ``` Beachten Sie die Einführung des Feldes `visual_aspects`. Dieses Feld weist GLM an, physische Merkmale zu dokumentieren, die in Produktbildern sichtbar sind, was die Extraktion von Informationen ermöglicht, die durch textbasiertes Parsing nicht zugänglich sind. Achten Sie auch auf die neuen Felder `is_best_seller` und `badge_label`. Hervorragend! Senden Sie das aktualisierte Pydantic-Modell und den Webseiten-Screenshot an die Z.ai-API für visuelles Web-Scraping mit GLM-5.3-Flash. ### Schritt #3: Daten aus einem Bild mit GLM-5.3 Vision scrapen Genau wie [OpenAI-Modelle mit Vision-Fähigkeiten](https://developers.openai.com/api/docs/guides/images-vision) akzeptiert GLM-5.3-Flash Bilder über das Feld `image_url`. Dieses akzeptiert entweder öffentlich zugängliche Bild-URLs oder [Base64-kodierte Bilddarstellungen](https://developer.mozilla.org/en-US/docs/Glossary/Base64). Da der Screenshot lokal als Bild-Bytes vorliegt, ist eine Base64-Kodierung erforderlich. Verwenden Sie dazu Pythons [`base64`-Modul](https://docs.python.org/3/library/base64.html): ```none import base64 screenshot_base64 = base64.b64encode(page_screenshot).decode("utf-8") ``` Übertragen Sie nun den Base64-kodierten Screenshot zusammen mit Ihren Extraktionsanweisungen an GLM-5.3-Flash: ```none # Perform visual web data parsing with GLM-5.3-Flash response = glm_client.chat.completions.create( model="glm-5.3-flash", messages=[ { "role": "user", "content": [ { "type": "image_url", "image_url": { "url": f"data:image/png;base64,{screenshot_base64}" }, }, { "type": "text", "text": f""" Extract the IKEA product information from the provided webpage screenshot and return it as structured data that conforms to the provided JSON schema. SCHEMA: {json.dumps(IkeaProduct.model_json_schema(), indent=2)} """, }, ], } ], response_format={"type": "json_object"}, ) # Get the parsed data in the defined schema format product_data = response.choices[0].message.content ``` Die Anfrage an die Z.ai-API umfasst zwei Komponenten: 1. Das Seiten-Screenshot-Bild. 2. Eine Textanweisung, die GLM-5.3 anweist, Produktinformationen anhand des definierten Pydantic-Schemas abzurufen. **Hinweis**: Diesmal ist das Zielmodell `glm-5.3-flash`, nicht `glm-5.3` wie zuvor. Diese Änderung ist erforderlich, da GLM-5.3 keine Vision-Fähigkeiten besitzt. Das Ergebnis ist eine Variable `product_data`, die einen JSON-String mit den visuell gescrapten Daten speichert. Speichern Sie ihn wie zuvor beschrieben auf die Festplatte. Beeindruckend! ### Schritt #4: Visuelles GLM-Scraping-Skript testen Der finale Code Ihres visuellen GLM-Web-Scraping-Skripts lautet: ```none # pip install dotenv requests openai pydantic from dotenv import load_dotenv import os import requests import base64 import json from pydantic import BaseModel, Field from typing import List, Optional from openai import OpenAI # Load the environment variables from the .env file load_dotenv() # Loading the required secrets from the envs BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY") ZAI_API_KEY = os.environ.get("ZAI_API_KEY") class IkeaProduct(BaseModel): title: Optional[str] = Field(None, description="Full product title as displayed on the IKEA website") product_type: Optional[str] = Field(None, description="General type of product, such as an armchair, shelf unit, cabinet, or table") price: Optional[float] = Field(None, description="Current displayed numerical price") currency: Optional[str] = Field(None, description="Currency used for the displayed price, such as USD") is_best_seller: Optional[bool] = Field(False, description="Whether a best-seller or top-seller badge is displayed") badge_label: Optional[str] = Field(None, description="Promotional or product badge displayed on the page, such as Top Seller") delivery_options: Optional[List[str]] = Field(None, description="Delivery or fulfillment options displayed on the page") color: Optional[str] = Field(None, description="Selected product color or finish, such as white or birch veneer") visual_aspects: Optional[str] = Field(None, description="Description of the physical characteristics visible in the product images, such as shape, components, finish, or configuration") dimensions: Optional[str] = Field(None, description="Overall product dimensions as displayed on the IKEA website") rating: Optional[float] = Field(None, description="Average customer rating, typically on a 5-point scale") review_count: Optional[int] = Field(None, description="Total number of customer reviews displayed") # Set up the authentication headers for Web Unlocker headers = { "Content-Type": "application/json", "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}" } # Define the request payload for the Web Unlocker API call payload = { "zone": "web_unlocker", # Replace with your Web Unlocker zone name "url": "https://www.ikea.com/us/en/p/kallax-shelf-unit-white-20631663/", # The IKEA product page URL you want to visually scrape "format": "raw", "country": "us", "data_format": "screenshot" # Get a screenshot of the web page } # Retrieve the screenshot of the unlocked target page web_unlocker_response = requests.post( "https://api.brightdata.com/request", json=payload, headers=headers ) page_screenshot = web_unlocker_response.content # Export the screenshot to a PNG file with open("screenshot.png", "wb") as f: f.write(page_screenshot) # Convert the screenshot to Base64 for vision processing screenshot_base64 = base64.b64encode(page_screenshot).decode("utf-8") # Initialize the OpenAI-compatible client for Z.ai glm_client = OpenAI( api_key=ZAI_API_KEY, base_url="https://api.z.ai/api/paas/v4/", ) # Perform visual web data parsing with GLM-5.3-Flash response = glm_client.chat.completions.create( model="glm-5.3-flash", messages=[ { "role": "user", "content": [ { "type": "image_url", "image_url": { "url": f"data:image/png;base64,{screenshot_base64}" }, }, { "type": "text", "text": f""" Extract the IKEA product information from the provided webpage screenshot and return it as structured data that conforms to the provided JSON schema. SCHEMA: {json.dumps(IkeaProduct.model_json_schema(), indent=2)} """, }, ], } ], response_format={"type": "json_object"}, ) # Get the parsed data in the defined schema format product_data = response.choices[0].message.content # Convert the JSON string into a validated IkeaProduct object product = IkeaProduct.model_validate_json(product_data) # Export the IkeaProduct object to a JSON file with open("visual_product.json", "w", encoding="utf-8") as f: f.write(product.model_dump_json(indent=2)) ``` Starten Sie das Skript, und es wird eine `visual_product.json`-Datei generiert, die Folgendes enthält: ![Die 'visual_product.json'-Datei mit den visuell via GLM-5.3-Flash gescrapten Daten](https://media.brightdata.com/2026/09/s_6FB0F5024692B91859A75BD16655F25AA285B0BD9B0FDF3E4918A147DCEBE020_1788773793776_image.png)Beachten Sie den erfolgreichen Abruf von Produktinformationen aus dem Seiten-Screenshot, einschließlich visueller Aspekte und des Labels ‘Best seller’. Erstaunlich! ## Fazit In diesem Tutorial haben Sie gelernt, wie Sie ein LLM-gestütztes Web-Datenextraktionssystem mit GLM-5.3 und GLM-5.3-Flash aufbauen. Die Hauptherausforderungen des KI-Web-Scrapings (d. h. der Zugriff auf Webinhalte ohne Blockierung und deren Konvertierung in ein LLM-fertiges Format) wurden mit Bright Datas Web Unlocker API problemlos bewältigt. Wie hier gezeigt, ermöglicht die Kombination von GLM-5.3 und GLM-5.3-Flash mit der Web Unlocker API die Extraktion strukturierter Informationen sowohl aus Webseiten als auch aus deren visuellen Darstellungen. Dies ist nur einer von vielen Anwendungsfällen, die von [Bright Datas KI-kompatiblen Web-Zugriffslösungen](/ai/web-access) unterstützt werden. Registrieren Sie sich noch heute bei Bright Data und beginnen Sie kostenlos mit unseren Web-Scraping-APIs zu experimentieren! Vertrieb kontaktierenGratis testen![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Inhaltsverzeichnis [ ](https://news.ycombinator.com/submitlink?t=Web-Scraping+mit+GLM%3A+Text-+und+visuelle+Datenextraktion&u=https://brightdata.de/blog/ai/web-scraping-with-glm) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Web-Scraping+mit+GLM%3A+Text-+und+visuelle+Datenextraktion&url=https://brightdata.de/blog/ai/web-scraping-with-glm) [ ](http://www.reddit.com/submit?title=Web-Scraping+mit+GLM%3A+Text-+und+visuelle+Datenextraktion&url=https://brightdata.de/blog/ai/web-scraping-with-glm) ## Das könnte Sie auch interessieren [ ![Containers as a Service (CaaS)](https://media.brightdata.de/2026/09/Container-as-a-Service.png) ](https://brightdata.de/blog/web-data-de/containers-as-a-service "Containers as a Service (CaaS): So nutzen Sie es für Web-Datenpipelines und KI-Agenten") [Web Data ![Antonello Zanini](https://media.brightdata.de/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Containers as a Service (CaaS): So nutzen Sie es für Web-Datenpipelines und KI-Agenten Wie Containers as a Service funktioniert und wie eine Bright Data Web-Scraping-Pipeline für KI-Agenten containerübergreifend skaliert wird. 16-Sep-2026 13 min lesen ](https://brightdata.de/blog/web-data-de/containers-as-a-service) [ ![Cursor + Bright Data vs a default coding agent setup](https://media.brightdata.de/2026/09/Cursor-Bright-Data-vs-a-default-coding-agent-setup.png) ](https://brightdata.de/blog/ai/cursor-bright-data-vs-default-coding-agent "Cursor + Bright Data vs. ein Standard-Coding-Agent-Setup: Aufbau eines echten Preis-Trackers") [AI ![Satyam Tripathi](https://media.brightdata.de/2024/09/Satyam-Tripathi-50x50.png) Satyam Tripathi Technical Writer ### Cursor + Bright Data vs. ein Standard-Coding-Agent-Setup: Aufbau eines echten Preis-Trackers Eine Preis-Tracker-Aufgabe, 41 eingefrorene Retailer-Seiten, zwei Coding-Agents, gleicher Prompt und gleiches Modell. Mit Bright Data’s MCP darunter: 89% Feldgenauigkeit und 40 von 41 gelesenen Seiten. Ohne: 72% und 34. 16-Sep-2026 27 min lesen ](https://brightdata.de/blog/ai/cursor-bright-data-vs-default-coding-agent) [ ![The 10 Best MCP Servers for OpenAI Codex in 2026](https://media.brightdata.de/2026/09/The-10-Best-MCP-Servers-for-OpenAI-Codex-in-2026.png) ](https://brightdata.de/blog/ai/best-mcp-servers-for-codex "Die 10 besten MCP-Server für OpenAI Codex im Jahr 2026") [AI ![Bald man with glasses smiling against light blue background.](https://media.brightdata.de/2022/09/Dvir-Sharon-50x50.png) Dvir Sharon Growth Marketing Manager ### Die 10 besten MCP-Server für OpenAI Codex im Jahr 2026 Die zehn MCP-Server, die es wert sind, mit Codex verbunden zu werden, mit dem genauen TOML für jeden, was jeder Server kostet, bevor er irgendetwas tut, und die drei beliebten, die man überspringen sollte. Bright Data MCP führt für entsperrten Web-Zugriff. 16-Sep-2026 19 min lesen ](https://brightdata.de/blog/ai/best-mcp-servers-for-codex)