---
title: "Criação de um agente imobiliário com CrewAI e Bright Data"
slug: crewai-real-estate-agent
date: 2025-08-24T08:57:18+00:00
modified: 2025-09-16T16:30:53+00:00
permalink: https://brightdata.com.br/blog/ai/crewai-real-estate-agent
type: blog
---
[ Blog ](https://brightdata.com.br/blog "Blog") / [AI](https://brightdata.com.br/blog/ai)
[AI](https://brightdata.com.br/blog/ai)
# Criação de um agente imobiliário com CrewAI e Bright Data
Descubra como automatizar dados imobiliários, análise de mercado e envolvimento do cliente usando CrewAI e o servidor MCP da Bright Data.
19 min de leitura
[  ](https://brightdata.com/blog/authors/arindam-majumder)
[Arindam Majumder
Technical Writer
](https://brightdata.com/blog/authors/arindam-majumder)
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](https://github.com/brightdata/brightdata-mcp).
Vamos começar!
## O que é CrewAI?
[O CrewAI](https://www.crewai.com/) é 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:
1. 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.
2. **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.
3. **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.
4. **Equipe.** Um objetivo imobiliário envolve um conjunto de agentes que trabalham de forma colaborativa, com cada um realizando suas atribuições aplicáveis.
5. 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](/blog/ai/crewai-with-bright-data-mcp-web-scraping).
## 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 MCP; faça o download no [site oficial](https://nodejs.org/en/download).
- **Ambiente virtual Python** – Mantém as dependências isoladas; consulte a [documentação](https://docs.python.org/3/library/venv.html) do [`venv`](https://docs.python.org/3/library/venv.html).
- **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](https://studio.nebius.com/playground) – Crie uma chave no [Nebius AI Studio](https://studio.nebius.com/playground) (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:
```none
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:
```none
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:
```none
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`:
```none
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:
```none
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 "
"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": ["", ""],
"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`:
```none
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:
```none
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:
```none
{
"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": ["", ""],
"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`:
```none
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`:
```none
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`:
```none
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`:
```none
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`:
```none
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 = ""
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](https://github.com/brightdata/brightdata-mcp).
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](http://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.
Contate-nosTeste grátis
Índice
[ ](https://news.ycombinator.com/submitlink?t=Cria%C3%A7%C3%A3o+de+um+agente+imobili%C3%A1rio+com+CrewAI+e+Bright+Data&u=https://brightdata.com.br/blog/ai/crewai-real-estate-agent) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Cria%C3%A7%C3%A3o+de+um+agente+imobili%C3%A1rio+com+CrewAI+e+Bright+Data&url=https://brightdata.com.br/blog/ai/crewai-real-estate-agent) [ ](http://www.reddit.com/submit?title=Cria%C3%A7%C3%A3o+de+um+agente+imobili%C3%A1rio+com+CrewAI+e+Bright+Data&url=https://brightdata.com.br/blog/ai/crewai-real-estate-agent)
## Você também pode estar interessado em
[  ](https://brightdata.com.br/blog/ai/openhuman-with-bright-data "Acesso à Web Pronto para Produção no OpenHuman Através do Bright Data CLI")
[AI
Antonello Zanini
Technical Writer
### Acesso à Web Pronto para Produção no OpenHuman Através do Bright Data CLI
Integre o Bright Data CLI ao OpenHuman para habilitar acesso à web pronto para produção e coleta de dados para agentes de IA.
09-Sep-2026
14 min de leitura
](https://brightdata.com.br/blog/ai/openhuman-with-bright-data)
[  ](https://brightdata.com.br/blog/dados-do-site/multimodal-web-scraping-with-minimax "Scraping de Dados Multimodal com MiniMax")
[Dados do site
Antonello Zanini
Technical Writer
### Scraping de Dados Multimodal com MiniMax
Combine a API Web Unlocker da Bright Data com a visão MiniMax M3 para extrair dados estruturados de imagens e capturas de tela de páginas web.
09-Sep-2026
5 min de leitura
](https://brightdata.com.br/blog/dados-do-site/multimodal-web-scraping-with-minimax)
[  ](https://brightdata.com.br/blog/ai/best-cli-tools-for-codex "As 10 Melhores Ferramentas CLI para Codex em 2026 – Testadas & Classificadas")
[AI
Daniel Shashko
Web Data & AI Expert
### As 10 Melhores Ferramentas CLI para Codex em 2026 – Testadas & Classificadas
As 10 ferramentas CLI que tornam o Codex mais rápido e capaz, começando com o Bright Data CLI para acesso real à web de dentro do sandbox.
06-Sep-2026
24 min de leitura
](https://brightdata.com.br/blog/ai/best-cli-tools-for-codex)