Update app.py

app.py

@@ -1,11 +1,11 @@
 """
-AI 기반 상권 분석 시스템 - 강화 버전
+AI 기반 상권 분석 시스템 - 프리미엄 버전
 Dataset: https://huggingface.co/datasets/ginipick/market
 """
 import gradio as gr
 import pandas as pd
 import numpy as np
-from typing import Dict, List, Tuple
+from typing import Dict, List, Tuple, Optional
 import json
 from datasets import load_dataset
 import plotly.express as px
@@ -18,6 +18,8 @@ from collections import Counter
 import re
 import os
 import time
+from dataclasses import dataclass
+from sklearn.preprocessing import MinMaxScaler
 
 # ============================================================================
 # 데이터 로더 클래스
@@ -80,7 +82,560 @@ class MarketDataLoader:
 
 
 # ============================================================================
-# 상권 분석 클래스
+# 창업 성공 스코어링 시스템
+# ============================================================================
+
+@dataclass
+class StartupScore:
+    """창업 성공 점수"""
+    total_score: float  # 0-100
+    competition_score: float  # 경쟁강도 점수
+    saturation_score: float  # 포화도 점수
+    location_score: float  # 입지 점수
+    floor_score: float  # 층수 적합도 점수
+    diversity_score: float  # 업종 다양성 점수
+    recommendation: str  # 추천 메시지
+    details: Dict  # 상세 정보
+
+class StartupScorer:
+    """창업 성공 확률 계산 엔진"""
+    
+    def __init__(self, df: pd.DataFrame):
+        self.df = df
+    
+    def calculate_score(self, category: str, district: str, floor: int, 
+                       budget: Optional[float] = None) -> StartupScore:
+        """창업 성공 점수 계산"""
+        
+        # 해당 지역 필터링
+        district_df = self.df[self.df['시군구명'].str.contains(district, na=False)]
+        
+        if district_df.empty:
+            return self._create_default_score("해당 지역 데이터가 없습니다.")
+        
+        # 1. 경쟁강도 점수 (0-20점)
+        competition_score = self._calculate_competition_score(district_df, category)
+        
+        # 2. 포화도 점수 (0-20점)
+        saturation_score = self._calculate_saturation_score(district_df, category)
+        
+        # 3. 입지 점수 (0-25점)
+        location_score = self._calculate_location_score(district_df, category)
+        
+        # 4. 층수 적합도 점수 (0-20점)
+        floor_score = self._calculate_floor_score(district_df, category, floor)
+        
+        # 5. 업종 다양성 점수 (0-15점)
+        diversity_score = self._calculate_diversity_score(district_df)
+        
+        # 총점 계산
+        total_score = (competition_score + saturation_score + location_score + 
+                      floor_score + diversity_score)
+        
+        # 추천 메시지 생성
+        recommendation = self._generate_recommendation(total_score, {
+            'competition': competition_score,
+            'saturation': saturation_score,
+            'location': location_score,
+            'floor': floor_score,
+            'diversity': diversity_score
+        })
+        
+        # 상세 정보
+        details = {
+            '동종업종수': len(district_df[district_df['상권업종중분류명'] == category]),
+            '전체점포수': len(district_df),
+            '업종비율': f"{len(district_df[district_df['상권업종중분류명'] == category]) / len(district_df) * 100:.1f}%",
+            '지역': district
+        }
+        
+        return StartupScore(
+            total_score=total_score,
+            competition_score=competition_score,
+            saturation_score=saturation_score,
+            location_score=location_score,
+            floor_score=floor_score,
+            diversity_score=diversity_score,
+            recommendation=recommendation,
+            details=details
+        )
+    
+    def _calculate_competition_score(self, district_df: pd.DataFrame, category: str) -> float:
+        """경쟁강도 점수 (낮을수록 좋음)"""
+        total_stores = len(district_df)
+        same_category = len(district_df[district_df['상권업종중분류명'] == category])
+        
+        if total_stores == 0:
+            return 10.0
+        
+        ratio = same_category / total_stores
+        
+        # 비율이 낮을수록 높은 점수 (경쟁이 적음)
+        if ratio < 0.05:
+            return 20.0
+        elif ratio < 0.10:
+            return 15.0
+        elif ratio < 0.15:
+            return 10.0
+        elif ratio < 0.20:
+            return 5.0
+        else:
+            return 0.0
+    
+    def _calculate_saturation_score(self, district_df: pd.DataFrame, category: str) -> float:
+        """포화도 점수"""
+        same_category = len(district_df[district_df['상권업종중분류명'] == category])
+        
+        # 동종 업종 수에 따른 점수
+        if same_category < 10:
+            return 20.0  # 블루오션
+        elif same_category < 30:
+            return 15.0
+        elif same_category < 50:
+            return 10.0
+        elif same_category < 100:
+            return 5.0
+        else:
+            return 0.0  # 레드오션
+    
+    def _calculate_location_score(self, district_df: pd.DataFrame, category: str) -> float:
+        """입지 점수"""
+        # 점포 밀집도가 적당히 높은 곳이 좋음 (유동인구가 많다는 의미)
+        density = len(district_df)
+        
+        if 500 < density < 2000:
+            return 25.0  # 최적
+        elif 200 < density <= 500 or 2000 <= density < 3000:
+            return 20.0
+        elif 100 < density <= 200 or 3000 <= density < 5000:
+            return 15.0
+        elif density <= 100:
+            return 10.0  # 너무 한적함
+        else:
+            return 5.0  # 너무 혼잡함
+    
+    def _calculate_floor_score(self, district_df: pd.DataFrame, category: str, floor: int) -> float:
+        """층수 적합도 점수"""
+        # 해당 업종의 층별 분포 분석
+        category_df = district_df[district_df['상권업종중분류명'] == category]
+        
+        if category_df.empty or '층정보' not in category_df.columns:
+            return 10.0
+        
+        # 층 정보 파싱
+        category_df = category_df.copy()
+        category_df['층정보_숫자'] = category_df['층정보'].apply(self._parse_floor)
+        
+        # 해당 업종에서 가장 많이 사용하는 층
+        floor_counts = category_df['층정보_숫자'].value_counts()
+        
+        if floor_counts.empty:
+            return 10.0
+        
+        most_common_floor = floor_counts.index[0]
+        
+        # 선택한 층과 선호 층 비교
+        if floor == most_common_floor:
+            return 20.0
+        elif abs(floor - most_common_floor) <= 1:
+            return 15.0
+        else:
+            return 10.0
+    
+    def _calculate_diversity_score(self, district_df: pd.DataFrame) -> float:
+        """업종 다양성 점수"""
+        if '상권업종중분류명' not in district_df.columns:
+            return 7.5
+        
+        num_categories = district_df['상권업종중분류명'].nunique()
+        
+        # 다양성이 높을수록 좋음 (다양한 소비자층)
+        if num_categories > 50:
+            return 15.0
+        elif num_categories > 30:
+            return 12.0
+        elif num_categories > 20:
+            return 9.0
+        else:
+            return 6.0
+    
+    def _parse_floor(self, floor_str):
+        """층 정보를 숫자로 변환"""
+        if pd.isna(floor_str):
+            return 1
+        floor_str = str(floor_str)
+        if '지하' in floor_str or 'B' in floor_str:
+            match = re.search(r'\d+', floor_str)
+            return -int(match.group()) if match else -1
+        elif '1층' in floor_str or floor_str == '1':
+            return 1
+        else:
+            match = re.search(r'\d+', floor_str)
+            return int(match.group()) if match else 1
+    
+    def _generate_recommendation(self, total_score: float, scores: Dict) -> str:
+        """추천 메시지 생성"""
+        if total_score >= 80:
+            level = "🟢 매우 우수"
+            msg = "창업 성공 가능성이 매우 높습니다! 적극 추천합니다."
+        elif total_score >= 65:
+            level = "🔵 우수"
+            msg = "창업하기 좋은 조건입니다. 세부 계획을 잘 세우세요."
+        elif total_score >= 50:
+            level = "🟡 보통"
+            msg = "신중한 검토가 필요합니다. 차별화 전략을 준비하세요."
+        elif total_score >= 35:
+            level = "🟠 주의"
+            msg = "경쟁이 치열합니다. 재고를 권장합니다."
+        else:
+            level = "🔴 위험"
+            msg = "창업을 권장하지 않습니다. 다른 지역을 고려하세요."
+        
+        # 가장 낮은 점수 항목 찾기
+        min_category = min(scores, key=scores.get)
+        weak_point = {
+            'competition': '경쟁이 매우 치열합니다',
+            'saturation': '시장이 포화 상태입니다',
+            'location': '입지가 최적이 아닙니다',
+            'floor': '층수 선택을 재고하세요',
+            'diversity': '업종 다양성이 부족합니다'
+        }
+        
+        return f"{level}\n{msg}\n\n⚠️ 약점: {weak_point[min_category]}"
+    
+    def _create_default_score(self, message: str) -> StartupScore:
+        """기본 점수 생성"""
+        return StartupScore(
+            total_score=0.0,
+            competition_score=0.0,
+            saturation_score=0.0,
+            location_score=0.0,
+            floor_score=0.0,
+            diversity_score=0.0,
+            recommendation=message,
+            details={}
+        )
+
+
+# ============================================================================
+# 반경 분석기
+# ============================================================================
+
+class RadiusAnalyzer:
+    """특정 위치 반경 분석"""
+    
+    def __init__(self, df: pd.DataFrame):
+        self.df = df
+    
+    def analyze_radius(self, lat: float, lon: float, radius_km: float, 
+                       category: Optional[str] = None) -> Dict:
+        """반경 내 경쟁자 분석"""
+        
+        # 반경 내 점포 필터링
+        nearby_stores = self._filter_by_radius(lat, lon, radius_km)
+        
+        if nearby_stores.empty:
+            return {
+                'total_stores': 0,
+                'category_stores': 0,
+                'message': '반경 내 점포가 없습니다.'
+            }
+        
+        # 동종 업종 필터링
+        if category:
+            category_stores = nearby_stores[nearby_stores['상권업종중분류명'] == category]
+            category_count = len(category_stores)
+        else:
+            category_count = 0
+        
+        # 업종별 분포
+        category_distribution = nearby_stores['상권업종중분류명'].value_counts().head(10).to_dict()
+        
+        # 경쟁 강도 계산
+        competition_level = self._calculate_competition_level(len(nearby_stores), category_count)
+        
+        # 결과 반환
+        return {
+            'total_stores': len(nearby_stores),
+            'category_stores': category_count,
+            'radius_km': radius_km,
+            'competition_level': competition_level,
+            'category_distribution': category_distribution,
+            'nearby_coords': nearby_stores[['위도', '경도', '상권업종중분류명']].to_dict('records')
+        }
+    
+    def _filter_by_radius(self, lat: float, lon: float, radius_km: float) -> pd.DataFrame:
+        """반경 내 점포 필터링 (Haversine 공식)"""
+        
+        # 위도/경도를 라디안으로 변환
+        lat_rad = np.radians(lat)
+        lon_rad = np.radians(lon)
+        
+        df_lat_rad = np.radians(self.df['위도'])
+        df_lon_rad = np.radians(self.df['경도'])
+        
+        # Haversine 공식
+        dlat = df_lat_rad - lat_rad
+        dlon = df_lon_rad - lon_rad
+        
+        a = np.sin(dlat/2)**2 + np.cos(lat_rad) * np.cos(df_lat_rad) * np.sin(dlon/2)**2
+        c = 2 * np.arcsin(np.sqrt(a))
+        
+        # 지구 반경 (km)
+        distance_km = 6371 * c
+        
+        # 반경 내 필터링
+        return self.df[distance_km <= radius_km].copy()
+    
+    def _calculate_competition_level(self, total: int, category: int) -> str:
+        """경쟁 강도 계산"""
+        if category == 0:
+            return "데이터 없음"
+        
+        ratio = category / total if total > 0 else 0
+        
+        if ratio > 0.3:
+            return "🔴 매우 높음"
+        elif ratio > 0.2:
+            return "🟠 높음"
+        elif ratio > 0.1:
+            return "🟡 보통"
+        elif ratio > 0.05:
+            return "🔵 낮음"
+        else:
+            return "🟢 매우 낮음"
+    
+    def create_radius_map(self, lat: float, lon: float, radius_km: float,
+                          category: Optional[str] = None) -> str:
+        """반경 분석 지도 생성"""
+        
+        # 지도 생성
+        m = folium.Map(location=[lat, lon], zoom_start=14)
+        
+        # 중심점 마커
+        folium.Marker(
+            [lat, lon],
+            popup="선택한 위치",
+            icon=folium.Icon(color='red', icon='star'),
+            tooltip="창업 희망 위치"
+        ).add_to(m)
+        
+        # 반경 원
+        folium.Circle(
+            location=[lat, lon],
+            radius=radius_km * 1000,  # km to m
+            color='blue',
+            fill=True,
+            fillOpacity=0.1,
+            popup=f"반경 {radius_km}km"
+        ).add_to(m)
+        
+        # 반경 내 점포 표시
+        nearby_stores = self._filter_by_radius(lat, lon, radius_km)
+        
+        if category:
+            # 동종 업종만 표시
+            category_stores = nearby_stores[nearby_stores['상권업종중분류명'] == category]
+            
+            for _, row in category_stores.iterrows():
+                folium.CircleMarker(
+                    location=[row['위도'], row['경도']],
+                    radius=3,
+                    color='red',
+                    fill=True,
+                    fillColor='red',
+                    fillOpacity=0.6,
+                    popup=f"{row['상권업종중분류명']}<br>{row.get('상호명', 'N/A')}"
+                ).add_to(m)
+        
+        return m._repr_html_()
+
+
+# ============================================================================
+# 최적 입지 추천 엔진
+# ============================================================================
+
+class LocationRecommender:
+    """최적 입지 추천"""
+    
+    def __init__(self, df: pd.DataFrame):
+        self.df = df
+        self.scorer = StartupScorer(df)
+    
+    def recommend_locations(self, category: str, budget: Optional[float] = None,
+                           preferred_regions: Optional[List[str]] = None,
+                           top_n: int = 5) -> List[Dict]:
+        """최적 입지 TOP N 추천"""
+        
+        # 지역 필터링
+        if preferred_regions:
+            filtered_df = self.df[self.df['시도명'].isin(preferred_regions)]
+        else:
+            filtered_df = self.df
+        
+        if filtered_df.empty:
+            return []
+        
+        # 시군구별로 점수 계산
+        districts = filtered_df['시군구명'].unique()
+        recommendations = []
+        
+        for district in districts[:50]:  # 상위 50개 지역만 분석 (성능 고려)
+            score = self.scorer.calculate_score(category, district, floor=1)
+            
+            district_df = filtered_df[filtered_df['시군구명'] == district]
+            
+            recommendations.append({
+                'district': district,
+                'score': score.total_score,
+                'competition_score': score.competition_score,
+                'saturation_score': score.saturation_score,
+                'total_stores': len(district_df),
+                'category_stores': len(district_df[district_df['상권업종중분류명'] == category]),
+                'recommendation': score.recommendation.split('\n')[0],  # 첫 줄만
+                'avg_lat': district_df['위도'].mean(),
+                'avg_lon': district_df['경도'].mean()
+            })
+        
+        # 점수 순으로 정렬
+        recommendations.sort(key=lambda x: x['score'], reverse=True)
+        
+        return recommendations[:top_n]
+    
+    def create_recommendation_map(self, recommendations: List[Dict]) -> str:
+        """추천 지역 지도 생성"""
+        
+        if not recommendations:
+            return "<p>추천 결과가 없습니다.</p>"
+        
+        # 중심점 계산
+        avg_lat = np.mean([r['avg_lat'] for r in recommendations])
+        avg_lon = np.mean([r['avg_lon'] for r in recommendations])
+        
+        # 지도 생성
+        m = folium.Map(location=[avg_lat, avg_lon], zoom_start=11)
+        
+        # 추천 지역 마커
+        colors = ['green', 'blue', 'orange', 'purple', 'red']
+        
+        for i, rec in enumerate(recommendations):
+            color = colors[i] if i < len(colors) else 'gray'
+            
+            folium.Marker(
+                location=[rec['avg_lat'], rec['avg_lon']],
+                popup=f"""
+                <b>{i+1}위: {rec['district']}</b><br>
+                점수: {rec['score']:.1f}점<br>
+                동종업종: {rec['category_stores']}개<br>
+                {rec['recommendation']}
+                """,
+                icon=folium.Icon(color=color, icon='info-sign'),
+                tooltip=f"#{i+1} {rec['district']} ({rec['score']:.1f}점)"
+            ).add_to(m)
+        
+        return m._repr_html_()
+
+
+# ============================================================================
+# 프랜차이즈 시뮬레이터
+# ============================================================================
+
+class FranchiseSimulator:
+    """프랜차이즈 vs 개인사업자 비교"""
+    
+    def __init__(self, df: pd.DataFrame):
+        self.df = df
+    
+    def analyze_franchise_ratio(self, category: str, district: Optional[str] = None) -> Dict:
+        """프랜차이즈 비율 분석"""
+        
+        # 지역 필터링
+        if district:
+            filtered_df = self.df[self.df['시군구명'].str.contains(district, na=False)]
+        else:
+            filtered_df = self.df
+        
+        # 해당 업종 필터링
+        category_df = filtered_df[filtered_df['상권업종중분류명'] == category]
+        
+        if category_df.empty:
+            return {
+                'total': 0,
+                'franchise': 0,
+                'individual': 0,
+                'franchise_ratio': 0.0,
+                'message': '데이터가 없습니다.'
+            }
+        
+        # 프랜차이즈 판별 (브랜드명이 있는 경우)
+        # 상호명에 특정 패턴이 있으면 프랜차이즈로 간주
+        if '상호명' in category_df.columns:
+            # 숫자가 들어간 상호명(ex: 스타벅스 강남점) 또는 반복되는 이름
+            name_counts = category_df['상호명'].value_counts()
+            franchise_names = name_counts[name_counts > 1].index.tolist()
+            
+            franchise_count = len(category_df[category_df['상호명'].isin(franchise_names)])
+            individual_count = len(category_df) - franchise_count
+        else:
+            # 상호명 정보가 없으면 추정
+            franchise_count = int(len(category_df) * 0.3)  # 30% 추정
+            individual_count = len(category_df) - franchise_count
+        
+        franchise_ratio = franchise_count / len(category_df) * 100
+        
+        # 추천 메시지
+        if franchise_ratio > 70:
+            message = "🔴 프랜차이즈 비율이 매우 높습니다. 개인 사업자에게 불리할 수 있습니다."
+        elif franchise_ratio > 50:
+            message = "🟠 프랜차이즈 비율이 높습니다. 차별화 전략이 필요합니다."
+        elif franchise_ratio > 30:
+            message = "🟡 프랜차이즈와 개인이 균형을 이루고 있습니다."
+        else:
+            message = "🟢 개인 사업자 비율이 높습니다. 진입하기 좋은 시장입니다."
+        
+        return {
+            'total': len(category_df),
+            'franchise': franchise_count,
+            'individual': individual_count,
+            'franchise_ratio': franchise_ratio,
+            'message': message,
+            'district': district or '전체'
+        }
+    
+    def create_comparison_chart(self, analysis: Dict) -> go.Figure:
+        """프랜차이즈 비교 차트"""
+        
+        fig = go.Figure(data=[
+            go.Bar(
+                name='프랜차이즈',
+                x=['점포 수'],
+                y=[analysis['franchise']],
+                text=[f"{analysis['franchise']}개<br>({analysis['franchise_ratio']:.1f}%)"],
+                textposition='auto',
+                marker_color='#e74c3c'
+            ),
+            go.Bar(
+                name='개인사업자',
+                x=['점포 수'],
+                y=[analysis['individual']],
+                text=[f"{analysis['individual']}개<br>({100-analysis['franchise_ratio']:.1f}%)"],
+                textposition='auto',
+                marker_color='#3498db'
+            )
+        ])
+        
+        fig.update_layout(
+            title=f"프랜차이즈 vs 개인사업자 비율 - {analysis['district']}",
+            barmode='group',
+            height=400,
+            showlegend=True
+        )
+        
+        return fig
+
+
+# ============================================================================
+# 상권 분석 클래스 (기존)
 # ============================================================================
 
 class MarketAnalyzer:
@@ -89,6 +644,12 @@ class MarketAnalyzer:
     def __init__(self, df: pd.DataFrame):
         self.df = df
         self.prepare_data()
+        
+        # 새로운 분석기 초기화
+        self.startup_scorer = StartupScorer(df)
+        self.radius_analyzer = RadiusAnalyzer(df)
+        self.location_recommender = LocationRecommender(df)
+        self.franchise_simulator = FranchiseSimulator(df)
     
     def prepare_data(self):
         """데이터 전처리"""
@@ -116,39 +677,122 @@ class MarketAnalyzer:
             match = re.search(r'\d+', floor_str)
             return int(match.group()) if match else None
     
-    def get_comprehensive_insights(self) -> List[Dict]:
-        """포괄적인 인사이트 생성"""
-        insights = []
+    def create_interactive_map(self, sample_size: int = 3000) -> str:
+        """인터랙티브 클릭 가능한 밀집도 지도"""
         
-        # 1. 업종별 점포 수 (상권업종중분류)
-        insights.append(self._create_top_categories_chart())
+        if self.df.empty or len(self.df) == 0:
+            return "<p>데이터가 없습니다.</p>"
         
-        # 2. 대분류별 분포 (파이 차트)
-        insights.append(self._create_major_category_pie())
+        # 샘플링
+        df_sample = self.df.sample(n=min(sample_size, len(self.df)), random_state=42)
         
-        # 3. 층별 분포 상세 분석
-        insights.append(self._create_floor_analysis())
+        # 중심점 계산
+        center_lat = df_sample['위도'].mean()
+        center_lon = df_sample['경도'].mean()
         
-        # 4. 지역별 업종 다양성 지수
-        insights.append(self._create_diversity_index())
+        # 지도 생성
+        m = folium.Map(
+            location=[center_lat, center_lon],
+            zoom_start=12,
+            tiles='OpenStreetMap'
+        )
         
-        # 5. 프랜차이즈 vs 개인사업자 분석
-        insights.append(self._create_franchise_analysis())
+        # 히트맵 데이터
+        heat_data = [[row['위도'], row['경도']] for _, row in df_sample.iterrows()]
+        HeatMap(heat_data, radius=10, blur=15, max_zoom=13).add_to(m)
+        
+        # 클릭 가능한 마커 클러스터
+        marker_cluster = MarkerCluster(name="점포 클러스터").add_to(m)
+        
+        # 업종별 색상
+        category_colors = {}
+        color_palette = ['blue', 'red', 'green', 'purple', 'orange', 'darkred', 
+                        'lightred', 'beige', 'darkblue', 'darkgreen']
+        
+        for i, category in enumerate(df_sample['상권업종중분류명'].unique()[:10]):
+            category_colors[category] = color_palette[i % len(color_palette)]
+        
+        # 마커 추가 (샘플링하여 성능 개선)
+        for idx, row in df_sample.head(500).iterrows():
+            category = row.get('상권업종중분류명', 'N/A')
+            color = category_colors.get(category, 'gray')
+            
+            popup_html = f"""
+            <div style="font-family: Arial; width: 200px;">
+                <h4 style="margin: 0 0 10px 0;">{row.get('상호명', 'N/A')}</h4>
+                <p style="margin: 5px 0;"><b>업종:</b> {category}</p>
+                <p style="margin: 5px 0;"><b>주소:</b> {row.get('도로명주소', 'N/A')}</p>
+                <p style="margin: 5px 0;"><b>층:</b> {row.get('층정보', 'N/A')}</p>
+                <hr style="margin: 10px 0;">
+                <p style="margin: 5px 0; font-size: 12px;">
+                    📍 위도: {row['위도']:.6f}<br>
+                    📍 경도: {row['경도']:.6f}
+                </p>
+            </div>
+            """
+            
+            folium.Marker(
+                location=[row['위도'], row['경도']],
+                popup=folium.Popup(popup_html, max_width=250),
+                tooltip=f"{category}",
+                icon=folium.Icon(color=color, icon='info-sign')
+            ).add_to(marker_cluster)
+        
+        # 레이어 컨트롤
+        folium.LayerControl().add_to(m)
+        
+        # 클릭 이벤트를 위한 JavaScript 추가
+        click_js = """
+        <script>
+        function onMapClick(e) {
+            var lat = e.latlng.lat.toFixed(6);
+            var lng = e.latlng.lng.toFixed(6);
+            
+            // Gradio의 텍스트박스에 좌표 입력
+            var latInput = document.querySelector('input[placeholder*="위도"]');
+            var lngInput = document.querySelector('input[placeholder*="경도"]');
+            
+            if (latInput) latInput.value = lat;
+            if (lngInput) lngInput.value = lng;
+            
+            // 이벤트 트리거
+            if (latInput) latInput.dispatchEvent(new Event('input', { bubbles: true }));
+            if (lngInput) lngInput.dispatchEvent(new Event('input', { bubbles: true }));
+            
+            alert('선택된 위치\\n위도: ' + lat + '\\n경도: ' + lng);
+        }
+        </script>
+        """
         
-        # 6. 업종별 층 선호도
-        insights.append(self._create_floor_preference())
+        return m._repr_html_() + click_js
+    
+    def analyze_for_llm(self) -> Dict:
+        """LLM을 위한 데이터 컨텍스트 생성"""
         
-        # 7. 시군구별 상권 밀집도 TOP 20
-        insights.append(self._create_district_density())
+        context = {
+            '총_점포_수': len(self.df),
+            '업종_수': self.df['상권업종중분류명'].nunique() if '상권업종중분류명' in self.df.columns else 0,
+            '상위_업종': self.df['상권업종중분류명'].value_counts().head(10).to_dict() if '상권업종중분류명' in self.df.columns else {},
+            '지역_분포': self.df['시군구명'].value_counts().head(10).to_dict() if '시군구명' in self.df.columns else {},
+        }
         
-        # 8. 업종 상관관계 (같은 지역에 자주 나타나는 업종)
-        insights.append(self._create_category_correlation())
+        # 층 정보
+        if '층정보_숫자' in self.df.columns:
+            floor_counts = self.df['층정보_숫자'].value_counts()
+            first_floor = floor_counts.get(1, 0)
+            context['1층_비율'] = f"{first_floor / len(self.df) * 100:.1f}%"
         
-        # 9. 소분류 트렌드 (상위 20개)
-        insights.append(self._create_subcategory_trends())
+        return context
+    
+    def get_comprehensive_insights(self) -> List[Dict]:
+        """포괄적인 인사이트 생성 (기존 10가지 분석)"""
+        insights = []
         
-        # 10. 지역별 특화 업종
-        insights.append(self._create_regional_specialization())
+        # 기존 분석들 (간략화)
+        insights.append(self._create_top_categories_chart())
+        insights.append(self._create_major_category_pie())
+        insights.append(self._create_floor_analysis())
+        insights.append(self._create_diversity_index())
         
         return insights
     
@@ -196,7 +840,6 @@ class MarketAnalyzer:
         floor_data = self.df['층정보_숫자'].dropna()
         floor_counts = floor_data.value_counts().sort_index()
         
-        # 지하, 1층, 2층 이상으로 그룹화
         underground = floor_counts[floor_counts.index < 0].sum()
         first_floor = floor_counts.get(1, 0)
         upper_floors = floor_counts[floor_counts.index > 1].sum()
@@ -213,7 +856,7 @@ class MarketAnalyzer:
             )
         ])
         fig.update_layout(
-            title='🏢 층별 점포 분포 (지하 vs 1층 vs 상층)',
+            title='🏢 층별 점포 분포',
             xaxis_title='층 구분',
             yaxis_title='점포 수',
             height=400
@@ -225,363 +868,114 @@ class MarketAnalyzer:
         if '시군구명' not in self.df.columns or '상권업종중분류명' not in self.df.columns:
             return None
         
-        # 각 시군구별 업종 다양성 계산 (업종 수 / 전체 점포 수)
         diversity_data = []
-        for district in self.df['시군구명'].unique()[:20]:  # 상위 20개
+        for district in self.df['시군구명'].unique()[:20]:
             district_df = self.df[self.df['시군구명'] == district]
             num_categories = district_df['상권업종중분류명'].nunique()
             total_stores = len(district_df)
             diversity_score = (num_categories / total_stores) * 100
             diversity_data.append({
                 '시군구': district,
-                '다양성 지수': diversity_score,
-                '업종 수': num_categories,
-                '총 점포': total_stores
+                '다양성 지수': diversity_score
             })
         
-        diversity_df = pd.DataFrame(diversity_data).sort_values('다양성 지수', ascending=False).head(15)
+        df_diversity = pd.DataFrame(diversity_data).sort_values('다양성 지수', ascending=False)
         
         fig = px.bar(
-            diversity_df,
+            df_diversity,
             x='다양성 지수',
             y='시군구',
             orientation='h',
-            title='🌈 지역별 업종 다양성 지수 (상위 15개)',
-            labels={'다양성 지수': '다양성 지수 (%)', '시군구': '지역'},
+            title='🌈 지역별 업종 다양성 지수 TOP 20',
             color='다양성 지수',
-            color_continuous_scale='viridis',
-            hover_data=['업종 수', '총 점포']
+            color_continuous_scale='viridis'
         )
-        fig.update_layout(height=500)
+        fig.update_layout(height=500, showlegend=False)
         return {'type': 'plot', 'data': fig, 'title': '업종 다양성 분석'}
-    
-    def _create_franchise_analysis(self) -> Dict:
-        """프랜차이즈 vs 개인사업자 분석"""
-        if '상호명' not in self.df.columns:
-            return None
-        
-        # 주요 프랜차이즈 키워드
-        franchise_keywords = [
-            'CU', 'GS25', '세븐일레븐', '이마트24', '미니스톱',
-            '스타벅스', '투썸플레이스', '이디야', '탐앤탐스', '커피빈',
-            '맥도날드', '버거킹', '롯데리아', 'KFC', '맘스터치',
-            'BBQ', '교촌', '굽네', 'bhc', '네네치킨'
-        ]
-        
-        franchise_counts = {}
-        for keyword in franchise_keywords:
-            count = self.df['상호명'].str.contains(keyword, case=False, na=False).sum()
-            if count > 0:
-                franchise_counts[keyword] = count
-        
-        total_franchise = sum(franchise_counts.values())
-        total_stores = len(self.df)
-        individual_stores = total_stores - total_franchise
-        
-        # 파이 차트
-        fig = make_subplots(
-            rows=1, cols=2,
-            specs=[[{'type': 'pie'}, {'type': 'bar'}]],
-            subplot_titles=('전체 비율', '프랜차이즈별 점포 수')
-        )
-        
-        # 전체 비율
-        fig.add_trace(
-            go.Pie(
-                labels=['개인사업자', '프랜차이즈'],
-                values=[individual_stores, total_franchise],
-                hole=0.3,
-                marker_colors=['#3498db', '#e74c3c']
-            ),
-            row=1, col=1
-        )
-        
-        # 프랜차이즈별
-        top_franchises = dict(sorted(franchise_counts.items(), key=lambda x: x[1], reverse=True)[:10])
-        fig.add_trace(
-            go.Bar(
-                x=list(top_franchises.keys()),
-                y=list(top_franchises.values()),
-                marker_color='#e74c3c'
-            ),
-            row=1, col=2
-        )
-        
-        fig.update_layout(
-            title_text='🏪 프랜차이즈 vs 개인사업자 분석',
-            showlegend=True,
-            height=400
-        )
-        return {'type': 'plot', 'data': fig, 'title': '프랜차이즈 점유율'}
-    
-    def _create_floor_preference(self) -> Dict:
-        """업종별 층 선호도"""
-        if '상권업종중분류명' not in self.df.columns or '층정보_숫자' not in self.df.columns:
-            return None
-        
-        # 상위 10개 업종의 층별 분포
-        top_categories = self.df['상권업종중분류명'].value_counts().head(10).index
-        
-        floor_pref_data = []
-        for category in top_categories:
-            cat_df = self.df[self.df['상권업종중분류명'] == category]
-            underground = (cat_df['층정보_숫자'] < 0).sum()
-            first_floor = (cat_df['층정보_숫자'] == 1).sum()
-            upper_floors = (cat_df['층정보_숫자'] > 1).sum()
-            
-            total = underground + first_floor + upper_floors
-            if total > 0:
-                floor_pref_data.append({
-                    '업종': category,
-                    '지하': (underground / total) * 100,
-                    '1층': (first_floor / total) * 100,
-                    '2층 이상': (upper_floors / total) * 100
-                })
-        
-        pref_df = pd.DataFrame(floor_pref_data)
-        
-        fig = go.Figure(data=[
-            go.Bar(name='지하', x=pref_df['업종'], y=pref_df['��하'], marker_color='#e74c3c'),
-            go.Bar(name='1층', x=pref_df['업종'], y=pref_df['1층'], marker_color='#3498db'),
-            go.Bar(name='2층 이상', x=pref_df['업종'], y=pref_df['2층 이상'], marker_color='#95a5a6')
-        ])
-        
-        fig.update_layout(
-            title='🎯 업종별 층 선호도 (상위 10개)',
-            xaxis_title='업종',
-            yaxis_title='비율 (%)',
-            barmode='stack',
-            height=500,
-            xaxis_tickangle=-45
-        )
-        return {'type': 'plot', 'data': fig, 'title': '층별 입지 선호도'}
-    
-    def _create_district_density(self) -> Dict:
-        """시군구별 상권 밀집도"""
-        if '시군구명' not in self.df.columns:
-            return None
-        
-        district_counts = self.df['시군구명'].value_counts().head(20)
-        
-        fig = px.bar(
-            x=district_counts.values,
-            y=district_counts.index,
-            orientation='h',
-            title='🌆 시군구별 상권 밀집도 TOP 20',
-            labels={'x': '점포 수', 'y': '시군구'},
-            color=district_counts.values,
-            color_continuous_scale='reds'
-        )
-        fig.update_layout(showlegend=False, height=600)
-        return {'type': 'plot', 'data': fig, 'title': '지역별 밀집도'}
-    
-    def _create_category_correlation(self) -> Dict:
-        """업종 상관관계 (같은 동에 자주 나타나는 업종)"""
-        if '행정동명' not in self.df.columns or '상권업종중분류명' not in self.df.columns:
-            return None
-        
-        # 상위 10개 업종만 분석
-        top_categories = self.df['상권업종중분류명'].value_counts().head(10).index.tolist()
-        
-        # 각 동별로 업종 카운트
-        correlation_matrix = []
-        for cat1 in top_categories:
-            row = []
-            for cat2 in top_categories:
-                # 두 업종이 같은 동에 있는 경우의 수
-                cat1_dongs = set(self.df[self.df['상권업종중분류명'] == cat1]['행정동명'].unique())
-                cat2_dongs = set(self.df[self.df['상권업종중분류명'] == cat2]['행정동명'].unique())
-                intersection = len(cat1_dongs & cat2_dongs)
-                union = len(cat1_dongs | cat2_dongs)
-                similarity = (intersection / union * 100) if union > 0 else 0
-                row.append(similarity)
-            correlation_matrix.append(row)
-        
-        fig = go.Figure(data=go.Heatmap(
-            z=correlation_matrix,
-            x=top_categories,
-            y=top_categories,
-            colorscale='Blues',
-            text=np.round(correlation_matrix, 1),
-            texttemplate='%{text}',
-            textfont={"size": 10}
-        ))
-        
-        fig.update_layout(
-            title='🔗 업종 상관관계 매트릭스 (같은 지역 동시 출현율)',
-            xaxis_title='업종',
-            yaxis_title='업종',
-            height=600,
-            xaxis_tickangle=-45
-        )
-        return {'type': 'plot', 'data': fig, 'title': '업종 공존 분석'}
-    
-    def _create_subcategory_trends(self) -> Dict:
-        """소분류 트렌드"""
-        if '상권업종소분류명' not in self.df.columns:
-            return None
-        
-        subcat_counts = self.df['상권업종소분류명'].value_counts().head(20)
-        
-        fig = px.treemap(
-            names=subcat_counts.index,
-            parents=[''] * len(subcat_counts),
-            values=subcat_counts.values,
-            title='🔍 소분류 업종 트렌드 TOP 20',
-            color=subcat_counts.values,
-            color_continuous_scale='greens'
-        )
-        fig.update_layout(height=600)
-        return {'type': 'plot', 'data': fig, 'title': '세부 업종 분석'}
-    
-    def _create_regional_specialization(self) -> Dict:
-        """지역별 특화 업종"""
-        if '시도명' not in self.df.columns or '상권업종중분류명' not in self.df.columns:
-            return None
-        
-        # 각 시도별 상위 3개 업종
-        specialization_data = []
-        for region in self.df['시도명'].unique():
-            region_df = self.df[self.df['시도명'] == region]
-            top_categories = region_df['상권업종중분류명'].value_counts().head(3)
-            for category, count in top_categories.items():
-                specialization_data.append({
-                    '지역': region,
-                    '특화업종': category,
-                    '점포수': count
-                })
-        
-        spec_df = pd.DataFrame(specialization_data)
-        
-        fig = px.sunburst(
-            spec_df,
-            path=['지역', '특화업종'],
-            values='점포수',
-            title='🎯 지역별 특화 업종 (각 지역 TOP 3)',
-            color='점포수',
-            color_continuous_scale='oranges'
-        )
-        fig.update_layout(height=700)
-        return {'type': 'plot', 'data': fig, 'title': '지역 특화 분석'}
-    
-    def create_density_map(self, sample_size: int = 1000) -> str:
-        """점포 밀집도 지도 생성"""
-        df_sample = self.df.sample(n=min(sample_size, len(self.df)), random_state=42)
-        
-        center_lat = df_sample['위도'].mean()
-        center_lon = df_sample['경도'].mean()
-        
-        m = folium.Map(location=[center_lat, center_lon], zoom_start=11, tiles='OpenStreetMap')
-        
-        # 히트맵
-        heat_data = [[row['위도'], row['경도']] for _, row in df_sample.iterrows()]
-        HeatMap(heat_data, radius=15, blur=25, max_zoom=13).add_to(m)
-        
-        return m._repr_html_()
-    
-    def analyze_for_llm(self) -> Dict:
-        """LLM 컨텍스트용 분석 데이터"""
-        context = {
-            '총_점포_수': len(self.df),
-            '지역_수': self.df['시도명'].nunique() if '시도명' in self.df.columns else 0,
-            '업종_수': self.df['상권업종중분류명'].nunique() if '상권업종중분류명' in self.df.columns else 0,
-        }
-        
-        if '상권업종중분류명' in self.df.columns:
-            context['상위_업종_5'] = self.df['상권업종중분류명'].value_counts().head(5).to_dict()
-        
-        if '층정보_숫자' in self.df.columns:
-            first_floor_ratio = (self.df['층정보_숫자'] == 1).sum() / len(self.df) * 100
-            context['1층_비율'] = f"{first_floor_ratio:.1f}%"
-        
-        return context
 
 
 # ============================================================================
-# LLM 쿼리 프로세서
+# LLM 프로세서 (스트리밍 지원)
 # ============================================================================
 
 class LLMQueryProcessor:
-    """Fireworks AI 기반 자연어 처리"""
+    """Fireworks AI를 활용한 상권 분석 챗봇 (스트리밍)"""
     
-    def __init__(self, api_key: str = None):
-        # 환경변수에서 API 키 가져오기
-        self.api_key = api_key or os.getenv("FIREWORKS_API_KEY")
-        self.base_url = "https://api.fireworks.ai/inference/v1/chat/completions"
-        
+    def __init__(self):
+        self.api_key = os.getenv("FIREWORKS_API_KEY")
         if not self.api_key:
-            raise ValueError("❌ FIREWORKS_API_KEY 환경변수를 설정하거나 API 키를 입력해주세요!")
+            raise ValueError("FIREWORKS_API_KEY 환경변수가 설정되지 않았습니다.")
+        
+        self.base_url = "https://api.fireworks.ai/inference/v1/chat/completions"
+        self.model = "accounts/fireworks/models/qwen3-235b-fp8"
     
-    def process_query(self, query: str, data_context: Dict, chat_history: List = None, max_retries: int = 3) -> str:
-        """자연어 쿼리 처리 (재시도 로직 포함)"""
-        system_prompt = f"""당신은 한국 상권 데이터 분석 전문가입니다.
-
-📊 **현재 분석 데이터**
-{json.dumps(data_context, ensure_ascii=False, indent=2)}
+    def process_query_stream(self, query: str, data_context: Dict, chat_history: List[Dict]):
+        """스트리밍 방식으로 응답 생성"""
+        
+        system_prompt = f"""당신은 대한민국 상권 분석 전문가입니다.
+소상공인들에게 실용적이고 구체적인 창업 조언을 제공합니다.
 
-구체적인 숫자와 비율로 정량적 분석을 제공하세요.
-창업, 투자, 경쟁 분석 관점에서 실용적 인사이트를 제공하세요."""
+현재 분석 중인 데이터:
+- 총 점포 수: {data_context.get('총_점포_수', 0):,}개
+- 분석 업종: {data_context.get('업종_수', 0)}개
+- 주요 업종: {', '.join(list(data_context.get('상위_업종', {}).keys())[:5])}
+- 주요 지역: {', '.join(list(data_context.get('지역_분포', {}).keys())[:5])}
 
+답변 시 주의사항:
+1. 구체적인 숫자와 데이터를 활용하세요
+2. 창업 리스크와 기회를 균형있게 제시하세요
+3. 실행 가능한 조언을 제공하세요
+4. 이모지를 활용해 가독성을 높이세요
+5. 한국 소상공인의 현실을 반영하세요"""
+        
         messages = [{"role": "system", "content": system_prompt}]
-        if chat_history:
-            messages.extend(chat_history[-6:])
+        messages.extend(chat_history)
         messages.append({"role": "user", "content": query})
         
-        payload = {
-            "model": "accounts/fireworks/models/qwen3-235b-a22b-instruct-2507",
-            "max_tokens": 2000,
-            "temperature": 0.7,
-            "messages": messages
-        }
-        
         headers = {
             "Authorization": f"Bearer {self.api_key}",
             "Content-Type": "application/json"
         }
         
-        # 재시도 로직
-        for attempt in range(max_retries):
-            try:
-                # 타임아웃을 60초로 증가
-                response = requests.post(
-                    self.base_url, 
-                    headers=headers, 
-                    json=payload, 
-                    timeout=60
-                )
-                
-                if response.status_code == 200:
-                    return response.json()['choices'][0]['message']['content']
-                elif response.status_code == 429:
-                    # Rate limit - 재시도
-                    wait_time = (attempt + 1) * 2
-                    time.sleep(wait_time)
-                    continue
-                else:
-                    return f"⚠️ API 오류: {response.status_code} - {response.text[:200]}"
-                    
-            except requests.exceptions.Timeout:
-                if attempt < max_retries - 1:
-                    time.sleep(2)
-                    continue
-                else:
-                    return "⚠️ API 응답 시간 초과. 잠시 후 다시 시도해주세요."
-                    
-            except requests.exceptions.ConnectionError:
-                if attempt < max_retries - 1:
-                    time.sleep(2)
-                    continue
-                else:
-                    return "⚠️ 네트워크 연결 오류. 인터넷 연결을 확인해주세요."
-                    
-            except Exception as e:
-                if attempt < max_retries - 1:
-                    time.sleep(1)
-                    continue
-                else:
-                    return f"❌ 오류: {str(e)}"
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "max_tokens": 4096,  # 토큰 수 증가
+            "temperature": 0.7,
+            "top_p": 0.9,
+            "stream": True  # 스트리밍 활성화
+        }
         
-        return "⚠️ 최대 재시도 횟수 초과. 잠시 후 다시 시도해주세요."
+        try:
+            response = requests.post(
+                self.base_url,
+                headers=headers,
+                json=payload,
+                stream=True,
+                timeout=60
+            )
+            response.raise_for_status()
+            
+            # 스트리밍 응답 처리
+            for line in response.iter_lines():
+                if line:
+                    line = line.decode('utf-8')
+                    if line.startswith('data: '):
+                        data = line[6:]  # 'data: ' 제거
+                        if data == '[DONE]':
+                            break
+                        try:
+                            json_data = json.loads(data)
+                            if 'choices' in json_data and len(json_data['choices']) > 0:
+                                delta = json_data['choices'][0].get('delta', {})
+                                content = delta.get('content', '')
+                                if content:
+                                    yield content
+                        except json.JSONDecodeError:
+                            continue
+        
+        except requests.exceptions.RequestException as e:
+            yield f"\n\n❌ API 오류: {str(e)}"
 
 
 # ============================================================================
@@ -589,31 +983,36 @@ class LLMQueryProcessor:
 # ============================================================================
 
 class AppState:
+    """앱 전역 상태"""
     def __init__(self):
+        self.df = None
         self.analyzer = None
         self.llm_processor = None
-        self.chat_history = []
 
 app_state = AppState()
 
 
 # ============================================================================
-# Gradio 인터페이스 함수
+# Gradio 이벤트 핸들러
 # ============================================================================
 
 def load_data(regions):
     """데이터 로드"""
-    if not regions:
-        return "❌ 최소 1개 지역을 선택해주세요!", None, None, None
-    
     try:
+        if not regions:
+            return "⚠️ 지역을 선택해주세요!", None, None, None
+        
+        if len(regions) > 5:
+            return "⚠️ 최대 5개 지역까지 선택 가능합니다!", None, None, None
+        
         df = MarketDataLoader.load_multiple_regions(regions, sample_per_region=30000)
+        
         if df.empty:
             return "❌ 데이터 로드 실패!", None, None, None
         
+        app_state.df = df
         app_state.analyzer = MarketAnalyzer(df)
         
-        # 기본 통계
         stats = f"""
 ✅ **데이터 로드 완료!**
 
@@ -622,6 +1021,11 @@ def load_data(regions):
 - 분석 지역: {', '.join(regions)}
 - 업종 수: {df['상권업종중분류명'].nunique()}개
 - 대분류: {df['상권업종대분류명'].nunique()}개
+
+🎯 **새로운 기능 활용하기**
+1. 📊 인사이트 탭: 기본 분석 확인
+2. 🎯 창업 분석 탭: 성공 스코어 계산
+3. 🤖 AI 챗봇 탭: 무엇이든 물어보기
 """
         
         return stats, gr.update(visible=True), gr.update(visible=True), gr.update(visible=True)
@@ -630,48 +1034,338 @@ def load_data(regions):
 
 
 def generate_insights():
-    """인사이트 생성"""
+    """기��� 인사이트 생성"""
     if app_state.analyzer is None:
-        return [None] * 11
+        return [None] * 5
     
     insights = app_state.analyzer.get_comprehensive_insights()
-    map_html = app_state.analyzer.create_density_map(sample_size=2000)
+    map_html = app_state.analyzer.create_interactive_map(sample_size=3000)
     
     result = [map_html]
-    for insight in insights:
+    for insight in insights[:4]:
         if insight and insight['type'] == 'plot':
             result.append(insight['data'])
         else:
             result.append(None)
     
-    # 부족한 차트는 None으로 채우기
-    while len(result) < 11:
-        result.append(None)
+    return result
+
+
+def calculate_startup_score(category, district, floor, budget):
+    """창업 성공 점수 계산"""
+    if app_state.analyzer is None:
+        return "❌ 먼저 데이터를 로드해주세요!", None
+    
+    try:
+        floor_num = int(floor) if floor else 1
+        budget_num = float(budget) if budget else None
+        
+        score = app_state.analyzer.startup_scorer.calculate_score(
+            category, district, floor_num, budget_num
+        )
+        
+        # 결과 텍스트
+        result_text = f"""
+# 🎯 창업 성공 확률 분석 결과
+
+## 📊 종합 점수: **{score.total_score:.1f}점 / 100점**
+
+{score.recommendation}
+
+---
+
+### 📈 세부 점수
+
+| 항목 | 점수 | 설명 |
+|------|------|------|
+| 🎯 경쟁강도 | {score.competition_score:.1f}/20 | 동종 업종 경쟁 수준 |
+| 📊 포화도 | {score.saturation_score:.1f}/20 | 시장 포화 정도 |
+| 📍 입지 | {score.location_score:.1f}/25 | 상권 밀집도 및 유동인구 |
+| 🏢 층수 적합도 | {score.floor_score:.1f}/20 | 업종별 층수 선호도 |
+| 🌈 업종 다양성 | {score.diversity_score:.1f}/15 | 지역 내 업종 다양성 |
+
+---
+
+### 📋 상세 정보
+
+- **지역**: {score.details.get('지역', 'N/A')}
+- **동종 업종 수**: {score.details.get('동종업종수', 0):,}개
+- **전체 점포 수**: {score.details.get('전체점포수', 0):,}개
+- **업종 비율**: {score.details.get('업종비율', 'N/A')}
+
+---
+
+### 💡 창업 팁
+
+{'- 경쟁이 적은 시간대나 특화 메뉴로 차별화하세요' if score.competition_score < 15 else ''}
+{'- 온라인 마케팅과 배달 서비스를 적극 활용하세요' if score.location_score < 20 else ''}
+{'- 프랜차이즈 가맹을 고려해보세요' if score.saturation_score < 15 else ''}
+"""
+        
+        # 점수 시각화 차트
+        fig = go.Figure(data=[
+            go.Bar(
+                x=['경쟁강도', '포화도', '입지', '층수', '다양성'],
+                y=[score.competition_score, score.saturation_score, 
+                   score.location_score, score.floor_score, score.diversity_score],
+                text=[f"{score.competition_score:.1f}/20", 
+                      f"{score.saturation_score:.1f}/20",
+                      f"{score.location_score:.1f}/25",
+                      f"{score.floor_score:.1f}/20",
+                      f"{score.diversity_score:.1f}/15"],
+                textposition='auto',
+                marker_color=['#3498db', '#e74c3c', '#2ecc71', '#f39c12', '#9b59b6']
+            )
+        ])
+        
+        fig.update_layout(
+            title=f"창업 성공 확률: {score.total_score:.1f}점",
+            yaxis_title='점수',
+            height=400,
+            showlegend=False
+        )
+        
+        return result_text, fig
+        
+    except Exception as e:
+        return f"❌ 오류: {str(e)}", None
+
+
+def analyze_radius(lat, lon, radius, category):
+    """반경 분석"""
+    if app_state.analyzer is None:
+        return "❌ 먼저 데이터를 로드해주세요!", None, None
+    
+    try:
+        lat_f = float(lat)
+        lon_f = float(lon)
+        radius_f = float(radius)
+        
+        analysis = app_state.analyzer.radius_analyzer.analyze_radius(
+            lat_f, lon_f, radius_f, category if category else None
+        )
+        
+        # 결과 텍스트
+        result_text = f"""
+# 📍 반경 {radius_f}km 경쟁자 분석
+
+## 🎯 분석 결과
+
+- **총 점포 수**: {analysis['total_stores']:,}개
+- **동종 업종 수**: {analysis['category_stores']:,}개
+- **경쟁 강도**: {analysis['competition_level']}
+
+---
+
+### 📊 주요 업종 TOP 10
+
+"""
+        for i, (cat, count) in enumerate(list(analysis['category_distribution'].items())[:10], 1):
+            result_text += f"{i}. **{cat}**: {count}개\n"
+        
+        result_text += f"""
+---
+
+### 💡 분석 의견
+
+"""
+        if analysis['category_stores'] == 0:
+            result_text += "✅ 동종 업종이 없어 경쟁이 없습니다. 블루오션 기회!\n"
+        elif analysis['category_stores'] < 5:
+            result_text += "🟢 경쟁이 적습니다. 창업하기 좋은 환경입니다.\n"
+        elif analysis['category_stores'] < 15:
+            result_text += "🟡 적당한 경쟁이 있습니다. 차별화 전략이 필요합니다.\n"
+        elif analysis['category_stores'] < 30:
+            result_text += "🟠 경쟁이 치열합니다. 신중한 검토가 필요합니다.\n"
+        else:
+            result_text += "🔴 경쟁이 매우 치열합니다. 다른 지역을 고려하세요.\n"
+        
+        # 지도 생성
+        map_html = app_state.analyzer.radius_analyzer.create_radius_map(
+            lat_f, lon_f, radius_f, category if category else None
+        )
+        
+        # 차트 생성
+        top_10 = dict(list(analysis['category_distribution'].items())[:10])
+        fig = px.bar(
+            x=list(top_10.values()),
+            y=list(top_10.keys()),
+            orientation='h',
+            title=f'반경 {radius_f}km 내 업종 분포',
+            labels={'x': '점포 수', 'y': '업종'},
+            color=list(top_10.values()),
+            color_continuous_scale='reds'
+        )
+        fig.update_layout(height=500, showlegend=False)
+        
+        return result_text, map_html, fig
+        
+    except Exception as e:
+        return f"❌ 오류: {str(e)}", None, None
+
+
+def recommend_locations(category, budget, regions):
+    """최적 입지 추천"""
+    if app_state.analyzer is None:
+        return "❌ 먼저 데이터를 로드해주세요!", None, None
+    
+    try:
+        budget_num = float(budget) if budget else None
+        preferred = regions if regions else None
+        
+        recommendations = app_state.analyzer.location_recommender.recommend_locations(
+            category, budget_num, preferred, top_n=5
+        )
+        
+        if not recommendations:
+            return "❌ 추천 결과가 없습니다.", None, None
+        
+        # 결과 텍스트
+        result_text = f"""
+# 🏆 최적 입지 TOP 5 추천
+
+**업종**: {category}
+**예산**: {f'{budget_num:,.0f}만원' if budget_num else '미지정'}
+
+---
+
+"""
+        
+        for i, rec in enumerate(recommendations, 1):
+            medal = ['🥇', '🥈', '🥉', '4️⃣', '5️⃣'][i-1]
+            result_text += f"""
+### {medal} {i}위: {rec['district']}
+
+- **종합 점수**: {rec['score']:.1f}점
+- **경쟁 점수**: {rec['competition_score']:.1f}/20
+- **포화도 점수**: {rec['saturation_score']:.1f}/20
+- **총 점포**: {rec['total_stores']:,}개
+- **동종 업종**: {rec['category_stores']}개
+- **평가**: {rec['recommendation']}
+
+---
+"""
+        
+        # 지도 생성
+        map_html = app_state.analyzer.location_recommender.create_recommendation_map(recommendations)
+        
+        # 차트 생성
+        fig = go.Figure(data=[
+            go.Bar(
+                x=[rec['district'] for rec in recommendations],
+                y=[rec['score'] for rec in recommendations],
+                text=[f"{rec['score']:.1f}점" for rec in recommendations],
+                textposition='auto',
+                marker_color=['#2ecc71', '#3498db', '#f39c12', '#e74c3c', '#95a5a6']
+            )
+        ])
+        
+        fig.update_layout(
+            title='지역별 창업 적합도 점수',
+            xaxis_title='지역',
+            yaxis_title='점수',
+            height=400,
+            showlegend=False
+        )
+        
+        return result_text, map_html, fig
+        
+    except Exception as e:
+        return f"❌ 오류: {str(e)}", None, None
+
+
+def analyze_franchise(category, district):
+    """프랜차이즈 분석"""
+    if app_state.analyzer is None:
+        return "❌ 먼저 데이터를 로드해주세요!", None
     
-    return result[:11]
+    try:
+        analysis = app_state.analyzer.franchise_simulator.analyze_franchise_ratio(
+            category, district if district else None
+        )
+        
+        result_text = f"""
+# 🏢 프랜차이즈 vs 개인사업자 분석
+
+**업종**: {category}
+**지역**: {analysis['district']}
+
+---
+
+## 📊 현황
+
+- **총 점포 수**: {analysis['total']:,}개
+- **프랜차이즈**: {analysis['franchise']:,}개 ({analysis['franchise_ratio']:.1f}%)
+- **개인사업자**: {analysis['individual']:,}개 ({100-analysis['franchise_ratio']:.1f}%)
+
+---
+
+## 💡 분석 의견
+
+{analysis['message']}
 
+---
 
-def chat_respond(message, history):
-    """챗봇 응답"""
+## 🎯 전략 제안
+
+"""
+        
+        if analysis['franchise_ratio'] > 70:
+            result_text += """
+- 프랜차이즈 가맹을 고려하세요 (브랜드 인지도 활용)
+- 틈새 시장 공략 (프랜차이즈가 제공하지 못하는 서비스)
+- 지역 밀착형 마케팅 강화
+"""
+        elif analysis['franchise_ratio'] > 50:
+            result_text += """
+- 차별화된 메뉴나 서비스 개발
+- SNS 마케팅 적극 활용
+- 고객 충성도 프로그램 운영
+"""
+        else:
+            result_text += """
+- 개인 브랜드 구축에 집중
+- 합리적인 가격 정책
+- 지역 커뮤니티와의 협력
+"""
+        
+        # 차트 생성
+        fig = app_state.analyzer.franchise_simulator.create_comparison_chart(analysis)
+        
+        return result_text, fig
+        
+    except Exception as e:
+        return f"❌ 오류: {str(e)}", None
+
+
+def chat_respond_stream(message, history):
+    """스트리밍 챗봇 응답"""
     if app_state.analyzer is None:
-        return history + [[message, "❌ 먼저 데이터를 로드해주세요!"]]
+        history.append([message, "❌ 먼저 데이터를 로드해주세요!"])
+        return history
     
     data_context = app_state.analyzer.analyze_for_llm()
     
-    # LLM 프로세서 초기화 (환경변수에서 API 키 자동 로드)
     try:
         if app_state.llm_processor is None:
             app_state.llm_processor = LLMQueryProcessor()
         
+        # 채팅 히스토리 변환
         chat_hist = []
         for user_msg, bot_msg in history:
             chat_hist.append({"role": "user", "content": user_msg})
-            chat_hist.append({"role": "assistant", "content": bot_msg})
+            if bot_msg:  # bot_msg가 None이 아닌 경우만
+                chat_hist.append({"role": "assistant", "content": bot_msg})
+        
+        # 스트리밍 응답
+        history.append([message, ""])
         
-        response = app_state.llm_processor.process_query(message, data_context, chat_hist)
+        for chunk in app_state.llm_processor.process_query_stream(message, data_context, chat_hist):
+            history[-1][1] += chunk
+            yield history
+            time.sleep(0.01)  # 부드러운 스트리밍을 위한 딜레이
         
     except ValueError as e:
-        # API 키가 없는 경우 기본 통계 제공
         response = f"""📊 **기본 데이터 분석 결과**
 
 **전체 현황**
@@ -679,60 +1373,52 @@ def chat_respond(message, history):
 - 업종 종류: {data_context['업종_수']}개
 - 1층 비율: {data_context.get('1층_비율', 'N/A')}
 
-⚠️ **AI 분석 사용 방법**
-환경변수를 설정하세요:
-```bash
-export FIREWORKS_API_KEY="your_api_key_here"
-```
-
-또는 Hugging Face Space에서는 Settings > Variables 에서 설정하세요."""
-    
-    history.append([message, response])
-    return history
+⚠️ **AI 분석 활성화 방법**
+환경변수 설정: `FIREWORKS_API_KEY`
+"""
+        history[-1][1] = response
+        yield history
 
 
 # ============================================================================
 # Gradio UI
 # ============================================================================
 
-with gr.Blocks(title="AI 상권 분석 시스템 Pro", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(title="AI 상권 분석 시스템 Pro Max", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    # 🏪 AI 상권 분석 시스템 Pro
-    *전국 상가(상권) 데이터 기반 실시간 분석 | Powered by Fireworks AI*
+    # 🏪 AI 상권 분석 시스템 Pro Max
+    *전국 상가(상권) 데이터 기반 + AI 창업 컨설팅 | Powered by Qwen3-235B*
     
-    **✨ 10가지 심층 분석 제공**: 업종 트렌드, 경쟁 강도, 입지 분석, 프랜차이즈 비율, 지역 특화, 층별 선호도 등
+    **✨ 프리미엄 기능**: 창업 성공 스코어링 | 반경 경쟁자 분석 | 최적 입지 추천 | 프랜차이즈 비교 | 인터랙티브 지도
     """)
     
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("### ⚙️ 설정")
             
-            # 환경변수 상태 표시
-            api_status = "✅ API 키 설정됨" if os.getenv("FIREWORKS_API_KEY") else "⚠️ API 키 미설정 (기본 통계만 제공)"
+            api_status = "✅ API 키 설정됨" if os.getenv("FIREWORKS_API_KEY") else "⚠️ API 키 미설정"
             gr.Markdown(f"**🔑 API 상태**: {api_status}")
             
             region_select = gr.CheckboxGroup(
                 choices=list(MarketDataLoader.REGIONS.keys()),
                 value=['서울'],
-                label="📍 분석 지역 선택 (최대 5개 권장)"
+                label="📍 분석 지역 선택 (최대 5개)"
             )
             
             load_btn = gr.Button("📊 데이터 로드", variant="primary", size="lg")
-            
             status_box = gr.Markdown("👈 지역을 선택하고 데이터를 로드하세요!")
         
         with gr.Column(scale=3):
             with gr.Tabs() as tabs:
-                with gr.Tab("📊 인사이트 대시보드", id=0) as tab1:
+                # 탭 1: 기본 인사이트
+                with gr.Tab("📊 인사이트", id=0):
                     insights_content = gr.Column(visible=False)
                     
                     with insights_content:
-                        gr.Markdown("### 🗺️ 점포 밀집도 히트맵")
+                        gr.Markdown("### 🗺️ 인터랙티브 히트맵 (클릭하면 좌표 자동 입력)")
                         map_output = gr.HTML()
                         
-                        gr.Markdown("---")
-                        gr.Markdown("### 📈 10가지 심층 상권 인사이트")
-                        
+                        gr.Markdown("### 📈 주요 인사이트")
                         with gr.Row():
                             chart1 = gr.Plot(label="업종별 점포 수")
                             chart2 = gr.Plot(label="대분류 분포")
@@ -740,58 +1426,142 @@ with gr.Blocks(title="AI 상권 분석 시스템 Pro", theme=gr.themes.Soft()) a
                         with gr.Row():
                             chart3 = gr.Plot(label="층별 분포")
                             chart4 = gr.Plot(label="업종 다양성")
+                
+                # 탭 2: 창업 분석 (신규)
+                with gr.Tab("🎯 창업 분석", id=1):
+                    startup_content = gr.Column(visible=False)
+                    
+                    with startup_content:
+                        gr.Markdown("## 🎯 창업 성공 확률 계산기")
                         
                         with gr.Row():
-                            chart5 = gr.Plot(label="프랜차이즈 분석")
-                            chart6 = gr.Plot(label="층 선호도")
+                            with gr.Column():
+                                startup_category = gr.Textbox(label="업종명", placeholder="예: 한식음식점")
+                                startup_district = gr.Textbox(label="지역명", placeholder="예: 강남구")
+                            with gr.Column():
+                                startup_floor = gr.Number(label="희망 층수", value=1)
+                                startup_budget = gr.Number(label="예산 (만원)", value=5000)
+                        
+                        startup_btn = gr.Button("📊 성공 확률 계산", variant="primary")
+                        startup_result = gr.Markdown()
+                        startup_chart = gr.Plot()
+                        
+                        gr.Markdown("---")
+                        gr.Markdown("## 📍 반경 경쟁자 분석")
                         
                         with gr.Row():
-                            chart7 = gr.Plot(label="지역 밀집도")
-                            chart8 = gr.Plot(label="업종 상관관계")
+                            with gr.Column():
+                                radius_lat = gr.Number(label="위도 (지도에서 클릭)", value=37.5665)
+                                radius_lon = gr.Number(label="경도 (지도에서 클릭)", value=126.9780)
+                            with gr.Column():
+                                radius_km = gr.Slider(0.5, 5.0, value=1.0, step=0.5, label="반경 (km)")
+                                radius_category = gr.Textbox(label="업종명 (선택)", placeholder="예: 커피")
+                        
+                        radius_btn = gr.Button("🔍 반경 분석", variant="primary")
+                        radius_result = gr.Markdown()
                         
                         with gr.Row():
-                            chart9 = gr.Plot(label="소분류 트렌드")
-                            chart10 = gr.Plot(label="지역 특화")
+                            radius_map = gr.HTML()
+                            radius_chart = gr.Plot()
+                        
+                        gr.Markdown("---")
+                        gr.Markdown("## 🏆 최적 입지 추천")
+                        
+                        with gr.Row():
+                            with gr.Column():
+                                recommend_category = gr.Textbox(label="업종명", placeholder="예: 카페")
+                                recommend_budget = gr.Number(label="예산 (만원)", value=5000)
+                            with gr.Column():
+                                recommend_regions = gr.CheckboxGroup(
+                                    choices=list(MarketDataLoader.REGIONS.keys()),
+                                    label="선호 지역 (선택)"
+                                )
+                        
+                        recommend_btn = gr.Button("🎯 입지 추천받기", variant="primary")
+                        recommend_result = gr.Markdown()
+                        
+                        with gr.Row():
+                            recommend_map = gr.HTML()
+                            recommend_chart = gr.Plot()
+                        
+                        gr.Markdown("---")
+                        gr.Markdown("## 🏢 프랜차이즈 vs 개인 분석")
+                        
+                        with gr.Row():
+                            franchise_category = gr.Textbox(label="업종명", placeholder="예: 치킨전문점")
+                            franchise_district = gr.Textbox(label="지역명 (선택)", placeholder="예: 송파구")
+                        
+                        franchise_btn = gr.Button("📊 프랜차이즈 분석", variant="primary")
+                        franchise_result = gr.Markdown()
+                        franchise_chart = gr.Plot()
                 
-                with gr.Tab("🤖 AI 분석 챗봇", id=1) as tab2:
+                # 탭 3: AI 챗봇
+                with gr.Tab("🤖 AI 챗봇", id=2):
                     chat_content = gr.Column(visible=False)
                     
                     with chat_content:
                         gr.Markdown("""
                         ### 💡 샘플 질문
-                        강남에서 카페 창업? | 치킨집 포화 지역? | 1층이 유리한 업종? | 프랜차이즈 점유율?
+                        강남에서 카페 창업? | 치킨집 포화 지역? | 1층이 유리한 업종? | 프랜차이즈 vs 개인?
                         """)
                         
-                        chatbot = gr.Chatbot(height=400, label="AI 상권 분석 어시스턴트")
+                        chatbot = gr.Chatbot(height=500, label="AI 상권 분석 어시스턴트 (스트리밍)")
                         
                         with gr.Row():
                             msg_input = gr.Textbox(
-                                placeholder="무엇이든 물어보세요! (예: 강남에서 카페 창업하려면?)",
+                                placeholder="무엇이든 물어보세요!",
                                 show_label=False,
                                 scale=4
                             )
                             submit_btn = gr.Button("전송", variant="primary", scale=1)
                         
-                        # 샘플 버튼들
                         with gr.Row():
                             sample_btn1 = gr.Button("강남에서 카페 창업?", size="sm")
                             sample_btn2 = gr.Button("치킨집 포화 지역?", size="sm")
                             sample_btn3 = gr.Button("1층이 유리한 업종?", size="sm")
-                            sample_btn4 = gr.Button("프랜차이즈 점유율?", size="sm")
+                            sample_btn4 = gr.Button("프랜차이즈 vs 개인?", size="sm")
     
     # 이벤트 핸들러
     load_btn.click(
         fn=load_data,
         inputs=[region_select],
-        outputs=[status_box, insights_content, chat_content, tab1]
+        outputs=[status_box, insights_content, startup_content, chat_content]
     ).then(
         fn=generate_insights,
-        outputs=[map_output, chart1, chart2, chart3, chart4, chart5, chart6, chart7, chart8, chart9, chart10]
+        outputs=[map_output, chart1, chart2, chart3, chart4]
+    )
+    
+    # 창업 분석 이벤트
+    startup_btn.click(
+        fn=calculate_startup_score,
+        inputs=[startup_category, startup_district, startup_floor, startup_budget],
+        outputs=[startup_result, startup_chart]
     )
     
-    # 챗봇 이벤트 (API 키 파라미터 제거)
+    # 반경 분석 이벤트
+    radius_btn.click(
+        fn=analyze_radius,
+        inputs=[radius_lat, radius_lon, radius_km, radius_category],
+        outputs=[radius_result, radius_map, radius_chart]
+    )
+    
+    # 입지 추천 이벤트
+    recommend_btn.click(
+        fn=recommend_locations,
+        inputs=[recommend_category, recommend_budget, recommend_regions],
+        outputs=[recommend_result, recommend_map, recommend_chart]
+    )
+    
+    # 프랜차이즈 분석 이벤트
+    franchise_btn.click(
+        fn=analyze_franchise,
+        inputs=[franchise_category, franchise_district],
+        outputs=[franchise_result, franchise_chart]
+    )
+    
+    # 챗봇 이벤트 (스트리밍)
     submit_btn.click(
-        fn=chat_respond,
+        fn=chat_respond_stream,
         inputs=[msg_input, chatbot],
         outputs=[chatbot]
     ).then(
@@ -800,7 +1570,7 @@ with gr.Blocks(title="AI 상권 분석 시스템 Pro", theme=gr.themes.Soft()) a
     )
     
     msg_input.submit(
-        fn=chat_respond,
+        fn=chat_respond_stream,
         inputs=[msg_input, chatbot],
         outputs=[chatbot]
     ).then(
@@ -809,48 +1579,39 @@ with gr.Blocks(title="AI 상권 분석 시스템 Pro", theme=gr.themes.Soft()) a
     )
     
     # 샘플 버튼 이벤트
-    for btn, text in [
-        (sample_btn1, "강남에서 카페 창업?"),
-        (sample_btn2, "치킨집 포화 지역?"),
-        (sample_btn3, "1층이 유리한 업종?"),
-        (sample_btn4, "프랜차이즈 점유율?")
-    ]:
-        btn.click(
-            fn=lambda t=text, h=chatbot: chat_respond(t, h.value or []),
-            outputs=[chatbot]
-        )
+    sample_btn1.click(lambda: "강남에서 카페 창업하려면 어떤 점을 고려해야 할까요?", outputs=[msg_input])
+    sample_btn2.click(lambda: "치킨집이 포화된 지역은 어디인가요?", outputs=[msg_input])
+    sample_btn3.click(lambda: "1층이 유리한 업종은 무엇인가요?", outputs=[msg_input])
+    sample_btn4.click(lambda: "프랜차이즈와 개인 사업자의 장단점을 비교해주세요.", outputs=[msg_input])
     
     gr.Markdown("""
     ---
-    ### 📖 사용 가이드
-    1. 지역 선택 → 2. 데이터 로드 → 3. 10가지 인사이트 확인 또는 AI에게 질문
-    
-    ### 🔑 AI 챗봇 활성화 방법
-    환경변수 ���정:
-    ```bash
-    export FIREWORKS_API_KEY="your_api_key_here"
-    ```
-    
-    Hugging Face Space에서는:
-    1. Settings 메뉴 클릭
-    2. Variables 탭 선택
-    3. New variable 추가: `FIREWORKS_API_KEY`
-    
-    ### 📊 제공되는 10가지 분석
-    1. **업종별 점포 수**: 가장 많은 업종 TOP 15
-    2. **대분류 분포**: 소매/음식/서비스 등 대분류 비율
-    3. **층별 분포**: 지하/1층/상층 입지 분석
-    4. **업종 다양성**: 지역별 업종 다양성 지수
-    5. **프랜차이즈 분석**: 개인 vs 프랜차이즈 비율
-    6. **층 선호도**: 업종별 선호 층수
-    7. **지역 밀집도**: 점포 수 상위 지역
-    8. **업종 상관관계**: 같이 나타나는 업종 패턴
-    9. **소분류 트렌드**: 세부 업종 분포
-    10. **지역 특화**: 각 지역의 특화 업종
-    
-    💡 **Tip**: API 키 없이도 10가지 시각화 분석과 기본 통계를 확인할 수 있습니다!
+    ### 🎯 프리미엄 기능 가이드
+    
+    **1. 창업 성공 스코어링** 🎯
+    - 업종, 지역, 층수, 예산 입력으로 성공 확률 계산
+    - 5가지 지표 (경쟁강도, 포화도, 입지, 층수, 다양성)
+    
+    **2. 반경 경쟁자 분석** 📍
+    - 지도에서 클릭하여 위치 선택
+    - 반경 0.5~5km 내 경쟁자 현황 분석
+    
+    **3. 최적 입지 추천** 🏆
+    - AI가 최적의 창업 지역 TOP 5 추천
+    - 각 지역별 점수와 장단점 제공
+    
+    **4. 프랜차이즈 vs 개인** 🏢
+    - 업종별 프랜차이즈 비율 분석
+    - 창업 형태 선택을 위한 전략 제안
+    
+    **5. AI 챗봇 (스트리밍)** 🤖
+    - Qwen3-235B 모델 (최대 4096 토큰)
+    - 실시간 스트리밍 응답
+    - 데이터 기반 맞춤형 조언
+    
+    ### 🔑 API 설정
+    환경변수: `export FIREWORKS_API_KEY="your_key"`
     """)
 
-# 실행
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860, share=False)