CrewAI-Agenten smarter: SERP-API für Live-Daten integrieren

In diesem Lernprogramm lernen Sie:

Was CrewAI ist und wie es sich von anderen KI-Agentenbibliotheken unterscheidet.
Seine größten Einschränkungen und wie man sie mit einem RAG-Workflow überwinden kann.
Wie man es mit einer Scraping-API integriert, um KI-Agenten mit SERP-Daten zu versorgen und so genauere Antworten zu erhalten.

Lasst uns eintauchen!

Was ist CrewAI?

CrewAI ist ein quelloffenes Python-Framework zur Orchestrierung und Verwaltung autonomer KI-Agenten, die zusammenarbeiten, um komplexe Aufgaben zu erledigen. Im Gegensatz zu Einzelagenten-Systemen wie Browser Use baut CrewAI auf “Crews” auf, die eine Gruppe von Agenten darstellen.

In einer Crew hat jeder Agent eine bestimmte Rolle, ein bestimmtes Ziel und eine Reihe von Tools. Im Detail können Sie KI-Agenten mit benutzerdefinierten Tools für spezielle Aufgaben wie Web-Scraping, Datenbankverbindungen und mehr ausstatten. Dieser Ansatz öffnet die Tür zu spezialisierten KI-gestützten Problemlösungen und effektiven Entscheidungen.

Die Multi-Agenten-Architektur von CrewAI fördert sowohl Effizienz als auch Skalierbarkeit. Es werden regelmäßig neue Funktionen hinzugefügt, wie z. B. Unterstützung für Qwen-Modelle und parallele Funktionsaufrufe, so dass sich das Ökosystem schnell weiterentwickelt.

Die Grenzen von CrewAI und wie man sie mit frischen Webdaten überwindet

CrewAI ist ein funktionsreicher Rahmen für den Aufbau von Multiagentensystemen. Es erbt jedoch einige wichtige Einschränkungen von den LLMs, auf die es sich stützt. Da LLMs in der Regel auf statischen Datensätzen trainiert werden, fehlt ihnen das Echtzeitbewusstsein und sie können in der Regel nicht auf die neuesten Nachrichten oder Live-Inhalte im Internet zugreifen.

Dies kann zu veralteten Antworten führen – oder schlimmer noch, zu Halluzinationen. Diese Probleme sind besonders wahrscheinlich, wenn die Agenten nicht mit aktuellen, vertrauenswürdigen Daten in einem Retrieval-Augmented Generation Setup versorgt werden.

Um diese Einschränkungen zu umgehen, sollten Sie Agenten (und damit auch deren LLMs) mit zuverlässigen externen Daten versorgen. Das Web ist die umfassendste und dynamischste verfügbare Datenquelle und damit ein ideales Ziel. Ein effektiver Ansatz besteht daher darin, CrewAI-Agenten zu ermöglichen, Live-Suchanfragen auf Plattformen wie Google oder anderen Suchmaschinen durchzuführen.

Dies kann durch den Aufbau eines benutzerdefinierten CrewAI-Tools geschehen, mit dem Agenten relevante Webseiten abrufen können, um daraus zu lernen. Das Scraping von SERPs (Search Engine Results Pages) ist jedoch eine technische Herausforderung, da JavaScript-Rendering, CAPTCHA-Lösungen, IP-Rotation und sich ständig ändernde Seitenstrukturen erforderlich sind.

All dies intern zu verwalten, kann komplexer sein als die Entwicklung der CrewAI-Logik selbst. Eine bessere Lösung ist es, sich auf erstklassige SERP-Scraping-APIs zu verlassen , wie z. B. die SERP-API von Bright Data. Diese Dienste übernehmen die schwere Aufgabe, saubere, strukturierte Daten aus dem Internet zu extrahieren.

Durch die Integration solcher APIs in Ihren CrewAI-Workflow erhalten Ihre Agenten Zugang zu aktuellen und präzisen Informationen, ohne dass der operative Overhead entsteht. Die gleiche Strategie kann auch auf andere Bereiche angewendet werden, indem Agenten mit bereichsspezifischen Scraping-APIs verbunden werden.

Integration von CrewAI mit SERP-APIs für Echtzeit-Datenzugriff

In dieser Anleitung erfahren Sie, wie Sie Ihren mit CrewAI erstellten KI-Agenten in die Lage versetzen, über die Bright Data SERP API direkt Daten von SERP-Maschinen abzurufen.

Diese RAG-Integration ermöglicht es Ihren CrewAI-Agenten, kontextbezogenere und aktuellere Ergebnisse zu liefern, komplett mit realen Links für weiterführende Informationen.

Führen Sie die folgenden Schritte aus, um mit der SERP-API-Integration von Bright Data ein schlagkräftiges Team aufzubauen!

Voraussetzungen

Um diesem Tutorial folgen zu können, müssen Sie über die entsprechenden Kenntnisse verfügen:

Ein Bright Data-API-Schlüssel.
Ein API-Schlüssel für die Verbindung zu einem LLM (in diesem Lehrgang wird Gemini verwendet).
Python 3.10 oder höher lokal installiert.

Weitere Einzelheiten finden Sie auf der Installationsseite der CrewAI-Dokumentation, die aktuelle Voraussetzungen enthält.

Machen Sie sich keine Sorgen, wenn Sie noch keinen Bright Data-API-Schlüssel haben, da Sie in den nächsten Schritten durch die Erstellung eines solchen geführt werden. Wenn Sie noch keinen LLM-API-Schlüssel haben, empfehlen wir Ihnen, einen Gemini-API-Schlüssel einzurichten, indem Sie die offizielle Anleitung von Google befolgen.

Schritt #1: CrewAI installieren

Beginnen Sie mit der globalen Installation von CrewAI, indem Sie den folgenden Befehl in Ihrem Terminal ausführen:

pip install crewai

Hinweis: Da mehrere Pakete heruntergeladen und konfiguriert werden müssen, kann dies eine Weile dauern.

Wenn bei der Installation oder Verwendung Probleme auftreten, lesen Sie bitte den Abschnitt zur Fehlerbehebung in der offiziellen Dokumentation.

Nach der Installation haben Sie Zugriff auf den CLI-Befehl crewai. Überprüfen Sie ihn, indem Sie den folgenden Befehl in Ihrem Terminal ausführen:

crewai

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Usage: crewai [OPTIONS] COMMAND [ARGS]...

  Top-level command group for crewai.

Options:
  --version  Show the version and exit.
  --help     Show this message and exit.

Commands:
  chat               Start a conversation with the Crew, collecting...
  create             Create a new crew, or flow.
  deploy             Deploy the Crew CLI group.
  flow               Flow related commands.
  install            Install the Crew.
  log-tasks-outputs  Retrieve your latest crew.kickoff() task outputs.
  login              Sign Up/Login to CrewAI+.
  replay             Replay the crew execution from a specific task.
  reset-memories     Reset the crew memories (long, short, entity,...
  run                Run the Crew.
  signup             Sign Up/Login to CrewAI+.
  test               Test the crew and evaluate the results.
  tool               Tool Repository related commands.
  train              Train the crew.
  update             Update the pyproject.toml of the Crew project to use...
  version            Show the installed version of crewai.

Großartig! Sie haben nun die CrewAI CLI bereit, um Ihr Projekt zu initialisieren.

Schritt #2: Projekt einrichten

Führen Sie den folgenden Befehl aus, um ein neues CrewAI-Projekt namens serp_agent zu erstellen:

crewai create crew serp_agent

Während der Einrichtung werden Sie aufgefordert, Ihren bevorzugten LLM-Anbieter auszuwählen:

Select a provider to set up:
1. openai
2. anthropic
3. gemini
4. nvidia_nim
5. groq
6. huggingface
7. ollama
8. watson
9. bedrock
10. azure
11. cerebras
12. sambanova
13. other
q. Quit
Enter the number of your choice or 'q' to quit:

In diesem Fall wählen wir die Option “3” für Gemini, da die Integration über die API kostenlos ist.

Wählen Sie dann das gewünschte Gemini-Modell aus:

Select a model to use for Gemini:
1. gemini/gemini-1.5-flash
2. gemini/gemini-1.5-pro
3. gemini/gemini-2.0-flash-lite-001
4. gemini/gemini-2.0-flash-001
5. gemini/gemini-2.0-flash-thinking-exp-01-21
6. gemini/gemini-2.5-flash-preview-04-17
7. gemini/gemini-2.5-pro-exp-03-25
8. gemini/gemini-gemma-2-9b-it
9. gemini/gemini-gemma-2-27b-it
10. gemini/gemma-3-1b-it
11. gemini/gemma-3-4b-it
12. gemini/gemma-3-12b-it
13. gemini/gemma-3-27b-it
q. Quit

In diesem Beispiel ist das freie Modell gemini/gemini-1.5 flash ausreichend. Sie können also die Option “1” wählen.

Anschließend werden Sie aufgefordert, Ihren Gemini-API-Schlüssel einzugeben:

Enter your GEMINI API key from https://ai.dev/apikey (press Enter to skip):

Fügen Sie sie ein, und wenn alles wie erwartet funktioniert, sollten Sie eine Ausgabe wie diese sehen:

API keys and model saved to .env file
Selected model: gemini/gemini-1.5-flash
  - Created serp_agent.gitignore
  - Created serp_agentpyproject.toml
  - Created serp_agentREADME.md
  - Created serp_agentknowledgeuser_preference.txt
  - Created serp_agentsrcserp_agent__init__.py
  - Created serp_agentsrcserp_agentmain.py
  - Created serp_agentsrcserp_agentcrew.py
  - Created serp_agentsrcserp_agenttoolscustom_tool.py
  - Created serp_agentsrcserp_agenttools__init__.py
  - Created serp_agentsrcserp_agentconfigagents.yaml
  - Created serp_agentsrcserp_agentconfigtasks.yaml
Crew serp_agent created successfully!

Dieses Verfahren erzeugt die folgende Projektstruktur:

serp_agent/
├── .gitignore
├── pyproject.toml
├── README.md
├── .env
├── knowledge/
├── tests/
└── src/
    └── serp_agent/
        ├── __init__.py
        ├── main.py
        ├── crew.py
        ├── tools/
        │   ├── custom_tool.py
        │   └── __init__.py
        └── config/
            ├── agents.yaml
            └── tasks.yaml

Hier:

main.py ist der Haupteinstiegspunkt für Ihr Projekt.
crew.py ist der Ort, an dem Sie die Logik Ihrer Mannschaft definieren.
config/agents.yaml definiert Ihre KI-Agenten.
config/tasks.yaml definiert die Aufgaben, die Ihre Agenten bearbeiten werden.
tools/custom_tool.py ermöglicht es Ihnen, benutzerdefinierte Werkzeuge hinzuzufügen, die Ihre Agenten verwenden können.
.env speichern API-Schlüssel und andere Umgebungsvariablen.

Navigieren Sie in den Projektordner und installieren Sie die CrewAI-Abhängigkeiten:

cd serp_agent
crewai install

Mit dem letzten Befehl wird ein lokaler Ordner für die virtuelle Umgebung .venv in Ihrem Projektverzeichnis erstellt. Dies ermöglicht es Ihnen, Ihre CrewAI lokal auszuführen.

Perfekt! Sie haben jetzt ein vollständig initialisiertes CrewAI-Projekt, das die Gemini-API verwendet. Sie sind bereit, Ihren intelligenten SERP-Agenten zu erstellen und auszuführen.

Schritt #3: Einstieg in die SERP API

Wie bereits erwähnt, werden wir die SERP-API von Bright Data nutzen, um Inhalte von Suchmaschinenergebnisseiten abzurufen und an unsere CrewAI-Agenten weiterzuleiten. Insbesondere werden wir genaue Google-Suchen auf der Grundlage der Benutzereingaben durchführen und die live gescrapten Daten nutzen, um die Antworten des Agenten zu verbessern.

Zur Einrichtung der SERP-API können Sie die offizielle Dokumentation zu Rate ziehen. Alternativ können Sie auch die folgenden Schritte ausführen.

Wenn Sie dies noch nicht getan haben, melden Sie sich für ein Konto bei Bright Data an. Andernfalls melden Sie sich einfach an. Wenn Sie angemeldet sind, gehen Sie zum Abschnitt “Meine Zonen” und klicken Sie auf die Zeile “SERP API”:

Wenn Sie diese Zeile in der Tabelle nicht sehen, bedeutet dies, dass Sie noch keine SERP-API-Zone konfiguriert haben. Scrollen Sie in diesem Fall nach unten und klicken Sie auf “Zone erstellen” unter dem Abschnitt “SERP API”:

Schalten Sie auf der SERP API-Produktseite den Schalter “Aktivieren” um, um das Produkt zu aktivieren:

Folgen Sie anschließend der offiziellen Anleitung, um Ihren Bright Data-API-Schlüssel zu generieren. Fügen Sie ihn dann wie unten beschrieben zu Ihrer .env-Datei hinzu:

BRIGHT_DATA_API_KEY=<YOUR_BRIGHT_DATA_API_KEY>

Ersetzen Sie den Platzhalter durch den tatsächlichen Wert Ihres Bright Data-API-Schlüssels.

Das ist es! Sie können jetzt die SERP-API von Bright Data in Ihrer CrewAI-Integration verwenden.

Schritt #4: Erstellen eines CrewAI SERP-Suchwerkzeugs

Es ist an der Zeit, ein SERP-Suchtool zu definieren, mit dem Ihre Agenten mit der Bright Data-SERP-API interagieren und Suchergebnisdaten abrufen können.

Öffnen Sie dazu die Datei custom_tool.py im Ordner tools/ und ersetzen Sie ihren Inhalt durch den folgenden Text:

# src/search_agent/tools/custom_tool.py

import os
import json
from typing import Type
import requests
from pydantic import BaseModel, PrivateAttr
from crewai.tools import BaseTool


class SerpSearchToolInput(BaseModel):
    query: str


class SerpSearchTool(BaseTool):
    _api_key: str = PrivateAttr()

    name: str = "Bright Data SERP Search Tool"
    description: str = """
    Uses Bright Data's SERP API to retrieve real-time Google search results based on the user's query.
    This tool fetches organic search listings to support agent responses with live data.
    """
    args_schema: Type[BaseModel] = SerpSearchToolInput

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        # Read the Bright Data API key from the envs
        self._api_key = os.environ.get("BRIGHT_DATA_API_KEY")

        if not self._api_key:
            raise ValueError("Missing Bright Data API key. Please set BRIGHT_DATA_API_KEY in your .env file")

    def _run(self, query: str) -> str:
        url = "https://api.brightdata.com/request"
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self._api_key}"
        }
        payload = {
            "zone": "serp", # Replace with the name of your actual Bright Data SERP API zone
            "format": "json",
            "url": f"https://www.google.com/search?q={query}&brd_json=1"
        }

        try:
            response = requests.post(url, json=payload, headers=headers)
            # Raise exceptions in case of errors
            response.raise_for_status()

            # Parse the JSON response
            json_response = response.json()
            response_body = json.loads(json_response.get("body", "{}"))

            if "organic" not in response_body:
                return "The response did not include organic search results."

            # Return the SERP data as a JSON string
            return json.dumps(response_body["organic"], indent=4)

        except requests.exceptions.HTTPError as http_err:
            return f"HTTP error occurred while querying Bright Data SERP API: {http_err}"
        except requests.exceptions.RequestException as req_err:
            return f"Network error occurred while connecting to Bright Data: {req_err}"
        except (json.JSONDecodeError, KeyError) as parse_err:
            return f"Error parsing Bright Data SERP API response: {parse_err}"

Dieses CrewAI-Tool definiert eine Funktion, die eine Benutzeranfrage annimmt und SERP-Ergebnisse von der Bright Data SERP API über Requets abruft.

Wenn der Abfrageparameter brd_json=1 verwendet wird und das Format auf json eingestellt ist, antwortet die SERP-API mit dieser Struktur:

{
  "status_code": 200,
  "headers": {
    "content-type": "application/json",
    // omitted for brevity...
  },
  "body": "{"general":{"search_engine":"google","query":"pizza","results_cnt":1980000000, ...}}"
}

Insbesondere erhalten Sie nach dem Parsen des Feldes body, das eine JSON-Zeichenkette enthält, die folgende Datenstruktur:

{
  "general": {
    "search_engine": "google",
    "query": "pizza",
    "results_cnt": 1980000000,
    "search_time": 0.57,
    "language": "en",
    "mobile": false,
    "basic_view": false,
    "search_type": "text",
    "page_title": "pizza - Google Search",
    "timestamp": "2023-06-30T08:58:41.786Z"
  },
  "input": {
    "original_url": "https://www.google.com/search?q=pizza&brd_json=1",
    "request_id": "hl_1a1be908_i00lwqqxt1"
  },
  "organic": [
    {
      "link": "https://www.pizzahut.com/",
      "display_link": "https://www.pizzahut.com",
      "title": "Pizza Hut | Delivery & Carryout - No One OutPizzas The Hut!",
      "rank": 1,
      "global_rank": 1
    },
    {
      "link": "https://www.dominos.com/en/",
      "display_link": "https://www.dominos.com",
      "title": "Domino's: Pizza Delivery & Carryout, Pasta, Chicken & More",
      "description": "Order pizza, pasta, sandwiches & more online...",
      "rank": 2,
      "global_rank": 3
    },
    // ...additional organic results omitted for brevity
  ]
}

Sie sind also hauptsächlich an dem organischen Feld interessiert. Das ist das Feld, auf das im Code zugegriffen wird, das in einen JSON-String geparst und dann vom Tool zurückgegeben wird.

Wahnsinn! Ihr CrewAI-Agent kann nun dieses Tool nutzen, um frische SERP-Daten abzurufen.

Schritt Nr. 5: Definieren Sie die Agenten

Um diese Aufgabe zu erfüllen, benötigen Sie zwei CrewAI Agenten, die jeweils einen bestimmten Zweck erfüllen:

Rechercheur: Sammelt Suchergebnisse von Google und filtert nützliche Erkenntnisse.
Berichterstattender Analyst: Er fasst die Ergebnisse in einer strukturierten und lesbaren Zusammenfassung zusammen.

Sie können sie in Ihrer agents.yml-Datei definieren, indem Sie sie wie folgt ausfüllen:

# src/search_agent/configs/agents.yml

researcher:
  role: >
    Online Research Specialist
  goal: >
    Conduct smart Google searches and collect relevant, trustworthy details from the top results.
  backstory: >
    You have a knack for phrasing search queries that deliver the most accurate and insightful content.
    Your expertise lies in quickly identifying high-quality information from reputable sources.

reporting_analyst:
  role: >
    Strategic Report Creator
  goal: >
    Organize collected data into a clear, informative narrative that’s easy to understand and act on.
  backstory: >
    You excel at digesting raw information and turning it into meaningful analysis. Your work helps
    teams make sense of data by presenting it in a well-structured and strategic format.

Beachten Sie, dass diese Konfiguration festhält, was jeder Agent tun soll – nicht mehr und nicht weniger. Definieren Sie einfach ihre Rolle, ihr Ziel und ihre Hintergrundgeschichte. Sehr gut!

Schritt Nr. 6: Legen Sie die Aufgaben für jeden Agenten fest

Machen Sie sich bereit, spezifische Aufgaben zu definieren, die die Rolle jedes Agenten innerhalb des Workflows klar umreißen. Laut der CrewAI-Dokumentationist die Aufgabendefinition wichtiger als die Agentendefinition, um genaue Ergebnisse zu erzielen.

Daher müssen Sie Ihren Agenten in der tasks.yml genau sagen, was sie zu tun haben (siehe unten):

# src/search_agent/configs/tasks.yml

research_task:
  description: >
    Leverage SerpSearchTool to perform a targeted search based on the user's {query}.
    Build API parameters like:
    - 'query': develop a short, Google-like, keyword-optimized search phrase for search engines.
    From the returned data, identify the most relevant and factual content.

  expected_output: >
    A file containing well-structured raw JSON content with the data from search results.
    Avoid rewriting, summarizing, or modifying any content.

  agent: researcher
  output_file: output/serp_data.json

report_task:
  description: >
    Turn the collected data into a digestible, insight-rich report.
    Address the user's {query} with fact-based findings. Add links for further reading. Do not fabricate or guess any information.

  expected_output: >
    A Markdown report with key takeaways and meaningful insights.
    Keep the content brief and clearly, visually structured.

  agent: reporting_analyst
  context: [research_task]
  output_file: output/report.md

In diesem Fall definieren Sie zwei Aufgaben – eine für jeden Bearbeiter:

research_task: Erklärt dem Forscher, wie er die Bright Data SERP API über das Tool verwenden kann, einschließlich der dynamischen Erstellung von API-Parametern auf der Grundlage der Abfrage.
report_task: Gibt an, dass die endgültige Ausgabe ein lesbarer, informativer Bericht sein soll, der ausschließlich aus den gesammelten Daten erstellt wird.

Diese tasks.yml-Definition ist alles, was Ihre CrewAI-Agenten brauchen, um SERP-Daten zu sammeln und einen Bericht zu erstellen, der auf echten Suchergebnissen basiert.

Zeit, die CrewAI-Agenten in Ihren Code zu integrieren und sie an die Arbeit zu lassen!

Schritt #7: Erstellen Sie Ihre Crew

Nun, da alle Komponenten vorhanden sind, verbinden Sie alles in der Datei crew.py, um eine voll funktionsfähige Crew zu erstellen. Konkret können Sie Ihre crew.py so definieren:

# src/search_agent/crew.py

from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from .tools.custom_tool import SerpSearchTool
from crewai.agents.agent_builder.base_agent import BaseAgent
from typing import List

@CrewBase
class SerpAgent():
    """SerpAgent crew"""

    agents: List[BaseAgent]
    tasks: List[Task]

    @agent
    def researcher(self) -> Agent:
        return Agent(
            config=self.agents_config["researcher"],
            tools=[SerpSearchTool()],
            verbose=True
        )

    @agent
    def reporting_analyst(self) -> Agent:
        return Agent(
            config=self.agents_config["reporting_analyst"],
            verbose=True
        )

    @task
    def research_task(self) -> Task:
        return Task(
            config=self.tasks_config["research_task"],
            output_file="output/serp_data.json"
        )

    @task
    def report_task(self) -> Task:
        return Task(
            config=self.tasks_config["report_task"],
            output_file="output/report.md"
        )

    @crew
    def crew(self) -> Crew:
        """Creates the SerpAgent crew"""
        return Crew(
            agents=self.agents,
            tasks=self.tasks,
            process=Process.sequential,
            verbose=True,
        )

In crew.py müssen Sie die CrewAI-Dekoratoren(@agent, @task, @crew, in diesem Fall) verwenden, um die Logik aus Ihren YAML-Dateien zu verknüpfen und die eigentliche Funktionalität zu verdrahten.

In diesem Beispiel:

Der Researcher-Agent erhält Zugriff auf das SerpSearchTool, mit dem er echte Google-Suchanfragen über die SERP-API von Bright Data durchführen kann.
Der Agent reporting_analyst ist so konfiguriert, dass er den Abschlussbericht unter Verwendung der Ergebnisse des Rechercheurs erstellt.
Jede Aufgabe entspricht dem, was in Ihrer tasks.yml definiert wurde, und ist explizit mit der entsprechenden Ausgabedatei verknüpft.
Der Prozess ist auf sequentiell eingestellt, so dass researcher zuerst läuft und dann seine Daten an reporting_analyst weitergibt.

Los geht’s! Ihre SerpAgent-Crew ist jetzt bereit für die Ausführung.

Schritt Nr. 8: Erstellen der Hauptschleife

In main.py lösen Sie die Crew aus, indem Sie die Abfrage des Benutzers als Eingabe übergeben:

# src/search_crew/main.py

import os
from serp_agent.crew import SerpAgent

# Create the output/ folder if it doesn"t already exist
os.makedirs("output", exist_ok=True)

def run():
    try:
        # Read the user's input and pass it to the crew
        inputs = {"query": input("nSearch for: ").strip()}

        # Start the SERP agent crew
        result = SerpAgent().crew().kickoff(
            inputs=inputs
        )
        return result
    except Exception as e:
        print(f"An error occurred: {str(e)}")

if __name__ == "__main__":
    run()

Auftrag erfüllt! Ihre CrewAI + SERP-API-Integration (mit Gemini als LLM) ist jetzt voll funktionsfähig. Führen Sie einfach main.py aus, geben Sie eine Suchanfrage ein und beobachten Sie, wie die CrewAI SERP-Daten sammelt und analysiert, um einen Bericht zu erstellen.

Schritt #9: Führen Sie Ihren AI-Agenten aus

Führen Sie in Ihrem Projektordner Ihre CrewAI-Anwendung mit dem folgenden Befehl aus:

crewai run

Geben Sie nun eine Abfrage ein wie z. B.:

"What are the new AI protocols?"

Dies ist die Art von Frage, die ein typischer LLM nur schwer genau beantworten kann. Der Grund dafür ist, dass die meisten der neuesten KI-Protokolle, wie CMP, A2A, AGP und ACP, noch nicht existierten, als das Modell ursprünglich trainiert wurde.

Im Folgenden erfahren Sie, was im Einzelnen geschehen wird:

Wie Sie oben sehen können, behandelt CrewAI die Anfrage auf diese Weise:

Das Forschungsmittel wird ausgeführt, das:
1. Wandelt die Benutzereingabe in eine strukturierte Abfrage "neue KI-Protokolle" um
2. Sendet die Abfrage über das SerpSearchTool an die SERP-API von Bright Data.
3. Empfängt die Ergebnisse von der API und speichert sie in der Datei output/serp_data.json.
Dann wird der Agent reporting_analyst ausgelöst, der:
1. Liest die strukturierten Daten aus der Datei serp_data.json.
2. Verwendet diese neuen Informationen, um einen kontextbezogenen Bericht in Markdown zu erstellen.
3. Speichert den endgültigen strukturierten Bericht in output/report.md.

Wenn Sie report.md mit einem Markdown-Viewer öffnen, sehen Sie etwa so aus:

Der von CrewAI erstellte endgültige Markdown-Bericht

Der Bericht enthält relevante kontextbezogene Informationen und sogar Links, die Ihnen helfen, tiefer einzutauchen.

Et voilà! Sie haben gerade einen RAG-Workflow in CrewAI implementiert, der durch die Integration mit einer SERP-API unterstützt wird.

Nächste Schritte

Mit dem in die Crew integrierten SERP-API-Tool von Bright Data können Agenten frische Suchmaschinenergebnisse erhalten. Mit den URLs dieser SERPs können Sie andere Scraping-APIs aufrufen, um Rohinhalte aus den verlinkten Seiten zu extrahieren – entweder in unverarbeiteter Form(um sie in Markdown zu konvertieren und an den Agenten zu übermitteln) oder bereits in JSON geparst.

Diese Idee ermöglicht es den Agenten, automatisch einige zuverlässige Quellen zu finden und aktuelle Informationen von ihnen abzurufen. Darüber hinaus könnten Sie eine Lösung wie Agent Browser integrieren, die es den Agenten ermöglicht, dynamisch mit jeder Live-Webseite zu interagieren.

Dies sind nur einige Beispiele, aber die möglichen Szenarien und Anwendungsfälle sind praktisch unbegrenzt.

Schlussfolgerung

In diesem Blogbeitrag haben Sie erfahren, wie Sie Ihre CrewAI-Agenten durch die Integration eines RAG-Setups mit der SERP-API von Bright Data kontextbezogener machen können.

Wie bereits erläutert, ist dies nur eine von vielen Möglichkeiten, die Sie durch die Verbindung Ihrer Agenten mit externen Scraping-APIs oder Automatisierungstools erkunden können. Insbesondere die Lösungen von Bright Data können als leistungsstarke Bausteine für intelligente KI-Workflows dienen.

Optimieren Sie Ihre KI-Infrastruktur mit den Tools von Bright Data:

Autonome KI-Agenten: Suche, Zugriff und Interaktion mit jeder Website in Echtzeit über eine Reihe leistungsstarker APIs.
Vertikale KI-Anwendungen: Erstellen Sie zuverlässige, benutzerdefinierte Datenpipelines zur Extraktion von Webdaten aus branchenspezifischen Quellen.
Grundlegende Modelle: Greifen Sie auf konforme, webbasierte Datensätze zu, um Pre-Training, Bewertung und Feinabstimmung zu unterstützen.
Multimodale KI: Nutzen Sie den weltweit größten Bestand an Bildern, Videos und Audiodateien, die für KI optimiert sind.
Datenanbieter: Verbinden Sie sich mit vertrauenswürdigen Anbietern, um hochwertige, KI-fähige Datensätze in großem Umfang zu beziehen.
Datenpakete: Erhalten Sie kuratierte, gebrauchsfertige, strukturierte, angereicherte und kommentierte Datensätze.

Weitere Informationen finden Sie in unserem KI-Hub.

Erstellen Sie ein Bright Data-Konto und testen Sie alle unsere Produkte und Services für die Entwicklung von KI-Agenten!

Verbesserung der CrewAI-Agenten durch SERP Scraping APIs über RAG