Die Immobilienbranche befindet sich im Umbruch, da intelligente Roboter und KI-Systeme die manuelle Arbeit vollständig ersetzen. Unternehmen in der Immobilienbranche haben oft mit uneinheitlichen Datensätzen, arbeitsintensiven Analysen und enormen Skalierungsgrenzen zu kämpfen. Doch was wäre, wenn es ein solches System gäbe, das mitdenkt, sich anpasst und selbstständig komplette Immobiliendienstleistungen erbringt?
Das erfahren Sie in diesem Leitfaden:
- Wie moderne KI-Agenten-Frameworks, die in eine Web-Scraping-Infrastruktur integriert sind, diese Probleme lösen.
- Wie man einen modernen Immobilienmakler mit CrewAI und dem MCP-Server von Bright Data erstellt.
Fangen wir an!
Was ist CrewAI?
CrewAI ist ein Open-Source-Framework für die Orchestrierung kollaborativer KI-Agenten. Mit CrewAI können Sie explizit festlegen, was ein Agent tun kann, welche Ziele er verfolgt und welche Tools er verwenden darf. Dies ermöglicht die Ausführung komplexer, mehrstufiger Workflows in der Immobilienbranche, indem Agenten in Teams oder Crews gruppiert werden.
CrewAI setzt sich aus diesen wesentlichen Komponenten zusammen:
- Agent. Ein LLM-gesteuerter Mitarbeiter mit einer definierten Rolle, einem spezifischen Ziel und einer optionalen Hintergrundgeschichte. Der Kontext der Immobiliendomäne ist für das Modell relevant.
- Aufgabe. Ein einzelner, klar begrenzter Auftrag für einen Agenten, der einen klar definierten Output hat, der als Maßstab für die Qualitätskontrolle dient.
- Werkzeug. Private Funktionen, die ein Makler für bereichsspezifische Funktionen aufrufen kann, wie z. B. das Abrufen von Immobiliendaten oder Marktanalysen, oder sogar die Verwendung des MCP-Endpunkts von Bright Data für Scraping.
- Mannschaft. Ein Immobilienobjektiv besteht aus einer Gruppe von Maklern, die zusammenarbeiten, wobei jeder von ihnen die ihm zugewiesenen Aufgaben erfüllt.
- Prozess. Der Ausführungsplan, der sequentiell, parallel oder hierarchisch erstellt werden kann, regelt die Reihenfolge der Aufgaben, ihre Zuweisung, Delegation und Wiederholung.
Dies spiegelt ein Immobilienteam wider: Immobilienforscher kümmern sich um die Datenextraktion, Marktanalysten liefern Einblicke, Kundenbetreuer kümmern sich um die Kommunikation und Listing-Spezialisten um das Marketing.
Wenn Sie mehr über die Integration von CrawAI mit Tools wie Bright Data erfahren möchten, lesen Sie diesen Leitfaden.
Was ist MCP?
MCP ist ein offener JSON-RPC 2.0-Standard, mit dem KI-Agenten externe Tools und Datenquellen über eine einzige, strukturierte Schnittstelle aufrufen können. Betrachten Sie es als universellen Konnektor für Immobiliendaten.
Der MCP-Server von Bright Data setzt diesen Standard in die Praxis um, indem er einen Agenten direkt mit dem Scraping-Stack von Bright Data verbindet, wodurch die Extraktion von Immobiliendaten weitaus einfacher wird als bei herkömmlichen Ansätzen:
- Umgehung von Anti-Bots. Anfragen fließen durch Web Unlocker und einen Pool von mehr als 150 Mio. rotierenden privaten IPs aus 195 Ländern.
- Unterstützung für dynamische Websites. Ein speziell entwickelter Scraping-Browser rendert JavaScript, so dass Agenten vollständig geladene Immobilienangebote sehen.
- Strukturierte Ergebnisse. Viele Tools liefern sauberes JSON, so dass keine benutzerdefinierten Parser erforderlich sind.
Der Server veröffentlicht über 50 vorgefertigte Tools, die von allgemeinen URL-Abfragen bis hin zu immobilienspezifischen Scrapern reichen, so dass Ihr CrewAI-Agent mit einem einzigen Aufruf Immobiliendetails, Marktdaten oder Angebotsinformationen abrufen kann.
Was wir bauen: Immobilienmakler
Wir werden einen CrewAI-Immobilienmakler bauen, der Immobilien auf der Zillow-Seite recherchiert und die Details als strukturierte JSON-Ausgabe zurückgibt.
Sie können es für andere Eigenschaften verwenden, indem Sie den Link und einige Teile des Codes ändern.
Voraussetzungen:
Bevor Sie in den Code eintauchen, stellen Sie sicher, dass Sie die folgenden Einstellungen vorgenommen haben:
- Python 3.11 – Empfohlen für Stabilität.
- Node.js + npm – Erforderlich für die Ausführung des Bright Data Web MCP-Servers; Download von der offiziellen Website.
- Virtuelle Python-Umgebung – Hält Abhängigkeiten isoliert; siehe die
venv-Dokumente. - Bright Data-Konto – Melden Sie sich an und erstellen Sie ein API-Token (kostenlose Testkredite sind verfügbar).
- Nebius API Schlüssel – Erstellen Sie einen Schlüssel in Nebius AI Studio (klicken Sie auf + Get API Key). Sie können ihn kostenlos verwenden. Es ist kein Abrechnungsprofil erforderlich.
Schritt 1. Umgebung einrichten:
Führen Sie die folgenden Befehle in Ihrem Terminal aus, um die Projektumgebung einzurichten und die Abhängigkeiten zu installieren:
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
Erstellen Sie eine neue Datei namens real_estate_agents.py und fügen Sie die folgenden Importe hinzu:
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()
Schritt 2. Konfiguration des Brightdata MCP-Servers
Erstellen Sie in Ihrem Projektstamm eine .env-Datei mit Ihren Anmeldedaten:
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"
Sie benötigen:
- API-Token: Generieren Sie ein neues API-Token über Ihr Bright Data-Dashboard
- Web Unlocker Zone: Erstellen Sie eine neue Web Unlocker Zone für Immobilienseiten
- Browser-API-Zone: Erstellen Sie eine neue Browser-API-Zone für JavaScript-lastige Immobilienseiten
- Nebius-API-Schlüssel: Bereits erstellt in Voraussetzungen
Fügen Sie diese Konfiguration zu Ihrer Datei real_estate_agents.py hinzu:
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"),
},
)
Dies startet *npx @brightdata/mcp* als Unterprozess und stellt über den MCP-Standard mehr als 50 Tools für die Extraktion von Immobiliendaten zur Verfügung.
Schritt 3. Definition von Agenten und Aufgaben
Hier definieren wir die Persona des Agenten und die spezifische Aufgabe, die er erfüllen muss. Wenn Sie CrewAI implementieren, sollten Sie dem Entwurf von Aufgaben Priorität einräumen und etwa 80 % Ihres Aufwands darauf verwenden, während Sie nur 20 % für die Definition Ihrer Agenten aufwenden. Aktualisieren Sie die Datei real_estate_agents.py, um Agenten- und Aufgabendefinitionen hinzuzufügen:
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,
)
Nachfolgend wird die Funktion der einzelnen Parameter erläutert:
- role – Kurze Berufsbezeichnung, CrewAI fügt den Parameter @role in jede Systemabfrage ein.
- goal – Nord-Stern-Ziel; CrewAI vergleicht es nach jedem Schleifenschritt, um zu entscheiden, ob angehalten werden soll.
- Hintergrundgeschichte – Fachwissen, das den Ton des Agenten bestimmt und Halluzinationen reduziert.
- tools – Injizieren einer Liste von BaseTool-Objekten (z. B. MCP search_engine, scrape_as_markdown).
- llm – Definition des Modells, das CrewAI für jede Think → Plan → Act → Answer-Routine verwendet.
- max_iter – Harte Obergrenze für die Anzahl der internen Schleifen, die der Agent ausführen kann – v0.30 + verwendet standardmäßig 20.
- verbose – Streamt jede Eingabeaufforderung, jeden Gedanken, jeden Werkzeugaufruf nach stdout (zur Fehlersuche).
- Beschreibung – Bei jedem Zug wird eine handlungsorientierte Anweisung gegeben.
- expected_output – Ein formaler Vertrag für eine gültige Antwort (strict JSON, kein nachfolgendes Komma).
- agent – Bindet diese Aufgabe an eine bestimmte Agent-Instanz für Crew.kickoff().
Schritt 4. Zusammenstellung der Crew und Durchführung
Dieser Teil stellt den Agenten und die Aufgabe zu einer Crew zusammen und führt den Arbeitsablauf aus. Fügen Sie das Skript für die Zusammenstellung und Ausführung der Crew zur Datei real_estate_agents.py hinzu:
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)}")
Schritt 5. Ausführen des Abstreifers
Führen Sie den Befehl aus, um das Skript über Ihr Terminal auszuführen:
python real_estate_agents.py
In der Konsole sehen Sie den Denkprozess der Agenten, wie sie ihre Aufgaben planen und ausführen.
Die endgültige Ausgabe wird ein sauberes JSON-Objekt sein:
{
"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"
}
Erweiterte Implementierungsmuster
Unser grundlegendes Beispiel zeigt zwar die Kernideen, aber die realen Anwendungen erfordern mehr Überlegungen:
Marktanalyse und Lead-Generierung
Der Aufbau von Marktkenntnissen erfordert Mitarbeiter, die Trends analysieren, Chancen erkennen und qualifizierte Leads generieren können. Diese Agenten arbeiten zusammen, um umfassende Markteinblicke zu liefern und potenzielle Kunden zu identifizieren.
Fügen Sie diese Marktanalyse-Agenten zu Ihrer Datei real_estate_agents.py hinzu:
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()
Kundeninteraktion und Kommunikation
Ein effektives Kundenmanagement erfordert spezialisierte Agenten, die die Kommunikation übernehmen, Termine planen und die Beziehungen während des gesamten Immobilienprozesses pflegen können. Diese Agenten gewährleisten einen konsistenten, professionellen Kundenservice.
Fügen Sie diese Client-Management-Agenten zu Ihrer Datei real_estate_agents.py hinzu:
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()
Immobilienauflistung und Marketing-Automatisierung
Die Marketing-Automatisierung erfordert spezialisierte Agenten, die überzeugende Angebote erstellen, sie für Suchmaschinen optimieren und über mehrere Plattformen verbreiten können.
Fügen Sie diesen Vermarktungsagenten zu Ihrer Datei real_estate_agents.py hinzu:
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,
)
Such- und Entdeckungsfunktionen
Intelligente Immobiliensuch- und Empfehlungssysteme ermöglichen es den Kunden, Immobilien zu finden, die genau ihren spezifischen Bedürfnissen und Vorlieben entsprechen. Diese Agenten bieten personalisierte Dienste zur Immobiliensuche und -empfehlung.
Fügen Sie diese Such- und Erkennungsagenten zu Ihrer Datei real_estate_agents.py hinzu:
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()
Bereitstellung und Produktionseinrichtung
Schließlich wollen wir ein umfassendes Orchestrierungssystem schaffen, das alle unsere spezialisierten Agenten koordiniert. Diese primäre Systemklasse wird als zentraler Knotenpunkt für alle Immobilienoperationen dienen.
Fügen Sie diese Hauptsystem-Orchestrierung zu Ihrer Datei real_estate_agents.py hinzu:
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()
Optimierung der Kosten
Der MCP von Bright Data ist nutzungsabhängig, d. h. jede zusätzliche Anfrage wird Ihnen in Rechnung gestellt. Hier sind einige Tipps, die Ihnen helfen, die Kosten in Grenzen zu halten:
- Fordern Sie nur die Immobilienfelder an, die Sie benötigen, anstatt ganze Websites oder Datensätze zu durchsuchen.
- Aktivieren Sie den CrewAI-Cache auf Werkzeugebene, um Aufrufe zu überspringen, wenn sich die Eigenschaftsdaten nicht geändert haben, und so Zeit und Credits zu sparen.
- Wählen Sie standardmäßig die Web Unlocker-Zone und wechseln Sie nur dann in die Browser-API-Zone, wenn das JavaScript-Rendering für komplexe Immobilienseiten unerlässlich ist.
- Geben Sie jedem Agenten eine sinnvolle Höchstgrenze für die Iteration vor, damit er sich nicht ewig mit problematischen Angeboten herumschlagen muss.
Wenn Sie diese Praktiken befolgen, bleiben Ihre CrewAI Agenten kosteneffizient und zuverlässig und sind bereit für den Einsatz in der Immobilienbranche.
Schlussfolgerung
In diesem Lernprogramm haben Sie gelernt, wie Sie CrawAI-Immobilienmakler mithilfe des MCP-Servers von Bright Data erstellen können.
Wir begannen damit, zu verstehen, was diese Technologien sind und wie sie verwendet werden. Dann gingen wir weiter und bauten den Immobilienmakler auf. Wir richteten den MCP-Server von Bright Data ein, konfigurierten den LLM, erstellten Agenten, definierten Aufgaben und bauten die Aufgaben-Crew zusammen.
Sie können diese Agenten leicht an andere Immobilienziele anpassen. Um zum Beispiel von Realtor.com statt von Zillow zu scrapen, müssen Sie nur die Rolle, das Ziel und die Hintergrundgeschichte Ihres Agenten sowie die Aufgabenbeschreibung und die erwarteten Ergebnisse anpassen.
