Upload app.py

app.py

@@ -0,0 +1,978 @@
+# ============================================
+# 📘 Vision LLM Agentic AI 프로젝트 견적 시스템
+# - 보수적 MM 산정 / 오픈소스 중심
+# - Phase별 상세 사이징
+# - PDF/Excel 다운로드 기능
+# - Hugging Face Spaces 최적화
+# ============================================
+
+import sys
+import os
+import math
+import time
+import warnings
+warnings.filterwarnings("ignore")
+
+# Hugging Face Spaces는 requirements.txt로 패키지 관리
+import gradio as gr
+import pandas as pd
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from fpdf import FPDF
+import json
+from datetime import datetime
+
+print("✅ 패키지 로드 완료!\n" + "="*70)
+
+# ============================================
+# 💰 금액 산출 기준 (명확히 정의)
+# ============================================
+
+CURRENCY_INFO = {
+    "base": "KRW",
+    "unit": "억원",
+    "display_factor": 100_000_000,
+}
+
+# 인건비 (원화 기준)
+LABOR_RATES = {
+    "Senior_Engineer": 18_000_000,
+    "Mid_Engineer": 15_000_000,
+    "Junior_Engineer": 12_000_000,
+    "Architect": 20_000_000,
+    "Average": 15_000_000,
+}
+
+LABOR_COST_PER_MM = LABOR_RATES["Average"]
+
+# GPU 단가 (원화 기준)
+GPU_COSTS_KRW = {
+    'A100_80GB': 4_000_000_000,
+    'H100_80GB': 6_000_000_000,
+    'A100_40GB': 2_500_000_000,
+    'L40S': 1_500_000_000,
+}
+
+GPU_COST = {k: v / CURRENCY_INFO['display_factor'] for k, v in GPU_COSTS_KRW.items()}
+
+# 서버 단가
+SERVER_COSTS_KRW = {
+    'CPU_High_End': 50_000_000,
+    'CPU_Mid_Range': 30_000_000,
+    'RAM_256GB': 10_000_000,
+    'RAM_512GB': 20_000_000,
+}
+
+STORAGE_COST_PER_TB = 2_000_000
+OSS_SETUP_COST_PER_MM = 3_000_000
+
+EXCHANGE_RATE_INFO = {
+    "USD_to_KRW": 1330,
+    "note": "GPU 가격은 미국 시장가를 환율 적용하여 산정"
+}
+
+# 보수적 안전계수
+SAFETY_FACTOR = 1.4
+GPU_EFFICIENCY = 0.65
+PARALLEL_EFFICIENCY = 0.70
+OSS_LABOR_MULTIPLIER = 1.5
+
+# ============================================
+# Value Chain Phase 정의
+# ============================================
+
+VALUE_CHAIN_PHASES = {
+    "Phase1_DataPrep": {
+        "name": "Phase 1: 데이터 준비 및 기반 구축",
+        "description": "문서 수집, 전처리, 메타데이터, 온톨로지 설계",
+        "base_mm_ratio": 0.39,
+        "roles": ["Data Engineer", "Data Architect", "Ontology Engineer"],
+        "oss_stack": [
+            "PyMuPDF (문서 파싱)",
+            "OpenCV (이미지 처리)",
+            "LayoutParser (표 인식)",
+            "spaCy (NLP)",
+            "PostgreSQL (메타DB)",
+            "Neo4j (그래프DB)",
+            "Apache Airflow (워크플로)",
+            "DVC (데이터 버전관리)"
+        ]
+    },
+    "Phase2_Training": {
+        "name": "Phase 2: 모델 학습 및 최적화",
+        "description": "Vision LLM Fine-Tuning, Q-LoRA, Validation",
+        "base_mm_ratio": 0.23,
+        "roles": ["ML Engineer", "AI Architect", "Research Engineer"],
+        "oss_stack": [
+            "PyTorch (딥러닝)",
+            "PEFT/LoRA (효율적 학습)",
+            "Hugging Face Transformers",
+            "Albumentations (증강)",
+            "InternVL 3.5 (Vision LLM)",
+            "Unsloth (학습 가속)",
+            "MLflow (실험 추적)",
+            "Weights & Biases (모니터링)"
+        ]
+    },
+    "Phase3_AgenticDev": {
+        "name": "Phase 3: Agentic AI 애플리케이션 개발",
+        "description": "Agent 설계, Workflow, Tool 연동, RAG",
+        "base_mm_ratio": 0.17,
+        "roles": ["AI Architect", "Backend Engineer", "ML Engineer"],
+        "oss_stack": [
+            "LangGraph (Agent 프레임워크)",
+            "LangChain (LLM 체인)",
+            "CrewAI (Multi-Agent)",
+            "Qdrant (Vector DB)",
+            "FAISS (벡터 검색)",
+            "Redis (Memory)",
+            "FastAPI (API)",
+            "n8n (워크플로 자동화)"
+        ]
+    },
+    "Phase4_Deployment": {
+        "name": "Phase 4: 배포·운영 및 지속 개선",
+        "description": "Docker/K8s 배포, 모니터링, 재학습 자동화",
+        "base_mm_ratio": 0.21,
+        "roles": ["DevOps Engineer", "MLOps Engineer", "SRE"],
+        "oss_stack": [
+            "Docker (컨테이너)",
+            "Kubernetes (오케스트레이션)",
+            "Prometheus (메트릭)",
+            "Grafana (시각화)",
+            "ELK Stack (로그)",
+            "ArgoCD (GitOps)",
+            "Kubeflow (ML 파이프라인)",
+            "GitLab CI/CD"
+        ]
+    }
+}
+
+# ============================================
+# Function Points
+# ============================================
+
+FP_COEFFICIENTS = {
+    "A-01": 0.00003, "A-02": 0.000015, "A-03": 0.00004, "A-04": 0.00008,
+    "A-05": 0.00006, "A-06": 0.00005, "A-07": 0.000055,
+    "B-01": 0.00004, "B-02": 0.00003, "B-03": 0.00005, "B-04": 0.00004,
+    "C-01": 0.00005, "C-02": 0.00007, "C-03": 0.00004, "C-04": 0.00003,
+    "D-01": 0.00009, "D-02": 0.00006, "D-03": 0.00015, "D-04": 0.00006, "D-05": 0.00004,
+    "F-01": 0.00005, "F-02": 0.00008, "F-03": 0.00007, "F-04": 0.00009, "F-05": 0.00007,
+    "G-01": 0.00008, "G-02": 0.00006, "G-03": 0.00004, "G-04": 0.00007,
+    "H-01": 0.00004, "H-02": 0.00005, "H-03": 0.00008, "H-04": 0.00003,
+}
+
+FP_TO_PHASE = {
+    "Phase1_DataPrep": ["A-01", "A-02", "A-03", "A-04", "A-05", "A-06", "A-07",
+                        "B-01", "B-02", "B-03", "B-04", "C-01", "C-02", "C-03", "C-04"],
+    "Phase2_Training": ["D-01", "D-02", "D-03", "D-04", "D-05"],
+    "Phase3_AgenticDev": ["F-01", "F-02", "F-03", "F-04", "F-05"],
+    "Phase4_Deployment": ["G-01", "G-02", "G-03", "G-04", "H-01", "H-02", "H-03", "H-04"]
+}
+
+# ============================================
+# 핵심 계산 함수
+# ============================================
+
+def calculate_phase_mm(phase_id, N_pages, doc_complexity, language_mix, 
+                       table_ratio, image_quality, model_size, 
+                       training_epochs, agent_complexity):
+    """Phase별 MM 계산"""
+    
+    fps = FP_TO_PHASE.get(phase_id, [])
+    total_mm = 0.0
+    fp_details = []
+    
+    if N_pages <= 10000:
+        scale_factor = 1.0
+    elif N_pages <= 100000:
+        scale_factor = 4.5
+    else:
+        scale_factor = 12.0
+    
+    for fp in fps:
+        coeff = FP_COEFFICIENTS.get(fp, 0.00005)
+        base_mm = coeff * N_pages * scale_factor
+        
+        if phase_id == "Phase1_DataPrep":
+            weight = (doc_complexity * language_mix * 
+                     (1 + table_ratio) * image_quality)
+            if fp in ["A-04", "A-05"]:
+                weight *= (1 + table_ratio*0.5)
+                
+        elif phase_id == "Phase2_Training":
+            weight = model_size * (1 + training_epochs/10) * image_quality
+            if fp == "D-03":
+                weight *= 1.8
+                
+        elif phase_id == "Phase3_AgenticDev":
+            weight = agent_complexity * doc_complexity
+            
+        else:
+            weight = (doc_complexity + agent_complexity) / 2
+        
+        mm = base_mm * weight * OSS_LABOR_MULTIPLIER * SAFETY_FACTOR
+        total_mm += mm
+        
+        fp_details.append({
+            "FP": fp,
+            "Base_MM": round(base_mm, 3),
+            "Weight": round(weight, 2),
+            "Final_MM": round(mm, 2)
+        })
+    
+    return total_mm, fp_details
+
+def calculate_hardware(phase_id, N_pages, model_size, training_epochs, 
+                       deployment_type, sla_level):
+    """Phase별 HW 사이징"""
+    
+    hw = {}
+    
+    if phase_id == "Phase1_DataPrep":
+        base_gpu = max(2, math.ceil(N_pages / 5000 * SAFETY_FACTOR))
+        hw["Preprocess_GPU"] = min(base_gpu, 8)
+        hw["GPU_Type"] = "L40S"
+        hw["CPU_Cores"] = 16 * hw["Preprocess_GPU"]
+        hw["RAM_GB"] = 64 * hw["Preprocess_GPU"]
+        hw["Storage_TB"] = round(max(10, N_pages * 0.5 / 1000000), 1)
+        
+    elif phase_id == "Phase2_Training":
+        base_gpu = max(4, math.ceil(N_pages * training_epochs / 3000 * model_size * SAFETY_FACTOR))
+        hw["Training_GPU"] = base_gpu
+        hw["GPU_Type"] = "A100_80GB"
+        hw["CPU_Cores"] = 32 * hw["Training_GPU"]
+        hw["RAM_GB"] = 128 * hw["Training_GPU"]
+        hw["Storage_TB"] = round(max(50, N_pages * training_epochs * 2.0 / 1000000), 1)
+        
+    elif phase_id == "Phase3_AgenticDev":
+        hw["Dev_GPU"] = max(2, math.ceil(model_size * 2))
+        hw["GPU_Type"] = "A100_40GB"
+        hw["VectorDB_Instances"] = max(2, math.ceil(N_pages / 100000))
+        hw["CPU_Cores"] = 32
+        hw["RAM_GB"] = 256
+        hw["Storage_TB"] = round(max(20, N_pages * 1.0 / 1000000), 1)
+        
+    else:
+        qps_estimate = N_pages / 10000
+        base_gpu = max(2, math.ceil(qps_estimate * sla_level * SAFETY_FACTOR))
+        hw["Inference_GPU"] = base_gpu
+        hw["GPU_Type"] = "A100_80GB"
+        hw["K8s_Nodes"] = max(3, math.ceil(base_gpu / 2))
+        hw["CPU_Cores"] = 64
+        hw["RAM_GB"] = 512
+        hw["Storage_TB"] = round(max(100, N_pages * 2.0 / 1000000), 1)
+    
+    return hw
+
+def estimate_cost(hw, mm, phase_id):
+    """비용 산정"""
+    
+    labor_cost_krw = mm * LABOR_COST_PER_MM
+    labor_cost = labor_cost_krw / CURRENCY_INFO['display_factor']
+    
+    gpu_cost = 0
+    if "Training_GPU" in hw:
+        gpu_type = hw.get("GPU_Type", "A100_80GB")
+        gpu_cost = hw["Training_GPU"] * GPU_COST.get(gpu_type, 40.0)
+    elif "Preprocess_GPU" in hw:
+        gpu_type = hw.get("GPU_Type", "L40S")
+        gpu_cost = hw["Preprocess_GPU"] * GPU_COST.get(gpu_type, 15.0)
+    elif "Inference_GPU" in hw:
+        gpu_type = hw.get("GPU_Type", "A100_80GB")
+        gpu_cost = hw["Inference_GPU"] * GPU_COST.get(gpu_type, 40.0)
+    elif "Dev_GPU" in hw:
+        gpu_type = hw.get("GPU_Type", "A100_40GB")
+        gpu_cost = hw["Dev_GPU"] * GPU_COST.get(gpu_type, 25.0)
+    
+    server_cost_krw = 0
+    if hw.get("CPU_Cores", 0) >= 32:
+        server_cost_krw += SERVER_COSTS_KRW['CPU_High_End']
+    elif hw.get("CPU_Cores", 0) >= 16:
+        server_cost_krw += SERVER_COSTS_KRW['CPU_Mid_Range']
+    
+    if hw.get("RAM_GB", 0) >= 512:
+        server_cost_krw += SERVER_COSTS_KRW['RAM_512GB']
+    elif hw.get("RAM_GB", 0) >= 256:
+        server_cost_krw += SERVER_COSTS_KRW['RAM_256GB']
+    
+    server_cost = server_cost_krw / CURRENCY_INFO['display_factor']
+    
+    storage_cost_krw = 0
+    if "Storage_TB" in hw:
+        storage_cost_krw = hw["Storage_TB"] * STORAGE_COST_PER_TB
+    storage_cost = storage_cost_krw / CURRENCY_INFO['display_factor']
+    
+    oss_setup_cost_krw = mm * OSS_SETUP_COST_PER_MM
+    oss_setup_cost = oss_setup_cost_krw / CURRENCY_INFO['display_factor']
+    
+    hw_total = gpu_cost + server_cost + storage_cost
+    infra_cost = hw_total * 0.3
+    
+    total_cost = labor_cost + gpu_cost + server_cost + storage_cost + oss_setup_cost + infra_cost
+    
+    return {
+        "Labor": round(labor_cost, 1),
+        "GPU": round(gpu_cost, 1),
+        "Server": round(server_cost, 1),
+        "Storage": round(storage_cost, 1),
+        "OSS_Setup": round(oss_setup_cost, 1),
+        "Infrastructure": round(infra_cost, 1),
+        "Total": round(total_cost, 1),
+    }
+
+# ============================================
+# 메인 견적 함수
+# ============================================
+
+def run_estimation(N_pages, doc_complexity, language_mix, table_ratio,
+                   image_quality, model_size, training_epochs, 
+                   agent_complexity, deployment_type, sla_level, 
+                   security_level):
+    """전체 견적 실행"""
+    
+    try:
+        if N_pages < 1000:
+            return ("❌ 문서 수는 최소 1,000장 이상이어야 합니다.",) + (None,) * 7
+        
+        results = {}
+        total_mm = 0
+        
+        phase_ids = ["Phase1_DataPrep", "Phase2_Training", "Phase3_AgenticDev", "Phase4_Deployment"]
+        
+        for phase_id in phase_ids:
+            phase_info = VALUE_CHAIN_PHASES[phase_id]
+            
+            mm, fp_details = calculate_phase_mm(
+                phase_id, N_pages, doc_complexity, language_mix,
+                table_ratio/100, image_quality, model_size,
+                training_epochs, agent_complexity
+            )
+            
+            if phase_id == "Phase4_Deployment":
+                mm *= (sla_level * security_level)
+            
+            mm *= deployment_type
+            total_mm += mm
+            
+            hw = calculate_hardware(
+                phase_id, N_pages, model_size, training_epochs,
+                deployment_type, sla_level
+            )
+            
+            cost = estimate_cost(hw, mm, phase_id)
+            
+            results[phase_id] = {
+                "name": phase_info["name"],
+                "mm": round(mm, 1),
+                "hw": hw,
+                "cost": cost,
+                "fp_details": fp_details,
+                "oss_stack": phase_info["oss_stack"]
+            }
+        
+        duration_months = (
+            results["Phase1_DataPrep"]["mm"] / 8 +
+            max(results["Phase2_Training"]["mm"] / 10,
+                results["Phase3_AgenticDev"]["mm"] / 6) * PARALLEL_EFFICIENCY +
+            results["Phase4_Deployment"]["mm"] / 8
+        )
+        duration_months = math.ceil(duration_months * 1.2)
+        
+        summary = generate_summary(results, total_mm, duration_months, N_pages)
+        phase_chart = create_phase_chart(results)
+        cost_chart = create_cost_breakdown(results)
+        timeline_chart = create_timeline(results, duration_months)
+        hw_table = create_hw_table(results)
+        oss_table = create_oss_table(results)
+        
+        pdf_path = generate_pdf(results, total_mm, duration_months, N_pages)
+        excel_path = generate_excel(results, total_mm, duration_months, N_pages)
+        
+        return summary, phase_chart, cost_chart, timeline_chart, hw_table, oss_table, pdf_path, excel_path
+        
+    except Exception as e:
+        import traceback
+        error_detail = traceback.format_exc()
+        error_msg = f"❌ 오류 발생: {str(e)}\n\n상세:\n{error_detail}"
+        return (error_msg,) + (None,) * 7
+
+def generate_summary(results, total_mm, duration_months, N_pages):
+    """요약 생성"""
+    
+    total_cost = sum(r["cost"]["Total"] for r in results.values())
+    total_labor = sum(r["cost"]["Labor"] for r in results.values())
+    total_gpu = sum(r["cost"]["GPU"] for r in results.values())
+    total_oss = sum(r["cost"]["OSS_Setup"] for r in results.values())
+    
+    summary = f"""
+# 📊 Vision LLM Agentic AI 프로젝트 견적서
+
+## 💰 금액 산출 기준
+- **기준 통화**: 원화 (KRW)
+- **표시 단위**: 억원 (1억 = 100,000,000원)
+- **환율 참조**: USD 1,330원 (2024년 11월 기준)
+
+### 단가 정보
+- **인건비**: 1,500만원/MM (Man-Month)
+- **GPU 단가**: A100 80GB 40억원, H100 80GB 60억원
+- **OSS 구축비**: 300만원/MM
+- **스토리지**: 200만원/TB
+
+## 프로젝트 개요
+- **처리 대상**: {N_pages:,}장
+- **총 소요 인력**: {total_mm:.1f} MM
+- **예상 기간**: {duration_months}개월
+- **총 예상 비용**: {total_cost:.1f}억원 ({int(total_cost * 100_000_000):,}원)
+
+## Phase별 요약
+
+### {results["Phase1_DataPrep"]["name"]}
+- 인력: {results["Phase1_DataPrep"]["mm"]:.1f} MM
+- 비용: {results["Phase1_DataPrep"]["cost"]["Total"]:.1f}억원
+- 주요 HW: {results["Phase1_DataPrep"]["hw"].get("GPU_Type", "N/A")} × {results["Phase1_DataPrep"]["hw"].get("Preprocess_GPU", 0)}대
+
+### {results["Phase2_Training"]["name"]}
+- 인력: {results["Phase2_Training"]["mm"]:.1f} MM
+- 비용: {results["Phase2_Training"]["cost"]["Total"]:.1f}억원
+- 주요 HW: {results["Phase2_Training"]["hw"].get("GPU_Type", "N/A")} × {results["Phase2_Training"]["hw"].get("Training_GPU", 0)}대
+
+### {results["Phase3_AgenticDev"]["name"]}
+- 인력: {results["Phase3_AgenticDev"]["mm"]:.1f} MM
+- 비용: {results["Phase3_AgenticDev"]["cost"]["Total"]:.1f}억원
+- 주요 HW: {results["Phase3_AgenticDev"]["hw"].get("GPU_Type", "N/A")} × {results["Phase3_AgenticDev"]["hw"].get("Dev_GPU", 0)}대
+
+### {results["Phase4_Deployment"]["name"]}
+- 인력: {results["Phase4_Deployment"]["mm"]:.1f} MM
+- 비용: {results["Phase4_Deployment"]["cost"]["Total"]:.1f}억원
+- 주요 HW: {results["Phase4_Deployment"]["hw"].get("GPU_Type", "N/A")} × {results["Phase4_Deployment"]["hw"].get("Inference_GPU", 0)}대
+
+## 비용 구성
+- **인건비**: {total_labor:.1f}억원 ({total_labor/total_cost*100:.1f}%)
+- **GPU**: {total_gpu:.1f}억원 ({total_gpu/total_cost*100:.1f}%)
+- **OSS 구축**: {total_oss:.1f}억원 ({total_oss/total_cost*100:.1f}%)
+- **기타 인프라**: {sum(r["cost"]["Infrastructure"] for r in results.values()):.1f}억원
+
+---
+💡 **참고사항**
+- 본 견적은 보수적 관점에서 산정 (안전계수 1.4)
+- 오픈소스 기반으로 상용 대비 1.5배 인력 반영
+- 실제 프로젝트 진행 시 ±15% 조정 가능
+"""
+    
+    return summary
+
+# ============================================
+# PDF 생성 함수
+# ============================================
+
+def generate_pdf(results, total_mm, duration_months, N_pages):
+    """PDF 견적서 생성"""
+    
+    try:
+        pdf = FPDF(orientation='P', unit='mm', format='A4')
+        pdf.add_page()
+        pdf.set_margins(25, 15, 25)
+        pdf.set_auto_page_break(auto=True, margin=15)
+        
+        # 기본 폰트 사용 (한글 지원 제한적)
+        pdf.set_font('Arial', '', 10)
+        
+        # 제목
+        pdf.set_font('Arial', 'B', 16)
+        pdf.cell(0, 10, 'Vision LLM Agentic AI Estimate', ln=1, align='C')
+        pdf.ln(3)
+        
+        pdf.set_font('Arial', '', 9)
+        pdf.cell(0, 5, f'Date: {datetime.now().strftime("%Y-%m-%d")}', ln=1, align='R')
+        pdf.ln(5)
+        
+        # 1. 금액 기준
+        pdf.set_font('Arial', 'B', 11)
+        pdf.cell(0, 7, '1. Cost Basis', ln=1)
+        pdf.set_font('Arial', '', 9)
+        
+        pdf.cell(0, 5, 'Currency: KRW (Korean Won)', ln=1)
+        pdf.cell(0, 5, 'Unit: 100M KRW', ln=1)
+        pdf.cell(0, 5, 'Labor: 15M KRW/MM', ln=1)
+        pdf.cell(0, 5, 'GPU A100 80GB: 4B KRW', ln=1)
+        pdf.cell(0, 5, 'OSS Setup: 3M KRW/MM', ln=1)
+        pdf.ln(3)
+        
+        # 2. 개요
+        pdf.set_font('Arial', 'B', 11)
+        pdf.cell(0, 7, '2. Project Overview', ln=1)
+        pdf.set_font('Arial', '', 9)
+        
+        total_cost = sum(r["cost"]["Total"] for r in results.values())
+        
+        pdf.cell(0, 5, f'Documents: {N_pages:,} pages', ln=1)
+        pdf.cell(0, 5, f'Manpower: {total_mm:.1f} MM', ln=1)
+        pdf.cell(0, 5, f'Duration: {duration_months} months', ln=1)
+        pdf.cell(0, 5, f'Total Cost: {total_cost:.1f}B KRW', ln=1)
+        pdf.ln(3)
+        
+        # 3. Phase별 상세
+        pdf.set_font('Arial', 'B', 11)
+        pdf.cell(0, 7, '3. Phase Details', ln=1)
+        pdf.ln(2)
+        
+        for i, (phase_id, data) in enumerate(results.items(), 1):
+            pdf.set_font('Arial', 'B', 10)
+            phase_name = f"Phase {i}"
+            pdf.cell(0, 6, phase_name, ln=1)
+            
+            pdf.set_font('Arial', '', 9)
+            pdf.cell(0, 4, f'  MM: {data["mm"]:.1f}', ln=1)
+            pdf.cell(0, 4, f'  Cost: {data["cost"]["Total"]:.1f}B KRW', ln=1)
+            pdf.cell(0, 4, f'  Labor: {data["cost"]["Labor"]:.1f}B', ln=1)
+            pdf.cell(0, 4, f'  GPU: {data["cost"]["GPU"]:.1f}B', ln=1)
+            pdf.ln(1)
+        
+        pdf.ln(3)
+        
+        # 4. HW 요약
+        pdf.add_page()
+        pdf.set_font('Arial', 'B', 11)
+        pdf.cell(0, 7, '4. Hardware Summary', ln=1)
+        pdf.ln(2)
+        
+        for phase_id, data in results.items():
+            hw = data["hw"]
+            pdf.set_font('Arial', '', 9)
+            
+            if "Training_GPU" in hw:
+                pdf.cell(0, 4, f'Training: {hw["GPU_Type"]} x{hw["Training_GPU"]}', ln=1)
+            elif "Preprocess_GPU" in hw:
+                pdf.cell(0, 4, f'Preprocess: {hw["GPU_Type"]} x{hw["Preprocess_GPU"]}', ln=1)
+            elif "Inference_GPU" in hw:
+                pdf.cell(0, 4, f'Inference: {hw["GPU_Type"]} x{hw["Inference_GPU"]}', ln=1)
+            elif "Dev_GPU" in hw:
+                pdf.cell(0, 4, f'Dev: {hw["GPU_Type"]} x{hw["Dev_GPU"]}', ln=1)
+            
+            pdf.cell(0, 4, f'  CPU: {hw.get("CPU_Cores", 0)} cores', ln=1)
+            pdf.cell(0, 4, f'  RAM: {hw.get("RAM_GB", 0)} GB', ln=1)
+            pdf.cell(0, 4, f'  Storage: {hw.get("Storage_TB", 0)} TB', ln=1)
+            pdf.ln(1)
+        
+        timestamp = int(time.time())
+        pdf_path = f'/tmp/Estimate_{timestamp}.pdf'
+        pdf.output(pdf_path)
+        
+        return pdf_path
+        
+    except Exception as e:
+        print(f"PDF generation error: {e}")
+        return None
+
+# ============================================
+# Excel 생성 함수
+# ============================================
+
+def generate_excel(results, total_mm, duration_months, N_pages):
+    """Excel 견적서 생성"""
+    
+    try:
+        timestamp = int(time.time())
+        excel_path = f'/tmp/Estimate_{timestamp}.xlsx'
+        
+        with pd.ExcelWriter(excel_path, engine='xlsxwriter') as writer:
+            
+            # 1. 요약
+            total_cost = sum(r["cost"]["Total"] for r in results.values())
+            summary_data = {
+                'Item': ['Documents', 'Manpower', 'Duration', 'Total Cost (100M KRW)', 'Total Cost (KRW)'],
+                'Value': [
+                    f'{N_pages:,} pages',
+                    f'{total_mm:.1f} MM',
+                    f'{duration_months} months',
+                    f'{total_cost:.1f}',
+                    f'{int(total_cost * 100_000_000):,}'
+                ]
+            }
+            pd.DataFrame(summary_data).to_excel(writer, sheet_name='Summary', index=False)
+            
+            # 2. Phase별 상세
+            phase_data = []
+            for phase_id, data in results.items():
+                phase_data.append({
+                    'Phase': data["name"].split(":")[1].strip(),
+                    'MM': round(data["mm"], 1),
+                    'Labor (100M)': round(data["cost"]["Labor"], 1),
+                    'GPU (100M)': round(data["cost"]["GPU"], 1),
+                    'OSS Setup (100M)': round(data["cost"]["OSS_Setup"], 1),
+                    'Total (100M)': round(data["cost"]["Total"], 1)
+                })
+            pd.DataFrame(phase_data).to_excel(writer, sheet_name='Phase Details', index=False)
+            
+            # 3. HW
+            hw_data = []
+            for phase_id, data in results.items():
+                hw = data["hw"]
+                hw_row = {'Phase': data["name"].split(":")[1].strip()}
+                hw_row.update(hw)
+                hw_data.append(hw_row)
+            pd.DataFrame(hw_data).to_excel(writer, sheet_name='Hardware', index=False)
+            
+            # 4. OSS
+            oss_data = []
+            for phase_id, data in results.items():
+                for oss in data["oss_stack"]:
+                    oss_data.append({
+                        'Phase': data["name"].split(":")[1].strip(),
+                        'Open Source': oss
+                    })
+            pd.DataFrame(oss_data).to_excel(writer, sheet_name='Open Source', index=False)
+        
+        return excel_path
+        
+    except Exception as e:
+        print(f"Excel generation error: {e}")
+        return None
+
+# ============================================
+# 시각화 함수
+# ============================================
+
+def create_phase_chart(results):
+    """Phase별 비교 차트"""
+    
+    names = [results[p]["name"].split(":")[1].strip() for p in results.keys()]
+    mms = [results[p]["mm"] for p in results.keys()]
+    costs = [results[p]["cost"]["Total"] for p in results.keys()]
+    
+    fig = make_subplots(
+        rows=1, cols=2,
+        subplot_titles=('Phase Manpower (MM)', 'Phase Cost (100M KRW)'),
+        specs=[[{'type':'bar'}, {'type':'bar'}]]
+    )
+    
+    fig.add_trace(
+        go.Bar(x=names, y=mms, text=[f"{m:.1f}" for m in mms],
+               textposition='auto', marker_color='#3498db'),
+        row=1, col=1
+    )
+    
+    fig.add_trace(
+        go.Bar(x=names, y=costs, text=[f"{c:.1f}" for c in costs],
+               textposition='auto', marker_color='#e74c3c'),
+        row=1, col=2
+    )
+    
+    fig.update_layout(height=400, showlegend=False, title_text="Phase Comparison", title_x=0.5)
+    return fig
+
+def create_cost_breakdown(results):
+    """비용 구성 차트"""
+    
+    categories = []
+    values = []
+    
+    for phase_id, data in results.items():
+        name = data["name"].split(":")[1].strip()
+        categories.append(f"{name}\nLabor")
+        values.append(data["cost"]["Labor"])
+        categories.append(f"{name}\nGPU")
+        values.append(data["cost"]["GPU"])
+    
+    fig = go.Figure(data=[go.Pie(
+        labels=categories,
+        values=values,
+        hole=.4,
+        textinfo='label+percent',
+        textposition='outside'
+    )])
+    
+    fig.update_layout(title_text="Cost Breakdown", height=500)
+    return fig
+
+def create_timeline(results, duration_months):
+    """타임라인 차트"""
+    
+    phase_durations = {}
+    start = 0
+    
+    p1_dur = math.ceil(results["Phase1_DataPrep"]["mm"] / 8)
+    phase_durations["Phase1_DataPrep"] = (start, p1_dur)
+    start += p1_dur
+    
+    p2_dur = math.ceil(results["Phase2_Training"]["mm"] / 10)
+    p3_dur = math.ceil(results["Phase3_AgenticDev"]["mm"] / 6)
+    parallel = max(p2_dur, p3_dur)
+    
+    phase_durations["Phase2_Training"] = (start, p2_dur)
+    phase_durations["Phase3_AgenticDev"] = (start, p3_dur)
+    start += parallel
+    
+    p4_dur = math.ceil(results["Phase4_Deployment"]["mm"] / 8)
+    phase_durations["Phase4_Deployment"] = (start, p4_dur)
+    
+    fig = go.Figure()
+    colors = ['#3498db', '#e74c3c', '#2ecc71', '#f39c12']
+    
+    for i, (phase_id, (s, d)) in enumerate(phase_durations.items()):
+        name = results[phase_id]["name"].split(":")[1].strip()
+        fig.add_trace(go.Bar(
+            y=[name], x=[d], base=s, orientation='h',
+            marker=dict(color=colors[i]), text=f"{d}mo",
+            textposition='inside', name=name
+        ))
+    
+    fig.update_layout(
+        title="Project Timeline", xaxis_title="Months", yaxis_title="Phase",
+        barmode='overlay', height=400, showlegend=False
+    )
+    return fig
+
+def create_hw_table(results):
+    """HW 테이블"""
+    
+    rows = []
+    for phase_id, data in results.items():
+        row = {"Phase": data["name"].split(":")[1].strip()}
+        row.update(data["hw"])
+        rows.append(row)
+    return pd.DataFrame(rows)
+
+def create_oss_table(results):
+    """OSS 테이블"""
+    
+    rows = []
+    for phase_id, data in results.items():
+        name = data["name"].split(":")[1].strip()
+        for i, oss in enumerate(data["oss_stack"]):
+            rows.append({
+                "Phase": name if i == 0 else "",
+                "No": i+1,
+                "Open Source": oss
+            })
+    return pd.DataFrame(rows)
+
+# ============================================
+# Gradio UI
+# ============================================
+
+EXAMPLES = [
+    [10000, 0.7, 0.8, 20, 0.8, 0.8, 3, 0.8, 1.0, 1.0, 1.0],
+    [50000, 1.0, 1.0, 40, 1.0, 1.0, 3, 1.0, 1.0, 1.0, 1.0],
+    [100000, 1.3, 1.3, 60, 1.0, 1.0, 5, 1.3, 1.0, 1.2, 1.3],
+    [500000, 1.6, 1.5, 80, 1.3, 1.3, 5, 1.6, 1.4, 1.5, 1.6],
+]
+
+with gr.Blocks(title="Vision LLM Agentic AI 견적", theme=gr.themes.Soft()) as demo:
+    
+    gr.Markdown("""
+    # 📘 Vision LLM 기반 Agentic AI 프로젝트 견적 시스템
+    
+    **보수적 견적 / 오픈소스 중심 / Phase별 상세 분석 / PDF·Excel 다운로드**
+    
+    💰 **금액 기준**: 원화(KRW), 단위: 억원 | 환율: USD 1,330원
+    """)
+    
+    with gr.Tab("📋 파라미터 입력"):
+        
+        gr.Markdown("## 1️⃣ 프로젝트 규모")
+        N_pages = gr.Number(label="📄 문서 페이지 수", value=10000)
+        
+        gr.Markdown("## 2️⃣ 문서 특성")
+        with gr.Row():
+            doc_complexity = gr.Slider(0.7, 1.6, value=1.0, step=0.1,
+                label="📊 문서 복잡도", info="0.7=단순, 1.0=보통, 1.3=복잡, 1.6=매우복잡")
+            language_mix = gr.Slider(0.8, 1.5, value=1.0, step=0.1,
+                label="🌐 언어 복잡도", info="0.8=단일, 1.0=이중, 1.3=다국어")
+        
+        with gr.Row():
+            table_ratio = gr.Slider(0, 100, value=40, step=5,
+                label="📋 표 비율 (%)")
+            image_quality = gr.Slider(0.8, 1.6, value=1.0, step=0.1,
+                label="🖼️ 이미지 품질", info="0.8=고, 1.0=중, 1.3=저")
+        
+        gr.Markdown("## 3️⃣ 모델 및 학습")
+        with gr.Row():
+            model_size = gr.Slider(0.8, 1.6, value=1.0, step=0.1,
+                label="🤖 모델 크기", info="0.8=소형, 1.0=중형, 1.3=대형")
+            training_epochs = gr.Slider(1, 10, value=3, step=1,
+                label="🔄 학습 Epoch")
+        
+        gr.Markdown("## 4️⃣ Agentic AI 및 배포")
+        with gr.Row():
+            agent_complexity = gr.Slider(0.8, 1.6, value=1.0, step=0.1,
+                label="🎯 Agent 복잡도", info="0.8=기본, 1.0=표준, 1.3=고급")
+            deployment_type = gr.Slider(0.9, 1.4, value=1.0, step=0.1,
+                label="🏗️ 배포 환경", info="0.9=Cloud, 1.0=On-Prem, 1.4=Air-Gap")
+        
+        gr.Markdown("## 5️⃣ 운영 요구사항")
+        with gr.Row():
+            sla_level = gr.Slider(1.0, 1.5, value=1.0, step=0.1,
+                label="📈 SLA 등급", info="1.0=표준, 1.2=높음, 1.5=미션크리티컬")
+            security_level = gr.Slider(1.0, 1.6, value=1.0, step=0.1,
+                label="🔐 보안 등급", info="1.0=일반, 1.3=강화, 1.6=최고")
+        
+        estimate_btn = gr.Button("🚀 견적 산정", variant="primary", size="lg")
+        
+        gr.Markdown("### 📌 예제 시나리오")
+        gr.Examples(
+            examples=EXAMPLES,
+            inputs=[N_pages, doc_complexity, language_mix, table_ratio,
+                   image_quality, model_size, training_epochs, agent_complexity,
+                   deployment_type, sla_level, security_level],
+        )
+    
+    with gr.Tab("📊 견적 결과"):
+        
+        summary_text = gr.Markdown()
+        
+        gr.Markdown("### 📥 견적서 다운로드")
+        with gr.Row():
+            pdf_download = gr.File(label="📄 PDF")
+            excel_download = gr.File(label="📊 Excel")
+        
+        with gr.Row():
+            phase_chart = gr.Plot()
+            cost_chart = gr.Plot()
+        
+        timeline_chart = gr.Plot()
+        
+        gr.Markdown("### 💻 하드웨어")
+        hw_table = gr.Dataframe()
+        
+        gr.Markdown("### 🔧 오픈소스")
+        oss_table = gr.Dataframe()
+    
+    with gr.Tab("ℹ️ 파라미터 가이드"):
+        
+        gr.Markdown("""
+        # 📖 파라미터 상세 설명
+        
+        ## 📊 문서 복잡도
+        - **0.7 (단순)**: 텍스트 위주, 표 없음
+        - **1.0 (보통)**: 텍스트 + 단순 표
+        - **1.3 (복잡)**: 텍스트 + 복잡한 표 + 이미지
+        - **1.6 (매우복잡)**: 다단 레이아웃 + 수식 + 다국어
+        
+        ## 🌐 언어 복잡도
+        - **0.8 (단일)**: 한국어만
+        - **1.0 (이중)**: 한국어 + 영어
+        - **1.3 (다국어)**: 한/영/일/중 혼합
+        - **1.5 (특수)**: 다국어 + 특수문자
+        
+        ## 📋 표 비율
+        - 전체 문서 중 표가 포함된 비율 (%)
+        - 표 구조 인식은 가장 복잡한 작업
+        
+        ## 🖼️ 이미지 품질
+        - **0.8 (고품질)**: 스캔 300dpi+
+        - **1.0 (보통)**: 스캔 200dpi
+        - **1.3 (저품질)**: 스캔 150dpi
+        - **1.6 (매우낮음)**: 사진촬영, 왜곡
+        
+        ## 🤖 모델 크기
+        - **0.8 (소형)**: 2B~7B 파라미터
+        - **1.0 (중형)**: 8B~14B
+        - **1.3 (대형)**: 20B~40B
+        - **1.6 (초대형)**: 70B+
+        
+        ## 🎯 Agent 복잡도
+        - **0.8 (기본)**: 단일 Agent, 단순 RAG
+        - **1.0 (표준)**: 2~3 Agent
+        - **1.3 (고급)**: Multi-Agent, 복잡한 Tool
+        - **1.6 (엔터프라이즈)**: Self-Learning
+        
+        ## 🏗️ 배포 환경
+        - **0.9 (Cloud)**: AWS/GCP/Azure
+        - **1.0 (On-Premise)**: 자체 서버
+        - **1.4 (Air-Gap)**: 폐쇄망, 고보안
+        
+        ## 📈 SLA 등급
+        - **1.0 (표준)**: 99% 가용성
+        - **1.2 (높음)**: 99.5% 가용성
+        - **1.5 (미션크리티컬)**: 99.9% 가용성
+        
+        ## 🔐 보안 등급
+        - **1.0 (일반)**: 기본 인증/암호화
+        - **1.3 (강화)**: 다중 인증, 감사 로그
+        - **1.6 (최고)**: Zero-Trust, 완전 격리
+        
+        ---
+        
+        ## 💰 금액 산출 기준
+        
+        ### 통화 및 단위
+        - **기준**: 원화 (KRW)
+        - **표시**: 억원
+        - **환율**: USD 1,330원
+        
+        ### 인건비
+        - **1 MM = 15,000,000원** (1,500만원/월)
+        
+        ### GPU 단가
+        - **A100 80GB: 40억원** (≈ $30,000)
+        - **H100 80GB: 60억원** (≈ $45,000)
+        
+        ### 기타
+        - **OSS 구축: 300만원/MM**
+        - **스토리지: 200만원/TB**
+        """)
+    
+    with gr.Tab("💰 금액 상세"):
+        
+        gr.Markdown(f"""
+        # 💰 금액 산출 상세
+        
+        ## 인건비 (원화)
+        
+        | 직급 | 월 단가 | 연봉 환산 |
+        |------|---------|----------|
+        | 아키텍트 | {LABOR_RATES['Architect']:,}원 | {LABOR_RATES['Architect']*12:,}원 |
+        | 시니어 | {LABOR_RATES['Senior_Engineer']:,}원 | {LABOR_RATES['Senior_Engineer']*12:,}원 |
+        | 중급 | {LABOR_RATES['Mid_Engineer']:,}원 | {LABOR_RATES['Mid_Engineer']*12:,}원 |
+        | 주니어 | {LABOR_RATES['Junior_Engineer']:,}원 | {LABOR_RATES['Junior_Engineer']*12:,}원 |
+        | **평균** | **{LABOR_RATES['Average']:,}원** | **{LABOR_RATES['Average']*12:,}원** |
+        
+        ## GPU 단가 (원화)
+        
+        | GPU | 단가 (원) | 단가 (달러) | 용도 |
+        |-----|-----------|------------|------|
+        | H100 80GB | {GPU_COSTS_KRW['H100_80GB']:,}원 | $45,000 | 대규모 학습 |
+        | A100 80GB | {GPU_COSTS_KRW['A100_80GB']:,}원 | $30,000 | 표준 학습 |
+        | A100 40GB | {GPU_COSTS_KRW['A100_40GB']:,}원 | $18,750 | 개발/테스트 |
+        | L40S | {GPU_COSTS_KRW['L40S']:,}원 | $11,250 | 전처리 |
+        
+        ## 기타 비용
+        
+        | 항목 | 단가 | 단위 |
+        |------|------|------|
+        | 스토리지 (NVMe) | {STORAGE_COST_PER_TB:,}원 | TB |
+        | OSS 구축 | {OSS_SETUP_COST_PER_MM:,}원 | MM |
+        | 고급 서버 | {SERVER_COSTS_KRW['CPU_High_End']:,}원 | 대 |
+        | RAM 512GB | {SERVER_COSTS_KRW['RAM_512GB']:,}원 | 세트 |
+        
+        ## 비용 산정 공식
+```
+        Total = Labor + GPU + Server + Storage + OSS + Infrastructure
+        
+        Labor = MM × 15,000,000원
+        GPU = GPU_Count × GPU_Unit_Price
+        OSS = MM × 3,000,000원
+        Infrastructure = (GPU + Server + Storage) × 0.3
+```
+        
+        ## 안전계수
+        - **안전계수**: 1.4 (40% 버퍼)
+        - **GPU 효율**: 0.65 (65% 활용률)
+        - **OSS 인력**: 1.5배 (상용 대비)
+        """)
+    
+    estimate_btn.click(
+        fn=run_estimation,
+        inputs=[N_pages, doc_complexity, language_mix, table_ratio,
+                image_quality, model_size, training_epochs, agent_complexity,
+                deployment_type, sla_level, security_level],
+        outputs=[summary_text, phase_chart, cost_chart, timeline_chart, 
+                hw_table, oss_table, pdf_download, excel_download]
+    )
+
+if __name__ == "__main__":
+    print("🚀 Starting Gradio app...")
+    demo.launch()