Upload app.py

app.py

@@ -0,0 +1,1343 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+허깅페이스 배포용 Agentic AI 글로벌 파트너 DB 분석 대시보드
+✅ Gmail SMTP 이메일 발송
+✅ 파스텔톤 차트 색상
+✅ 생태계별 최적화된 대시보드
+✅ jeongkee10@gmission.com 수신
+"""
+
+import os
+import subprocess
+import sys
+import datetime
+import traceback
+import gc
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+import ssl
+import re
+
+# 패키지 설치 함수
+def install_packages():
+    packages = ['gradio>=4.0.0', 'plotly>=5.0.0', 'pandas>=2.0.0', 'openpyxl>=3.0.0']
+    for package in packages:
+        try:
+            pkg_name = package.split('>=')[0]
+            __import__(pkg_name)
+        except ImportError:
+            print(f"Installing {package}...")
+            subprocess.check_call([sys.executable, "-m", "pip", "install", package])
+
+# 패키지 설치 실행
+try:
+    install_packages()
+    print("✅ 패키지 설치 완료")
+except Exception as e:
+    print(f"⚠️ 패키지 설치 오류: {e}")
+
+import pandas as pd
+import gradio as gr
+
+# Gradio 버전 호환성 확인
+try:
+    gradio_version = gr.__version__
+    print(f"✅ Gradio 버전: {gradio_version}")
+except:
+    print("⚠️ Gradio 버전 확인 불가")
+
+try:
+    import plotly.express as px
+    import plotly.graph_objects as go
+    from plotly.subplots import make_subplots
+    PLOTLY_AVAILABLE = True
+    print("✅ Plotly 사용 가능")
+except ImportError:
+    print("⚠️ Plotly 없음 - 차트 기능 제한")
+    PLOTLY_AVAILABLE = False
+
+from typing import Tuple, List, Dict, Any, Optional
+
+# ==================== 설정 및 색상 정의 ====================
+
+# 파스텔톤 색상 팔레트
+PASTEL_COLORS = {
+    'primary_palette': ['#FFB3BA', '#FFDFBA', '#FFFFBA', '#BAFFC9', '#BAE1FF', '#E5BAFF', '#FFBAE5'],
+    'secondary_palette': ['#FFD6D6', '#FFEBD6', '#FFFFD6', '#D6FFE0', '#D6EBFF', '#E0D6FF', '#FFD6EB'],
+    'ecosystem_colors': {
+        'Infra': '#FFB3BA',  # 파스텔 핑크
+        'Foundation Model': '#BAFFC9',  # 파스텔 그린
+        'Platform / Agentic AI Pipeline': '#BAE1FF',  # 파스텔 블루
+        'Application': '#FFDFBA',  # 파스텔 오렌지
+        '전체': '#E5BAFF'  # 파스텔 퍼플
+    },
+    'importance_colors': {
+        5: '#FFB3BA',  # S급 - 파스텔 핑크
+        4: '#FFDFBA',  # A급 - 파스텔 오렌지
+        3: '#BAE1FF',  # B급 - 파스텔 블루
+        2: '#BAFFC9',  # C급 - 파스텔 그린
+        1: '#E5E5E5'   # D급 - 파스텔 그레이
+    }
+}
+
+# 생태계 카테고리
+ECOSYSTEM_CATEGORIES = [
+    "전체",
+    "Infra",
+    "Foundation Model",
+    "Platform / Agentic AI Pipeline",
+    "Application"
+]
+
+# 생태계별 최적화된 컬럼 매핑
+ECOSYSTEM_OPTIMIZED_COLUMNS = {
+    'Infra': {
+        'primary': ['기업명', '중요도', 'HQ_국가', '설립연도', 'PrimaryLLM', 'LLM_Deployment', '주요제품'],
+        'charts': ['중요도_분포', '국가별_분포', '설립연도_분포', 'LLM_배포방식'],
+        'focus': 'infrastructure and deployment capabilities'
+    },
+    'Foundation Model': {
+        'primary': ['기업명', '중요도', 'HQ_국가', 'PrimaryLLM', 'OpenSource여부', 'LLM_Deployment', '창업자'],
+        'charts': ['중요도_분포', 'OpenSource_분포', 'LLM_종류', '국가별_분포'],
+        'focus': 'model development and open-source contributions'
+    },
+    'Platform / Agentic AI Pipeline': {
+        'primary': ['기업명', '중요도', 'Application_Domain', 'PrimaryLLM', 'STT_TTS지원', 'TargetCustomer', 'PricingModel'],
+        'charts': ['중요도_분포', '응용도메인_분포', 'STT_TTS_지원', '타겟고객'],
+        'focus': 'platform integration and agentic workflows'
+    },
+    'Application': {
+        'primary': ['기업명', '중요도', 'Application_Domain', 'TargetCustomer', 'PricingModel', 'KoreaSupport', 'STT_TTS지원'],
+        'charts': ['중요도_분포', '응용도메인_분포', '가격정책', '한국지원'],
+        'focus': 'end-user applications and market solutions'
+    }
+}
+
+# 컬럼 매핑
+EXACT_COLUMN_MAPPING = {
+    '기업명': ['기업명', 'CompanyName', 'company', 'name'],
+    '중요도': ['중요도', 'Importance', 'Priority'],
+    'Ecosystem_Category': ['Ecosystem Category', 'Ecosystem_Category'],
+    'HQ_국가': ['HQ_국가', 'HQ_Country', 'Country'],
+    '설립연도': ['설립연도', 'FoundedYear', 'Founded'],
+    '주요투자자': ['주요투자자', 'KeyInvestors', 'Investors'],
+    '기업개요': ['기업개요', 'CompanySummary', 'Summary'],
+    '웹사이트': ['웹사이트', 'Website', 'WebsiteURL'],
+    '문의URL': ['문의URL', 'ContactURL', 'Contact_URL'],
+    '이메일': ['이메일', 'Email', 'EmailAddress'],
+    '전화번호': ['전화번호', 'PhoneNumber', 'phone'],
+    'HQ_도시': ['HQ_도시', 'HQ_City', 'City'],
+    '창업자': ['창업자', 'Founders', 'founder'],
+    'Application_Domain': ['Application_Domain', 'Application Domain'],
+    'PrimaryLLM': ['PrimaryLLM', 'Primary LLM'],
+    'LLM_Deployment': ['LLM_Deployment', 'LLM Deployment'],
+    'OpenSource여부': ['OpenSource여부', 'OpenSource'],
+    '주요제품': ['주요제품', 'KeyProducts', 'Products'],
+    'STT_TTS지원': ['STT_TTS지원', 'STT_TTS'],
+    'TargetCustomer': ['TargetCustomer', 'Target Customer'],
+    'PricingModel': ['PricingModel', 'Pricing Model'],
+    'KoreaSupport': ['KoreaSupport', 'Korea Support'],
+    'PartnershipProgram': ['PartnershipProgram', 'Partnership Program']
+}
+
+# ==================== Gmail SMTP 이메일 시스템 ====================
+
+class GmailEmailSystem:
+    def __init__(self):
+        self.email_history = []
+        self.smtp_server = "smtp.gmail.com"
+        self.port = 587
+
+        # 허깅페이스 Secrets에서 이메일 정보 가져오기
+        self.gmail_email = os.getenv("GMAIL_EMAIL", "")
+        self.gmail_password = os.getenv("GMAIL_PASSWORD", "")
+        self.recipient_email = os.getenv("RECIPIENT_EMAIL", "jeongkee10@gmission.com")
+
+        print(f"📧 Gmail 설정: {self.gmail_email[:5] if self.gmail_email else '미설정'}***@gmail.com → {self.recipient_email}")
+
+    def validate_email(self, email: str) -> bool:
+        """이메일 주소 유효성 검증"""
+        pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+        return re.match(pattern, email) is not None
+
+    def send_email(self, subject: str, body: str, company_name: str, target_email: str) -> Tuple[bool, str]:
+        """Gmail SMTP를 통한 실제 이메일 발송"""
+        try:
+            if not self.gmail_email or not self.gmail_password:
+                return False, "Gmail 계정 정보가 설정되지 않았습니다. 허깅페이스 Secrets를 확인하세요."
+
+            if not self.validate_email(target_email):
+                return False, f"올바르지 않은 이메일 주소: {target_email}"
+
+            # 이메일 메시지 생성
+            message = MIMEMultipart()
+            message["From"] = self.gmail_email
+            message["To"] = self.recipient_email  # 항상 jeongkee10@gmission.com으로 발송
+            message["Subject"] = f"[파트너십 제안] {subject}"
+
+            # 이메일 본문 (원본 대상과 내용 포함)
+            enhanced_body = f"""
+G-Mission 파트너십 팀에게,
+
+다음 기업에 대한 파트너십 제안서가 대시보드에서 생성되었습니다:
+
+원본 대상 기업: {company_name}
+원본 이메일 주소: {target_email}
+생성 시간: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+=== 파트너십 제안 내용 ===
+
+{body}
+
+=== 다음 단계 ===
+1. 제안 내용 검토
+2. 필요시 내용 수정
+3. {target_email}로 직접 발송
+4. 결과 추적 및 관리
+
+---
+이 이메일은 Agentic AI 파트너 DB 분석 대시보드에서 자동 생성되었습니다.
+"""
+
+            message.attach(MIMEText(enhanced_body, "plain", "utf-8"))
+
+            # Gmail SMTP 서버 연결 및 발송
+            context = ssl.create_default_context()
+            with smtplib.SMTP(self.smtp_server, self.port) as server:
+                server.starttls(context=context)
+                server.login(self.gmail_email, self.gmail_password)
+                server.sendmail(self.gmail_email, self.recipient_email, message.as_string())
+
+            # 발송 기록
+            self.record_email_send(company_name, target_email, subject, body[:100])
+
+            return True, f"✅ 이메일이 {self.recipient_email}로 성공적으로 발송되었습니다!"
+
+        except smtplib.SMTPAuthenticationError:
+            return False, "❌ Gmail 인증 실패. 앱 비밀번호를 확인하세요."
+        except smtplib.SMTPException as e:
+            return False, f"❌ SMTP 오류: {str(e)}"
+        except Exception as e:
+            return False, f"❌ 이메일 발송 실패: {str(e)}"
+
+    def create_partnership_email(self, company_name: str, email: str, ecosystem_category: str,
+                               importance: int = 3, country: str = "", website: str = "") -> Tuple[str, str, str]:
+        """개선된 파트너십 이메일 생성"""
+        try:
+            if not email or '@' not in str(email) or str(email) in ['정보 없음', 'N/A']:
+                return "", "", ""
+
+            # 생태계별 맞춤 제목
+            ecosystem_subjects = {
+                "Infra": f"Infrastructure Partnership Opportunity - {company_name} & G-Mission",
+                "Foundation Model": f"AI Foundation Model Collaboration - {company_name} & G-Mission",
+                "Platform / Agentic AI Pipeline": f"Agentic AI Platform Partnership - {company_name} & G-Mission",
+                "Application": f"AI Application Partnership Proposal - {company_name} & G-Mission"
+            }
+
+            subject = ecosystem_subjects.get(ecosystem_category,
+                                           f"Strategic AI Partnership Proposal - {company_name} & G-Mission")
+
+            # 중요도별 접근 방식
+            importance_approaches = {
+                5: "We have identified your company as a top-tier strategic partner",
+                4: "We have identified your company as a key strategic partner",
+                3: "We have identified your company as a promising strategic partner",
+                2: "We are interested in exploring partnership opportunities",
+                1: "We would like to discuss potential collaboration opportunities"
+            }
+
+            approach = importance_approaches.get(int(importance),
+                                               "We are interested in exploring partnership opportunities")
+
+            # 생태계별 협력 방안
+            ecosystem_focus = {
+                "Infra": """
+INFRASTRUCTURE COLLABORATION FOCUS:
+• AI compute infrastructure optimization and resource sharing
+• Cloud deployment strategies for Korean market
+• Hardware-software integration solutions
+• Scalable AI infrastructure development""",
+
+                "Foundation Model": """
+FOUNDATION MODEL COLLABORATION FOCUS:
+• Korean language model development and fine-tuning
+• Model licensing and technology transfer opportunities
+• Joint research in multilingual AI capabilities
+• Open-source collaboration initiatives""",
+
+                "Platform / Agentic AI Pipeline": """
+PLATFORM INTEGRATION FOCUS:
+• API integration and interoperability solutions
+• Agentic workflow automation partnerships
+• Platform ecosystem development
+• Enterprise AI orchestration solutions""",
+
+                "Application": """
+APPLICATION PARTNERSHIP FOCUS:
+• Market-specific AI application development
+• Customer success case studies and joint marketing
+• Industry-vertical solution partnerships
+• Korean market entry and expansion strategies"""
+            }
+
+            collaboration_details = ecosystem_focus.get(ecosystem_category,
+                                                       "• Strategic technology partnership development")
+
+            current_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+
+            body = f"""Dear {company_name} Partnership Team,
+
+Greetings from G-Mission!
+
+{approach} in the '{ecosystem_category}' space through our comprehensive analysis of 155+ global Agentic AI companies.
+
+{collaboration_details}
+
+KEY PARTNERSHIP OPPORTUNITIES:
+• Technology integration and joint product development
+• Market expansion in Korea and APAC region
+• Strategic alliance in enterprise AI solutions
+• Investment and business development collaboration
+
+ABOUT G-MISSION:
+G-Mission is a leading AI technology company focused on developing innovative solutions for the Korean and APAC markets. We specialize in enterprise AI implementations and strategic partnerships with global technology leaders.
+
+NEXT STEPS:
+We would be delighted to schedule an introductory partnership discussion to explore mutual opportunities. Our team can share detailed market insights, partnership frameworks, and collaboration proposals tailored to your strategic objectives.
+
+Would you be available for a partnership discussion in the coming weeks?
+
+Best regards,
+
+G-Mission Partnership Development Team
+Email: jeongkee10@gmission.com
+Website: https://gmission.com
+
+---
+This partnership proposal was generated through our Agentic AI Global Partner Database Analysis.
+Generated on: {current_time}
+Analysis Confidence: {"High" if importance >= 4 else "Medium" if importance >= 3 else "Standard"}"""
+
+            return subject, body, str(email)
+
+        except Exception as e:
+            print(f"이메일 생성 오류: {e}")
+            return "", "", ""
+
+    def record_email_send(self, company_name: str, email: str, subject: str, body_preview: str) -> bool:
+        """이메일 발송 기록"""
+        try:
+            record = {
+                'timestamp': datetime.datetime.now(),
+                'company_name': str(company_name),
+                'target_email': str(email),
+                'subject': str(subject),
+                'body_preview': str(body_preview),
+                'recipient': self.recipient_email,
+                'status': '발송 완료',
+                'send_date': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            }
+
+            self.email_history.append(record)
+            return True
+        except:
+            return False
+
+    def get_email_history_text(self) -> str:
+        """이메일 발송 이력 반환"""
+        if not self.email_history:
+            return """📧 **이메일 발송 현황**
+
+아직 발송된 이메일이 없습니다.
+
+**사용 방법:**
+1. 기업 분석 실행
+2. 📧 이메일 탭에서 내용 확인/수정
+3. '실제 이메일 발송' 버튼 클릭
+4. 이메일이 jeongkee10@gmission.com으로 발송됩니다"""
+
+        history_text = f"📧 **이메일 발송 현황** (총 {len(self.email_history)}건)\n\n"
+
+        for i, record in enumerate(reversed(self.email_history), 1):
+            history_text += f"""
+**{i}. {record['company_name']}**
+- 발송일시: {record['send_date']}
+- 대상 이메일: {record['target_email']}
+- 실제 수신: {record['recipient']}
+- 제목: {record['subject'][:50]}...
+- 상태: ✅ {record['status']}
+
+---
+"""
+
+        return history_text
+
+# ==================== 데이터 처리 시스템 ====================
+
+class OptimizedDataProcessor:
+    @staticmethod
+    def find_column_mapping(df_columns: List[str]) -> Dict[str, str]:
+        """컬럼 매핑 찾기"""
+        mapping = {}
+        for standard_name, possible_names in EXACT_COLUMN_MAPPING.items():
+            for possible_name in possible_names:
+                if possible_name in df_columns:
+                    mapping[standard_name] = possible_name
+                    break
+        return mapping
+
+    @staticmethod
+    def safe_numeric_conversion(series: pd.Series) -> pd.Series:
+        """안전한 숫자 변환"""
+        try:
+            processed = series.astype(str).copy()
+            processed = processed.replace(['정보 없음', 'nan', 'null', 'NaN', '', 'N/A'], '0')
+            grade_mapping = {'S': '5', 'A': '4', 'B': '3', 'C': '2', 'D': '1'}
+            processed = processed.replace(grade_mapping)
+            processed = processed.str.replace(r'[^\d.]', '', regex=True).replace('', '0')
+            return pd.to_numeric(processed, errors='coerce').fillna(0)
+        except:
+            return pd.Series([0] * len(series))
+
+    @staticmethod
+    def process_data(df: pd.DataFrame) -> pd.DataFrame:
+        """데이터 처리 메인 함수"""
+        try:
+            if df is None or df.empty:
+                return pd.DataFrame()
+
+            column_mapping = OptimizedDataProcessor.find_column_mapping(df.columns.tolist())
+            processed_df = pd.DataFrame()
+
+            for standard_name, original_name in column_mapping.items():
+                if original_name in df.columns:
+                    processed_df[standard_name] = df[original_name].copy()
+
+            # 필수 컬럼 보장
+            if '기업명' not in processed_df.columns:
+                processed_df['기업명'] = df.iloc[:, 1] if len(df.columns) > 1 else [f"기업_{i+1}" for i in range(len(df))]
+
+            if 'Ecosystem_Category' not in processed_df.columns:
+                processed_df['Ecosystem_Category'] = '미분류'
+
+            # 중요도 처리
+            if '중요도' in processed_df.columns:
+                processed_df['중요도'] = OptimizedDataProcessor.safe_numeric_conversion(processed_df['중요도'])
+                processed_df['중요도등급'] = processed_df['중요도'].apply(
+                    lambda x: 'S급 (최우선)' if x == 5 else
+                             'A급 (핵심)' if x == 4 else
+                             'B급 (유망)' if x == 3 else
+                             'C급 (관심)' if x == 2 else
+                             'D급 (참고)' if x == 1 else '미분류'
+                )
+
+            processed_df = processed_df.fillna('정보 없음')
+
+            # 메모리 최적화
+            for col in processed_df.columns:
+                if processed_df[col].dtype == 'object':
+                    processed_df[col] = processed_df[col].astype('category')
+
+            return processed_df
+
+        except Exception as e:
+            print(f"데이터 처리 오류: {e}")
+            return df if df is not None else pd.DataFrame()
+
+# ==================== 파스텔톤 차트 생성 시스템 ====================
+
+class PastelChartGenerator:
+    @staticmethod
+    def create_ecosystem_optimized_charts(df: pd.DataFrame, ecosystem_filter: str = "전체") -> Tuple[Any, Any, Any, Any, str]:
+        """생태계별 최적화된 파스텔톤 차트 생성"""
+        try:
+            if not PLOTLY_AVAILABLE or df is None or df.empty:
+                return None, None, None, None, "데이터가 없거나 Plotly를 사용할 수 없습니다."
+
+            # 데이터 필터링
+            if ecosystem_filter != "전체":
+                filtered_df = df[df['Ecosystem_Category'] == ecosystem_filter].copy()
+                filter_info = f"'{ecosystem_filter}' 생태계"
+            else:
+                filtered_df = df.copy()
+                filter_info = "전체 생태계"
+
+            if filtered_df.empty:
+                return None, None, None, None, f"{ecosystem_filter} 카테고리에 기업이 없습니다."
+
+            # 요약 정보 생성
+            total_companies = len(filtered_df)
+            s_grade = len(filtered_df[filtered_df['중요도'] == 5]) if '중요도' in filtered_df.columns else 0
+            a_grade = len(filtered_df[filtered_df['중요도'] == 4]) if '중요도' in filtered_df.columns else 0
+            countries = filtered_df['HQ_국가'].nunique() if 'HQ_국가' in filtered_df.columns else 0
+
+            # 생태계별 특화 분석
+            ecosystem_focus = ECOSYSTEM_OPTIMIZED_COLUMNS.get(ecosystem_filter, {}).get('focus', 'comprehensive analysis')
+
+            summary_text = f"""### 📊 {filter_info} 분석 요약
+
+**총 기업 수:** {total_companies:,}개
+**S급 최우선 기업:** {s_grade}개
+**A급 핵심 기업:** {a_grade}개
+**참여 국가:** {countries}개국
+
+**분석 포커스:** {ecosystem_focus}
+**전략적 기회:** {s_grade + a_grade}개 핵심 기업이 전체의 {((s_grade + a_grade) / total_companies * 100):.1f}%"""
+
+            # 1. 생태계별 파스텔톤 분포 차트
+            if ecosystem_filter == "전체":
+                ecosystem_counts = filtered_df['Ecosystem_Category'].value_counts()
+                ecosystem_colors = [PASTEL_COLORS['ecosystem_colors'].get(eco, PASTEL_COLORS['primary_palette'][i % 7])
+                                  for i, eco in enumerate(ecosystem_counts.index)]
+
+                fig1 = px.pie(
+                    values=ecosystem_counts.values,
+                    names=ecosystem_counts.index,
+                    title=f"🏗️ 생태계별 기업 분포 (총 {total_companies}개)",
+                    color_discrete_sequence=ecosystem_colors
+                )
+                fig1.update_traces(textposition='inside', textinfo='percent+label',
+                                 textfont=dict(size=12, color='white'))
+            else:
+                fig1 = go.Figure(data=[go.Pie(
+                    labels=[ecosystem_filter],
+                    values=[total_companies],
+                    marker_colors=[PASTEL_COLORS['ecosystem_colors'].get(ecosystem_filter, '#E5BAFF')],
+                    textinfo='value+label',
+                    textfont=dict(size=14, color='white')
+                )])
+                fig1.update_layout(title=f"🏗️ {ecosystem_filter} 생태계 ({total_companies}개 기업)")
+
+            fig1.update_layout(
+                font=dict(size=14),
+                plot_bgcolor='rgba(0,0,0,0)',
+                paper_bgcolor='rgba(0,0,0,0)',
+                height=400
+            )
+
+            # 2. 중요도별 파스텔톤 분포 차트
+            if '중요도' in filtered_df.columns:
+                importance_counts = filtered_df['중요도'].value_counts().sort_index(ascending=False)
+                grade_names = {5: 'S급', 4: 'A급', 3: 'B급', 2: 'C급', 1: 'D급'}
+
+                if not importance_counts.empty:
+                    x_labels = [grade_names.get(grade, f'{grade}급') for grade in importance_counts.index]
+                    y_values = importance_counts.values
+                    bar_colors = [PASTEL_COLORS['importance_colors'].get(grade, '#E5E5E5')
+                                for grade in importance_counts.index]
+
+                    fig2 = go.Figure(data=[
+                        go.Bar(x=x_labels, y=y_values,
+                              marker_color=bar_colors,
+                              text=y_values, textposition='auto',
+                              textfont=dict(size=12, color='black'))
+                    ])
+                    fig2.update_layout(
+                        title=f"⭐ {filter_info} 중요도별 분포",
+                        xaxis_title="중요도 등급",
+                        yaxis_title="기업 수",
+                        font=dict(size=14),
+                        plot_bgcolor='rgba(0,0,0,0)',
+                        paper_bgcolor='rgba(0,0,0,0)',
+                        height=400
+                    )
+                else:
+                    fig2 = go.Figure()
+            else:
+                fig2 = go.Figure()
+
+            # 3. 생태계별 최적화된 추가 차트
+            fig3 = PastelChartGenerator.create_ecosystem_specific_chart(filtered_df, ecosystem_filter)
+
+            # 4. 생태계별 상세 분석 차트
+            fig4 = PastelChartGenerator.create_detailed_analysis_chart(filtered_df, ecosystem_filter)
+
+            return fig1, fig2, fig3, fig4, summary_text
+
+        except Exception as e:
+            print(f"차트 생성 오류: {e}")
+            return None, None, None, None, f"차트 생성 중 오류: {str(e)}"
+
+    @staticmethod
+    def create_ecosystem_specific_chart(df: pd.DataFrame, ecosystem_filter: str) -> Any:
+        """생태계별 특화 차트 생성"""
+        try:
+            if ecosystem_filter == "Infra":
+                # 인프라: LLM 배포 방식 분포
+                if 'LLM_Deployment' in df.columns:
+                    deployment_counts = df['LLM_Deployment'].value_counts().head(8)
+                    if not deployment_counts.empty:
+                        fig = px.bar(
+                            x=deployment_counts.index,
+                            y=deployment_counts.values,
+                            title="🚀 LLM 배포 방식 분포",
+                            color_discrete_sequence=PASTEL_COLORS['primary_palette']
+                        )
+                        fig.update_layout(xaxis_title="배포 방식", yaxis_title="기업 수")
+                        return fig
+
+            elif ecosystem_filter == "Foundation Model":
+                # 파운데이션 모���: 오픈소스 여부 분포
+                if 'OpenSource여부' in df.columns:
+                    opensource_counts = df['OpenSource여부'].value_counts()
+                    if not opensource_counts.empty:
+                        fig = px.pie(
+                            values=opensource_counts.values,
+                            names=opensource_counts.index,
+                            title="🔓 오픈소스 여부 분포",
+                            color_discrete_sequence=PASTEL_COLORS['secondary_palette']
+                        )
+                        return fig
+
+            elif ecosystem_filter == "Platform / Agentic AI Pipeline":
+                # 플랫폼: 응용 도메인 분포
+                if 'Application_Domain' in df.columns:
+                    domain_counts = df['Application_Domain'].value_counts().head(10)
+                    if not domain_counts.empty:
+                        fig = px.bar(
+                            x=domain_counts.values,
+                            y=domain_counts.index,
+                            orientation='h',
+                            title="🎯 응용 도메인별 분포",
+                            color_discrete_sequence=PASTEL_COLORS['primary_palette']
+                        )
+                        fig.update_layout(xaxis_title="기업 수", yaxis_title="응용 도메인")
+                        return fig
+
+            elif ecosystem_filter == "Application":
+                # 애플리케이션: 타겟 고객 분포
+                if 'TargetCustomer' in df.columns:
+                    customer_counts = df['TargetCustomer'].value_counts().head(8)
+                    if not customer_counts.empty:
+                        fig = px.bar(
+                            x=customer_counts.index,
+                            y=customer_counts.values,
+                            title="👥 타겟 고객별 분포",
+                            color_discrete_sequence=PASTEL_COLORS['primary_palette']
+                        )
+                        fig.update_layout(xaxis_title="타겟 고객", yaxis_title="기업 수")
+                        return fig
+
+            else:
+                # 전체: 국가별 분포
+                if 'HQ_국가' in df.columns:
+                    country_counts = df['HQ_국가'].value_counts().head(10)
+                    if not country_counts.empty:
+                        fig = px.bar(
+                            x=country_counts.values,
+                            y=country_counts.index,
+                            orientation='h',
+                            title="🌍 주요 국가별 기업 수",
+                            color_discrete_sequence=PASTEL_COLORS['primary_palette']
+                        )
+                        fig.update_layout(xaxis_title="기업 수", yaxis_title="국가")
+                        return fig
+
+            return go.Figure()
+
+        except Exception as e:
+            print(f"생태계별 차트 생성 오류: {e}")
+            return go.Figure()
+
+    @staticmethod
+    def create_detailed_analysis_chart(df: pd.DataFrame, ecosystem_filter: str) -> Any:
+        """상세 분석 차트 생성"""
+        try:
+            if ecosystem_filter == "Infra":
+                # 인프라: 설립연도별 분포
+                if '설립연도' in df.columns:
+                    years = df['설립연도'][df['설립연도'] > 0]
+                    if not years.empty:
+                        fig = px.histogram(
+                            x=years,
+                            nbins=20,
+                            title="📅 설립연도별 분포",
+                            color_discrete_sequence=[PASTEL_COLORS['ecosystem_colors']['Infra']]
+                        )
+                        fig.update_layout(xaxis_title="설립연도", yaxis_title="기업 수")
+                        return fig
+
+            elif ecosystem_filter == "Foundation Model":
+                # 파운데이션 모델: PrimaryLLM 분포
+                if 'PrimaryLLM' in df.columns:
+                    llm_counts = df['PrimaryLLM'].value_counts().head(8)
+                    if not llm_counts.empty:
+                        fig = px.bar(
+                            x=llm_counts.index,
+                            y=llm_counts.values,
+                            title="🤖 주요 LLM 모델 분포",
+                            color_discrete_sequence=PASTEL_COLORS['primary_palette']
+                        )
+                        fig.update_layout(xaxis_title="LLM 모델", yaxis_title="기업 수")
+                        return fig
+
+            elif ecosystem_filter == "Platform / Agentic AI Pipeline":
+                # 플랫폼: STT/TTS 지원 현황
+                if 'STT_TTS지원' in df.columns:
+                    stt_counts = df['STT_TTS지원'].value_counts()
+                    if not stt_counts.empty:
+                        fig = px.pie(
+                            values=stt_counts.values,
+                            names=stt_counts.index,
+                            title="🎤 STT/TTS 지원 현황",
+                            color_discrete_sequence=PASTEL_COLORS['secondary_palette']
+                        )
+                        return fig
+
+            elif ecosystem_filter == "Application":
+                # 애플리케이션: 한국 지원 현황
+                if 'KoreaSupport' in df.columns:
+                    korea_counts = df['KoreaSupport'].value_counts()
+                    if not korea_counts.empty:
+                        fig = px.pie(
+                            values=korea_counts.values,
+                            names=korea_counts.index,
+                            title="🇰🇷 한국 시장 지원 현황",
+                            color_discrete_sequence=PASTEL_COLORS['primary_palette']
+                        )
+                        return fig
+
+            else:
+                # 전체: 중요도와 설립연도 상관관계
+                if '중요도' in df.columns and '설립연도' in df.columns:
+                    valid_data = df[(df['중요도'] > 0) & (df['설립연도'] > 0)]
+                    if not valid_data.empty:
+                        fig = px.scatter(
+                            valid_data,
+                            x='설립연도',
+                            y='중요도',
+                            size=[10] * len(valid_data),
+                            title="📊 설립연도 vs 중요도 분포",
+                            color_discrete_sequence=[PASTEL_COLORS['ecosystem_colors']['전체']]
+                        )
+                        fig.update_layout(xaxis_title="설립연도", yaxis_title="중요도")
+                        return fig
+
+            return go.Figure()
+
+        except Exception as e:
+            print(f"상세 분석 차트 생성 오류: {e}")
+            return go.Figure()
+
+# ==================== 기업 분석 시스템 ====================
+
+def analyze_company_comprehensive(df: pd.DataFrame, company_name: str, email_system: GmailEmailSystem) -> Tuple[str, str, str, str]:
+    """종합적인 기업 분석 (생태계별 최적화)"""
+    try:
+        if df is None or df.empty or not company_name:
+            return "기업을 선택해주세요.", "", "", ""
+
+        # 기업 데이터 찾기
+        company_data = df[df['기업명'] == company_name]
+        if company_data.empty:
+            return f"'{company_name}' 기업을 찾을 수 없습니다.", "", "", ""
+
+        data = company_data.iloc[0]
+
+        def safe_get(field, default='정보 없음'):
+            value = data.get(field, default)
+            if pd.isna(value) or str(value).strip() in ['', 'nan', 'NaN', 'N/A']:
+                return default
+            return str(value)
+
+        # 기업 정보 추출
+        company_name_clean = safe_get('기업명')
+        ecosystem_cat = safe_get('Ecosystem_Category')
+        importance = safe_get('중요도', 0)
+        importance_grade = safe_get('중요도등급', '미분류')
+        email_address = safe_get('이메일')
+        country = safe_get('HQ_국가')
+        website = safe_get('웹사이트')
+
+        # 생태계별 최적화된 분석
+        optimized_info = ECOSYSTEM_OPTIMIZED_COLUMNS.get(ecosystem_cat, {})
+        primary_columns = optimized_info.get('primary', [])
+        focus_area = optimized_info.get('focus', 'comprehensive business analysis')
+
+        # 액션 추천
+        action_recommendations = {
+            5: "🚀 **최우선 협력 추진** - S급 전략적 파트너로 즉시 파트너십 개시",
+            4: "🎯 **핵심 파트너십 개발** - A급 중요 기업으로 상세 협력 방안 수립",
+            3: "🤝 **전술적 협력 검토** - B급 유망 파트너로 단계적 접근",
+            2: "👀 **시장 동향 모니터링** - C급 관심 기업으로 지속 관찰",
+            1: "📋 **정보 수집 및 분석** - D급 참고 기업으로 기본 정보 축적"
+        }
+
+        try:
+            importance_num = float(importance)
+            action_recommendation = action_recommendations.get(int(importance_num), "📋 **기본 정보 수집**")
+        except:
+            action_recommendation = "📋 **기본 정보 수집**"
+
+        # 생태계별 상세 분석 생성
+        ecosystem_analysis = generate_ecosystem_specific_analysis(data, ecosystem_cat, primary_columns)
+
+        # 최종 분석 결과
+        analysis = f"""# 🏢 {company_name_clean} 종합 분석
+
+## ✅ 생태계별 최적화 분석 완료!
+
+## ⭐ 전략적 평가
+- **전략적 중요도:** {importance}/5점 ({importance_grade})
+- **생태계 분류:** {ecosystem_cat}
+- **분석 포커스:** {focus_area}
+- **권장 액션:** {action_recommendation}
+
+---
+
+## 📍 기업 기본 정보
+- **본사 위치:** {country} - {safe_get('HQ_도시')}
+- **설립 연도:** {safe_get('설립연도')}
+- **창업자:** {safe_get('창업자')}
+- **주요 투자자:** {safe_get('주요투자자')}
+
+## 🎯 기업 개요
+{safe_get('기업개요')}
+
+{ecosystem_analysis}
+
+## 🔗 연락처 및 웹 정보
+- **공식 웹사이트:** {website}
+- **문의 페이지:** {safe_get('문의URL')}
+- **이메일:** {email_address}
+- **전화번호:** {safe_get('전화번호')}
+
+---
+
+## 💡 맞춤형 파트너십 전략
+
+{generate_partnership_strategy(ecosystem_cat, int(importance) if str(importance).isdigit() else 3)}
+
+---
+
+**✨ 이메일 탭으로 이동하면 자동 생성된 맞춤형 파트너십 이메일을 확인할 수 있습니다!**
+**📧 '실제 이메일 발송' 버튼으로 jeongkee10@gmission.com에 이메일을 발송할 수 있습니다.**"""
+
+        # 이메일 자동 생성
+        if email_address != '정보 없음' and '@' in email_address:
+            subject, body, recipient = email_system.create_partnership_email(
+                company_name_clean, email_address, ecosystem_cat, int(importance) if str(importance).isdigit() else 3, country, website
+            )
+            return analysis, subject, body, recipient
+        else:
+            return analysis, "", "", ""
+
+    except Exception as e:
+        error_msg = f"기업 분석 오류: {str(e)}"
+        print(error_msg)
+        return error_msg, "", "", ""
+
+def generate_ecosystem_specific_analysis(data, ecosystem_cat: str, primary_columns: List[str]) -> str:
+    """생태계별 특화 분석 생성"""
+    def safe_get(field, default='정보 없음'):
+        value = data.get(field, default)
+        if pd.isna(value) or str(value).strip() in ['', 'nan', 'NaN', 'N/A']:
+            return default
+        return str(value)
+
+    if ecosystem_cat == "Infra":
+        return f"""
+## 🏗️ 인프라 생태계 전문 분석
+- **주요 LLM:** {safe_get('PrimaryLLM')}
+- **배포 방식:** {safe_get('LLM_Deployment')}
+- **주요 제품/서비스:** {safe_get('주요제품')}
+- **파트너십 프로그램:** {safe_get('PartnershipProgram')}
+
+**인프라 특화 협력 방안:**
+• GPU/클라우드 리소스 공동 활용 및 최적화
+• AI 워크로드 배포 및 스케일링 기술 협력
+• 한국 데이터센터 및 엣지 컴퓨팅 구축
+• 고성능 AI 인프라 공동 개발"""
+
+    elif ecosystem_cat == "Foundation Model":
+        return f"""
+## 🤖 파운데이션 모델 생태계 전문 분석
+- **주요 LLM:** {safe_get('PrimaryLLM')}
+- **오픈소스 여부:** {safe_get('OpenSource여부')}
+- **배포 방식:** {safe_get('LLM_Deployment')}
+- **타겟 고객:** {safe_get('TargetCustomer')}
+
+**파운데이션 모델 특화 협력 방안:**
+• 한국어 특화 모델 공동 개발 및 Fine-tuning
+• 모델 라이센싱 및 기술 이전 협력
+• 멀티모달 AI 모델 공동 연구
+• 오픈소스 생태계 기여 및 협력"""
+
+    elif ecosystem_cat == "Platform / Agentic AI Pipeline":
+        return f"""
+## 🔗 플랫폼/에이전틱 AI 파이프라인 전문 분석
+- **응용 도메인:** {safe_get('Application_Domain')}
+- **STT/TTS 지원:** {safe_get('STT_TTS지원')}
+- **타겟 고객:** {safe_get('TargetCustomer')}
+- **가격 정책:** {safe_get('PricingModel')}
+
+**플랫폼 특화 협력 방안:**
+• API 연동 및 상호 운용성 확보
+• 에이전틱 워크플로우 자동화 플랫폼 구축
+• 엔터프라이즈 AI 오케스트레이션 솔루션
+• 통합 플랫폼 생태계 공동 개발"""
+
+    elif ecosystem_cat == "Application":
+        return f"""
+## 📱 애플리케이션 생태계 전문 분석
+- **응용 도메인:** {safe_get('Application_Domain')}
+- **타겟 고객:** {safe_get('TargetCustomer')}
+- **가격 정책:** {safe_get('PricingModel')}
+- **한국 지원:** {safe_get('KoreaSupport')}
+
+**애플리케이션 특화 협력 방안:**
+• 산업별 맞춤형 AI 솔루션 공동 개발
+• 한국 시장 진출 및 현지화 협력
+• B2B/B2C 고객 사례 공유 및 공동 마케팅
+• 실제 비즈니스 적용 사례 구축"""
+
+    else:
+        return f"""
+## 🔍 종합 기술 분석
+- **주요 기술:** {safe_get('주요제품')}
+- **응용 분야:** {safe_get('Application_Domain')}
+- **시장 접근:** {safe_get('TargetCustomer')}
+
+**종합 협력 방안:**
+• 기술 통합 및 공동 개발
+• 시장 확장 전략 협력
+• 혁신 생태계 구축"""
+
+def generate_partnership_strategy(ecosystem_cat: str, importance: int) -> str:
+    """파트너십 전략 생성"""
+    strategies = {
+        "Infra": """
+**인프라 파트너십 전략:**
+1. **기술 협력**: 클라우드 인프라 공동 구축 및 최적화
+2. **시장 진출**: 한국/APAC 데이터센터 확장 협력
+3. **투자 협력**: 인프라 투자 펀드 공동 조성
+4. **표준화**: AI 인프라 표준 개발 공동 참여""",
+
+        "Foundation Model": """
+**파운데이션 모델 파트너십 전략:**
+1. **기술 협력**: 한국어 LLM 공동 개발 및 최적화
+2. **라이센싱**: 모델 기술 이전 및 라이센싱 협력
+3. **연구 협력**: 공동 연구소 설립 및 인재 교류
+4. **생태계**: 오��소스 기여 및 커뮤니티 구축""",
+
+        "Platform / Agentic AI Pipeline": """
+**플랫폼 파트너십 전략:**
+1. **통합 협력**: API 상호 연동 및 플랫폼 통합
+2. **솔루션**: 엔터프라이즈 AI 솔루션 공동 개발
+3. **마케팅**: 공동 고객 확보 및 시장 개척
+4. **표준화**: 에이전틱 AI 표준 및 프로토콜 개발""",
+
+        "Application": """
+**애플리케이션 파트너십 전략:**
+1. **현지화**: 한국 시장 맞춤형 애플리케이션 개발
+2. **고객 확보**: 공동 세일즈 및 마케팅 협력
+3. **사례 구축**: 성공 사례 공동 개발 및 홍보
+4. **투자**: 후속 투자 및 사업 확장 협력"""
+    }
+
+    base_strategy = strategies.get(ecosystem_cat, "**종합 파트너십 전략:** 기술, 시장, 투자 전방위 협력")
+
+    if importance >= 4:
+        priority = "\n\n**🚀 최우선 추진 권장:** 즉시 파트너십 개시 및 전담팀 구성"
+    elif importance >= 3:
+        priority = "\n\n**🎯 중점 검토 권장:** 단계별 협력 방안 수립 및 파일럿 프로젝트 진행"
+    else:
+        priority = "\n\n**👀 지속 모니터링:** 시장 동향 관찰 및 기회 발굴"
+
+    return base_strategy + priority
+
+# ==================== 파일 처리 ====================
+
+def process_uploaded_file(file):
+    """파일 업로드 처리"""
+    if file is None:
+        return None, "파일을 업로드해주세요."
+
+    try:
+        file_path = file.name if hasattr(file, 'name') else str(file)
+
+        if file_path.endswith('.csv'):
+            df = pd.read_csv(file_path, encoding='utf-8-sig')
+        elif file_path.endswith(('.xlsx', '.xls')):
+            df = pd.read_excel(file_path)
+        else:
+            return None, "CSV 또는 Excel 파일을 업로드해주세요."
+
+        if df.empty:
+            return None, "빈 파일입니다."
+
+        processed_df = OptimizedDataProcessor.process_data(df)
+        success_msg = f"✅ 파일 처리 완료!\n- 총 기업 수: {len(processed_df):,}개\n- 컬럼 수: {len(processed_df.columns)}개"
+
+        # 메모리 최적화
+        del df
+        gc.collect()
+
+        return processed_df, success_msg
+
+    except Exception as e:
+        return None, f"파일 처리 오류: {str(e)}"
+
+# ==================== 메인 대시보드 ====================
+
+def create_huggingface_dashboard():
+    """허깅페이스 배포용 메인 대시보드"""
+
+    # Gmail 이메일 시스템 초기화
+    email_system = GmailEmailSystem()
+
+    # 커스텀 CSS
+    custom_css = """
+    .gradio-container {
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif !important;
+        max-width: 1400px !important;
+        margin: 0 auto !important;
+    }
+    .ecosystem-card {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        border-radius: 10px;
+        padding: 20px;
+        margin: 10px;
+        color: white;
+    }
+    .pastel-btn {
+        background: linear-gradient(135deg, #FFB3BA 0%, #FFDFBA 100%);
+        border: none;
+        border-radius: 8px;
+        color: #333;
+        font-weight: bold;
+    }
+    """
+
+    with gr.Blocks(
+        theme=gr.themes.Soft(primary_hue="blue", secondary_hue="cyan"),
+        title="G-Mission Agentic AI Partner Database",
+        css=custom_css
+    ) as demo:
+
+        # 헤더
+        gr.Markdown("""
+        # 🚀 G-Mission Agentic AI 글로벌 파트너 DB 분석 대시보드
+
+        ### ✅ 허깅페이스 배포 완료 | ✅ Gmail SMTP 이메일 | ✅ 파스텔톤 차트 | ✅ 생태계별 최적화
+
+        **155개 글로벌 Agentic AI 기업 완벽 분석** | **실시간 파트너십 이메일 발송**
+
+        **주요 기능:**
+        - 🎨 **파스텔톤 시각화**: 생태계별 맞춤 색상으로 직관적 분석
+        - 🏗️ **생태계별 최적화**: Infra, Foundation Model, Platform, Application 특화 분석
+        - 📧 **Gmail SMTP 연동**: jeongkee10@gmission.com으로 실시간 이메일 발송
+        - 🎯 **맞춤형 파트너십**: 기업별/생태계별 최적화된 협력 제안
+        """)
+
+        # 상태 변수
+        df_state = gr.State(value=None)
+
+        # 파일 업로드
+        with gr.Row():
+            with gr.Column():
+                file_upload = gr.File(
+                    label="📁 Agentic AI 기업 데이터베이스 업로드",
+                    file_types=['.csv', '.xlsx', '.xls'],
+                    file_count="single"
+                )
+                upload_status = gr.Markdown("📋 **현재 상태:** 파일을 업로드해주세요.")
+
+        # 메인 탭
+        with gr.Tabs():
+            # 탭 1: 파스텔톤 시장 분석
+            with gr.TabItem("🎨 파스텔톤 시장 분석"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        market_ecosystem_filter = gr.Dropdown(
+                            choices=ECOSYSTEM_CATEGORIES,
+                            value="전체",
+                            label="🏗️ 생태계 필터",
+                            info="특정 생태계 선택 시 해당 영역에 최적화된 분석 제공"
+                        )
+                        market_analysis_btn = gr.Button(
+                            "🎨 파스텔톤 분석 실행",
+                            variant="primary",
+                            size="lg"
+                        )
+
+                        market_summary = gr.Markdown(
+                            "생태계를 선택하고 분석을 실행하면 맞춤형 요약이 표시됩니다.",
+                            label="📊 분석 요약"
+                        )
+
+                with gr.Row():
+                    with gr.Column():
+                        chart1 = gr.Plot(label="🏗️ 생태계별 분포")
+                    with gr.Column():
+                        chart2 = gr.Plot(label="⭐ 중요도별 분포")
+
+                with gr.Row():
+                    with gr.Column():
+                        chart3 = gr.Plot(label="🎯 생태계별 특화 분석")
+                    with gr.Column():
+                        chart4 = gr.Plot(label="📊 상세 분석")
+
+            # 탭 2: 생태계별 최적화 기업 분석
+            with gr.TabItem("🏢 생태계별 최적화 기업 분석"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        ecosystem_filter_company = gr.Dropdown(
+                            choices=ECOSYSTEM_CATEGORIES,
+                            value="전체",
+                            label="🏗️ 생태계별 필터링",
+                            info="각 생태계에 최적화된 컬럼과 분석 제공"
+                        )
+
+                        company_dropdown = gr.Dropdown(
+                            choices=[],
+                            label="🏢 기업 선택",
+                            info="생태계별 필터링 후 기업 선택"
+                        )
+
+                        analyze_company_btn = gr.Button(
+                            "🔍 생태계별 최적화 분석 실행",
+                            variant="primary",
+                            size="lg"
+                        )
+
+                        # 생태계별 정보 표시
+                        ecosystem_info = gr.Markdown(
+                            """### 🏗️ 생태계별 최적화 정보
+
+**Infra**: LLM 배포, 인프라 기술, 파트너십 프로그램
+**Foundation Model**: LLM 모델, 오픈소스, 기술 이전
+**Platform**: 응용도메인, STT/TTS, 타겟고객, 가격정책
+**Application**: 타겟고객, 가격정책, 한국지원, 애플리케이션""",
+                            label="생태계별 특화 정보"
+                        )
+
+                    with gr.Column(scale=2):
+                        company_analysis = gr.Markdown(
+                            """# 🏢 생태계별 최적화 기업 분석
+
+생태계를 선택하고 기업을 선택한 후 분석을 실행하면:
+
+**🎯 생태계별 특화 분석:**
+- **Infra**: 인프라 기술, 배포 방식, 파트너십 중심 분석
+- **Foundation Model**: LLM 모델, 오픈소스, 기술력 중심 분석
+- **Platform**: 플랫폼 통합, API, 에이전틱 파이프라인 중심 분석
+- **Application**: 실제 응용, 시장 접근, 고객 중심 분석
+
+**✨ 각 생태계에 최적화된 맞춤형 파트너십 전략이 제공됩니다!**""",
+                            label="기업 상세 분석"
+                        )
+
+            # 탭 3: Gmail SMTP 이메일 시스템
+            with gr.TabItem("📧 Gmail SMTP 이메일"):
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("""## 📧 Gmail SMTP 이메일 시스템
+
+**설정 상태:**
+- 📧 Gmail 계정: 허깅페이스 Secrets에서 로드
+- 🎯 수신 이메일: jeongkee10@gmission.com (고정)
+- 🔐 보안: Gmail 앱 비밀번호 사용
+
+**사용 방법:**
+1. 기업 분석 실행 → 이메일 자동 생성
+2. 아래에서 이메일 내용 확인/수정
+3. '실제 이메일 발송' 버튼 클릭
+4. jeongkee10@gmission.com으로 이메일 발송됨""")
+
+                        # 이메일 필드들
+                        email_recipient = gr.Textbox(
+                            label="📧 대상 기업 이메일 (참조용)",
+                            placeholder="기업 분석 후 자동 입력됩니다",
+                            interactive=True
+                        )
+
+                        email_subject = gr.Textbox(
+                            label="📧 이메일 제목 (수정 가능)",
+                            placeholder="기업 분석 후 자동 생성됩니다",
+                            interactive=True
+                        )
+
+                        email_body = gr.Textbox(
+                            label="📧 이메일 내용 (수정 가능)",
+                            lines=15,
+                            placeholder="기업 분석 후 생태계별 맞춤형 이메일이 자동 생성됩니다",
+                            interactive=True
+                        )
+
+                        # 실제 이메일 발송 버튼
+                        real_email_send_btn = gr.Button(
+                            "📧 실제 Gmail로 이메일 발송 (→ jeongkee10@gmission.com)",
+                            variant="primary",
+                            size="lg"
+                        )
+
+                        email_send_status = gr.Markdown(
+                            """### 📧 이메일 발송 안내
+
+기업 분석을 실행하면 해당 기업에 맞는 맞춤형 파트너십 이메일이 자동 생성됩니다.
+내용을 확인/수정한 후 '실제 Gmail로 이메일 발송' 버튼을 클릭하면
+**jeongkee10@gmission.com**으로 이메일이 발송됩니다.
+
+**발송되는 이메일에는:**
+- 원본 대상 기업 정보
+- 파트너십 제안 내용
+- 다음 단계 가이드
+- 대시보드 링크가 포함됩니다.""",
+                            label="발송 상태"
+                        )
+
+            # 탭 4: 이메일 발송 현황
+            with gr.TabItem("📧 이메일 발송 현황"):
+                with gr.Column():
+                    refresh_email_btn = gr.Button(
+                        "🔄 발송 현황 새로고침",
+                        variant="primary"
+                    )
+
+                    email_history_display = gr.Markdown(
+                        email_system.get_email_history_text(),
+                        label="📧 이메일 발송 이력"
+                    )
+
+        # ==================== 이벤트 핸들러 ====================
+
+        # 1. 파일 업로드
+        def handle_file_upload(file):
+            try:
+                df, status = process_uploaded_file(file)
+                if df is not None:
+                    company_names = sorted(df['기업명'].unique().tolist())
+                    return (
+                        df,
+                        status,
+                        gr.update(choices=company_names, value=None)
+                    )
+                else:
+                    return None, status, gr.update(choices=[], value=None)
+            except Exception as e:
+                return None, f"파일 업로드 오류: {str(e)}", gr.update(choices=[], value=None)
+
+        file_upload.upload(
+            fn=handle_file_upload,
+            inputs=[file_upload],
+            outputs=[df_state, upload_status, company_dropdown]
+        )
+
+        # 2. 파스텔톤 시장 분석
+        def handle_market_analysis(df, ecosystem_filter):
+            try:
+                if df is None or df.empty:
+                    return None, None, None, None, "데이터 파일을 업로드해주세요."
+
+                return PastelChartGenerator.create_ecosystem_optimized_charts(df, ecosystem_filter)
+            except Exception as e:
+                return None, None, None, None, f"시장 분석 오류: {str(e)}"
+
+        market_analysis_btn.click(
+            fn=handle_market_analysis,
+            inputs=[df_state, market_ecosystem_filter],
+            outputs=[chart1, chart2, chart3, chart4, market_summary]
+        )
+
+        # 3. 생태계별 기업 필터링
+        def update_company_dropdown(df, ecosystem_filter):
+            try:
+                if df is None or df.empty:
+                    return gr.update(choices=[])
+
+                if ecosystem_filter != "전체":
+                    filtered_df = df[df['Ecosystem_Category'] == ecosystem_filter]
+                else:
+                    filtered_df = df
+
+                company_names = sorted(filtered_df['기업명'].unique().tolist())
+                return gr.update(choices=company_names, value=None)
+            except Exception as e:
+                return gr.update(choices=[])
+
+        ecosystem_filter_company.change(
+            fn=update_company_dropdown,
+            inputs=[df_state, ecosystem_filter_company],
+            outputs=[company_dropdown]
+        )
+
+        # 4. 🔥 핵심: 생태계별 최적화 기업 분석 + 이메일 자동 생성
+        analyze_company_btn.click(
+            fn=lambda df, company: analyze_company_comprehensive(df, company, email_system),
+            inputs=[df_state, company_dropdown],
+            outputs=[
+                company_analysis,    # 기업 분석 결과
+                email_subject,       # 이메일 제목 자동 입력
+                email_body,          # 이메일 내용 자동 입력
+                email_recipient      # 받는 사람 자동 입력
+            ]
+        )
+
+        # 5. 실제 Gmail 이메일 발송
+        def handle_real_email_send(recipient, subject, body):
+            try:
+                if not recipient or '@' not in recipient:
+                    return "올바른 대상 기업 이메일 주소가 필요합니다."
+
+                if not subject or not body:
+                    return "이메일 제목과 내용을 입력해주세요."
+
+                # 회사명 추출
+                company_name = recipient.split('@')[0].capitalize()
+
+                # 실제 Gmail 발송
+                success, message = email_system.send_email(subject, body, company_name, recipient)
+
+                return message
+
+            except Exception as e:
+                return f"이메일 발송 처리 오류: {str(e)}"
+
+        real_email_send_btn.click(
+            fn=handle_real_email_send,
+            inputs=[email_recipient, email_subject, email_body],
+            outputs=[email_send_status]
+        )
+
+        # 6. 이메일 현황 새로고침
+        refresh_email_btn.click(
+            fn=lambda: email_system.get_email_history_text(),
+            outputs=[email_history_display]
+        )
+
+    return demo
+
+# ==================== 메인 실행 ====================
+
+def main():
+    """메인 실행 함수"""
+    print("🚀 G-Mission 허깅페이스 배포용 Agentic AI 대시보드 시작!")
+    print("✅ Gmail SMTP 이메일 시스템")
+    print("✅ 파스텔톤 차트 색상")
+    print("✅ 생태계별 최적화")
+    print("✅ jeongkee10@gmission.com 수신")
+
+    try:
+        demo = create_huggingface_dashboard()
+
+        # 허깅페이스 배포용 launch 설정
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            debug=False,
+            share=False
+        )
+
+        print("✅ 허깅페이스 배포용 대시보드 실행 성공!")
+
+    except Exception as e:
+        print(f"❌ 대시보드 실행 오류: {e}")
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    main()