Le secteur de l’immobilier connaît des changements importants, la robotique intelligente et les systèmes d’IA remplaçant entièrement le travail manuel. Les entreprises du secteur de l’immobilier sont souvent confrontées à des ensembles de données disparates, à des analyses à forte intensité de main-d’œuvre et à d’énormes limites d’échelle. Et s’il existait un système capable de raisonner, de s’adapter et de fournir de manière autonome des services immobiliers complets ?
Vous apprendrez dans ce guide :
- Comment les cadres modernes d’agents d’intelligence artificielle intégrés à l’infrastructure d’exploration du web résolvent ces problèmes.
- Comment créer un agent immobilier moderne en utilisant CrewAI et le serveur MCP de Bright Data.
C’est parti !
Qu’est-ce que CrewAI ?
CrewAI est un cadre open-source pour l’orchestration d’agents d’IA collaboratifs. Avec CrewAI, vous pouvez spécifier explicitement ce qu’un agent peut faire, ses objectifs et les outils qu’il est autorisé à utiliser. Cela permet d’exécuter des flux de travail complexes et à plusieurs étapes dans l’immobilier en regroupant les agents en équipes ou en équipages.
CrewAI se compose de ces éléments essentiels :
- Agent. Un travailleur piloté par LLM avec un rôle défini, un objectif spécifique et une histoire facultative. Le contexte du domaine immobilier est pertinent pour le modèle.
- Tâche. Un travail unique, bien délimité, pour un agent, dont le résultat est clairement défini et qui sert de référence pour le contrôle de la qualité.
- Outil. Fonctions privées qu’un agent peut appeler pour des fonctionnalités spécifiques à un domaine, telles que l’obtention de données sur les biens immobiliers ou l’analyse du marché, ou même l’utilisation du point de terminaison MCP de Bright Data pour le scraping.
- L’équipage. Un objectif immobilier implique un ensemble d’agents travaillant en collaboration, chacun effectuant les tâches qui lui incombent.
- Processus. Le plan d’exécution, qui peut être séquentiel, parallèle ou hiérarchique, régit l’ordre des tâches, leur affectation, leur délégation et leur répétition.
À l’image d’une équipe immobilière, les chercheurs en immobilier s’occupent de l’extraction des données, les analystes de marché fournissent des informations, les gestionnaires de clientèle s’occupent de la communication et les spécialistes de la vente supervisent le marketing.
Pour en savoir plus sur l’intégration de CrawAI avec des outils comme Bright Data, consultez ce guide.
Qu’est-ce que le MCP ?
MCP est une norme JSON-RPC 2.0 ouverte qui permet aux agents d’intelligence artificielle d’appeler des outils et des sources de données externes par le biais d’une interface unique et structurée. Il s’agit d’un connecteur universel pour les données immobilières.
Le serveur MCP de Bright Data met cette norme en pratique en connectant un agent directement à la pile d’extraction de Bright Data, ce qui rend l’extraction de données immobilières beaucoup plus simple que les approches traditionnelles :
- Contournement de l’anti-bot. Les demandes passent par Web Unlocker et un pool de plus de 150 millions d’adresses IP résidentielles tournantes couvrant 195 pays.
- Prise en charge des sites dynamiques. Un navigateur de scraping spécialement conçu rend le JavaScript, de sorte que les agents voient des listes de biens immobiliers entièrement chargées.
- Résultats structurés. De nombreux outils renvoient des données JSON propres, ce qui évite d’avoir recours à des analyseurs personnalisés.
Le serveur publie plus de 50 outils prêts à l’emploi, allant de l’extraction d’URL génériques à des scraps spécifiques à l’immobilier, afin que votre agent CrewAI puisse récupérer les détails d’une propriété, les données du marché ou les informations relatives à une inscription en un seul appel.
Ce que nous construisons : Agents immobiliers
Nous allons créer un agent immobilier CrewAI qui recherchera des biens immobiliers sur la page Zillow et renverra les détails sous la forme d’une sortie JSON structurée.
Vous pouvez l’utiliser pour d’autres propriétés en modifiant le lien et certaines parties du code.
Prérequis :
Avant de plonger dans le code, assurez-vous d’avoir la configuration suivante :
- Python 3.11 – Recommandé pour la stabilité.
- Node.js + npm – Nécessaire pour exécuter le serveur Bright Data Web MCP ; à télécharger sur le site officiel.
- Environnement virtuel Python – Permet d’isoler les dépendances ; voir la documentation de
venv. - Compte Bright Data – S’inscrire et créer un jeton API (des crédits d’essai gratuits sont disponibles).
- Clé API Nebius – Créez une clé dans Nebius AI Studio (cliquez + Get API Key). Vous pouvez l’utiliser gratuitement. Aucun profil de facturation n’est requis.
Étape 1. Configuration de l’environnement :
Exécutez les commandes suivantes dans votre terminal pour configurer l’environnement du projet et installer les dépendances :
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
Créez un nouveau fichier appelé real_estate_agents.py et ajoutez les importations suivantes :
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()
Étape 2. Configuration du serveur MCP de Brightdata
Créez un fichier .env à la racine de votre projet avec vos informations d’identification :
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"
Vous avez besoin de :
- Clé API: Générez une nouvelle clé d’API à partir de votre tableau de bord Bright Data.
- Zone Web Unlocker: Créer une nouvelle zone Web Unlocker pour les sites immobiliers
- Zone API navigateur: Créer une nouvelle zone Browser API pour les sites immobiliers à forte composante JavaScript
- Clé API Nebius: Déjà créée dans les conditions préalables
Ajoutez cette configuration à votre fichier 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"),
},
)
Il lance *npx @brightdata/mcp* en tant que sous-processus et expose plus de 50 outils via la norme MCP pour l’extraction de données immobilières.
Étape 3. Définition de l’agent et de la tâche
Ici, nous définissons le personnage de l’agent et la tâche spécifique qu’il doit accomplir. Lors de la mise en œuvre de CrewAI, donnez la priorité à la conception des tâches, en y consacrant environ 80 % de vos efforts, et n’allouez que 20 % à la définition de vos agents. Mettez à jour le fichier real_estate_agents.py pour ajouter les définitions des agents et des tâches :
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,
)
Voici ce que fait chaque paramètre :
- role – Titre court du poste, CrewAI injecte le paramètre @role dans chaque invite du système.
- goal – Objectif de l’étoile du Nord ; CrewAI le compare après chaque étape de la boucle pour décider s’il faut s’arrêter.
- backstory – Connaissance du domaine qui permet d’orienter le ton de l’agent et de réduire les hallucinations.
- tools – Injecter une liste d’objets BaseTool (par exemple, MCP search_engine, scrape_as_markdown).
- llm – définition du modèle que CrewAI utilisera pour chaque routine think → plan → act → answer.
- max_iter – Limite stricte du nombre de boucles internes que l’agent peut effectuer – v0.30 + utilise 20 par défaut.
- verbeux – envoie chaque invite, chaque pensée, chaque appel d’outil à stdout (pour le débogage).
- description – Une instruction orientée vers l’action est injectée à chaque tour.
- expected_output – Un contrat formel pour une réponse valide (JSON strict, pas de virgule suivante).
- agent – Lie cette tâche à une instance d’agent spécifique pour Crew.kickoff().
Étape 4. Constitution et exécution de l’équipage
Cette partie assemble l’agent et la tâche dans une équipe et exécute le flux de travail. Ajoutez le script d’assemblage et d’exécution de l’équipe au fichier 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)}")
Étape 5. Faire fonctionner le grattoir
Lancez la commande pour exécuter le script à partir de votre terminal :
python real_estate_agents.py
Vous verrez le processus de réflexion de l’agent dans la console lorsque chaque agent planifie et exécute ses tâches.
Le résultat final sera un objet JSON propre :
{
"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"
}
Modèle de mise en œuvre avancé
Bien que notre exemple de base illustre les idées fondamentales, les applications dans le monde réel nécessitent une réflexion plus approfondie :
Analyse de marché et génération de leads
La mise en place d’une veille commerciale nécessite des agents capables d’analyser les tendances, d’identifier les opportunités et de générer des pistes qualifiées. Ces agents collaborent pour fournir des informations complètes sur le marché et identifier les prospects.
Ajoutez ces agents d’analyse de marché à votre fichier 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()
Interaction et communication avec les clients
Une gestion efficace de la clientèle nécessite des agents spécialisés capables de gérer les communications, de fixer des rendez-vous et d’entretenir des relations tout au long du processus immobilier. Ces agents assurent un service à la clientèle cohérent et professionnel.
Ajoutez ces agents de gestion des clients à votre fichier 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()
Automatisation des listes de propriétés et du marketing
L’automatisation du marketing nécessite des agents spécialisés capables de créer des listes attrayantes, de les optimiser pour les moteurs de recherche et de les distribuer sur plusieurs plateformes.
Ajoutez cet agent marketing à votre fichier 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,
)
Fonctions de recherche et de découverte
Les systèmes intelligents de recherche et de recommandation de biens immobiliers permettent aux clients de trouver des biens qui correspondent précisément à leurs besoins et à leurs préférences. Ces agents fournissent des services personnalisés de découverte et de recommandation de biens immobiliers.
Ajoutez ces agents de recherche et de découverte à votre fichier 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()
Déploiement et mise en production
Enfin, créons un système d’orchestration complet qui coordonne tous nos agents spécialisés. Cette classe de système primaire servira de plaque tournante pour toutes les opérations immobilières.
Ajoutez cette orchestration du système principal à votre fichier 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()
Optimisation des coûts
Le MCP de Bright Data est basé sur l’utilisation, ce qui signifie que vous êtes facturé pour chaque demande supplémentaire que vous effectuez. Voici quelques conseils pour vous aider à maîtriser vos coûts :
- Demandez uniquement les champs de propriété dont vous avez besoin au lieu d’explorer des sites d’inscription ou des ensembles de données entiers.
- Activez le cache au niveau de l’outil CrewAI pour ignorer les appels lorsque les données de propriété n’ont pas changé, ce qui permet d’économiser du temps et des crédits.
- Utiliser par défaut la zone Web Unlocker et passer à la zone Browser API uniquement lorsque le rendu JavaScript est essentiel pour les sites immobiliers complexes.
- Donnez à chaque agent une limite d’itération maximale raisonnable afin qu’il ne puisse pas boucler indéfiniment sur des listes problématiques.
Suivez ces pratiques, et vos agents CrewAI resteront rentables et fiables, prêts pour des charges de travail immobilières de production.
Conclusion
Tout au long de ce tutoriel, vous avez appris à créer des agents immobiliers CrawAI en utilisant le serveur MCP de Bright Data.
Nous avons commencé par comprendre ce que sont ces technologies et comment elles sont utilisées. Puis nous sommes allés plus loin pour construire l’agent immobilier. Mise en place du serveur MCP de Bright Data, configuration du LLM, création d’agents, définition des tâches et assemblage de l’équipe de tâches.
Vous pouvez facilement adapter ces agents à d’autres cibles immobilières. Par exemple, pour récupérer les données de Realtor.com au lieu de Zillow, il vous suffit de modifier le rôle, l’objectif et l’histoire de votre agent, ainsi que la description de la tâche et ce que vous attendez comme résultat.
