Integração do Google ADK com um servidor MCP para desenvolvimento de agentes de IA

Neste guia, você verá:

• O que é a biblioteca Google ADK para criar agentes de IA.
• Por que seu suporte nativo para MCP o torna especial.
• Como integrá-lo ao servidor MCP da Bright Data para criar um agente de IA extremamente potente

Vamos mergulhar de cabeça!

O que é o Google ADK?

O Google ADK, abreviação de Google Agent Development Kit, é uma estrutura Python de código aberto para criar e implantar agentes de IA. Embora seja otimizado para o Gemini e o ecossistema mais amplo do Google, ele permanece independente do modelo e da implementação.

O ADK enfatiza a experiência do desenvolvedor, oferecendo ferramentas e estruturas de dados que facilitam a criação de sistemas multiagentes avançados. Ele permite que você defina agentes de IA que podem raciocinar, colaborar e interagir com o mundo por meio de ferramentas e integrações.

O objetivo final do Google ADK é fazer com que o desenvolvimento de agentes se pareça mais com o desenvolvimento tradicional de software. Isso é conseguido simplificando o processo de criação, implantação e orquestração de arquiteturas de agentes.

O que torna o Google ADK especial

Em comparação com outras bibliotecas de criação de agentes de IA, o Google ADK se destaca pelo suporte integrado à MCP (Managed Connectivity Platform, plataforma de conectividade gerenciada). Se você não conhece, a MCP é uma maneira padronizada de os modelos de IA interagirem com ferramentas e fontes de dados externas, como APIs, bancos de dados e sistemas de arquivos.

Em termos mais simples, o MCP permite que seu agente do Google ADK aproveite os recursos de qualquer servidor compatível com o MCP. Pense nisso como uma integração plug-and-play que amplia seu agente de IA para além das limitações do LLM subjacente, dando-lhe acesso a dados e ações do mundo real.

Essa opção oferece uma maneira estruturada, segura e dimensionável de conectar seu agente a recursos externos, sem exigir que você crie essas conexões do zero. A integração do MCP torna-se especialmente atraente quando integrada a um servidor MCP avançado, como o servidor MCP da Bright Data.

Esse servidor MCP opera em Node.js e se conecta perfeitamente a todas as poderosas ferramentas de recuperação de dados de IA da Bright Data. Essas ferramentas permitem que seu agente interaja com dados da Web em tempo real, conjuntos de dados estruturados e recursos de raspagem.

No momento em que este texto foi escrito, as ferramentas MCP compatíveis são:

Para outra integração possível, consulte nosso artigo sobre raspagem da Web usando os servidores MCP.

Observação: Novas ferramentas são adicionadas regularmente ao servidor Bright Data MCP, tornando-o cada vez mais avançado e rico em recursos com o passar do tempo.

Veja como tirar proveito dessas ferramentas com o Google ADK!

Como integrar o Google ADK ao servidor MCP da Bright Data

Nesta seção do tutorial, você aprenderá a usar o Google ADK para criar um agente de IA avançado. Ele será equipado com recursos de raspagem ao vivo, recuperação de dados e transformação fornecidos pelo servidor Bright Data MCP.

Essa configuração foi implementada inicialmente por Meir Kadosh, portanto, não deixe de conferir o repositório original do GitHub.

Especificamente, o agente de IA será capaz de:

1. Recupere URLs de mecanismos de pesquisa.
2. Extraia o texto dessas páginas da Web.
3. Gerar respostas baseadas na fonte usando os dados extraídos.

Observação: ao alterar os prompts no código, você pode adaptar facilmente o agente de IA a qualquer outro cenário ou caso de uso.

Siga as etapas abaixo para criar seu agente do Google ADK com tecnologia MCP da Bright Data em Python!

Pré-requisitos

Para seguir este tutorial, você precisa:

• Python 3.9 ou superior instalado localmente.
• Node.js instalado localmente.
• Um sistema baseado em UNIX, como Linux ou macOS, ou o WSL(Windows Subsystem for Linux).

Observação: a integração do Google ADK com o servidor Bright Data MCP atualmente não funciona de forma nativa no Windows. A tentativa de executá-la pode gerar um NotImplementedError nessa seção do código:

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

Por esse motivo, o tutorial pressupõe que você esteja usando o Linux, o macOS ou a WSL.

Você também precisará de:

• Uma conta da Bright Data
• Uma chave de API da Gemini

Este tutorial o guiará na configuração das credenciais do Gemini e do Bright Data quando necessário. Portanto, não se preocupe com elas no momento.

Embora não seja obrigatório, os itens a seguir o ajudarão a tirar o máximo proveito deste tutorial:

• Uma ideia geral de como o MCP funciona.
• Conhecimento básico do funcionamento do Google ADK.
• Familiaridade com o servidor MCP da Bright Data e suas ferramentas disponíveis.
• Alguma experiência com programação assíncrona em Python.

Etapa 1: Configuração do projeto

Abra seu terminal e crie uma nova pasta para seu agente de raspagem:

mkdir google_adk_mcp_agent

A pasta google_adk_mcp_agent conterá todo o código do seu agente de IA Python.

Em seguida, navegue até a pasta do projeto e crie um ambiente virtual dentro dela:

cd google_adk_mcp_agent
python3 -m venv .venv

Abra a pasta do projeto em seu IDE Python preferido. Recomendamos usar o Visual Studio Code com a extensão Python ou o PyCharm Community Edition.

Dentro de google_adk_mcp_agent, crie uma subpasta chamada web_search_agent. Essa subpasta conterá a lógica central do seu agente e deverá incluir os dois arquivos a seguir:

• __init__.py: Exporta a lógica do agent.py.
• agent.py: Contém a definição do agente do Google ADK.

Essa é a estrutura de pastas necessária para que a biblioteca do Google ADK funcione corretamente:

Agora, inicialize o arquivo __init__ .py com a seguinte linha:

from . import agent

Em vez disso, o agent.py será definido com a lógica do agente de IA do agente em breve.

No terminal do IDE, ative o ambiente virtual. No Linux ou macOS, execute este comando:

./.venv/bin/activate

De forma equivalente, no Windows, inicie:

.venv/Scripts/activate

Está tudo pronto! Agora você tem um ambiente Python para criar um agente de IA usando o Google ADK e o servidor MCP da Bright Data.

Etapa 2: Configurar a leitura das variáveis de ambiente

Seu projeto interagirá com serviços de terceiros, como Gemini e Bright Data. Em vez de codificar chaves de API e segredos de autenticação diretamente no código Python, a prática recomendada é carregá-los a partir de variáveis de ambiente.

Para simplificar essa tarefa, usaremos a biblioteca python-dotenv. Com seu ambiente virtual ativado, instale-a executando:

pip install python-dotenv

Em seu arquivo agent.py, importe a biblioteca e carregue as variáveis de ambiente com load_dotenv():

from dotenv import load_dotenv

load_dotenv()

Isso permite que você leia variáveis de um arquivo .env local. Portanto, adicione um arquivo .env ao seu diretório de agente aninhado:

Agora você pode ler variáveis de ambiente em seu código com esta linha de código:

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

Não se esqueça de importar o módulo os da biblioteca padrão do Python:

import os

Excelente! Agora você está pronto para ler os segredos do env para se integrar com segurança a serviços de terceiros.

Etapa 3: começar a usar o Google ADK

Em seu ambiente virtual ativado, instale a biblioteca Google ADK Python executando:

pip install google-adk

Em seguida, abra o agent.py e adicione as seguintes importações:

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

Eles serão usados nas próximas etapas para a integração com o Google ADK.

Agora, lembre-se de que o Google ADK exige a integração com um provedor de IA. Aqui, usaremos o Gemini, pois a biblioteca é otimizada para os modelos de IA do Google.

Se você ainda não obteve sua chave de API, siga a documentação oficial do Google. Faça login na sua conta do Google e acesse o Google AI Studio. Em seguida, navegue até a seção“Get API Key” e você verá este modal:

Clique no botão “Get API key” (Obter chave de API). Na tela seguinte, pressione o botão “Create API key” (Criar chave de API):

Depois de gerada, você verá sua chave exibida em um modal:

Copie a chave e guarde-a em um local seguro. Observe que, com a mesma chave, você pode realizar a raspagem da Web com o Gemini.

Observação: a camada gratuita do Gemini é suficiente para este tutorial. A camada paga só é necessária se você precisar de limites de taxa mais altos ou não quiser que seus avisos e respostas sejam usados para melhorar os produtos do Google. Consulte a página de faturamento do Gemini.

Agora, inicialize seu arquivo .env com as seguintes variáveis de ambiente:

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

Substitua pela chave real que você acabou de gerar. Nenhum código adicional é necessário no agent.py, pois a biblioteca google-adk procura automaticamente a variável de ambiente GOOGLE_API_KEY.

Da mesma forma, a configuração GOOGLE_GENAI_USE_VERTEXAI determina se o Google ADK deve se integrar à Vertex AI. Defina-a como "False" para usar diretamente a API Gemini.

Incrível! Agora você pode usar o Gemini no Google ADK. Vamos continuar com a configuração inicial da solução de terceiros necessária para a integração.

Etapa 4: Configurar o servidor MCP da Bright Data

Se você ainda não o fez, [crie uma conta na Bright Data](). Se já tiver uma, basta fazer o login.

Em seguida, siga as instruções oficiais para:

1. Recupere seu token da API da Bright Data.
2. Configure o Web Unlocker e o Scraping Browser para integração com o MCP.

Você terminará com:

• Um token da API da Bright Data.
• Uma zona do Web Unlocker (aqui, assumiremos que ela tem o nome padrão, que é mcp_unlocker).
• Raspagem das credenciais de autenticação do navegador no formato: <BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>.

Agora você está pronto para instalar o servidor Bright Data MCP globalmente em seu ambiente Node.js com:

npm install -g @brightdata/mcp

Em seguida, inicie o servidor MCP por meio do pacote @brightdata/mcp npm com:

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

O comando acima define as variáveis de ambiente necessárias(API_TOKEN e BROWSER_AUTH) e inicia o servidor MCP localmente. Se tudo estiver configurado corretamente, você verá uma saída indicando que o servidor está sendo executado com êxito:

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

Fantástico! O servidor MCP da Bright Data funciona muito bem.

Adicione essas variáveis de ambiente ao seu arquivo .env na raiz do seu projeto do Google ADK:

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

Substitua os espaços reservados pelos valores reais.

Em seguida, leia esses envs em seu código com:

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

Perfeito! Agora você tem tudo configurado para integrar o servidor Bright Data MCP com o Google ADK. Mas, primeiro, é hora de definir os agentes de IA.

Etapa nº 5: Definir os agentes

Conforme mencionado na introdução, o agente Google ADK com tecnologia MCP atuará como um agente de resumo de conteúdo. Seu principal objetivo é receber a entrada de um usuário e retornar um resumo de alta qualidade e com boas fontes.

Em detalhes, o agente seguirá este fluxo de trabalho:

1. Interprete a solicitação do usuário e divida-a em consultas de pesquisa no estilo do Google.
2. Processar as consultas de pesquisa usando um subagente que

   :Polylang placeholder do not modify

3. Gere um relatório Markdown em resposta à consulta original do usuário. O processo usará o conteúdo recém-coletado como fonte e incluirá links para leitura adicional.

Como o processo se divide naturalmente em três estágios distintos, faz sentido dividir o agente de IA de nível superior em três subagentes:

• Planejador: Converte tópicos complexos em consultas de pesquisa bem formadas.
• Pesquisador: Executa as pesquisas e extrai informações significativas das páginas da Web resultantes.
• Editor: Sintetiza a pesquisa em um documento bem escrito e estruturado.

Implemente esses três agentes no Google ADK usando o seguinte código Python:

• Planejador:

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"
    )

• Pesquisador:

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
    )

Observação: O argumento de entrada mcp_tools é uma lista que especifica com quais ferramentas do MCP o agente pode interagir. Na próxima etapa, você verá como preencher essa lista usando as ferramentas fornecidas pelo servidor MCP da Bright Data.

• Editor:
  “`python
  def create_publisher_agent():
  return Agent(
  name=”publisher”,
  model=”gemini-2.0-flash”,
  description=”Sintetiza os resultados da pesquisa em um documento final abrangente e bem estruturado.”,
  instruction=”””
  Você é um escritor especialista. Sua tarefa é pegar o resultado da pesquisa estruturada do agente scraper e criar um relatório claro, perspicaz e bem organizado. ORIENTAÇÕES: - Use a estrutura adequada do tipo Markdown: título (#), subtítulo, introdução, capítulos (##), subcapítulos (###) e conclusão (##). - Integre links contextuais (quando necessário) usando os URLs da saída do agente pesquisador. - Mantenha um tom profissional, objetivo e informativo. - Vá além da reafirmação das descobertas - sintetize as informações, conecte as ideias e apresente-as como uma narrativa coerente. """ )

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(“Conectando-se ao Bright Data MCP…”)
tools, exit_stack = await MCPToolset.from_server(
connection_params=StdioServerParameters(
comando=’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 “As ferramentas disponíveis incluem: {‘, ‘.join(tool_names)}”)

print("MCP initialization complete!")

return tools, exit_stack

Para carregar as ferramentas do MCP, o Google ADK fornece a função MCPToolset.from_server(). Esse método aceita o comando usado para iniciar o servidor MCP, juntamente com todas as variáveis de ambiente necessárias. Nesse caso, o comando configurado no código corresponde ao comando que você usou na Etapa 4 para testar o servidor MCP localmente.

⚠️ Aviso: Configurar as ferramentas do MCP e mencioná-las em seus prompts de agente não garante que a biblioteca as usará de fato. Em última análise, cabe ao LLM decidir se essas ferramentas são necessárias para realizar a tarefa. Lembre-se de que a integração do MCP no Google ADK ainda está em seus estágios iniciais e pode nem sempre se comportar como esperado.

Bom trabalho! Tudo o que resta é chamar essa função e integrar as ferramentas resultantes em um agente que executa seus subagentes sequencialmente.

Etapa nº 7: criar o agente raiz

O Google ADK oferece suporte a vários tipos de agentes. Nesse caso, seu fluxo de trabalho segue uma sequência clara de etapas, portanto, um agente sequencial raiz é a escolha certa. Você pode definir um agente como este:

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

Para que isso funcione, o Google ADK espera que você defina uma variável root_agent em seu arquivo agent.py. Faça isso com:

root_agent = create_root_agent()

Observação: não se preocupe em chamar uma função assíncrona sem aguardar aqui. Essa é a abordagem recomendada nos documentos oficiais do Google ADK. Assim, a estrutura cuidará da execução assíncrona para você.

Excelente trabalho! Sua integração entre o servidor Bright Data MCP e o Google ADK está concluída.

Etapa #8: Juntar tudo

Seu arquivo agent.py agora deve conter:

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()

Na pasta raiz do seu projeto e com o ambiente virtual ativado, inicie o agente de IA em uma interface da Web com:

adk web

O aplicativo a seguir será iniciado em http://localhost:8000:

Depois de executar sua primeira solicitação, a biblioteca do Google ADK tentará acessar a variável root_agent. Isso acionará a função create_root_agent(), que, por sua vez, chama initialize_mcp_tools().

Como resultado, no terminal, você verá:

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!

Como você pode ver, o Google ADK carregou as 30 ferramentas do Bright Data MCP corretamente.
Agora, depois de inserir uma solicitação no bate-papo, o agente de IA irá:

1. Converta sua solicitação em frases-chave no estilo do mecanismo de pesquisa.
2. Envie essas frases-chave para a ferramenta MCP do mecanismo de pesquisa para

   :Polylang placeholder do not modify

3. Gere um artigo ou relatório contextualmente relevante com base nesses insights para responder à sua consulta.

Observe que, conforme mencionado na Etapa 6, o Gemini (ou qualquer outro LLM) pode, às vezes, ignorar totalmente as ferramentas do MCP. Isso é verdade mesmo que elas estejam configuradas no código e explicitamente mencionadas nos prompts do subagente. Em detalhes, ele pode retornar uma resposta direta ou executar subagentes sem usar as ferramentas MCP recomendadas.

Para evitar esse efeito colateral, ajuste cuidadosamente os prompts do subagente. Além disso, lembre-se de que a integração do MCP no Google ADK ainda está evoluindo e pode nem sempre se comportar como esperado. Portanto, certifique-se de que a biblioteca esteja atualizada.

Agora, suponha que você queira conhecer a biografia do Papa recentemente eleito. Normalmente, os LLMs teriam dificuldades com consultas sobre eventos atuais. Mas graças à API SERP da Bright Data e aos recursos de raspagem da Web, seu agente de IA pode buscar e resumir informações em tempo real sem esforço:

E pronto! Missão concluída.

Conclusão

Nesta postagem do blog, você aprendeu a usar a estrutura do Google ADK em combinação com o Bright Data MCP para criar um agente de IA avançado em Python.

Conforme demonstrado, a combinação de um servidor MCP rico em recursos com o Google ADK permite que você crie agentes de IA capazes de recuperar dados em tempo real da Web e muito mais. Esse é apenas um exemplo de como as ferramentas e os serviços da Bright Data podem capacitar a automação avançada e orientada por IA.

Explore nossas soluções para o desenvolvimento de agentes de IA:

• Agentes autônomos de IA: Pesquise, acesse e interaja com qualquer site em tempo real usando um conjunto avançado de APIs.
• Aplicativos de IA verticais: crie pipelines de dados confiáveis e personalizados para extrair dados da Web de fontes específicas do setor.
• Modelos básicos: Acesse conjuntos de dados compatíveis e em escala da Web para potencializar o pré-treinamento, a avaliação e o ajuste fino.
• IA multimodal: aproveite o maior repositório do mundo de imagens, vídeos e áudio otimizados para IA.
• Provedores de dados: Conecte-se com provedores confiáveis para obter conjuntos de dados de alta qualidade e prontos para IA em escala.
• Pacotes de dados: Obtenha conjuntos de dados com curadoria, prontos para uso, estruturados, enriquecidos e anotados.

Para obter mais informações, explore nosso hub de IA.

Crie uma conta na Bright Data e experimente todos os nossos produtos e serviços para o desenvolvimento de agentes de IA!