Update app.py

app.py

@@ -1,10 +1,8 @@
 import os
-import json
 import gradio as gr
 import geopandas as gpd
 import folium
 import requests
-from shapely.geometry import shape
 
 # osmnx opsiyonel (fallback için), yoksa sorun değil
 try:
@@ -14,6 +12,7 @@ except ImportError:
 
 from huggingface_hub import InferenceClient, login
 
+
 # ==========================================
 #  HF TOKEN & MODEL
 # ==========================================
@@ -24,6 +23,14 @@ if HF_TOKEN:
 else:
     print("UYARI: HF_TOKEN / HUGGINGFACE_HUB_TOKEN bulunamadı, gated modellere erişilemeyebilir.")
 
+#client = InferenceClient(
+#    model="abacusai/Dracarys-72B-Instruct",
+#    token=HF_TOKEN if HF_TOKEN else None,
+#)
+
+
+
+
 # ==========================================
 #  ÖNCEDEN HAZIRLANMIŞ OSM VERİSİ
 # ==========================================
@@ -41,36 +48,25 @@ else:
 
 
 DEFAULT_TAGS = {
-    "amenity": ["school", "pharmacy", "hospital", "restaurant", "cafe", "bank", "university"],
+    "amenity": ["school", "pharmacy", "hospital", "restaurant", "cafe", "bank"],
     "leisure": ["park", "playground"],
     "shop": True,
-    "highway": ["bus_stop"],
-    "railway": ["station", "halt", "tram_stop"],
-    "public_transport": ["stop_position", "platform"],
+    # >>> ULAŞIM ETİKETLERİ
+    "highway": ["bus_stop"],  # otobüs durakları
+    "railway": ["station", "halt", "tram_stop"],  # tren / metro / tramvay istasyonları
+    "public_transport": ["stop_position", "platform"],  # toplu taşıma durak/istasyonları
 }
 
-# ==========================================
-#  SYSTEM PROMPTS (GÜNCELLENDİ)
-# ==========================================
-# <<< GÜNCELLENDİ: LLM'e 'around' (yakınında) sorgusu yapmayı öğretiyoruz.
-OSM_QUERY_SYSTEM = """
-You are an expert in OpenStreetMap and Overpass API.
-Produce only valid Overpass QL.
-No explanations. No markdown.
-Use [out:json][timeout:25]; at top.
-End with: out center;
 
-IMPORTANT RULES:
-1. If the user asks for "nearest", "nearby", "close to" or "closest", use the (around:RADIUS, LAT, LON) filter.
-   Example: node(around:3000, 39.123, 32.456)["amenity"="university"];
-2. Do not use 'center' area unless explicitly asked. Use the provided lat/lon coordinates in the prompt context.
-3. Default radius for "nearby" queries should be around 2000 to 5000 meters if not specified.
-"""
 
 # ==========================================
 #  OSM / CBS FONKSİYONLARI
 # ==========================================
 def get_neighborhood_gdf(city: str, district: str, neighborhood: str):
+    """
+    1) Önce önceden kaydedilmiş GeoJSON'dan arar (city + district + neighborhood).
+    2) Eğer orada yoksa ve osmnx mevcutsa, OSM'den canlı çeker (fallback).
+    """
     city = (city or "").strip()
     district = (district or "").strip()
     neighborhood = (neighborhood or "").strip()
@@ -88,9 +84,13 @@ def get_neighborhood_gdf(city: str, district: str, neighborhood: str):
 
     # 2) Fallback: canlı OSM çağrısı
     if ox is None:
+        print("OSM fallback kullanılamıyor: osmnx yüklü değil.")
         return None
 
+    # İlçe bilgisini de geocode sorgusuna ekliyoruz
     query = f"{neighborhood}, {district}, {city}, Türkiye"
+    print(f"OSM fallback: {query}")
+
     try:
         gdf_osm = ox.geocode_to_gdf(query)
     except Exception as e:
@@ -104,17 +104,27 @@ def get_neighborhood_gdf(city: str, district: str, neighborhood: str):
     gdf_osm["city"] = city
     gdf_osm["district"] = district
     gdf_osm["neighborhood"] = neighborhood
+
     return gdf_osm
 
 
+
 def get_pois_within(gdf, tags=None):
+    """
+    1) Eğer GeoJSON'da bu mahalle için POI varsa, oradan döner.
+    2) Yoksa ve osmnx mevcutsa, poligon üzerinden OSM'den canlı çeker (fallback).
+    """
     if gdf is None:
         return None
+
     if tags is None:
         tags = DEFAULT_TAGS
 
     # 1) Precomputed POI verisi
-    if (pois_gdf is not None and all(col in gdf.columns for col in ["city", "district", "neighborhood"])):
+    if (
+        pois_gdf is not None
+        and all(col in gdf.columns for col in ["city", "district", "neighborhood"])
+    ):
         row = gdf.iloc[0]
         city = row["city"]
         district = row["district"]
@@ -126,11 +136,13 @@ def get_pois_within(gdf, tags=None):
             & (pois_gdf["neighborhood"] == neighborhood)
         )
         pois_local = pois_gdf[mask]
+
         if pois_local is not None and len(pois_local) > 0:
             return pois_local
 
     # 2) Fallback: OSM'den canlı POI çek
     if ox is None:
+        print("OSM POI fallback kullanılamıyor: osmnx yüklü değil.")
         return None
 
     try:
@@ -144,11 +156,13 @@ def get_pois_within(gdf, tags=None):
 
 def summarize_pois(gdf, pois):
     summary = {}
+    
     try:
         area_m2 = gdf.to_crs(epsg=32636).geometry.iloc[0].area
         summary["alan_m2"] = float(area_m2)
         summary["alan_km2"] = float(area_m2 / 1_000_000)
-    except Exception:
+    except Exception as e:
+        print("Alan hesaplama hatası:", e)
         summary["alan_m2"] = None
         summary["alan_km2"] = None
         
@@ -157,170 +171,386 @@ def summarize_pois(gdf, pois):
         return summary
 
     summary["toplam_poi"] = int(len(pois))
-    
-    for col in ["amenity", "leisure", "shop", "highway", "railway", "public_transport"]:
-        if col in pois.columns:
-            counts = pois[col].value_counts().to_dict()
-            for k, v in counts.items():
-                summary[f"{col}_{k}"] = int(v)
+
+    if "amenity" in pois.columns:
+        amenity_counts = pois["amenity"].value_counts().to_dict()
+        for k, v in amenity_counts.items():
+            summary[f"amenity_{k}"] = int(v)
+
+    if "leisure" in pois.columns:
+        leisure_counts = pois["leisure"].value_counts().to_dict()
+        for k, v in leisure_counts.items():
+            summary[f"leisure_{k}"] = int(v)
+
+    if "shop" in pois.columns:
+        shop_counts = pois["shop"].value_counts().to_dict()
+        for k, v in shop_counts.items():
+            summary[f"shop_{k}"] = int(v)
+
+    # >>> ULAŞIM: highway / railway / public_transport
+    if "highway" in pois.columns:
+        hw_counts = pois["highway"].value_counts().to_dict()
+        for k, v in hw_counts.items():
+            summary[f"highway_{k}"] = int(v)
+
+    if "railway" in pois.columns:
+        rw_counts = pois["railway"].value_counts().to_dict()
+        for k, v in rw_counts.items():
+            summary[f"railway_{k}"] = int(v)
+
+    if "public_transport" in pois.columns:
+        pt_counts = pois["public_transport"].value_counts().to_dict()
+        for k, v in pt_counts.items():
+            summary[f"public_transport_{k}"] = int(v)
+
     return summary
 
 
 def build_poi_names_text(pois, max_per_category=15) -> str:
+    """
+    POI GeoDataFrame'inden okul, eczane, kafe, restoran, market vb.
+    için isim listeleri çıkarır. LLM bağlamında kullanılacak metni döndürür.
+    """
     if pois is None or len(pois) == 0:
         return "Bu mahalle için isim verisi olan POI bulunamadı.\n"
+
     if "name" not in pois.columns:
         return "Bu mahallede POI'ler için 'name' alanı bulunamadı.\n"
 
     lines = []
+
     def add_category(title, mask):
         sub = pois[mask]
-        if sub is None or len(sub) == 0: return
-        names = sub["name"].dropna().astype(str).str.strip()
+        if sub is None or len(sub) == 0:
+            return
+        names = (
+            sub["name"]
+            .dropna()
+            .astype(str)
+            .str.strip()
+        )
         names = [n for n in names if n]
-        if not names: return
+        if not names:
+            return
         unique_names = sorted(set(names))[:max_per_category]
         lines.append(f"{title}:")
         for n in unique_names:
             lines.append(f"  - {n}")
-        lines.append("")
+        lines.append("")  # kategori arası boş satır
 
+    # Kategoriler
     if "amenity" in pois.columns:
-        add_category("Okullar", pois["amenity"] == "school")
-        add_category("Üniversiteler", pois["amenity"] == "university")
-        add_category("Eczaneler", pois["amenity"] == "pharmacy")
-        add_category("Kafeler", pois["amenity"] == "cafe")
-        add_category("Restoranlar", pois["amenity"] == "restaurant")
+        amenity = pois["amenity"]
+        add_category("Okullar", amenity == "school")
+        add_category("Eczaneler", amenity == "pharmacy")
+        add_category("Kafeler", amenity == "cafe")
+        add_category("Restoranlar", amenity == "restaurant")
 
     if "shop" in pois.columns:
-        add_category("Marketler", pois["shop"].isin(["supermarket", "convenience", "mall"]))
+        shop = pois["shop"]
+        # İstersen buraya başka shop türleri de ekleyebilirsin
+        add_category("Marketler", shop.isin(["supermarket", "convenience", "mall", "department_store"]))
 
     if not lines:
         return "Bu mahallede adı bilinen POI listesi çıkarılamadı.\n"
+
     return "\n".join(lines)
 
 
+
 def build_stats_text(summary: dict) -> str:
     if not summary:
         return "Veri bulunamadı."
-    
+
     alan = summary.get("alan_km2", 0) or 0.0
     toplam_poi = summary.get("toplam_poi", 0)
     okul = summary.get("amenity_school", 0)
-    univ = summary.get("amenity_university", 0)
     park = summary.get("leisure_park", 0)
     eczane = summary.get("amenity_pharmacy", 0)
     cafe = summary.get("amenity_cafe", 0)
     restoran = summary.get("amenity_restaurant", 0)
 
+    # >>> ULAŞIM SAYILARI
+    otobus_duragi = summary.get("highway_bus_stop", 0)
+    tren_istasyonu = summary.get("railway_station", 0) + summary.get("railway_halt", 0)
+    tramvay_duragi = summary.get("railway_tram_stop", 0)
+    pt_platform = summary.get("public_transport_platform", 0)
+
     lines = [
         f"- Tahmini alan: {alan:.2f} km²",
-        f"- Toplam POI: {toplam_poi}",
+        f"- Toplam POI (ilgi noktası): {toplam_poi}",
         f"- Okul sayısı: {okul}",
-        f"- Üniversite sayısı: {univ}",
         f"- Park sayısı: {park}",
         f"- Eczane sayısı: {eczane}",
         f"- Kafe sayısı: {cafe}",
         f"- Restoran sayısı: {restoran}",
+        # >>> ULAŞIM SATIRLARI
+        f"- Otobüs durağı sayısı: {otobus_duragi}",
+        f"- Tren/metro istasyonu sayısı: {tren_istasyonu}",
+        f"- Tramvay durağı sayısı: {tramvay_duragi}",
+        f"- Toplu taşıma platform/istasyon öğesi: {pt_platform}",
     ]
+
     return "\n".join(lines)
 
 
-# ==========================================
-#  OVERPASS VE HARİTA İŞLEMLERİ
-# ==========================================
+import requests
+import json
+import geopandas as gpd
+from shapely.geometry import shape
+
+def is_osm_query(message: str) -> bool:
+    return isinstance(message, str) and message.strip().lower().startswith("/osm")
+
+OSM_QUERY_SYSTEM = """
+You are an expert in OpenStreetMap and Overpass API.
+Produce only valid Overpass QL.
+No explanations. No markdown.
+Use [out:json][timeout:25]; at top.
+End with: out center;
+"""
+
 def generate_overpass_query_from_llm(prompt: str, model_name: str) -> str:
+    """
+    Doğal dilde verilen prompt'u kullanarak Overpass QL sorgusu üretir.
+    Sadece geçerli Overpass QL döndürmeye çalışır, markdown vs. temizler.
+    """
     prompt = (prompt or "").strip()
     if not prompt:
         prompt = "Generate an Overpass QL query for my request."
 
     client = InferenceClient(model=model_name, token=HF_TOKEN if HF_TOKEN else None)
+
     messages = [
         {"role": "system", "content": OSM_QUERY_SYSTEM},
         {"role": "user", "content": prompt},
     ]
+
+    # Streaming'e gerek yok, tek seferde alalım
     result = client.chat_completion(
-        messages=messages, max_tokens=400, temperature=0.2, top_p=0.9, stream=False
+        messages=messages,
+        max_tokens=400,
+        temperature=0.2,
+        top_p=0.9,
+        stream=False,
     )
+
+    # HF InferenceClient sonucu
     query_text = result.choices[0].message.content
+
+    # Olası ```ql ``` bloklarını temizle
     query_text = query_text.replace("```ql", "").replace("```QL", "").replace("```", "")
     return query_text.strip()
 
-
 def normalize_overpass_query(raw_query: str) -> str:
-    if not raw_query: return ""
+    """
+    Kullanıcının yapıştırdığı sorgudan markdown / gereksiz metinleri temizler.
+    ```ql, ``` gibi blokları, 'Üretilen Overpass Sorgusu:' gibi başlıkları atar.
+    """
+    if not raw_query:
+        return ""
+
     q = raw_query.strip()
+
+    # Başlık metnini temizle
     if "Üretilen Overpass Sorgusu:" in q:
         q = q.split("Üretilen Overpass Sorgusu:", 1)[-1].strip()
+
+    # Markdown code fence'leri temizle
     for token in ("```ql", "```QL", "```", "<code>", "</code>", "<pre>", "</pre>"):
         q = q.replace(token, "")
+
     return q.strip()
 
 
-def summarize_overpass_data(data: dict, max_examples: int = 30) -> str:
-    if not data: return "Overpass sonucu boş."
-    elements = data.get("elements", [])
-    if not elements: return "Hiç element bulunamadı."
-    
-    total = len(elements)
-    examples = []
-    for e in elements[:max_examples]:
-        etype = e.get("type")
-        tags = e.get("tags", {})
-        name = tags.get("name", "(isimsiz)")
-        # Önemli etiketler
-        tag_info = [f"{k}={v}" for k,v in tags.items() if k in ["amenity", "leisure", "shop", "highway"]]
-        tag_str = ", ".join(tag_info) if tag_info else "etiket yok"
-        examples.append(f"- {etype} | {name} | {tag_str}")
-        
-    return f"Toplam {total} öğe bulundu.\nÖrnekler:\n" + "\n".join(examples)
+
+# ==========================================
+#  MAHALLE KARŞILAŞTIRMA BAĞLAMI
+# ==========================================
+def prepare_comparison(city, district1, neigh1, district2, neigh2):
+    """
+    Butona basıldığında:
+      - Her iki mahalle için OSM özetini hazırlar
+      - İki metin döndürür
+      - LLM için karşılaştırma bağlamını üretir
+    """
+    city = (city or "").strip()
+    district1 = (district1 or "").strip()
+    neigh1 = (neigh1 or "").strip()
+    district2 = (district2 or "").strip()
+    neigh2 = (neigh2 or "").strip()
+
+    if not city or not district1 or not neigh1 or not district2 or not neigh2:
+        msg = "Şehir, ilçe ve iki mahalle de girilmelidir."
+        return (msg, msg, "", "<b>Harita için yeterli veri yok.</b>")
+
+    # Varsayılan olarak boş metinler
+    labels1 = "Bu mahalle için isim verisi çıkarılamadı."
+    labels2 = "Bu mahalle için isim verisi çıkarılamadı."
+
+    # Mahalle 1
+    gdf1 = get_neighborhood_gdf(city, district1, neigh1)
+    if gdf1 is None or len(gdf1) == 0:
+        stats1 = f"{city} / {district1} / {neigh1} için veri bulunamadı."
+        summary1 = None
+    else:
+        pois1 = get_pois_within(gdf1)
+        summary1 = summarize_pois(gdf1, pois1)
+        stats1 = build_stats_text(summary1)
+        # >>> POI isim metni
+        labels1 = build_poi_names_text(pois1)
+
+    # Mahalle 2
+    gdf2 = get_neighborhood_gdf(city, district2, neigh2)
+    if gdf2 is None or len(gdf2) == 0:
+        stats2 = f"{city} / {district2} / {neigh2} için veri bulunamadı."
+        summary2 = None
+    else:
+        pois2 = get_pois_within(gdf2)
+        summary2 = summarize_pois(gdf2, pois2)
+        stats2 = build_stats_text(summary2)
+        # >>> POI isim metni
+        labels2 = build_poi_names_text(pois2)
+
+    # LLM bağlamı
+    compare_context_parts = [
+        f"Şehir: {city}",
+        "",
+        f"1. Mahalle: {neigh1} (İlçe: {district1})",
+        stats1,
+        "",
+        "1. mahalledeki önemli POI isimleri (okullar, eczaneler, marketler, kafeler vb.):",
+        labels1,
+        "",
+        f"2. Mahalle: {neigh2} (İlçe: {district2})",
+        stats2,
+        "",
+        "2. mahalledeki önemli POI isimleri (okullar, eczaneler, marketler, kafeler vb.):",
+        labels2,
+        "",
+        "Bu iki mahalleyi alan, toplam POI sayısı, park, okul, kafe, restoran, eczane sayıları"
+        " ve verilen POI isimleri açısından karşılaştır."
+        " Kullanıcı soru sorarsa, hem sayısal verilere hem de POI isimlerine dayanarak"
+        " açıklayıcı ve dengeli bir karşılaştırma yap."
+    ]
+    compare_context = "\n".join(compare_context_parts)
+
+    # Harita HTML'i
+    map_html = create_comparison_map(gdf1, gdf2)
+
+    return stats1, stats2, compare_context, map_html
+
 
 
 def add_poi_markers_to_map(pois, m, layer_prefix="POI"):
-    if pois is None or len(pois) == 0: return
+    """
+    POI GeoDataFrame'ini alır, amenity/leisure/shop/railway/highway/public_transport
+    sütunlarına göre kategorik katmanlar oluşturup haritaya ekler.
+    """
+    if pois is None or len(pois) == 0:
+        return
+
+    # Gerekirse WGS84'e (lat/lon) çevir
     try:
         if pois.crs is not None and pois.crs.to_epsg() != 4326:
             pois = pois.to_crs(epsg=4326)
-    except Exception: pass
+    except Exception:
+        # CRS yoksa veya hata olursa direkt devam
+        pass
 
-    layer_groups = {}
+    # >>> ÖNEMLİ: layer_groups burada tanımlanmalı
+    layer_groups = {}  # {kategori_ismi: folium.FeatureGroup}
 
     for _, row in pois.iterrows():
         geom = row.geometry
-        if geom is None or geom.is_empty: continue
-        
+        if geom is None or geom.is_empty:
+            continue
+
+        # Nokta değilse centroid al
         try:
             if geom.geom_type == "Point":
                 lat, lon = geom.y, geom.x
             else:
                 c = geom.centroid
                 lat, lon = c.y, c.x
-        except Exception: continue
+        except Exception:
+            continue
 
         amenity = row.get("amenity")
-        name = row.get("name")
-        
-        # Basit kategori
-        cat = "Diğer"
-        if isinstance(amenity, str): cat = f"Amenity: {amenity}"
-        
+        leisure = row.get("leisure")
+        shop = row.get("shop")
+        highway = row.get("highway")
+        railway = row.get("railway")
+        public_transport = row.get("public_transport")
+
+        # Kategori belirle (öncelik: amenity > leisure > shop > railway > highway > public_transport)
+        if isinstance(amenity, str):
+            cat = f"Amenity: {amenity}"
+        elif isinstance(leisure, str):
+            cat = f"Leisure: {leisure}"
+        elif isinstance(shop, str):
+            cat = f"Shop: {shop}"
+        elif isinstance(railway, str):
+            cat = f"Railway: {railway}"
+        elif isinstance(highway, str):
+            cat = f"Highway: {highway}"
+        elif isinstance(public_transport, str):
+            cat = f"PT: {public_transport}"
+        else:
+            cat = "Diğer"
+
         layer_name = f"{layer_prefix} - {cat}"
+
         if layer_name not in layer_groups:
-            fg = folium.FeatureGroup(name=layer_name, show=False) # Varsayılan kapalı olsun kalabalık olmasın
+            fg = folium.FeatureGroup(name=layer_name, show=True)
             fg.add_to(m)
             layer_groups[layer_name] = fg
-            
-        tooltip_txt = name if isinstance(name, str) else "POI"
+
+        name = row.get("name")
+
+        popup_items = []
+        # Önce isim
+        if isinstance(name, str) and name.strip():
+            popup_items.append(name.strip())
+
+        if isinstance(amenity, str):
+            popup_items.append(f"amenity={amenity}")
+        if isinstance(leisure, str):
+            popup_items.append(f"leisure={leisure}")
+        if isinstance(shop, str):
+            popup_items.append(f"shop={shop}")
+        if isinstance(railway, str):
+            popup_items.append(f"railway={railway}")
+        if isinstance(highway, str):
+            popup_items.append(f"highway={highway}")
+        if isinstance(public_transport, str):
+            popup_items.append(f"public_transport={public_transport}")
+
+        popup_text = ", ".join(popup_items) if popup_items else "POI"
+
         folium.CircleMarker(
-            location=[lat, lon], radius=3, color="orange", fill=True, fill_opacity=0.6,
-            tooltip=tooltip_txt, popup=f"{cat}: {tooltip_txt}"
+            location=[lat, lon],
+            radius=4,
+            popup=popup_text,
+            tooltip=name.strip() if isinstance(name, str) and name.strip() else None,
+            weight=1,
+            fill=True,
+            fill_opacity=0.7,
         ).add_to(layer_groups[layer_name])
 
 
+
+
 def create_comparison_map(gdf1, gdf2):
     """
-    İlk oluşturma anında kullanılan harita fonksiyonu.
+    İki mahalle poligonunu tek bir Folium haritasında gösterir.
+    + Her mahalle için POI'leri kategorik katmanlar hâlinde ekler.
     """
+    # Hiç veri yoksa
+    if (gdf1 is None or len(gdf1) == 0) and (gdf2 is None or len(gdf2) == 0):
+        return "<b>Harita için yeterli veri yok.</b>"
+
+    # Merkez olarak mevcut bir poligonun centroid'ini al
     centroid = None
     if gdf1 is not None and len(gdf1) > 0:
         centroid = gdf1.geometry.iloc[0].centroid
@@ -330,295 +560,551 @@ def create_comparison_map(gdf1, gdf2):
     if centroid is None:
         return "<b>Geometri bulunamadı.</b>"
 
-    m = folium.Map(location=[centroid.y, centroid.x], zoom_start=13)
+    m = folium.Map(location=[centroid.y, centroid.x], zoom_start=14)
 
+    # Mahalle 1
+    pois1 = None
     if gdf1 is not None and len(gdf1) > 0:
         name1 = str(gdf1.get("neighborhood", ["Mahalle 1"]).iloc[0])
         folium.GeoJson(
             gdf1.geometry.__geo_interface__,
-            name=f"{name1} Sınırı",
-            style_function=lambda x: {"color": "red", "fill": False, "weight": 3}
+            name=name1,
+            style_function=lambda feat: {
+                "color": "red",
+                "fill": False,
+                "weight": 3,
+            },
         ).add_to(m)
+
+        # >>> Mahalle 1 için POI'ler
         pois1 = get_pois_within(gdf1)
-        add_poi_markers_to_map(pois1, m, layer_prefix=name1)
+        add_poi_markers_to_map(pois1, m, layer_prefix=f"{name1} POI")
 
+    # Mahalle 2
+    pois2 = None
     if gdf2 is not None and len(gdf2) > 0:
         name2 = str(gdf2.get("neighborhood", ["Mahalle 2"]).iloc[0])
         folium.GeoJson(
             gdf2.geometry.__geo_interface__,
-            name=f"{name2} Sınırı",
-            style_function=lambda x: {"color": "blue", "fill": False, "weight": 3}
+            name=name2,
+            style_function=lambda feat: {
+                "color": "blue",
+                "fill": False,
+                "weight": 3,
+            },
         ).add_to(m)
+
+        # >>> Mahalle 2 için POI'ler
         pois2 = get_pois_within(gdf2)
-        add_poi_markers_to_map(pois2, m, layer_prefix=name2)
+        add_poi_markers_to_map(pois2, m, layer_prefix=f"{name2} POI")
 
     folium.LayerControl().add_to(m)
     return m._repr_html_()
 
 
-# ==========================================
-#  ANA İŞ MANTIĞI (GÜNCELLENEN KISIMLAR)
-# ==========================================
-
-def prepare_comparison(city, district1, neigh1, district2, neigh2):
-    """
-    İki mahallenin verilerini hazırlar ve 'saved_data' olarak state döndürür.
-    """
-    city = (city or "").strip()
-    district1 = (district1 or "").strip()
-    neigh1 = (neigh1 or "").strip()
-    district2 = (district2 or "").strip()
-    neigh2 = (neigh2 or "").strip()
-
-    if not city or not district1 or not neigh1 or not district2 or not neigh2:
-        return "Eksik bilgi.", "Eksik bilgi.", "", "<b>Harita için yeterli veri yok.</b>", None
-
-    # Mahalle 1
-    gdf1 = get_neighborhood_gdf(city, district1, neigh1)
-    stats1_txt = "Veri yok"
-    labels1 = ""
-    if gdf1 is not None and len(gdf1) > 0:
-        pois1 = get_pois_within(gdf1)
-        sum1 = summarize_pois(gdf1, pois1)
-        stats1_txt = build_stats_text(sum1)
-        labels1 = build_poi_names_text(pois1)
 
-    # Mahalle 2
-    gdf2 = get_neighborhood_gdf(city, district2, neigh2)
-    stats2_txt = "Veri yok"
-    labels2 = ""
-    if gdf2 is not None and len(gdf2) > 0:
-        pois2 = get_pois_within(gdf2)
-        sum2 = summarize_pois(gdf2, pois2)
-        stats2_txt = build_stats_text(sum2)
-        labels2 = build_poi_names_text(pois2)
 
-    # LLM Context
-    context = (
-        f"Şehir: {city}\n"
-        f"1. Mahalle: {neigh1} ({district1})\n{stats1_txt}\nPOI İsimleri:\n{labels1}\n\n"
-        f"2. Mahalle: {neigh2} ({district2})\n{stats2_txt}\nPOI İsimleri:\n{labels2}\n"
-    )
 
-    map_html = create_comparison_map(gdf1, gdf2)
-
-    # <<< GÜNCELLENDİ: Koordinatları hesapla ve State içine kaydet
-    center1, center2 = None, None
-    if gdf1 is not None and len(gdf1) > 0:
-        c = gdf1.to_crs(epsg=4326).geometry.iloc[0].centroid
-        center1 = (c.y, c.x)
-    
-    if gdf2 is not None and len(gdf2) > 0:
-        c = gdf2.to_crs(epsg=4326).geometry.iloc[0].centroid
-        center2 = (c.y, c.x)
 
-    saved_data = {
-        "gdf1": gdf1, "gdf2": gdf2,
-        "name1": neigh1, "name2": neigh2,
-        "center1": center1, "center2": center2
-    }
-
-    return stats1_txt, stats2_txt, context, map_html, saved_data
-
-
-def run_overpass_to_map(query: str, saved_data=None):
+def run_overpass_to_map(query: str):
     """
-    Overpass sorgusunu çalıştırır ve saved_data varsa önceki sınırları da çizer.
+    Overpass QL sorgusunu çalıştırır, Folium haritası ve LLM bağlamı için
+    metinsel bir özet döndürür.
     """
-    query = normalize_overpass_query(query)
-    if not query: return "<b>Sorgu boş.</b>", "Sorgu boş."
+    query = normalize_overpass_query(query) if 'normalize_overpass_query' in globals() else query
+
+    if not query or not query.strip():
+        return "<b>Overpass sorgusu boş.</b>", "Geçerli bir Overpass sorgusu sağlanmadı."
+
+    url = "https://overpass-api.de/api/interpreter"
 
     try:
-        resp = requests.post("https://overpass-api.de/api/interpreter", data={"data": query}, timeout=30)
+        resp = requests.post(url, data={"data": query}, timeout=30)
         resp.raise_for_status()
         data = resp.json()
     except Exception as e:
-        return f"<b>Hata:</b> {e}", "Hata oluştu."
+        print("Overpass isteği hatası:", e)
+        try:
+            print("Overpass response text:", resp.text[:500])
+        except Exception:
+            pass
+        return f"<b>Overpass isteği hatası:</b> {e}", "Overpass isteğinde hata oluştu, veri yok."
 
     elements = data.get("elements", [])
-    
-    # Merkez belirleme
-    center_lat, center_lon = None, None
-    # 1. Öncelik: Kayıtlı mahalle
-    if saved_data and saved_data.get("center1"):
-        center_lat, center_lon = saved_data["center1"]
-    # 2. Öncelik: Overpass verisi
-    elif elements:
-        el = elements[0]
-        if "lat" in el: center_lat, center_lon = el["lat"], el["lon"]
-        elif "geometry" in el: center_lat, center_lon = el["geometry"][0]["lat"], el["geometry"][0]["lon"]
+    if not elements:
+        return "<b>Overpass sonucu: veri bulunamadı.</b>", "Overpass sonucu: hiç element bulunamadı."
 
+    # Merkez için ilk noktanın koordinatlarını bulalım
+    center_lat, center_lon = None, None
+    for el in elements:
+        if "lat" in el and "lon" in el:
+            center_lat, center_lon = el["lat"], el["lon"]
+            break
     if center_lat is None:
-        return "<b>Veri yok veya konum bulunamadı.</b>", "Veri yok."
-
-    m = folium.Map(location=[center_lat, center_lon], zoom_start=13)
-
-    # <<< GÜNCELLENDİ: Önce mahalle sınırlarını tekrar çiz
-    if saved_data:
-        gdf1 = saved_data.get("gdf1")
-        if gdf1 is not None and len(gdf1) > 0:
-            folium.GeoJson(
-                gdf1.geometry.__geo_interface__,
-                name=f"{saved_data.get('name1')} Sınırı",
-                style_function=lambda x: {"color": "red", "fill": False, "weight": 2}
-            ).add_to(m)
-        
-        gdf2 = saved_data.get("gdf2")
-        if gdf2 is not None and len(gdf2) > 0:
-            folium.GeoJson(
-                gdf2.geometry.__geo_interface__,
-                name=f"{saved_data.get('name2')} Sınırı",
-                style_function=lambda x: {"color": "blue", "fill": False, "weight": 2}
-            ).add_to(m)
-
-    # Overpass sonuçlarını çiz
-    fg = folium.FeatureGroup(name="Sorgu Sonuçları", show=True)
-    fg.add_to(m)
+        return "<b>Overpass sonucu: nokta verisi yok.</b>", "Overpass sonucu: nokta verisi bulunamadı."
+
+    m = folium.Map(location=[center_lat, center_lon], zoom_start=14)
+
+    # Katman: node'lar
+    fg_nodes = folium.FeatureGroup(name="Noktalar")
+    fg_nodes.add_to(m)
+
+    # Katman: yollar
+    fg_ways = folium.FeatureGroup(name="Yollar")
+    fg_ways.add_to(m)
 
     for el in elements:
+        etype = el.get("type")
         tags = el.get("tags", {})
-        name = tags.get("name", el.get("type"))
-        popup = f"{name}<br>" + "<br>".join([f"{k}:{v}" for k,v in tags.items() if k!='name'])
-        
-        if el["type"] == "node" and "lat" in el:
+        name = tags.get("name", "")
+        popup_items = []
+
+        if name:
+            popup_items.append(name)
+        for k, v in tags.items():
+            if k != "name":
+                popup_items.append(f"{k}={v}")
+        popup_text = "<br>".join(popup_items) if popup_items else etype
+
+        # Node → nokta işaretle
+        if etype == "node" and "lat" in el and "lon" in el:
             folium.CircleMarker(
-                [el["lat"], el["lon"]], radius=6, color="green", fill=True, popup=popup, tooltip=name
-            ).add_to(fg)
-        elif el["type"] == "way" and "geometry" in el:
-            pts = [(p["lat"], p["lon"]) for p in el["geometry"]]
-            folium.PolyLine(pts, color="green", weight=4, popup=popup, tooltip=name).add_to(fg)
+                location=[el["lat"], el["lon"]],
+                radius=4,
+                popup=popup_text,
+                tooltip=name or None,
+                weight=1,
+                fill=True,
+                fill_opacity=0.7,
+            ).add_to(fg_nodes)
+
+        # Way → polyline çiz
+        elif etype == "way" and "geometry" in el:
+            coords = [(p["lat"], p["lon"]) for p in el["geometry"]]
+            if len(coords) >= 2:
+                folium.PolyLine(
+                    locations=coords,
+                    popup=popup_text,
+                    weight=3,
+                ).add_to(fg_ways)
 
     folium.LayerControl().add_to(m)
-    return m._repr_html_(), summarize_overpass_data(data)
+
+    map_html = m._repr_html_()
+    summary_text = summarize_overpass_data(data)
+
+    return map_html, summary_text
+
 
 
-def llm_overpass_to_map(natural_prompt, model_name, saved_data=None):
+
+
+def llm_overpass_to_map(natural_prompt: str, model_name: str):
     """
-    LLM'e koordinatları enjekte ederek sorgu üretir.
+    1) Doğal dil prompt'tan LLM ile Overpass QL üretir
+    2) Overpass QL'i çalıştırır, folium haritası ve özet döndürür
+    3) Hem sorguyu, hem haritayı, hem de spatial özetini return eder
     """
-    if not natural_prompt: return "Sorgu yok", "...", "..."
-
-    # <<< GÜNCELLENDİ: Koordinatları prompt'a ekle
-    coords_info = ""
-    if saved_data:
-        c1 = saved_data.get("center1")
-        n1 = saved_data.get("name1")
-        c2 = saved_data.get("center2")
-        n2 = saved_data.get("name2")
-        parts = []
-        if c1: parts.append(f"{n1}: {c1[0]}, {c1[1]}")
-        if c2: parts.append(f"{n2}: {c2[0]}, {c2[1]}")
-        if parts:
-            coords_info = "\nREFERENCE COORDINATES (Lat, Lon):\n" + "\n".join(parts)
-
-    augmented_prompt = f"{natural_prompt}\n{coords_info}"
-    
+    if not natural_prompt or not natural_prompt.strip():
+        return (
+            "Doğal dil sorgu boş.",
+            "<b>Overpass sonucu: sorgu üretilemedi.</b>",
+            "Overpass sonucu: sorgu üretilemedi."
+        )
+
     try:
-        query = generate_overpass_query_from_llm(augmented_prompt, model_name)
+        query = generate_overpass_query_from_llm(natural_prompt, model_name)
     except Exception as e:
-        return f"LLM Hatası: {e}", "Hata", "Hata"
+        print("LLM Overpass üretim hatası:", e)
+        return (
+            f"LLM Overpass üretim hatası: {e}",
+            "<b>Overpass sonucu: LLM hatası.</b>",
+            "Overpass sonucu: LLM hatası."
+        )
 
-    map_html, summary = run_overpass_to_map(query, saved_data)
-    return query, map_html, summary
+    # run_overpass_to_map zaten (map_html, summary_text) döndürüyor
+    map_html, summary_text = run_overpass_to_map(query)
+
+    # 3 değer döndürüyoruz:
+    # - overpass_box içine yazılacak query
+    # - map_html (harita)
+    # - spatial_state (LLM için özet)
+    return query, map_html, summary_text
+
+
+def summarize_overpass_data(data: dict, max_examples: int = 30) -> str:
+    """
+    Overpass JSON sonucundan LLM'e verilecek metinsel bir özet üretir.
+    Çok büyük verilerde token patlamaması için sınırlı örnek verir.
+    """
+    if not data:
+        return "Overpass sonucu boş veya geçersiz.\n"
+
+    elements = data.get("elements", [])
+    if not elements:
+        return "Overpass sonucu: hiç element bulunamadı.\n"
+
+    total_nodes = sum(1 for e in elements if e.get("type") == "node")
+    total_ways = sum(1 for e in elements if e.get("type") == "way")
+    total_rel  = sum(1 for e in elements if e.get("type") == "relation")
+
+    # Basit tag istatistikleri
+    amenity_counts = {}
+    leisure_counts = {}
+    shop_counts = {}
+    highway_counts = {}
+    railway_counts = {}
+    pt_counts = {}
+
+    examples = []
+
+    for e in elements[:max_examples]:
+        etype = e.get("type")
+        tags = e.get("tags", {})
+        name = tags.get("name", "(isimsiz)")
+
+        amenity = tags.get("amenity")
+        leisure = tags.get("leisure")
+        shop = tags.get("shop")
+        highway = tags.get("highway")
+        railway = tags.get("railway")
+        pt = tags.get("public_transport")
+        opening_hours = tags.get("opening_hours")
+        wheelchair = tags.get("wheelchair")
+
+        if amenity:
+            amenity_counts[amenity] = amenity_counts.get(amenity, 0) + 1
+        if leisure:
+            leisure_counts[leisure] = leisure_counts.get(leisure, 0) + 1
+        if shop:
+            shop_counts[shop] = shop_counts.get(shop, 0) + 1
+        if highway:
+            highway_counts[highway] = highway_counts.get(highway, 0) + 1
+        if railway:
+            railway_counts[railway] = railway_counts.get(railway, 0) + 1
+        if pt:
+            pt_counts[pt] = pt_counts.get(pt, 0) + 1
+
+        # Örnek satır
+        tag_parts = []
+        for k in ["amenity", "leisure", "shop", "highway", "railway", "public_transport",
+                  "opening_hours", "wheelchair"]:
+            v = tags.get(k)
+            if v:
+                tag_parts.append(f"{k}={v}")
+
+        tag_text = ", ".join(tag_parts) if tag_parts else "etiket yok"
+        examples.append(f"- {etype} | {name} | {tag_text}")
+
+    def dict_to_lines(title, d):
+        if not d:
+            return []
+        items = sorted(d.items(), key=lambda x: -x[1])
+        lines = [title]
+        for k, v in items:
+            lines.append(f"  - {k}: {v}")
+        return lines
+
+    lines = [
+        f"Toplam node sayısı: {total_nodes}",
+        f"Toplam way sayısı: {total_ways}",
+        f"Toplam relation sayısı: {total_rel}",
+        "",
+    ]
+    lines += dict_to_lines("Amenity türleri:", amenity_counts)
+    lines += dict_to_lines("Leisure türleri:", leisure_counts)
+    lines += dict_to_lines("Shop türleri:", shop_counts)
+    lines += dict_to_lines("Highway türleri:", highway_counts)
+    lines += dict_to_lines("Railway türleri:", railway_counts)
+    lines += dict_to_lines("Public transport türleri:", pt_counts)
+
+    if examples:
+        lines.append("")
+        lines.append(f"İlk {len(examples)} elementten bazı örnekler:")
+        lines.extend(examples)
+
+    return "\n".join(lines)
+
+
+
+
+# ==========================================
+#  LLM SOHBET FONKSİYONU
+# ==========================================
+def respond(
+    message,
+    history,
+    model_name,
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+    compare_context,  # mahalle karşılaştırma bağlamı
+    spatial_context,   # 👈 yeni: son Overpass sonuç özeti
+):
+
+
+    # --------------- OSM SPATIAL QUERY MODU ---------------
+    # --- /osm ile başlayan mesajlar: sadece Overpass sorgusu üret ---
+    if is_osm_query(message):
+        user_text = message.lstrip()[4:].strip()
+        if not user_text:
+            user_text = "Generate an Overpass QL query for my request."
+
+        client = InferenceClient(model=model_name, token=HF_TOKEN if HF_TOKEN else None)
+
+        messages = [
+            {"role": "system", "content": OSM_QUERY_SYSTEM},
+            {"role": "user", "content": user_text},
+        ]
+
+        query_text = ""
+        for chunk in client.chat_completion(
+            messages=messages,
+            max_tokens=400,
+            stream=True,
+            temperature=0.2,
+            top_p=0.9,
+        ):
+            choices = chunk.choices
+            token_text = ""
+            if len(choices) and choices[0].delta.content:
+                token_text = choices[0].delta.content
+
+            query_text += token_text
+            # Kullanıcıya sadece sorguyu göster
+            yield f"Üretilen Overpass Sorgusu:\n```ql\n{query_text}\n```"
+
+        
+        return
+    # --------------- NORMAL CHAT AKIŞI ---------------
 
 
-def respond(message, history, model_name, system_msg, max_tokens, temp, top_p, compare_ctx, spatial_ctx):
-    # Eğer /osm ile başlıyorsa direkt sorgu moduna geçebilirdik ama UI'da ayrı buton var.
-    # Burası normal sohbet.
-    full_system = system_msg
-    if compare_ctx:
-        full_system += f"\n\nMAHALLE VERİLERİ:\n{compare_ctx}"
-    if spatial_ctx:
-        full_system += f"\n\nSON HARİTA SORGUSU SONUCU:\n{spatial_ctx}"
 
-    client = InferenceClient(model=model_name, token=HF_TOKEN if HF_TOKEN else None)
-    messages = [{"role": "system", "content": full_system}] + history + [{"role": "user", "content": message}]
     
+    """
+    Streaming chat using Hugging Face Inference API.
+    history: list of {"role": "...", "content": "..."}
+    """
+    # Temperature güvenli aralık (model max 2)
+    temperature = max(0.0, min(2.0, float(temperature)))
+    top_p = max(0.0, min(1.0, float(top_p)))
+
+    client = InferenceClient(model=model_name, token=HF_TOKEN if HF_TOKEN else None)
+
+    # System mesajına mahalle karşılaştırma bağlamını ekle
+    full_system = system_message
+    if compare_context:
+        full_system += (
+            "\n\nAşağıda aynı şehirdeki iki mahalleye ait sayısal özetler var.\n"
+            "Kullanıcı bu mahalleler hakkında soru sorarsa bu bağlama göre cevap ver:\n"
+            f"{compare_context}"
+        )
+        
+    if spatial_context:
+        full_system += (
+            "\n\nAyrıca kullanıcı tarafından en son çalıştırılan bir Overpass (spatial) sorgusunun"
+            " özet sonuçları var. Kullanıcı bu sorgudan gelen veriler hakkında soru sorarsa,"
+            " bu özet bağlamına dayanarak cevap ver:\n"
+            f"{spatial_context}"
+        )
+
+    messages = [{"role": "system", "content": full_system}]
+    messages.extend(history)
+    messages.append({"role": "user", "content": message})
+
     response = ""
-    for chunk in client.chat_completion(messages=messages, max_tokens=max_tokens, stream=True, temperature=temp, top_p=top_p):
-        if chunk.choices and chunk.choices[0].delta.content:
-            response += chunk.choices[0].delta.content
-            yield response
+    for chunk in client.chat_completion(
+        messages=messages,
+        max_tokens=max_tokens,
+        stream=True,
+        temperature=temperature,
+        top_p=top_p,
+    ):
+        choices = chunk.choices
+        token_text = ""
+        if len(choices) and choices[0].delta.content:
+            token_text = choices[0].delta.content
+
+        response += token_text
+        yield response + f"\n\n---\n**Model:** {model_name}"
 
 
 # ==========================================
-#  GRADIO UI
+#  GRADIO ARAYÜZÜ (SOL CHAT, SAĞ KARŞILAŞTIRMA PANELİ)
 # ==========================================
-with gr.Blocks(title="Mahalle Analiz Botu") as demo:
+with gr.Blocks() as demo:
     gr.Markdown("## Mahalle Karşılaştırmalı Chat Botu")
     
-    # State değişkenleri
     compare_state = gr.State("")
-    spatial_state = gr.State("")
-    gdf_state = gr.State(None) # <<< GÜNCELLENDİ: Mahalle geometrilerini tutar
+    spatial_state = gr.State("")  # 👈 yeni: son Overpass sonuç özeti
+
 
     with gr.Row():
-        # --- SOL: CHAT ---
-        with gr.Column(scale=4):
-            chatbox = gr.Chatbot(height=700, type="messages")
+        # SOL SÜTUN: CHAT
+        with gr.Column(scale=2):
+            chatbox = gr.Chatbot(height=800, scale=1)
+        
+            model_dropdown = gr.Dropdown(
+                choices=[
+                    # Küçük modeller
+                    "google/gemma-2-2b-it",                      # 2B
+                    "meta-llama/Meta-Llama-3.1-8B-Instruct",     # 8B
+        
+                    # Büyük modeller
+                    "abacusai/Dracarys-72B-Instruct",            # 72B
+                    "Qwen/Qwen2.5-72B-Instruct",                 # 72B
+        
+                    # Çok büyük model
+                    "openai/gpt-oss-120b",                       # 120Bdı
+                ],
+                label="Model Seç (Bu listedeki modeller Hugging Face Inference API chat_completion ile uyumludur)",
+                value="abacusai/Dracarys-72B-Instruct"
+            )
+        
+            system_box = gr.Textbox(
+                value="Sen şehir planlama ve mahalleler hakkında bilgi veren yardımsever bir asistansın.",
+                label="System message",
+            )
+        
+            max_tokens_slider = gr.Slider(
+                minimum=1,
+                maximum=2048,
+                value=512,
+                step=1,
+                label="Max new tokens",
+            )
+        
+            temperature_slider = gr.Slider(
+                minimum=0.0,
+                maximum=2.0,   # model max 2
+                value=0.7,
+                step=0.1,
+                label="Temperature",
+            )
+        
+            top_p_slider = gr.Slider(
+                minimum=0.1,
+                maximum=1.0,
+                value=0.95,
+                step=0.05,
+                label="Top-p (nucleus sampling)",
+            )
+        
+            chatbot = gr.ChatInterface(
+                respond,
+                chatbot=chatbox,
+                type="messages",
+                title="Basit Chat Botu",
+                description="Küçük bir sohbet botu, HF Inference API ve OSM verisi ile çalışıyor.",
+                additional_inputs=[
+                    model_dropdown,
+                    system_box,
+                    max_tokens_slider,
+                    temperature_slider,
+                    top_p_slider,
+                    compare_state,  # >>> mahalle karşılaştırma bağlamı
+                    spatial_state,  # >>> son Overpass sonucu özeti
+
+                ],
+            )
+
+
+        # SAĞ SÜTUN: MAHALLE KARŞILAŞTIRMA PANELİ
+        with gr.Column(scale=1):
+            gr.Markdown("### Mahalle Karşılaştırma")
+        
+            city_in = gr.Textbox(
+                label="Şehir",
+                value="Ankara",
+                placeholder="Örn: Ankara",
+            )
+        
+            # 1. mahalle: ilçe + mahalle aynı satırda
             with gr.Row():
-                model_sel = gr.Dropdown(
-                    ["abacusai/Dracarys-72B-Instruct", "meta-llama/Meta-Llama-3.1-8B-Instruct"],
-                    label="Model", value="abacusai/Dracarys-72B-Instruct"
+                district1_in = gr.Textbox(
+                    label="1. İlçe",
+                    value="Gölbaşı",
+                    scale=1,
+                    placeholder="Örn: Gölbaşı",
                 )
-                sys_msg = gr.Textbox("Sen uzman bir şehir plancısısın.", label="Sistem Mesajı")
-            
+                neigh1_in = gr.Textbox(
+                    label="1. Mahalle",
+                    value="İncek",
+                    scale=2,
+                    placeholder="Örn: İncek Mahallesi",
+                )
+        
+            # 2. mahalle: ilçe + mahalle aynı satırda
             with gr.Row():
-                temp_sl = gr.Slider(0, 2, 0.7, label="Temperature")
-                max_tok = gr.Slider(100, 2000, 512, label="Max Tokens")
-            
-            chat_iface = gr.ChatInterface(
-                respond, chatbot=chatbox, 
-                additional_inputs=[model_sel, sys_msg, max_tok, temp_sl, gr.Slider(0,1,0.95), compare_state, spatial_state]
+                district2_in = gr.Textbox(
+                    label="2. İlçe",
+                    value="Gölbaşı",
+                    scale=1,
+                    placeholder="Örn: Gölbaşı",
+                )
+                neigh2_in = gr.Textbox(
+                    label="2. Mahalle",
+                    value="Kızılcaşar",
+                    scale=2,
+                    placeholder="Örn: Kızılcaşar Mahallesi",
+                )
+        
+            compare_btn = gr.Button("Karşılaştırmayı Hazırla")
+        
+            stats1_box = gr.Textbox(
+                label="1. Mahalle Özeti",
+                lines=6,
+            )
+            stats2_box = gr.Textbox(
+                label="2. Mahalle Özeti",
+                lines=6,
             )
+            map_html = gr.HTML(label="Mahalle Haritası")
 
-        # --- SAĞ: KONTROL VE HARİTA ---
-        with gr.Column(scale=5):
-            gr.Markdown("### 1. Mahalle Seçimi")
-            city_in = gr.Textbox("Ankara", label="Şehir")
-            with gr.Row():
-                d1 = gr.Textbox("Gölbaşı", label="İlçe 1")
-                n1 = gr.Textbox("İncek", label="Mahalle 1")
-            with gr.Row():
-                d2 = gr.Textbox("Gölbaşı", label="İlçe 2")
-                n2 = gr.Textbox("Kızılcaşar", label="Mahalle 2")
-            
-            btn_compare = gr.Button("Karşılaştır", variant="primary")
-            
-            with gr.Row():
-                stat1 = gr.Textbox(label="Mahalle 1 Bilgi", lines=4)
-                stat2 = gr.Textbox(label="Mahalle 2 Bilgi", lines=4)
-                
-            map_out = gr.HTML(label="Harita", min_height=400)
-            
-            gr.Markdown("### 2. Akıllı Harita Sorgusu (LLM)")
-            osm_prompt = gr.Textbox(label="Soru Sor (Örn: İncek'e en yakın üniversiteler)", lines=2)
-            btn_gen_run = gr.Button("Sorgula ve Haritaya Ekle")
+            gr.Markdown("### Spatial Query (Overpass)")
+        
+            # 1) LLM'e doğal dil prompt'u
+            osm_nl_prompt = gr.Textbox(
+                label="LLM ile Overpass Sorgusu (Doğal Dil)",
+                lines=3,
+                placeholder="Örn: İncek ve Kızılcaşar çevresindeki tüm park ve okulları getir"
+            )
+        
+            gen_and_run_btn = gr.Button("LLM ile Sorguyu Üret ve Çalıştır")
+        
+            # 2) Üretilen veya manuel Overpass sorgusu
+            overpass_box = gr.Textbox(
+                label="Overpass Sorgusu",
+                lines=6,
+                placeholder="Buraya LLM'in ürettiği Overpass QL sorgusunu yapıştırın..."
+            )
+        
+            run_overpass_btn = gr.Button("Sorguyu Çalıştır ve Haritayı Güncelle")
+
+            # LLM ile üret + çalıştır
+            gen_and_run_btn.click(
+                fn=llm_overpass_to_map,
+                inputs=[osm_nl_prompt, model_dropdown],
+                outputs=[overpass_box, map_html, spatial_state],  # 👈 artık spatial_state de güncelleniyor
+            )
             
-            ql_out = gr.Textbox(label="Oluşan Overpass Sorgusu", lines=3)
-            btn_run_manual = gr.Button("Sorguyu Manuel Çalıştır")
-
-    # --- EVENTLER ---
-    # Karşılaştır butonuna basınca hem metinleri hem haritayı hem de GEOMETRİ STATE'ini güncelle
-    btn_compare.click(
-        prepare_comparison,
-        inputs=[city_in, d1, n1, d2, n2],
-        outputs=[stat1, stat2, compare_state, map_out, gdf_state]
-    )
-    
-    # LLM ile sorgu üretirken GDF STATE'ini de gönderiyoruz (koordinatları bilsin diye)
-    btn_gen_run.click(
-        llm_overpass_to_map,
-        inputs=[osm_prompt, model_sel, gdf_state],
-        outputs=[ql_out, map_out, spatial_state]
-    )
-    
-    # Manuel çalıştırmada da GDF STATE kullanıyoruz (eski sınırları çizsin diye)
-    btn_run_manual.click(
-        run_overpass_to_map,
-        inputs=[ql_out, gdf_state],
-        outputs=[map_out, spatial_state]
-    )
+                    
+            # Manuel Overpass çalıştırma
+            run_overpass_btn.click(
+                fn=run_overpass_to_map,
+                inputs=[overpass_box],
+                outputs=[map_html, spatial_state],  # 👈 harita + LLM için özet
+            )
+
+
+
+            compare_btn.click(
+                fn=prepare_comparison,
+                inputs=[city_in, district1_in, neigh1_in, district2_in, neigh2_in],
+                outputs=[stats1_box, stats2_box, compare_state, map_html],
+            )
+
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()