Neste artigo, você descobrirá:
- O que é o AutoGen e o que o torna único.
- Por que você deve ampliar seus agentes com recursos de recuperação e interação de dados da web por meio do MCP.
- Como criar um agente AutoGen AgentChat que se integra ao Web MCP da Bright Data.
- Como testar o mesmo agente no aplicativo web visual AutoGen Studio.
Vamos começar!
O que é o AutoGen?
O AutoGen é uma estrutura de código aberto para a criação de sistemas de IA multiagentes, desenvolvida pela Microsoft. Ele permite que vários agentes de IA colaborem e se comuniquem entre si para realizar tarefas complexas, de forma autônoma ou com orientação humana.
A biblioteca ganhou popularidade significativa, com mais de 50 mil estrelas no GitHub, e está disponível para Python e C# (.NET).
Principais recursos
Os principais recursos oferecidos pelo AutoGen incluem:
- Agentes personalizáveis e conversacionais: integra agentes de IA com LLMs, entradas humanas e várias ferramentas. Você pode definir comportamentos personalizados e padrões de conversação usando uma API de alto nível ou até mesmo em JSON.
- Fluxos de trabalho com intervenção humana: suporta a incorporação de feedback humano em vários pontos do fluxo de trabalho. Por exemplo, o
UserProxyAgentpode atuar como um Proxy para um humano, permitindo supervisão e intervenção. - Integração de ferramentas: os agentes podem ser equipados com uma ampla gama de ferramentas, como funções para pesquisas na web, execução de código ou manipulação de arquivos. Isso também inclui suporte para integração MCP.
- Tipos de agentes integrados: o AutoGen fornece vários tipos de agentes pré-construídos, incluindo:
UserProxyAgent: representa um usuário humano e pode executar código.AssistantAgent: um assistente de uso geral baseado em LLM, capaz de realizar tarefas e usar ferramentas.CodeExecutorAgent: especializado em executar e testar código.
- Observabilidade e depuração: possui ferramentas integradas para rastrear e depurar interações e fluxos de trabalho de agentes, com suporte para padrões como OpenTelemetry.
- AutoGen Studio: Uma interface web gráfica de baixo código para prototipagem, teste e implantação rápidos de sistemas multiagentes.
Por que estender os agentes AutoGen com o Web MCP da Bright Data
O AutoGen oferece suporte a vários provedores de modelos de IA. No entanto, independentemente do LLM escolhido — seja OpenAI, Anthropic, Ollama ou outro provedor —, todos os modelos compartilham a mesma limitação fundamental: seu conhecimento é estático.
Os LLMs são treinados com dados que representam um instantâneo no tempo, o que significa que seu conhecimento pode se tornar obsoleto rapidamente. Mais importante ainda, eles não podem interagir nativamente com sites ativos ou acessar fontes de dados por conta própria.
Felizmente, o AutoGen é compatível com MCP. Isso significa que você pode combinar seus agentes com o Web MCP da Bright Data. Isso amplia os LLMs, fornecendo-lhes ferramentas para recuperar dados novos e de alta qualidade diretamente da web, além de outros recursos.
Mais detalhadamente, o Web MCP é um servidor de código aberto que fornece mais de 60 ferramentas prontas para IA. Todas elas são alimentadas pela infraestrutura da Bright Data para interação com a web e coleta de dados.
Mesmo em um nível gratuito, você terá acesso a estas duas ferramentas revolucionárias:
| Ferramenta | Descrição |
|---|---|
search_engine |
Recupere resultados de pesquisa do Google, Bing ou Yandex em JSON ou Markdown. |
scrape_as_markdown |
Extraia qualquer página da web em formato Markdown limpo, contornando a detecção de bots e CAPTCHA. |
Além disso, o Web MCP desbloqueia dezenas de ferramentas especializadas para coleta estruturada de dados em plataformas populares como Amazon, LinkedIn, TikTok, Google Play, App Store, Yahoo Finance e muito mais. Saiba mais na página oficial do GitHub.
Resumindo, configurar o Web MCP no AutoGen ajuda você a criar agentes de IA complexos, capazes de interagir com sites ativos e acessar dados da web atualizados para gerar insights baseados no mundo real.
Como criar um agente de IA com ferramentas do Web MCP no AutoGen AgentChat usando Python
Nesta seção guiada, você aprenderá como criar um agente usando o AutoGen AgentChat, a API de alto nível para a criação de aplicativos multiagentes. Especificamente, o agente será capaz de usar todas as ferramentas expostas pelo servidor Web MCP, ampliando os recursos do LLM subjacente.
Observação: o agente a seguir será escrito em Python, mas você pode adaptá-lo facilmente para .NET.
Siga as etapas abaixo para criar um agente em Python com integração AutoGen e MCP!
Pré-requisitos
Para acompanhar este tutorial, certifique-se de ter:
- Python 3.10+ instalado em sua máquina.
- Node.js instalado (recomendamos aversão LTS mais recente).
- Uma chave API OpenAI (ou uma chave API de qualquer um dos outros LLMs suportados).
Você também precisará de uma conta Bright Data com uma chave API, mas não se preocupe, pois você será orientado sobre isso em breve. Ter um conhecimento básico de como o MCP funciona e das ferramentas expostas pelo Web MCP também será útil.
Etapa 1: Configuração do projeto AutoGen
Abra um terminal e crie um novo diretório para o seu projeto AutoGen IA:
mkdir autogen-mcp-agentA pasta autogen-mcp-agent/ conterá o código Python para o seu agente integrado ao MCP.
Em seguida, navegue até o diretório do projeto e inicialize um ambiente virtual dentro dele:
cd autogen-mcp-agent
python -m venv .venvAtive o ambiente virtual. No Linux ou macOS, execute:
source .venv/bin/activateDe forma equivalente, no Windows, execute:
.venv/Scripts/activateAdicione um novo arquivo chamado agent.py ao seu projeto, que agora deve conter:
autogen-mcp-agent/
├── .venv/
└── agent.pyagent.py servirá como seu arquivo Python principal e conterá a lógica do agente de IA.
Carregue a pasta do projeto em seu IDE Python favorito, como o Visual Studio Code com a extensão Python ou o PyCharm Community Edition.
Com o ambiente virtual ativado, instale as dependências necessárias:
pip install autogen-agentchat "autogen-ext[openai]" "autogen-ext[mcp]" python-dotenvAs bibliotecas que você acabou de instalar são:
autogen-agentchat: para desenvolver aplicativos de agente único ou múltiplos agentes por meio de uma API fácil de usar, construída sobre o autogen-core."autogen-ext[openai]": extensão para o AutoGen para criar agentes com modelos OpenAI."autogen-ext[mcp]": extensão para conectar agentes AutoGen a servidores MCP.python-dotenv: Para carregar variáveis de ambiente de um arquivo.envlocal.
Observação: se você não planeja usar modelos OpenAI, instale o pacote apropriado para o seu provedor LLM preferido, conforme explicado na documentação.
Pronto! Seu ambiente Python agora está pronto para o desenvolvimento de agentes de IA com o AutoGen.
Etapa 2: Configurar a leitura de variáveis de ambiente
Seu agente dependerá de conexões com serviços de terceiros, como OpenAI e Bright Data. Para autenticar essas conexões, você precisa fornecer suas chaves de API. Em vez de codificá-las no arquivo agent.py, o que é uma prática inadequada e pode levantar questões de segurança, configure seu script para ler segredos das variáveis de ambiente.
É por isso que o pacote python-dotenv foi instalado em primeiro lugar. No seu arquivo agent.py, importe a biblioteca e chame load_dotenv() para carregar suas variáveis de ambiente:
from dotenv import load_dotenv
load_dotenv()Agora, seu assistente pode ler variáveis de um arquivo .env local.
Portanto, adicione um arquivo .env à raiz do diretório do seu projeto:
autogen-mcp-agent/
├── .venv/
├── .env # <------
└── agent.pyAgora você pode acessar as variáveis de ambiente em seu código com:
import os
os.getenv("ENV_NAME")Ótimo! Seu script carrega segredos de integração de terceiros usando variáveis de ambiente.
Etapa 3: Comece a usar o Web MCP da Bright Data
Antes de conectar seu agente ao Web MCP da Bright Data, você deve primeiro garantir que sua máquina possa executar o servidor. Isso é necessário porque você instruirá o AutoGen a iniciar o Web MCP localmente, e o agente se conectará a ele.
Se você ainda não tem uma conta na Bright Data, crie uma. Se já tem, basta fazer login. Para uma configuração rápida, consulte a seção“MCP”na sua conta:
Para obter mais orientações, siga as instruções abaixo.
Comece gerando uma chave API da Bright Data. Em seguida, guarde-a em um local seguro, pois você precisará dela em breve. Aqui, presumimos que a chave API tenha permissões de administrador, pois isso simplifica o processo de integração do Web MCP.
Continue instalando o Web MCP globalmente em seu sistema por meio do pacote npm @brightdata/mcp:
npm install -g @brightdata/mcpEm seguida, verifique se o servidor MCP local funciona iniciando-o:
$Env:API_TOKEN="<YOUR_BRIGHT_DATA_API>"; npx -y @brightdata/mcpOu, de forma equivalente, no Linux/macOS:
API_TOKEN="<YOUR_BRIGHT_DATA_API>" npx -y @brightdata/mcpSubstitua o espaço reservado <YOUR_BRIGHT_DATA_API> pelo seu token API Bright Data real. Ambos os comandos definem a variável de ambiente API_TOKEN necessária e iniciam o Web MCP localmente.
Se for bem-sucedido, você deverá ver uma saída como esta:
Na primeira inicialização, o Web MCP cria automaticamente duas zonas padrão na sua conta Bright Data:
mcp_unlocker: uma zona para o Web Unlocker.mcp_browser: uma zona para a API do navegador.
O Web MCP depende desses dois produtos Bright Data para alimentar suas mais de 60 ferramentas.
Para confirmar que as zonas foram criadas, faça login no painel da Bright Data e acesse a página“Proxy & Infraestrutura de scraping”(Proxy einfraestruturadescraping). Você deverá encontrar as duas zonas na tabela:
Observação: se o seu token de API não tiver permissões de administrador, essas zonas não serão criadas. Nesse caso, você deve defini-las manualmente no painel e configurar seus nomes no comando por meio de variáveis de ambiente (leia a página do GitHub para obter detalhes).
Lembre-se de que, por padrão, o servidor MCP expõe apenas as ferramentas search_engine e scrape_as_markdown (e suas versões em lote). Essas ferramentas estão incluídas no nível gratuito do Web MCP, portanto, você pode usá-las gratuitamente.
Para desbloquear ferramentas avançadas, como automação do navegador e feeds de dados estruturados, você precisa ativar o modo Pro. Para fazer isso, defina a variável de ambiente PRO_MODE="true" antes de iniciar o Web MCP:
$Env:API_TOKEN="<YOUR_BRIGHT_DATA_API>"; $Env:PRO_MODE="true"; npx -y @brightdata/mcpOu, no Linux/macOS:
API_TOKEN="<YOUR_BRIGHT_DATA_API>" PRO_MODE="true" npx -y @brightdata/mcpO modo Pro desbloqueia todas as mais de 60 ferramentas, mas não está incluído no plano gratuito e acarreta custos adicionais.
Perfeito! Você acabou de verificar que o servidor Web MCP funciona na sua máquina. Interrompa o processo MCP, pois você irá configurar o seu agente AutoGen AgentChat para iniciar e se conectar a ele na próxima etapa.
Etapa 4: Configure a conexão Web MCP
Agora que sua máquina pode executar o Web MCP, você precisa instruir seu script a se conectar ao servidor.
Comece adicionando a chave da API Bright Data que você recuperou anteriormente ao seu arquivo .env:
BRIGHT_DATA_API_KEY="<SUA_CHAVE_API_BRIGHT_DATA>"Substitua <SUA_CHAVE_API_BRIGHT_DATA> pela sua chave API real.
Em agent.py, carregue o valor da chave API da Bright Data com:
BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")Em seguida, defina uma função assíncrona e configure a conexão MCP para um processo MCP Web local:
from autogen_ext.tools.mcp import (
StdioServerParams,
mcp_server_tools
)
async def main():
# Configurações para conectar-se ao Bright Data Web MCP
bright_data_mcp_server = StdioServerParams(
command="npx",
args=[
"-y",
"@brightdata/mcp"
],
env={
"API_TOKEN": BRIGHT_DATA_API_KEY,
"PRO_MODE": "true" # Opcional
}
)
# Carregar as ferramentas expostas pelo servidor Bright Data Web MCP
bright_data_tools = await mcp_server_tools(bright_data_mcp_server)
# Definição do agente...Essa configuração reflete o comando npx da etapa anterior, usando a variável de ambiente para o token da API. Observe que PRO_MODE é opcional, enquanto API_TOKEN é obrigatório.
Essencialmente, seu script agent.py agora iniciará um processo Web MCP e se conectará a ele via STDIO. O resultado é uma matriz de ferramentas que você pode passar para seus agentes AutoGen.
Verifique a conexão listando as ferramentas disponíveis:
para bright_data_tool em bright_data_tools:
print(f"FERRAMENTA: {bright_data_tool.name} - {bright_data_tool.description}n")Se você executar seu script com o modo Pro desativado, deverá ver uma saída semelhante a esta:
Caso contrário, com o modo Pro ativado, você verá todas as mais de 60 ferramentas:
Pronto! O resultado confirma que sua integração com o Web MCP está funcionando perfeitamente.
Etapa 5: defina seu agente AutoGen
O AutoGen AgentChat vem com um conjunto de agentes predefinidos, cada um projetado com diferentes estilos de resposta. Neste caso, o AssistantAgent de uso geral é o mais adequado.
Antes de definir o agente, você precisa configurar uma integração LLM, pois um agente não pode funcionar sem um modelo de IA subjacente.
Comece adicionando sua chave API OpenAI ao arquivo .env:
OPENAI_API_KEY="<SUA_CHAVE_API_OPENAI>"Em seguida, configure a integração OpenAI em seu código com:
from autogen_ext.models.openai import OpenAIChatCompletionClient
model_client = OpenAIChatCompletionClient(
model="gpt-4o-mini",
)O OpenAIChatCompletionClient lê automaticamente a variável de ambiente OPENAI_API_KEY, portanto, não há necessidade de carregá-la em seu código. Essa variável de ambiente será usada para autenticar as chamadas de API subjacentes para o OpenAI.
Observe que o exemplo acima conecta seu agente ao modelo GPT-4o da OpenAI. Se você planeja usar outro modelo ou provedor LLM, verifique a documentação deles e faça os ajustes necessários.
Observação: no momento da redação deste artigo, os modelos GPT-5 ainda não são compatíveis com o autogen-ext[openai].
Agora, combine o modelo com as ferramentas MCP que você carregou anteriormente para criar um agente assistente:
from autogen_agentchat.agents import AssistantAgent
agent = AssistantAgent(
name="web_agent",
model_client=model_client,
tools=bright_data_tools,
)Ótimo! Você acabou de criar seu primeiro agente AutoGen AgentChat, desenvolvido pela OpenAI e integrado às ferramentas MCP da Bright Data.
Etapa 6: crie sua equipe AutoGen
Você pode passar uma tarefa diretamente para o seu agente e executá-la. No entanto, isso não proporcionará a melhor experiência, pois o agente irá parar após a execução de uma única ferramenta. Embora você possa ajustar esse comportamento com o argumento max_tool_iterations, geralmente é melhor definir uma equipe.
No AutoGen, uma equipe é um grupo de agentes que trabalham juntos em direção a um objetivo. No seu caso, a equipe terá apenas um agente (o que é uma configuração válida). Ainda assim, definir uma equipe agora facilita a expansão posterior, caso você queira adicionar mais agentes e criar um fluxo de trabalho com vários agentes.
Uma configuração comum é a equipe RoundRobinGroupChat, na qual os agentes se revezam em um estilo round-robin. Você também precisará de uma condição de término para decidir quando o loop deve parar. Aqui, usaremos TextMentionTermination, configurado para encerrar o processo quando a palavra “TERMINATE” aparecer na resposta do agente:
from autogen_agentchat.conditions import TextMentionTermination
from autogen_agentchat.teams import RoundRobinGroupChat
# Defina uma condição de encerramento para o loop
text_termination = TextMentionTermination("TERMINATE")
# Crie uma equipe com o único agente
team = RoundRobinGroupChat([agent], termination_condition=text_termination)Observe que esta é uma configuração padrão mostrada na maioria dos exemplos do AutoGen.
Mesmo com apenas um agente, a equipe continuará chamando-o repetidamente até que a tarefa seja concluída. Isso é especialmente útil para tarefas complexas que podem exigir várias chamadas de ferramentas — e, portanto, várias rodadas de interação — antes de serem concluídas.
Ótimo! Resta apenas executar a equipe e capturar o resultado.
Etapa 7: Executar a tarefa
Para executar seu aplicativo AutoGen AgentChat, passe uma tarefa para a equipe à qual seu agente pertence. Para testar os recursos estendidos de recuperação de dados da web, tente executar um prompt como este:
tarefa = """
Recupere informações do seguinte aplicativo na App Store:
"https://apps.apple.com/us/app/brave-browser-search-engine/id1052879175"
Com base nas avaliações dos usuários, preços e todas as informações disponíveis, diga-me se você acha que vale a pena instalar este aplicativo e se ele é confiável.
"""Naturalmente, os modelos OpenAI por si só não podem realizar essa tarefa, pois não conseguem obter todos os dados da App Store. É aqui que entra em jogo sua integração com as ferramentas da Bright Data. Com essa configuração, seu agente pode rastrear a página do aplicativo, analisar avaliações e detalhes de preços e, em seguida, permitir que o LLM processe as informações em um relatório claro e legível por humanos.
Este é um exemplo prático de como você pode criar um agente que avalia aplicativos antes da instalação, destacando possíveis problemas ou preocupações dos usuários. Afinal, instalar aplicativos sem a devida diligência pode ser arriscado do ponto de vista da segurança.
Agora, execute a tarefa e transmita a resposta diretamente no seu terminal com:
from autogen_agentchat.ui import Console
await Console(team.run_stream(task=task))Ótimo! Nesse ponto, a equipe começará e a tarefa será transferida para o agente configurado. O agente pode executar várias iterações para atingir o objetivo. O resultado esperado é que o agente use as ferramentas da Bright Data do Web MCP para extrair dados da App Store e, em seguida, o LLM sintetize esses dados em uma avaliação sobre se vale a pena instalar o aplicativo escolhido.
Como última etapa, não se esqueça de fechar a conexão com o modelo escolhido no final do seu script:
await model_client.close()Etapa 8: Junte tudo
Seu arquivo agent.py deve conter:
# pip install autogen-agentchat "autogen-ext[openai]" "autogen-ext[mcp]" python-dotenv
import asyncio
from dotenv import load_dotenv
import os
from autogen_ext.tools.mcp import (
StdioServerParams,
mcp_server_tools
)
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.conditions import TextMentionTermination
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_agentchat.ui import Console
# Carregue as variáveis de ambiente do arquivo .env
load_dotenv()
# Carregue sua chave API Bright Data dos envs
BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")
async def main():
# Configurações para se conectar ao Bright Data Web MCP
bright_data_mcp_server = StdioServerParams(
command="npx",
args=[
"-y",
"@brightdata/mcp"
],
env={
"API_TOKEN": BRIGHT_DATA_API_KEY,
"PRO_MODE": "true" # Opcional
}
)
# Carregue as ferramentas expostas pelo servidor Bright Data Web MCP
bright_data_tools = await mcp_server_tools(bright_data_mcp_server)
# Integração LLM
model_client = OpenAIChatCompletionClient(
model="gpt-4o-mini",
)
# Defina seu agente assistente de IA com tecnologia das ferramentas Web MCP
agent = AssistantAgent(
name="web_agent",
model_client=model_client,
tools=bright_data_tools,
)
# Defina uma condição de encerramento para o loop
text_termination = TextMentionTermination("TERMINATE")
# Crie uma equipe com o único agente
team = RoundRobinGroupChat([agent], termination_condition=text_termination)
# A tarefa a ser executada pela equipe
task = """
Recuperar informações do seguinte aplicativo na App Store:
"https://apps.apple.com/us/app/brave-browser-search-engine/id1052879175"
Com base nas avaliações dos usuários, preços e todas as informações disponíveis, diga-me se você acha que vale a pena instalar este aplicativo e se ele é confiável.
"""
# Transmita a resposta da equipe para o terminal
await Console(team.run_stream(task=task))
# Feche a conexão de IA
await model_client.close()
if __name__ == "__main__":
asyncio.run(main())Uau! Em cerca de 70 linhas de código, você acabou de criar uma equipe de agente único para analisar aplicativos para instalação na App Store.
Execute o agente com:
python agent.pyIsso é o que você deve ver no terminal:
Como você pode ver, o agente identificou corretamente que o web_data_apple_app_store do Web MCP era a ferramenta certa para essa tarefa. Essa é uma ferramenta Pro para “recuperar rapidamente dados estruturados da Apple App Store”. Portanto, foi definitivamente uma boa escolha. Se você não ativasse o modo Pro, o agente utilizaria a ferramenta scrape_as_markdown.
A execução da ferramenta pode demorar um pouco. O resultado são dados estruturados (em formato JSON) extraídos da página da App Store, como esperado:
Essa saída estruturada é então analisada e processada pelo LLM, que gera um relatório Markdown:
Observe as informações detalhadas fornecidas no início do relatório gerado. Elas correspondem exatamente ao que é exibido na página da App Store de destino:
Missão cumprida! Agora, seu agente pode recuperar dados da web e processá-los para realizar tarefas significativas.
Lembre-se de que este foi apenas um exemplo simples. Com a ampla gama de ferramentas Bright Data Web MCP disponíveis no AutoGen AgentChat, você pode projetar agentes muito mais avançados, adaptados a uma ampla variedade de casos de uso do mundo real.
Et voilà! Você acabou de ver o poder da integração do Web MCP da Bright Data em um agente de IA AutoGen AgentChat em Python.
Teste visualmente o agente aprimorado pelo Web MCP no Agent Studio
O AutoGen também oferece o Studio, uma ferramenta de baixo código baseada em navegador que permite criar e experimentar agentes visualmente. Você pode usá-la para testar o agente com integração MCP de maneira simplificada. Veja como!
Pré-requisitos
O único pré-requisito para seguir esta seção opcional do tutorial é ter o AutoGen Studio instalado. A partir do seu ambiente virtual ativado no diretório do projeto, instale-o com:
pip install -U autogenstudioO AutoGen Studio lerá automaticamente a OPENAI_API_KEY do seu arquivo .env, portanto, você não precisa configurá-la manualmente dentro da ferramenta.
Etapa 1: Obtenha o arquivo de configuração JSON da equipe
No AutoGen, qualquer componente em uma configuração de equipe pode ser representado como um arquivo JSON. Como o AutoGen Studio é construído sobre o AgentChat, você pode exportar os componentes do AgentChat para JSON e, em seguida, carregá-los no AutoGen Studio. É exatamente isso que faremos aqui!
Comece exportando a definição da equipe que você criou anteriormente para um arquivo JSON local:
config = team.dump_component()
with open("bd_mcp_team.json", "w", encoding="utf-8") as f:
f.write(config.model_dump_json())Isso produzirá um arquivo bd_mcp_team.json dentro da pasta do seu projeto. Abra-o.
O arquivo contém uma representação JSON do seu agente, incluindo todos os detalhes necessários para se conectar às ferramentas Web MCP da Bright Data.
Etapa 2: Carregue o arquivo JSON no AutoGen Studio
Inicie o AutoGen Studio localmente com:
autogenstudio ui --port 8080O aplicativo estará disponível no seu navegador em http://127.0.0.1:8080. Abra-o e você deverá obter o seguinte aplicativo web:
Por padrão, a solução vem com uma equipe chamada “RoundRobin Team”. Para configurá-la como seu agente MCP estendido, alterne a opção “Visual Builder” e acesse o modo “View JSON”:
No editor JSON, cole o conteúdo do seu arquivo bd_mcp_team.json e pressione o botão “Save Changes”:
Sua “RoundRobin Team” atualizada agora deve ter a seguinte aparência:
Observe que o nome do agente agora é web_agent, exatamente como você definiu no código. Agora você poderá testar seu agente integrado ao Web MCP diretamente no AutoGen Studio.
Etapa 3: teste visualmente o agente
Pressione o botão “Executar” no canto superior direito. A seção de bate-papo para testar sua equipe será exibida:
Cole o mesmo prompt de tarefa de antes e inicie-o:
Como antes, o agente seleciona e executa a ferramenta web_data_apple_app_store. O resultado final será:
À esquerda, a penúltima mensagem contém a resposta gerada pelo agente. Desta vez, você também pode ver que o agente encerra usando uma mensagem “TERMINATE”, que é enviada automaticamente. À direita, há uma representação visual da execução, ajudando você a entender o que acontece passo a passo.
Mesmo que o agente tenha encerrado, seu contexto ainda é compartilhado com a equipe. Isso significa que você pode continuar a conversa sem interrupções, passando outra tarefa — assim como no ChatGPT ou em qualquer outra interface de IA semelhante a um chat.
Isso demonstra um dos benefícios reais de testar seus agentes no AutoGen Studio. Você pode acompanhar visualmente as ações do agente, inspecionar os resultados e manter o contexto em várias interações. Incrível!
Conclusão
Nesta postagem do blog, você viu como criar um agente de IA usando o AutoGen AgentChat e potencializá-lo com ferramentas do Web MCP da Bright Data (que também oferece um plano gratuito!). Você também testou seu agente visualmente e o executou em uma experiência semelhante a um chat por meio do AutoGen Studio.
Essa integração amplia seu agente com pesquisa na web, extração de dados estruturados, acesso a feeds de dados da web, recursos de interação na web e muito mais. Para criar agentes de IA mais avançados, explore o amplo conjunto de produtos e serviços da infraestrutura de IA da Bright Data.
Cadastre-se hoje mesmo para obter uma conta gratuita na Bright Data e comece a experimentar as ferramentas de dados da web preparadas para IA!
