GPT-5 zekasını kullanarak ürün arama - manuel filtreleme yok

app.py

@@ -29,8 +29,25 @@ from enhanced_features import (
 )
 from image_renderer import extract_product_info_for_gallery, format_message_with_images
 
-# SMART warehouse stock finder - general algorithm
+# Import smart warehouse with GPT intelligence
+try:
+    from smart_warehouse import get_warehouse_stock_smart
+except ImportError:
+    get_warehouse_stock_smart = None
+
 def get_warehouse_stock(product_name):
+    """Use GPT intelligence to find warehouse stock"""
+    # First try GPT-powered search
+    if get_warehouse_stock_smart:
+        result = get_warehouse_stock_smart(product_name)
+        if result:
+            return result
+    
+    # Fallback to old method
+    return get_warehouse_stock_old(product_name)
+
+# OLD warehouse stock finder - general algorithm
+def get_warehouse_stock_old(product_name):
     """Smart warehouse stock finder with general algorithm"""
     try:
         import re
@@ -60,34 +77,44 @@ def get_warehouse_stock(product_name):
         # Smart filtering: Keep only meaningful product identifiers
         product_words = []
         
-        # First pass: identify what looks like product terms
-        for word in words:
-            # Skip if it's a size marker
-            if word in sizes:
-                continue
-            
-            # Always keep numbers (model numbers like 6, 7, 8)
-            if word.isdigit():
-                product_words.append(word)
-            
-            # Keep alphanumeric codes (like "sl6", "gen8")
-            elif any(c.isdigit() for c in word) and any(c.isalpha() for c in word):
-                product_words.append(word)
-            
-            # Keep 2-3 letter codes (often product codes like "sl", "slr", "emx")
-            elif 2 <= len(word) <= 3 and word.isalpha():
-                # Check if it has consonants (likely a code, not a particle)
-                if any(c not in 'aeiou' for c in word):
+        # If query is very short (like "hangi boyu"), skip it
+        if len(words) <= 2 and not any(w.isdigit() for w in words):
+            # Likely just a question, not a product search
+            pass
+        else:
+            # Extract product-like terms
+            for word in words:
+                # Skip if it's a size marker
+                if word in sizes:
+                    continue
+                
+                # Always keep numbers (model numbers)
+                if word.isdigit():
                     product_words.append(word)
-            
-            # Keep longer words that have good consonant/vowel mix (likely product names)
-            elif len(word) > 3:
-                # Calculate consonant ratio
-                consonants = sum(1 for c in word if c not in 'aeiou')
-                vowels = len(word) - consonants
-                # Product names usually have balanced or consonant-heavy distribution
-                # Turkish question words are often vowel-heavy
-                if consonants >= vowels * 0.5:  # At least 1 consonant per 2 vowels
+                
+                # Keep alphanumeric codes
+                elif any(c.isdigit() for c in word) and any(c.isalpha() for c in word):
+                    product_words.append(word)
+                
+                # Keep 2-3 letter codes that look like product codes
+                elif len(word) in [2, 3] and word.isalpha():
+                    # Skip common particles
+                    if word in ['mi', 'mı', 'mu', 'mü', 'var', 'yok', 've', 'de', 'da']:
+                        continue
+                    # Must have at least one consonant
+                    if any(c not in 'aeiouı' for c in word):
+                        product_words.append(word)
+                
+                # For longer words, be selective
+                elif len(word) > 3:
+                    # Skip if ends with Turkish question suffixes
+                    if any(word.endswith(suffix) for suffix in ['mi', 'mı', 'mu', 'mü']):
+                        continue
+                    # Skip if only 1-2 consonants (likely a particle/question word)
+                    consonants = sum(1 for c in word if c not in 'aeiouı')
+                    if consonants <= 2:  # "var" has 2 consonants, skip it
+                        continue
+                    # Keep it
                     product_words.append(word)
         
         print(f"DEBUG - Searching: {' '.join(product_words)}, Size: {size}")

smart_warehouse.py

@@ -0,0 +1,129 @@
+"""Smart warehouse stock finder using GPT-5's intelligence"""
+
+import requests
+import re
+import os
+import json
+
+def get_warehouse_stock_smart(user_message):
+    """Let GPT-5 intelligently find products in XML without manual filtering"""
+    
+    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+    
+    # Get XML data
+    try:
+        url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php'
+        response = requests.get(url, verify=False, timeout=7)
+        xml_text = response.text
+        print(f"DEBUG - XML fetched: {len(xml_text)} characters")
+    except Exception as e:
+        print(f"XML fetch error: {e}")
+        return None
+    
+    # Extract just product blocks to reduce token usage
+    product_pattern = r'<Product>(.*?)</Product>'
+    all_products = re.findall(product_pattern, xml_text, re.DOTALL)
+    
+    # Create a simplified product list for GPT
+    products_summary = []
+    for i, product_block in enumerate(all_products):  # All products
+        name_match = re.search(r'<ProductName><!\[CDATA\[(.*?)\]\]></ProductName>', product_block)
+        variant_match = re.search(r'<ProductVariant><!\[CDATA\[(.*?)\]\]></ProductVariant>', product_block)
+        
+        if name_match:
+            product_info = {
+                "index": i,
+                "name": name_match.group(1),
+                "variant": variant_match.group(1) if variant_match else ""
+            }
+            products_summary.append(product_info)
+    
+    # Let GPT-5 find the product
+    smart_prompt = f"""User is asking: "{user_message}"
+
+Find the product they're asking about from this list:
+{json.dumps(products_summary, ensure_ascii=False, indent=2)}
+
+Return ONLY the index number of the matching product, or -1 if not found.
+Be smart about matching - consider partial matches, abbreviations, Turkish/English variations.
+If asking about size (S, M, L, XL), match the variant field."""
+
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {OPENAI_API_KEY}"
+    }
+    
+    payload = {
+        "model": "gpt-5-chat-latest",
+        "messages": [
+            {"role": "system", "content": "You are a product matcher. Return only a number."},
+            {"role": "user", "content": smart_prompt}
+        ],
+        "temperature": 0,
+        "max_tokens": 10
+    }
+    
+    try:
+        response = requests.post(
+            "https://api.openai.com/v1/chat/completions",
+            headers=headers,
+            json=payload,
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            product_index = result['choices'][0]['message']['content'].strip()
+            
+            try:
+                idx = int(product_index)
+                if idx == -1:
+                    return ["Ürün bulunamadı"]
+                
+                # Get warehouse info for found product
+                product_block = all_products[idx]
+                return extract_warehouse_info(product_block)
+                
+            except (ValueError, IndexError):
+                print(f"DEBUG - GPT returned invalid index: {product_index}")
+                return None
+        else:
+            print(f"GPT API error: {response.status_code}")
+            return None
+            
+    except Exception as e:
+        print(f"Error calling GPT: {e}")
+        return None
+
+def extract_warehouse_info(product_block):
+    """Extract warehouse stock information from a product block"""
+    warehouse_info = []
+    
+    # Find all warehouses with stock
+    warehouse_regex = r'<Warehouse>.*?<Name><!\[CDATA\[(.*?)\]\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
+    warehouses = re.findall(warehouse_regex, product_block, re.DOTALL)
+    
+    for wh_name, wh_stock in warehouses:
+        try:
+            stock = int(wh_stock.strip())
+            if stock > 0:
+                # Format warehouse name nicely
+                if "CADDEBOSTAN" in wh_name:
+                    display = "Caddebostan mağazası"
+                elif "ORTAKÖY" in wh_name:
+                    display = "Ortaköy mağazası"
+                elif "ALSANCAK" in wh_name:
+                    display = "İzmir Alsancak mağazası"
+                elif "BAHCEKOY" in wh_name or "BAHÇEKÖY" in wh_name:
+                    display = "Bahçeköy mağazası"
+                else:
+                    display = wh_name.replace("MAGAZA DEPO", "").strip()
+                
+                warehouse_info.append(f"{display}: {stock} adet")
+        except:
+            pass
+    
+    if warehouse_info:
+        return warehouse_info
+    else:
+        return ["Hiçbir mağazada stokta yok"]