O setor imobiliário está passando por mudanças significativas, com a robótica inteligente e os sistemas de IA substituindo totalmente o trabalho manual. As empresas do setor imobiliário geralmente lidam com conjuntos de dados díspares, análises com uso intensivo de mão de obra e enormes limites de escala. Mas e se existisse um sistema que pudesse raciocinar, adaptar-se e fornecer de forma autônoma serviços imobiliários completos?
Você aprenderá neste guia:
- Como as estruturas modernas de agentes de IA integradas à infraestrutura de raspagem da Web resolvem esses problemas.
- Como criar um agente imobiliário moderno usando a CrewAI e o servidor MCP da Bright Data.
Vamos começar!
O que é CrewAI?
O CrewAI é uma estrutura de código aberto para orquestrar agentes de IA colaborativos. Com o CrewAI, você pode especificar explicitamente o que um agente pode fazer, seus objetivos e as ferramentas que ele pode usar. Isso permite a execução de fluxos de trabalho complexos e de várias etapas no setor imobiliário, agrupando agentes em equipes ou tripulações.
A CrewAI é composta por esses componentes essenciais:
- Agente. Um trabalhador orientado pelo LLM com uma função definida, um objetivo específico e uma história de fundo opcional. O contexto do domínio imobiliário é relevante para o modelo.
- Tarefa. Uma única saída bem delimitada e um trabalho com escopo para um agente que tem uma saída claramente definida que serve como referência de controle de qualidade.
- Ferramenta. Funções privadas que um agente pode chamar para a funcionalidade específica do domínio, como buscar dados de propriedade ou análise de mercado, ou até mesmo usar o ponto de extremidade MCP da Bright Data para raspagem.
- Equipe. Um objetivo imobiliário envolve um conjunto de agentes que trabalham de forma colaborativa, com cada um realizando suas atribuições aplicáveis.
- Processo. O plano de execução, que pode ser feito de forma sequencial, paralela ou hierárquica, rege a ordem das tarefas, sua atribuição, delegação e repetição.
Isso espelha uma equipe imobiliária: os pesquisadores de propriedades lidam com a extração de dados, os analistas de mercado fornecem insights, os gerentes de clientes lidam com a comunicação e os especialistas em listagem supervisionam o marketing.
Para saber mais sobre como o CrawAI se integra a ferramentas como o Bright Data, consulte este guia.
O que é MCP?
O MCP é um padrão JSON-RPC 2.0 aberto que permite que os agentes de IA chamem ferramentas e fontes de dados externas por meio de uma interface única e estruturada. Pense nele como um conector universal para dados imobiliários.
O servidor MCP da Bright Data transforma esse padrão em prática ao conectar um agente diretamente à pilha de raspagem da Bright Data, tornando a extração de dados imobiliários muito mais simples do que as abordagens tradicionais:
- Desvio de anti-bot. As solicitações fluem pelo Web Unlocker e por um pool de mais de 150 milhões de IPs residenciais rotativos, abrangendo 195 países
- Suporte a sites dinâmicos. Um navegador de raspagem desenvolvido especificamente para renderizar JavaScript, para que os agentes vejam listagens de propriedades totalmente carregadas
- Resultados estruturados. Muitas ferramentas retornam JSON limpo, eliminando a necessidade de analisadores personalizados.
O servidor publica mais de 50 ferramentas prontas, que variam de buscas genéricas de URL a raspadores específicos de imóveis, para que seu agente da CrewAI possa recuperar detalhes de propriedades, dados de mercado ou informações de listagem com uma única chamada.
O que estamos construindo: Agentes imobiliários
Criaremos um agente imobiliário da CrewAI que pesquisará propriedades imobiliárias na página do Zillow e retornará os detalhes como uma saída JSON estruturada.
Você pode usá-lo para outras propriedades alterando o link e algumas partes do código.
Pré-requisitos:
Antes de se aprofundar no código, verifique se você tem a seguinte configuração:
- Python 3.11 – Recomendado para estabilidade.
- Node.js + npm – Necessário para executar o servidor do Bright Data Web MCP; faça o download no site oficial.
- Ambiente virtual Python – Mantém as dependências isoladas; consulte a documentação do
venv. - Conta da Bright Data – Inscreva-se e crie um token de API (créditos de avaliação gratuitos estão disponíveis).
- Chave da API do Nebius – Crie uma chave no Nebius AI Studio (clique em + Get API Key). Você pode usá-la gratuitamente. Não é necessário um perfil de faturamento.
Etapa 1. Configuração do ambiente:
Execute os seguintes comandos em seu terminal para configurar o ambiente do projeto e instalar as dependências:
mkdir real-estate-ai-system && cd real-estate-ai-system
python -m venv venv
# macOS/Linux: source venv/bin/activate
# Windows: venv\\Scripts\\activate
pip install "crewai-tools[mcp]" crewai mcp python-dotenv pandas
Crie um novo arquivo chamado real_estate_agents.py e adicione as seguintes importações:
from crewai import Agent, Task, Crew, Process
from crewai_tools import MCPServerAdapter
from mcp import StdioServerParameters
from crewai.llm import LLM
import os
import json
import pandas as pd
from datetime import datetime
from dotenv import load_dotenv
load_dotenv()
Etapa 2. Configuração do servidor MCP da Brightdata
Crie um arquivo .env na raiz do projeto com suas credenciais:
BRIGHT_DATA_API_TOKEN="your_api_token_here"
WEB_UNLOCKER_ZONE="your_web_unlocker_zone"
BROWSER_ZONE="your_browser_zone"
NEBIUS_API_KEY="your_nebius_api_key"
Você precisa:
- Token de API: Gere um novo token de API em seu painel de controle da Bright Data
- Zona do Web Unlocker: Crie uma nova zona do Web Unlocker para sites de imóveis
- Zona da API do navegador: Crie uma nova zona de API do navegador para sites de propriedades com muito JavaScript
- Chave da API do Nebius: Já criada em Pré-requisitos
Adicione essa configuração ao seu arquivo real_estate_agents.py:
llm = LLM(
model="nebius/Qwen/Qwen3-235B-A22B",
api_key=os.getenv("NEBIUS_API_KEY")
)
server_params = StdioServerParameters(
command="npx",
args=["@brightdata/mcp"],
env={
"API_TOKEN": os.getenv("BRIGHT_DATA_API_TOKEN"),
"WEB_UNLOCKER_ZONE": os.getenv("WEB_UNLOCKER_ZONE"),
"BROWSER_ZONE": os.getenv("BROWSER_ZONE"),
},
)
Isso inicia o *npx @brightdata/mcp* como um subprocesso e expõe mais de 50 ferramentas por meio do padrão MCP para extração de dados imobiliários.
Etapa 3. Definição do agente e da tarefa
Aqui, definimos a persona do agente e o trabalho específico que ele precisa fazer. Ao implementar a CrewAI, priorize o design da tarefa, dedicando aproximadamente 80% de seu esforço a ela, e aloque apenas 20% para definir seus agentes. Atualize o arquivo real_estate_agents.py para adicionar definições de agentes e tarefas:
def build_scraper_agent(mcp_tools):
return Agent(
role="Senior Real Estate Data Extractor",
goal=(
"Return a JSON object with snake_case keys containing: address, price, "
"bedrooms, bathrooms, square_feet, lot_size, year_built, property_type, "
"listing_agent, days_on_market, mls_number, description, image_urls, "
"and neighborhood for the target property listing page. Ensure strict schema validation."
),
backstory=(
"Veteran real estate data engineer with years of experience extracting "
"property information from Zillow, Realtor.com, and Redfin. Skilled in "
"Bright Data MCP, proxy rotation, CAPTCHA avoidance, and strict "
"JSON-schema validation for real estate data."
),
tools=mcp_tools,
llm=llm,
max_iter=3,
verbose=True,
)
def build_scraping_task(agent):
return Task(
description=(
"Extract property data from <https://www.zillow.com/homedetails/123-Main-St-City-State-12345/123456_zpid/> "
"and return it as structured JSON."
),
expected_output="""{
"address": "123 Main Street, City, State 12345",
"price": "$450,000",
"bedrooms": 3,
"bathrooms": 2,
"square_feet": 1850,
"lot_size": "0.25 acres",
"year_built": 1995,
"property_type": "Single Family Home",
"listing_agent": "John Doe, ABC Realty",
"days_on_market": 45,
"mls_number": "MLS123456",
"description": "Beautiful home with updated kitchen...",
"image_urls": ["<https://example.com/image1.jpg>", "<https://example.com/image2.jpg>"],
"neighborhood": "Downtown Historic District"
}""",
agent=agent,
)
Veja a seguir o que cada parâmetro faz:
- role – Título curto do cargo, o CrewAI injeta o parâmetro @role em cada prompt do sistema.
- meta – meta da estrela do norte; a CrewAI a compara após cada etapa do looping para decidir se deve parar.
- backstory – conhecimento de domínio que ajuda a orientar o tom do agente e reduz a alucinação.
- tools – Injeta uma lista de objetos BaseTool (por exemplo, MCP search_engine, scrape_as_markdown).
- llm – definição do modelo que o CrewAI usará para cada rotina de pensar → planejar → agir → responder.
- max_iter – Limite rígido do número de loops internos que o agente pode fazer – a versão 0.30 + usa 20 por padrão.
- verbose – Transmite cada prompt, cada pensamento, cada chamada de ferramenta para stdout (para depuração).
- Descrição – Uma instrução orientada para a ação é injetada em cada turno.
- expected_output – Um contrato formal para uma resposta válida (JSON estrito, sem vírgula seguinte).
- agent – Vincula essa tarefa a uma instância específica do agente para Crew.kickoff().
Etapa 4. Montagem e execução da equipe
Essa parte reúne o agente e a tarefa em uma equipe e executa o fluxo de trabalho. Adicione o script de montagem e execução do Crew ao arquivo real_estate_agents.py:
def scrape_property_data():
"""Assembles and runs the scraping crew."""
with MCPServerAdapter(server_params) as mcp_tools:
scraper_agent = build_scraper_agent(mcp_tools)
scraping_task = build_scraping_task(scraper_agent)
crew = Crew(
agents=[scraper_agent],
tasks=[scraping_task],
process=Process.sequential,
verbose=True
)
return crew.kickoff()
if __name__ == "__main__":
try:
result = scrape_property_data()
print("\\n[SUCCESS] Scraping completed!")
print("Extracted property data:")
print(result)
except Exception as e:
print(f"\\n[ERROR] Scraping failed: {str(e)}")
Etapa 5. Execução do raspador
Execute o comando para executar o script em seu terminal:
python real_estate_agents.py
Você verá o processo de pensamento do agente no console à medida que cada agente planeja e executa suas tarefas.
A saída final será um objeto JSON limpo:
{
"address": "123 Main Street, City, State 12345",
"price": "$450,000",
"bedrooms": 3,
"bathrooms": 2,
"square_feet": 1850,
"lot_size": "0.25 acres",
"year_built": 1995,
"property_type": "Single Family Home",
"listing_agent": "John Doe, ABC Realty",
"days_on_market": 45,
"mls_number": "MLS123456",
"description": "Beautiful home with updated kitchen...",
"image_urls": ["<https://example.com/image1.jpg>", "<https://example.com/image2.jpg>"],
"neighborhood": "Downtown Historic District"
}
Padrão de implementação avançado
Embora nosso exemplo básico mostre as ideias centrais, os aplicativos do mundo real precisam de mais reflexão:
Análise de mercado e geração de leads
A criação de inteligência de mercado requer agentes que possam analisar tendências, identificar oportunidades e gerar leads qualificados. Esses agentes colaboram para fornecer percepções abrangentes do mercado e identificar clientes potenciais.
Adicione esses agentes de análise de mercado ao seu arquivo real_estate_agents.py:
def build_market_analysis_agent(mcp_tools):
return Agent(
role="Real Estate Market Analyst",
goal=(
"Analyze market trends, price movements, and investment opportunities. "
"Provide actionable insights for buyers, sellers, and investors based "
"on comprehensive market data and comparable property analysis."
),
backstory=(
"Senior market analyst with expertise in real estate economics, "
"property valuation, and investment analysis. Specializes in identifying "
"market trends, pricing anomalies, and investment opportunities using "
"statistical analysis and machine learning techniques."
),
tools=mcp_tools,
llm=llm,
max_iter=4,
verbose=True,
)
def build_lead_generation_agent(mcp_tools):
return Agent(
role="Real Estate Lead Generation Specialist",
goal=(
"Identify potential buyers and sellers based on market activity, "
"property searches, and behavioral patterns. Generate qualified "
"leads with contact information and engagement strategies."
),
backstory=(
"Lead generation expert with deep knowledge of real estate marketing, "
"customer behavior analysis, and digital prospecting. Experienced in "
"identifying high-value prospects and developing targeted outreach "
"campaigns for real estate professionals."
),
tools=mcp_tools,
llm=llm,
max_iter=3,
verbose=True,
)
def analyze_market_and_generate_leads(area_zip_code, price_range):
"""Perform market analysis and generate leads for a specific area."""
with MCPServerAdapter(server_params) as mcp_tools:
market_analyst = build_market_analysis_agent(mcp_tools)
lead_generator = build_lead_generation_agent(mcp_tools)
market_task = Task(
description=(
f"Analyze the real estate market for ZIP code {area_zip_code} "
f"within price range {price_range}. Research recent sales, "
"current listings, price trends, and market conditions. "
"Identify opportunities and provide investment recommendations."
),
expected_output="""{
"market_overview": {
"avg_price": "$000,000",
"median_price": "$000,000",
"price_trend": "increasing/decreasing/stable",
"days_on_market_avg": 00,
"inventory_levels": "high/medium/low"
},
"recent_sales": [],
"active_listings": 000,
"price_per_sqft_trend": "$000",
"investment_opportunities": [],
"market_forecast": "market_prediction",
"recommendations": []
}""",
agent=market_analyst,
)
lead_task = Task(
description=(
f"Generate qualified leads for {area_zip_code} area. "
"Identify potential sellers with properties likely to be listed, "
"buyers actively searching in the area, and investors looking "
"for opportunities. Include contact strategies and timing recommendations."
),
expected_output="""{
"potential_sellers": [],
"active_buyers": [],
"investor_prospects": [],
"lead_scoring": {
"high_priority": [],
"medium_priority": [],
"low_priority": []
},
"contact_strategies": [],
"follow_up_timeline": []
}""",
agent=lead_generator,
)
crew = Crew(
agents=[market_analyst, lead_generator],
tasks=[market_task, lead_task],
process=Process.sequential,
verbose=True
)
return crew.kickoff()
Interação e comunicação com o cliente
O gerenciamento eficaz de clientes requer agentes especializados que possam lidar com comunicações, agendar compromissos e manter relacionamentos durante todo o processo imobiliário. Esses agentes garantem um atendimento consistente e profissional ao cliente.
Adicione esses agentes de gerenciamento de clientes ao seu arquivo real_estate_agents.py:
def build_client_communication_agent(mcp_tools):
return Agent(
role="Real Estate Client Relations Manager",
goal=(
"Manage client communications, schedule appointments, send follow-ups, "
"and maintain client relationships throughout the buying/selling process. "
"Provide personalized service and timely responses to client inquiries."
),
backstory=(
"Experienced client relations specialist with expertise in real estate "
"customer service, appointment scheduling, and relationship management. "
"Skilled in understanding client needs, managing expectations, and "
"maintaining long-term relationships for referrals and repeat business."
),
tools=mcp_tools,
llm=llm,
max_iter=3,
verbose=True,
)
def build_appointment_scheduler_agent(mcp_tools):
return Agent(
role="Real Estate Appointment Coordinator",
goal=(
"Schedule property viewings, client meetings, and follow-up appointments. "
"Coordinate between buyers, sellers, and agents to optimize scheduling "
"and maximize showing efficiency."
),
backstory=(
"Professional appointment coordinator with deep understanding of real "
"estate workflows, client preferences, and scheduling optimization. "
"Expert in managing complex calendars and coordinating multiple stakeholders."
),
tools=mcp_tools,
llm=llm,
max_iter=2,
verbose=True,
)
def handle_client_communication(client_inquiry, client_profile):
"""Process client inquiries and manage communications."""
with MCPServerAdapter(server_params) as mcp_tools:
communication_agent = build_client_communication_agent(mcp_tools)
scheduler_agent = build_appointment_scheduler_agent(mcp_tools)
communication_task = Task(
description=(
f"Process client inquiry: '{client_inquiry}' from client with "
f"profile: {client_profile}. Provide personalized response, "
"address their specific needs, and recommend next steps."
),
expected_output="""{
"response_message": "personalized_client_response",
"client_needs_assessment": {
"budget_range": "$000,000 - $000,000",
"preferred_locations": [],
"property_requirements": [],
"timeline": "timeframe"
},
"recommended_properties": [],
"next_steps": [],
"follow_up_schedule": "timing_recommendations"
}""",
agent=communication_agent,
)
scheduling_task = Task(
description=(
"Based on the client communication, schedule appropriate "
"follow-up appointments, property viewings, or consultation "
"meetings. Optimize scheduling for client convenience and "
"agent efficiency."
),
expected_output="""{
"scheduled_appointments": [],
"property_viewing_schedule": [],
"follow_up_reminders": [],
"calendar_integration": "scheduling_details"
}""",
agent=scheduler_agent,
)
crew = Crew(
agents=[communication_agent, scheduler_agent],
tasks=[communication_task, scheduling_task],
process=Process.sequential,
verbose=True
)
return crew.kickoff()
Listagem de propriedades e automação de marketing
A automação de marketing requer agentes especializados que possam criar listagens atraentes, otimizá-las para mecanismos de pesquisa e distribuí-las em várias plataformas.
Adicione esse agente de marketing ao seu arquivo real_estate_agents.py:
def build_listing_manager_agent(mcp_tools):
return Agent(
role="Property Listing Marketing Manager",
goal=(
"Create compelling property listings, optimize for search engines, "
"and distribute across multiple platforms. Generate marketing materials "
"and track listing performance to maximize exposure and inquiries."
),
backstory=(
"Digital marketing specialist with expertise in real estate marketing, "
"SEO optimization, and multi-platform listing management. Experienced "
"in creating high-converting property descriptions and managing "
"marketing campaigns across MLS, Zillow, Realtor.com, and social media."
),
tools=mcp_tools,
llm=llm,
max_iter=4,
verbose=True,
)
Recursos de pesquisa e descoberta
Os sistemas inteligentes de busca e recomendação de propriedades permitem que os clientes encontrem propriedades que atendam precisamente às suas necessidades e preferências específicas. Esses agentes oferecem serviços personalizados de descoberta e recomendação de propriedades.
Adicione esses agentes de pesquisa e descoberta ao seu arquivo real_estate_agents.py:
def build_search_agent(mcp_tools):
return Agent(
role="Intelligent Property Search Specialist",
goal=(
"Provide intelligent property search and recommendation services. "
"Understand client preferences, search multiple databases, and "
"deliver personalized property recommendations with detailed analysis."
),
backstory=(
"Search technology expert with deep understanding of real estate "
"databases, property matching algorithms, and client preference analysis. "
"Specializes in advanced search techniques and personalized recommendation "
"systems for optimal property discovery."
),
tools=mcp_tools,
llm=llm,
max_iter=4,
verbose=True,
)
def build_recommendation_agent(mcp_tools):
return Agent(
role="Property Recommendation Engine",
goal=(
"Analyze client behavior, preferences, and market data to generate "
"personalized property recommendations. Learn from client feedback "
"and continuously improve recommendation accuracy."
),
backstory=(
"Machine learning specialist with expertise in recommendation systems, "
"behavioral analysis, and predictive modeling for real estate. "
"Experienced in developing personalized recommendation engines that "
"learn from user interactions and market trends."
),
tools=mcp_tools,
llm=llm,
max_iter=3,
verbose=True,
)
def intelligent_property_search(search_criteria, client_preferences):
"""Perform intelligent property search with personalized recommendations."""
with MCPServerAdapter(server_params) as mcp_tools:
search_agent = build_search_agent(mcp_tools)
recommendation_agent = build_recommendation_agent(mcp_tools)
search_task = Task(
description=(
f"Search for properties matching criteria: {search_criteria}. "
f"Client preferences: {client_preferences}. Use advanced search "
"techniques across multiple platforms and databases. Prioritize "
"results based on client preferences and market conditions."
),
expected_output="""{
"search_results": [],
"total_matches": 0,
"search_filters_applied": [],
"alternative_suggestions": [],
"market_insights": {
"avg_price_in_area": "$000,000",
"market_trends": "trend_analysis",
"inventory_levels": "availability_status"
}
}""",
agent=search_agent,
)
recommendation_task = Task(
description=(
"Analyze search results and client preferences to generate "
"personalized recommendations. Rank properties by relevance, "
"identify hidden gems, and suggest alternative options that "
"might meet client needs."
),
expected_output="""{
"top_recommendations": [],
"personalization_score": "0-100",
"recommendation_reasoning": [],
"alternative_options": [],
"learning_insights": {
"preference_patterns": [],
"behavior_analysis": "client_behavior_summary"
}
}""",
agent=recommendation_agent,
)
crew = Crew(
agents=[search_agent, recommendation_agent],
tasks=[search_task, recommendation_task],
process=Process.sequential,
verbose=True
)
return crew.kickoff()
Implantação e configuração de produção
Por fim, vamos criar um sistema de orquestração abrangente que coordene todos os nossos agentes especializados. Essa classe de sistema principal servirá como o hub central para todas as operações imobiliárias.
Adicione essa orquestração do sistema principal ao seu arquivo real_estate_agents.py:
class RealEstateAgentSystem:
def full_property_analysis(self, property_url, client_profile=None):
with MCPServerAdapter(server_params) as mcp_tools:
research_agent = build_property_research_agent(mcp_tools)
market_analyst = build_market_analysis_agent(mcp_tools)
listing_manager = build_listing_manager_agent(mcp_tools)
research_task = build_property_research_task(research_agent, property_url)
market_task = Task(
description="Analyze market conditions for the researched property",
expected_output="Market analysis with trends and recommendations",
agent=market_analyst,
)
marketing_task = Task(
description="Create marketing strategy based on property and market analysis",
expected_output="Complete marketing campaign plan",
agent=listing_manager,
)
crew = Crew(
agents=[research_agent, market_analyst, listing_manager],
tasks=[research_task, market_task, marketing_task],
process=Process.sequential,
verbose=True
)
return crew.kickoff()
def client_service_workflow(self, client_inquiry, client_profile):
communication_result = handle_client_communication(client_inquiry, client_profile)
if "search" in client_inquiry.lower():
search_criteria = self.extract_search_criteria(client_inquiry)
search_result = intelligent_property_search(search_criteria, client_profile)
return {
"communication": communication_result,
"search_results": search_result
}
return communication_result
def extract_search_criteria(self, inquiry):
criteria = {
"price_range": "extracted_from_inquiry",
"location": "extracted_from_inquiry",
"property_type": "extracted_from_inquiry",
"bedrooms": "extracted_from_inquiry",
"bathrooms": "extracted_from_inquiry"
}
return criteria
def main():
system = RealEstateAgentSystem()
property_url = "<https://www.zillow.com/homedetails/661-Cranbrook-Rd-London-ON-N6K-1W8/2071250954_zpid/>"
try:
print("=== Starting Comprehensive Property Analysis ===")
analysis_result = system.full_property_analysis(property_url)
print("\\n=== Analysis Complete ===")
print("Extracted property data:")
print(json.dumps(analysis_result, indent=2) if isinstance(analysis_result, dict) else str(analysis_result))
client_inquiry = "I'm looking for a 3-bedroom house under $500,000 in downtown area"
client_profile = {
"name": "John Smith",
"budget": "$450,000",
"preferred_locations": ["downtown", "midtown"],
"timeline": "3 months"
}
print("\\n=== Processing Client Inquiry ===")
service_result = system.client_service_workflow(client_inquiry, client_profile)
print("\\n=== Client Service Complete ===")
print("Client service results:")
print(json.dumps(service_result, indent=2) if isinstance(service_result, dict) else str(service_result))
print("\\n=== Analyzing Market and Generating Leads ===")
market_leads = analyze_market_and_generate_leads("90210", "$500,000-$1,000,000")
print("\\n=== Market Analysis Complete ===")
print("Market analysis and leads:")
print(json.dumps(market_leads, indent=2) if isinstance(market_leads, dict) else str(market_leads))
except Exception as e:
print(f"\\n[ERROR] System execution failed: {str(e)}")
if __name__ == "__main__":
main()
Otimização de custos
O MCP da Bright Data é baseado no uso, portanto, você será cobrado por cada solicitação adicional que fizer. Aqui estão algumas dicas para ajudá-lo a manter os custos sob controle:
- Solicite apenas os campos de propriedade de que você precisa, em vez de rastrear sites de listagem ou conjuntos de dados inteiros.
- Ative o cache em nível de ferramenta do CrewAI para ignorar chamadas quando os dados de propriedade não tiverem sido alterados, economizando tempo e créditos.
- Use como padrão a zona do Web Unlocker e mude para a zona da API do navegador somente quando a renderização de JavaScript for essencial para sites de propriedades complexos.
- Forneça a cada agente um limite máximo de iteração razoável para que ele não possa ficar fazendo loop infinito em listagens problemáticas.
Siga essas práticas e seus agentes CrewAI permanecerão econômicos e confiáveis, prontos para cargas de trabalho de produção imobiliária.
Conclusão
Ao longo deste tutorial, você aprendeu a criar agentes imobiliários da CrawAI usando o servidor MCP da Bright Data.
Começamos entendendo o que são essas tecnologias e como elas são usadas. Em seguida, fomos além para criar o agente imobiliário. Configurando o servidor MCP da Bright Data, configurando o LLM, criando agentes, definindo tarefas e montando a equipe de tarefas.
Você pode adaptar facilmente esses agentes a outros alvos imobiliários. Por exemplo, para fazer o scraping do Realtor.com em vez do Zillow, tudo o que você precisa fazer é ajustar a função, a meta e a história do agente, juntamente com a descrição da tarefa e o que você espera como resultado.
