Create app-backup.py

app-backup.py

@@ -0,0 +1,1896 @@
+import os
+import json
+import re
+import logging
+import requests
+import markdown
+import time
+import io
+import random
+import hashlib
+from datetime import datetime
+from dataclasses import dataclass
+from itertools import combinations, product
+from typing import Iterator
+
+import streamlit as st
+import pandas as pd
+import PyPDF2  # For handling PDF files
+from collections import Counter
+
+from openai import OpenAI  # OpenAI 라이브러리
+from gradio_client import Client
+from kaggle.api.kaggle_api_extended import KaggleApi
+import tempfile
+import glob
+import shutil
+
+# ─── 추가된 라이브러리(절대 누락 금지) ───────────────────────────────
+import pyarrow.parquet as pq
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+# ─────────────────────────────── Environment Variables / Constants ─────────────────────────
+
+OPENAI_API_KEY   = os.getenv("OPENAI_API_KEY", "")
+BRAVE_KEY        = os.getenv("SERPHOUSE_API_KEY", "")   # Brave Search API
+KAGGLE_USERNAME  = os.getenv("KAGGLE_USERNAME", "")
+KAGGLE_KEY       = os.getenv("KAGGLE_KEY", "")
+KAGGLE_API_KEY   = KAGGLE_KEY
+
+if not (KAGGLE_USERNAME and KAGGLE_KEY):
+    raise RuntimeError("⚠️  KAGGLE_USERNAME과 KAGGLE_KEY 환경변수를 먼저 설정하세요.")
+
+os.environ["KAGGLE_USERNAME"] = KAGGLE_USERNAME
+os.environ["KAGGLE_KEY"]      = KAGGLE_KEY
+
+BRAVE_ENDPOINT   = "https://api.search.brave.com/res/v1/web/search"
+IMAGE_API_URL    = "http://211.233.58.201:7896"  # 예시 이미지 생성용 API
+MAX_TOKENS       = 7999
+
+# ─────────────────────────────── Logging ───────────────────────────────
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+
+# ─────────────────────────────── 군사(밀리터리) 전술 데이터셋 로드 ─────────────────
+@st.cache_resource
+def load_military_dataset():
+    """
+    mil.parquet (index, scenario_description, attack_reasoning, defense_reasoning)
+    """
+    path = os.path.join(os.path.dirname(__file__), "mil.parquet")
+    if not os.path.exists(path):
+        logging.warning("mil.parquet not found – military support disabled.")
+        return None
+    try:
+        df = pq.read_table(path).to_pandas()
+        return df
+    except Exception as e:
+        logging.error(f"Failed to read mil.parquet: {e}")
+        return None
+
+MIL_DF = load_military_dataset()
+
+def is_military_query(text: str) -> bool:
+    """군사/전술 관련 키워드가 등장하면 True 반환"""
+    kw = [
+        "군사", "전술", "전투", "전쟁", "작전", "무기", "병력",
+        "military", "tactic", "warfare", "battle", "operation"
+    ]
+    return any(k.lower() in text.lower() for k in kw)
+
+def military_search(query: str, top_k: int = 3):
+    """
+    mil.parquet의 scenario_description 열과 코사인 유사도 분석하여
+    query와 가장 유사한 상위 시나리오를 반환
+    """
+    if MIL_DF is None:
+        return []
+    try:
+        corpus = MIL_DF["scenario_description"].tolist()
+        vec = TfidfVectorizer().fit_transform([query] + corpus)
+        sims = cosine_similarity(vec[0:1], vec[1:]).flatten()
+        top_idx = sims.argsort()[-top_k:][::-1]
+        return MIL_DF.iloc[top_idx][[
+            "scenario_description",
+            "attack_reasoning",
+            "defense_reasoning"
+        ]].to_dict("records")
+    except Exception as e:
+        logging.error(f"military_search error: {e}")
+        return []
+
+# ─────────────────────────────── Kaggle Datasets ────────────────────────
+KAGGLE_DATASETS = {
+    "general_business": {
+        "ref": "mohammadgharaei77/largest-2000-global-companies",
+        "title": "Largest 2000 Global Companies",
+        "subtitle": "Comprehensive data about the world's largest companies",
+        "url": "https://www.kaggle.com/datasets/mohammadgharaei77/largest-2000-global-companies",
+        "keywords": ["business", "company", "corporation", "enterprise", "global", "비즈니스", "기업", "회사", "글로벌", "기업가치"]
+    },
+    "global_development": {
+        "ref": "michaelmatta0/global-development-indicators-2000-2020",
+        "title": "Global Development Indicators (2000-2020)",
+        "subtitle": "Economic and social indicators for countries worldwide",
+        "url": "https://www.kaggle.com/datasets/michaelmatta0/global-development-indicators-2000-2020",
+        "keywords": ["development", "economy", "global", "indicators", "social", "경제", "발전", "지표", "사회", "국가", "글로벌"]
+    },
+    "startup_ideas": {
+        "ref": "rohitsahoo/100-startup-ideas",
+        "title": "Startup Idea Generator Dataset",
+        "subtitle": "A variety of startup ideas",
+        "url": "https://www.kaggle.com/datasets/rohitsahoo/100-startup-ideas",
+        "keywords": ["startup", "innovation", "business idea", "entrepreneurship", "스타트업", "창업", "혁신", "아이디어", "기업가"]
+    },
+    "legal_terms": {
+        "ref": "gu05087/korean-legal-terms",
+        "title": "Korean Legal Terms",
+        "subtitle": "Database of Korean legal terminology",
+        "url": "https://www.kaggle.com/datasets/gu05087/korean-legal-terms",
+        "keywords": ["legal", "law", "terms", "korean", "legislation", "법률", "법적", "한국", "용어", "규제"]
+    },
+    "billionaires": {
+        "ref": "vincentcampanaro/forbes-worlds-billionaires-list-2024",
+        "title": "Forbes World's Billionaires List 2024",
+        "subtitle": "Comprehensive data on the world's wealthiest individuals",
+        "url": "https://www.kaggle.com/datasets/vincentcampanaro/forbes-worlds-billionaires-list-2024",
+        "keywords": ["billionaire", "wealth", "rich", "forbes", "finance", "부자", "억만장자", "포브스", "부", "재테크"]
+    },
+    "financial_news": {
+        "ref": "thedevastator/uncovering-financial-insights-with-the-reuters-2",
+        "title": "Reuters Financial News Insights",
+        "subtitle": "Financial news and market analysis from Reuters",
+        "url": "https://www.kaggle.com/datasets/thedevastator/uncovering-financial-insights-with-the-reuters-2",
+        "keywords": ["finance", "market", "stock", "investment", "news", "금융", "시장", "주식", "투자", "뉴스"]
+    },
+    "ecommerce": {
+        "ref": "oleksiimartusiuk/80000-products-e-commerce-data-clean",
+        "title": "80,000 Products E-Commerce Data",
+        "subtitle": "Clean dataset of e-commerce products information",
+        "url": "https://www.kaggle.com/datasets/oleksiimartusiuk/80000-products-e-commerce-data-clean",
+        "keywords": ["ecommerce", "product", "retail", "shopping", "online", "이커머스", "제품", "소매", "쇼핑", "온라인"]
+    },
+    "world_development_indicators": {
+        "ref": "georgejdinicola/world-bank-indicators",
+        "title": "World Development Indicators",
+        "subtitle": "Long-run socio-economic indicators for 200+ countries",
+        "url": "https://www.kaggle.com/datasets/georgejdinicola/world-bank-indicators",
+        "keywords": [
+            "wdi", "macro", "economy", "gdp", "population",
+            "개발지표", "거시경제", "세계은행", "경제지표", "인구"
+        ]
+    },
+    "commodity_prices": {
+        "ref": "debashish311601/commodity-prices",
+        "title": "Commodity Prices (2000-2023)",
+        "subtitle": "Daily prices for crude oil, gold, grains, metals, etc.",
+        "url": "https://www.kaggle.com/datasets/debashish311601/commodity-prices",
+        "keywords": [
+            "commodity", "oil", "gold", "raw material", "price",
+            "원자재", "유가", "금", "가격", "시장"
+        ]
+    },
+    "world_trade": {
+        "ref": "muhammadtalhaawan/world-export-and-import-dataset",
+        "title": "World Export & Import Dataset",
+        "subtitle": "34-year historical trade flows by country & product",
+        "url": "https://www.kaggle.com/datasets/muhammadtalhaawan/world-export-and-import-dataset",
+        "keywords": [
+            "trade", "export", "import", "commerce", "flow",
+            "무역", "수출", "수입", "국제교역", "관세"
+        ]
+    },
+    "us_business_reports": {
+        "ref": "census/business-and-industry-reports",
+        "title": "US Business & Industry Reports",
+        "subtitle": "Key monthly economic indicators from the US Census Bureau",
+        "url": "https://www.kaggle.com/datasets/census/business-and-industry-reports",
+        "keywords": [
+            "us", "economy", "retail sales", "construction", "manufacturing",
+            "미국", "경제지표", "소매판매", "산업생산", "건설"
+        ]
+    },
+    "us_industrial_production": {
+        "ref": "federalreserve/industrial-production-index",
+        "title": "Industrial Production Index (US)",
+        "subtitle": "Monthly Fed index for manufacturing, mining & utilities",
+        "url": "https://www.kaggle.com/datasets/federalreserve/industrial-production-index",
+        "keywords": [
+            "industry", "production", "index", "fed", "us",
+            "산업생산", "제조업", "미국", "경기", "지수"
+        ]
+    },
+    "us_stock_market": {
+        "ref": "borismarjanovic/price-volume-data-for-all-us-stocks-etfs",
+        "title": "Huge Stock Market Dataset",
+        "subtitle": "Historical prices & volumes for all US stocks and ETFs",
+        "url": "https://www.kaggle.com/datasets/borismarjanovic/price-volume-data-for-all-us-stocks-etfs",
+        "keywords": [
+            "stock", "market", "finance", "equity", "price",
+            "주식", "미국증시", "시세", "ETF", "데이터"
+        ]
+    },
+    "company_financials": {
+        "ref": "rish59/financial-statements-of-major-companies2009-2023",
+        "title": "Financial Statements of Major Companies (2009-2023)",
+        "subtitle": "15-year income sheet & balance sheet data for global firms",
+        "url": "https://www.kaggle.com/datasets/rish59/financial-statements-of-major-companies2009-2023",
+        "keywords": [
+            "financials", "income", "balance sheet", "cashflow",
+            "재무제표", "매출", "수익성", "기업재무", "포트폴리오"
+        ]
+    },
+    "startup_investments": {
+        "ref": "justinas/startup-investments",
+        "title": "Crunchbase Startup Investments",
+        "subtitle": "Funding rounds & investor info for global startups",
+        "url": "https://www.kaggle.com/datasets/justinas/startup-investments",
+        "keywords": [
+            "startup", "venture", "funding", "crunchbase",
+            "투자", "VC", "스타트업", "라운드", "신규진입"
+        ]
+    },
+    "global_energy": {
+        "ref": "atharvasoundankar/global-energy-consumption-2000-2024",
+        "title": "Global Energy Consumption (2000-2024)",
+        "subtitle": "Country-level energy usage by source & sector",
+        "url": "https://www.kaggle.com/datasets/atharvasoundankar/global-energy-consumption-2000-2024",
+        "keywords": [
+            "energy", "consumption", "renewable", "oil", "utility",
+            "에너지", "소비", "재생에너지", "전력수요", "화석연료"
+        ]
+    },
+    "co2_emissions": {
+        "ref": "ulrikthygepedersen/co2-emissions-by-country",
+        "title": "CO₂ Emissions by Country",
+        "subtitle": "Annual CO₂ emissions & per-capita data since 1960s",
+        "url": "https://www.kaggle.com/datasets/ulrikthygepedersen/co2-emissions-by-country",
+        "keywords": [
+            "co2", "emission", "climate", "environment", "carbon",
+            "탄소배출", "기후변화", "환경", "온실가스", "지속가능"
+        ]
+    },
+    "crop_climate": {
+        "ref": "thedevastator/the-relationship-between-crop-production-and-cli",
+        "title": "Crop Production & Climate Change",
+        "subtitle": "Yield & area stats for wheat, corn, rice, soybean vs climate",
+        "url": "https://www.kaggle.com/datasets/thedevastator/the-relationship-between-crop-production-and-cli",
+        "keywords": [
+            "agriculture", "crop", "climate", "yield", "food",
+            "농업", "작물", "기후", "수확량", "식품"
+        ]
+    },
+    "esg_ratings": {
+        "ref": "alistairking/public-company-esg-ratings-dataset",
+        "title": "Public Company ESG Ratings",
+        "subtitle": "Environment, Social & Governance scores for listed firms",
+        "url": "https://www.kaggle.com/datasets/alistairking/public-company-esg-ratings-dataset",
+        "keywords": [
+            "esg", "sustainability", "governance", "csr",
+            "환경", "사회", "지배구조", "지속가능", "평가"
+        ]
+    },
+    "global_health": {
+        "ref": "malaiarasugraj/global-health-statistics",
+        "title": "Global Health Statistics",
+        "subtitle": "Comprehensive health indicators & disease prevalence by country",
+        "url": "https://www.kaggle.com/datasets/malaiarasugraj/global-health-statistics",
+        "keywords": [
+            "health", "disease", "life expectancy", "WHO",
+            "보건", "질병", "기대수명", "의료", "공중보건"
+        ]
+    },
+    "housing_market": {
+        "ref": "atharvasoundankar/global-housing-market-analysis-2015-2024",
+        "title": "Global Housing Market Analysis (2015-2024)",
+        "subtitle": "House price index, mortgage rates, rent data by country",
+        "url": "https://www.kaggle.com/datasets/atharvasoundankar/global-housing-market-analysis-2015-2024",
+        "keywords": [
+            "housing", "real estate", "price index", "mortgage",
+            "부동산", "주택가격", "임대료", "시장", "금리"
+        ]
+    },
+    "pharma_sales": {
+        "ref": "milanzdravkovic/pharma-sales-data",
+        "title": "Pharma Sales Data (2014-2019)",
+        "subtitle": "600k sales records across 8 ATC drug categories",
+        "url": "https://www.kaggle.com/datasets/milanzdravkovic/pharma-sales-data",
+        "keywords": [
+            "pharma", "sales", "drug", "healthcare", "medicine",
+            "제약", "의약품", "매출", "헬스케어", "시장"
+        ]
+    },
+    "ev_sales": {
+        "ref": "muhammadehsan000/global-electric-vehicle-sales-data-2010-2024",
+        "title": "Global EV Sales Data (2010-2024)",
+        "subtitle": "Electric vehicle unit sales by region & model year",
+        "url": "https://www.kaggle.com/datasets/muhammadehsan000/global-electric-vehicle-sales-data-2010-2024",
+        "keywords": [
+            "ev", "electric vehicle", "automotive", "mobility",
+            "전기차", "판매량", "자동차산업", "친환경모빌리티", "시장성장"
+        ]
+    },
+    "hr_attrition": {
+        "ref": "pavansubhasht/ibm-hr-analytics-attrition-dataset",
+        "title": "IBM HR Analytics: Attrition & Performance",
+        "subtitle": "Employee demographics, satisfaction & attrition flags",
+        "url": "https://www.kaggle.com/datasets/pavansubhasht/ibm-hr-analytics-attrition-dataset",
+        "keywords": [
+            "hr", "attrition", "employee", "people analytics",
+            "인사", "이직률", "직원", "HR분석", "조직관리"
+        ]
+    },
+    "employee_satisfaction": {
+        "ref": "redpen12/employees-satisfaction-analysis",
+        "title": "Employee Satisfaction Survey Data",
+        "subtitle": "Department-level survey scores on satisfaction & engagement",
+        "url": "https://www.kaggle.com/datasets/redpen12/employees-satisfaction-analysis",
+        "keywords": [
+            "satisfaction", "engagement", "survey", "workplace",
+            "직원만족도", "조직문화", "설문", "근무환경", "HR"
+        ]
+    },
+    "world_bank_indicators": {
+        "ref": "georgejdinicola/world-bank-indicators",
+        "title": "World Bank Indicators by Topic (1960-Present)",
+        "subtitle": "Macro-economic, 사회·인구 통계 등 200+개국 장기 시계열 지표",
+        "url": "https://www.kaggle.com/datasets/georgejdinicola/world-bank-indicators",
+        "keywords": ["world bank", "development", "economy", "global", "indicator", "세계은행", "경제", "지표", "개발", "거시"]
+    },
+    "physical_chem_properties": {
+        "ref": "ivanyakovlevg/physical-and-chemical-properties-of-substances",
+        "title": "Physical & Chemical Properties of Substances",
+        "subtitle": "8만여 화합물의 물리·화학 특성 및 분류 정보",
+        "url": "https://www.kaggle.com/datasets/ivanyakovlevg/physical-and-chemical-properties-of-substances",
+        "keywords": ["chemistry", "materials", "property", "substance", "화학", "물성", "소재", "데이터", "R&D"]
+    },
+    "global_weather_repository": {
+        "ref": "nelgiriyewithana/global-weather-repository",
+        "title": "Global Weather Repository",
+        "subtitle": "전 세계 기상 관측치(기온·강수·풍속 등) 일별 업데이트",
+        "url": "https://www.kaggle.com/datasets/nelgiriyewithana/global-weather-repository",
+        "keywords": ["weather", "climate", "meteorology", "global", "forecast", "기상", "날씨", "기후", "관측", "환경"]
+    },
+    "amazon_best_seller_softwares": {
+        "ref": "kaverappa/amazon-best-seller-softwares",
+        "title": "Amazon Best Seller – Software Category",
+        "subtitle": "아마존 소프트웨어 베스트셀러 순위 및 리뷰 데이터",
+        "url": "https://www.kaggle.com/datasets/kaverappa/amazon-best-seller-softwares",
+        "keywords": ["amazon", "e-commerce", "software", "review", "ranking", "아마존", "이커머스", "소프트웨어", "베스트셀러", "리뷰"]
+    },
+    "world_stock_prices": {
+        "ref": "nelgiriyewithana/world-stock-prices-daily-updating",
+        "title": "World Stock Prices (Daily Updating)",
+        "subtitle": "30,000여 글로벌 상장사의 일간 주가·시총·섹터 정보 실시간 갱신",
+        "url": "https://www.kaggle.com/datasets/nelgiriyewithana/world-stock-prices-daily-updating",
+        "keywords": ["stock", "finance", "market", "equity", "price", "글로벌", "주가", "금융", "시장", "투자"]
+    }
+}
+
+SUN_TZU_STRATEGIES = [
+    {"계": "만천과해", "요약": "평범한 척, 몰래 진행", "조건": "상대가 지켜보고 있을 때", "행동": "루틴·평온함 과시", "목적": "경계 무력화", "예시": "규제기관 눈치 보는 신사업 파일럿"},
+    {"계": "위위구조", "요약": "뒤통수 치면 포위 풀린다", "조건": "우리 측이 압박받을 때", "행동": "적 본진 급습", "목적": "압박 해소", "예시": "경쟁사 핵심 고객 뺏기"},
+    {"계": "차도살인", "요약": "내 손 더럽히지 마", "조건": "직접 공격 부담", "행동": "제3자 활용", "목적": "책임 전가", "예시": "언론을 통한 경쟁사 비판"},
+    {"계": "이일대우", "요약": "우리가 쉬면 적이 지친다", "조건": "상대가 과로 중", "행동": "버티며 체력 보존", "목적": "역전 타이밍 확보", "예시": "협상 지연 후 헐값 인수"},
+    {"계": "진화타겁", "요약": "불날 때 주워 담기", "조건": "시장 혼란·위기", "행동": "저가 매수", "목적": "저비용 고이익", "예시": "금융위기 때 우량자산 매입"},
+    {"계": "성동격서", "요약": "소음은 왼쪽, 공격은 오른쪽", "조건": "정면 방어 견고", "행동": "가짜 신호 → 우회", "목적": "방어 분산", "예시": "신제품 A 홍보, 실제는 B 확장"},
+    {"계": "무중생유", "요약": "없는 것도 있는 척", "조건": "자원 부족", "행동": "허세��연막", "목적": "상대 혼란", "예시": "스타트업 과장 로드맵"},
+    {"계": "암도진창", "요약": "뒷문으로 돌아가라", "조건": "우회로 존재", "행동": "비밀 루트 침투", "목적": "허를 찌름", "예시": "관세 피해 제3국 생산"},
+    {"계": "격안관화", "요약": "남 싸움 구경", "조건": "두 경쟁자 충돌", "행동": "관망", "목적": "둘 다 소모", "예시": "플랫폼 전쟁 중 중립 유지"},
+    {"계": "소리장도", "요약": "웃으며 칼 숨기기", "조건": "친밀 분위기", "행동": "우호 제스처 후 기습", "목적": "경계 붕괴", "예시": "합작 후 핵심 기술 탈취"},
+    {"계": "이대도강", "요약": "덜 중요한 걸 내줘라", "조건": "뭔가 잃었을 때", "행동": "부속 희생", "목적": "핵심 보호", "예시": "제품 라인 하나 단종"},
+    {"계": "순수견양", "요약": "방치된 것 챙기기", "조건": "경계 허술", "행동": "자연스럽게 수집", "목적": "무혈 이득", "예시": "공공 API 데이터 긁기"},
+    {"계": "타초경사", "요약": "풀 쳐서 뱀 나온다", "조건": "적이 숨을 때", "행동": "일부러 소란", "목적": "위치 노출", "예시": "이사회 반대파 의중 파악"},
+    {"계": "차시환혼", "요약": "죽은 카드 재활용", "조건": "폐기 자원", "행동": "리브랜딩", "목적": "새 전력 확보", "예시": "실패 앱 재출시"},
+    {"계": "조호이산", "요약": "호랑이 산 밖으로", "조건": "강적 거점", "행동": "유인 이동", "목적": "빈집 공략", "예시": "경쟁 VC 행사 유도 후 딜 선점"},
+    {"계": "욕금고종", "요약": "잡으려면 놓아줘라", "조건": "인재·적 포획", "행동": "일부러 풀어줌", "목적": "저항 약화", "예시": "핵심 인재 재계약 유도"},
+    {"계": "포전인옥", "요약": "벽돌 던져 옥 얻기", "조건": "큰 보상 필요", "행동": "작은 미끼", "목적": "참여 유도", "예시": "무료 → 유료 전환"},
+    {"계": "금적금왕", "요약": "도둑 잡으려면 두목부터", "조건": "조직 복잡", "행동": "수뇌 공격", "목적": "조직 붕괴", "예시": "최대 주주 지분 매입"},
+    {"계": "부저이지", "요약": "가마 밑 불 끄기", "조건": "적 의존성 존재", "행동": "보급 차단", "목적": "전력 급감", "예시": "핵심 공급업체 선점"},
+    {"계": "혼수모어", "요약": "물 흐려 놓고 낚시", "조건": "판세 불투명", "행동": "혼탁 유지", "목적": "어부지리", "예시": "입법 지연 로비"},
+    {"계": "금선탈각", "요약": "허물 벗고 도망", "조건": "추적 심함", "행동": "외피만 남김", "목적": "추적 무효", "예시": "부실 자회사 떼어내기"},
+    {"계": "관문잡적", "요약": "문 닫고 잡아라", "조건": "퇴로 예측", "행동": "출구 봉쇄", "목적": "완전 포획", "예시": "락업 조항으로 지분 매집"},
+    {"계": "원교근공", "요약": "먼 데와 친해지고 가까운 데 친다", "조건": "다국 간 경쟁", "행동": "원거리 동맹", "목적": "단계적 확장", "예시": "원거리 FTA 체결 후 인근 M&A"},
+    {"계": "가도벌괵", "요약": "길 빌려 공격", "조건": "중간 세력 장벽", "행동": "통로 명분 → 제압", "목적": "장애 제거", "예시": "총판 빌미 시장 진입"},
+    {"계": "투량환주", "요약": "들보 몰래 바꿔치기", "조건": "감시 존재", "행동": "내부 교체", "목적": "인식 왜곡", "예시": "백엔드 갈아끼우기"},
+    {"계": "지상매괴", "요약": "뽕나무 가리켜 회초리 욕", "조건": "직접 비판 곤란", "행동": "제3자 지적", "목적": "메시지 전달", "예시": "싱크탱크 보고서 압박"},
+    {"계": "가치불전", "요약": "바보 연기", "조건": "상대 의심 많음", "행동": "일부러 허술", "목적": "방심 유도", "예시": "저평가 가이던스"},
+    {"계": "상옥추제", "요약": "사다리 걷어차기", "조건": "길 열어준 뒤", "행동": "퇴로 차단", "목적": "고립", "예시": "투자자 초청 후 정보 차단"},
+    {"계": "수상개화", "요약": "나무에 꽃 핀 척", "조건": "실력 부족", "행동": "외형 부풀림", "목적": "영향력 확대", "예시": "MOU ·공동 로고 홍보"},
+    {"계": "반객위주", "요약": "손님에서 주인으로", "조건": "부차적 위치", "행동": "주도권 장악", "목적": "역전 지휘", "예시": "플랫폼 입점사 자체 마켓"},
+    {"계": "미인계", "요약": "매력으로 판단 흐리기", "조건": "유혹 가능", "행동": "감정·매력 활용", "목적": "결정 왜곡", "예시": "지역 투자로 정치인 호감 얻기"},
+    {"계": "공성계", "요약": "텅 빈 성문 열어놓기", "조건": "병력 부족", "행동": "과감히 공개", "목적": "상대 의심", "예시": "내부자료 전면 공개"},
+    {"계": "반간계", "요약": "가짜 스파이 역이용", "조건": "내부 불��� 요소", "행동": "교란 정보", "목적": "분열", "예시": "경쟁사에 가짜 루머"},
+    {"계": "고육계", "요약": "살 내주고 뼈 취하기", "조건": "신뢰 상실", "행동": "스스로 손실", "목적": "진정성 증명", "예시": "CEO 보너스 반납"},
+    {"계": "연환계", "요약": "사슬로 한꺼번에", "조건": "복수 대상 다수", "행동": "연결 묶기", "목적": "효율 타격", "예시": "패키지 제재안"},
+    {"계": "주위상계", "요약": "도망이 상책", "조건": "승산 없음", "행동": "즉시 후퇴", "목적": "손실 최소·재기", "예시": "적자 시장 철수"}
+]
+
+physical_transformation_categories = {
+    # (카테고리 + 항목 대량 추가됨)
+    # ... (생략 없이 전체 포함)
+    "센서 기능": [
+        "시각 센서", "시각 감지", "청각 센서", "청각 감지", "촉각 센서", "촉각 감지",
+        "미각 센서", "미각 감지", "후각 센서", "후각 감지", "온도 센서", "온도 감지",
+        "습도 센서", "습도 감지", "압력 센서", "압력 감지", "가속도 센서", "가속도 감지",
+        "회전 센서", "회전 감지", "근접 센서", "근접 감지", "위치 센서", "위치 감지",
+        "운동 센서", "운동 감지", "가스 센서", "가스 감지", "적외선 센서", "적외선 감지",
+        "자외선 센서", "자외선 감지", "방사선 센서", "방사선 감지", "자기장 센서", "자기장 감지",
+        "전기장 센서", "전기장 감지", "화학물질 센서", "화학물질 감지", "생체신호 센서", "생체신호 감지",
+        "진동 센서", "진동 감지", "소음 센서", "소음 감지", "빛 세기 센서", "빛 세기 감지",
+        "빛 파장 센서", "빛 파장 감지", "기울기 센서", "기울기 감지", "pH 센서", "pH 감지",
+        "전류 센서", "전류 감지", "전압 센서", "전압 감지", "이미지 센서", "이미지 감지",
+        "거리 센서", "거리 감지", "깊이 센서", "깊이 감지", "중력 센서", "중력 감지",
+        "속도 센서", "속도 감지", "흐름 센서", "흐름 감지", "수위 센서", "수위 감지",
+        "탁도 센서", "탁도 감지", "염도 센서", "염도 감지", "금속 감지", "압전 센서",
+        "압전 감지", "광전 센서", "광전 감지", "열전대 센서", "열전대 감지", "홀 효과 센서",
+        "홀 효과 감지", "초음파 센서", "초음파 감지", "레이더 센서", "레이더 감지",
+        "라이다 센서", "라이다 감지", "터치 센서", "터치 감지", "제스처 센서", "제스처 감지",
+        "심박 센서", "심박 감지", "혈압 센서", "혈압 감지", "LAN", "WIFI", "블루투스", "생체 인증",
+        "다중 스펙트럼 센서", "다중 스펙트럼 감지", "깊이 인식 센서", "깊이 인식 감지",
+        "퀀텀 센서", "퀀텀 감지", "웨어러블 센서", "웨어러블 감지", "바이오마커 센서", "바이오마커 감지",
+        "임베디드 센서", "임베디드 감지", "IoT 센서 네트워크", "스트레인 센서", "스트레인 감지",
+        "경도/연도 센서", "경도/연도 감지", "5G/6G 연결성", "NFC", "양자암호화 통신",
+        "스마트 먼지 센서", "환경 센서 그리드", "신경형태학적 센서", "두뇌-기계 인터페이스"
+    ],
+    # ... (다른 카테고리 전체 항목들도 추가/수정된 상태로 포함)
+    "사용자 인터페이스 및 상호작용": [
+        "제스처 인식", "제스처 제어", "음성 인식", "음성 제어", "시선 추적", "시선 제어",
+        "촉각 피드백", "햅틱 인터페이스", "뇌-컴퓨터 인터페이스", "증강 현실 인터페이스",
+        "가상 현실 인터페이스", "혼합 현실 인터페이스", "주변 인텔리전스", "상황 인식 인터페이스",
+        "자연어 처리 인터페이스", "생체인식 인증", "다중 모달 인터페이스", "암묵적 상호작용",
+        "명시적 상호작용", "인지적 부하 최소화", "지능형 적응 인터페이스", "감정 인식 인터페이스",
+        "소셜 인터페이스", "공간 인터페이스", "신체 증강 인터페이스", "피부 인터페이스",
+        "안구 내 인터페이스", "신경 인터페이스", "근전도 인터페이스", "후각 인터페이스"
+    ],
+    # ...
+}
+
+physical_transformation_categories_en = {}  # (영문 카테고리는 사용하지 않아도 되므로 비워둠)
+
+SWOT_FRAMEWORK = {
+    "strengths": {
+        "title": "강점 (Strengths)",
+        "description": "내부적 긍정 요소 - 조직이 가진 경쟁 우위 요소",
+        "prompt_keywords": ["강점", "장점", "우위", "역량", "자산", "전문성", "strength", "advantage"]
+    },
+    "weaknesses": {
+        "title": "약점 (Weaknesses)",
+        "description": "내부적 부정 요소 - 개선이 필요한 내부 한계",
+        "prompt_keywords": ["약점", "단점", "부족", "한계", "취약점", "weakness", "limitation", "deficit"]
+    },
+    "opportunities": {
+        "title": "기회 (Opportunities)",
+        "description": "외부적 긍정 요소 - 활용 가능한 외부 환경 변화",
+        "prompt_keywords": ["기회", "가능성", "트렌드", "변화", "성장", "opportunity", "trend", "potential"]
+    },
+    "threats": {
+        "title": "위협 (Threats)",
+        "description": "외부적 부정 요소 - 대응이 필요한 외부 위험 요소",
+        "prompt_keywords": ["위협", "리스크", "경쟁", "위험", "장벽", "threat", "risk", "competition", "barrier"]
+    }
+}
+
+PORTER_FRAMEWORK = {
+    "rivalry": {
+        "title": "기존 경쟁자 간의 경쟁",
+        "description": "동일 산업 내 경쟁 강도 분석",
+        "prompt_keywords": ["경쟁", "경쟁사", "시장점유율", "가격경쟁", "competition", "rival", "market share"]
+    },
+    "new_entrants": {
+        "title": "신규 진입자의 위협",
+        "description": "새로운 기업의 시장 진입 난이도 분석",
+        "prompt_keywords": ["진입장벽", "신규", "스타트업", "entry barrier", "newcomer", "startup"]
+    },
+    "substitutes": {
+        "title": "대체재의 위협",
+        "description": "대체 가능한 제품/서비스의 위협 분석",
+        "prompt_keywords": ["대체재", "대안", "substitute", "alternative", "replacement"]
+    },
+    "buyer_power": {
+        "title": "구매자의 교섭력",
+        "description": "고객의 가격 협상력 분석",
+        "prompt_keywords": ["고객", "구매자", "가격민감도", "협상력", "customer", "buyer power"]
+    },
+    "supplier_power": {
+        "title": "공급자의 교섭력",
+        "description": "공급업체의 가격/조건 협상력 분석",
+        "prompt_keywords": ["공급자", "벤더", "원재료", "supplier", "vendor", "raw material"]
+    }
+}
+
+BCG_FRAMEWORK = {
+    "stars": {
+        "title": "스타 (Stars)",
+        "description": "높은 성장률, 높은 시장점유율 - 추가 투자 필요",
+        "prompt_keywords": ["성장", "점유율", "중점", "투자", "star", "growth", "investment"]
+    },
+    "cash_cows": {
+        "title": "현금젖소 (Cash Cows)",
+        "description": "낮은 성장률, 높은 시장점유율 - 현금흐름 창출",
+        "prompt_keywords": ["안정", "수익", "현금", "전통", "cash cow", "profit", "mature"]
+    },
+    "question_marks": {
+        "title": "물음표 (Question Marks)",
+        "description": "높은 성장률, 낮은 시장점유율 - 선택적 투자/철수",
+        "prompt_keywords": ["가능성", "위험", "불확실", "잠재", "question mark", "uncertain", "potential"]
+    },
+    "dogs": {
+        "title": "개 (Dogs)",
+        "description": "낮은 성장률, 낮은 시장점유율 - 철수 고려",
+        "prompt_keywords": ["회수", "철수", "저성장", "비효율", "dog", "divest", "low growth"]
+    }
+}
+
+BUSINESS_FRAMEWORKS = {
+    "sunzi": "손자병법 36계",
+    "swot": "SWOT 분석",
+    "porter": "Porter의 5 Forces",
+    "bcg": "BCG 매트릭스"
+}
+
+@dataclass
+class Category:
+    """통일된 카테고리 및 항목 구조"""
+    name_ko: str
+    name_en: str
+    tags: list[str]
+    items: list[str]
+
+# ──────────────────────────────── 프레임워크 분석 함수들 ─────────────────────────
+def analyze_with_swot(prompt: str) -> dict:
+    prompt_lower = prompt.lower()
+    results = {}
+    for category, info in SWOT_FRAMEWORK.items():
+        score = sum(1 for keyword in info["prompt_keywords"] if keyword.lower() in prompt_lower)
+        keywords = []
+        for keyword in info["prompt_keywords"]:
+            if keyword.lower() in prompt_lower:
+                pattern = f".{{0,15}}{keyword}.{{0,15}}"
+                matches = re.findall(pattern, prompt_lower, re.IGNORECASE)
+                for match in matches[:2]:
+                    keywords.append(match.strip())
+        results[category] = {
+            "title": info["title"],
+            "description": info["description"],
+            "score": score,
+            "keywords": keywords[:5]
+        }
+    return results
+
+def analyze_with_porter(prompt: str) -> dict:
+    prompt_lower = prompt.lower()
+    results = {}
+    for category, info in PORTER_FRAMEWORK.items():
+        score = sum(1 for keyword in info["prompt_keywords"] if keyword.lower() in prompt_lower)
+        keywords = []
+        for keyword in info["prompt_keywords"]:
+            if keyword.lower() in prompt_lower:
+                pattern = f".{{0,15}}{keyword}.{{0,15}}"
+                matches = re.findall(pattern, prompt_lower, re.IGNORECASE)
+                for match in matches[:2]:
+                    keywords.append(match.strip())
+        results[category] = {
+            "title": info["title"],
+            "description": info["description"],
+            "score": score,
+            "keywords": keywords[:5]
+        }
+    return results
+
+def analyze_with_bcg(prompt: str) -> dict:
+    prompt_lower = prompt.lower()
+    results = {}
+    for category, info in BCG_FRAMEWORK.items():
+        score = sum(1 for keyword in info["prompt_keywords"] if keyword.lower() in prompt_lower)
+        keywords = []
+        for keyword in info["prompt_keywords"]:
+            if keyword.lower() in prompt_lower:
+                pattern = f".{{0,15}}{keyword}.{{0,15}}"
+                matches = re.findall(pattern, prompt_lower, re.IGNORECASE)
+                for match in matches[:2]:
+                    keywords.append(match.strip())
+        results[category] = {
+            "title": info["title"],
+            "description": info["description"],
+            "score": score,
+            "keywords": keywords[:5]
+        }
+    return results
+
+def format_business_framework_analysis(framework_type: str, analysis_result: dict) -> str:
+    if not analysis_result:
+        return ""
+    titles = {
+        'swot': '# SWOT 분석 결과',
+        'porter': '# Porter의 5 Forces 분석 결과',
+        'bcg': '# BCG 매트릭스 분석 결과'
+    }
+    md = f"{titles.get(framework_type, '# 경영 프레임워크 분석')}\n\n"
+    md += "각 요소별 텍스트 분석 점수와 관련 키워드입니다.\n\n"
+    for category, info in analysis_result.items():
+        md += f"## {info['title']}\n\n"
+        md += f"{info['description']}\n\n"
+        md += f"**관련성 점수**: {info['score']}\n\n"
+        if info['keywords']:
+            md += "**관련 키워드 및 컨텍스트**:\n"
+            for keyword in info['keywords']:
+                md += f"- *{keyword}*\n"
+            md += "\n"
+        else:
+            md += "관련 키워드가 발견되지 않았습니다.\n\n"
+    return md
+
+# ──────────────────────────────── 마크다운 → HTML 변환 ─────────────────────────
+def md_to_html(md_text: str, title: str = "Output") -> str:
+    html_content = markdown.markdown(
+        md_text,
+        extensions=['tables', 'fenced_code', 'codehilite']
+    )
+    return f"""<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>{title}</title>
+    <style>
+        body {{
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+            line-height: 1.6;
+            color: #333;
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 20px;
+        }}
+        h1, h2, h3, h4, h5, h6 {{
+            margin-top: 24px;
+            margin-bottom: 16px;
+            font-weight: 600;
+            line-height: 1.25;
+        }}
+        h1 {{ font-size: 2em; color: #0366d6; }}
+        h2 {{ font-size: 1.5em; color: #0366d6; border-bottom: 1px solid #eaecef; padding-bottom: .3em; }}
+        h3 {{ font-size: 1.25em; color: #0366d6; }}
+        p, ul, ol {{ margin-bottom: 16px; }}
+        a {{ color: #0366d6; text-decoration: none; }}
+        a:hover {{ text-decoration: underline; }}
+        code {{
+            font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, monospace;
+            background-color: rgba(27, 31, 35, 0.05);
+            border-radius: 3px;
+            font-size: 85%;
+            padding: 0.2em 0.4em;
+        }}
+        pre {{
+            background-color: #f6f8fa;
+            border-radius: 3px;
+            font-size: 85%;
+            line-height: 1.45;
+            overflow: auto;
+            padding: 16px;
+        }}
+        pre code {{
+            background-color: transparent;
+            padding: 0;
+        }}
+        blockquote {{
+            border-left: 4px solid #dfe2e5;
+            color: #6a737d;
+            margin: 0;
+            padding: 0 1em;
+        }}
+        table {{
+            border-collapse: collapse;
+            width: 100%;
+            margin-bottom: 16px;
+        }}
+        table th, table td {{
+            border: 1px solid #dfe2e5;
+            padding: 6px 13px;
+        }}
+        table th {{
+            background-color: #f6f8fa;
+            font-weight: 600;
+        }}
+        img {{
+            max-width: 100%;
+            height: auto;
+        }}
+        hr {{
+            border: 0;
+            height: 1px;
+            background-color: #dfe2e5;
+            margin: 24px 0;
+        }}
+    </style>
+</head>
+<body>
+    {html_content}
+    <hr>
+    <footer>
+        <p><small>Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} |
+        Created by <a href="https://discord.gg/openfreeai" target="_blank">VIDraft</a>
+        </small></p>
+    </footer>
+</body>
+</html>
+"""
+
+# ──────────────────────────────── 업로드 파일 처리 함수 ─────────────────────
+def process_text_file(uploaded_file):
+    try:
+        content = uploaded_file.read().decode('utf-8')
+        return f"""# 업로드된 텍스트 파일: {uploaded_file.name}
+
+{content}
+"""
+    except Exception as e:
+        logging.error(f"텍스트 파일 처리 오류: {str(e)}")
+        return f"**Error processing {uploaded_file.name}**: {str(e)}"
+
+def process_csv_file(uploaded_file):
+    try:
+        df = pd.read_csv(uploaded_file)
+        return f"""# 업로드된 CSV 파일: {uploaded_file.name}
+
+## 기본 정보
+- 행 수: {df.shape[0]}
+- 열 수: {df.shape[1]}
+- 열 이름: {', '.join(df.columns.tolist())}
+
+## 첫 5행 데이터 미리보기
+{df.head(5).to_markdown(index=False)}
+
+## 기본 통계
+{df.describe().to_markdown()}
+"""
+    except Exception as e:
+        logging.error(f"CSV 파일 처리 오류: {str(e)}")
+        return f"**Error processing {uploaded_file.name}**: {str(e)}"
+
+def process_pdf_file(uploaded_file):
+    try:
+        file_bytes = uploaded_file.read()
+        pdf_file   = io.BytesIO(file_bytes)
+        reader     = PyPDF2.PdfReader(pdf_file, strict=False)
+
+        pages_preview = []
+        for page_num in range(min(5, len(reader.pages))):
+            page = reader.pages[page_num]
+            pages_preview.append(f"--- Page {page_num+1} ---\n{page.extract_text()}")
+
+        preview_text = "\n\n".join(pages_preview)
+        return f"""# 업로드된 PDF 파일: {uploaded_file.name}
+
+## 기본 정보
+- 총 페이지 수: {len(reader.pages)}
+
+## 처음 5개 페이지 내용 미리보기
+{preview_text}
+"""
+    except Exception as e:
+        logging.error(f"PDF 파일 처리 오류: {str(e)}")
+        return f"**Error processing {uploaded_file.name}**: {str(e)}"
+
+def process_uploaded_files(uploaded_files):
+    """Process all uploaded files and return their content as markdown."""
+    if not uploaded_files:
+        return ""
+    file_contents = []
+    for file in uploaded_files:
+        try:
+            ext = file.name.split('.')[-1].lower()
+            if ext == 'txt':
+                file_contents.append(process_text_file(file))
+                file.seek(0)
+            elif ext == 'csv':
+                file_contents.append(process_csv_file(file))
+                file.seek(0)
+            elif ext == 'pdf':
+                file_contents.append(process_pdf_file(file))
+                file.seek(0)
+            else:
+                file_contents.append(
+                    f"# Unsupported file: {file.name}\n\nThis file type is not supported for processing."
+                )
+        except Exception as e:
+            logging.error(f"파일 처리 오류 {file.name}: {str(e)}")
+            file_contents.append(f"# Error processing file: {file.name}\n\n{str(e)}")
+
+    return "\n\n# 사용자 업로드 파일 분석\n\n" + "\n\n---\n\n".join(file_contents)
+
+# ──────────────────────────────── 이미지 생성 함수 ──────────────────────
+def generate_image(prompt: str):
+    if not prompt:
+        return None, None
+    try:
+        clean_prompt = prompt.strip("\"'").strip()
+        if len(clean_prompt) < 3:
+            return None, None
+        logging.info(f"Sending image generation request with prompt: {clean_prompt}")
+
+        res = Client(IMAGE_API_URL).predict(
+            prompt=clean_prompt,
+            width=768,
+            height=768,
+            guidance=3.5,
+            inference_steps=30,
+            seed=3,
+            do_img2img=False,
+            init_image=None,
+            image2image_strength=0.8,
+            resize_img=True,
+            api_name="/generate_image"
+        )
+        if res and len(res) >= 2 and res[0]:
+            logging.info("Successfully received image data")
+            return res[0], clean_prompt
+        else:
+            logging.warning(f"Invalid response format from image API: {res}")
+            return None, None
+    except Exception as e:
+        logging.error(f"Image generation error: {str(e)}", exc_info=True)
+        return None, None
+
+# ──────────────────────────────── Kaggle API 관련 ───────────────────────
+@st.cache_resource
+def check_kaggle_availability():
+    if not KAGGLE_API_KEY:
+        logging.warning("Kaggle API를 사용할 수 없습니다. (KAGGLE_KEY가 비어 있음)")
+        return False
+    return True
+
+def extract_kaggle_search_keywords(prompt, top=3):
+    clean_text = re.sub(r'[^\w\s]', ' ', prompt.lower())
+    stop_words = {
+        'the', 'a', 'an', 'in', 'on', 'at', 'of', 'for', 'to', 'by',
+        '와', '과', '은', '는', '이', '가', '을', '를', '에', '에서', '으로'
+    }
+    words = [word for word in clean_text.split() if word not in stop_words and len(word) > 1]
+    word_freq = Counter(words)
+    top_words = [word for word, _ in word_freq.most_common(top)]
+    if not top_words and words:
+        top_words = words[:min(top, len(words))]
+    return " ".join(top_words)
+
+def search_kaggle_datasets(query: str, top: int = 5) -> list[dict]:
+    if not query:
+        return []
+    q_tokens = set(re.findall(r'[a-zA-Z가-힣]{2,}', query.lower()))
+    scored = []
+    for ds in KAGGLE_DATASETS.values():
+        tokens = set(t.lower() for t in ds["keywords"])
+        score  = len(q_tokens & tokens)
+        title_hit = any(tok in ds["title"].lower() for tok in q_tokens)
+        sub_hit   = any(tok in ds["subtitle"].lower() for tok in q_tokens)
+        if title_hit:
+            score += 2
+        if sub_hit:
+            score += 1
+        if score > 0:
+            scored.append((score, ds))
+    scored.sort(key=lambda x: (-x[0], x[1]["ref"]))
+    return [ds for _, ds in scored[:top]]
+
+@st.cache_data
+def download_and_analyze_dataset(dataset_ref: str, max_rows: int = 1000):
+    if not (os.getenv("KAGGLE_USERNAME") and os.getenv("KAGGLE_KEY")):
+        return "Kaggle API 인증정보가 없습니다."
+    api = KaggleApi()
+    api.authenticate()
+    tmpdir = tempfile.mkdtemp()
+    try:
+        api.dataset_download_files(dataset_ref, path=tmpdir, unzip=True)
+    except Exception as e:
+        logging.error(f"Dataset download failed ({dataset_ref}): {e}")
+        shutil.rmtree(tmpdir)
+        return f"데이터셋 다운로드 오류: {e}"
+
+    csv_files = glob.glob(f"{tmpdir}/**/*.csv", recursive=True)
+    if not csv_files:
+        shutil.rmtree(tmpdir)
+        return "CSV 파일을 찾을 수 없습니다."
+
+    try:
+        df = pd.read_csv(csv_files[0], nrows=max_rows)
+        analysis = {
+            "shape": df.shape,
+            "columns": df.columns.tolist(),
+            "head": df.head().to_dict("records"),
+            "describe": df.describe().to_dict(),
+            "missing_values": df.isnull().sum().to_dict()
+        }
+    except Exception as e:
+        analysis = f"CSV 파싱 오류: {e}"
+
+    shutil.rmtree(tmpdir)
+    return analysis
+
+def format_kaggle_analysis_markdown_multi(analyses: list[dict]) -> str:
+    """
+    여러 Kaggle 데이터셋(최대 3개) 메타‧분석 결과를 한꺼번에 마크다운으로 반환
+    analyses = [ {"meta": {...}, "analysis": {... or str}}, ... ]
+    """
+    if not analyses:
+        return "# Kaggle 데이터셋\n\n관련 데이터셋을 찾을 수 없습니다.\n\n"
+    md = "# Kaggle 데이터셋 분석 결과\n\n"
+    md += "다음 데이터셋을 검토하여 아이디어 형성에 참고하세요.\n\n"
+    for i, item in enumerate(analyses, 1):
+        ds  = item["meta"]
+        ana = item["analysis"]
+        md += f"## {i}. {ds['title']}\n\n"
+        md += f"{ds['subtitle']}\n\n"
+        md += f"- **참조** : {ds['ref']}\n"
+        md += f"- **URL** : [{ds['url']}]({ds['url']})\n\n"
+        if isinstance(ana, dict):
+            md += f"**행 × 열** : {ana['shape'][0]} × {ana['shape'][1]}\n\n"
+            md += "<details><summary>미리보기 & 통계 (펼치기)</summary>\n\n"
+            try:
+                md += pd.DataFrame(ana["head"]).to_markdown(index=False) + "\n\n"
+            except:
+                pass
+            try:
+                md += pd.DataFrame(ana["describe"]).to_markdown() + "\n\n"
+            except:
+                pass
+            md += "</details>\n\n"
+        else:
+            md += f"{ana}\n\n"
+        md += "---\n\n"
+    return md
+
+# ──────────────────────────────── OpenAI Client ──────────────────────────
+@st.cache_resource
+def get_openai_client():
+    if not OPENAI_API_KEY:
+        raise RuntimeError("⚠️ OPENAI_API_KEY 환경 변수가 설정되지 않았습니다.")
+    return OpenAI(
+        api_key=OPENAI_API_KEY,
+        timeout=60.0,
+        max_retries=3
+    )
+
+# ──────────────────────────────── 의사결정 목적/제약 식별 (이제 디자인/발명 목적) ─────────────────────
+def identify_decision_purpose(prompt: str) -> dict:
+    """
+    디자인/발명과 관련된 주요 목적이나 제약을 대략적으로 식별.
+    (기존의 의사결정 목적/제약 식별 로직을 재활용하되,
+     design/invention 관련 키워드도 추가로 고려할 수 있음.)
+    """
+    purpose_patterns = {
+        'cost_reduction': [r'비용(\s*절감)?', r'예산', r'효율', r'저렴', r'경제', r'cost', r'saving', r'budget'],
+        'innovation': [r'혁신', r'새로운', r'창의', r'개발', r'발명', r'innovation', r'creative', r'develop'],
+        'risk_management': [r'위험', r'리스크', r'안전', r'예방', r'대비', r'risk', r'safety', r'prevent'],
+        'growth': [r'성장', r'확장', r'증가', r'확대', r'매출', r'growth', r'expand', r'increase', r'scale'],
+        'customer': [r'고객', r'사용자', r'만족', r'경험', r'서비스', r'customer', r'user', r'experience']
+    }
+    constraint_patterns = {
+        'time': [r'시간', r'빠르게', r'긴급', r'마감', r'기한', r'time', r'deadline', r'urgent'],
+        'budget': [r'저예산', r'자금', r'투자', r'재정', r'budget', r'finance', r'fund', r'investment'],
+        'resources': [r'자원', r'인력', r'장비', r'제한', r'resource', r'staff', r'equipment', r'limited'],
+        'regulation': [r'규제', r'법률', r'규정', r'준수', r'법적', r'regulation', r'legal', r'compliance']
+    }
+    purpose_scores = {}
+    for purpose, patterns in purpose_patterns.items():
+        score = sum(1 for pattern in patterns if re.search(pattern, prompt, re.IGNORECASE))
+        if score > 0:
+            purpose_scores[purpose] = score
+    constraint_scores = {}
+    for constraint, patterns in constraint_patterns.items():
+        score = sum(1 for pattern in patterns if re.search(pattern, prompt, re.IGNORECASE))
+        if score > 0:
+            constraint_scores[constraint] = score
+    main_purposes = sorted(purpose_scores.items(), key=lambda x: x[1], reverse=True)[:2]
+    main_constraints = sorted(constraint_scores.items(), key=lambda x: x[1], reverse=True)[:2]
+    return {
+        'purposes': main_purposes,
+        'constraints': main_constraints,
+        'all_purpose_scores': purpose_scores,
+        'all_constraint_scores': constraint_scores
+    }
+
+# ──────────────────────────────── 카테고리 유틸 ─────────────────────────
+def keywords(text: str, top: int = 8) -> str:
+    words = re.findall(r'\b[a-zA-Z가-힣]{2,}\b', text.lower())
+    stopwords = {
+        'the', 'a', 'an', 'of', 'to', 'in', 'for', 'on', 'by', 'and', 'is', 'are', 'was', 'were',
+        'be', 'been', 'being', 'with', 'as', 'at', 'that', 'this', 'these', 'those', 'from', 'not',
+        '이', '그', '저', '것', '수', '등', '를', '을', '에', '에서', '그리고', '하는', '있는', '것은',
+        '있다', '그것', '또한', '또', '및', '이런', '그런', '무엇', '어떤', '많은', '한', '두', '몇'
+    }
+    words = [word for word in words if word not in stopwords]
+    word_freq = {}
+    for word in words:
+        word_freq[word] = word_freq.get(word, 0) + 1
+    sorted_words = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)
+    top_words = [word for word, _ in sorted_words[:top]]
+    return ' '.join(top_words)
+
+def compute_relevance_scores(prompt: str, categories: list[Category]) -> dict:
+    """
+    디자인/발명 관점에서, 입력 프롬프트가 어떤 카테고리의 항목들과 관련성이 높은지 스코어링.
+    """
+    prompt_lower = prompt.lower()
+    prompt_tokens = set(re.findall(r'\b[a-zA-Z가-힣]{2,}\b', prompt_lower))
+    purpose_keywords = {
+        'cost_reduction': ['비용', '절감', '효율', '예산', 'cost', 'saving', 'budget', 'efficiency'],
+        'innovation': ['혁신', '창의', '신규', '개발', 'innovation', 'creative', 'novel', 'development', '발명', '디자인'],
+        'risk_management': ['위험', '리스크', '관리', '예방', 'risk', 'management', 'prevention', 'mitigation'],
+        'growth': ['성장', '확장', '증가', '규모', 'growth', 'expansion', 'increase', 'scale'],
+        'customer': ['사용자', '고객', '만족', '경험', 'user', 'customer', 'satisfaction', 'experience']
+    }
+    purpose_scores = {}
+    for purpose, keywords_ in purpose_keywords.items():
+        score = sum(1 for kw in keywords_ if kw in prompt_lower)
+        if score > 0:
+            purpose_scores[purpose] = score
+    main_purpose = max(purpose_scores.items(), key=lambda x: x[1])[0] if purpose_scores else None
+
+    relevance_scores = {}
+    for category in categories:
+        cat_score = sum(1 for tag in category.tags if tag in prompt_lower) * 0.5
+        if category.name_ko in prompt or category.name_en.lower() in prompt_lower:
+            cat_score += 1
+
+        # 약간의 목적별 가중치 적용
+        if main_purpose:
+            purpose_category_weights = {
+                'cost_reduction': {
+                    '구조적 변화': 1.5, '화학적 변화': 1.3, '비즈니스 아이디어': 1.5,
+                },
+                'innovation': {
+                    '센서 기능': 1.5, '표면 및 외관 변화': 1.3, '비즈니스 아이디어': 1.5,
+                },
+                'risk_management': {
+                    '환경 상호작용': 1.5, '시간 관련 변화': 1.3, '비즈니스 아이디어': 1.4,
+                },
+                'growth': {
+                    '크기와 형태 변화': 1.4, '비즈니스 아이디어': 1.6, '구조적 변화': 1.3,
+                },
+                'customer': {
+                    '표면 및 외관 변화': 1.5, '센서 기능': 1.4, '빛과 시각 효과': 1.3, '비즈니스 아이디어': 1.4,
+                }
+            }
+            if category.name_ko in purpose_category_weights.get(main_purpose, {}):
+                cat_score *= purpose_category_weights[main_purpose][category.name_ko]
+            elif category.name_en in purpose_category_weights.get(main_purpose, {}):
+                cat_score *= purpose_category_weights[main_purpose][category.name_en]
+
+        # 항목별 토큰 매칭
+        for item in category.items:
+            item_score = cat_score
+            item_tokens = set(re.findall(r'\b[a-zA-Z가-힣]{2,}\b', item.lower()))
+            matches = item_tokens.intersection(prompt_tokens)
+            if matches:
+                item_score += len(matches) * 0.3
+            if item_score > 0:
+                relevance_scores[(category.name_ko, item)] = item_score
+    return relevance_scores
+
+def compute_score(weight: int, impact: int, confidence: float) -> float:
+    return round(weight * impact * confidence, 2)
+
+def generate_comparison_matrix(
+    categories: list[Category],
+    relevance_scores: dict = None,
+    max_depth: int = 3,
+    max_combinations: int = 100,
+    relevance_threshold: float = 0.2
+) -> list[tuple]:
+    """
+    여러 카테고리의 요소를 복합적으로 조합한 '아이디어' 후보를 뽑아내는 매트릭스.
+    (본래 의사결정 매트릭스였으나, 디자인/발명에 맞게 재활용)
+    """
+    if relevance_scores is None:
+        pool = [(c.name_ko, item) for c in categories for item in c.items]
+        basic_combos = []
+        for depth in range(2, max_depth + 1):
+            for combo in combinations(pool, depth):
+                basic_combos.append((1, 1, 1.0, 1.0, combo))
+                if len(basic_combos) >= max_combinations:
+                    break
+        return basic_combos[:max_combinations]
+
+    filtered_pool = [
+        (cat, item) for (cat, item), score in relevance_scores.items()
+        if score >= relevance_threshold
+    ]
+    if not filtered_pool:
+        pool = [(c.name_ko, i) for c in categories for i in c.items]
+        if len(pool) > 200:
+            import random
+            filtered_pool = random.sample(pool, 200)
+        else:
+            filtered_pool = pool
+
+    evaluated_combinations = []
+    for depth in range(2, max_depth + 1):
+        for combo in combinations(filtered_pool, depth):
+            if len({item[0] for item in combo}) == depth:
+                combo_relevance = sum(relevance_scores.get((item[0], item[1]), 0) for item in combo) / depth
+                weight = min(5, max(1, int(combo_relevance * 2)))
+                impact = min(5, depth)
+                confidence = min(1.0, combo_relevance / 2.5)
+                total_score = compute_score(weight, impact, confidence)
+                evaluated_combinations.append((weight, impact, confidence, total_score, combo))
+    evaluated_combinations.sort(key=lambda x: x[3], reverse=True)
+    return evaluated_combinations[:max_combinations]
+
+# ──────────────────────────────── Diverse Matrix Generator ────────────────────
+def smart_weight(cat_name, item, relevance, global_cnt, T):
+    rare_boost = 1 / (global_cnt.get(item, 0) + 0.5)
+    noise = random.random() ** (1 / T)  # T가 클수록 noise가 1에 가까움
+    relevance_weight = 1 - (T - 0.1) / 3.0
+    return ((relevance * relevance_weight) + 0.1) * rare_boost * noise
+
+def generate_random_comparison_matrix(
+    categories: list[Category],
+    relevance_scores: dict | None = None,
+    k_cat=(8, 12),
+    n_item=(6, 10),
+    depth_range=(3, 6),
+    max_combos=1000,
+    seed: int | None = None,
+    T: float = 1.3,
+):
+    """
+    다양성 있게 여러 카테고리/항목들을 조합하여 무작위 매트릭스를 생성.
+    (디자인/발명 아이디어 확장 시 유용)
+    """
+    if seed is None:
+        seed = random.randrange(2 ** 32)
+    random.seed(seed)
+    if "GLOBAL_PICK_COUNT" not in st.session_state:
+        st.session_state.GLOBAL_PICK_COUNT = {}
+    global_cnt = st.session_state.GLOBAL_PICK_COUNT
+
+    k = random.randint(*k_cat)
+    sampled_cats = random.sample(categories, k)
+    pool = []
+    for cat in sampled_cats:
+        items   = cat.items
+        weights = [
+            smart_weight(
+                cat.name_ko,
+                it,
+                relevance_scores.get((cat.name_ko, it), 0.05) if relevance_scores else 0.05,
+                global_cnt,
+                T
+            )
+            for it in items
+        ]
+        n = min(len(items), random.randint(*n_item))
+        sampled_items = random.choices(items, weights=weights, k=n)
+        for it in sampled_items:
+            global_cnt[it] = global_cnt.get(it, 0) + 1
+            pool.append((cat.name_ko, it))
+    combos = []
+    for d in range(depth_range[0], depth_range[1] + 1):
+        for combo in combinations(pool, d):
+            if len({c for c, _ in combo}) != d:
+                continue
+            w = sum(relevance_scores.get((c, i), 0.2) if relevance_scores else 1 for c, i in combo) / d
+            imp  = d
+            conf = 0.5 + random.random() * 0.5
+            total = compute_score(w, imp, conf)
+            combos.append((w, imp, conf, total, combo))
+    combos.sort(key=lambda x: x[3], reverse=True)
+    return combos[:max_combos]
+
+# ──────────────────────────────── PHYS_CATEGORIES ────────────────────────
+PHYS_CATEGORIES: list[Category] = [
+    Category(
+        name_ko="센서 기능",
+        name_en="Sensor Functions",
+        tags=["sensor", "detection", "감지"],
+        items=physical_transformation_categories["센서 기능"]
+    ),
+    Category(
+        name_ko="크기와 형태 변화",
+        name_en="Size and Shape Change",
+        tags=["shape", "geometry", "크기"],
+        items=physical_transformation_categories["크기와 형태 변화"]
+    ),
+    Category(
+        name_ko="표면 및 외관 변화",
+        name_en="Surface and Appearance Change",
+        tags=["surface", "appearance", "표면"],
+        items=physical_transformation_categories["표면 및 외관 변화"]
+    ),
+    Category(
+        name_ko="물질의 상태 변화",
+        name_en="Material State Change",
+        tags=["material", "state", "상태"],
+        items=physical_transformation_categories["물질의 상태 변화"]
+    ),
+    Category(
+        name_ko="움직임 특성 변화",
+        name_en="Movement Characteristics Change",
+        tags=["motion", "dynamics", "움직임"],
+        items=physical_transformation_categories["움직임 특성 변화"]
+    ),
+    Category(
+        name_ko="구조적 변화",
+        name_en="Structural Change",
+        tags=["structure", "form", "구조"],
+        items=physical_transformation_categories["구조적 변화"]
+    ),
+    Category(
+        name_ko="공간 이동",
+        name_en="Spatial Movement",
+        tags=["movement", "space", "이동"],
+        items=physical_transformation_categories["공간 이동"]
+    ),
+    Category(
+        name_ko="시간 관련 변화",
+        name_en="Time-Related Change",
+        tags=["time", "aging", "시간"],
+        items=physical_transformation_categories["시간 관련 변화"]
+    ),
+    Category(
+        name_ko="빛과 시각 효과",
+        name_en="Light and Visual Effects",
+        tags=["light", "visual", "빛"],
+        items=physical_transformation_categories["빛과 시각 효과"]
+    ),
+    Category(
+        name_ko="소리와 진동 효과",
+        name_en="Sound and Vibration Effects",
+        tags=["sound", "vibration", "소리"],
+        items=physical_transformation_categories["소리와 진동 효과"]
+    ),
+    Category(
+        name_ko="열 관련 변화",
+        name_en="Thermal Changes",
+        tags=["heat", "thermal", "온도"],
+        items=physical_transformation_categories["열 관련 변화"]
+    ),
+    Category(
+        name_ko="전기 및 자기 변화",
+        name_en="Electrical and Magnetic Changes",
+        tags=["electric", "magnetic", "전기"],
+        items=physical_transformation_categories["전기 및 자기 변화"]
+    ),
+    Category(
+        name_ko="화학적 변화",
+        name_en="Chemical Change",
+        tags=["chemical", "reaction", "화학"],
+        items=physical_transformation_categories["화학적 변화"]
+    ),
+    Category(
+        name_ko="생물학적 변화",
+        name_en="Biological Change",
+        tags=["bio", "living", "생물"],
+        items=physical_transformation_categories["생물학적 변화"]
+    ),
+    Category(
+        name_ko="환경 상호작용",
+        name_en="Environmental Interaction",
+        tags=["environment", "interaction", "환경"],
+        items=physical_transformation_categories["환경 상호작용"]
+    ),
+    Category(
+        name_ko="비즈니스 아이디어",
+        name_en="Business Ideas",
+        tags=["business", "idea", "비즈니스"],
+        items=physical_transformation_categories["비즈니스 아이디어"]
+    ),
+    Category(
+        name_ko="사용자 인터페이스 및 상호작용",
+        name_en="User Interface and Interaction",
+        tags=["interface", "interaction", "인터페이스"],
+        items=physical_transformation_categories["사용자 인터페이스 및 상호작용"]
+    ),
+    Category(
+        name_ko="데이터 및 정보 변환",
+        name_en="Data and Information Transformation",
+        tags=["data", "information", "데이터"],
+        items=physical_transformation_categories["데이터 및 정보 변환"]
+    ),
+    Category(
+        name_ko="인지 및 심리적 변화",
+        name_en="Cognitive and Psychological Changes",
+        tags=["cognitive", "psychology", "인지"],
+        items=physical_transformation_categories["인지 및 심리적 변화"]
+    ),
+    Category(
+        name_ko="에너지 변환 및 관리",
+        name_en="Energy Conversion and Management",
+        tags=["energy", "power", "에너지"],
+        items=physical_transformation_categories["에너지 변환 및 관리"]
+    ),
+    Category(
+        name_ko="지속가��성 및 환경 영향",
+        name_en="Sustainability and Environmental Impact",
+        tags=["sustainability", "eco", "지속가능"],
+        items=physical_transformation_categories["지속가능성 및 환경 영향"]
+    ),
+    Category(
+        name_ko="보안 및 프라이버시",
+        name_en="Security and Privacy",
+        tags=["security", "privacy", "보안"],
+        items=physical_transformation_categories["보안 및 프라이버시"]
+    ),
+    Category(
+        name_ko="사회적 상호작용 및 협업",
+        name_en="Social Interaction and Collaboration",
+        tags=["social", "collaboration", "협업"],
+        items=physical_transformation_categories["사회적 상호작용 및 협업"]
+    ),
+    Category(
+        name_ko="미학 및 감성 경험",
+        name_en="Aesthetics and Emotional Experience",
+        tags=["aesthetics", "emotion", "감성"],
+        items=physical_transformation_categories["미학 및 감성 경험"]
+    )
+]
+
+# ──────────────────────────────── 시스템 프롬프트 생성 ─────────────────────
+def get_idea_system_prompt(selected_category: str | None = None,
+                           selected_frameworks: list | None = None) -> str:
+    """
+    [디자인/발명 전용] 시스템 프롬프트.
+    """
+    cat_clause = (
+        f'\n**추가 지침**: 선택된 카테고리 "{selected_category}"에 특별한 주의를 기울이십시오. '
+        f'이 카테고리의 항목들을 아이디어 발상 전 과정에 우선 고려하세요.\n'
+    ) if selected_category else ""
+
+    # (기존에 'sunzi','swot','porter','bcg' 등 사용했으나, 이제 디자인/발명 위주이므로 최소화)
+    if not selected_frameworks:
+        selected_frameworks = []
+
+    # 새 목적: 디자인/발명 아이디어 착안
+    framework_instruction   = "\n\n### (디자인/발명) 활용 프레임워크\n"
+    framework_output_format = ""
+
+    # 프레임워크 사용 예시(원한다면 "sunzi" 등 사용 가능)
+    for fw in selected_frameworks:
+        if fw == "sunzi":
+            framework_instruction += "- **손자병법 36계**: 창의적 전략으로 발명 아이디어에 적용\n"
+            framework_output_format += """
+## 손자병법 관점에서의 창의 아이디어
+(원하는 경우에 사용)
+"""
+        elif fw == "swot":
+            framework_instruction += "- **SWOT 분석**: 내부/외부 요소 고려하여 발명 방향성 탐색\n"
+        elif fw == "porter":
+            framework_instruction += "- **Porter의 5 Forces**: 시장/환경 관점에서 디자인 요구 파악\n"
+        elif fw == "bcg":
+            framework_instruction += "- **BCG 매트릭스**: 발명 아이템 포트폴리오적 관점으로 접근\n"
+
+    base_prompt = f"""
+당신은 창의적 디자인/발명 전문가 AI입니다.  
+사용자의 텍스트(질문이나 아이디어 방향)를 분석하여, **새로운 발명/디자인 아이디어**를 구체적으로 제시하고,  
+필요하다면 여러 관련 **데이터/자료**를 활용하여 통찰력을 보강하십시오.
+
+1) 문제/목표 분석:  
+   - 사용자가 말한 디자인/발명 목적·키워드를 파악,  
+   - 연관되는 카테고리 및 항목 식별
+
+2) 카테고리 매핑 및 아이디어 스케치:  
+   - 다양한 물리적/화학적/구조적/환경적 범주의 요소가 어떻게 아이디어에 적용 가능한지 서술  
+   - 관련 데이터(웹검색, Kaggle 등)도 참조 가능
+
+3) 종합 아이디어 제안:  
+   - 상위 2~3가지 주요 디자인/발명 방향 제시  
+   - 구체적으로 구현 가능성, 예상 기능, 장단점, 확장성, 위험 요소 등 분석
+
+{framework_instruction}
+
+### 최종 출력 형식 (마크다운)
+- **핵심 목표/키워드**: (사용자 질문 요약)
+- **연관 카테고리 요소**: 표 형식 또는 나열  
+- **아이디어 스케치**: (각 아이디어별 개념, 특징, 시나리오)
+- **예상 문제/리스크**: (기술·비용·윤리 등)
+- **실행 단계**: (프로토타입, 테스트, 검증, 런칭)
+- **추가 아이디어/참고**: (옵션)
+
+{framework_output_format}
+{cat_clause}
+
+**모든 답변은 한국어**로 작성.  
+중간 사고 과정을 내부적으로 수행하되, 최종 답변만 출력.  
+웹 검색 및 Kaggle 데이터셋 분석도 통합하여 아이디어 품질을 높이십시오.
+"""
+    return base_prompt.strip()
+
+# ──────────────────────────────── Brave Search API ───────────────────────
+@st.cache_data(ttl=3600)
+def brave_search(query: str, count: int = 20):
+    if not BRAVE_KEY:
+        raise RuntimeError("⚠️ SERPHOUSE_API_KEY (Brave API Key) 환경 변수가 비어있습니다.")
+    headers = {
+        "Accept": "application/json",
+        "Accept-Encoding": "gzip",
+        "X-Subscription-Token": BRAVE_KEY
+    }
+    params = {"q": query, "count": str(count)}
+    for attempt in range(3):
+        try:
+            r = requests.get(BRAVE_ENDPOINT, headers=headers, params=params, timeout=15)
+            r.raise_for_status()
+            data = r.json()
+            raw = data.get("web", {}).get("results") or data.get("results", [])
+            if not raw:
+                raise ValueError("No search results found.")
+            arts = []
+            for i, res in enumerate(raw[:count], 1):
+                url = res.get("url", res.get("link", ""))
+                host = re.sub(r"https?://(www\.)?", "", url).split("/")[0]
+                arts.append({
+                    "index": i,
+                    "title": res.get("title", "No title"),
+                    "link": url,
+                    "snippet": res.get("description", res.get("text", "No snippet")),
+                    "displayed_link": host
+                })
+            return arts
+        except Exception as e:
+            logging.error(f"Brave search failure (attempt {attempt+1}/3): {e}")
+            time.sleep(1)
+    return []
+
+def mock_results(query: str) -> str:
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    return (
+        f"# Fallback Search Content (Generated: {ts})\n\n"
+        f"The web search API request failed. Please generate the invention/design ideas based on '{query}' using general knowledge.\n\n"
+        f"You may consider aspects such as:\n\n"
+        f"- Basic concept or definition of {query}\n"
+        f"- Potential expansions or improvements\n"
+        f"- Category-based transformations\n\n"
+        f"Note: This is fallback text, not real-time data.\n\n"
+    )
+
+def do_web_search(query: str) -> str:
+    try:
+        arts = brave_search(query, 20)
+        if not arts:
+            logging.warning("No search results from Brave. Using fallback.")
+            return mock_results(query)
+        hdr = "# Web Search Results\nUse the information below to spark new design/invention insights.\n\n"
+        body = "\n".join(
+            f"### Result {a['index']}: {a['title']}\n\n{a['snippet']}\n\n**Source**: [{a['displayed_link']}]({a['link']})\n\n---\n"
+            for a in arts
+        )
+        return hdr + body
+    except Exception as e:
+        logging.error(f"Web search process failed: {str(e)}")
+        return mock_results(query)
+
+# ──────────────────────────────── (신규) 디자인/발명 아이디어 처리 함수 ─────────────────
+def process_invention_ideas(keyword: str):
+    """
+    (이전에는 별도 버튼/프롬프트가 있었으나,
+     이제 메인 프롬프트로 일원화되어 사실상 사용되지 않을 수도 있음.)
+    """
+    if not keyword.strip():
+        st.warning("키워드를 입력하세요.")
+        return
+
+    st.info(f"디자인/발명 아이디어 생성 중... (키워드: **{keyword}**)")
+
+    # 모든 카테고리와 항목을 리스트업
+    categories_text = []
+    for cat_name, items in physical_transformation_categories.items():
+        joined_items = ", ".join(items)
+        categories_text.append(f"- {cat_name}: {joined_items}")
+    categories_joined = "\n".join(categories_text)
+
+    prompt = f"""
+당신은 디자인/발명 전문가입니다.
+키워드: "{keyword}"
+아래는 카테고리+항목 목록입니다.
+{categories_joined}
+
+이 키워드를 각 항목과 결합한 아이디어를 생각하고,
+타당한 것과 배제할 것을 분류하여 마크다운으로 출력하세요.
+"""
+    try:
+        client = get_openai_client()
+        with st.spinner("Generating invention ideas..."):
+            response = client.chat.completions.create(
+                model="gpt-4.1-mini",
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.9,
+                max_tokens=2500,
+            )
+        result_text = response.choices[0].message.content
+        st.markdown(result_text)
+    except Exception as e:
+        st.error(f"오류 발생: {e}")
+
+# ──────────────────────────────── Streamlit 메인 앱 ──────────────────────
+def idea_generator_app():
+    st.title("Ilúvatar(일루바타르) : Creative Design & Invention AI")
+    st.caption("이 시스템은 빅데이터를 자율적으로 수집·분석하여, 복합적인 디자인/발명 아이디어를 제안합니다.")
+
+    default_vals = {
+        "ai_model": "gpt-4.1-mini",
+        "messages": [],
+        "auto_save": True,
+        "generate_image": True,
+        "web_search_enabled": True,
+        "kaggle_enabled": True,
+        "selected_frameworks": [],
+        "GLOBAL_PICK_COUNT": {},
+        "_skip_dup_idx": None
+    }
+    for k, v in default_vals.items():
+        if k not in st.session_state:
+            st.session_state[k] = v
+
+    sb = st.sidebar
+    st.session_state.temp = sb.slider(
+        "Diversity temperature", 0.1, 3.0, 1.3, 0.1,
+        help="0.1 = 매우 보수적, 3.0 = 매우 창의/무작위"
+    )
+
+    sb.title("Settings")
+    sb.toggle("Auto Save", key="auto_save")
+    sb.toggle("Auto Image Generation", key="generate_image")
+
+    st.session_state.web_search_enabled = sb.toggle(
+        "Use Web Search", value=st.session_state.web_search_enabled
+    )
+    st.session_state.kaggle_enabled = sb.toggle(
+        "Use Kaggle Datasets", value=st.session_state.kaggle_enabled
+    )
+
+    if st.session_state.web_search_enabled:
+        sb.info("✅ Web search results enabled")
+    if st.session_state.kaggle_enabled:
+        if KAGGLE_KEY:
+            sb.info("✅ Kaggle data integration enabled")
+        else:
+            sb.error("⚠️ KAGGLE_KEY not set.")
+            st.session_state.kaggle_enabled = False
+
+    # (디자인/발명용 사이드바 항목은 삭제됨, 메인 prompt에서 처리)
+
+    # 예시 주제
+    example_topics = {
+        "example1": "스마트홈에서 사용할 차세대 가전제품 발명 아이디어",
+        "example2": "지속가능한 소재를 활용한 패션 디자인 컨셉",
+        "example3": "사용자 인터페이스(UI/UX) 혁신을 위한 웨어러블 기기 아이디어"
+    }
+    sb.subheader("Example Topics")
+    c1, c2, c3 = sb.columns(3)
+    if c1.button("가전제품 발명", key="ex1"):
+        process_example(example_topics["example1"])
+    if c2.button("친환경 패션 디자인", key="ex2"):
+        process_example(example_topics["example2"])
+    if c3.button("UI/UX 혁신", key="ex3"):
+        process_example(example_topics["example3"])
+
+    # 대화 히스토리 다운로드
+    latest_ideas = next(
+        (m["content"] for m in reversed(st.session_state.messages)
+         if m["role"] == "assistant" and m["content"].strip()),
+        None
+    )
+    if latest_ideas:
+        title_match = re.search(r"# (.*?)(\n|$)", latest_ideas)
+        title = (title_match.group(1) if title_match else "design_invention").strip()
+        sb.subheader("Download Latest Ideas")
+        d1, d2 = sb.columns(2)
+        d1.download_button("Download as Markdown", latest_ideas,
+                           file_name=f"{title}.md", mime="text/markdown")
+        d2.download_button("Download as HTML", md_to_html(latest_ideas, title),
+                           file_name=f"{title}.html", mime="text/html")
+
+    # 대화 히스토리 로드/저장
+    up = sb.file_uploader("Load Conversation (.json)", type=["json"], key="json_uploader")
+    if up:
+        try:
+            st.session_state.messages = json.load(up)
+            sb.success("Conversation history loaded successfully")
+        except Exception as e:
+            sb.error(f"Failed to load: {e}")
+
+    if sb.button("Download Conversation as JSON"):
+        sb.download_button(
+            "Save JSON",
+            data=json.dumps(st.session_state.messages, ensure_ascii=False, indent=2),
+            file_name="chat_history.json",
+            mime="application/json"
+        )
+
+    # 파일 업로드
+    st.subheader("File Upload (Optional)")
+    uploaded_files = st.file_uploader(
+        "Upload reference files (txt, csv, pdf)",
+        type=["txt", "csv", "pdf"],
+        accept_multiple_files=True,
+        key="file_uploader"
+    )
+    if uploaded_files:
+        st.success(f"{len(uploaded_files)} files uploaded.")
+        with st.expander("Preview Uploaded Files", expanded=False):
+            for idx, file in enumerate(uploaded_files):
+                st.write(f"**File Name:** {file.name}")
+                ext = file.name.split('.')[-1].lower()
+                try:
+                    if ext == 'txt':
+                        preview = file.read(1000).decode('utf-8', errors='ignore')
+                        file.seek(0)
+                        st.text_area("Preview", preview + ("..." if len(preview) >= 1000 else ""), height=150)
+                    elif ext == 'csv':
+                        df = pd.read_csv(file)
+                        file.seek(0)
+                        st.dataframe(df.head(5))
+                    elif ext == 'pdf':
+                        reader = PyPDF2.PdfReader(io.BytesIO(file.read()), strict=False)
+                        file.seek(0)
+                        pg_txt = reader.pages[0].extract_text() if reader.pages else "(No text)"
+                        st.text_area("Preview", (pg_txt[:500] + "...") if pg_txt else "(No text)", height=150)
+                except Exception as e:
+                    st.error(f"Preview failed: {e}")
+                if idx < len(uploaded_files) - 1:
+                    st.divider()
+
+    # 이미 렌더된 메시지(중복 방지)
+    skip_idx = st.session_state.get("_skip_dup_idx")
+    for i, m in enumerate(st.session_state.messages):
+        if skip_idx is not None and i == skip_idx:
+            continue
+        with st.chat_message(m["role"]):
+            st.markdown(m["content"])
+            if "image" in m:
+                st.image(m["image"], caption=m.get("image_caption", ""))
+    st.session_state["_skip_dup_idx"] = None
+
+    # 메인 채팅 입력
+    prompt = st.chat_input("새로운 디자인/발명 아이디어가 필요하신가요? 여기에 상황이나 목표를 작성하세요!")
+    if prompt:
+        process_input(prompt, uploaded_files)
+
+    sb.markdown("---")
+    sb.markdown("Created by [VIDraft](https://discord.gg/openfreeai)")
+
+def process_example(topic):
+    process_input(topic, [])
+
+def process_input(prompt: str, uploaded_files):
+    """
+    메인 채팅 입력을 받아 디자인/발명 아이디어를 생성한다.
+    """
+    if not any(m["role"] == "user" and m["content"] == prompt for m in st.session_state.messages):
+        st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    for i in range(len(st.session_state.messages) - 1):
+        if (st.session_state.messages[i]["role"] == "user"
+            and st.session_state.messages[i]["content"] == prompt
+            and st.session_state.messages[i + 1]["role"] == "assistant"):
+            return
+
+    with st.chat_message("assistant"):
+        status = st.status("Preparing to generate invention ideas…")
+        stream_placeholder = st.empty()
+        full_response = ""
+
+        try:
+            client = get_openai_client()
+            status.update(label="Initializing model…")
+
+            selected_cat = st.session_state.get("category_focus", None)
+            selected_frameworks = st.session_state.get("selected_frameworks", [])
+
+            # 목적이 "디자인/발명"이므로, system prompt 변경
+            sys_prompt = get_idea_system_prompt(
+                selected_category=selected_cat,
+                selected_frameworks=selected_frameworks
+            )
+
+            def category_context(sel):
+                if sel:
+                    return json.dumps({sel: physical_transformation_categories[sel]}, ensure_ascii=False)
+                return "ALL_CATEGORIES: " + ", ".join(physical_transformation_categories.keys())
+
+            use_web_search = st.session_state.web_search_enabled
+            use_kaggle     = st.session_state.kaggle_enabled
+            has_uploaded   = bool(uploaded_files)
+
+            search_content  = None
+            kaggle_content  = None
+            file_content    = None
+
+            # ① 웹검색
+            if use_web_search:
+                status.update(label="Searching the web…")
+                with st.spinner("Searching…"):
+                    search_content = do_web_search(keywords(prompt, top=5))
+
+            # ② Kaggle
+            if use_kaggle and check_kaggle_availability():
+                status.update(label="Kaggle 데이터셋 분석 중…")
+                with st.spinner("Searching Kaggle…"):
+                    kaggle_kw = extract_kaggle_search_keywords(prompt)
+                    try:
+                        datasets = search_kaggle_datasets(kaggle_kw)
+                    except Exception as e:
+                        logging.warning(f"search_kaggle_datasets 오류 무시: {e}")
+                        datasets = []
+                    analyses = []
+                    if datasets:
+                        status.update(label="Downloading & analysing datasets…")
+                        for ds in datasets:
+                            try:
+                                ana = download_and_analyze_dataset(ds["ref"])
+                            except Exception as e:
+                                logging.error(f"Kaggle 분석 오류({ds['ref']}) : {e}")
+                                ana = f"데이터셋 분석 오류: {e}"
+                            analyses.append({"meta": ds, "analysis": ana})
+                    if analyses:
+                        kaggle_content = format_kaggle_analysis_markdown_multi(analyses)
+
+            # ③ 파일 업로드
+            if has_uploaded:
+                status.update(label="Reading uploaded files…")
+                with st.spinner("Processing files…"):
+                    file_content = process_uploaded_files(uploaded_files)
+
+            # ④ 군사 전술 데이터 (필요 시)
+            mil_content = None
+            if is_military_query(prompt):
+                status.update(label="Searching military tactics dataset…")
+                with st.spinner("Loading military insights…"):
+                    mil_rows = military_search(prompt)
+                if mil_rows:
+                    mil_content = "# Military Tactics Dataset Reference\n\n"
+                    for i, row in enumerate(mil_rows, 1):
+                        mil_content += (
+                            f"### Case {i}\n"
+                            f"**Scenario:** {row['scenario_description']}\n\n"
+                            f"**Attack Reasoning:** {row['attack_reasoning']}\n\n"
+                            f"**Defense Reasoning:** {row['defense_reasoning']}\n\n---\n"
+                        )
+
+            user_content = prompt
+            if search_content:
+                user_content += "\n\n" + search_content
+            if kaggle_content:
+                user_content += "\n\n" + kaggle_content
+            if file_content:
+                user_content += "\n\n" + file_content
+            if mil_content:
+                user_content += "\n\n" + mil_content
+
+            # 내부 분석
+            status.update(label="분석 중…")
+            decision_purpose = identify_decision_purpose(prompt)
+            relevance_scores = compute_relevance_scores(prompt, PHYS_CATEGORIES)
+
+            status.update(label="카테고리 조합 아이디어 생성 중…")
+            T = st.session_state.temp
+            k_cat_range  = (4, 8) if T < 1.0 else (6, 10) if T < 2.0 else (8, 12)
+            n_item_range = (2, 4) if T < 1.0 else (3, 6) if T < 2.0 else (4, 8)
+            depth_range  = (2, 3) if T < 1.0 else (2, 5) if T < 2.0 else (2, 6)
+            combos = generate_random_comparison_matrix(
+                PHYS_CATEGORIES,
+                relevance_scores,
+                k_cat=k_cat_range,
+                n_item=n_item_range,
+                depth_range=depth_range,
+                seed=hash(prompt) & 0xFFFFFFFF,
+                T=T,
+            )
+
+            combos_table = "| 조합 | 가중치 | 영향도 | 신뢰도 | 총점 |\n|------|--------|--------|--------|-----|\n"
+            for w, imp, conf, tot, cmb in combos:
+                combo_str = " + ".join(f"{c[0]}-{c[1]}" for c in cmb)
+                combos_table += f"| {combo_str} | {w} | {imp} | {conf:.1f} | {tot} |\n"
+
+            purpose_info = "\n\n## 디자인/발명 목표 분석\n"
+            if decision_purpose['purposes']:
+                purpose_info += "### 핵심 목적\n"
+                for p, s in decision_purpose['purposes']:
+                    purpose_info += f"- **{p}** (관련성: {s})\n"
+            if decision_purpose['constraints']:
+                purpose_info += "\n### 제약 조건\n"
+                for c, s in decision_purpose['constraints']:
+                    purpose_info += f"- **{c}** (관련성: {s})\n"
+
+            # 프레임워크 적용 결과 (현재 목적이 디자인/발명 -> 선택적으로 표시)
+            framework_contents = []
+            for fw in selected_frameworks:
+                if fw == "swot":
+                    swot_res = analyze_with_swot(prompt)
+                    framework_contents.append(format_business_framework_analysis("swot", swot_res))
+                elif fw == "porter":
+                    porter_res = analyze_with_porter(prompt)
+                    framework_contents.append(format_business_framework_analysis("porter", porter_res))
+                elif fw == "bcg":
+                    bcg_res = analyze_with_bcg(prompt)
+                    framework_contents.append(format_business_framework_analysis("bcg", bcg_res))
+                elif fw == "sunzi":
+                    # 손자병법 예시
+                    # (실제로는 별도 로직이 필요하나 여기선 생략)
+                    pass
+
+            if framework_contents:
+                user_content += "\n\n## (Optional) 기타 프레임워크 분석\n\n" + "\n\n".join(framework_contents)
+
+            user_content += f"\n\n## 카테고리 매트릭스 분석{purpose_info}\n{combos_table}"
+
+            status.update(label="Generating final design/invention ideas…")
+            api_messages = [
+                {"role": "system", "content": sys_prompt},
+                {"role": "system", "name": "category_db", "content": category_context(selected_cat)},
+                {"role": "user",   "content": user_content},
+            ]
+            stream = client.chat.completions.create(
+                model="gpt-4.1-mini",
+                messages=api_messages,
+                temperature=1,
+                max_tokens=MAX_TOKENS,
+                top_p=1,
+                stream=True
+            )
+
+            for chunk in stream:
+                if chunk.choices and chunk.choices[0].delta.content:
+                    full_response += chunk.choices[0].delta.content
+                    stream_placeholder.markdown(full_response + "▌")
+
+            stream_placeholder.markdown(full_response)
+            status.update(label="Invention ideas created!", state="complete")
+
+            # 이미지 생성
+            img_data = img_caption = None
+            if st.session_state.generate_image and full_response:
+                match = re.search(r"###\s*이미지\s*프롬프트\s*\n+([^\n]+)", full_response, re.I)
+                if not match:
+                    match = re.search(r"Image\s+Prompt\s*[:\-]\s*([^\n]+)", full_response, re.I)
+                if match:
+                    raw_prompt = re.sub(r'[\r\n"\'\\]', " ", match.group(1)).strip()
+                    with st.spinner("Generating illustrative image…"):
+                        img_data, img_caption = generate_image(raw_prompt)
+                    if img_data:
+                        st.image(img_data, caption=f"Visualized Concept – {img_caption}")
+
+            answer_msg = {"role": "assistant", "content": full_response}
+            if img_data:
+                answer_msg["image"]         = img_data
+                answer_msg["image_caption"] = img_caption
+            st.session_state["_skip_dup_idx"] = len(st.session_state.messages)
+            st.session_state.messages.append(answer_msg)
+
+            # 다운로드 버튼
+            st.subheader("Download This Output")
+            col_md, col_html = st.columns(2)
+            col_md.download_button(
+                "Markdown",
+                data=full_response,
+                file_name=f"{prompt[:30]}.md",
+                mime="text/markdown"
+            )
+            col_html.download_button(
+                "HTML",
+                data=md_to_html(full_response, prompt[:30]),
+                file_name=f"{prompt[:30]}.html",
+                mime="text/html"
+            )
+
+            if st.session_state.auto_save:
+                fn = f"chat_history_auto_{datetime.now():%Y%m%d_%H%M%S}.json"
+                with open(fn, "w", encoding="utf-8") as fp:
+                    json.dump(st.session_state.messages, fp, ensure_ascii=False, indent=2)
+
+        except Exception as e:
+            logging.error("process_input error", exc_info=True)
+            st.error(f"⚠️ 작업 중 오류가 발생했습니다: {e}")
+            st.session_state.messages.append(
+                {"role": "assistant", "content": f"⚠️ 오류: {e}"}
+            )
+
+def main():
+    idea_generator_app()
+
+if __name__ == "__main__":
+    main()