El sector inmobiliario está experimentando cambios significativos con la robótica inteligente y los sistemas de IA que sustituyen por completo el trabajo manual. Las empresas del sector inmobiliario se enfrentan a menudo a conjuntos de datos dispares, análisis que requieren mucha mano de obra y enormes límites de escala. Pero, ¿y si existiera un sistema capaz de razonar, adaptarse y prestar de forma autónoma servicios inmobiliarios completos?
En esta guía aprenderás:
- Cómo resuelven estos problemas los modernos marcos de agentes de IA integrados con la infraestructura de raspado web.
- Cómo crear un agente inmobiliario moderno utilizando CrewAI y el servidor MCP de Bright Data.
Empecemos.
¿Qué es CrewAI?
CrewAI es un marco de código abierto para orquestar agentes de IA colaborativos. Con CrewAI, puedes especificar explícitamente lo que puede hacer un agente, sus objetivos y las herramientas que puede utilizar. Esto permite la ejecución de flujos de trabajo complejos y de varios pasos en el sector inmobiliario mediante la agrupación de agentes en equipos o cuadrillas.
CrewAI se compone de estos componentes esenciales:
- Agente. Un trabajador dirigido por LLM con un papel definido, un objetivo específico y una historia de fondo opcional. El contexto del dominio inmobiliario es relevante para el modelo.
- Tarea. Un trabajo único, bien delimitado y con un alcance para un agente que tiene un resultado claramente definido que sirve como referencia de control de calidad.
- Herramienta. Funciones privadas a las que un agente puede llamar para funciones específicas del dominio, como la obtención de datos inmobiliarios o análisis de mercado, o incluso el uso del punto final MCP de Bright Data para el scraping.
- Equipo. Un objetivo inmobiliario consiste en un conjunto de agentes que trabajan en colaboración, cada uno de los cuales realiza las tareas que le corresponden.
- Proceso. El plan de ejecución, que puede realizarse de forma secuencial, paralela o jerárquica, rige el orden de las tareas, su asignación, delegación y repetición.
Es el reflejo de un equipo inmobiliario: los investigadores de propiedades se encargan de extraer datos, los analistas de mercado aportan información, los gestores de clientes se ocupan de la comunicación y los especialistas en listados supervisan el marketing.
Para obtener más información sobre la integración de CrawAI con herramientas como Bright Data, consulte esta guía.
¿Qué es MCP?
MCP es un estándar abierto JSON-RPC 2.0 que permite a los agentes de IA llamar a herramientas y fuentes de datos externas a través de una interfaz única y estructurada. Piense en él como un conector universal para datos inmobiliarios.
El servidor MCP de Bright Data convierte esa norma en práctica al conectar un agente directamente a la pila de raspado de Bright Data, lo que hace que la extracción de datos inmobiliarios sea mucho más sencilla que los enfoques tradicionales:
- Anulación de robots. Las solicitudes fluyen a través de Web Unlocker y un grupo de más de 150 millones de IPs residenciales rotativas que abarcan 195 países.
- Compatibilidad con sitios dinámicos. Un explorador de raspado especialmente diseñado renderiza JavaScript, para que los agentes vean los listados de propiedades completamente cargados.
- Resultados estructurados. Muchas herramientas devuelven JSON limpio, eliminando la necesidad de analizadores personalizados.
El servidor publica más de 50 herramientas listas para usar, desde URL genéricas hasta scrapers específicos para el sector inmobiliario, para que su agente de CrewAI pueda recuperar detalles de propiedades, datos de mercado o información de listados con una sola llamada.
Qué estamos construyendo: Agentes inmobiliarios
Vamos a construir un agente inmobiliario CrewAI que investigará propiedades inmobiliarias de la página Zillow y devolverá los detalles como una salida JSON estructurada.
Puede utilizarlo para otras propiedades cambiando el enlace y algunas partes del código.
Requisitos previos:
Antes de sumergirte en el código, asegúrate de tener la siguiente configuración:
- Python 3.11 – Recomendado por estabilidad.
- Node.js + npm – Necesario para ejecutar el servidor de Bright Data Web MCP; descárguelo del sitio oficial.
- Entorno virtual Python – Mantiene las dependencias aisladas; consulte la documentación de
venv. - Cuenta de Bright Data: regístrese y cree un token de API (hay disponibles créditos de prueba gratuitos).
- Clave API de Nebius – Cree una clave en Nebius AI Studio (haga clic en + Obtener clave API). Puede utilizarla de forma gratuita. No se requiere perfil de facturación.
Paso 1. Configuración del entorno:
Ejecute los siguientes comandos en su terminal para configurar el entorno del proyecto e instalar las dependencias:
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
Crea un nuevo archivo llamado real_estate_agents.py y añade las siguientes importaciones:
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()
Paso 2. Configuración del servidor MCP de Brightdata
Crea un archivo .env en la raíz de tu proyecto con tus credenciales:
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"
Lo necesitas:
- Token de API: Genere un nuevo token de API desde su panel de Bright Data.
- Zona Web Unlocker: Crear una nueva zona Web Unlocker para sitios inmobiliarios.
- Zona API del navegador: Cree una nueva zona Browser API para sitios de propiedades con mucho JavaScript.
- Clave API de Nebius: Ya creada en Requisitos previos
Añada esta configuración a su archivo 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"),
},
)
Esto lanza *npx @brightdata/mcp* como subproceso y expone más de 50 herramientas a través del estándar MCP para la extracción de datos inmobiliarios.
Paso 3. Definición de agentes y tareas Definición de agentes y tareas
Aquí definimos la persona del agente y la tarea específica que debe realizar. Cuando implementes CrewAI, prioriza el diseño de tareas, dedicándole aproximadamente el 80% de tu esfuerzo, y destina sólo el 20% a definir tus agentes. Actualiza el archivo real_estate_agents.py para añadir las definiciones de agentes y tareas:
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,
)
Esto es lo que hace cada parámetro:
- rol – Título corto del trabajo, CrewAI inyecta el parámetro @role en cada pregunta del sistema.
- meta – Meta norte-estrella; CrewAI la compara después de cada paso de bucle para decidir si se detiene.
- backstory – Conocimiento del dominio que ayuda a guiar el tono del agente y reduce la alucinación.
- tools – Inyectar lista de objetos BaseTool (por ejemplo, MCP search_engine, scrape_as_markdown).
- llm – definición del modelo que CrewAI utilizará para cada rutina pensar → planificar → actuar → responder.
- max_iter – Límite máximo del número de bucles internos que puede realizar el agente – v0.30 + utiliza 20 por defecto.
- verbose – Transmite cada pregunta, cada pensamiento, cada llamada a la herramienta a stdout (para depuración).
- descripción – En cada turno se inyecta una instrucción orientada a la acción.
- expected_output – Un contrato formal para una respuesta válida (JSON estricto, sin coma a continuación).
- agent – Vincula esta tarea a una instancia de agente específica para Crew.kickoff().
Paso 4. Reunión y ejecución de la tripulación
Esta parte ensambla el agente y la tarea en un Crew y ejecuta el flujo de trabajo. Añade el script de ensamblaje y ejecución del Crew al archivo 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)}")
Paso 5. Funcionamiento del rascador
Ejecute el comando para ejecutar el script desde su terminal:
python real_estate_agents.py
Verá el proceso de pensamiento del agente en la consola a medida que cada agente planifica y ejecuta sus tareas.
El resultado final será un objeto JSON limpio:
{
"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"
}
Patrón de aplicación avanzada
Aunque nuestro ejemplo básico muestra las ideas fundamentales, las aplicaciones en el mundo real requieren más reflexión:
Análisis de mercado y generación de contactos
La creación de inteligencia de mercado requiere agentes capaces de analizar tendencias, identificar oportunidades y generar clientes potenciales cualificados. Estos agentes colaboran para ofrecer información exhaustiva sobre el mercado e identificar clientes potenciales.
Añada estos agentes de análisis de mercado a su archivo 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()
Interacción y comunicación con el cliente
Una gestión eficaz de los clientes requiere agentes especializados que se ocupen de las comunicaciones, programen citas y mantengan relaciones a lo largo de todo el proceso inmobiliario. Estos agentes garantizan un servicio al cliente coherente y profesional.
Añada estos agentes de gestión de clientes a su archivo 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()
Listado de propiedades y automatización del marketing
La automatización del marketing requiere agentes especializados que puedan crear anuncios atractivos, optimizarlos para los motores de búsqueda y distribuirlos a través de múltiples plataformas.
Añada este agente de marketing a su archivo 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,
)
Funciones de búsqueda y descubrimiento
Los sistemas inteligentes de búsqueda y recomendación de propiedades permiten a los clientes encontrar propiedades que se ajustan con precisión a sus necesidades y preferencias específicas. Estos agentes ofrecen servicios personalizados de búsqueda y recomendación de propiedades.
Añada estos agentes de búsqueda y descubrimiento a su archivo 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()
Despliegue y puesta en producción
Por último, vamos a crear un sistema de orquestación integral que coordine a todos nuestros agentes especializados. Esta clase de sistema primario servirá como eje central de todas las operaciones inmobiliarias.
Añada esta orquestación del sistema principal a su archivo 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()
Optimización de costes
El MCP de Bright Data se basa en el uso, por lo que se le facturará por cada solicitud adicional que realice. Estos son algunos consejos que le ayudarán a mantener los costes bajo control:
- Solicite sólo los campos de propiedad que necesite en lugar de rastrear sitios de listados o conjuntos de datos enteros.
- Habilite la caché a nivel de herramienta de CrewAI para omitir llamadas cuando los datos de propiedad no hayan cambiado, ahorrando tiempo y créditos.
- Utilice por defecto la zona Web Unlocker y cambie a la zona Browser API sólo cuando la renderización de JavaScript sea esencial para sitios de propiedades complejas.
- Asigne a cada agente un límite máximo de iteración razonable para que no pueda repetir eternamente los listados problemáticos.
Siga estas prácticas y sus agentes CrewAI se mantendrán rentables y fiables, listos para las cargas de trabajo de producción inmobiliaria.
Conclusión
A lo largo de este tutorial, ha aprendido a crear agentes inmobiliarios CrawAI utilizando el servidor MCP de Bright Data.
Empezamos por entender qué son estas tecnologías y cómo se utilizan. Luego fuimos más allá para construir el agente inmobiliario. Configuramos el servidor MCP de Bright Data, configuramos el LLM, creamos agentes, definimos tareas y montamos el task Crew.
Puedes adaptar fácilmente estos agentes a otros objetivos inmobiliarios. Por ejemplo, para hacer scraping de Realtor.com en lugar de Zillow, todo lo que tienes que hacer es modificar la función, el objetivo y la historia de fondo de tu agente, junto con la descripción de la tarea y lo que esperas como resultado.
