--- title: "Verwendung von LlamaIndex und Bright Data für die Websuche" slug: llamaindex-serp-scraping date: 2025-07-07T07:56:02+00:00 modified: 2025-11-04T08:48:13+00:00 permalink: https://brightdata.de/blog/ai/llamaindex-serp-scraping type: blog --- [ Blog ](https://brightdata.de/blog "Blog") / [AI](https://brightdata.de/blog/ai) [AI](https://brightdata.de/blog/ai) # Verwendung von LlamaIndex und Bright Data für die Websuche Eine Schritt-für-Schritt-Anleitung zum Erstellen von LlamaIndex-KI-Agenten, die das Web in Echtzeit mithilfe der leistungsstarken SERP-Integration von Bright Data durchsuchen können. 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) ![Search the web with LlamaIndex blog image](https://media.brightdata.de/2025/07/Search-the-web-with-LlamaIndex-blog-image.png) In diesem Leitfaden erfahren Sie mehr: - Was LlamaIndex ist. - Warum KI-Agenten, die mit LlamaIndex entwickelt wurden, in der Lage sein sollten, Websuchen durchzuführen. - Wie man einen LlamaIndex-KI-Agenten mit Websuchfunktionen erstellt. Lasst uns eintauchen! ## Was ist LlamaIndex? [LlamaIndex](https://www.llamaindex.ai/) ist ein quelloffenes Python-Framework zur Erstellung von Anwendungen, die auf LLMs basieren. Es dient als Brücke zwischen unstrukturierten Daten und LLMs. Insbesondere macht es die Orchestrierung von LLM-Workflows über eine Vielzahl von Datenquellen einfach. Mit LlamaIndex können Sie produktionsreife KI-Workflows und Agenten erstellen. Diese können nach relevanten Informationen suchen und diese abrufen, Erkenntnisse synthetisieren, detaillierte Berichte erstellen, automatisierte Aktionen durchführen und vieles mehr. Zum Zeitpunkt der Erstellung dieses Artikels ist sie eine der am schnellsten wachsenden Bibliotheken im KI-Ökosystem, [mit über 42k Sternen auf GitHub](https://github.com/run-llama/llama_index). ## Warum sollten Sie Web-Suchdaten in Ihren LlamaIndex AI Agent integrieren? Im Vergleich zu anderen [KI-Agenten-Frameworks](/blog/ai/best-ai-agent-frameworks) wurde LlamaIndex entwickelt, um eine der größten Einschränkungen von LLMs zu lösen. Das ist ihr Mangel an aktuellem, realitätsnahem Wissen. Um dieses Problem zu lösen, bietet LlamaIndex Integrationen mit verschiedenen Datenkonnektoren, mit denen Sie Inhalte aus verschiedenen Quellen aufnehmen können. Nun fragen Sie sich vielleicht: *Welche ist die wertvollste Datenquelle für einen KI-Agenten?* Um diese Frage zu beantworten, ist es hilfreich, sich anzusehen, welche [Datenquellen für die Ausbildung von LLMs verwendet werden](/blog/web-data-de/llm-training-data). Erfolgreiche LLMs erhielten die meisten ihrer Trainingsdaten aus dem Internet, der größten und vielfältigsten Quelle für öffentliche Daten. Wenn Sie möchten, dass Ihr LlamaIndex-KI-Agent über seine statischen Trainingsdaten hinausgeht, ist die Schlüsselfähigkeit, die er benötigt, die **Fähigkeit, das Web zu durchsuchen und aus dem, was er findet, zu lernen**. Ihr Agent sollte also in der Lage sein, strukturierte Informationen aus den resultierenden Suchergebnissen (den sogenannten[SERPs](https://www.semrush.com/blog/serp/)) zu extrahieren. Dann sollte er sie sinnvoll verarbeiten und daraus lernen. Die Herausforderung besteht darin, dass SERP-Scraping aufgrund des [jüngsten Vorgehens von Google gegen einfache Scraping-Skripte](https://hackernoon.com/surviving-the-google-serp-data-crisis) viel schwieriger geworden ist. Aus diesem Grund benötigen Sie ein Tool, das sich in LlamaIndex integriert und diesen Prozess vereinfacht. Hier kommt [**die Bright Data-Integration von LlamaIndex**](https://docs.llamaindex.ai/en/stable/api_reference/tools/brightdata/) ins Spiel! Bright Data übernimmt die komplexe Arbeit des SERP Scraping. Mit seinem `search_engine-Tool` kann Ihr LlamaIndex-Agent Suchanfragen durchführen und strukturierte Ergebnisse im Markdown- oder JSON-Format erhalten. Das ist es, was Ihr KI-Agent braucht, um auf Fragen vorbereitet zu sein, sowohl jetzt als auch in Zukunft. Sehen Sie im nächsten Kapitel, wie diese Integration funktioniert! ## Erstellen eines LlamaIndex-Agenten, der das Web mit Hilfe von Bright Data Tools durchsuchen kann In dieser Schritt-für-Schritt-Anleitung sehen Sie, wie Sie mit LlamaIndex einen Python-KI-Agenten erstellen, der das Web durchsuchen kann. Durch die Integration mit Bright Data ermöglichen Sie Ihrem Agenten den Zugriff auf frische, kontextbezogene, reichhaltige Websuchdaten. Weitere Einzelheiten finden Sie [in unserer offiziellen Dokumentation](https://docs.brightdata.com/integrations/llamaindex). Führen Sie die folgenden Schritte aus, um mit LlamaIndex Ihren Bright Data-gestützten KI-SERP-Agenten zu erstellen! ### Voraussetzungen Um diesem Tutorial folgen zu können, benötigen Sie Folgendes: - [Python 3.9 oder höher](https://www.python.org/downloads/) muss auf Ihrem Rechner installiert sein (wir empfehlen die Verwendung der neuesten Version). - Ein Bright Data-API-Schlüssel zur Integration in die SERP-APIs von Bright Data. - Ein API-Schlüssel von einem unterstützten LLM. (In diesem Leitfaden verwenden wir Gemini, das die Integration über API kostenlos unterstützt. Sie können aber auch [jeden anderen LLM-Anbieter](https://docs.llamaindex.ai/en/stable/api_reference/llms/) verwenden [, der von LlamaIndex unterstützt](https://docs.llamaindex.ai/en/stable/api_reference/llms/) wird). Machen Sie sich keine Sorgen, wenn Sie noch keinen Gemini- oder Bright Data-API-Schlüssel haben. Wir zeigen Ihnen in den nächsten Schritten, wie Sie beide erstellen können. ### Schritt #1: Initialisieren Sie Ihr Python-Projekt Starten Sie zunächst Ihr Terminal und erstellen Sie einen neuen Ordner für Ihr LlamaIndex AI Agent Projekt: ```none mkdir llamaindex-bright-data-serp-agent ``` `llamaindex-bright-data-serp-agent/` enthält den gesamten Code für Ihren KI-Agenten mit Websuchfunktionen, die von Bright Data unterstützt werden. Navigieren Sie anschließend in das Projektverzeichnis und erstellen Sie darin eine [virtuelle Python-Umgebung](https://docs.python.org/3/library/venv.html): ```none cd llamaindex-bright-data-serp-agent python -m venv venv ``` Öffnen Sie nun den Projektordner in Ihrer bevorzugten Python-IDE. Wir empfehlen [Visual Studio Code mit der Python-Erweiterung](https://code.visualstudio.com/docs/languages/python) oder [PyCharm Community Edition](https://www.jetbrains.com/pycharm/download/). Erstellen Sie eine neue Datei namens `agent.py` im Stammverzeichnis Ihres Projekts. Die Struktur Ihres Projekts sollte wie folgt aussehen: ```none llamaindex-bright-data-serp-agent/ ├── venv/ └── agent.py ``` Aktivieren Sie im Terminal die virtuelle Umgebung. Unter Linux oder macOS führen Sie aus: ```none source venv/bin/activate ``` Unter Windows führen Sie entsprechend aus: ```none venv/Scripts/activate ``` In den nächsten Schritten werden Sie durch die Installation der erforderlichen Pakete geführt. Wenn Sie jedoch alles im Voraus installieren möchten, führen Sie aus: ```none pip install python-dotenv llama-index-tools-brightdata llama-index-llms-google-genai llama-index ``` **Hinweis**: Wir installieren `llama-index-llms-google-genai`, weil dieses Tutorial [Gemini als LlamaIndex LLM-Anbieter](https://docs.llamaindex.ai/en/stable/examples/llm/gemini/) verwendet. Wenn Sie einen anderen Anbieter verwenden möchten, müssen Sie stattdessen die entsprechende LLM-Integration installieren. Gut gemacht! Ihre Python-Entwicklungsumgebung ist bereit für die Erstellung eines KI-Agenten mit der SERP-Integration von Bright Data unter Verwendung von LlamaIndex. ### Schritt #2: Umgebungsvariablen einbinden Lesen Ihr LlamaIndex-Agent stellt über die API eine Verbindung zu externen Diensten wie Gemini und Bright Data her. Aus Sicherheitsgründen sollten Sie API-Schlüssel niemals direkt in Ihren Python-Code codieren. Verwenden Sie stattdessen Umgebungsvariablen, um sie geheim zu halten. Installieren Sie die Bibliothek [python-dotenv](https://pypi.org/project/python-dotenv/), um die Verwaltung von Umgebungsvariablen zu erleichtern. Starten Sie in Ihrer aktivierten virtuellen Umgebung: ```none pip install python-dotenv ``` Als nächstes öffnen Sie Ihre `agent.py-Datei` und fügen Sie die folgenden Zeilen am Anfang ein, um envs aus einer `.env-Datei` zu laden: ```none from dotenv import load_dotenv load_dotenv() ``` `load_dotenv()` sucht nach einer `.env-Datei` im Hauptverzeichnis Ihres Projekts und lädt deren Werte in die Umgebung. Erstellen Sie nun eine `.env-Datei` neben Ihrer `agent.py-Datei`. Die Struktur Ihrer neuen Projektdatei sollte wie folgt aussehen: ```none llamaindex-bright-data-serp-agent/ ├── venv/ ├── .env # <------------- └── agent.py ``` Fantastisch! Sie haben soeben eine sichere Methode zur Verwaltung sensibler API-Anmeldedaten für Dienste von Drittanbietern eingerichtet. Setzen Sie die Ersteinrichtung fort, indem Sie Ihre `.env-Datei` mit den erforderlichen Umgebungsvariablen füllen! ### Schritt 3: Konfigurieren Sie Bright Data Um eine Verbindung zu den Bright Data SERP APIs in LlamaIndex über das offizielle Integrationspaket herzustellen, müssen Sie zunächst eine Verbindung herstellen: 1. Aktivieren Sie die Web Unlocker Lösung in Ihrem Bright Data Dashboard. 2. Rufen Sie Ihr Bright Data-API-Token ab. Folgen Sie den nachstehenden Schritten, um die Einrichtung abzuschließen! Wenn Sie noch kein Bright Data-Konto haben, \[erstellen Sie eines\](). Wenn Sie bereits ein Konto haben, melden Sie sich an. Klicken Sie im Dashboard auf die Schaltfläche “Proxy-Produkte abrufen”: ![Klicken Sie auf die Schaltfläche "Proxy-Produkte abrufen" in Ihrem Bright Data Dashboard](https://media.brightdata.com/2025/07/image-2-1024x542.png)Sie werden zur Seite “Proxies & Scraping Infrastructure” weitergeleitet: ![Beachten Sie die konfigurierte Web Unlocker API-Zone](https://media.brightdata.com/2025/07/image-3-1024x582.png)Wenn Sie bereits eine aktive Web Unlocker API-Zone sehen (wie im Bild oben), sind Sie bereit. Notieren Sie sich den Zonennamen (z. B. `unlocker`), da Sie ihn später in Ihrem Code verwenden werden. Wenn Sie noch keine Web Unlocker Zone haben, scrollen Sie nach unten zum Abschnitt “Web Unlocker API” und drücken Sie die Schaltfläche “Zone erstellen”: ![Klicken Sie auf "Zone erstellen" auf der Karte "Web Unlocker API".](https://media.brightdata.com/2025/07/image-4-1024x514.png)> **Warum die Web Unlocker API anstelle der speziellen SERP API verwenden?** > Die LlamaIndex-SERP-Integration von Bright Data funktioniert über die Web Unlocker-API. Wenn sie richtig konfiguriert ist, funktioniert Web Unlocker auf die gleiche Weise wie die dedizierten SERP-APIs. Kurz gesagt, wenn Sie eine Web Unlocker API-Zone mit der LlamaIndex Bright Data-Integration einrichten, erhalten Sie automatisch auch Zugriff auf die SERP-APIs. Geben Sie Ihrer neuen Zone einen Namen, z. B. unlocker, aktivieren Sie alle erweiterten Funktionen für eine bessere Leistung, und klicken Sie auf “Hinzufügen”: ![Konfigurieren Sie Ihre neue Web Unlocker API-Zone](https://media.brightdata.com/2025/07/image-5-1024x544.png)Nach der Erstellung werden Sie zur Konfigurationsseite der Zone weitergeleitet: ![Die Seite "unlocker" Web Unlocker API Zone](https://media.brightdata.com/2025/07/image-6-1024x546.png)Vergewissern Sie sich, dass der Aktivierungsschalter auf den Status “Aktiv” eingestellt ist. Dies bestätigt, dass Ihre Zone einsatzbereit ist. Folgen Sie anschließend der [offiziellen Bright Data-Anleitung, um Ihren API-Schlüssel zu generieren](https://docs.brightdata.com/api-reference/authentication#api-key). Sobald Sie Ihren Schlüssel haben, speichern Sie ihn sicher in Ihrer .env-Datei wie folgt: ```none BRIGHT_DATA_API_KEY="" ``` Ersetzen Sie den `` Platzhalter durch Ihren tatsächlichen API-Schlüsselwert. Großartig! Konfigurieren Sie das Bright Data SERP-Tool in Ihrem LlamaIndex-Agentenskript. ### Schritt #4: Zugriff auf das Bright Data LlamaIndex SERP Tool Laden Sie in `agent.py` zunächst Ihren Bright Data-API-Schlüssel aus der Umgebung: ```none BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY") ``` Stellen Sie sicher, dass Sie [`os`](https://docs.python.org/3/library/os.html) aus der Python-Standardbibliothek importieren: ```none import os ``` Installieren Sie in Ihrer aktivierten virtuellen Umgebung das [LlamaIndex Bright Data Tools-Paket](https://pypi.org/project/llama-index-tools-brightdata/): ```none pip install llama-index-tools-brightdata ``` Importieren Sie als Nächstes die [`BrightDataToolSpec-Klasse`](https://docs.llamaindex.ai/en/stable/api_reference/tools/brightdata/#llama_index.tools.brightdata.BrightDataToolSpec) in Ihre `agent.py-Datei`: ```none from llama_index.tools.brightdata import BrightDataToolSpec ``` Erstellen Sie eine Instanz von `BrightDataToolSpec`, indem Sie Ihren API-Schlüssel und den Namen der Web Unlocker-Zone angeben: ```none brightdata_tool_spec = BrightDataToolSpec( api_key=BRIGHT_DATA_API_KEY, zone="unlocker", # Replace with the name of your Web Unlocker zone verbose=True, ) ``` Ersetzen Sie den Zonenwert durch den Namen der Web Unlocker API-Zone, die Sie zuvor eingerichtet haben (in diesem Fall ist es unlocker). Beachten Sie, dass die Einstellung `verbose=True` bei der Entwicklung nützlich ist. Auf diese Weise gibt die Bibliothek hilfreiche Protokolle aus, wenn Ihr LlamaIndex-Agent Anfragen über Bright Data stellt. `BrightDataToolSpec` bietet mehrere Tools, aber hier konzentrieren wir uns auf das Tool [`search_engine`](https://docs.llamaindex.ai/en/stable/api_reference/tools/brightdata/#llama_index.tools.brightdata.BrightDataToolSpec.search_engine). Dieses Tool kann Google, Bing, Yandex und andere abfragen und Ergebnisse in Markdown oder JSON zurückgeben. Um genau dieses Werkzeug zu extrahieren, schreiben Sie: ```none brightdata_serp_tools = brightdata_tool_spec.to_tool_list(["search_engine"]) ``` Das an `to_tool_list()` übergebene Array dient als Filter, der nur das Werkzeug namens `search_engine` einschließt. **Hinweis**: Standardmäßig wählt LlamaIndex das am besten geeignete Werkzeug für eine bestimmte Benutzeranfrage aus. Eine Filterung der Tools ist daher nicht unbedingt erforderlich. Da es in diesem Lernprogramm speziell um die Integration der SERP-Funktionen von Bright Data geht, ist es sinnvoll, sich aus Gründen der Übersichtlichkeit auf das Tool `search_engine` zu beschränken. Großartig! Bright Data ist jetzt integriert und bereit, Ihren LlamaIndex-Agenten mit Web-Suchfunktionen auszustatten. ### Schritt #5: Verbinden Sie ein LLM-Modell Die Anweisungen in diesem Schritt verwenden Gemini als LLM-Anbieter für diese Integration. Ein guter Grund für die Wahl von Gemini ist, dass es kostenlosen API-Zugang zu einigen seiner Modelle bietet. Um mit Gemini in LlamaIndex zu beginnen, installieren Sie das erforderliche Integrationspaket: ```none pip install llama-index-llms-google-genai ``` Als nächstes importieren Sie die GoogleGenAI-Klasse in `agent.py`: ```none from llama_index.llms.google_genai import GoogleGenAI ``` Nun initialisieren Sie den Gemini LLM wie folgt: ```none llm = GoogleGenAI( model="models/gemini-2.5-flash", ) ``` In diesem Beispiel verwenden wir das Modell [`gemini-2.5flash`](https://cloud.google.com/vertex-ai/generative-ai/docs/models/gemini/2-5-flash). Sie können aber auch jedes andere unterstützte Gemini-Modell wählen. Hinter den Kulissen sucht die GoogleGenAI-Klasse automatisch nach einer Umgebungsvariablen namens `GEMINI_API_KEY`. Sie verwendet den aus dieser Umgebungsvariable gelesenen API-Schlüssel, um eine Verbindung zu den Gemini-APIs herzustellen. Konfigurieren Sie es, indem Sie Ihre .env-Datei öffnen und hinzufügen: ```none GEMINI_API_KEY="" ``` Ersetzen Sie den `` Platzhalter durch Ihren tatsächlichen Gemini-API-Schlüssel. Wenn Sie noch keinen haben, können Sie ihn kostenlos erhalten, indem Sie die [offizielle Gemini-API-Abfrageanleitung](https://ai.google.dev/gemini-api/docs/api-key) befolgen. **Hinweis**: Wenn Sie einen anderen LLM-Anbieter verwenden möchten, unterstützt LlamaIndex viele Optionen. Schauen Sie einfach in die [offiziellen LlamaIndex-Dokumente für Anweisungen zur Einrichtung](https://docs.llamaindex.ai/en/stable/api_reference/llms/). Gut gemacht! Sie haben nun alle wichtigen Teile für den Aufbau eines LlamaIndex-KI-Agenten, der das Internet durchsuchen kann, beisammen. ### Schritt #6: Definieren Sie den LlamaIndex Agent Installieren Sie zunächst das [Hauptpaket von LlamaIndex](https://pypi.org/project/llama-index/): ```none pip install llama-index ``` Als nächstes importieren Sie in Ihrer agent.py-Datei die Klasse FunctionAgent: ```none from llama_index.core.agent.workflow import FunctionAgent ``` `FunctionAgent` ist ein spezialisierter LlamaIndex-KI-Agent, der mit externen Tools interagieren kann, wie z. B. dem Bright Data SERP-Tool, das Sie zuvor eingerichtet haben. Initialisieren Sie den Agenten mit Ihrem LLM und dem SERP-Tool von Bright Data wie folgt: ```none agent = FunctionAgent( tools=brightdata_serp_tools, llm=llm, verbose=True, # Useful while developing system_prompt=""" You are a helpful assistant that can retrieve SERP results in JSON format. """ ) ``` Dadurch wird ein KI-Agent erstellt, der Benutzereingaben über Ihr LLM verarbeitet und bei Bedarf die SERP-Tools von Bright Data aufrufen kann, um Websuchen in Echtzeit durchzuführen. Beachten Sie das Argument system\_prompt, das die Rolle und das Verhalten des Agenten definiert. Auch hier ist das `verbose=True-Flag` nützlich, um die internen Aktivitäten zu überprüfen. Wunderbar! Die Integration von LlamaIndex und Bright Data SERP ist abgeschlossen. Der nächste Schritt ist die Implementierung der REPL für die interaktive Nutzung. ### Schritt #7: Erstellen der REPL REPL, die Abkürzung für “[Read-Eval-Print Loop](https://realpython.com/python-repl/)“, ist ein interaktives Programmiermuster, bei dem Sie Befehle eingeben, sie auswerten lassen und die Ergebnisse sehen. In diesem Zusammenhang funktioniert die REPL wie folgt: 1. Sie beschreiben die Aufgabe, die der KI-Agent erledigen soll. 2. Der KI-Agent übernimmt die Aufgabe und führt bei Bedarf Online-Recherchen durch. 3. Sie sehen die Antwort im Terminal ausgedruckt. Diese Schleife läuft so lange, bis Sie `"exit"` eingeben. Fügen Sie in `agent.py` diese asynchrone Funktion hinzu, um die REPL-Logik zu behandeln: ```none async def main(): print("Gemini-based agent with web searching capabilities powered by Bright Data. Type 'exit' to quit.n") while True: # Read the user request for the AI agent from the CLI request = input("Request -> ") # Terminate the execution if the user type "exit" if request.strip().lower() == "exit": print("nAgent terminated") break try: # Execute the request response = await agent.run(request) print(f"nResponse ->:n{response}n") except Exception as e: print(f"nError: {str(e)}n") ``` Diese REPL-Funktion: 1. Akzeptiert Benutzereingaben von der Kommandozeile über [`input()`](https://docs.python.org/3/library/functions.html#input). 2. Verarbeitet die Eingabe mit dem LlamaIndex-Agenten, der von Gemini und Bright Data durch `agent.run()` unterstützt wird. 3. Zeigt die Antwort auf der Konsole an. Da `agent.run()` asynchron ist, muss die REPL-Logik innerhalb einer `asynchronen` Funktion stehen. Führen Sie sie wie folgt am Ende Ihrer Datei aus: ```none if __name__ == "__main__": asyncio.run(main()) ``` Vergessen Sie nicht, [`asyncio`](https://docs.python.org/3/library/asyncio.html) zu importieren: ```none import asyncio ``` Jetzt geht’s los! Der LlamaIndex AI-Agent mit SERP-Scraping-Tools ist fertig. ### Schritt Nr. 8: Alles zusammenfügen und den KI-Agenten ausführen Dies sollte Ihre `agent.py-Datei` enthalten: ```none from dotenv import load_dotenv import os from llama_index.tools.brightdata import BrightDataToolSpec from llama_index.llms.google_genai import GoogleGenAI from llama_index.core.agent.workflow import FunctionAgent import asyncio # Load environment variables from the .env file load_dotenv() # Read the Bright Data API key from the envs BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY") # Set up the Bright Data Tools brightdata_tool_spec = BrightDataToolSpec( api_key=BRIGHT_DATA_API_KEY, zone="unlocker", # Replace with the name of your Web Unlocker zone verbose=True, # Useful while developing ) # Get only the "search_engine" (SERP scraping) tool brightdata_serp_tools = brightdata_tool_spec.to_tool_list(["search_engine"]) # Configure the connection to Gemini llm = GoogleGenAI( model="models/gemini-2.5-flash", ) # Create the LlamaIndex agent powered by Gemini and connected to Bright Data tools agent = FunctionAgent( tools=brightdata_serp_tools, llm=llm, verbose=True, # Useful while developing system_prompt=""" You are a helpful assistant that can retrieve SERP results in JSON format. """ ) # Async REPL loop async def main(): print("Gemini-based agent with web searching capabilities powered by Bright Data. Type 'exit' to quit.n") while True: # Read the user request for the AI agent from the CLI request = input("Request -> ") # Terminate the execution if the user type "exit" if request.strip().lower() == "exit": print("nAgent terminated") break try: # Execute the request response = await agent.run(request) print(f"nResponse ->:n{response}n") except Exception as e: print(f"nError: {str(e)}n") if __name__ == "__main__": asyncio.run(main()) ``` Starten Sie Ihren LlamaIndex SERP-Agenten mit: ```none python agent.py ``` Wenn das Skript startet, sehen Sie eine Eingabeaufforderung wie diese in Ihrem Terminal: ![Die REPL Ihres AI SERP-Agenten wird im Terminal ausgegeben](https://media.brightdata.com/2025/07/image-7-1024x66.png)Versuchen Sie zum Beispiel, Ihren Agenten um etwas zu bitten, das neue Informationen erfordert: ```none Write a short Markdown report on the new AI protocols, including some real-world links for further reading. ``` Um diese Aufgabe effektiv zu erfüllen, muss der KI-Agent im Internet nach aktuellen Informationen suchen. Das Ergebnis wird sein: ![Wie der SERP-KI-Agent von LlamaIndex und Bright Data die Aufforderung anspricht](https://media.brightdata.com/2025/07/image-8-1024x533.png)Das ging ziemlich schnell, also lassen Sie uns aufschlüsseln, was passiert ist: 1. Der Agent erkennt die Notwendigkeit, nach “neuen KI-Protokollen” zu suchen, und ruft die SERP-API von Bright Data über das search\_engine-Tool mit dieser Eingabe-URL auf: `https://www.google.com/search?q=new%20AI%20protocols&num=10&brd_json=1.` 2. Das Tool holt asynchron SERP-Daten im JSON-Format aus der [Google Search API von Bright Data](/products/serp-api/google-search). 3. Der Agent übergibt die JSON-Antwort an den Gemini LLM. 4. Gemini verarbeitet die neuen Daten und erstellt einen klaren, präzisen Markdown-Bericht mit relevanten Links. In diesem Fall kehrte der KI-Agent zurück: ```none ## New AI Protocols: A Brief Report The rapid advancement of Artificial Intelligence has led to the emergence of new protocols designed to enhance interoperability, communication, and data handling among AI systems and with external data sources. These protocols aim to standardize how AI agents interact, leading to more scalable and integrated AI deployments. Here are some of the key new AI protocols: ### 1. Model Context Protocol (MCP) The Model Context Protocol (MCP) is an open standard that facilitates secure, two-way connections between AI-powered tools and various data sources. It fundamentally changes how AI assistants interact with the digital world by allowing them to access and utilize external information more effectively. This protocol is crucial for enabling AI models to communicate with external data sources and for building more capable and context-aware AI applications. **Further Reading:** * **Introducing the Model Context Protocol:** [https://www.anthropic.com/news/model-context-protocol](https://www.anthropic.com/news/model-context-protocol) * **How A Simple Protocol Is Changing Everything About AI:** [https://www.forbes.com/sites/craigsmith/2025/04/07/how-a-simple-protocol-is-changing-everything-about-ai/](https://www.forbes.com/sites/craigsmith/2025/04/07/how-a-simple-protocol-is-changing-everything-about-ai/) * **The New Model Context Protocol for AI Agents:** [https://evergreen.insightglobal.com/the-new-model-context-protocol-for-ai-agents/](https://evergreen.insightglobal.com/the-new-model-context-protocol-for-ai-agents/) * **Model Context Protocol: The New Standard for AI Interoperability:** [https://techstrong.ai/aiops/model-context-protocol-the-new-standard-for-ai-interoperability/](https://techstrong.ai/aiops/model-context-protocol-the-new-standard-for-ai-interoperability/) * **Hot new protocol glues together AI and apps:** [https://www.axios.com/2025/04/17/model-context-protocol-anthropic-open-source](https://www.axios.com/2025/04/17/model-context-protocol-anthropic-open-source) ### 2. Agent2Agent Protocol (A2A) The Agent2Agent Protocol (A2A) is a cross-platform specification designed to enable AI agents to communicate with each other, securely exchange information, and coordinate actions. This protocol is vital for fostering collaboration among different AI agents, allowing them to work together on complex tasks and delegate responsibilities across various enterprise systems. **Further Reading:** * **Announcing the Agent2Agent Protocol (A2A):** [https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/](https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/) * **What Every AI Engineer Should Know About A2A, MCP & ACP:** [https://medium.com/@elisowski/what-every-ai-engineer-should-know-about-a2a-mcp-acp-8335a210a742](https://medium.com/@elisowski/what-every-ai-engineer-should-know-about-a2a-mcp-acp-8335a210a742) * **What a new AI protocol means for journalists:** [https://www.dw.com/en/what-coding-agents-and-a-new-ai-protocol-mean-for-journalists/a-72976193](https://www.dw.com/en/what-coding-agents-and-a-new-ai-protocol-mean-for-journalists/a-72976193) ### 3. Agent Communication Protocol (ACP) The Agent Communication Protocol (ACP) is an open standard specifically for agent-to-agent communication. Its purpose is to transform the current landscape of siloed AI agents into interoperable agentic systems, promoting easier integration and collaboration between them. ACP provides a standardized messaging framework for structured communication. **Further Reading:** * **MCP, ACP, and Agent2Agent set standards for scalable AI:** [https://www.cio.com/article/3991302/ai-protocols-set-standards-for-scalable-results.html](https://www.cio.com/article/3991302/ai-protocols-set-standards-for-scalable-results.html) * **What is Agent Communication Protocol (ACP)?** [https://www.ibm.com/think/topics/agent-communication-protocol](https://www.ibm.com/think/topics/agent-communication-protocol) * **MCP vs A2A vs ACP: AI Protocols Explained:** [https://www.bluebash.co/blog/mcp-vs-a2a-vs-acp-agent-communication-protocols/](https://www.bluebash.co/blog/mcp-vs-a2a-vs-acp-agent-communication-protocols/) These emerging protocols are crucial steps towards a more interconnected and efficient AI ecosystem, enabling more sophisticated and collaborative AI applications across various industries. ``` Beachten Sie, dass die Antwort des KI-Agenten neue Protokolle und aktuelle Links enthält, die nach dem letzten Trainings-Update von Gemini veröffentlicht wurden. Dies unterstreicht den Wert der Integration von Live-Web-Suchfunktionen. Genauer gesagt enthält die Antwort kontextbezogene Links, die genau dem entsprechen, was man bei der Suche nach “new ai protocols” auf Google finden würde: ![Die "neuen KI-Protokolle" Google SERP](https://media.brightdata.com/2025/07/image-9-1024x535.png)Beachten Sie, dass die Antwort viele der gleichen Links enthält, die Sie in der aktuellen SERP für “neue KI-Protokolle” finden würden (zumindest zum Zeitpunkt der Erstellung dieses Artikels). Et voilà! Sie haben jetzt einen LlamaIndex-KI-Agenten mit Suchmaschinen-Scraping-Fähigkeiten, die von Bright Data unterstützt werden. ### Schritt #9: Nächste Schritte Der aktuelle LlamaIndex SERP AI Agent ist nur ein einfaches Beispiel, das nur das search\_engine Tool von Bright Data verwendet. In fortgeschrittenen Szenarien wollen Sie Ihren Agenten wahrscheinlich nicht auf ein einziges Werkzeug beschränken. Stattdessen ist es besser, Ihrem Agenten Zugang zu allen verfügbaren Werkzeugen zu geben und eine klare Systemaufforderung zu schreiben, die dem LLM hilft, zu entscheiden, welche Werkzeuge er für jedes Ziel verwenden soll. Sie könnten zum Beispiel Ihre Aufforderung erweitern, um einen Schritt weiter zu gehen und: 1. Führen Sie mehrere Suchanfragen durch. 2. Wählen Sie die obersten N Links aus den SERP-Ergebnissen aus. 3. Besuchen Sie diese Seiten und scrapen Sie deren Inhalt in Markdown. 4. Lernen Sie aus diesen Informationen, um ein reichhaltigeres, detaillierteres Ergebnis zu erzielen. Weitere Hinweise zur Integration mit allen verfügbaren Tools finden Sie in unserem Tutorial zur [Erstellung von KI-Agenten mit LlamaIndex und Bright Data](/blog/ai/build-ai-agents-with-llamaindex). ## Schlussfolgerung In diesem Artikel haben Sie gelernt, wie Sie mit LlamaIndex einen KI-Agenten erstellen, der das Web über Bright Data durchsuchen kann. Diese Integration ermöglicht es Ihrem Agenten, Suchanfragen in den wichtigsten Suchmaschinen wie Google, Bing, Yandex und vielen anderen auszuführen. Denken Sie daran, dass das hier beschriebene Beispiel nur ein Ausgangspunkt ist. Wenn Sie fortgeschrittenere Agenten entwickeln möchten, benötigen Sie robuste Tools zum Abrufen, Validieren und Umwandeln von Live-Webdaten. Genau das [bietet die KI-Infrastruktur für Agenten von Bright Data](/ai/data-for-ai-agents). Erstellen Sie ein kostenloses Bright Data-Konto und erkunden Sie noch heute unsere agentenbasierten KI-Datentools! Vertrieb kontaktierenGratis testen![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Inhaltsverzeichnis [ ](https://news.ycombinator.com/submitlink?t=Verwendung+von+LlamaIndex+und+Bright+Data+f%C3%BCr+die+Websuche&u=https://brightdata.de/blog/ai/llamaindex-serp-scraping) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Verwendung+von+LlamaIndex+und+Bright+Data+f%C3%BCr+die+Websuche&url=https://brightdata.de/blog/ai/llamaindex-serp-scraping) [ ](http://www.reddit.com/submit?title=Verwendung+von+LlamaIndex+und+Bright+Data+f%C3%BCr+die+Websuche&url=https://brightdata.de/blog/ai/llamaindex-serp-scraping) ## 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)