Update app.py

app.py

@@ -134,9 +134,10 @@
 #     )
 
 
+
 """
-🏥 Pharmacy RAG System - Advanced Multi-Agent Architecture
-Uses: OpenRouter (GPT-4o-mini + text-embedding-3-small), Qdrant, NetworkX
+🏥 Pharmacy RAG System - Interactive Chat Support Version
+تعاملی - سوال‌محور - مشاوره‌ای
 """
 
 import os
@@ -168,8 +169,8 @@ OPENROUTER_API_KEY = "sk-or-v1-23bc69e32d37529bd5143ae2bb542552c44fbe1fc696d4a84
 QDRANT_URL = "http://130.185.121.155:6333"
 COLLECTION_NAME = "pharmacy_products"
 
-LLM_MODEL = "openai/gpt-4.1-mini"  # برای reasoning
-EMBEDDING_MODEL = "openai/text-embedding-3-small"  # برای embeddings
+LLM_MODEL = "openai/gpt-4o-mini"
+EMBEDDING_MODEL = "openai/text-embedding-3-small"
 
 
 # ============================================================================
@@ -190,9 +191,10 @@ class Product:
 @dataclass
 class QueryIntent:
     """مدل intent شناسایی شده"""
-    intent_type: str  # simple_lookup, comparison, complex_reasoning
+    intent_type: str
     extracted_symptoms: List[str]
     extracted_products: List[str]
+    missing_info: List[str]
     requires_graph: bool
     confidence: float
 
@@ -228,11 +230,10 @@ class OpenRouterClient:
             return result['data'][0]['embedding']
         except Exception as e:
             print(f"❌ Embedding Error: {e}")
-            # Fallback: return zero vector
             return [0.0] * 1536
     
-    def generate(self, messages: List[Dict], temperature: float = 0.7, max_tokens: int = 1500) -> str:
-        """تولید متن با LLM"""
+    def generate(self, messages: List[Dict], temperature: float = 0.7, max_tokens: int = 800) -> str:
+        """تولید متن با LLM - محدودیت طول برای پاسخ‌های کوتاه‌تر"""
         url = f"{self.base_url}/chat/completions"
         
         payload = {
@@ -260,22 +261,20 @@ class VectorDB:
     """مدیریت Qdrant Vector Database"""
     
     def __init__(self, url: str, collection_name: str):
-        self.client = QdrantClient(url=url, timeout=60)  # افزایش timeout به 60 ثانیه
+        self.client = QdrantClient(url=url, timeout=60)
         self.collection_name = collection_name
         self.fallback_mode = False
-        self.fallback_vectors = []  # برای حالت fallback
+        self.fallback_vectors = []
         self.fallback_metadata = []
         
     def create_collection(self, vector_size: int = 1536):
         """ساخت collection"""
         try:
-            # بررسی وجود collection
             collections = self.client.get_collections().collections
             if any(c.name == self.collection_name for c in collections):
                 print(f"✅ Collection '{self.collection_name}' already exists")
                 return
             
-            # ساخت collection جدید
             self.client.create_collection(
                 collection_name=self.collection_name,
                 vectors_config=VectorParams(size=vector_size, distance=Distance.COSINE)
@@ -287,8 +286,7 @@ class VectorDB:
     def upsert_points(self, points: List[PointStruct]):
         """اضافه کردن points به collection"""
         try:
-            # تقسیم به batch های کوچکتر برای جلوگیری از timeout
-            batch_size = 5  # کاهش به 5 برای جلوگیری از timeout
+            batch_size = 5
             total = len(points)
             failed_batches = 0
             
@@ -296,7 +294,6 @@ class VectorDB:
                 batch = points[i:i+batch_size]
                 print(f"   Uploading batch {i//batch_size + 1}/{(total + batch_size - 1)//batch_size}...")
                 
-                # تلاش مجدد در صورت خطا
                 max_retries = 3
                 batch_failed = True
                 for attempt in range(max_retries):
@@ -304,7 +301,7 @@ class VectorDB:
                         self.client.upsert(
                             collection_name=self.collection_name,
                             points=batch,
-                            wait=True  # صبر برای تکمیل
+                            wait=True
                         )
                         batch_failed = False
                         break
@@ -312,7 +309,6 @@ class VectorDB:
                         if attempt == max_retries - 1:
                             print(f"   ⚠️ Failed batch {i//batch_size + 1}: {e}")
                             failed_batches += 1
-                            # ذخیره در fallback
                             for point in batch:
                                 self.fallback_vectors.append(point.vector)
                                 self.fallback_metadata.append(point.payload)
@@ -328,7 +324,6 @@ class VectorDB:
             print(f"✅ Upserted {len(points)} points (with batching)")
         except Exception as e:
             print(f"❌ Error upserting points: {e}")
-            # فعال کردن حالت fallback
             self.fallback_mode = True
             for point in points:
                 self.fallback_vectors.append(point.vector)
@@ -337,7 +332,6 @@ class VectorDB:
     
     def search(self, query_vector: List[float], limit: int = 5) -> List[Dict]:
         """جستجوی vector"""
-        # اگر در حالت fallback هستیم
         if self.fallback_mode and self.fallback_vectors:
             return self._search_fallback(query_vector, limit)
         
@@ -360,7 +354,6 @@ class VectorDB:
             ]
         except Exception as e:
             print(f"❌ Search error: {e}")
-            # تلاش با fallback
             if self.fallback_vectors:
                 print(f"   Using in-memory fallback...")
                 return self._search_fallback(query_vector, limit)
@@ -375,7 +368,6 @@ class VectorDB:
         
         for i, vec in enumerate(self.fallback_vectors):
             vec_arr = np.array(vec)
-            # محاسبه cosine similarity
             similarity = np.dot(query_vec, vec_arr) / (np.linalg.norm(query_vec) * np.linalg.norm(vec_arr))
             results.append({
                 "id": i,
@@ -383,7 +375,6 @@ class VectorDB:
                 "payload": self.fallback_metadata[i]
             })
         
-        # مرتب‌سازی بر اساس score
         results.sort(key=lambda x: x["score"], reverse=True)
         return results[:limit]
 
@@ -451,38 +442,58 @@ class KnowledgeGraph:
 
 
 # ============================================================================
-# QUERY UNDERSTANDING AGENT
+# QUERY UNDERSTANDING AGENT (تغییر اساسی اینجا)
 # ============================================================================
 
 class QueryUnderstandingAgent:
-    """Agent درک query کاربر"""
+    """Agent درک query کاربر - نسخه تعاملی"""
     
     def __init__(self, llm: OpenRouterClient):
         self.llm = llm
     
-    def analyze_query(self, query: str) -> QueryIntent:
-        """تحلیل query و استخراج intent"""
+    def analyze_query(self, query: str, conversation_history: List[Dict] = None) -> QueryIntent:
+        """تحلیل query و تشخیص نیاز به اطلاعات بیشتر"""
+        
+        history_context = ""
+        if conversation_history and len(conversation_history) > 1:
+            recent_msgs = conversation_history[-6:]  # 6 پیام آخر
+            history_context = "\n\nتاریخچه مکالمه:\n" + "\n".join([
+                f"{msg['role']}: {msg['content'][:150]}" 
+                for msg in recent_msgs
+            ])
         
-        prompt = f"""تو یک متخصص تحلیل سوالات پزشکی هستی. سوال کاربر را تحلیل کن:
+        prompt = f"""تو یک متخصص تحلیل گفتگوهای مشاوره داروخانه هستی.
+
+پیام جدید کاربر: "{query}"
+{history_context}
 
-سوال: "{query}"
+**وظیفه تو**: تشخیص بده که آیا اطلاعات کافی برای پیشنهاد محصول داریم یا نه.
 
-لطفا خروجی را به صورت JSON برگردان:
+اطلاعات لازم برای پیشنهاد محصول:
+1. نوع مشکل (جوش، لک، چربی زیاد، خشکی و...)
+2. نوع پوست (چرب، خشک، مختلط، حساس)
+3. شدت مشکل (خفیف، متوسط، شدید)
+4. محدودیت بودجه (اقتصادی یا نامحدود)
+
+خروجی JSON:
 {{
-    "intent_type": "simple_lookup یا comparison یا complex_reasoning",
-    "extracted_symptoms": ["لیست علائم"],
-    "extracted_products": ["لیست نام محصولات"],
-    "requires_graph": true/false,
+    "intent_type": "needs_clarification" یا "ready_to_recommend",
+    "extracted_symptoms": ["علائم ذکر شده"],
+    "extracted_products": ["محصولات خاص ذکر شده"],
+    "skin_type_mentioned": true/false,
+    "severity_mentioned": true/false,
+    "budget_mentioned": true/false,
+    "missing_info": ["چه اطلاعاتی کم است"],
+    "requires_graph": false,
     "confidence": 0.0-1.0
 }}
 
-فقط JSON برگردان، هیچ توضیح اضافه نده."""
+فقط JSON برگردان، بدون توضیح."""
 
         messages = [{"role": "user", "content": prompt}]
-        response = self.llm.generate(messages, temperature=0.3)
+        response = self.llm.generate(messages, temperature=0.2, max_tokens=400)
         
         try:
-            # پاک کردن markdown و استخراج JSON
             clean_response = response.strip()
             if "```json" in clean_response:
                 clean_response = clean_response.split("```json")[1].split("```")[0]
@@ -492,21 +503,22 @@ class QueryUnderstandingAgent:
             intent_data = json.loads(clean_response.strip())
             
             return QueryIntent(
-                intent_type=intent_data.get("intent_type", "simple_lookup"),
+                intent_type=intent_data.get("intent_type", "needs_clarification"),
                 extracted_symptoms=intent_data.get("extracted_symptoms", []),
                 extracted_products=intent_data.get("extracted_products", []),
+                missing_info=intent_data.get("missing_info", []),
                 requires_graph=intent_data.get("requires_graph", False),
                 confidence=intent_data.get("confidence", 0.5)
             )
         except Exception as e:
             print(f"⚠️ Intent parsing error: {e}")
-            # Fallback
             return QueryIntent(
-                intent_type="simple_lookup",
+                intent_type="needs_clarification",
                 extracted_symptoms=[],
                 extracted_products=[],
+                missing_info=["نوع پوست", "شدت مشکل"],
                 requires_graph=False,
-                confidence=0.5
+                confidence=0.3
             )
 
 
@@ -522,19 +534,14 @@ class RetrievalAgent:
         self.kg = knowledge_graph
         self.llm = llm
     
-    def retrieve(self, query: str, intent: QueryIntent, top_k: int = 5) -> List[Dict]:
-        """بازیابی اطلاعات بر اساس intent"""
+    def retrieve(self, query: str, intent: QueryIntent, top_k: int = 3) -> List[Dict]:
+        """بازیابی اطلاعات - فقط top 3 برای پاسخ کوتاه‌تر"""
         
-        # دریافت embedding
         query_vector = self.llm.get_embedding(query)
-        
-        # جستجوی vector
         vector_results = self.vector_db.search(query_vector, limit=top_k)
         
-        # اگر نیاز به graph داریم
         if intent.requires_graph and intent.extracted_symptoms:
             graph_results = self._graph_search(intent.extracted_symptoms)
-            # ترکیب نتایج
             return self._merge_results(vector_results, graph_results)
         
         return vector_results
@@ -543,7 +550,6 @@ class RetrievalAgent:
         """جستجو در graph"""
         results = []
         for symptom in symptoms:
-            # پیدا کردن node های مرتبط
             symptom_clean = symptom.lower().strip()
             related = self.kg.multi_hop_query([symptom_clean], max_hops=2)
             results.append({"symptom": symptom, "graph_data": related})
@@ -577,19 +583,16 @@ class GradingAgent:
                 "relevance_score": score
             })
         
-        # مرتب‌سازی بر اساس نمره
         graded_docs.sort(key=lambda x: x["relevance_score"], reverse=True)
         return graded_docs
     
     def _score_document(self, query: str, doc: Dict) -> float:
         """محاسبه نمره relevance"""
-        # اگر از vector search اومده، از cosine score استفاده کن
         if "score" in doc:
             return doc["score"]
         
-        # در غیر این صورت، از LLM بپرس
         try:
-            doc_text = str(doc.get("payload", doc))[:500]  # محدود کردن طول
+            doc_text = str(doc.get("payload", doc))[:500]
             
             prompt = f"""این document چقدر به سوال کاربر مرتبط است؟
 
@@ -601,63 +604,116 @@ Document: {doc_text}
             messages = [{"role": "user", "content": prompt}]
             response = self.llm.generate(messages, temperature=0.1, max_tokens=10)
             
-            # استخراج عدد
             score = float(re.findall(r'0\.\d+|1\.0', response)[0])
             return score
         except:
-            return 0.5  # نمره پیش‌فرض
+            return 0.5
 
 
 # ============================================================================
-# GENERATION AGENT
+# GENERATION AGENT (تغییر اساسی اینجا)
 # ============================================================================
 
 class GenerationAgent:
-    """Agent تولید پاسخ نهایی"""
+    """Agent تولید پاسخ - نسخه تعاملی و پرسشگر"""
     
     def __init__(self, llm: OpenRouterClient):
         self.llm = llm
     
-    def generate_answer(self, query: str, context_docs: List[Dict]) -> str:
-        """تولید پاسخ نهایی"""
+    def generate_clarification(self, query: str, intent: QueryIntent, conversation_history: List[Dict] = None) -> str:
+        """تولید سوالات برای جمع‌آوری اطلاعات بیشتر"""
+        
+        history_context = ""
+        if conversation_history and len(conversation_history) > 1:
+            history_context = "\n\nمکالمه قبلی:\n" + "\n".join([
+                f"{msg['role']}: {msg['content'][:100]}" 
+                for msg in conversation_history[-4:]
+            ])
+        
+        missing_info_str = ", ".join(intent.missing_info) if intent.missing_info else "اطلاعات تکمیلی"
+        
+        prompt = f"""تو یک مشاور داروخانه دوستانه و حرفه‌ای هستی که می‌خواهی بهترین محصول رو به مشتری پیشنهاد بدی.
+
+پیام مشتری: "{query}"
+{history_context}
+
+اطلاعات ناقص: {missing_info_str}
+
+**وظیفه تو**: 
+- یک سوال کوتاه و دوستانه بپرس تا اطلاعات لازم رو جمع کنی
+- فقط یک سوال در هر پیام (نه لیست سوالات!)
+- خیلی گرم و صمیمی باش
+- اگر مشتری قبلا چیزی گفته، بهش اشاره کن
+
+مثال‌های خوب:
+"باشه! یه سوال، پوست شما چرب هست یا خشک؟ 😊"
+"عالیه! چقدر شدیده این جوش‌ها؟ یعنی زیاده یا فقط گاهی پیش میاد؟"
+"متوجه شدم! به بودجه محدودیتی دارید یا می‌تونید کمی بیشتر خرج کنید؟"
+
+پاسخ کوتاه و دوستانه:"""
+
+        messages = [{"role": "user", "content": prompt}]
+        response = self.llm.generate(messages, temperature=0.8, max_tokens=150)
+        
+        return response.strip()
+    
+    def generate_recommendation(self, query: str, context_docs: List[Dict], conversation_history: List[Dict] = None) -> str:
+        """تولید پیشنهاد نهایی - کوتاه و مختصر"""
         
-        # آماده‌سازی context
         context = self._prepare_context(context_docs)
         
-        prompt = f"""تو یک مشاور داروخانه حرفه‌ای هستی. بر اساس اطلاعات زیر به سوال کاربر پاسخ بده:
+        history_context = ""
+        if conversation_history and len(conversation_history) > 1:
+            history_context = "\n\nخلاصه مکالمه:\n" + "\n".join([
+                f"{msg['role']}: {msg['content'][:80]}" 
+                for msg in conversation_history[-4:]
+            ])
+        
+        prompt = f"""تو یک مشاور داروخانه حرفه‌ای هستی. الان وقت پیشنهاد نهایی است!
+
+{history_context}
 
-سوال کاربر: {query}
+سوال نهایی: {query}
 
-اطلاعات موجود:
+محصولات موجود:
 {context}
 
-راهنمایی‌ها:
-- پاسخ کامل و دقیق بده
-- لینک محصولات را حتما اضافه کن
-- اگر چند محصول هست، تفاوت‌هاشون رو توضیح بده
-- اگر اطلاعات کافی نداری، صادقانه بگو
+**قوانین مهم**:
+1. فقط 1-2 محصول پیشنهاد بده (نه همه!)
+2. توضیح خیلی کوتاه بده (2-3 جمله)
+3. لینک محصول رو حتما بذار
+4. اگر 2 تا پیشنهاد داری، تفاوتشون رو خیلی کوتاه بگو
+5. در آخر بپرس: "سوال دیگه‌ای دارید؟" یا "می‌خواید درباره نحوه استفاده بدونید؟"
+
+مثال پاسخ خوب:
+"برای جوش‌های سرسیاه، سرم مارگریت رو پیشنهاد می‌کنم - خیلی قوی و تخصصیه:
+🔗 [لینک محصول]
+
+اگه بودجه محدودتره، ژل سبوما آردن هم عالیه و ارزون‌تره:
+🔗 [لینک محصول]
 
-پاسخ:"""
+سوال دیگه‌ای دارید؟ 😊"
+
+پاسخ (کوتاه و مفید):"""
 
         messages = [{"role": "user", "content": prompt}]
-        answer = self.llm.generate(messages, temperature=0.7, max_tokens=1500)
+        answer = self.llm.generate(messages, temperature=0.7, max_tokens=400)
         
-        return answer
+        return answer.strip()
     
     def _prepare_context(self, docs: List[Dict]) -> str:
-        """آماده‌سازی context از documents"""
+        """آماده‌سازی context از documents - خلاصه‌تر"""
         context_parts = []
         
-        for i, doc in enumerate(docs[:5], 1):  # فقط top 5
+        for i, doc in enumerate(docs[:3], 1):  # فقط 3 تای اول
             payload = doc.get("payload", {})
             
-            text = f"""
-محصول {i}:
-- دسته‌بندی: {payload.get('category', 'نامشخص')}
-- مشکل: {payload.get('problem', 'نامشخص')}
-- علائم: {payload.get('symptoms', 'نامشخص')}
-- درمان: {payload.get('treatment', 'نامشخص')}
-- لینک: {payload.get('url', 'ندارد')}
+            products_str = ", ".join(payload.get('products', ['نامشخص'])[:2])  # فقط 2 محصول اول
+            url = payload.get('url', payload.get('urls', [''])[0] if payload.get('urls') else '')
+            
+            text = f"""محصول {i}: {products_str}
+مشکل: {payload.get('problem', 'نامشخص')}
+لینک: {url}
 """
             context_parts.append(text)
         
@@ -665,27 +721,25 @@ class GenerationAgent:
 
 
 # ============================================================================
-# MAIN RAG SYSTEM
+# MAIN RAG SYSTEM (تغییر در query method)
 # ============================================================================
 
 class PharmacyRAGSystem:
-    """سیستم RAG کامل داروخانه"""
+    """سیستم RAG کامل داروخانه - نسخه تعاملی"""
     
     def __init__(self):
-        print("🚀 Initializing Pharmacy RAG System...")
+        print("🚀 Initializing Interactive Pharmacy RAG System...")
         
-        # کلاینت‌ها
         self.llm = OpenRouterClient(OPENROUTER_API_KEY)
         self.vector_db = VectorDB(QDRANT_URL, COLLECTION_NAME)
         self.kg = KnowledgeGraph()
         
-        # Agents
         self.query_agent = QueryUnderstandingAgent(self.llm)
         self.retrieval_agent = RetrievalAgent(self.vector_db, self.kg, self.llm)
         self.grading_agent = GradingAgent(self.llm)
         self.generation_agent = GenerationAgent(self.llm)
         
-        print("✅ System initialized!")
+        print("✅ Interactive System initialized!")
     
     def load_data(self, csv_path: str):
         """بارگذاری داده‌ها از CSV"""
@@ -694,19 +748,13 @@ class PharmacyRAGSystem:
         df = pd.read_excel(csv_path)
         products = self._parse_dataframe(df)
         
-        # ساخت collection
         self.vector_db.create_collection()
         
-        # آماده‌سازی points برای Qdrant
         points = []
         for i, product in enumerate(products):
-            # ساخت متن برای embedding
             text = f"{product.problem_title} {product.symptoms} {product.treatment_info}"
-            
-            # دریافت embedding
             vector = self.llm.get_embedding(text)
             
-            # ساخت point
             point = PointStruct(
                 id=i,
                 vector=vector,
@@ -721,11 +769,8 @@ class PharmacyRAGSystem:
                 }
             )
             points.append(point)
-            
-            # ساخت graph
             self._build_graph_from_product(product, i)
         
-        # آپلود به Qdrant
         self.vector_db.upsert_points(points)
         
         print(f"✅ Loaded {len(products)} products!")
@@ -736,10 +781,7 @@ class PharmacyRAGSystem:
         products = []
         
         for _, row in df.iterrows():
-            # استخراج URLs
             urls = re.findall(r'https://[^\s]+', str(row['محصولات پیشنهادی درمانی']))
-            
-            # استخراج نام محصولات
             product_names = re.findall(r'(?:سرم|ژل|کرم|فوم|محلول|اسپری|تونر|فلوئید)\s+[^\n]+', 
                                        str(row['محصولات پیشنهادی درمانی']))
             
@@ -757,11 +799,9 @@ class PharmacyRAGSystem:
     
     def _build_graph_from_product(self, product: Product, product_id: int):
         """ساخت گراف از یک محصول"""
-        # Node برای مشکل
         problem_id = f"problem_{product_id}"
         self.kg.add_node(problem_id, "problem", {"name": product.problem_title})
         
-        # Node برای محصولات
         for i, url in enumerate(product.urls):
             product_node_id = f"product_{product_id}_{i}"
             product_name = product.product_names[i] if i < len(product.product_names) else f"محصول {i+1}"
@@ -771,80 +811,90 @@ class PharmacyRAGSystem:
                 "url": url
             })
             
-            # Edge: مشکل -> محصول
             self.kg.add_edge(problem_id, product_node_id, "TREATED_BY")
     
-    def query(self, user_query: str) -> str:
-        """پردازش query کاربر"""
+    def query(self, user_query: str, conversation_history: List[Dict] = None) -> str:
+        """پردازش query کاربر - با رویکرد تعاملی"""
         print(f"\n🔍 Processing query: {user_query}")
         
         # مرحله 1: فهم query
-        intent = self.query_agent.analyze_query(user_query)
+        intent = self.query_agent.analyze_query(user_query, conversation_history)
         print(f"   Intent: {intent.intent_type} (confidence: {intent.confidence:.2f})")
         
-        # مرحله 2: بازیابی
-        retrieved_docs = self.retrieval_agent.retrieve(user_query, intent, top_k=5)
+        # **تصمیم‌گیری: سوال بپرس یا پاسخ بده؟**
+        if intent.intent_type == "needs_clarification" and intent.confidence > 0.4:
+            # نیاز به سوال داریم
+            print(f"   -> Need more info: {intent.missing_info}")
+            return self.generation_agent.generate_clarification(user_query, intent, conversation_history)
+        
+        # مرحله 2: بازیابی (فقط اگر آماده پیشنهاد هستیم)
+        retrieved_docs = self.retrieval_agent.retrieve(user_query, intent, top_k=3)
         print(f"   Retrieved: {len(retrieved_docs)} documents")
         
         # مرحله 3: ارزیابی
         graded_docs = self.grading_agent.grade_relevance(user_query, retrieved_docs)
         print(f"   Top score: {graded_docs[0]['relevance_score']:.2f}")
         
-        # مرحله 4: تولید پاسخ
-        answer = self.generation_agent.generate_answer(user_query, graded_docs)
+        # مرحله 4: تولید پاسخ نهایی
+        answer = self.generation_agent.generate_recommendation(user_query, graded_docs, conversation_history)
         
         return answer
 
 
 # ============================================================================
-# GRADIO UI
+# GRADIO UI (تغییر برای نگهداری تاریخچه)
 # ============================================================================
 
 def create_gradio_interface(rag_system: PharmacyRAGSystem):
-    """ساخت رابط کاربری Gradio"""
+    """ساخت رابط کاربری Gradio - با تاریخچه مکالمه"""
     
     def chat(message, history):
-        """تابع چت"""
+        """تابع چت با تاریخچه"""
         try:
-            answer = rag_system.query(message)
+            # تبدیل history به فرمت مورد نیاز
+            conversation_history = []
+            for h in history:
+                conversation_history.append({"role": "user", "content": h[0]})
+                conversation_history.append({"role": "assistant", "content": h[1]})
+            
+            # اضافه کردن پیام جدید
+            conversation_history.append({"role": "user", "content": message})
+            
+            # دریافت پاسخ
+            answer = rag_system.query(message, conversation_history)
             return answer
         except Exception as e:
             return f"❌ خطا: {str(e)}"
     
-    # طراحی UI با Gradio 6.0
-    with gr.Blocks(title="🏥 سیستم مشاوره داروخانه") as demo:
+    with gr.Blocks(title="🏥 مشاور هوشمند داروخانه", theme=gr.themes.Soft()) as demo:
         gr.Markdown("""
-        # 🏥 سیستم هوشمند مشاوره داروخانه
-        ### مبتنی بر هوش مصنوعی - RAG با معماری Multi-Agent
+        # 🏥 مشاور هوشمند داروخانه
+        ### چت پشتیبانی تعاملی - با هوش مصنوعی
         
-        سوالات خود درباره مشکلات پوستی و محصولات مناسب را بپرسید!
+        سلام! من دستیار شما هستم. می‌خوام بهترین محصول رو برای شما پیدا کنم 😊
         """)
         
-        # استفاده از ChatInterface ساده
         chatbot = gr.ChatInterface(
             fn=chat,
             examples=[
-                "محصول مناسب برای جوش سرسیاه چیه؟",
-                "پوستم خیلی چربه و براقه، چیکار کنم؟",
-                "تفاوت سالیسیلیک اسید و نیاسینامید چیه؟",
-                "برای جوش‌های قرمز و دردناک چه محصولی پیشنهاد میدی؟",
-                "محصول اقتصادی برای منافذ باز",
-            ]
+                "سلام، برای جوش صورتم چیکار کنم؟",
+                "پوستم خیلی چربه",
+                "یه چیز اقتصادی می‌خوام",
+                "میخوام منافذ پوستم کوچیک بشه",
+            ],
+            title="",
+            description="با من چت کنید تا بهترین محصول رو پیدا کنیم!",
         )
         
         gr.Markdown("""
         ---
-        **ویژگی‌ها:**
-        - 🧠 درک هوشمند سوال شما
-        - 🔍 جستجوی پیشرفته در پایگاه داده محصولات
-        - 🕸️ استفاده از گراف دانش برای پیدا کردن روابط
-        - ✅ خود-اصلاحی و بهبود کیفیت پاسخ
-        - 📊 پیشنهاد محصولات با لینک مستقیم
-        
-        **تکنولوژی:**
-        - LLM: GPT-4o-mini (OpenRouter)
-        - Vector DB: Qdrant
-        - Knowledge Graph: NetworkX
+        **این سیستم چطور کار می‌کنه؟**
+        1. 🤔 سوالات شما رو می‌فهمه
+        2. ❓ سوالات هدفمند می‌پرسه تا بهترین محصول رو پیدا کنه
+        3. 🎯 فقط 1-2 محصول مناسب پیشنهاد می‌ده (نه همه محصولات!)
+        4. 💬 مثل یک مشاور واقعی باهاتون صحبت می‌کنه
+        
+        **تکنولوژی:** GPT-4o-mini + Qdrant + NetworkX
         """)
     
     return demo
@@ -855,18 +905,13 @@ def create_gradio_interface(rag_system: PharmacyRAGSystem):
 # ============================================================================
 
 if __name__ == "__main__":
-    # ساخت سیستم
     rag_system = PharmacyRAGSystem()
     
-    # بارگذاری داده‌ها
     rag_system.load_data("7590053231020941057_391109923615173.xlsx")
     
-    # راه‌اندازی UI
     demo = create_gradio_interface(rag_system)
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=True,  # برای دریافت لینک عمومی
-        theme=gr.themes.Soft()
+        share=True,
     )
-