major changes

.gitignore

@@ -0,0 +1,2 @@
+qwen2.5-1.5b-instruct-q4_k_m.gguf
+qwen2.5-1.5b-instruct-q5_k_m.gguf

app.py

@@ -3,152 +3,215 @@ import threading
 import asyncio
 import json
 import re
+import random
+import time
+import pickle
+import numpy as np
+import requests  # For llama.cpp server calls
 from datetime import datetime
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect
-
-# ------------------------ Chatbot Code (Unmodified) ------------------------
-
 from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
 from langgraph.graph import StateGraph, START, END
-# from langchain_ollama import ChatOllama
 import faiss
 from sentence_transformers import SentenceTransformer
-import pickle
-import numpy as np
-from tools import extract_json_from_response, apply_filters_partial, rule_based_extract, format_property_data, estateKeywords
-import random
+from tools import extract_json_from_response, apply_filters_partial, rule_based_extract, structured_property_data, estateKeywords, sendTokenViaSocket
+from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.tools import tool
 from langchain_core.callbacks import StreamingStdOutCallbackHandler, CallbackManager
 from langchain_core.callbacks.base import BaseCallbackHandler
 
-# ------------------------ Custom Callback for WebSocket Streaming ------------------------
+# ------------------------ Model Inference Wrapper ------------------------
 
-class WebSocketStreamingCallbackHandler(BaseCallbackHandler):
-    def __init__(self, connection_id: str, loop):
-        self.connection_id = connection_id
-        self.loop = loop
-
-    def on_llm_new_token(self, token: str, **kwargs):
-        asyncio.run_coroutine_threadsafe(
-            manager_socket.send_message(self.connection_id, token),
-            self.loop
-        )
-
-
-from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
-
-class ChatHuggingFace:
-    def __init__(self, model, token="", temperature=0.3, streaming=False):
-        # Instead of using InferenceClient, load the model locally.
+class ChatQwen:
+    """
+    A chat wrapper for Qwen using llama.cpp.
+    This class can work in two modes:
+      - Local: Using a llama-cpp-python binding (gguf model file loaded locally).
+      - Server: Calling a remote llama.cpp server endpoint.
+    """
+    def __init__(
+        self,
+        temperature=0.3,
+        streaming=False,
+        max_new_tokens=512,
+        callbacks=None,
+        use_server=False,
+        model_path: str = None,
+        server_url: str = None
+    ):
         self.temperature = temperature
         self.streaming = streaming
-        self.tokenizer = AutoTokenizer.from_pretrained(model)
-        self.model = AutoModelForCausalLM.from_pretrained(model)
-        self.pipeline = pipeline("text-generation", model=self.model, tokenizer=self.tokenizer)
-    
-    def invoke(self, messages, config=None):
-        """
-        Mimics the ChatOllama.invoke interface.
-        In streaming mode, token-by-token output is sent via callbacks.
-        Otherwise, returns a single aggregated response.
-        """
-        config = config or {}
-        callbacks = config.get("callbacks", [])
-        aggregated_response = ""
+        self.max_new_tokens = max_new_tokens
+        self.callbacks = callbacks
+        self.use_server = use_server
+
+        if self.use_server:
+            # Use remote llama.cpp server – provide its URL.
+            self.server_url = server_url or "http://localhost:8000"
+        else:
+            # For local inference, a model_path must be provided.
+            if not model_path:
+                raise ValueError("Local mode requires a valid model_path to the gguf file.")
+            from llama_cpp import Llama  # assumes llama-cpp-python is installed
+            self.model = Llama(
+                model_path=model_path,
+                temperature=self.temperature,
+                # n_ctx=512,
+                n_ctx=2048,
+                n_threads=4,  # Adjust as needed
+                batch_size=512,
+            )
 
-        # Build the prompt by concatenating messages in the expected format.
+    def build_prompt(self, messages: list) -> str:
+        """Build Qwen-compatible prompt with special tokens."""
         prompt = ""
         for msg in messages:
-            role = msg.get("role", "")
-            content = msg.get("content", "")
+            role = msg["role"]
+            content = msg["content"]
             if role == "system":
-                prompt += f"<|im_start|>system\n{content}\n<|im_end|>\n"
+                prompt += f"<|im_start|>system\n{content}<|im_end|>\n"
             elif role == "user":
-                prompt += f"<|im_start|>user\n{content}\n<|im_end|>\n"
+                prompt += f"<|im_start|>user\n{content}<|im_end|>\n"
             elif role == "assistant":
-                prompt += f"<|im_start|>assistant\n{content}\n<|im_end|>\n"
+                prompt += f"<|im_start|>assistant\n{content}<|im_end|>\n"
+        prompt += "<|im_start|>assistant\n"
+        return prompt
 
+    def generate_text(self, messages: list) -> str:
+        prompt = self.build_prompt(messages)
+        stop_tokens = ["<|im_end|>", "\n"]  # Qwen's stop sequences
+        
+        if self.use_server:
+            payload = {
+                "prompt": prompt,
+                "max_tokens": self.max_new_tokens,
+                "temperature": self.temperature,
+                "stream": self.streaming,
+                "stop": stop_tokens  # Add stop tokens to server request
+            }
+            if self.streaming:
+                response = requests.post(f"{self.server_url}/generate", json=payload, stream=True)
+                generated_text = ""
+                for line in response.iter_lines():
+                    if line:
+                        token = line.decode("utf-8")
+                        # Check for stop tokens in stream
+                        if any(stop in token for stop in stop_tokens):
+                            break
+                        generated_text += token
+                        if self.callbacks:
+                            for callback in self.callbacks:
+                                callback.on_llm_new_token(token)
+                return generated_text
+            else:
+                response = requests.post(f"{self.server_url}/generate", json=payload)
+                return response.json().get("generated_text", "")
+        else:
+            # Local llama.cpp inference
+            if self.streaming:
+                stream = self.model.create_completion(
+                    prompt=prompt,
+                    max_tokens=self.max_new_tokens,
+                    temperature=self.temperature,
+                    stream=True,
+                    stop=stop_tokens
+                )
+                generated_text = ""
+                for token_chunk in stream:
+                    token_text = token_chunk["choices"][0]["text"]
+                    # Stop early if we detect end token
+                    if any(stop in token_text for stop in stop_tokens):
+                        break
+                    generated_text += token_text
+                    if self.callbacks:
+                        for callback in self.callbacks:
+                            callback.on_llm_new_token(token_text)
+                return generated_text
+            else:
+                result = self.model.create_completion(
+                    prompt=prompt,
+                    max_tokens=self.max_new_tokens,
+                    temperature=self.temperature,
+                    stop=stop_tokens
+                )
+                return result["choices"][0]["text"]
+
+    def invoke(self, messages: list, config: dict = None) -> AIMessage:
+        config = config or {}
+        callbacks = config.get("callbacks", self.callbacks)
+        original_callbacks = self.callbacks
+        self.callbacks = callbacks
+
+        output_text = self.generate_text(messages)
+        self.callbacks = original_callbacks
+
+        # In streaming mode we return an empty content as tokens are being sent via callbacks.
         if self.streaming:
-            # Generate text locally.
-            full_output = self.pipeline(
-                prompt,
-                max_new_tokens=100,
-                do_sample=True,
-                temperature=self.temperature
-            )[0]['generated_text']
-            # Assume the pipeline returns the prompt + generated text.
-            new_text = full_output[len(prompt):]
-            # Simulate token-by-token streaming.
-            for token in new_text.split():
-                aggregated_response += token + " "
-                for cb in callbacks:
-                    cb.on_llm_new_token(token=token + " ")
-            return type("AIMessage", (object,), {"content": aggregated_response.strip()})
+            return AIMessage(content="")
         else:
-            # Non-streaming mode.
-            response = self.pipeline(
-                prompt,
-                max_new_tokens=100,
-                do_sample=True,
-                temperature=self.temperature
-            )[0]['generated_text']
-            new_text = response[len(prompt):]
-            return type("AIMessage", (object,), {"content": new_text.strip()})
-
-
-
-
-# ------------------------ LLM and Data Setup ------------------------
-# model_name="qwen2.5:1.5b"
-model_name="Qwen/Qwen2.5-1.5B-Instruct"
-# llm = ChatOllama(model=model_name, temperature=0.3, streaming=True)
-llm = ChatHuggingFace(
-    model=model_name,
-    # token=token
+            return AIMessage(content=output_text)
+
+    def __call__(self, messages: list) -> AIMessage:
+        return self.invoke(messages)
+
+# ------------------------ Callback for WebSocket Streaming ------------------------
+
+class WebSocketStreamingCallbackHandler(BaseCallbackHandler):
+    def __init__(self, connection_id: str, loop):
+        self.connection_id = connection_id
+        self.loop = loop
+
+    def on_llm_new_token(self, token: str, **kwargs):
+        asyncio.run_coroutine_threadsafe(
+            manager_socket.send_message(self.connection_id, token),
+            self.loop
+        )
+
+# ------------------------ Instantiate the LLM ------------------------
+# Choose one mode: local (set use_server=False) or server (set use_server=True).
+model_path="qwen2.5-1.5b-instruct-q4_k_m.gguf"
+llm = ChatQwen(
     temperature=0.3,
-    streaming=True  # or True, based on your needs
+    streaming=True,
+    max_new_tokens=512,
+    use_server=False,
+    model_path=model_path,
+    # server_url="http://localhost:8000"  # Uncomment and set if using server mode.
 )
 
+# ------------------------ FAISS and Sentence Transformer Setup ------------------------
+
 index = faiss.read_index("./faiss.index")
 with open("./metadata.pkl", "rb") as f:
     docs = pickle.load(f)
 st_model = SentenceTransformer('all-MiniLM-L6-v2')
 
-
 def make_system_prompt(suffix: str) -> str:
     return (
-        "You are EstateGuru, a real estate expert created by Abhishek Pathak from SwavishTek. "
-        "Your role is to help customers buy properties using the available data. "
-        "Only use the provided data—do not make up any information. "
-        "The default currency is AED. If a query uses a different currency, convert the amount to AED "
-        "(for example, $10k becomes 36726.50 AED and $1 becomes 3.67 AED). "
-        "If a customer is interested in a property, wants to buy, or needs to contact an agent or customer care, "
-        "instruct them to call +91 8766268285."
+        "You are EstateGuru, a real estate expert developed by Abhishek Pathak at SwavishTek. "
+        "Your role is to help customers buy properties using only the provided data—do not invent any details. "
+        "The default currency is AED; if a query mentions another currency, convert the amount to AED "
+        "(for example, convert $10k to 36726.50 AED and $1 to 3.67 AED). "
+        "If a customer is interested in a property or needs to contact an agent, instruct them to call +91 8766268285. "
+        "Keep your answers short, clear, and concise."
         f"\n{suffix}"
     )
 
 general_query_prompt = make_system_prompt(
-    "You are EstateGuru, a helpful real estate assistant. Answer the user's query accurately using the available data. "
-    "Do not invent any details or go beyond the real estate domain. "
-    "If the user shows interest in a property or contacting an agent, ask them to call +91 8766268285."
+    "You are EstateGuru, a helpful real estate assistant. "
+    "Please respond only in English. "
+    "Convert any prices to USD before answering. "
+    "Provide a brief, direct answer without extra details."
 )
 
-
-
 # ------------------------ Tool Definitions ------------------------
 
 @tool
 def extract_filters(query: str) -> dict:
-    """For extracting filters"""
-    # llm_local = ChatOllama(model=model_name, temperature=0.3)
-    llm_local = ChatHuggingFace(
-        model=model_name,
-        # token=token,
-        temperature=0.3,
-        streaming=False
-    )
+    """Extract filters from the query."""
+    llm_local = ChatQwen(temperature=0.3, streaming=False, use_server=False, model_path=model_path)
     system = (
-        "You are an expert in extracting filters from property-related queries. Your task is to extract and return only the keys explicitly mentioned in the query as a valid JSON object (starting with '{{' and ending with '}}'). Include only those keys that are directly present in the query.\n\n"
+        "You are an expert in extracting filters from property-related queries. Your task is to extract and return only the keys explicitly mentioned in the query as a valid JSON object (starting with '{' and ending with '}'). Include only those keys that are directly present in the query.\n\n"
         "The possible keys are:\n"
         "  - 'projectName': The name of the project.\n"
         "  - 'developerName': The developer's name.\n"
@@ -182,7 +245,7 @@ def extract_filters(query: str) -> dict:
         "Example:\n"
         "  For the query: \"properties near dubai mall under 43k\"\n"
         "  The expected output should be:\n"
-        "    {{ \"surroundingArea\": \"dubai mall\", \"totalCosts\": 43000 }}\n\n"
+        "    { \"surroundingArea\": \"dubai mall\", \"totalCosts\": 43000 }\n\n"
         "Return ONLY a valid JSON object with the extracted keys and their corresponding values, with no additional text."
     )
 
@@ -207,88 +270,63 @@ def extract_filters(query: str) -> dict:
 
 @tool
 def determine_route(query: str) -> dict:
-    """For determining route using enhanced prompt and fallback logic."""
-    # Define a set of keywords that are strong indicators of a real estate query.
+    """Determine the route (search, suggest, detail, general, out_of_domain) for the query."""
     real_estate_keywords = estateKeywords
-    
-    # Check if the query includes any of the positive signals.
     pattern = re.compile("|".join(re.escape(keyword) for keyword in real_estate_keywords), re.IGNORECASE)
     positive_signal = bool(pattern.search(query))
-    
-    # Proceed with LLM classification regardless, but use the positive signal in fallback.
-    # llm_local = ChatOllama(model=model_name, temperature=0.3)
-    llm_local = ChatHuggingFace(
-        model=model_name,
-        # token=token,
-        temperature=0.3,
-        streaming=False
-    )
+
+    llm_local = ChatQwen(temperature=0.3, streaming=False, use_server=False, model_path=model_path)
     transform_suggest_to_list = query.lower().replace("suggest ", "list ", -1)
     system = """
     Classify the user query as:
     
     - **"search"**: if it requests property listings with specific filters (e.g., location, price, property type like "2bhk", service charges, pet policies, etc.).
     - **"suggest"**: if it asks for property suggestions without filters.
-    - **"detail"**: if it is asking for more information about a previously provided property (e.g., "tell me more about property 5" or "I want more information regarding 4BHK").
+    - **"detail"**: if it is asking for more information about a previously provided property (for example, "tell me more about property 5" or "I want more information regarding 4BHK").
     - **"general"**: for all other real estate-related questions.
     - **"out_of_domain"**: if the query is not related to real estate (for example, tourist attractions, restaurants, etc.).
     
     Keep in mind that queries mentioning terms like "service charge", "allow pets", "pet rules", etc., are considered real estate queries.
+    When user asks about you (for example, "who you are", "who made you" etc.) consider as general.
     
     Return only the keyword: search, suggest, detail, general, or out_of_domain.
     """
     human_str = f"Here is the query:\n{transform_suggest_to_list}"
-    filter_prompt = [
+    router_prompt = [
         {"role": "system", "content": system},
         {"role": "user", "content": human_str},
     ]
-    response = llm_local.invoke(messages=filter_prompt)
+    
+    response = llm_local.invoke(messages=router_prompt)
     response_text = response.content if isinstance(response, AIMessage) else str(response)
     route_value = str(response_text).strip().lower()
-    
-    # Fallback: if no positive real estate signal is found, override to out_of_domain.
-    # if not positive_signal:
-    #     route_value = "out_of_domain"
-    
-    # Fallback
+
+    # --- NEW: Force 'detail' if query explicitly mentions a specific property (e.g., "property 2") ---
+    property_detail_pattern = re.compile(r"property\s+\d+", re.IGNORECASE)
+    if property_detail_pattern.search(query):
+        route_value = "detail"
+
+    # Fallback override if query appears detailed.
     detail_phrases = [
-    "more information",
-    "tell me more",
-    "more details",
-    "give me more details",
-    "I need more details",
-    "can you provide more details",
-    "additional details",
-    "further information",
-    "expand on that",
-    "explain further",
-    "elaborate more",
-    "more specifics",
-    "I want to know more",
-    "could you elaborate",
-    "need more info",
-    "provide more details",
-    "detail it further",
-    "in-depth information",
-    "break it down further",
-    "further explanation"
+        "more information", "tell me more", "more details", "give me more details",
+        "i need more details", "can you provide more details", "additional details",
+        "further information", "expand on that", "explain further", "elaborate more",
+        "more specifics", "i want to know more", "could you elaborate", "need more info",
+        "provide more details", "detail it further", "in-depth information", "break it down further",
+        "further explanation", "property 1", "property1", "first property", "about the 2nd", "regarding number 3"
     ]
-
     if any(phrase in query.lower() for phrase in detail_phrases):
         route_value = "detail"
-    
+
     if route_value not in {"search", "suggest", "detail", "general", "out_of_domain"}:
         route_value = "general"
     if route_value == "out_of_domain" and positive_signal:
         route_value = "general"
-        
     if route_value == "out_of_domain":
-        # If positive real estate signal exists, treat it as "general".
         route_value = "general" if positive_signal else "out_of_domain"
         
     return {"route": route_value}
 
-
 # ------------------------ Workflow Setup ------------------------
 
 workflow = StateGraph(state_schema=dict)
@@ -310,6 +348,8 @@ def hybrid_extract(state: dict) -> dict:
 
 def search_faiss(state: dict) -> dict:
     new_state = state.copy()
+    # Preserve previous properties until new ones are fetched:
+    new_state.setdefault("current_properties", state.get("current_properties", []))
     query_embedding = st_model.encode([state["query"]])
     _, indices = index.search(query_embedding.astype(np.float32), 5)
     new_state["faiss_results"] = [docs[idx] for idx in indices[0] if idx < len(docs)]
@@ -318,11 +358,19 @@ def search_faiss(state: dict) -> dict:
 def apply_filters(state: dict) -> dict:
     new_state = state.copy()
     new_state["final_results"] = apply_filters_partial(state["faiss_results"], state.get("filters", {}))
+    if(len(new_state["final_results"]) == 0):
+        new_state["response"] = "Sorry, There is no result found :("
+        new_state["route"] = "general"
     return new_state
 
 def suggest_properties(state: dict) -> dict:
     new_state = state.copy()
     new_state["suggestions"] = random.sample(docs, 5)
+    # Explicitly update current_properties only when new listings are fetched
+    new_state["current_properties"] = new_state["suggestions"]
+    if(len(new_state["suggestions"]) == 0):
+        new_state["response"] = "Sorry, There is no result found :("
+        new_state["route"] = "general"
     return new_state
 
 def handle_out_of_domain(state: dict) -> dict:
@@ -334,65 +382,48 @@ def handle_out_of_domain(state: dict) -> dict:
 
 def generate_response(state: dict) -> dict:
     new_state = state.copy()
-    detail_query_flag = False
-
-    # --- Disambiguate specific property requests using property number ---
-    property_match = re.search(r"(?:the\s+)?property\s*(\d+)\b", state.get("query", ""), re.IGNORECASE)
-    if property_match and new_state.get("current_properties"):
-        try:
-            index_requested = int(property_match.group(1)) - 1
-            if 0 <= index_requested < len(new_state["current_properties"]):
-                new_state["current_properties"] = [new_state["current_properties"][index_requested]]
-                detail_query_flag = True
-                new_state["detail_query"] = True
-        except Exception as e:
-            print(f"Property selection error: {e}")
-
-    # Construct messages for the LLM.
     messages = []
     
     # Add the general query prompt.
-    messages.append(SystemMessage(content=general_query_prompt))
-    # If this is a detail query, add a system message that forces a detailed answer.
-    if detail_query_flag:
-        messages.append(SystemMessage(content=(
-            "This is a detail query. Please provide detailed information about the property below. "
-            "Do not generate a new list of properties; only use the provided property details to answer the query. "
-            "Focus on answering the specific question (for example, whether pets are allowed)."
-        )))
-    
+    messages.append({"role": "system", "content": general_query_prompt})
     
-    # Provide the current property context.
+    # For detail queries (specific property queries), add extra instructions.
+    if new_state.get("route", "general") == "detail":
+        messages.append({
+            "role": "system",
+            "content": (
+                "The user is asking about a specific property from the numbered list below. "
+                "Properties are listed as 1, 2, 3, etc. Use ONLY the corresponding property details. "
+                "For example, if the user says 'property 2', respond using only the details from the second entry. Never invent data."
+            )
+        })
+        
     if new_state.get("current_properties"):
-        property_context = format_property_data(new_state["current_properties"])
-        messages.insert(0, SystemMessage(content="Available Property:\n" + property_context))
-    
-    # Add the conversation history.
-    for msg in state.get("messages", []):
-        if msg["role"] == "user":
-            messages.append(HumanMessage(content=msg["content"]))
-        else:
-            messages.append(AIMessage(content=msg["content"]))
-    
-    # Instruction for response.
-    messages.append(SystemMessage(content=(
-        "When responding, use only the provided property details to answer the user's specific question about the property."
-    )))
+        # Format properties with indices starting at 1
+        property_context = format_property_data_with_indices(new_state["current_properties"])
+        messages.append({"role": "system", "content": "Available Properties:\n" + property_context})
+        messages.append({"role": "system", "content": "When responding, use only the provided property details."})
     
-    # Invoke the LLM with the constructed messages.
+    # Add conversation history
+    # Truncate conversation history (last 2 exchanges)
+    truncated_history = state.get("messages", [])[-4:]  # Last 2 user+assistant pairs
+    for msg in truncated_history:
+        messages.append({"role": msg["role"], "content": msg["content"]})
+
     connection_id = state.get("connection_id")
     loop = state.get("loop")
     if connection_id and loop:
-        callback_manager = CallbackManager([WebSocketStreamingCallbackHandler(connection_id, loop)])
+        print("Using WebSocket streaming")
+        callback_manager = [WebSocketStreamingCallbackHandler(connection_id, loop)]
         _ = llm.invoke(
-            messages=messages,
+            messages,
             config={"callbacks": callback_manager}
         )
         new_state["response"] = ""
     else:
-        callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])
+        callback_manager = [StreamingStdOutCallbackHandler()]
         response = llm.invoke(
-            messages=messages,
+            messages,
             config={"callbacks": callback_manager}
         )
         new_state["response"] = response.content if isinstance(response, AIMessage) else str(response)
@@ -400,30 +431,50 @@ def generate_response(state: dict) -> dict:
     return new_state
 
 
+def format_property_data_with_indices(properties: list) -> str:
+    formatted = []
+    for idx, prop in enumerate(properties, 1):
+        cost = prop.get("totalCosts", "N/A")
+        cost_str = f"{cost:,}" if isinstance(cost, (int, float)) else cost
+        formatted.append(
+            f"{idx}. Type: {prop['propertyType']}, Cost: AED {cost_str}, "
+            f"Size: {prop.get('propertySize', 'N/A')}, Amenities: {', '.join(prop.get('amenities', []))}, "
+            f"Rental Yield: {prop.get('expectedRentalYield', 'N/A')}, "
+            f"Ownership: {prop.get('ownershipType', 'N/A')}"
+        )
+    return "\n".join(formatted)
+
 
 def format_final_response(state: dict) -> dict:
     new_state = state.copy()
-    # Only override the current_properties if this is NOT a detail query.
-    if not state.get("detail_query", False):
-        if state.get("route") in ["search", "suggest"]:
-            if "final_results" in state:
-                new_state["current_properties"] = state["final_results"]
-            elif "suggestions" in state:
-                new_state["current_properties"] = state["suggestions"]
     
-    # Then format the response based on the (possibly filtered) current_properties.
-    if new_state.get("current_properties"):
-        formatted = []
-        for idx, prop in enumerate(new_state["current_properties"], 1):
-            cost = prop.get("totalCosts", "N/A")
-            cost_str = f"{cost:,}" if isinstance(cost, (int, float)) else cost
-            formatted.append(
-                f"{idx}. Type: {prop['propertyType']}, Cost: AED {cost_str}, "
-                f"Size: {prop.get('propertySize', 'N/A')}, Amenities: {', '.join(map(str, prop.get('amenities', []))) if prop.get('amenities') else 'N/A'}, "
-                f"Rental Yield: {prop.get('expectedRentalYield', 'N/A')}, "
-                f"Ownership: {prop.get('ownershipType', 'N/A')}\n"
-            )
+    if state.get("route") in ["search", "suggest"]:
+        if "final_results" in state:
+            new_state["current_properties"] = state["final_results"]
+        elif "suggestions" in state:
+            new_state["current_properties"] = state["suggestions"]
+    elif "current_properties" in new_state:
+        new_state["current_properties"] = state["current_properties"]
+    
+    
+    # print("state: ", json.dumps(new_state), "\n\n")
+    # Format the property details if available.
+    # if new_state.get("current_properties"):
+    if state.get("route") in ["search", "suggest"] and new_state.get("current_properties"):
+        formatted = structured_property_data(state=new_state)
+        
+        # for idx, prop in enumerate(new_state["current_properties"], 1):
+        #     cost = prop.get("totalCosts", "N/A")
+        #     cost_str = f"{cost:,}" if isinstance(cost, (int, float)) else cost
+        #     formatted.append(
+        #         f"{idx}. Type: {prop['propertyType']}, Cost: AED {cost_str}, "
+        #         f"Size: {prop.get('propertySize', 'N/A')}, Amenities: {', '.join(map(str, prop.get('amenities', []))) if prop.get('amenities') else 'N/A'}, "
+        #         f"Rental Yield: {prop.get('expectedRentalYield', 'N/A')}, "
+        #         f"Ownership: {prop.get('ownershipType', 'N/A')}\n"
+        #     )
         aggregated_response = "Here are the property details:\n" + "\n".join(formatted)
+        # print(aggregated_response)
+        
         connection_id = state.get("connection_id")
         loop = state.get("loop")
         if connection_id and loop:
@@ -439,12 +490,23 @@ def format_final_response(state: dict) -> dict:
         else:
             new_state["response"] = aggregated_response
     elif "response" in new_state:
+        connection_id = state.get("connection_id")
+        loop = state.get("loop")
+        if connection_id and loop:
+            import time
+            tokens = str(new_state["response"]).split(" ")
+            for token in tokens:
+                asyncio.run_coroutine_threadsafe(
+                    manager_socket.send_message(connection_id, token + " "),
+                    loop
+                )
+                time.sleep(0.05)
         new_state["response"] = str(new_state["response"])
+        
     return new_state
 
 
 
-
 nodes = [
     ("route_query", route_query),
     ("hybrid_extract", hybrid_extract),
@@ -485,7 +547,9 @@ workflow_app = workflow.compile()
 
 class ConversationManager:
     def __init__(self):
+        # Each connection gets its own conversation history and state.
         self.conversation_history = []
+        # current_properties stores the current property listing.
         self.current_properties = []
 
     def _add_message(self, role: str, content: str):
@@ -496,7 +560,7 @@ class ConversationManager:
         })
 
     def process_query(self, query: str) -> str:
-        # Reset context on greetings to avoid using off-domain history
+        # For greeting messages, reset history/state. // post request
         if query.strip().lower() in {"hi", "hello", "hey"}:
             self.conversation_history = []
             self.current_properties = []
@@ -515,10 +579,13 @@ class ConversationManager:
             }
             for event in workflow_app.stream(initial_state, stream_mode="values"):
                 final_state = event
-            if 'final_results' in final_state:
-                self.current_properties = final_state['final_results']
-            elif 'suggestions' in final_state:
-                self.current_properties = final_state['suggestions']
+            # Only update property listings if a new listing is fetched
+            # if 'final_results' in final_state:
+            #     self.current_properties = final_state['final_results']
+            # elif 'suggestions' in final_state:
+            #     self.current_properties = final_state['suggestions']
+            self.current_properties = final_state.get("current_properties", [])
+            
             if final_state.get("route") == "general":
                 response_text = final_state.get("response", "")
                 self._add_message("assistant", response_text)
@@ -531,6 +598,8 @@ class ConversationManager:
             print(f"Processing error: {e}")
             return "Sorry, I encountered an error processing your request."
 
+
+
 conversation_managers = {}
 
 # ------------------------ FastAPI Backend with WebSockets ------------------------
@@ -560,24 +629,26 @@ class ConnectionManager:
 
 manager_socket = ConnectionManager()
 
-
-
 def stream_query(query: str, connection_id: str, loop):
     conv_manager = conversation_managers.get(connection_id)
     if conv_manager is None:
         print(f"No conversation manager found for connection {connection_id}")
         return
 
-    # Check for greetings and handle them immediately
     if query.strip().lower() in {"hi", "hello", "hey"}:
         conv_manager.conversation_history = []
         conv_manager.current_properties = []
         greeting_response = "Hello! How can I assist you today with your real estate inquiries?"
         conv_manager._add_message("assistant", greeting_response)
-        asyncio.run_coroutine_threadsafe(
-            manager_socket.send_message(connection_id, greeting_response),
-            loop
+        sendTokenViaSocket(
+            state={"connection_id": connection_id, "loop": loop},
+            manager_socket=manager_socket,
+            message=greeting_response
         )
+        # asyncio.run_coroutine_threadsafe(
+        #     manager_socket.send_message(connection_id, greeting_response),
+        #     loop
+        # )
         return
 
     conv_manager._add_message("user", query)
@@ -590,21 +661,48 @@ def stream_query(query: str, connection_id: str, loop):
         "connection_id": connection_id,
         "loop": loop
     }
+    # try:
+    #     workflow_app.invoke(initial_state)
+    # except Exception as e:
+    #     error_msg = f"Error processing query: {str(e)}"
+    #     asyncio.run_coroutine_threadsafe(
+    #         manager_socket.send_message(connection_id, error_msg),
+    #         loop
+    #     )
     try:
-        workflow_app.invoke(initial_state)
+        # Capture all states during execution
+        # final_state = None
+        # for event in workflow_app.stream(initial_state, stream_mode="values"):
+        #     final_state = event
+        
+        # # Update conversation manager with final state
+        # if final_state:
+        #     conv_manager.current_properties = final_state.get("current_properties", [])
+        #     if final_state.get("response"):
+        #         conv_manager._add_message("assistant", final_state["response"])
+        final_state = None
+        for event in workflow_app.stream(initial_state, stream_mode="values"):
+            final_state = event
+        
+        if final_state:
+            # Always update current_properties from final state
+            conv_manager.current_properties = final_state.get("current_properties", [])
+            # Keep conversation history bounded
+            conv_manager.conversation_history = conv_manager.conversation_history[-6:]  # Last 3 exchanges
+            
     except Exception as e:
         error_msg = f"Error processing query: {str(e)}"
         asyncio.run_coroutine_threadsafe(
             manager_socket.send_message(connection_id, error_msg),
             loop
         )
-
-
-
+        
+        
 
 @app.websocket("/ws")
 async def websocket_endpoint(websocket: WebSocket):
     connection_id = await manager_socket.connect(websocket)
+    # Each connection maintains its own conversation manager.
     conversation_managers[connection_id] = ConversationManager()
     try:
         while True:
@@ -631,3 +729,20 @@ async def post_query(query: str):
     return {"response": response}
 
 
+@app.get("/setup")
+async def setup():
+    import os
+    from huggingface_hub import hf_hub_download
+    repo_id="Qwen/Qwen2.5-1.5B-Instruct-GGUF"
+    filename = "qwen2.5-1.5b-instruct-q4_k_m.gguf"
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    model_path = hf_hub_download(
+        repo_id=repo_id,
+        filename=filename,
+        local_dir=script_dir,
+        local_dir_use_symlinks=False,
+    )
+    return model_path
+
+
+

download.py

@@ -0,0 +1,14 @@
+from huggingface_hub import hf_hub_download
+import os
+
+repo_id="Qwen/Qwen2.5-1.5B-Instruct-GGUF"
+filename = "qwen2.5-1.5b-instruct-q4_k_m.gguf"
+script_dir = os.path.dirname(os.path.abspath(__file__))
+model_path = hf_hub_download(
+    repo_id=repo_id,
+    filename=filename,
+    local_dir=script_dir,
+    local_dir_use_symlinks=False,  # optional: don't use symlinks
+)
+
+print(f"Model downloaded to: {model_path}")

index.html

@@ -0,0 +1,120 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Real Estate Chatbot Test UI</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      padding: 20px;
+    }
+    #messages {
+      border: 1px solid #ccc;
+      padding: 10px;
+      height: 300px;
+      overflow-y: auto;
+      background-color: #f9f9f9;
+    }
+    .message {
+      margin-bottom: 10px;
+    }
+    .user {
+      color: blue;
+    }
+    .assistant {
+      color: green;
+    }
+    .system {
+      color: gray;
+    }
+    #inputBox {
+      width: 80%;
+      padding: 10px;
+      font-size: 1em;
+    }
+    #sendButton {
+      padding: 10px 20px;
+      font-size: 1em;
+    }
+  </style>
+</head>
+<body>
+  <h2>Real Estate Chatbot</h2>
+  <div id="messages"></div>
+  <br>
+  <input type="text" id="inputBox" placeholder="Type your query here" />
+  <button id="sendButton">Send</button>
+
+  <script>
+    // Create a WebSocket connection to your backend
+    const ws = new WebSocket("ws://localhost:8000/ws");
+
+    // This variable holds the current assistant message element for live updating.
+    let currentAssistantMessageEl = null;
+
+    // When the connection is opened
+    ws.onopen = () => {
+      console.log("WebSocket connection established.");
+      addMessage("Connected to server.", "system");
+    };
+
+    // When a message (token/chunk) is received from the server
+    ws.onmessage = (event) => {
+      // If there's no current assistant message element, create one.
+      if (!currentAssistantMessageEl) {
+        currentAssistantMessageEl = document.createElement("div");
+        currentAssistantMessageEl.classList.add("message", "assistant");
+        currentAssistantMessageEl.textContent = "Assistant: ";
+        document.getElementById("messages").appendChild(currentAssistantMessageEl);
+      }
+      // Append the received token/chunk to the existing assistant message.
+      currentAssistantMessageEl.textContent += event.data;
+      scrollToBottom();
+    };
+
+    // Handle any WebSocket error.
+    ws.onerror = (error) => {
+      console.error("WebSocket error:", error);
+      addMessage("WebSocket error. Please check the console for details.", "system");
+    };
+
+    // Utility to add a new message element.
+    function addMessage(message, type="user") {
+      const messagesDiv = document.getElementById("messages");
+      const newMessage = document.createElement("div");
+      newMessage.classList.add("message", type);
+      newMessage.textContent = message;
+      messagesDiv.appendChild(newMessage);
+      scrollToBottom();
+    }
+
+    // Ensure the messages container scrolls to the bottom.
+    function scrollToBottom(){
+      const messagesDiv = document.getElementById("messages");
+      messagesDiv.scrollTop = messagesDiv.scrollHeight;
+    }
+
+    // Send query on button click.
+    document.getElementById("sendButton").addEventListener("click", () => {
+      const inputBox = document.getElementById("inputBox");
+      const query = inputBox.value.trim();
+      if (query) {
+        // Add user's query.
+        addMessage("You: " + query, "user");
+        // Reset the assistant message element for a new response.
+        currentAssistantMessageEl = null;
+        ws.send(query);
+        inputBox.value = "";
+      }
+    });
+
+    // Also send query when the Enter key is pressed.
+    document.getElementById("inputBox").addEventListener("keyup", (event) => {
+      if (event.key === "Enter") {
+        document.getElementById("sendButton").click();
+      }
+    });
+  </script>
+</body>
+</html>

test.py

@@ -0,0 +1,619 @@
+import uuid
+import threading
+import asyncio
+import json
+import re
+from datetime import datetime
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+from langgraph.graph import StateGraph, START, END
+import faiss
+from sentence_transformers import SentenceTransformer
+import pickle
+import numpy as np
+from tools import extract_json_from_response, apply_filters_partial, rule_based_extract, format_property_data, estateKeywords
+import random
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.tools import tool
+from langchain_core.callbacks import StreamingStdOutCallbackHandler, CallbackManager
+from langchain_core.callbacks.base import BaseCallbackHandler
+from transformers import AutoTokenizer, AutoModelForCausalLM, TextStreamer
+
+
+class CallbackTextStreamer(TextStreamer):
+    def __init__(self, tokenizer, callbacks, skip_prompt=True, skip_special_tokens=True):
+        super().__init__(tokenizer, skip_prompt=skip_prompt, skip_special_tokens=skip_special_tokens)
+        self.callbacks = callbacks
+
+    def on_new_token(self, token: str):
+        for callback in self.callbacks:
+            callback.on_llm_new_token(token)
+
+
+
+
+
+class ChatQwen:
+    def __init__(self, temperature=0.3, streaming=False, max_new_tokens=512, callbacks=None):
+        self.temperature = temperature
+        self.streaming = streaming
+        self.max_new_tokens = max_new_tokens
+        self.callbacks = callbacks
+        self.model_name = "Qwen/Qwen2.5-1.5B-Instruct"
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+        self.model = AutoModelForCausalLM.from_pretrained(
+            self.model_name, 
+            torch_dtype="auto", 
+            device_map="auto"
+        )
+
+    def generate_text(self, messages: list) -> str:
+        """
+        Given a list of messages, create a prompt and generate text using the Qwen model.
+        In streaming mode, uses a TextIteratorStreamer and iterates over tokens to call callbacks.
+        """
+        # Create prompt from messages using the tokenizer's chat template.
+        prompt = self.tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True
+        )
+        model_inputs = self.tokenizer([prompt], return_tensors="pt").to(self.model.device)
+
+        if self.streaming:
+            from transformers import TextIteratorStreamer
+            from threading import Thread
+
+            # Create the streamer that collects tokens as they are generated.
+            streamer = TextIteratorStreamer(self.tokenizer, skip_prompt=True, skip_special_tokens=True)
+            generation_kwargs = dict(
+                **model_inputs,
+                max_new_tokens=self.max_new_tokens,
+                streamer=streamer,
+                temperature=self.temperature,
+                do_sample=True
+            )
+            # Run generation in a separate thread so that we can iterate over tokens.
+            thread = Thread(target=self.model.generate, kwargs=generation_kwargs)
+            thread.start()
+
+            generated_text = ""
+            # Iterate over tokens as they arrive.
+            for token in streamer:
+                generated_text += token
+                # Call each callback with the new token.
+                if self.callbacks:
+                    for callback in self.callbacks:
+                        callback.on_llm_new_token(token)
+            # In streaming mode you may want to return empty string,
+            # but here we return the full text if needed.
+            return generated_text
+        else:
+            outputs = self.model.generate(
+                **model_inputs,
+                max_new_tokens=self.max_new_tokens,
+                temperature=self.temperature,
+                do_sample=True
+            )
+            # Remove the prompt tokens from the output.
+            prompt_length = model_inputs.input_ids.shape[-1]
+            generated_ids = outputs[0][prompt_length:]
+            text_output = self.tokenizer.decode(generated_ids, skip_special_tokens=True)
+            return text_output
+
+
+    def invoke(self, messages: list, config: dict = None) -> AIMessage:
+        config = config or {}
+        # Use provided callbacks if any, otherwise default to the callbacks in the instance.
+        callbacks = config.get("callbacks", self.callbacks)
+        original_callbacks = self.callbacks
+        self.callbacks = callbacks
+
+        output_text = self.generate_text(messages)
+        self.callbacks = original_callbacks
+
+        if self.streaming:
+            return AIMessage(content="")
+        else:
+            return AIMessage(content=output_text)
+
+
+    def __call__(self, messages: list) -> AIMessage:
+        return self.invoke(messages)
+
+
+
+class WebSocketStreamingCallbackHandler(BaseCallbackHandler):
+    def __init__(self, connection_id: str, loop):
+        self.connection_id = connection_id
+        self.loop = loop
+
+    def on_llm_new_token(self, token: str, **kwargs):
+        asyncio.run_coroutine_threadsafe(
+            manager_socket.send_message(self.connection_id, token),
+            self.loop
+        )
+
+
+llm = ChatQwen(temperature=0.3, streaming=True, max_new_tokens=512)
+
+index = faiss.read_index("./faiss.index")
+with open("./metadata.pkl", "rb") as f:
+    docs = pickle.load(f)
+st_model = SentenceTransformer('all-MiniLM-L6-v2')
+
+
+def make_system_prompt(suffix: str) -> str:
+    return (
+        "You are EstateGuru, a real estate expert created by Abhishek Pathak from SwavishTek. "
+        "Your role is to help customers buy properties using the available data. "
+        "Only use the provided data—do not make up any information. "
+        "The default currency is AED. If a query uses a different currency, convert the amount to AED "
+        "(for example, $10k becomes 36726.50 AED and $1 becomes 3.67 AED). "
+        "If a customer is interested in a property, wants to buy, or needs to contact an agent or customer care, "
+        "instruct them to call +91 8766268285."
+        f"\n{suffix}"
+    )
+
+general_query_prompt = make_system_prompt(
+    "You are EstateGuru, a helpful real estate assistant. Answer the user's query accurately using the available data. "
+    "Do not invent any details or go beyond the real estate domain. "
+    "If the user shows interest in a property or contacting an agent, ask them to call +91 8766268285."
+)
+
+# ------------------------ Tool Definitions ------------------------
+
+@tool
+def extract_filters(query: str) -> dict:
+    """For extracting filters"""
+    # Use a non-streaming ChatQwen for tool use.
+    llm_local = ChatQwen(temperature=0.3, streaming=False)
+    system = (
+        "You are an expert in extracting filters from property-related queries. Your task is to extract and return only the keys explicitly mentioned in the query as a valid JSON object (starting with '{' and ending with '}'). Include only those keys that are directly present in the query.\n\n"
+        "The possible keys are:\n"
+        "  - 'projectName': The name of the project.\n"
+        "  - 'developerName': The developer's name.\n"
+        "  - 'relationshipManager': The relationship manager.\n"
+        "  - 'propertyAddress': The property address.\n"
+        "  - 'surroundingArea': The area or nearby landmarks.\n"
+        "  - 'propertyType': The type or configuration of the property.\n"
+        "  - 'amenities': Any amenities mentioned.\n"
+        "  - 'coveredParking': Parking availability.\n"
+        "  - 'petRules': Pet policies.\n"
+        "  - 'security': Security details.\n"
+        "  - 'occupancyRate': Occupancy information.\n"
+        "  - 'constructionImpact': Construction or its impact.\n"
+        "  - 'propertySize': Size of the property.\n"
+        "  - 'propertyView': View details.\n"
+        "  - 'propertyCondition': Condition of the property.\n"
+        "  - 'serviceCharges': Service or maintenance charges.\n"
+        "  - 'ownershipType': Ownership type.\n"
+        "  - 'totalCosts': A cost threshold or cost amount.\n"
+        "  - 'paymentPlans': Payment or financing plans.\n"
+        "  - 'expectedRentalYield': Expected rental yield.\n"
+        "  - 'rentalHistory': Rental history.\n"
+        "  - 'shortTermRentals': Short-term rental information.\n"
+        "  - 'resalePotential': Resale potential.\n"
+        "  - 'uniqueId': A unique identifier.\n\n"
+        "Important instructions regarding cost thresholds:\n"
+        "  - If the query contains phrases like 'under 10k', 'below 2m', or 'less than 5k', interpret these as cost thresholds.\n"
+        "  - Convert any shorthand cost values to pure numbers (for example, '10k' becomes 10000, '2m' becomes 2000000) and assign them to the key 'totalCosts'.\n"
+        "  - Do not use 'propertySize' for cost thresholds.\n\n"
+        "  - Default currency is AED, if user query have different currency symbol then convert to equivalent AED amount (eg. $10k becomes 36726.50, $1 becomes 3.67).\n\n"
+        "Example:\n"
+        "  For the query: \"properties near dubai mall under 43k\"\n"
+        "  The expected output should be:\n"
+        "    { \"surroundingArea\": \"dubai mall\", \"totalCosts\": 43000 }\n\n"
+        "Return ONLY a valid JSON object with the extracted keys and their corresponding values, with no additional text."
+    )
+
+    human_str = f"Here is the query:\n{query}"
+    filter_prompt = [
+        {"role": "system", "content": system},
+        {"role": "user", "content": human_str},
+    ]
+    response = llm_local.invoke(messages=filter_prompt)
+    response_text = response.content if isinstance(response, AIMessage) else str(response)
+    try:
+        model_filters = extract_json_from_response(response_text)
+    except Exception as e:
+        print(f"JSON parsing error: {e}")
+        model_filters = {}
+    rule_filters = rule_based_extract(query)
+    print("Rule-based extraction:", rule_filters)
+    final_filters = {**model_filters, **rule_filters}
+    print("Final extraction:", final_filters)
+    return {"filters": final_filters}
+
+
+@tool
+def determine_route(query: str) -> dict:
+    """For determining route using enhanced prompt and fallback logic."""
+    # Define a set of keywords that are strong indicators of a real estate query.
+    real_estate_keywords = estateKeywords
+
+    # Check if the query includes any of the positive signals.
+    pattern = re.compile("|".join(re.escape(keyword) for keyword in real_estate_keywords), re.IGNORECASE)
+    positive_signal = bool(pattern.search(query))
+
+    # Proceed with LLM classification regardless, but use the positive signal in fallback.
+    llm_local = ChatQwen(temperature=0.3, streaming=False)
+    transform_suggest_to_list = query.lower().replace("suggest ", "list ", -1)
+    system = """
+    Classify the user query as:
+    
+    - **"search"**: if it requests property listings with specific filters (e.g., location, price, property type like "2bhk", service charges, pet policies, etc.).
+    - **"suggest"**: if it asks for property suggestions without filters.
+    - **"detail"**: if it is asking for more information about a previously provided property (for example, "tell me more about property 5" or "I want more information regarding 4BHK").
+    - **"general"**: for all other real estate-related questions.
+    - **"out_of_domain"**: if the query is not related to real estate (for example, tourist attractions, restaurants, etc.).
+    
+    Keep in mind that queries mentioning terms like "service charge", "allow pets", "pet rules", etc., are considered real estate queries.
+    
+    Return only the keyword: search, suggest, detail, general, or out_of_domain.
+    """
+    human_str = f"Here is the query:\n{transform_suggest_to_list}"
+    router_prompt = [
+        {"role": "system", "content": system},
+        {"role": "user", "content": human_str},
+    ]
+    
+    response = llm_local.invoke(messages=router_prompt)
+    response_text = response.content if isinstance(response, AIMessage) else str(response)
+    route_value = str(response_text).strip().lower()
+
+    # Fallback: if the query seems like a detailed request, override.
+    detail_phrases = [
+        "more information",
+        "tell me more",
+        "more details",
+        "give me more details",
+        "i need more details",
+        "can you provide more details",
+        "additional details",
+        "further information",
+        "expand on that",
+        "explain further",
+        "elaborate more",
+        "more specifics",
+        "i want to know more",
+        "could you elaborate",
+        "need more info",
+        "provide more details",
+        "detail it further",
+        "in-depth information",
+        "break it down further",
+        "further explanation"
+    ]
+    if any(phrase in query.lower() for phrase in detail_phrases):
+        route_value = "detail"
+
+    if route_value not in {"search", "suggest", "detail", "general", "out_of_domain"}:
+        route_value = "general"
+    if route_value == "out_of_domain" and positive_signal:
+        route_value = "general"
+    if route_value == "out_of_domain":
+        route_value = "general" if positive_signal else "out_of_domain"
+        
+    return {"route": route_value}
+
+
+
+# ------------------------ Workflow Setup ------------------------
+
+workflow = StateGraph(state_schema=dict)
+
+def route_query(state: dict) -> dict:
+    new_state = state.copy()
+    try:
+        new_state["route"] = determine_route.invoke(new_state.get("query", "")).get("route", "general")
+        print(new_state["route"])
+    except Exception as e:
+        print(f"Routing error: {e}")
+        new_state["route"] = "general"
+    return new_state
+
+def hybrid_extract(state: dict) -> dict:
+    new_state = state.copy()
+    new_state["filters"] = extract_filters.invoke(new_state.get("query", "")).get("filters", {})
+    return new_state
+
+def search_faiss(state: dict) -> dict:
+    new_state = state.copy()
+    query_embedding = st_model.encode([state["query"]])
+    _, indices = index.search(query_embedding.astype(np.float32), 5)
+    new_state["faiss_results"] = [docs[idx] for idx in indices[0] if idx < len(docs)]
+    return new_state
+
+def apply_filters(state: dict) -> dict:
+    new_state = state.copy()
+    new_state["final_results"] = apply_filters_partial(state["faiss_results"], state.get("filters", {}))
+    return new_state
+
+def suggest_properties(state: dict) -> dict:
+    new_state = state.copy()
+    new_state["suggestions"] = random.sample(docs, 5)
+    return new_state
+
+def handle_out_of_domain(state: dict) -> dict:
+    new_state = state.copy()
+    new_state["response"] = "I only handle real estate inquiries. Please ask a question related to properties."
+    return new_state
+
+
+def generate_response(state: dict) -> dict:
+    new_state = state.copy()
+    messages = []
+    
+    # Add the general query prompt.
+    messages.append({"role": "system", "content": general_query_prompt})
+    
+    # If this is a detail query, add a system message that forces a detailed answer.
+    if new_state.get("route", "general") == "detail":
+        messages.append({
+            "role": "system",
+            "content": (
+                "This is a detail query. Please provide detailed information about the property below. "
+                "Do not generate a new list of properties; only use the provided property details to answer the query. "
+                "Focus on answering the specific question (for example, whether pets are allowed)."
+            )
+        })
+        
+    # If property details are available, add them without clearing context.
+    if new_state.get("current_properties"):
+        property_context = format_property_data(new_state["current_properties"])
+        messages.append({"role": "system", "content": "Available Property:\n" + property_context})
+        # Do NOT clear current_properties here.
+        messages.append({"role": "system", "content": "When responding, use only the provided property details to answer the user's specific question about the property."})
+    
+    # Add the conversation history.
+    for msg in state.get("messages", []):
+        if msg["role"] == "user":
+            messages.append({"role": "user", "content": msg["content"]})
+        else:
+            messages.append({"role": "assistant", "content": msg["content"]})
+    
+    # Invoke the LLM with the constructed messages.
+    connection_id = state.get("connection_id")
+    loop = state.get("loop")
+    if connection_id and loop:
+        print("Yes")
+        callback_manager = [WebSocketStreamingCallbackHandler(connection_id, loop)]
+        _ = llm.invoke(
+            messages,
+            config={"callbacks": callback_manager}
+        )
+        new_state["response"] = ""
+    else:
+        callback_manager = [StreamingStdOutCallbackHandler()]
+        response = llm.invoke(
+            messages,
+            config={"callbacks": callback_manager}
+        )
+        new_state["response"] = response.content if isinstance(response, AIMessage) else str(response)
+    
+    return new_state
+
+def format_final_response(state: dict) -> dict:
+    new_state = state.copy()
+    # Only override the current_properties if this is NOT a detail query.
+    if not state.get("route", "general") == "detail":
+        if state.get("route") in ["search", "suggest"]:
+            if "final_results" in state:
+                new_state["current_properties"] = state["final_results"]
+            elif "suggestions" in state:
+                new_state["current_properties"] = state["suggestions"]
+    
+    # Then format the response based on the (possibly filtered) current_properties.
+    if new_state.get("current_properties"):
+        formatted = []
+        for idx, prop in enumerate(new_state["current_properties"], 1):
+            cost = prop.get("totalCosts", "N/A")
+            cost_str = f"{cost:,}" if isinstance(cost, (int, float)) else cost
+            formatted.append(
+                f"{idx}. Type: {prop['propertyType']}, Cost: AED {cost_str}, "
+                f"Size: {prop.get('propertySize', 'N/A')}, Amenities: {', '.join(map(str, prop.get('amenities', []))) if prop.get('amenities') else 'N/A'}, "
+                f"Rental Yield: {prop.get('expectedRentalYield', 'N/A')}, "
+                f"Ownership: {prop.get('ownershipType', 'N/A')}\n"
+            )
+        aggregated_response = "Here are the property details:\n" + "\n".join(formatted)
+        connection_id = state.get("connection_id")
+        loop = state.get("loop")
+        if connection_id and loop:
+            import time
+            tokens = aggregated_response.split(" ")
+            for token in tokens:
+                asyncio.run_coroutine_threadsafe(
+                    manager_socket.send_message(connection_id, token + " "),
+                    loop
+                )
+                time.sleep(0.05)
+            new_state["response"] = ""
+        else:
+            new_state["response"] = aggregated_response
+    elif "response" in new_state:
+        new_state["response"] = str(new_state["response"])
+    return new_state
+
+
+
+nodes = [
+    ("route_query", route_query),
+    ("hybrid_extract", hybrid_extract),
+    ("faiss_search", search_faiss),
+    ("apply_filters", apply_filters),
+    ("suggest_properties", suggest_properties),
+    ("handle_out_of_domain", handle_out_of_domain),
+    ("generate_response", generate_response),
+    ("format_response", format_final_response)
+]
+
+for name, node in nodes:
+    workflow.add_node(name, node)
+
+workflow.add_edge(START, "route_query")
+workflow.add_conditional_edges(
+    "route_query",
+    lambda state: state.get("route", "general"),
+    {
+        "search": "hybrid_extract", 
+        "suggest": "suggest_properties", 
+        "detail": "generate_response", 
+        "general": "generate_response", 
+        "out_of_domain": "handle_out_of_domain"
+    }
+)
+workflow.add_edge("hybrid_extract", "faiss_search")
+workflow.add_edge("faiss_search", "apply_filters")
+workflow.add_edge("apply_filters", "format_response")
+workflow.add_edge("suggest_properties", "format_response")
+workflow.add_edge("generate_response", "format_response")
+workflow.add_edge("handle_out_of_domain", "format_response")
+workflow.add_edge("format_response", END)
+
+workflow_app = workflow.compile()
+
+# ------------------------ Conversation Manager ------------------------
+
+class ConversationManager:
+    def __init__(self):
+        self.conversation_history = []
+        self.current_properties = []
+
+    def _add_message(self, role: str, content: str):
+        self.conversation_history.append({
+            "role": role,
+            "content": content,
+            "timestamp": datetime.now().isoformat()
+        })
+
+    def process_query(self, query: str) -> str:
+        # Reset context on greetings to avoid using off-domain history
+        if query.strip().lower() in {"hi", "hello", "hey"}:
+            self.conversation_history = []
+            self.current_properties = []
+            greeting_response = "Hello! How can I assist you today with your real estate inquiries?"
+            self._add_message("assistant", greeting_response)
+            return greeting_response
+
+        try:
+            self._add_message("user", query)
+            initial_state = {
+                "messages": self.conversation_history.copy(),
+                "query": query,
+                "route": "general",
+                "filters": {},
+                "current_properties": self.current_properties
+            }
+            for event in workflow_app.stream(initial_state, stream_mode="values"):
+                final_state = event
+            if 'final_results' in final_state:
+                self.current_properties = final_state['final_results']
+            elif 'suggestions' in final_state:
+                self.current_properties = final_state['suggestions']
+            if final_state.get("route") == "general":
+                response_text = final_state.get("response", "")
+                self._add_message("assistant", response_text)
+                return response_text
+            else:
+                response = final_state.get("response", "I couldn't process that request.")
+                self._add_message("assistant", response)
+                return response
+        except Exception as e:
+            print(f"Processing error: {e}")
+            return "Sorry, I encountered an error processing your request."
+
+conversation_managers = {}
+
+# ------------------------ FastAPI Backend with WebSockets ------------------------
+
+app = FastAPI()
+
+class ConnectionManager:
+    def __init__(self):
+        self.active_connections = {}
+
+    async def connect(self, websocket: WebSocket):
+        await websocket.accept()
+        connection_id = str(uuid.uuid4())
+        self.active_connections[connection_id] = websocket
+        print(f"New connection: {connection_id}")
+        return connection_id
+
+    def disconnect(self, connection_id: str):
+        if connection_id in self.active_connections:
+            del self.active_connections[connection_id]
+            print(f"Disconnected: {connection_id}")
+
+    async def send_message(self, connection_id: str, message: str):
+        websocket = self.active_connections.get(connection_id)
+        if websocket:
+            await websocket.send_text(message)
+
+manager_socket = ConnectionManager()
+
+def stream_query(query: str, connection_id: str, loop):
+    conv_manager = conversation_managers.get(connection_id)
+    if conv_manager is None:
+        print(f"No conversation manager found for connection {connection_id}")
+        return
+
+    # Check for greetings and handle them immediately
+    if query.strip().lower() in {"hi", "hello", "hey"}:
+        conv_manager.conversation_history = []
+        conv_manager.current_properties = []
+        greeting_response = "Hello! How can I assist you today with your real estate inquiries?"
+        conv_manager._add_message("assistant", greeting_response)
+        asyncio.run_coroutine_threadsafe(
+            manager_socket.send_message(connection_id, greeting_response),
+            loop
+        )
+        return
+
+    conv_manager._add_message("user", query)
+    initial_state = {
+        "messages": conv_manager.conversation_history.copy(),
+        "query": query,
+        "route": "general",
+        "filters": {},
+        "current_properties": conv_manager.current_properties,
+        "connection_id": connection_id,
+        "loop": loop
+    }
+    try:
+        workflow_app.invoke(initial_state)
+    except Exception as e:
+        error_msg = f"Error processing query: {str(e)}"
+        asyncio.run_coroutine_threadsafe(
+            manager_socket.send_message(connection_id, error_msg),
+            loop
+        )
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    connection_id = await manager_socket.connect(websocket)
+    conversation_managers[connection_id] = ConversationManager()
+    try:
+        while True:
+            query = await websocket.receive_text()
+            loop = asyncio.get_event_loop()
+            # loop = asyncio.get_running_loop()
+            threading.Thread(
+                target=stream_query,
+                args=(query, connection_id, loop),
+                daemon=True
+            ).start()
+    except WebSocketDisconnect:
+        conv_manager = conversation_managers.get(connection_id)
+        if conv_manager:
+            filename = f"conversations/conversation_{connection_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+            with open(filename, "w") as f:
+                json.dump(conv_manager.conversation_history, f, indent=4)
+            del conversation_managers[connection_id]
+        manager_socket.disconnect(connection_id)
+
+@app.post("/query")
+async def post_query(query: str):
+    conv_manager = ConversationManager()
+    response = conv_manager.process_query(query)
+    return {"response": response}

test2.py

@@ -0,0 +1,813 @@
+import uuid
+import threading
+import asyncio
+import json
+import re
+import random
+import time
+import pickle
+import numpy as np
+import requests  # For llama.cpp server calls
+from datetime import datetime
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+from langgraph.graph import StateGraph, START, END
+import faiss
+from sentence_transformers import SentenceTransformer
+from tools import extract_json_from_response, apply_filters_partial, rule_based_extract, format_property_data, estateKeywords
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.tools import tool
+from langchain_core.callbacks import StreamingStdOutCallbackHandler, CallbackManager
+from langchain_core.callbacks.base import BaseCallbackHandler
+
+# ------------------------ Model Inference Wrapper ------------------------
+
+class ChatQwen:
+    """
+    A chat wrapper for Qwen using llama.cpp.
+    This class can work in two modes:
+      - Local: Using a llama-cpp-python binding (gguf model file loaded locally).
+      - Server: Calling a remote llama.cpp server endpoint.
+    """
+    def __init__(
+        self,
+        temperature=0.3,
+        streaming=False,
+        max_new_tokens=512,
+        callbacks=None,
+        use_server=False,
+        model_path: str = None,
+        server_url: str = None
+    ):
+        self.temperature = temperature
+        self.streaming = streaming
+        self.max_new_tokens = max_new_tokens
+        self.callbacks = callbacks
+        self.use_server = use_server
+
+        if self.use_server:
+            # Use remote llama.cpp server – provide its URL.
+            self.server_url = server_url or "http://localhost:8000"
+        else:
+            # For local inference, a model_path must be provided.
+            if not model_path:
+                raise ValueError("Local mode requires a valid model_path to the gguf file.")
+            from llama_cpp import Llama  # assumes llama-cpp-python is installed
+            self.model = Llama(
+                model_path=model_path,
+                temperature=self.temperature,
+                n_ctx=512,
+                n_threads=4  # Adjust as needed
+            )
+
+    def build_prompt(self, messages: list) -> str:
+        """Build Qwen-compatible prompt with special tokens."""
+        prompt = ""
+        for msg in messages:
+            role = msg["role"]
+            content = msg["content"]
+            if role == "system":
+                prompt += f"<|im_start|>system\n{content}<|im_end|>\n"
+            elif role == "user":
+                prompt += f"<|im_start|>user\n{content}<|im_end|>\n"
+            elif role == "assistant":
+                prompt += f"<|im_start|>assistant\n{content}<|im_end|>\n"
+        prompt += "<|im_start|>assistant\n"
+        return prompt
+
+    # def generate_text(self, messages: list) -> str:
+    #     prompt = self.build_prompt(messages)
+    #     if self.use_server:
+    #         payload = {
+    #             "prompt": prompt,
+    #             "max_tokens": self.max_new_tokens,
+    #             "temperature": self.temperature,
+    #             "stream": self.streaming
+    #         }
+    #         if self.streaming:
+    #             response = requests.post(f"{self.server_url}/generate", json=payload, stream=True)
+    #             generated_text = ""
+    #             for line in response.iter_lines():
+    #                 if line:
+    #                     token = line.decode("utf-8")
+    #                     generated_text += token
+    #                     if self.callbacks:
+    #                         for callback in self.callbacks:
+    #                             callback.on_llm_new_token(token)
+    #             return generated_text
+    #         else:
+    #             response = requests.post(f"{self.server_url}/generate", json=payload)
+    #             return response.json().get("generated_text", "")
+    #     else:
+    #         # Local llama.cpp inference using llama-cpp-python.
+    #         if self.streaming:
+    #             stream = self.model(
+    #                 prompt=prompt,
+    #                 max_tokens=self.max_new_tokens,
+    #                 stream=True
+    #             )
+    #             generated_text = ""
+    #             for token in stream:
+    #                 # If token is a dict, extract text from token["choices"][0]["text"]
+    #                 if isinstance(token, dict):
+    #                     if "choices" in token and token["choices"]:
+    #                         token_text = token["choices"][0].get("text", "")
+    #                     else:
+    #                         token_text = str(token)
+    #                 else:
+    #                     token_text = token
+    #                 generated_text += token_text
+    #                 if self.callbacks:
+    #                     for callback in self.callbacks:
+    #                         callback.on_llm_new_token(token_text)
+    #             return generated_text
+    #         else:
+    #             result = self.model(
+    #                 prompt=prompt,
+    #                 max_tokens=self.max_new_tokens,
+    #                 stream=False
+    #             )
+    #             return result["choices"][0]["text"]
+
+    def generate_text(self, messages: list) -> str:
+        prompt = self.build_prompt(messages)
+        stop_tokens = ["<|im_end|>", "\n"]  # Qwen's stop sequences
+        
+        if self.use_server:
+            payload = {
+                "prompt": prompt,
+                "max_tokens": self.max_new_tokens,
+                "temperature": self.temperature,
+                "stream": self.streaming,
+                "stop": stop_tokens  # Add stop tokens to server request
+            }
+            if self.streaming:
+                response = requests.post(f"{self.server_url}/generate", json=payload, stream=True)
+                generated_text = ""
+                for line in response.iter_lines():
+                    if line:
+                        token = line.decode("utf-8")
+                        # Check for stop tokens in stream
+                        if any(stop in token for stop in stop_tokens):
+                            break
+                        generated_text += token
+                        if self.callbacks:
+                            for callback in self.callbacks:
+                                callback.on_llm_new_token(token)
+                return generated_text
+            else:
+                response = requests.post(f"{self.server_url}/generate", json=payload)
+                return response.json().get("generated_text", "")
+        else:
+            # Local llama.cpp inference
+            if self.streaming:
+                stream = self.model.create_completion(
+                    prompt=prompt,
+                    max_tokens=self.max_new_tokens,
+                    temperature=self.temperature,
+                    stream=True,
+                    stop=stop_tokens
+                )
+                generated_text = ""
+                for token_chunk in stream:
+                    token_text = token_chunk["choices"][0]["text"]
+                    # Stop early if we detect end token
+                    if any(stop in token_text for stop in stop_tokens):
+                        break
+                    generated_text += token_text
+                    if self.callbacks:
+                        for callback in self.callbacks:
+                            callback.on_llm_new_token(token_text)
+                return generated_text
+            else:
+                result = self.model.create_completion(
+                    prompt=prompt,
+                    max_tokens=self.max_new_tokens,
+                    temperature=self.temperature,
+                    stop=stop_tokens
+                )
+                return result["choices"][0]["text"]
+    def invoke(self, messages: list, config: dict = None) -> AIMessage:
+        config = config or {}
+        callbacks = config.get("callbacks", self.callbacks)
+        original_callbacks = self.callbacks
+        self.callbacks = callbacks
+
+        output_text = self.generate_text(messages)
+        self.callbacks = original_callbacks
+
+        # In streaming mode we return an empty content as tokens are being sent via callbacks.
+        if self.streaming:
+            return AIMessage(content="")
+        else:
+            return AIMessage(content=output_text)
+
+    def __call__(self, messages: list) -> AIMessage:
+        return self.invoke(messages)
+
+
+# ------------------------ Callback for WebSocket Streaming ------------------------
+
+class WebSocketStreamingCallbackHandler(BaseCallbackHandler):
+    def __init__(self, connection_id: str, loop):
+        self.connection_id = connection_id
+        self.loop = loop
+
+    def on_llm_new_token(self, token: str, **kwargs):
+        asyncio.run_coroutine_threadsafe(
+            manager_socket.send_message(self.connection_id, token),
+            self.loop
+        )
+
+
+# ------------------------ Instantiate the LLM ------------------------
+# Choose one mode: local (set use_server=False) or server (set use_server=True).
+model_path="qwen2.5-1.5b-instruct-q4_k_m.gguf"
+llm = ChatQwen(
+    temperature=0.3,
+    streaming=True,
+    max_new_tokens=512,
+    use_server=False,
+    model_path=model_path,
+    # server_url="http://localhost:8000"  # Uncomment and set if using server mode.
+)
+
+# ------------------------ FAISS and Sentence Transformer Setup ------------------------
+
+index = faiss.read_index("./faiss.index")
+with open("./metadata.pkl", "rb") as f:
+    docs = pickle.load(f)
+st_model = SentenceTransformer('all-MiniLM-L6-v2')
+
+
+def make_system_prompt(suffix: str) -> str:
+    return (
+        "You are EstateGuru, a real estate expert developed by Abhishek Pathak at SwavishTek. "
+        "Your role is to help customers buy properties using only the provided data—do not invent any details. "
+        "The default currency is AED; if a query mentions another currency, convert the amount to AED "
+        "(for example, convert $10k to 36726.50 AED and $1 to 3.67 AED). "
+        "If a customer is interested in a property or needs to contact an agent, instruct them to call +91 8766268285. "
+        "Keep your answers short, clear, and concise."
+        f"\n{suffix}"
+    )
+
+general_query_prompt = make_system_prompt(
+    "You are EstateGuru, a helpful real estate assistant. "
+    "Please respond only in English. "
+    "Convert any prices to USD before answering. "
+    "Provide a brief, direct answer without extra details."
+)
+
+
+
+
+# ------------------------ Tool Definitions ------------------------
+
+@tool
+def extract_filters(query: str) -> dict:
+    """Extract filters from the query."""
+    llm_local = ChatQwen(temperature=0.3, streaming=False, use_server=False, model_path=model_path)
+    system = (
+        "You are an expert in extracting filters from property-related queries. Your task is to extract and return only the keys explicitly mentioned in the query as a valid JSON object (starting with '{' and ending with '}'). Include only those keys that are directly present in the query.\n\n"
+        "The possible keys are:\n"
+        "  - 'projectName': The name of the project.\n"
+        "  - 'developerName': The developer's name.\n"
+        "  - 'relationshipManager': The relationship manager.\n"
+        "  - 'propertyAddress': The property address.\n"
+        "  - 'surroundingArea': The area or nearby landmarks.\n"
+        "  - 'propertyType': The type or configuration of the property.\n"
+        "  - 'amenities': Any amenities mentioned.\n"
+        "  - 'coveredParking': Parking availability.\n"
+        "  - 'petRules': Pet policies.\n"
+        "  - 'security': Security details.\n"
+        "  - 'occupancyRate': Occupancy information.\n"
+        "  - 'constructionImpact': Construction or its impact.\n"
+        "  - 'propertySize': Size of the property.\n"
+        "  - 'propertyView': View details.\n"
+        "  - 'propertyCondition': Condition of the property.\n"
+        "  - 'serviceCharges': Service or maintenance charges.\n"
+        "  - 'ownershipType': Ownership type.\n"
+        "  - 'totalCosts': A cost threshold or cost amount.\n"
+        "  - 'paymentPlans': Payment or financing plans.\n"
+        "  - 'expectedRentalYield': Expected rental yield.\n"
+        "  - 'rentalHistory': Rental history.\n"
+        "  - 'shortTermRentals': Short-term rental information.\n"
+        "  - 'resalePotential': Resale potential.\n"
+        "  - 'uniqueId': A unique identifier.\n\n"
+        "Important instructions regarding cost thresholds:\n"
+        "  - If the query contains phrases like 'under 10k', 'below 2m', or 'less than 5k', interpret these as cost thresholds.\n"
+        "  - Convert any shorthand cost values to pure numbers (for example, '10k' becomes 10000, '2m' becomes 2000000) and assign them to the key 'totalCosts'.\n"
+        "  - Do not use 'propertySize' for cost thresholds.\n\n"
+        "  - Default currency is AED, if user query have different currency symbol then convert to equivalent AED amount (eg. $10k becomes 36726.50, $1 becomes 3.67).\n\n"
+        "Example:\n"
+        "  For the query: \"properties near dubai mall under 43k\"\n"
+        "  The expected output should be:\n"
+        "    { \"surroundingArea\": \"dubai mall\", \"totalCosts\": 43000 }\n\n"
+        "Return ONLY a valid JSON object with the extracted keys and their corresponding values, with no additional text."
+    )
+
+    human_str = f"Here is the query:\n{query}"
+    filter_prompt = [
+        {"role": "system", "content": system},
+        {"role": "user", "content": human_str},
+    ]
+    response = llm_local.invoke(messages=filter_prompt)
+    response_text = response.content if isinstance(response, AIMessage) else str(response)
+    try:
+        model_filters = extract_json_from_response(response_text)
+    except Exception as e:
+        print(f"JSON parsing error: {e}")
+        model_filters = {}
+    rule_filters = rule_based_extract(query)
+    print("Rule-based extraction:", rule_filters)
+    final_filters = {**model_filters, **rule_filters}
+    print("Final extraction:", final_filters)
+    return {"filters": final_filters}
+
+
+@tool
+def determine_route(query: str) -> dict:
+    """Determine the route (search, suggest, detail, general, out_of_domain) for the query."""
+    real_estate_keywords = estateKeywords
+    pattern = re.compile("|".join(re.escape(keyword) for keyword in real_estate_keywords), re.IGNORECASE)
+    positive_signal = bool(pattern.search(query))
+
+    llm_local = ChatQwen(temperature=0.3, streaming=False, use_server=False, model_path=model_path)
+    transform_suggest_to_list = query.lower().replace("suggest ", "list ", -1)
+    system = """
+    Classify the user query as:
+    
+    - **"search"**: if it requests property listings with specific filters (e.g., location, price, property type like "2bhk", service charges, pet policies, etc.).
+    - **"suggest"**: if it asks for property suggestions without filters.
+    - **"detail"**: if it is asking for more information about a previously provided property (for example, "tell me more about property 5" or "I want more information regarding 4BHK").
+    - **"general"**: for all other real estate-related questions.
+    - **"out_of_domain"**: if the query is not related to real estate (for example, tourist attractions, restaurants, etc.).
+    
+    Keep in mind that queries mentioning terms like "service charge", "allow pets", "pet rules", etc., are considered real estate queries.
+    
+    Return only the keyword: search, suggest, detail, general, or out_of_domain.
+    """
+    human_str = f"Here is the query:\n{transform_suggest_to_list}"
+    router_prompt = [
+        {"role": "system", "content": system},
+        {"role": "user", "content": human_str},
+    ]
+    
+    response = llm_local.invoke(messages=router_prompt)
+    response_text = response.content if isinstance(response, AIMessage) else str(response)
+    route_value = str(response_text).strip().lower()
+
+    # Fallback override if query appears detailed.
+    detail_phrases = [
+        "more information", "tell me more", "more details", "give me more details",
+        "i need more details", "can you provide more details", "additional details",
+        "further information", "expand on that", "explain further", "elaborate more",
+        "more specifics", "i want to know more", "could you elaborate", "need more info",
+        "provide more details", "detail it further", "in-depth information", "break it down further",
+        "further explanation", "property 1", "property1", "first property", "about the 2nd", "regarding number 3"
+    ]
+    if any(phrase in query.lower() for phrase in detail_phrases):
+        route_value = "detail"
+
+    if route_value not in {"search", "suggest", "detail", "general", "out_of_domain"}:
+        route_value = "general"
+    if route_value == "out_of_domain" and positive_signal:
+        route_value = "general"
+    if route_value == "out_of_domain":
+        route_value = "general" if positive_signal else "out_of_domain"
+        
+    return {"route": route_value}
+
+
+# ------------------------ Workflow Setup ------------------------
+
+workflow = StateGraph(state_schema=dict)
+
+def route_query(state: dict) -> dict:
+    new_state = state.copy()
+    try:
+        new_state["route"] = determine_route.invoke(new_state.get("query", "")).get("route", "general")
+        print(new_state["route"])
+    except Exception as e:
+        print(f"Routing error: {e}")
+        new_state["route"] = "general"
+    return new_state
+
+def hybrid_extract(state: dict) -> dict:
+    new_state = state.copy()
+    new_state["filters"] = extract_filters.invoke(new_state.get("query", "")).get("filters", {})
+    return new_state
+
+# def search_faiss(state: dict) -> dict:
+#     new_state = state.copy()
+#     query_embedding = st_model.encode([state["query"]])
+#     _, indices = index.search(query_embedding.astype(np.float32), 5)
+#     new_state["faiss_results"] = [docs[idx] for idx in indices[0] if idx < len(docs)]
+#     return new_state
+
+def apply_filters(state: dict) -> dict:
+    new_state = state.copy()
+    new_state["final_results"] = apply_filters_partial(state["faiss_results"], state.get("filters", {}))
+    return new_state
+
+# def suggest_properties(state: dict) -> dict:
+#     new_state = state.copy()
+#     new_state["suggestions"] = random.sample(docs, 5)
+#     return new_state
+
+def handle_out_of_domain(state: dict) -> dict:
+    new_state = state.copy()
+    new_state["response"] = "I only handle real estate inquiries. Please ask a question related to properties."
+    return new_state
+
+
+def search_faiss(state: dict) -> dict:
+    new_state = state.copy()
+    # Keep existing properties unless explicitly changed
+    new_state.setdefault("current_properties", state.get("current_properties", []))
+    query_embedding = st_model.encode([state["query"]])
+    _, indices = index.search(query_embedding.astype(np.float32), 5)
+    new_state["faiss_results"] = [docs[idx] for idx in indices[0] if idx < len(docs)]
+    return new_state
+
+
+def suggest_properties(state: dict) -> dict:
+    new_state = state.copy()
+    new_state["suggestions"] = random.sample(docs, 5)
+    new_state["current_properties"] = new_state["suggestions"]  # Explicitly set
+    return new_state
+
+# def generate_response(state: dict) -> dict:
+#     new_state = state.copy()
+#     messages = []
+    
+#     # Add the general query prompt.
+#     messages.append({"role": "system", "content": general_query_prompt})
+    
+#     # For detail queries, add extra instructions.
+#     if new_state.get("route", "general") == "detail":
+#         messages.append({
+#             "role": "system",
+#             "content": (
+#                 "This is a detail query. Please provide detailed information about the property below. "
+#                 "Do not generate a new list of properties; only use the provided property details to answer the query. "
+#                 "Focus on answering the specific question (for example, whether pets are allowed)."
+#             )
+#         })
+        
+#     if new_state.get("current_properties"):
+#         property_context = format_property_data(new_state["current_properties"])
+#         messages.append({"role": "system", "content": "Available Property:\n" + property_context})
+#         messages.append({"role": "system", "content": "When responding, use only the provided property details."})
+    
+#     for msg in state.get("messages", []):
+#         messages.append({"role": msg["role"], "content": msg["content"]})
+    
+#     connection_id = state.get("connection_id")
+#     loop = state.get("loop")
+#     if connection_id and loop:
+#         print("Using WebSocket streaming")
+#         callback_manager = [WebSocketStreamingCallbackHandler(connection_id, loop)]
+#         _ = llm.invoke(messages, config={"callbacks": callback_manager})
+#         new_state["response"] = ""
+#     else:
+#         callback_manager = [StreamingStdOutCallbackHandler()]
+#         response = llm.invoke(messages, config={"callbacks": callback_manager})
+#         new_state["response"] = response.content if isinstance(response, AIMessage) else str(response)
+    
+#     return new_state
+
+
+
+
+
+# def format_final_response(state: dict) -> dict:
+#     new_state = state.copy()
+#     if not state.get("route", "general") == "detail":
+#         if state.get("route") in ["search", "suggest"]:
+#             if "final_results" in state:
+#                 new_state["current_properties"] = state["final_results"]
+#             elif "suggestions" in state:
+#                 new_state["current_properties"] = state["suggestions"]
+    
+#     if new_state.get("current_properties"):
+#         formatted = []
+#         for idx, prop in enumerate(new_state["current_properties"], 1):
+#             cost = prop.get("totalCosts", "N/A")
+#             cost_str = f"{cost:,}" if isinstance(cost, (int, float)) else cost
+#             formatted.append(
+#                 f"{idx}. Type: {prop['propertyType']}, Cost: AED {cost_str}, "
+#                 f"Size: {prop.get('propertySize', 'N/A')}, Amenities: {', '.join(map(str, prop.get('amenities', []))) if prop.get('amenities') else 'N/A'}, "
+#                 f"Rental Yield: {prop.get('expectedRentalYield', 'N/A')}, "
+#                 f"Ownership: {prop.get('ownershipType', 'N/A')}\n"
+#             )
+#         aggregated_response = "Here are the property details:\n" + "\n".join(formatted)
+#         connection_id = state.get("connection_id")
+#         loop = state.get("loop")
+#         if connection_id and loop:
+#             tokens = aggregated_response.split(" ")
+#             for token in tokens:
+#                 asyncio.run_coroutine_threadsafe(
+#                     manager_socket.send_message(connection_id, token + " "),
+#                     loop
+#                 )
+#                 time.sleep(0.05)
+#             new_state["response"] = ""
+#         else:
+#             new_state["response"] = aggregated_response
+#     elif "response" in new_state:
+#         new_state["response"] = str(new_state["response"])
+#     return new_state
+
+def generate_response(state: dict) -> dict:
+    new_state = state.copy()
+    messages = []
+    
+    # Add the general query prompt.
+    messages.append({"role": "system", "content": general_query_prompt})
+    
+    # For detail queries, add extra instructions.
+    if new_state.get("route", "general") == "detail":
+        messages.append({
+            "role": "system",
+            "content": (
+                "The user is asking about a specific property from the numbered list below. "
+                "Properties are listed as 1, 2, 3, etc. Use ONLY the corresponding property details. "
+                "Example: If they ask 'property 2', use the second entry in the list. Never invent data."
+            )
+        })
+        
+    if new_state.get("current_properties"):
+        # Format properties with indices starting at 1
+        property_context = format_property_data_with_indices(new_state["current_properties"])
+        messages.append({"role": "system", "content": "Available Properties:\n" + property_context})
+        messages.append({"role": "system", "content": "When responding, use only the provided property details."})
+    
+    # Add conversation history
+    for msg in state.get("messages", []):
+        messages.append({"role": msg["role"], "content": msg["content"]})
+    
+    connection_id = state.get("connection_id")
+    loop = state.get("loop")
+    if connection_id and loop:
+        print("Yes")
+        callback_manager = [WebSocketStreamingCallbackHandler(connection_id, loop)]
+        _ = llm.invoke(
+            messages,
+            config={"callbacks": callback_manager}
+        )
+        new_state["response"] = ""
+    else:
+        callback_manager = [StreamingStdOutCallbackHandler()]
+        response = llm.invoke(
+            messages,
+            config={"callbacks": callback_manager}
+        )
+        new_state["response"] = response.content if isinstance(response, AIMessage) else str(response)
+    
+    return new_state
+
+
+
+
+def format_property_data_with_indices(properties: list) -> str:
+    formatted = []
+    for idx, prop in enumerate(properties, 1):
+        cost = prop.get("totalCosts", "N/A")
+        cost_str = f"{cost:,}" if isinstance(cost, (int, float)) else cost
+        formatted.append(
+            f"{idx}. Type: {prop['propertyType']}, Cost: AED {cost_str}, "
+            f"Size: {prop.get('propertySize', 'N/A')}, Amenities: {', '.join(prop.get('amenities', []))}, "
+            f"Rental Yield: {prop.get('expectedRentalYield', 'N/A')}, "
+            f"Ownership: {prop.get('ownershipType', 'N/A')}"
+        )
+    return "\n".join(formatted)
+
+
+def format_final_response(state: dict) -> dict:
+    new_state = state.copy()
+    if "current_properties" in new_state:
+        new_state["current_properties"] = state["current_properties"]
+    
+    if not state.get("route", "general") == "detail":
+        if state.get("route") in ["search", "suggest"]:
+            if "final_results" in state:
+                new_state["current_properties"] = state["final_results"]
+            elif "suggestions" in state:
+                new_state["current_properties"] = state["suggestions"]
+    
+    # Ensure properties are stored even if not in search/suggest routes
+    if "current_properties" not in new_state and "response" in new_state:
+        # Fallback to retain properties if needed
+        pass
+    
+    # Existing formatting code remains but use the same indexed formatting
+    if new_state.get("current_properties"):
+        formatted = []
+        for idx, prop in enumerate(new_state["current_properties"], 1):
+            cost = prop.get("totalCosts", "N/A")
+            cost_str = f"{cost:,}" if isinstance(cost, (int, float)) else cost
+            formatted.append(
+                f"{idx}. Type: {prop['propertyType']}, Cost: AED {cost_str}, "
+                f"Size: {prop.get('propertySize', 'N/A')}, Amenities: {', '.join(map(str, prop.get('amenities', []))) if prop.get('amenities') else 'N/A'}, "
+                f"Rental Yield: {prop.get('expectedRentalYield', 'N/A')}, "
+                f"Ownership: {prop.get('ownershipType', 'N/A')}\n"
+            )
+        aggregated_response = "Here are the property details:\n" + "\n".join(formatted)
+        connection_id = state.get("connection_id")
+        loop = state.get("loop")
+        if connection_id and loop:
+            import time
+            tokens = aggregated_response.split(" ")
+            for token in tokens:
+                asyncio.run_coroutine_threadsafe(
+                    manager_socket.send_message(connection_id, token + " "),
+                    loop
+                )
+                time.sleep(0.05)
+            new_state["response"] = ""
+        else:
+            new_state["response"] = aggregated_response
+    elif "response" in new_state:
+        new_state["response"] = str(new_state["response"])
+    return new_state
+
+
+
+nodes = [
+    ("route_query", route_query),
+    ("hybrid_extract", hybrid_extract),
+    ("faiss_search", search_faiss),
+    ("apply_filters", apply_filters),
+    ("suggest_properties", suggest_properties),
+    ("handle_out_of_domain", handle_out_of_domain),
+    ("generate_response", generate_response),
+    ("format_response", format_final_response)
+]
+
+for name, node in nodes:
+    workflow.add_node(name, node)
+
+workflow.add_edge(START, "route_query")
+workflow.add_conditional_edges(
+    "route_query",
+    lambda state: state.get("route", "general"),
+    {
+        "search": "hybrid_extract", 
+        "suggest": "suggest_properties", 
+        "detail": "generate_response", 
+        "general": "generate_response", 
+        "out_of_domain": "handle_out_of_domain"
+    }
+)
+workflow.add_edge("hybrid_extract", "faiss_search")
+workflow.add_edge("faiss_search", "apply_filters")
+workflow.add_edge("apply_filters", "format_response")
+workflow.add_edge("suggest_properties", "format_response")
+workflow.add_edge("generate_response", "format_response")
+workflow.add_edge("handle_out_of_domain", "format_response")
+workflow.add_edge("format_response", END)
+
+workflow_app = workflow.compile()
+
+# ------------------------ Conversation Manager ------------------------
+
+class ConversationManager:
+    def __init__(self):
+        self.conversation_history = []
+        self.current_properties = []
+
+    def _add_message(self, role: str, content: str):
+        self.conversation_history.append({
+            "role": role,
+            "content": content,
+            "timestamp": datetime.now().isoformat()
+        })
+
+    def process_query(self, query: str) -> str:
+        if query.strip().lower() in {"hi", "hello", "hey"}:
+            self.conversation_history = []
+            self.current_properties = []
+            greeting_response = "Hello! How can I assist you today with your real estate inquiries?"
+            self._add_message("assistant", greeting_response)
+            return greeting_response
+
+        try:
+            self._add_message("user", query)
+            initial_state = {
+                "messages": self.conversation_history.copy(),
+                "query": query,
+                "route": "general",
+                "filters": {},
+                "current_properties": self.current_properties
+            }
+            for event in workflow_app.stream(initial_state, stream_mode="values"):
+                final_state = event
+            if 'final_results' in final_state:
+                self.current_properties = final_state['final_results']
+            elif 'suggestions' in final_state:
+                self.current_properties = final_state['suggestions']
+            if final_state.get("route") == "general":
+                response_text = final_state.get("response", "")
+                self._add_message("assistant", response_text)
+                return response_text
+            else:
+                response = final_state.get("response", "I couldn't process that request.")
+                self._add_message("assistant", response)
+                return response
+        except Exception as e:
+            print(f"Processing error: {e}")
+            return "Sorry, I encountered an error processing your request."
+
+conversation_managers = {}
+
+# ------------------------ FastAPI Backend with WebSockets ------------------------
+
+app = FastAPI()
+
+class ConnectionManager:
+    def __init__(self):
+        self.active_connections = {}
+
+    async def connect(self, websocket: WebSocket):
+        await websocket.accept()
+        connection_id = str(uuid.uuid4())
+        self.active_connections[connection_id] = websocket
+        print(f"New connection: {connection_id}")
+        return connection_id
+
+    def disconnect(self, connection_id: str):
+        if connection_id in self.active_connections:
+            del self.active_connections[connection_id]
+            print(f"Disconnected: {connection_id}")
+
+    async def send_message(self, connection_id: str, message: str):
+        websocket = self.active_connections.get(connection_id)
+        if websocket:
+            await websocket.send_text(message)
+
+manager_socket = ConnectionManager()
+
+def stream_query(query: str, connection_id: str, loop):
+    conv_manager = conversation_managers.get(connection_id)
+    if conv_manager is None:
+        print(f"No conversation manager found for connection {connection_id}")
+        return
+
+    if query.strip().lower() in {"hi", "hello", "hey"}:
+        conv_manager.conversation_history = []
+        conv_manager.current_properties = []
+        greeting_response = "Hello! How can I assist you today with your real estate inquiries?"
+        conv_manager._add_message("assistant", greeting_response)
+        asyncio.run_coroutine_threadsafe(
+            manager_socket.send_message(connection_id, greeting_response),
+            loop
+        )
+        return
+
+    conv_manager._add_message("user", query)
+    initial_state = {
+        "messages": conv_manager.conversation_history.copy(),
+        "query": query,
+        "route": "general",
+        "filters": {},
+        "current_properties": conv_manager.current_properties,
+        "connection_id": connection_id,
+        "loop": loop
+    }
+    try:
+        workflow_app.invoke(initial_state)
+    except Exception as e:
+        error_msg = f"Error processing query: {str(e)}"
+        asyncio.run_coroutine_threadsafe(
+            manager_socket.send_message(connection_id, error_msg),
+            loop
+        )
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    connection_id = await manager_socket.connect(websocket)
+    conversation_managers[connection_id] = ConversationManager()
+    try:
+        while True:
+            query = await websocket.receive_text()
+            loop = asyncio.get_event_loop()
+            threading.Thread(
+                target=stream_query,
+                args=(query, connection_id, loop),
+                daemon=True
+            ).start()
+    except WebSocketDisconnect:
+        conv_manager = conversation_managers.get(connection_id)
+        if conv_manager:
+            filename = f"conversations/conversation_{connection_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+            with open(filename, "w") as f:
+                json.dump(conv_manager.conversation_history, f, indent=4)
+            del conversation_managers[connection_id]
+        manager_socket.disconnect(connection_id)
+
+@app.post("/query")
+async def post_query(query: str):
+    conv_manager = ConversationManager()
+    response = conv_manager.process_query(query)
+    return {"response": response}

test3.py

@@ -0,0 +1,726 @@
+import uuid
+import threading
+import asyncio
+import json
+import re
+import random
+import time
+import pickle
+import numpy as np
+import requests  # For llama.cpp server calls
+from datetime import datetime
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+from langgraph.graph import StateGraph, START, END
+import faiss
+from sentence_transformers import SentenceTransformer
+from tools import extract_json_from_response, apply_filters_partial, rule_based_extract, structured_property_data, estateKeywords, sendTokenViaSocket
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.tools import tool
+from langchain_core.callbacks import StreamingStdOutCallbackHandler, CallbackManager
+from langchain_core.callbacks.base import BaseCallbackHandler
+
+# ------------------------ Model Inference Wrapper ------------------------
+
+class ChatQwen:
+    """
+    A chat wrapper for Qwen using llama.cpp.
+    This class can work in two modes:
+      - Local: Using a llama-cpp-python binding (gguf model file loaded locally).
+      - Server: Calling a remote llama.cpp server endpoint.
+    """
+    def __init__(
+        self,
+        temperature=0.3,
+        streaming=False,
+        max_new_tokens=512,
+        callbacks=None,
+        use_server=False,
+        model_path: str = None,
+        server_url: str = None
+    ):
+        self.temperature = temperature
+        self.streaming = streaming
+        self.max_new_tokens = max_new_tokens
+        self.callbacks = callbacks
+        self.use_server = use_server
+
+        if self.use_server:
+            # Use remote llama.cpp server – provide its URL.
+            self.server_url = server_url or "http://localhost:8000"
+        else:
+            # For local inference, a model_path must be provided.
+            if not model_path:
+                raise ValueError("Local mode requires a valid model_path to the gguf file.")
+            from llama_cpp import Llama  # assumes llama-cpp-python is installed
+            self.model = Llama(
+                model_path=model_path,
+                temperature=self.temperature,
+                # n_ctx=512,
+                n_ctx=2048,
+                n_threads=4,  # Adjust as needed
+                batch_size=512,
+            )
+
+    def build_prompt(self, messages: list) -> str:
+        """Build Qwen-compatible prompt with special tokens."""
+        prompt = ""
+        for msg in messages:
+            role = msg["role"]
+            content = msg["content"]
+            if role == "system":
+                prompt += f"<|im_start|>system\n{content}<|im_end|>\n"
+            elif role == "user":
+                prompt += f"<|im_start|>user\n{content}<|im_end|>\n"
+            elif role == "assistant":
+                prompt += f"<|im_start|>assistant\n{content}<|im_end|>\n"
+        prompt += "<|im_start|>assistant\n"
+        return prompt
+
+    def generate_text(self, messages: list) -> str:
+        prompt = self.build_prompt(messages)
+        stop_tokens = ["<|im_end|>", "\n"]  # Qwen's stop sequences
+        
+        if self.use_server:
+            payload = {
+                "prompt": prompt,
+                "max_tokens": self.max_new_tokens,
+                "temperature": self.temperature,
+                "stream": self.streaming,
+                "stop": stop_tokens  # Add stop tokens to server request
+            }
+            if self.streaming:
+                response = requests.post(f"{self.server_url}/generate", json=payload, stream=True)
+                generated_text = ""
+                for line in response.iter_lines():
+                    if line:
+                        token = line.decode("utf-8")
+                        # Check for stop tokens in stream
+                        if any(stop in token for stop in stop_tokens):
+                            break
+                        generated_text += token
+                        if self.callbacks:
+                            for callback in self.callbacks:
+                                callback.on_llm_new_token(token)
+                return generated_text
+            else:
+                response = requests.post(f"{self.server_url}/generate", json=payload)
+                return response.json().get("generated_text", "")
+        else:
+            # Local llama.cpp inference
+            if self.streaming:
+                stream = self.model.create_completion(
+                    prompt=prompt,
+                    max_tokens=self.max_new_tokens,
+                    temperature=self.temperature,
+                    stream=True,
+                    stop=stop_tokens
+                )
+                generated_text = ""
+                for token_chunk in stream:
+                    token_text = token_chunk["choices"][0]["text"]
+                    # Stop early if we detect end token
+                    if any(stop in token_text for stop in stop_tokens):
+                        break
+                    generated_text += token_text
+                    if self.callbacks:
+                        for callback in self.callbacks:
+                            callback.on_llm_new_token(token_text)
+                return generated_text
+            else:
+                result = self.model.create_completion(
+                    prompt=prompt,
+                    max_tokens=self.max_new_tokens,
+                    temperature=self.temperature,
+                    stop=stop_tokens
+                )
+                return result["choices"][0]["text"]
+
+    def invoke(self, messages: list, config: dict = None) -> AIMessage:
+        config = config or {}
+        callbacks = config.get("callbacks", self.callbacks)
+        original_callbacks = self.callbacks
+        self.callbacks = callbacks
+
+        output_text = self.generate_text(messages)
+        self.callbacks = original_callbacks
+
+        # In streaming mode we return an empty content as tokens are being sent via callbacks.
+        if self.streaming:
+            return AIMessage(content="")
+        else:
+            return AIMessage(content=output_text)
+
+    def __call__(self, messages: list) -> AIMessage:
+        return self.invoke(messages)
+
+# ------------------------ Callback for WebSocket Streaming ------------------------
+
+class WebSocketStreamingCallbackHandler(BaseCallbackHandler):
+    def __init__(self, connection_id: str, loop):
+        self.connection_id = connection_id
+        self.loop = loop
+
+    def on_llm_new_token(self, token: str, **kwargs):
+        asyncio.run_coroutine_threadsafe(
+            manager_socket.send_message(self.connection_id, token),
+            self.loop
+        )
+
+# ------------------------ Instantiate the LLM ------------------------
+# Choose one mode: local (set use_server=False) or server (set use_server=True).
+model_path="qwen2.5-1.5b-instruct-q4_k_m.gguf"
+llm = ChatQwen(
+    temperature=0.3,
+    streaming=True,
+    max_new_tokens=512,
+    use_server=False,
+    model_path=model_path,
+    # server_url="http://localhost:8000"  # Uncomment and set if using server mode.
+)
+
+# ------------------------ FAISS and Sentence Transformer Setup ------------------------
+
+index = faiss.read_index("./faiss.index")
+with open("./metadata.pkl", "rb") as f:
+    docs = pickle.load(f)
+st_model = SentenceTransformer('all-MiniLM-L6-v2')
+
+def make_system_prompt(suffix: str) -> str:
+    return (
+        "You are EstateGuru, a real estate expert developed by Abhishek Pathak at SwavishTek. "
+        "Your role is to help customers buy properties using only the provided data—do not invent any details. "
+        "The default currency is AED; if a query mentions another currency, convert the amount to AED "
+        "(for example, convert $10k to 36726.50 AED and $1 to 3.67 AED). "
+        "If a customer is interested in a property or needs to contact an agent, instruct them to call +91 8766268285. "
+        "Keep your answers short, clear, and concise."
+        f"\n{suffix}"
+    )
+
+general_query_prompt = make_system_prompt(
+    "You are EstateGuru, a helpful real estate assistant. "
+    "Please respond only in English. "
+    "Convert any prices to USD before answering. "
+    "Provide a brief, direct answer without extra details."
+)
+
+# ------------------------ Tool Definitions ------------------------
+
+@tool
+def extract_filters(query: str) -> dict:
+    """Extract filters from the query."""
+    llm_local = ChatQwen(temperature=0.3, streaming=False, use_server=False, model_path=model_path)
+    system = (
+        "You are an expert in extracting filters from property-related queries. Your task is to extract and return only the keys explicitly mentioned in the query as a valid JSON object (starting with '{' and ending with '}'). Include only those keys that are directly present in the query.\n\n"
+        "The possible keys are:\n"
+        "  - 'projectName': The name of the project.\n"
+        "  - 'developerName': The developer's name.\n"
+        "  - 'relationshipManager': The relationship manager.\n"
+        "  - 'propertyAddress': The property address.\n"
+        "  - 'surroundingArea': The area or nearby landmarks.\n"
+        "  - 'propertyType': The type or configuration of the property.\n"
+        "  - 'amenities': Any amenities mentioned.\n"
+        "  - 'coveredParking': Parking availability.\n"
+        "  - 'petRules': Pet policies.\n"
+        "  - 'security': Security details.\n"
+        "  - 'occupancyRate': Occupancy information.\n"
+        "  - 'constructionImpact': Construction or its impact.\n"
+        "  - 'propertySize': Size of the property.\n"
+        "  - 'propertyView': View details.\n"
+        "  - 'propertyCondition': Condition of the property.\n"
+        "  - 'serviceCharges': Service or maintenance charges.\n"
+        "  - 'ownershipType': Ownership type.\n"
+        "  - 'totalCosts': A cost threshold or cost amount.\n"
+        "  - 'paymentPlans': Payment or financing plans.\n"
+        "  - 'expectedRentalYield': Expected rental yield.\n"
+        "  - 'rentalHistory': Rental history.\n"
+        "  - 'shortTermRentals': Short-term rental information.\n"
+        "  - 'resalePotential': Resale potential.\n"
+        "  - 'uniqueId': A unique identifier.\n\n"
+        "Important instructions regarding cost thresholds:\n"
+        "  - If the query contains phrases like 'under 10k', 'below 2m', or 'less than 5k', interpret these as cost thresholds.\n"
+        "  - Convert any shorthand cost values to pure numbers (for example, '10k' becomes 10000, '2m' becomes 2000000) and assign them to the key 'totalCosts'.\n"
+        "  - Do not use 'propertySize' for cost thresholds.\n\n"
+        "  - Default currency is AED, if user query have different currency symbol then convert to equivalent AED amount (eg. $10k becomes 36726.50, $1 becomes 3.67).\n\n"
+        "Example:\n"
+        "  For the query: \"properties near dubai mall under 43k\"\n"
+        "  The expected output should be:\n"
+        "    { \"surroundingArea\": \"dubai mall\", \"totalCosts\": 43000 }\n\n"
+        "Return ONLY a valid JSON object with the extracted keys and their corresponding values, with no additional text."
+    )
+
+    human_str = f"Here is the query:\n{query}"
+    filter_prompt = [
+        {"role": "system", "content": system},
+        {"role": "user", "content": human_str},
+    ]
+    response = llm_local.invoke(messages=filter_prompt)
+    response_text = response.content if isinstance(response, AIMessage) else str(response)
+    try:
+        model_filters = extract_json_from_response(response_text)
+    except Exception as e:
+        print(f"JSON parsing error: {e}")
+        model_filters = {}
+    rule_filters = rule_based_extract(query)
+    print("Rule-based extraction:", rule_filters)
+    final_filters = {**model_filters, **rule_filters}
+    print("Final extraction:", final_filters)
+    return {"filters": final_filters}
+
+
+@tool
+def determine_route(query: str) -> dict:
+    """Determine the route (search, suggest, detail, general, out_of_domain) for the query."""
+    real_estate_keywords = estateKeywords
+    pattern = re.compile("|".join(re.escape(keyword) for keyword in real_estate_keywords), re.IGNORECASE)
+    positive_signal = bool(pattern.search(query))
+
+    llm_local = ChatQwen(temperature=0.3, streaming=False, use_server=False, model_path=model_path)
+    transform_suggest_to_list = query.lower().replace("suggest ", "list ", -1)
+    system = """
+    Classify the user query as:
+    
+    - **"search"**: if it requests property listings with specific filters (e.g., location, price, property type like "2bhk", service charges, pet policies, etc.).
+    - **"suggest"**: if it asks for property suggestions without filters.
+    - **"detail"**: if it is asking for more information about a previously provided property (for example, "tell me more about property 5" or "I want more information regarding 4BHK").
+    - **"general"**: for all other real estate-related questions.
+    - **"out_of_domain"**: if the query is not related to real estate (for example, tourist attractions, restaurants, etc.).
+    
+    Keep in mind that queries mentioning terms like "service charge", "allow pets", "pet rules", etc., are considered real estate queries.
+    
+    Return only the keyword: search, suggest, detail, general, or out_of_domain.
+    """
+    human_str = f"Here is the query:\n{transform_suggest_to_list}"
+    router_prompt = [
+        {"role": "system", "content": system},
+        {"role": "user", "content": human_str},
+    ]
+    
+    response = llm_local.invoke(messages=router_prompt)
+    response_text = response.content if isinstance(response, AIMessage) else str(response)
+    route_value = str(response_text).strip().lower()
+
+    # --- NEW: Force 'detail' if query explicitly mentions a specific property (e.g., "property 2") ---
+    property_detail_pattern = re.compile(r"property\s+\d+", re.IGNORECASE)
+    if property_detail_pattern.search(query):
+        route_value = "detail"
+
+    # Fallback override if query appears detailed.
+    detail_phrases = [
+        "more information", "tell me more", "more details", "give me more details",
+        "i need more details", "can you provide more details", "additional details",
+        "further information", "expand on that", "explain further", "elaborate more",
+        "more specifics", "i want to know more", "could you elaborate", "need more info",
+        "provide more details", "detail it further", "in-depth information", "break it down further",
+        "further explanation", "property 1", "property1", "first property", "about the 2nd", "regarding number 3"
+    ]
+    if any(phrase in query.lower() for phrase in detail_phrases):
+        route_value = "detail"
+
+    if route_value not in {"search", "suggest", "detail", "general", "out_of_domain"}:
+        route_value = "general"
+    if route_value == "out_of_domain" and positive_signal:
+        route_value = "general"
+    if route_value == "out_of_domain":
+        route_value = "general" if positive_signal else "out_of_domain"
+        
+    return {"route": route_value}
+
+# ------------------------ Workflow Setup ------------------------
+
+workflow = StateGraph(state_schema=dict)
+
+def route_query(state: dict) -> dict:
+    new_state = state.copy()
+    try:
+        new_state["route"] = determine_route.invoke(new_state.get("query", "")).get("route", "general")
+        print(new_state["route"])
+    except Exception as e:
+        print(f"Routing error: {e}")
+        new_state["route"] = "general"
+    return new_state
+
+def hybrid_extract(state: dict) -> dict:
+    new_state = state.copy()
+    new_state["filters"] = extract_filters.invoke(new_state.get("query", "")).get("filters", {})
+    return new_state
+
+def search_faiss(state: dict) -> dict:
+    new_state = state.copy()
+    # Preserve previous properties until new ones are fetched:
+    new_state.setdefault("current_properties", state.get("current_properties", []))
+    query_embedding = st_model.encode([state["query"]])
+    _, indices = index.search(query_embedding.astype(np.float32), 5)
+    new_state["faiss_results"] = [docs[idx] for idx in indices[0] if idx < len(docs)]
+    return new_state
+
+def apply_filters(state: dict) -> dict:
+    new_state = state.copy()
+    new_state["final_results"] = apply_filters_partial(state["faiss_results"], state.get("filters", {}))
+    return new_state
+
+def suggest_properties(state: dict) -> dict:
+    new_state = state.copy()
+    new_state["suggestions"] = random.sample(docs, 5)
+    # Explicitly update current_properties only when new listings are fetched
+    new_state["current_properties"] = new_state["suggestions"]
+    return new_state
+
+def handle_out_of_domain(state: dict) -> dict:
+    new_state = state.copy()
+    new_state["response"] = "I only handle real estate inquiries. Please ask a question related to properties."
+    return new_state
+
+
+
+def generate_response(state: dict) -> dict:
+    new_state = state.copy()
+    messages = []
+    
+    # Add the general query prompt.
+    messages.append({"role": "system", "content": general_query_prompt})
+    
+    # For detail queries (specific property queries), add extra instructions.
+    if new_state.get("route", "general") == "detail":
+        messages.append({
+            "role": "system",
+            "content": (
+                "The user is asking about a specific property from the numbered list below. "
+                "Properties are listed as 1, 2, 3, etc. Use ONLY the corresponding property details. "
+                "For example, if the user says 'property 2', respond using only the details from the second entry. Never invent data."
+            )
+        })
+        
+    if new_state.get("current_properties"):
+        # Format properties with indices starting at 1
+        property_context = format_property_data_with_indices(new_state["current_properties"])
+        messages.append({"role": "system", "content": "Available Properties:\n" + property_context})
+        messages.append({"role": "system", "content": "When responding, use only the provided property details."})
+    
+    # for msg in state.get("messages", []): // todo: remove previous listing data and keep only last
+    #     if(msg["role"] == "system" and msg["content"].in)
+    
+    
+    # Add conversation history
+    # Truncate conversation history (last 2 exchanges)
+    truncated_history = state.get("messages", [])[-4:]  # Last 2 user+assistant pairs
+    for msg in truncated_history:
+        messages.append({"role": msg["role"], "content": msg["content"]})
+
+    connection_id = state.get("connection_id")
+    loop = state.get("loop")
+    if connection_id and loop:
+        print("Using WebSocket streaming")
+        callback_manager = [WebSocketStreamingCallbackHandler(connection_id, loop)]
+        _ = llm.invoke(
+            messages,
+            config={"callbacks": callback_manager}
+        )
+        new_state["response"] = ""
+    else:
+        callback_manager = [StreamingStdOutCallbackHandler()]
+        response = llm.invoke(
+            messages,
+            config={"callbacks": callback_manager}
+        )
+        new_state["response"] = response.content if isinstance(response, AIMessage) else str(response)
+    
+    return new_state
+
+
+def format_property_data_with_indices(properties: list) -> str:
+    formatted = []
+    for idx, prop in enumerate(properties, 1):
+        cost = prop.get("totalCosts", "N/A")
+        cost_str = f"{cost:,}" if isinstance(cost, (int, float)) else cost
+        formatted.append(
+            f"{idx}. Type: {prop['propertyType']}, Cost: AED {cost_str}, "
+            f"Size: {prop.get('propertySize', 'N/A')}, Amenities: {', '.join(prop.get('amenities', []))}, "
+            f"Rental Yield: {prop.get('expectedRentalYield', 'N/A')}, "
+            f"Ownership: {prop.get('ownershipType', 'N/A')}"
+        )
+    return "\n".join(formatted)
+
+
+def format_final_response(state: dict) -> dict:
+    new_state = state.copy()
+    
+    if state.get("route") in ["search", "suggest"]:
+        if "final_results" in state:
+            new_state["current_properties"] = state["final_results"]
+        elif "suggestions" in state:
+            new_state["current_properties"] = state["suggestions"]
+    elif "current_properties" in new_state:
+        new_state["current_properties"] = state["current_properties"]
+    
+    
+    # print("state: ", json.dumps(new_state), "\n\n")
+    # Format the property details if available.
+    # if new_state.get("current_properties"):
+    if state.get("route") in ["search", "suggest"] and new_state.get("current_properties"):
+        formatted = structured_property_data(state=new_state)
+        
+        # for idx, prop in enumerate(new_state["current_properties"], 1):
+        #     cost = prop.get("totalCosts", "N/A")
+        #     cost_str = f"{cost:,}" if isinstance(cost, (int, float)) else cost
+        #     formatted.append(
+        #         f"{idx}. Type: {prop['propertyType']}, Cost: AED {cost_str}, "
+        #         f"Size: {prop.get('propertySize', 'N/A')}, Amenities: {', '.join(map(str, prop.get('amenities', []))) if prop.get('amenities') else 'N/A'}, "
+        #         f"Rental Yield: {prop.get('expectedRentalYield', 'N/A')}, "
+        #         f"Ownership: {prop.get('ownershipType', 'N/A')}\n"
+        #     )
+        aggregated_response = "Here are the property details:\n" + "\n".join(formatted)
+        # print(aggregated_response)
+        
+        connection_id = state.get("connection_id")
+        loop = state.get("loop")
+        if connection_id and loop:
+            import time
+            tokens = aggregated_response.split(" ")
+            for token in tokens:
+                asyncio.run_coroutine_threadsafe(
+                    manager_socket.send_message(connection_id, token + " "),
+                    loop
+                )
+                time.sleep(0.05)
+            new_state["response"] = ""
+        else:
+            new_state["response"] = aggregated_response
+    elif "response" in new_state:
+        connection_id = state.get("connection_id")
+        loop = state.get("loop")
+        if connection_id and loop:
+            import time
+            tokens = str(new_state["response"]).split(" ")
+            for token in tokens:
+                asyncio.run_coroutine_threadsafe(
+                    manager_socket.send_message(connection_id, token + " "),
+                    loop
+                )
+                time.sleep(0.05)
+        new_state["response"] = str(new_state["response"])
+        
+    return new_state
+
+
+
+nodes = [
+    ("route_query", route_query),
+    ("hybrid_extract", hybrid_extract),
+    ("faiss_search", search_faiss),
+    ("apply_filters", apply_filters),
+    ("suggest_properties", suggest_properties),
+    ("handle_out_of_domain", handle_out_of_domain),
+    ("generate_response", generate_response),
+    ("format_response", format_final_response)
+]
+
+for name, node in nodes:
+    workflow.add_node(name, node)
+
+workflow.add_edge(START, "route_query")
+workflow.add_conditional_edges(
+    "route_query",
+    lambda state: state.get("route", "general"),
+    {
+        "search": "hybrid_extract", 
+        "suggest": "suggest_properties", 
+        "detail": "generate_response", 
+        "general": "generate_response", 
+        "out_of_domain": "handle_out_of_domain"
+    }
+)
+workflow.add_edge("hybrid_extract", "faiss_search")
+workflow.add_edge("faiss_search", "apply_filters")
+workflow.add_edge("apply_filters", "format_response")
+workflow.add_edge("suggest_properties", "format_response")
+workflow.add_edge("generate_response", "format_response")
+workflow.add_edge("handle_out_of_domain", "format_response")
+workflow.add_edge("format_response", END)
+
+workflow_app = workflow.compile()
+
+# ------------------------ Conversation Manager ------------------------
+
+class ConversationManager:
+    def __init__(self):
+        # Each connection gets its own conversation history and state.
+        self.conversation_history = []
+        # current_properties stores the current property listing.
+        self.current_properties = []
+
+    def _add_message(self, role: str, content: str):
+        self.conversation_history.append({
+            "role": role,
+            "content": content,
+            "timestamp": datetime.now().isoformat()
+        })
+
+    def process_query(self, query: str) -> str:
+        # For greeting messages, reset history/state. // post request
+        if query.strip().lower() in {"hi", "hello", "hey"}:
+            self.conversation_history = []
+            self.current_properties = []
+            greeting_response = "Hello! How can I assist you today with your real estate inquiries?"
+            self._add_message("assistant", greeting_response)
+            return greeting_response
+
+        try:
+            self._add_message("user", query)
+            initial_state = {
+                "messages": self.conversation_history.copy(),
+                "query": query,
+                "route": "general",
+                "filters": {},
+                "current_properties": self.current_properties
+            }
+            for event in workflow_app.stream(initial_state, stream_mode="values"):
+                final_state = event
+            # Only update property listings if a new listing is fetched
+            # if 'final_results' in final_state:
+            #     self.current_properties = final_state['final_results']
+            # elif 'suggestions' in final_state:
+            #     self.current_properties = final_state['suggestions']
+            self.current_properties = final_state.get("current_properties", [])
+            
+            if final_state.get("route") == "general":
+                response_text = final_state.get("response", "")
+                self._add_message("assistant", response_text)
+                return response_text
+            else:
+                response = final_state.get("response", "I couldn't process that request.")
+                self._add_message("assistant", response)
+                return response
+        except Exception as e:
+            print(f"Processing error: {e}")
+            return "Sorry, I encountered an error processing your request."
+
+
+
+conversation_managers = {}
+
+# ------------------------ FastAPI Backend with WebSockets ------------------------
+
+app = FastAPI()
+
+class ConnectionManager:
+    def __init__(self):
+        self.active_connections = {}
+
+    async def connect(self, websocket: WebSocket):
+        await websocket.accept()
+        connection_id = str(uuid.uuid4())
+        self.active_connections[connection_id] = websocket
+        print(f"New connection: {connection_id}")
+        return connection_id
+
+    def disconnect(self, connection_id: str):
+        if connection_id in self.active_connections:
+            del self.active_connections[connection_id]
+            print(f"Disconnected: {connection_id}")
+
+    async def send_message(self, connection_id: str, message: str):
+        websocket = self.active_connections.get(connection_id)
+        if websocket:
+            await websocket.send_text(message)
+
+manager_socket = ConnectionManager()
+
+def stream_query(query: str, connection_id: str, loop):
+    conv_manager = conversation_managers.get(connection_id)
+    if conv_manager is None:
+        print(f"No conversation manager found for connection {connection_id}")
+        return
+
+    if query.strip().lower() in {"hi", "hello", "hey"}:
+        conv_manager.conversation_history = []
+        conv_manager.current_properties = []
+        greeting_response = "Hello! How can I assist you today with your real estate inquiries?"
+        conv_manager._add_message("assistant", greeting_response)
+        sendTokenViaSocket(
+            state={"connection_id": connection_id, "loop": loop},
+            manager_socket=manager_socket,
+            message=greeting_response
+        )
+        # asyncio.run_coroutine_threadsafe(
+        #     manager_socket.send_message(connection_id, greeting_response),
+        #     loop
+        # )
+        return
+
+    conv_manager._add_message("user", query)
+    initial_state = {
+        "messages": conv_manager.conversation_history.copy(),
+        "query": query,
+        "route": "general",
+        "filters": {},
+        "current_properties": conv_manager.current_properties,
+        "connection_id": connection_id,
+        "loop": loop
+    }
+    # try:
+    #     workflow_app.invoke(initial_state)
+    # except Exception as e:
+    #     error_msg = f"Error processing query: {str(e)}"
+    #     asyncio.run_coroutine_threadsafe(
+    #         manager_socket.send_message(connection_id, error_msg),
+    #         loop
+    #     )
+    try:
+        # Capture all states during execution
+        # final_state = None
+        # for event in workflow_app.stream(initial_state, stream_mode="values"):
+        #     final_state = event
+        
+        # # Update conversation manager with final state
+        # if final_state:
+        #     conv_manager.current_properties = final_state.get("current_properties", [])
+        #     if final_state.get("response"):
+        #         conv_manager._add_message("assistant", final_state["response"])
+        final_state = None
+        for event in workflow_app.stream(initial_state, stream_mode="values"):
+            final_state = event
+        
+        if final_state:
+            # Always update current_properties from final state
+            conv_manager.current_properties = final_state.get("current_properties", [])
+            # Keep conversation history bounded
+            conv_manager.conversation_history = conv_manager.conversation_history[-6:]  # Last 3 exchanges
+            
+    except Exception as e:
+        error_msg = f"Error processing query: {str(e)}"
+        asyncio.run_coroutine_threadsafe(
+            manager_socket.send_message(connection_id, error_msg),
+            loop
+        )
+        
+        
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    connection_id = await manager_socket.connect(websocket)
+    # Each connection maintains its own conversation manager.
+    conversation_managers[connection_id] = ConversationManager()
+    try:
+        while True:
+            query = await websocket.receive_text()
+            loop = asyncio.get_event_loop()
+            threading.Thread(
+                target=stream_query,
+                args=(query, connection_id, loop),
+                daemon=True
+            ).start()
+    except WebSocketDisconnect:
+        conv_manager = conversation_managers.get(connection_id)
+        if conv_manager:
+            filename = f"conversations/conversation_{connection_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+            with open(filename, "w") as f:
+                json.dump(conv_manager.conversation_history, f, indent=4)
+            del conversation_managers[connection_id]
+        manager_socket.disconnect(connection_id)
+
+@app.post("/query")
+async def post_query(query: str):
+    conv_manager = ConversationManager()
+    response = conv_manager.process_query(query)
+    return {"response": response}

tools.py

@@ -1,7 +1,8 @@
 import random
 import json
 import re
-
+import asyncio
+import time
 # if no document found suggest some ...
 # "  - Remove currency symbol if present, convert currency to AED if user mentioned currency symbol other than AED.\n\n"
 def extract_json_from_response(response):
@@ -32,6 +33,19 @@ def extract_json_from_response(response):
 
 
 
+def sendTokenViaSocket(state, manager_socket, message):
+    connection_id = state.get("connection_id")
+    loop = state.get("loop")
+    if connection_id and loop:
+        tokens = message.split(" ")
+        for token in tokens:
+            asyncio.run_coroutine_threadsafe(
+                manager_socket.send_message(connection_id, token + " "),
+                loop
+            )
+            time.sleep(0.05)
+
+
 def rule_based_extract(query):
     """
     A lightweight extraction using regular expressions.
@@ -123,6 +137,39 @@ def format_property_data(properties: list) -> str:
     return "\n".join(formatted)
 
 
+def structured_property_data(state):
+    structured_data = []
+        
+        # Add list start with count
+    property_count = len(state["current_properties"])
+    structured_data.append(f"PROPERTY_LIST_START||{property_count}\n\n")
+        
+    # Add each property item
+    for idx, prop in enumerate(state["current_properties"], 1):
+        # Format cost with commas if numeric
+        cost = prop.get("totalCosts", "N/A")
+        cost_str = f"AED {cost:,}" if isinstance(cost, (int, float)) else cost
+            
+        # Format amenities
+        amenities = ', '.join(map(str, prop.get('amenities', []))) if prop.get('amenities') else 'N/A'
+            
+            # Build property item
+        item = [
+                f"ITEM_START||{prop.get("uniqueId")}||{idx}",
+                f"Type: {prop.get('propertyType', 'N/A')}",
+                f"Cost: {cost_str}",
+                f"Size: {prop.get('propertySize', 'N/A')}",
+                f"Amenities: {amenities}",
+                f"Rental Yield: {prop.get('expectedRentalYield', 'N/A')}",
+                f"Ownership: {prop.get('ownershipType', 'N/A')}",
+                "ITEM_END\n"
+            ]
+            
+        structured_data.append("\n".join(item) + "\n")
+        
+        # Add list end marker
+    structured_data.append("PROPERTY_LIST_END")
+    return structured_data