Create app.py

app.py

@@ -0,0 +1,684 @@
+# -*- coding: utf-8 -*-
+# Mixed Prompt Composer — Combo + Free-text + Strong Rationale + RAG(FAISS)
+# Gradio 4.x / Hugging Face Spaces 호환
+
+import os, re, json
+from typing import List, Dict, Tuple
+import gradio as gr
+
+# ===== RAG deps =====
+import faiss
+import numpy as np
+import pandas as pd
+from sentence_transformers import SentenceTransformer
+from pypdf import PdfReader
+from docx import Document as Docx
+
+# =============== 모델 워밍업(최초 로딩 지연 완화) ===============
+EMBED_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
+try:
+    _WARMUP = SentenceTransformer(EMBED_MODEL_NAME)
+except Exception:
+    _WARMUP = None
+
+# -----------------------------
+# 0) 데이터셋/글로서리
+# -----------------------------
+ALL_TECHS = [
+    "Persona Prompting","Few-shot Prompting","Self-consistency Prompting","Output Formatting",
+    "Chain-of-Thought (CoT)","Constrained Prompting","RAG Prompting","Step-back Prompting","Role Prompting",
+]
+
+TECH_GLOSSARY = {
+    "Persona Prompting": {
+        "desc": "대상 역할/세그먼트의 언어·KPI·관심사와 메시지를 정렬해 반응률·공감도를 높임.",
+        "purpose": "누구에게 말하는지 분명히 해 가치가 ‘그들의 언어’로 전달되게 함.",
+        "mechanics": [
+            "역할/권한/관심 KPI 명시(예: Sales Leader=파이프라인·승률·리드타임).",
+            "톤/금칙어/선호 표현 정의(직설·간결·숫자/ROI, 모호어 금지).",
+            "페르소나별 문장 매핑(문제→가치→증거→CTA)."
+        ],
+        "example": "예) “이번 분기 파이프라인 18% 보강 위해 두 가지 빠른 액션 제안드립니다.”"
+    },
+    "Few-shot Prompting": {
+        "desc": "소수의 고성과 예시를 제공해 톤·구조·리듬을 모사, 품질 편차↓·속도↑.",
+        "purpose": "검증된 패턴 복제로 일관성 확보.",
+        "mechanics": [
+            "샘플 2~3개를 헤드라인/오프닝/근거/CTA 패턴으로 제공.",
+            "‘이 톤을 모사해 3개 변형’처럼 다변량 후보 생성."
+        ],
+        "example": "[샘플] {산업} 팀들의 {성과}(사례). 이번주 {수/목} {11:00/16:00} 15분 통화 가능하실까요?"
+    },
+    "Self-consistency Prompting": {
+        "desc": "여러 후보안 생성 후 자체 채점(체크리스트/스코어링)으로 최적안 선택.",
+        "purpose": "A/B 테스트 내장으로 품질 향상.",
+        "mechanics": [
+            "제목5·바디3·CTA3 등 다변량 생성.",
+            "체크리스트(개인화/명료/가치/스팸회피/CTA) 채점→Top-1 출력."
+        ],
+        "example": "출력: 후보 리스트 + 채점표 + 최종 추천 1~2안."
+    },
+    "Output Formatting": {
+        "desc": "산출물의 형식/섹션/필드 고정(표/섹션/JSON 등)으로 속도·가독성·재사용성 확보.",
+        "purpose": "승인 루프 단축, 표준화.",
+        "mechanics": [
+            "유형별 템플릿 강제(이메일/카피/보고서/PRD/API).",
+            "필수·선택 필드/길이/금칙어 명시."
+        ],
+        "example": "이메일: 제목/오프닝/가치제안/증거/CTA/PS"
+    },
+    "Chain-of-Thought (CoT)": {
+        "desc": "목표→지표→대안→선택→실행의 단계적 추론으로 논리 비약 최소화.",
+        "purpose": "분석/전략 문서의 논리 일관성.",
+        "mechanics": ["각 단계에 가정/근거/대안/리스크/권고 체크 질문 부여."],
+        "example": "요약→현황→과제→분석→인사이트→권고→한계"
+    },
+    "Constrained Prompting": {
+        "desc": "길이·금칙어·필수필드·JSON 스키마 등 제약 준수.",
+        "purpose": "브랜드/법무/심의 리스크 최소화.",
+        "mechanics": ["제목 ≤ 30자, 금칙어 제거, 필수 키 누락 시 재생성."],
+        "example": "JSON 스키마 준수 출력 / 표준 체크리스트 포함"
+    },
+    "RAG Prompting": {
+        "desc": "외부 보고서/DB/문서의 근거 주입으로 최신성·신뢰성 확보.",
+        "purpose": "추정/환각 방지, 출처 기반 서술.",
+        "mechanics": ["‘문서에 없는 내용은 추정 금지, 출처 메모’ 지시.", "인용/각주/링크 표기."],
+        "example": "예) Gartner MQ 2024, 공시 2024Q3, Crunchbase 2024.07"
+    },
+    "Step-back Prompting": {
+        "desc": "상위 목적/원칙에서 출발해 의미 중심으로 재해석.",
+        "purpose": "‘왜 중요한가’에 먼저 답해 경영 시사점 강화.",
+        "mechanics": ["상위 목표→핵심 원칙→현재 선택 정합성 검증."],
+        "example": "‘비용 20%↓’가 전략 KPI에 어떻게 기여하는지 연결"
+    },
+    "Role Prompting": {
+        "desc": "‘당신은 PM/전략가/UX 라이터…’처럼 관점 고정으로 목적 적합성↑.",
+        "purpose": "직무별 언어/판단 기준 일치.",
+        "mechanics": ["역할·KPI·결정권·리스크 관점 명시."],
+        "example": "PM: 문제정의/AC/리스크 | 전략: 인사이트/권고/거버넌스"
+    },
+}
+
+CATALOG = {
+    "1 외부 커뮤니케이션": {
+        "subdomains": ["이메일(콜드/웜)", "광고/랜딩", "PR/보도자료", "SNS/영상"],
+        "pains": ["반응률 저조", "메시지 불일치", "작성 시간 과다", "A/B 테스트 부담"],
+        "outputs": ["콜드메일", "광고 카피", "보도자료", "랜딩페이지 섹션"],
+        "users": ["세일즈", "마케팅팀", "PR팀", "창업자"]
+    },
+    "2 시장·고객 리서치": {
+        "subdomains": ["시장보고서", "경쟁분석", "VOC 분석", "페르소나"],
+        "pains": ["경쟁사 정보 부족", "고객 요구 불명확", "출처/기간 누락", "리서치 작성 부담"],
+        "outputs": ["시장조사 보고서", "경쟁사 분석", "페르소나", "VOC 요약"],
+        "users": ["전략팀", "기획팀", "컨설턴트", "IR/투자준비팀"]
+    },
+    "3 제품·UX 문서": {
+        "subdomains": ["PRD/요구사항", "유스케이스", "UX 마이크로카피", "릴리스 노트"],
+        "pains": ["요구사항 언어화 난항", "UX 카피 불일치", "의사결정 기준 불명확"],
+        "outputs": ["PRD", "유스케이스", "UX 카피", "릴리스 노트"],
+        "users": ["PM", "UX 디자이너", "개발팀", "QA"]
+    },
+}
+
+PAIN_SUB = {
+    "반응률 저조": ["제목/프리헤더", "타게팅", "CTA 약함", "신뢰 근거 부족"],
+    "메시지 불일치": ["톤/보이스", "포맷/길이", "채널/페이싱"],
+    "작성 시간 과다": ["템플릿 부재", "예시 부족", "승인 루프 지연"],
+    "경쟁사 정보 부족": ["자료 수집", "정합성 검증", "최신성"],
+    "고객 요구 불명확": ["세그먼트 정의", "JTBD 모호", "페인/게인"],
+}
+
+OUTPUT_SUB = {
+    "콜드메일": ["신규 인바운드", "콜드 아웃바운드", "후속/리마인드", "이탈 재참여"],
+    "광고 카피": ["웹 배너", "검색광고", "SNS 카드", "앱 푸시"],
+    "시장조사 보고서": ["탑다운(탐색)", "바텀업 추정", "혼합 접근", "리서치 브리프"],
+    "경쟁사 분석": ["기능 비교표", "가격/패키지", "포지셔닝 맵", "SWOT"],
+    "PRD": ["문제정의", "목표/지표", "범위/비범위", "수용기준(AC)", "리스크"],
+}
+
+USER_SUB = {
+    "세일즈": ["BDR", "AE", "AM", "Sales Leader"],
+    "마케팅팀": ["퍼포먼스", "콘텐츠", "브랜드", "그로스"],
+    "PR팀": ["코퍼레이트", "프로덕트 PR"],
+    "창업자": ["Seed", "Series A+", "부트스트랩"],
+    "전략팀": ["Corp Strategy", "Biz Ops"],
+    "PM": ["Jr PM", "Sr PM", "Group PM"],
+    "UX 디자이너": ["UX Writer", "Product Designer"],
+    "개발팀": ["FE", "BE", "ML", "Infra"],
+    "QA": ["QA 엔지니어", "QA 리드"]
+}
+
+# -----------------------------
+# 유틸
+# -----------------------------
+def uniq(xs: List[str]) -> List[str]:
+    if not xs: return []
+    s=set(); out=[]
+    for x in xs:
+        if x not in s:
+            s.add(x); out.append(x)
+    return out
+
+AUTO_RULES_PAIN = {
+    "반응률": ["Persona Prompting", "Few-shot Prompting", "Self-consistency Prompting"],
+    "불일치": ["Output Formatting", "Constrained Prompting"],
+    "작성":   ["Output Formatting", "Few-shot Prompting"],
+    "경쟁":   ["RAG Prompting", "Chain-of-Thought (CoT)"],
+    "요구":   ["Persona Prompting", "Step-back Prompting"],
+}
+AUTO_RULES_OUTPUT = {
+    "이메일": ["Persona Prompting", "Output Formatting", "Few-shot Prompting", "Self-consistency Prompting"],
+    "카피":   ["Few-shot Prompting", "Self-consistency Prompting", "Output Formatting"],
+    "보고서": ["RAG Prompting", "Chain-of-Thought (CoT)", "Output Formatting"],
+    "PRD":    ["Role Prompting", "Constrained Prompting", "Chain-of-Thought (CoT)"],
+}
+AUTO_RULES_USER = {
+    "세일즈": ["Persona Prompting", "Few-shot Prompting", "Self-consistency Prompting"],
+    "마케팅": ["Few-shot Prompting", "Self-consistency Prompting"],
+    "전략":   ["Chain-of-Thought (CoT)", "Step-back Prompting", "RAG Prompting"],
+    "PM":     ["Role Prompting", "Constrained Prompting"],
+    "데이터": ["RAG Prompting", "Constrained Prompting"],
+}
+
+def auto_recommend(domain_key, pains, outs, users):
+    rec=[]
+    if domain_key=="1 외부 커뮤니케이션":
+        rec+=["Persona Prompting","Few-shot Prompting","Self-consistency Prompting","Output Formatting"]
+    if domain_key=="2 시장·고객 리서치":
+        rec+=["RAG Prompting","Chain-of-Thought (CoT)","Output Formatting","Step-back Prompting"]
+    if domain_key=="3 제품·UX 문서":
+        rec+=["Role Prompting","Constrained Prompting","Chain-of-Thought (CoT)","Output Formatting"]
+    for p in pains or []:
+        for k,ts in AUTO_RULES_PAIN.items():
+            if k in p: rec+=ts
+    for o in outs or []:
+        for k,ts in AUTO_RULES_OUTPUT.items():
+            if k in o: rec+=ts
+    for u in users or []:
+        for k,ts in AUTO_RULES_USER.items():
+            if k in u: rec+=ts
+    rec.append("Output Formatting")
+    return uniq(rec)
+
+def guess_format_hint(outs: List[str], override: str="") -> str:
+    if override.strip():
+        return override.strip()
+    j=" ".join(outs or [])
+    if any(k in j for k in ["PRD","API","ADR","정책","SOP","유스케이스","FAQ"]): return "JSON/표/불릿(필드 키 고정)"
+    if any(k in j for k in ["보고서","브리프","요약","문서","1-Pager"]): return "요약/현황/경쟁/인사이트/권고/한계"
+    if any(k in j for k in ["카피","광고","랜딩"]): return "헤드라인/서브헤드/바디/CTA"
+    if any(k in j for k in ["이메일","메일","콜드메일"]): return "제목/오프닝/가치제안/증거/CTA/PS"
+    return "목차/요약/본문/권고/CTA"
+
+# -----------------------------
+# Rationale(강화판)
+# -----------------------------
+def reason_from_pain(tech: str, pains: List[str], pain_subs: List[str]) -> List[str]:
+    R=[]
+    jp=" ".join(pains or []) + " " + " ".join(pain_subs or [])
+    if "반응률" in jp:
+        if tech=="Persona Prompting": R.append("반응률 저조 → 세그먼트 맞춤 어휘/어조로 체감 가치 상승")
+        if tech=="Few-shot Prompting": R.append("반응률 저조 → 고성과 예시 패턴 복제")
+        if tech=="Self-consistency Prompting": R.append("반응률 저조 → 다변량 후보 생성→자체 채점으로 Top-1")
+    if "불일치" in jp or "톤/보이스" in jp or "포맷" in jp:
+        if tech=="Output Formatting": R.append("메시지 불일치 → 형식/섹션 고정으로 정합성↑")
+        if tech=="Constrained Prompting": R.append("메시지 불일치 → 금칙/길이/필수필드 강제")
+    if "작성 시간" in jp or "예시 부족" in jp:
+        if tech in {"Few-shot Prompting","Output Formatting"}: R.append("작성시간 과다/예시 부족 → 템플릿 + 예시 기반 속도↑")
+    if "경쟁사 정보" in jp:
+        if tech=="RAG Prompting": R.append("경쟁사 정보 부족 → 외부 데이터 근거 주입(최신성/신뢰성)")
+        if tech=="Chain-of-Thought (CoT)": R.append("경쟁사 분석 구조화(CoT)로 인사이트 명료화")
+    if "요구 불명확" in jp:
+        if tech in {"Persona Prompting","Step-back Prompting"}: R.append("고객 요구 불명확 → 상위 목적/JTBD 정렬")
+    return R
+
+def reason_from_output(tech: str, outs: List[str], out_subs: List[str]) -> List[str]:
+    R=[]
+    jo=" ".join(outs or []) + " " + " ".join(out_subs or [])
+    if "메일" in jo or "카피" in jo or "랜딩" in jo:
+        if tech=="Output Formatting": R.append("카피/메일 → 헤드라인/서브/바디/CTA 고정이 성과 좌우")
+        if tech=="Self-consistency Prompting": R.append("메시지 후보 다변량 생성→최적안 선택 필요")
+        if tech=="Few-shot Prompting": R.append("채널별 톤/길이 차이를 예시로 빠르게 적응")
+    if "보고서" in jo or "분석" in jo:
+        if tech=="RAG Prompting": R.append("보고서/분석 → 수치·출처 최신성 보장")
+        if tech=="Chain-of-Thought (CoT)": R.append("보고서/분석 → 단계적 구조(CoT)로 논리 강화")
+    if "PRD" in jo or "API" in jo:
+        if tech in {"Constrained Prompting","Role Prompting"}: R.append("PRD/API → JSON/필드 강제 + 직무 관점 고정 필요")
+    return R
+
+def reason_from_user(tech: str, users: List[str], user_subs: List[str]) -> List[str]:
+    R=[]
+    ju=" ".join(users or []) + " " + " ".join(user_subs or [])
+    if "세일즈" in ju:
+        if tech=="Persona Prompting": R.append("Sales는 파이프라인/승률 언어 선호 → 페르소나 톤 적용")
+        if tech=="Few-shot Prompting": R.append("영업 레퍼런스 사례 모사가 설득력↑")
+    if "전략" in ju:
+        if tech in {"Chain-of-Thought (CoT)","Step-back Prompting","RAG Prompting"}:
+            R.append("전략조직은 근거/논리/시사점 중시 → CoT+RAG+Step-back 적합")
+    if "PM" in ju or "UX" in ju:
+        if tech in {"Role Prompting","Constrained Prompting"}:
+            R.append("PM/UX는 필드/AC/톤 표준 필요 → 역할 고정 + 제약 강제")
+    return R
+
+def domain_reco(tech: str, outs: List[str]) -> str:
+    j=" ".join(outs or [])
+    if tech=="Output Formatting":
+        if "메일" in j: return "이메일: 제목/오프닝/가치제안/증거/CTA/PS 형식 고정"
+        if "카피" in j or "랜딩" in j: return "카피/랜딩: 헤드라인/서브/바디/CTA 블록 고정"
+        if "보고서" in j: return "보고서: 요약/현황/경쟁/인사이트/권고/한계 섹션 고정"
+        if "PRD" in j: return "PRD: 필수 필드(JSON/표) 강제"
+        return "산출물 표준 섹션 고정"
+    if tech=="Persona Prompting": return "세그먼트·역할 KPI 언어 정렬"
+    if tech=="Few-shot Prompting": return "고성과 예시 구조/톤 모사"
+    if tech=="Self-consistency Prompting": return "다중 후보 생성→자체 ���점→Top-1"
+    if tech=="Constrained Prompting": return "길이/금칙어/필수필드 강제"
+    if tech=="RAG Prompting": return "외부 리포트/백서 근거 주입"
+    if tech=="Chain-of-Thought (CoT)": return "목표→지표→대안→권고 단계화"
+    if tech=="Step-back Prompting": return "상위 목적/원칙에서 의미 재해석"
+    if tech=="Role Prompting": return "역할 고정으로 관점 일치"
+    return "-"
+
+def build_rationale_detailed(
+    tech: str, domain_key: str, subdomains: List[str],
+    pains: List[str], pain_subs: List[str],
+    outs: List[str], out_subs: List[str],
+    users: List[str], user_subs: List[str]
+) -> str:
+    if not tech: return ""
+    g = TECH_GLOSSARY.get(tech, {})
+    desc, purpose, mechs, example = g.get("desc",""), g.get("purpose",""), g.get("mechanics",[]), g.get("example","")
+
+    R = []
+    R += reason_from_pain(tech, pains, pain_subs)
+    R += reason_from_output(tech, outs, out_subs)
+    R += reason_from_user(tech, users, user_subs)
+    R = uniq(R)
+
+    parts = [
+        f"## {tech}",
+        f"**설명**: {desc}",
+        f"- **적용 목적**: {purpose}" if purpose else "",
+        "- **작동 방식**:\n  - " + "\n  - ".join(mechs) if mechs else "",
+        f"- **도메인 권장**: {domain_reco(tech, outs)}",
+        f"- **선정 근거(선택 반영)**:\n  - " + "\n  - ".join(R) if R else "- **선정 근거**: (선택 항목에 따라 자동 생성)",
+        f"- **예시**: {example}"
+    ]
+    return "\n".join([p for p in parts if p.strip()])
+
+# -----------------------------
+# RAG: 업로드→청킹→임베딩→FAISS→검색
+# -----------------------------
+_model = None
+_faiss = None
+_chunks = []   # [{id, text, meta}]
+_dim = 384
+
+def get_model():
+    global _model
+    if _model is None:
+        _model = SentenceTransformer(EMBED_MODEL_NAME)
+    return _model
+
+def embed_texts(texts: List[str]) -> np.ndarray:
+    model = get_model()
+    vecs = model.encode(texts, normalize_embeddings=True)
+    return np.array(vecs, dtype="float32")
+
+def extract_text(path: str) -> Tuple[str, Dict]:
+    name = os.path.basename(path)
+    ext = os.path.splitext(path)[1].lower()
+    meta = {"source": name}
+    if ext == ".pdf":
+        reader = PdfReader(path)
+        pages = []
+        for i, p in enumerate(reader.pages):
+            try: pages.append(p.extract_text() or "")
+            except: pages.append("")
+        return "\n".join(pages), meta
+    if ext == ".docx":
+        d = Docx(path)
+        return "\n".join(p.text for p in d.paragraphs), meta
+    if ext == ".csv":
+        df = pd.read_csv(path, dtype=str).fillna("")
+        return df.to_csv(index=False), meta
+    if ext == ".txt":
+        with open(path, "r", encoding="utf-8", errors="ignore") as f:
+            return f.read(), meta
+    raise ValueError("지원 확장자: pdf/docx/csv/txt")
+
+def chunk_text(t: str, chunk=800, overlap=200) -> List[str]:
+    t = re.sub(r"\s+", " ", (t or "")).strip()
+    if not t: return []
+    out=[]; s=0
+    while s < len(t):
+        e=min(len(t), s+chunk)
+        out.append(t[s:e])
+        if e==len(t): break
+        s=max(0, e-overlap)
+    return out
+
+def build_index(files, chunk=800, overlap=200):
+    global _faiss, _chunks, _dim
+    _chunks=[]
+
+    all_texts=[]
+    for f in files or []:
+        txt, meta = extract_text(f.name)
+        cks = chunk_text(txt, chunk, overlap)
+        for ci, c in enumerate(cks):
+            _chunks.append({"id": len(_chunks), "text": c, "meta": {"source": meta["source"], "chunk_id": ci}})
+            all_texts.append(c)
+
+    if not all_texts:
+        return "⚠️ 추출 텍스트가 없습니다."
+
+    vecs = embed_texts(all_texts)
+    _dim = vecs.shape[1]
+    _faiss = faiss.IndexFlatIP(_dim)
+    _faiss.add(vecs)
+    return f"✅ 인덱스 구축 완료 · 청크 {len(all_texts)}개 · dim={_dim}"
+
+def search_index(query: str, k=5) -> List[Dict]:
+    if _faiss is None or not _chunks: return []
+    qv = embed_texts([query])
+    scores, idxs = _faiss.search(qv, k)
+    res=[]
+    for rank, (i, s) in enumerate(zip(idxs[0].tolist(), scores[0].tolist()), 1):
+        if 0<=i<len(_chunks):
+            item = _chunks[i]
+            res.append({"rank": rank, "score": float(s),
+                        "text": item["text"], "source": item["meta"]["source"], "chunk_id": item["meta"]["chunk_id"]})
+    return res
+
+def make_context_block(query: str, k=5) -> Tuple[str, str]:
+    hits = search_index(query, k)
+    if not hits: return "(no RAG context)", "(no sources)"
+    ctx_lines=[]; srcs=[]
+    for h in hits:
+        ctx_lines.append(f"[{h['rank']}|{h['source']}|#{h['chunk_id']}|{h['score']:.3f}] {h['text']}")
+        srcs.append(f"{h['rank']}. {h['source']} (chunk {h['chunk_id']})")
+    return "\n\n".join(ctx_lines), "\n".join(srcs)
+
+# -----------------------------
+# 최종 템플릿/프롬프트
+# -----------------------------
+TEMPLATE = """# 목적(Purpose)
+- 우리는 [{domain}]에서 [{out}]을 신속·정확·재사용 ���능하게 만들고자 한다.
+- 최종 독자: [{user}]  | 해결할 Pain: [{pain}]
+
+# 선택 컨텍스트(자유 입력 포함)
+- 세부 도메인: {subdomain}
+- 도메인 메모: {domain_note}
+- Pain 세부/메모: {pain_sub} | {pain_note}
+- Output 세부/스펙: {out_sub} | {out_note}
+- User 세부/메모: {user_sub} | {user_note}
+
+# 산출물 정의(What to produce)
+- 산출물 종류: [{out}]
+- 사용 맥락/목표 KPI: [{kpi}]
+- 성공 기준(통과 조건):
+  1) [{format_hint}]을 100% 준수
+  2) [{audience}]에게 가치가 즉시 보임
+  3) 스팸/과장/애매어 없음
+
+# 형식/톤 가드레일(Format & Tone)
+- 형식: [{format_hint}]
+- 톤: [{tone}]  | 금지: [{ng}]
+
+# 혼합 프롬프팅 기술(Why these techniques)
+{tech_blocks}
+
+{rag_section}
+
+# 작성 작업(Tasks)
+1) **초안 v1**: [{format_hint}]에 맞춘 본문 작성
+2) **대안 생성**: 핵심 문구/제목/CTA 후보 N개 생성
+3) **자체 검증**: 스팸어/금칙어/길이/개인화 변수 체크리스트 통과
+4) **요약 v2**: 5줄 요약(문제→가치→증거→CTA→다음 액션)
+
+# 출력 형식(Output)
+- 섹션별로 구분해 마크다운으로 출력(제목, 오프닝, 가치제안, 증거, CTA, PS 등)
+- 마지막: **검증 체크리스트**(□ 개인화 필드 □ 금칙어 없음 □ 길이 준수 □ 가치/증거/CTA 명확)
+- **다음 액션 3가지**(예: 캘린더 링크, 사례 PDF, 2차 연락 스케줄)
+"""
+
+def compose_final_prompt(
+    domain_key, subdomains, pains, pain_subs, outs, out_subs, users, user_subs, techs,
+    domain_note, pain_note, out_note, user_note, kpi_text, tone_text, ng_text, format_override,
+    fewshot_text, rag_text,
+    use_rag, rag_topk
+):
+    if not domain_key or not outs or not users or not techs:
+        return "⚠️ ‘구분/Output/User/기술’을 선택하세요."
+
+    format_hint = guess_format_hint(outs, format_override)
+    audience = ", ".join(user_subs or users)
+    kpi = kpi_text.strip() or ("오픈율/CTR/응답·미팅 수" if "외부" in domain_key else "정확성/근거/가독성")
+    tone = tone_text.strip() or ("직접적·간결·ROI 중심" if "세일즈" in " ".join(users or []) else "명료·객관·간결")
+    ng = ng_text.strip() or "과장·근거 없는 수치·모호한 표현"
+
+    blocks=[]
+    for t in techs:
+        reasons = uniq(reason_from_pain(t, pains, pain_subs) +
+                       reason_from_output(t, outs, out_subs) +
+                       reason_from_user(t, users, user_subs))
+        head = f"- **{t}** — {TECH_GLOSSARY.get(t,{}).get('desc','')}"
+        tail = ""
+        if reasons:
+            tail = "\n  - 선정 근거: " + " / ".join(reasons[:4])
+        dom = domain_reco(t, outs)
+        if dom: tail += f"\n  - 도메인 권장: {dom}"
+        blocks.append((head + tail).rstrip())
+
+    rag_section = ""
+    if use_rag:
+        query = f"{' '.join(outs)} | {' '.join(out_subs or [])} | {' '.join(users)} | {' '.join(pains)} | {pain_note} | {out_note}"
+        ctx, srcs = make_context_block(query, k=int(rag_topk))
+        rag_section = f"""# RAG 컨텍스트
+- 질의: {query}
+- Top-{rag_topk} 컨텍스트:
+{ctx}
+
+- 출처:
+{srcs}
+
+- 지시: **컨텍스트 범위 내에서만** 서술하고, 문서에 없는 내용은 ‘근거 없음’으로 명시."""
+    else:
+        if rag_text.strip():
+            rag_section = f"# 참고 자료 메모(수기)\n{rag_text.strip()}"
+
+    if fewshot_text.strip():
+        blocks.append(f"- **Few-shot 예시**: {fewshot_text.strip()}")
+
+    return TEMPLATE.format(
+        domain=domain_key,
+        out=", ".join(outs),
+        user=", ".join(users) + (" / " + ", ".join(user_subs) if user_subs else ""),
+        pain=", ".join(pains) + (" / " + ", ".join(pain_subs) if pain_subs else ""),
+        subdomain=", ".join(subdomains or ["-"]),
+        domain_note=domain_note or "-",
+        pain_sub=", ".join(pain_subs or ["-"]),
+        pain_note=pain_note or "-",
+        out_sub=", ".join(out_subs or ["-"]),
+        out_note=out_note or "-",
+        user_sub=", ".join(user_subs or ["-"]),
+        user_note=user_note or "-",
+        kpi=kpi,
+        audience=audience,
+        format_hint=format_hint,
+        tone=tone,
+        ng=ng,
+        tech_blocks="\n\n".join(blocks),
+        rag_section=rag_section or ""
+    )
+
+# -----------------------------
+# 여러 기술 설명 한꺼번에 보기
+# -----------------------------
+def render_multi_rationales(tech_list: List[str],
+                            domain_key, subdomains, pains, pain_subs, outs, out_subs, users, user_subs):
+    if not tech_list:
+        return "기술을 하나 이상 선택하세요."
+    sections=[]
+    for t in tech_list:
+        sec = build_rationale_detailed(t, domain_key, subdomains, pains, pain_subs, outs, out_subs, users, user_subs)
+        if sec:
+            sections.append(sec)
+    return ("\n\n---\n\n".join(sections)).strip()
+
+# -----------------------------
+# UI
+# -----------------------------
+DEFAULT_DOMAIN = "2 시장·고객 리서치"
+D = CATALOG[DEFAULT_DOMAIN]
+
+with gr.Blocks(title="Mixed Prompt Composer — Rationale + RAG + Multi Preview") as demo:
+    gr.Markdown("## 융합 프롬프팅 — 콤보 + 자유 입력 + **강화 Rationale** + **RAG(FAISS)** + **여러 기술 한꺼번에 미리보기**")
+
+    # 1) 도메인/세부 + 자유입력
+    with gr.Row():
+        domain = gr.Dropdown(label="구분(대분류)", choices=list(CATALOG.keys()), value=DEFAULT_DOMAIN)
+        subdomain = gr.Dropdown(label="세부 도메인(복수 선택)", choices=D["subdomains"], multiselect=True, value=["시장보고서"])
+    domain_note = gr.Textbox(label="도메인 메모(자유 입력)", placeholder="예: 북미 SaaS B2B 중심, 최신 분기 기준")
+
+    # 2) Pain + 자유입력
+    with gr.Row():
+        pains = gr.Dropdown(label="Pain Points(복수 선택)", choices=D["pains"], multiselect=True, value=["경쟁사 정보 부족"])
+        pain_detail = gr.Dropdown(label="Pain 세부(복수 선택)", choices=PAIN_SUB["경쟁사 정보 부족"], multiselect=True, value=["자료 수집"])
+    pain_note = gr.Textbox(label="Pain 메모(자유 입력)", placeholder="예: 유료 리포트 접근 제한, 2024 Q3 데이터 필요")
+
+    # 3) Output + 자유입력
+    with gr.Row():
+        outs = gr.Dropdown(label="Outputs(복수 선택)", choices=D["outputs"], multiselect=True, value=["시장조사 보고서"])
+        out_detail = gr.Dropdown(label="Output 세부(복수 선택)", choices=OUTPUT_SUB["시장조사 보고서"], multiselect=True, value=["리서치 브리프"])
+    out_note = gr.Textbox(label="Output 스펙(자유 입력)", placeholder="예: 8~10p, 표/그래프 4개, 경쟁 5사, 출처 각주 필수")
+
+    # 4) User + 자유입력
+    with gr.Row():
+        users = gr.Dropdown(label="Users(복수 선택)", choices=D["users"], multiselect=True, value=["전략팀"])
+        user_detail = gr.Dropdown(label="User 세부(복수 선택)", choices=USER_SUB["전략팀"], multiselect=True, value=["Corp Strategy"])
+    user_note = gr.Textbox(label="User 메모(자유 입력)", placeholder="예: 경영진 브리핑용 1-pager 요약 추가 필요")
+
+    # 5) 자동 추천 & 기술 선택
+    with gr.Row():
+        auto_btn = gr.Button("🔮 Mixed Prompts 자동 추천")
+        techs = gr.Dropdown(label="Mixed Prompts(복수 선택/수정 가능)", choices=ALL_TECHS, multiselect=True)
+
+    # 6) 고급 설정
+    with gr.Accordion("고급 설정(오버라이드 & 예시/근거)", open=False):
+        with gr.Row():
+            kpi_text = gr.Textbox(label="KPI(오버라이드)", placeholder="예: 인사이트 정확성, 경영진 의사결정 지원")
+            tone_text = gr.Textbox(label="톤(오버라이드)", placeholder="예: 객관·간결·데이터 중심")
+        with gr.Row():
+            ng_text = gr.Textbox(label="금지어/NG(오버라이드)", placeholder="예: 과장, 출처 미표기, 추정 수치 단정화")
+            format_override = gr.Textbox(label="형식(오버라이드)", placeholder="예: 요약/현황/경쟁/인사이트/권고/한계")
+        fewshot_text = gr.Textbox(label="Few-shot 예시(자유 입력)", lines=4, placeholder="[샘플] 제목/오프닝/근거/CTA…")
+        rag_text = gr.Textbox(label="참고 자료 메모(수기 RAG 대체/보완)", lines=3)
+
+    # 7) 여러 기술 “한꺼번에” 상세 미리보기
+    with gr.Accordion("📖 선택한 프롬프트 기술 — 설명 & Rationale (복수 펼쳐보기)", open=True):
+        with gr.Row():
+            tech_preview = gr.Dropdown(label="미리볼 기술(복수 선택)", choices=ALL_TECHS, multiselect=True)
+            from_selected_btn = gr.Button("현재 Mixed Prompts 전체 설명 보기")
+        rationale_md = gr.Markdown("여러 기술을 선택하면 **설명 & 선정 근거**를 한꺼번에 펼칩니다.")
+
+    # 8) RAG 업로드/인덱싱
+    gr.Markdown("### 📚 RAG — 파일 업로드 → 인덱싱 → 융합 프롬프팅 자동 주입")
+    with gr.Row():
+        rag_files = gr.Files(label="문서 업로드(pdf/docx/csv/txt 복수)", file_count="multiple", file_types=[".pdf",".docx",".csv",".txt"])
+        build_btn = gr.Button("🔨 인덱스 구축")
+        rag_status = gr.Markdown("상태: 인덱스 없음")
+    with gr.Row():
+        use_rag = gr.Checkbox(label="RAG 사용", value=False)
+        rag_topk = gr.Slider(1,10,value=5,step=1,label="RAG Top-K")
+
+    # 9) 최종 프롬프트
+    gen_btn = gr.Button("🚀 구조화된 융합 프롬프팅 생성")
+    final_box = gr.Textbox(label="최종 융합 프롬프트 (복사하여 Gemini/Claude/Perplexity/OpenAI에 사용)", lines=28, show_copy_button=True)
+
+    # ===== 이벤트 바인딩 =====
+    def on_domain_change(dkey):
+        cfg = CATALOG.get(dkey, {})
+        return (gr.update(choices=cfg.get("subdomains", []), value=[]),
+                gr.update(choices=cfg.get("pains", []), value=[]),
+                gr.update(choices=[], value=[]),
+                gr.update(choices=cfg.get("outputs", []), value=[]),
+                gr.update(choices=[], value=[]),
+                gr.update(choices=cfg.get("users", []), value=[]),
+                gr.update(choices=[], value=[]))
+    domain.change(on_domain_change, inputs=[domain],
+                  outputs=[subdomain, pains, pain_detail, outs, out_detail, users, user_detail])
+
+    def on_pain_change(ps):
+        ch=[]; [ch.extend(PAIN_SUB.get(p, [])) for p in (ps or [])]
+        return gr.update(choices=uniq(ch), value=[])
+    pains.change(on_pain_change, inputs=[pains], outputs=[pain_detail])
+
+    def on_out_change(osel):
+        ch=[]; [ch.extend(OUTPUT_SUB.get(o, [])) for o in (osel or [])]
+        return gr.update(choices=uniq(ch), value=[])
+    outs.change(on_out_change, inputs=[outs], outputs=[out_detail])
+
+    def on_user_change(usel):
+        ch=[]; [ch.extend(USER_SUB.get(u, [])) for u in (usel or [])]
+        return gr.update(choices=uniq(ch), value=[])
+    users.change(on_user_change, inputs=[users], outputs=[user_detail])
+
+    def do_auto(dkey, ps, osel, usel):
+        rec = auto_recommend(dkey, ps or [], osel or [], usel or [])
+        return gr.update(value=rec, choices=uniq(ALL_TECHS + rec))
+    auto_btn.click(do_auto, inputs=[domain, pains, outs, users], outputs=[techs])
+
+    # 여러 기술 “한꺼번에” 상세 미리보기
+    tech_preview.change(
+        render_multi_rationales,
+        inputs=[tech_preview, domain, subdomain, pains, pain_detail, outs, out_detail, users, user_detail],
+        outputs=[rationale_md]
+    )
+    from_selected_btn.click(
+        lambda cur: gr.update(value=cur),
+        inputs=[techs],
+        outputs=[tech_preview]
+    ).then(
+        render_multi_rationales,
+        inputs=[tech_preview, domain, subdomain, pains, pain_detail, outs, out_detail, users, user_detail],
+        outputs=[rationale_md]
+    )
+
+    # RAG 인덱싱
+    build_btn.click(lambda files: build_index(files, 800, 200),
+                    inputs=[rag_files], outputs=[rag_status])
+
+    # 최종 프롬프트 생성
+    gen_btn.click(
+        compose_final_prompt,
+        inputs=[
+            domain, subdomain, pains, pain_detail, outs, out_detail, users, user_detail, techs,
+            # free text
+            domain_note, pain_note, out_note, user_note,
+            # overrides
+            kpi_text, tone_text, ng_text, format_override,
+            # extras
+            fewshot_text, rag_text,
+            # RAG
+            use_rag, rag_topk
+        ],
+        outputs=[final_box]
+    )
+
+# ================== 런치 (Spaces/로컬 공통) ==================
+if __name__ == "__main__":
+    # (선택) Basic Auth: Space Secrets에 HF_AUTH_LIST="alice:pw1,bob:pw2"
+    auth_pairs = []
+    if os.getenv("HF_AUTH_LIST", "").strip():
+        for pair in os.getenv("HF_AUTH_LIST").split(","):
+            if ":" in pair:
+                u, p = pair.split(":", 1)
+                auth_pairs.append((u.strip(), p.strip()))
+
+    launch_kwargs = {"server_name": "0.0.0.0"}
+    if auth_pairs:
+        launch_kwargs["auth"] = auth_pairs
+
+    demo.queue()             # Gradio Queue 활성화(동시 접속 안전)
+    demo.launch(**launch_kwargs)