Integration von Google ADK mit einem MCP-Server für die Entwicklung von KI-Agenten

In diesem Leitfaden werden Sie sehen:

• Was die Google ADK-Bibliothek zur Erstellung von KI-Agenten ist.
• Warum die native Unterstützung für MCP das Besondere ist.
• Integration mit dem Bright Data MCP-Server zum Aufbau eines extrem leistungsfähigen KI-Agenten

Lasst uns eintauchen!

Was ist Google ADK?

Google ADK, kurz für Google Agent Development Kit, ist ein Open-Source-Python-Framework für die Entwicklung und den Einsatz von KI-Agenten. Obwohl es für Gemini und das breitere Google-Ökosystem optimiert ist, bleibt es modell- und einsatzunabhängig.

ADK legt den Schwerpunkt auf die Erfahrung der Entwickler und bietet Werkzeuge und Datenstrukturen, die den Aufbau leistungsstarker Multiagentensysteme erleichtern. Es ermöglicht Ihnen, KI-Agenten zu definieren, die mit Hilfe von Tools und Integrationen logisch denken, zusammenarbeiten und mit der Welt interagieren können.

Das ultimative Ziel von Google ADK ist es, dass sich die Entwicklung von Agenten mehr wie die traditionelle Softwareentwicklung anfühlt. Dies wird durch die Vereinfachung des Prozesses der Erstellung, Bereitstellung und Orchestrierung von Agentenarchitekturen erreicht.

Was Google ADK besonders macht

Im Vergleich zu anderen Bibliotheken zur Erstellung von KI-Agenten zeichnet sich Google ADK durch die integrierte Unterstützung für MCP (Managed Connectivity Platform) aus. MCP ist ein standardisierter Weg für KI-Modelle, mit externen Tools und Datenquellen wie APIs, Datenbanken und Dateisystemen zu interagieren, falls Sie damit nicht vertraut sind.

Einfacher ausgedrückt: MCP ermöglicht es Ihrem Google ADK-Agenten, die Fähigkeiten eines beliebigen MCP-kompatiblen Servers zu nutzen. Betrachten Sie es als eine Plug-and-Play-Integration, die Ihren KI-Agenten über die Beschränkungen des zugrunde liegenden LLM hinaus erweitert, indem sie ihm Zugang zu realen Daten und Aktionen gibt.

Diese Option bietet eine strukturierte, sichere und skalierbare Möglichkeit, Ihren Agenten mit externen Funktionen zu verbinden, ohne dass Sie diese Verbindungen von Grund auf neu aufbauen müssen. Die MCP-Integration wird besonders überzeugend, wenn sie mit einem umfangreichen MCP-Server wie dem Bright Data MCP-Server integriert wird.

Dieser MCP-Server läuft über Node.js und ist nahtlos mit allen leistungsstarken KI-Datenabfragetools von Bright Data verbunden. Mit diesen Tools kann Ihr Agent mit Live-Webdaten, strukturierten Datensätzen und Scraping-Funktionen interagieren.

Zum jetzigen Zeitpunkt werden folgende MCP-Tools unterstützt

Eine weitere Integrationsmöglichkeit finden Sie in unserem Artikel über Web Scraping mit Hilfe der MCP-Server.

Hinweis: Der Bright Data MCP-Server wird regelmäßig um neue Tools erweitert, so dass er mit der Zeit immer leistungsfähiger und funktionsreicher wird.

Sehen Sie, wie Sie mit Google ADK die Vorteile dieser Tools nutzen können!

So integrieren Sie Google ADK mit dem Bright Data MCP-Server

In diesem Tutorial lernen Sie, wie Sie mit Google ADK einen leistungsstarken KI-Agenten erstellen. Dieser wird mit Live-Scraping-, Datenabruf- und Transformationsfunktionen ausgestattet, die vom Bright Data MCP-Server bereitgestellt werden.

Dieses Setup wurde ursprünglich von Meir Kadosh implementiert. Schauen Sie sich also unbedingt sein GitHub-Repository im Original an.

Der KI-Agent wird insbesondere in der Lage sein:

1. Abrufen von URLs aus Suchmaschinen.
2. Scrapen Sie Text von diesen Webseiten.
3. Generierung von quellenbasierten Antworten unter Verwendung der extrahierten Daten.

Hinweis: Durch Ändern der Eingabeaufforderungen im Code können Sie den KI-Agenten problemlos an jedes andere Szenario oder jeden anderen Anwendungsfall anpassen.

Führen Sie die folgenden Schritte aus, um Ihren Bright Data MCP-gestützten Google ADK-Agenten in Python zu erstellen!

Voraussetzungen

Für dieses Tutorial benötigen Sie:

• Python 3.9 oder höher lokal installiert.
• Node.js lokal installiert.
• Ein UNIX-basiertes System, wie Linux oder macOS, oder das WSL(Windows Subsystem für Linux).

Hinweis: Die Integration von Google ADK mit dem Bright Data MCP-Server funktioniert derzeit nicht nativ unter Windows. Der Versuch, sie auszuführen, kann in diesem Codeabschnitt einen NotImplementedError auslösen:

transport = await self._make_subprocess_transport(
                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        protocol, popen_args, False, stdin, stdout, stderr,
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        bufsize, **kwargs)
        ^^^^^^^^^^^^^^^^^^
    raise NotImplementedError

Aus diesem Grund geht das Tutorial davon aus, dass Sie Linux, macOS oder die WSL verwenden.

Sie benötigen außerdem:

• Ein Bright Data-Konto
• Ein Gemini-API-Schlüssel

In diesem Lernprogramm werden Sie bei Bedarf sowohl die Gemini- als auch die Bright Data-Anmeldedaten einrichten. Machen Sie sich also im Moment keine Gedanken darüber.

Die folgenden Angaben sind zwar nicht erforderlich, helfen Ihnen aber, den größtmöglichen Nutzen aus diesem Lernprogramm zu ziehen:

• Eine allgemeine Vorstellung davon, wie der MCP funktioniert.
• Ein grundlegendes Verständnis der Funktionsweise des Google ADK.
• Vertrautheit mit dem Bright Data MCP-Server und seinen verfügbaren Tools.
• Einige Erfahrung mit asynchroner Programmierung in Python.

Schritt 1: Projekt einrichten

Öffnen Sie Ihr Terminal und erstellen Sie einen neuen Ordner für Ihren Scraping-Agent:

mkdir google_adk_mcp_agent

Der Ordner google_adk_mcp_agent enthält den gesamten Code für Ihren Python-KI-Agenten.

Navigieren Sie dann in den Projektordner und erstellen Sie darin eine virtuelle Umgebung:

cd google_adk_mcp_agent
python3 -m venv .venv

Öffnen Sie den Projektordner in Ihrer bevorzugten Python-IDE. Wir empfehlen die Verwendung von Visual Studio Code mit der Python-Erweiterung oder PyCharm Community Edition.

Erstellen Sie innerhalb von google_adk_mcp_agent einen Unterordner namens web_search_agent. Dieser Unterordner enthält die Kernlogik Ihres Agenten und sollte die folgenden zwei Dateien enthalten:

• __init__.py: Exportiert die Logik aus agent.py.
• agent.py: Enthält die Definition des Google ADK-Agenten.

Dies ist die Ordnerstruktur, die erforderlich ist, damit die Google ADK-Bibliothek ordnungsgemäß funktioniert:

Nun initialisieren Sie die Datei __init__.py mit der folgenden Zeile:

from . import agent

Stattdessen wird agent.py demnächst mit der Agentenlogik des Agenten AI definiert werden.

Aktivieren Sie im Terminal der IDE die virtuelle Umgebung. Unter Linux oder macOS führen Sie diesen Befehl aus:

./.venv/bin/activate

Starten Sie unter Windows die entsprechende Funktion:

.venv/Scripts/activate

Sie sind bereit! Sie verfügen nun über eine Python-Umgebung zum Erstellen eines KI-Agenten mit dem Google ADK und dem Bright Data MCP-Server.

Schritt #2: Einrichten von Umgebungsvariablen Lesen

Ihr Projekt wird mit Drittanbieterdiensten wie Gemini und Bright Data interagieren. Anstatt API-Schlüssel und Authentifizierungsgeheimnisse direkt in Ihrem Python-Code zu kodieren, sollten Sie sie aus Umgebungsvariablen laden.

Um diese Aufgabe zu vereinfachen, werden wir die python-dotenv-Bibliothek verwenden. Wenn Ihre virtuelle Umgebung aktiviert ist, installieren Sie sie, indem Sie sie ausführen:

pip install python-dotenv

Importieren Sie in Ihrer agent.py-Datei die Bibliothek und laden Sie die Umgebungsvariablen mit load_dotenv():

from dotenv import load_dotenv

load_dotenv()

Dies ermöglicht es Ihnen, Variablen aus einer lokalen .env-Datei zu lesen. Fügen Sie also eine .env-Datei zu Ihrem verschachtelten Agentenverzeichnis hinzu:

Mit dieser Codezeile können Sie nun Umgebungsvariablen in Ihrem Code lesen:

env_value = os.getenv("<ENV_NAME>")

Vergessen Sie nicht, das Modul os aus der Python-Standardbibliothek zu importieren:

import os

Großartig! Sie sind nun bereit, die Geheimnisse der env für die sichere Integration von Diensten Dritter zu lesen.

Schritt #3: Starten Sie mit Google ADK

Installieren Sie in Ihrer aktivierten virtuellen Umgebung die Google ADK Python-Bibliothek, indem Sie sie ausführen:

pip install google-adk

Öffnen Sie dann agent.py und fügen Sie die folgenden Importe hinzu:

from google.adk.agents import Agent, SequentialAgent
from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset, StdioServerParameters

Diese werden in den nächsten Schritten für die Google ADK-Integration verwendet.

Denken Sie daran, dass Google ADK die Integration mit einem KI-Anbieter erfordert. Hier werden wir Gemini verwenden, da die Bibliothek für Googles KI-Modelle optimiert ist.

Wenn Sie Ihren API-Schlüssel noch nicht erhalten haben, folgen Sie der offiziellen Dokumentation von Google. Melden Sie sich bei Ihrem Google-Konto an und rufen Sie Google AI Studio auf. Navigieren Sie dann zum Abschnitt“API-Schlüssel abrufen“, und Sie werden dieses Modal sehen:

Klicken Sie auf die Schaltfläche “API-Schlüssel abrufen”. Im nächsten Bildschirm klicken Sie auf die Schaltfläche “API-Schlüssel erstellen”:

Nach der Generierung wird Ihnen Ihr Schlüssel in einem Modal angezeigt:

Kopieren Sie den Schlüssel und bewahren Sie ihn an einem sicheren Ort auf. Beachten Sie, dass Sie mit demselben Schlüssel auch Web Scraping mit Gemini durchführen können.

Hinweis: Die kostenlose Gemini-Stufe ist für dieses Lernprogramm ausreichend. Die kostenpflichtige Stufe ist nur erforderlich, wenn Sie höhere Ratenlimits benötigen oder nicht möchten, dass Ihre Eingabeaufforderungen und Antworten zur Verbesserung von Google-Produkten verwendet werden. Weitere Informationen finden Sie auf der Gemini-Abrechnungsseite.

Initialisieren Sie nun Ihre .env-Datei mit den folgenden Umgebungsvariablen:

GOOGLE_GENAI_USE_VERTEXAI="False"
GOOGLE_API_KEY="<YOUR_GEMINI_API_KEY>"

Ersetzen Sie durch den aktuellen Schlüssel, den Sie gerade erzeugt haben. Es ist kein zusätzlicher Code in agent.py erforderlich, da die google-adk-Bibliothek automatisch nach der Umgebungsvariablen GOOGLE_API_KEY sucht.

In ähnlicher Weise bestimmt die Einstellung GOOGLE_GENAI_USE_VERTEXAI, ob Google ADK mit Vertex AI integriert werden soll. Setzen Sie sie auf "False", um stattdessen direkt die Gemini-API zu verwenden.

Erstaunlich! Sie können jetzt Gemini in Google ADK verwenden. Fahren wir mit der Ersteinrichtung der für die Integration erforderlichen Drittanbieterlösung fort.

Schritt Nr. 4: Einrichten des Bright Data MCP-Servers

Falls Sie dies noch nicht getan haben, [erstellen Sie ein Bright Data-Konto](). Wenn Sie bereits eines haben, melden Sie sich einfach an.

Folgen Sie dann den offiziellen Anweisungen:

1. Rufen Sie Ihr Bright Data-API-Token ab.
2. Konfigurieren Sie Web Unlocker und Scraping Browser für die MCP-Integration.

Sie werden am Ende mit:

• Ein Bright Data-API-Token.
• Eine Web Unlocker-Zone (wir nehmen hier an, dass diese den Standardnamen mcp_unlocker trägt).
• Scraping Browser-Authentifizierungsdaten im Format: <BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>.

Jetzt können Sie den Bright Data MCP-Server global in Ihrer Node.js-Umgebung mit installieren:

npm install -g @brightdata/mcp

Dann starten Sie den MCP-Server über das npm-Paket @brightdata/mcp mit:

API_TOKEN="<YOUR_BRIGHT_DATA_API_TOKEN>" \
BROWSER_AUTH="<BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>" \
npx -y @brightdata/mcp

Der obige Befehl setzt die erforderlichen Umgebungsvariablen(API_TOKEN und BROWSER_AUTH) und startet den MCP-Server lokal. Wenn alles korrekt eingerichtet ist, sollten Sie eine Ausgabe sehen, die anzeigt, dass der Server erfolgreich läuft:

Checking for required zones...
Required zone "mcp_unlocker" already exists
Starting server...

Großartig! Der Bright Data MCP-Server funktioniert wie ein Zauber.

Fügen Sie diese Umgebungsvariablen zu Ihrer .env-Datei im Stammverzeichnis Ihres Google ADK-Projekts hinzu:

BRIGHT_DATA_API_TOKEN="<YOUR_BRIGHT_DATA_API_TOKEN>"
BRIGHT_DATA_BROWSER_AUTH="<BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>"

Ersetzen Sie die Platzhalter durch die tatsächlichen Werte.

Als nächstes lesen Sie diese envs in Ihrem Code mit:

BRIGHT_DATA_API_TOKEN = os.getenv("BRIGHT_DATA_API_TOKEN")
BRIGHT_DATA_BROWSER_AUTH = os.getenv("BRIGHT_DATA_BROWSER_AUTH")

Perfekt! Sie haben nun alles für die Integration des Bright Data MCP-Servers mit Google ADK vorbereitet. Aber zuerst müssen Sie die KI-Agenten definieren.

Schritt Nr. 5: Definieren Sie die Agenten

Wie bereits in der Einleitung erwähnt, fungiert der MCP-gestützte Google ADK-Agent als Agent für die Zusammenfassung von Inhalten. Sein primäres Ziel ist es, die Eingaben eines Nutzers entgegenzunehmen und eine hochwertige, gut recherchierte Zusammenfassung zu liefern.

Im Einzelnen wird der Bearbeiter diesen Arbeitsablauf befolgen:

1. Interpretieren Sie die Anfrage des Nutzers und schlüsseln Sie sie in Google-ähnliche Suchanfragen auf.
2. Verarbeiten Sie die Suchanfragen mit einem Unteragenten, der

   :Polylang-Platzhalter nicht verändert

3. Generieren Sie einen Markdown-Bericht als Antwort auf die ursprüngliche Anfrage des Benutzers. Der Prozess verwendet den frisch gesammelten Inhalt als Quelle und enthält Links für weitere Lektüre.

Da der Prozess naturgemäß in drei verschiedene Phasen unterteilt ist, ist es sinnvoll, den KI-Agenten der obersten Ebene in drei Unteragenten aufzuteilen:

• Planer: Konvertiert komplexe Themen in wohlgeformte Suchanfragen.
• Rechercheur: Führt die Suchvorgänge aus und extrahiert aussagekräftige Informationen aus den resultierenden Webseiten.
• Herausgeber: Fasst die Forschungsergebnisse in einem gut geschriebenen und strukturierten Dokument zusammen.

Implementieren Sie diese drei Agenten in Google ADK mit Hilfe des folgenden Python-Codes:

• Planer:

def create_planner_agent():
    return Agent(
        name="planner",
        model="gemini-2.0-flash",
        description="Breaks down user input into focused search queries for research purposes.",
        instruction="""
        You are a research planning assistant. Your task is to:
        1. Analyze the user's input topic or question.
        2. Break it down into 3 to 5 focused and diverse search engine-like queries that collectively cover the topic.
        3. Return your output as a JSON object in the following format:

        {
            "queries": ["query1", "query2", "query3"]
        }

        IMPORTANT:
        - The queries should be phrased as if typed into a search engine.
        """,
        output_key="search_queries"
    )

• Forscherin:

def create_researcher_agent(mcp_tools):
    return Agent(
        name="researcher",
        model="gemini-2.0-flash",
        description="Performs web searches and extracts key insights from web pages using the configured tools.",
        instruction="""
        You are a web research agent. Your task is to:
        1. Receive a list of search queries from the planner agent.
        2. For each search query, apply the `search_engine` tool to get Google search results.
        3. From the global results, select the top 3 most relevant URLs.
        4. Pass each URL to the `scraping_browser_navigate` tool.
        5. From each page, use the `scraping_browser_get_text` tool to extract the main page content.
        6. Analyze the extracted text and summarize the key insights in the following JSON format:
        [
            {
                "url": "https://example.com",
                "insights": [
                    "Main insight one",
                    "Main insight two"
                ]
            },
            ...
        ]

        IMPORTANT:
        - You are only allowed to use the following tools: `search_engine`, `scraping_browser_navigate`, and `scraping_browser_get_text`.
        """,
        tools=mcp_tools
    )

Hinweis: Das Eingabeargument mcp_tools ist eine Liste, die angibt, mit welchen MCP-Tools der Agent interagieren kann. Im nächsten Schritt erfahren Sie, wie Sie diese Liste mit den vom Bright Data-MCP-Server bereitgestellten Tools auffüllen können.

• Herausgeber:
  “`python
  def create_publisher_agent():
  return Agent(
  name=”verleger”,
  model=”gemini-2.0-flash”,
  description=”Synthetisiert Forschungsergebnisse in ein umfassendes, gut strukturiertes Enddokument.”,
  instruction=”””
  Sie sind ein Experte im Schreiben. Ihre Aufgabe ist es, aus den strukturierten Forschungsergebnissen des Scraper Agent einen klaren, aufschlussreichen und gut organisierten Bericht zu verfassen. RICHTLINIEN: - Verwenden Sie eine korrekte Markdown-ähnliche Struktur: Titel (#), Untertitel, Einleitung, Kapitel (##), Unterkapitel (###) und Schlussfolgerung (##). - Integrieren Sie kontextbezogene Links (wo nötig) unter Verwendung der URLs aus der Ausgabe des Rechercheurs. - Behalten Sie einen professionellen, objektiven und informativen Ton bei. - Geben Sie nicht nur die Ergebnisse wieder, sondern fassen Sie die Informationen zusammen, verknüpfen Sie Ideen und präsentieren Sie sie als kohärente Erzählung. """ )

Note that each AI agent prompt corresponds to one specific step in the overall 3-step workflow. In other words, each sub-agent is responsible for a distinct task within the process.

### Step #6: Add the MCP Integration
As mentioned in the previous step, the `reasearch` agent depends on the tools exported by the Bright Data MCP server. Retrieve them with this function:

python
async def initialize_mcp_tools():
print(“Verbindung zu Bright Data MCP herstellen…”)
tools, exit_stack = await MCPToolset.from_server(
connection_params=StdioServerParameters(
command=’npx’,
args=[“-y”, “@brightdata/mcp”],
env={
“API_TOKEN”: BRIGHT_DATA_API_TOKEN,
“BROWSER_AUTH”: BRIGHT_DATA_BROWSER_AUTH,
}
)
)
print(f “MCP Toolset erfolgreich erstellt mit {len(tools)} tools”)
tool_names = [tool.name for tool in tools]
print(f “Verfügbare Werkzeuge sind: {‘, ‘.join(tool_names)}”)

print("MCP initialization complete!")

return tools, exit_stack

Um die MCP-Tools zu laden, bietet Google ADK die Funktion MCPToolset.from_server(). Diese Methode akzeptiert den Befehl, der zum Starten des MCP-Servers verwendet wird, zusammen mit allen erforderlichen Umgebungsvariablen. In diesem Fall entspricht der im Code konfigurierte Befehl dem Befehl, den Sie in Schritt 4 zum lokalen Testen des MCP-Servers verwendet haben.

⚠️ Warnung: Die Konfiguration von MCP-Werkzeugen und ihre Erwähnung in den Eingabeaufforderungen Ihres Agenten garantiert nicht, dass die Bibliothek sie tatsächlich verwendet. Es ist letztendlich Sache des LLM zu entscheiden, ob diese Werkzeuge zur Erfüllung der Aufgabe notwendig sind. Beachten Sie, dass sich die MCP-Integration in Google ADK noch im Anfangsstadium befindet und sich möglicherweise nicht immer wie erwartet verhält.

Gute Arbeit! Nun müssen Sie nur noch diese Funktion aufrufen und die daraus resultierenden Werkzeuge in einen Agenten integrieren, der Ihre Unteragenten nacheinander ausführt.

Schritt Nr. 7: Erstellen des Root-Agenten

Google ADK unterstützt verschiedene Arten von Agenten. In diesem Fall folgt Ihr Workflow einer klaren Abfolge von Schritten, so dass ein sequenzieller Stamm-Agent die richtige Wahl ist. Sie können ihn wie folgt definieren:

async def create_root_agent():
    # Load the MCP tools
    mcp_tools, exit_stack = await initialize_mcp_tools()

    # Define an agent that applies the configured sub-agents sequentially
    root_agent = SequentialAgent(
        name="web_research_agent",
        description="An agent that researches topics on the web and creates comprehensive reports.",
        sub_agents=[
            create_planner_agent(),
            create_researcher_agent(mcp_tools),
            create_publisher_agent(),
        ]
    )

    return root_agent, exit_stack

Damit dies funktioniert, erwartet Google ADK, dass Sie eine root_agent-Variable in Ihrer agent.py-Datei definieren. Erreichen Sie das mit:

root_agent = create_root_agent()

Hinweis: Machen Sie sich keine Sorgen über den Aufruf einer asynchronen Funktion ohne await hier. Dies ist der empfohlene Ansatz in den offiziellen Google ADK-Dokumenten. So wird das Framework die asynchrone Ausführung für Sie übernehmen.

Gute Arbeit! Ihre Integration zwischen dem Bright Data MCP-Server und dem Google ADK ist nun abgeschlossen.

Schritt #8: Alles zusammenfügen

Ihre agent.py-Datei sollte nun enthalten:

from dotenv import load_dotenv
import os
from google.adk.agents import Agent, SequentialAgent
from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset, StdioServerParameters

# Load the environment variables from the .env file
load_dotenv()

# Read the envs for integration with the Bright Data MCP server
BRIGHT_DATA_API_TOKEN = os.getenv("BRIGHT_DATA_API_TOKEN")
BRIGHT_DATA_BROWSER_AUTH = os.getenv("BRIGHT_DATA_BROWSER_AUTH")

# Define the functions for the creation of the required sub-agents
def create_planner_agent():
    return Agent(
        name="planner",
        model="gemini-2.0-flash",
        description="Breaks down user input into focused search queries for research purposes.",
        instruction="""
        You are a research planning assistant. Your task is to:
        1. Analyze the user"s input topic or question.
        2. Break it down into 3 to 5 focused and diverse search engine-like queries that collectively cover the topic.
        3. Return your output as a JSON object in the following format:

        {
            "queries": ["query1", "query2", "query3"]
        }

        IMPORTANT:
        - The queries should be phrased as if typed into a search engine.
        """,
        output_key="search_queries"
    )

def create_researcher_agent(mcp_tools):
    return Agent(
        name="researcher",
        model="gemini-2.0-flash",
        description="Performs web searches and extracts key insights from web pages using the configured tools.",
        instruction="""
        You are a web research agent. Your task is to:
        1. Receive a list of search queries from the planner agent.
        2. For each search query, apply the `search_engine` tool to get Google search results.
        3. From the global results, select the top 3 most relevant URLs.
        4. Pass each URL to the `scraping_browser_navigate` tool.
        5. From each page, use the `scraping_browser_get_text` tool to extract the main page content.
        6. Analyze the extracted text and summarize the key insights in the following JSON format:
        [
            {
                "url": "https://example.com",
                "insights": [
                    "Main insight one",
                    "Main insight two"
                ]
            },
            ...
        ]

        IMPORTANT:
        - You are only allowed to use the following tools: `search_engine`, `scraping_browser_navigate`, and `scraping_browser_get_text`.
        """,
        tools=mcp_tools
    )

def create_publisher_agent():
    return Agent(
        name="publisher",
        model="gemini-2.0-flash",
        description="Synthesizes research findings into a comprehensive, well-structured final document.",
        instruction="""
        You are an expert writer. Your task is to take the structured research output from the scraper agent and craft a clear, insightful, and well-organized report.

        GUIDELINES:
        - Use proper Markdown-like structure: title (#), subtitle, introduction, chapters (##), subchapters (###), and conclusion (##).
        - Integrate contextual links (where needed) using the URLs from the output of the researcher agent.
        - Maintain a professional, objective, and informative tone.
        - Go beyond restating findings—synthesize the information, connect ideas, and present them as a coherent narrative.
        """
    )

# To load the MCP tools exposed by the Bright Data MCP server
async def initialize_mcp_tools():
    print("Connecting to Bright Data MCP...")
    tools, exit_stack = await MCPToolset.from_server(
        connection_params=StdioServerParameters(
            command="npx",
            args=["-y", "@brightdata/mcp"],
            env={
                "API_TOKEN": BRIGHT_DATA_API_TOKEN,
                "BROWSER_AUTH": BRIGHT_DATA_BROWSER_AUTH,
            }
        )
    )
    print(f"MCP Toolset created successfully with {len(tools)} tools")
    tool_names = [tool.name for tool in tools]
    print(f"Available tools include: {", ".join(tool_names)}")

    print("MCP initialization complete!")

    return tools, exit_stack

# Define the root agent required by Google ADK to start
async def create_root_agent():
    # Load the MCP tools
    mcp_tools, exit_stack = await initialize_mcp_tools()

    # Define an agent that applies the configured sub-agents sequentially
    root_agent = SequentialAgent(
        name="web_research_agent",
        description="An agent that researches topics on the web and creates comprehensive reports.",
        sub_agents=[
            create_planner_agent(),
            create_researcher_agent(mcp_tools),
            create_publisher_agent(),
        ]
    )

    return root_agent, exit_stack

# Google ADK will load the root agent in the web UI or CLI
root_agent = create_root_agent()

Starten Sie Ihren KI-Agenten im Stammordner Ihres Projekts und bei aktivierter virtueller Umgebung in einer Web-UI mit:

adk web

Die folgende Anwendung wird auf http://localhost:8000 gestartet :

Nach der Ausführung Ihrer ersten Anfrage versucht die Google ADK-Bibliothek, auf die Variable root_agent zuzugreifen. Dadurch wird die Funktion create_root_agent() ausgelöst, die wiederum initialize_mcp_tools() aufruft.

Das Ergebnis ist, dass Sie im Terminal sehen werden:

Connecting to Bright Data MCP...
Checking for required zones...
Required zone "mcp_unlocker" already exists
Starting server...
MCP Toolset created successfully with 30 tools
Available tools include: search_engine, scrape_as_markdown, scrape_as_html, session_stats, web_data_amazon_product, web_data_amazon_product_reviews, web_data_linkedin_person_profile, web_data_linkedin_company_profile, web_data_zoominfo_company_profile, web_data_instagram_profiles, web_data_instagram_posts, web_data_instagram_reels, web_data_instagram_comments, web_data_facebook_posts, web_data_facebook_marketplace_listings, web_data_facebook_company_reviews, web_data_x_posts, web_data_zillow_properties_listing, web_data_booking_hotel_listings, web_data_youtube_videos, scraping_browser_navigate, scraping_browser_go_back, scraping_browser_go_forward, scraping_browser_links, scraping_browser_click, scraping_browser_type, scraping_browser_wait_for, scraping_browser_screenshot, scraping_browser_get_text, scraping_browser_get_html
MCP initialization complete!

Wie Sie sehen können, hat Google ADK die 30 Bright Data MCP-Tools korrekt geladen.
Jetzt wird der KI-Agent nach der Eingabe einer Anfrage im Chat:

1. Konvertieren Sie Ihre Anfrage in suchmaschinenähnliche Schlüsselwörter.
2. Senden Sie diese Keyphrases an das MCP-Tool search_engine to

   :Polylang placeholder do not modify

3. Erstellen Sie auf der Grundlage dieser Erkenntnisse einen kontextrelevanten Artikel oder Bericht, um Ihre Anfrage zu beantworten.

Beachten Sie, dass, wie in Schritt #6 erwähnt, Gemini (oder jeder andere LLM) MCP-Tools manchmal ganz auslassen kann. Das gilt selbst dann, wenn sie im Code konfiguriert und in den Aufforderungen der Unteragenten ausdrücklich erwähnt sind. Im Einzelnen könnte er eine direkte Antwort zurückgeben oder Sub-Agenten ausführen, ohne die empfohlenen MCP-Tools zu verwenden.

Um diesen Nebeneffekt zu vermeiden, sollten Sie die Eingabeaufforderungen der Unteragenten sorgfältig anpassen. Denken Sie auch daran, dass sich die MCP-Integration in Google ADK noch in der Entwicklung befindet und sich möglicherweise nicht immer wie erwartet verhält. Stellen Sie daher sicher, dass die Bibliothek auf dem neuesten Stand ist.

Nehmen wir nun an, Sie möchten die Biografie des kürzlich gewählten Papstes erfahren. Normalerweise würden sich LLMs mit Abfragen zu aktuellen Ereignissen schwer tun. Aber dank der SERP-API von Bright Data und der Web-Scraping-Funktionen kann Ihr KI-Agent mühelos Echtzeitinformationen abrufen und zusammenfassen:

Et voilà! Auftrag erfüllt.

Schlussfolgerung

In diesem Blogbeitrag haben Sie gelernt, wie Sie das Google ADK-Framework in Kombination mit dem Bright Data MCP verwenden, um einen leistungsstarken KI-Agenten in Python zu erstellen.

Wie gezeigt, ermöglicht die Kombination eines funktionsreichen MCP-Servers mit Google ADK die Erstellung von KI-Agenten, die in der Lage sind, Echtzeitdaten aus dem Web abzurufen und vieles mehr. Dies ist nur ein Beispiel dafür, wie die Tools und Services von Bright Data eine fortschrittliche, KI-gesteuerte Automatisierung ermöglichen können.

Entdecken Sie unsere Lösungen für die Entwicklung von KI-Agenten:

• 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 Fundus 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!