streamlit_app.py

# 안정적인 AI 카피라이터 - 임베딩 기반 RAG 시스템
# Hugging Face Spaces 환경 최적화 버전

import streamlit as st
import pandas as pd
import numpy as np
import pickle
import google.generativeai as genai
import time
import json
import os
from datetime import datetime

# 환경 설정 (권한 문제 해결)
os.environ['STREAMLIT_BROWSER_GATHER_USAGE_STATS'] = 'false'
os.environ['TRANSFORMERS_CACHE'] = '/tmp/transformers'
os.environ['SENTENCE_TRANSFORMERS_HOME'] = '/tmp/sentence_transformers'

# 페이지 설정
st.set_page_config(
    page_title="AI 카피라이터 | RAG 기반 광고 카피 생성",
    page_icon="✨",
    layout="wide",
    initial_sidebar_state="expanded"
)

# 제목 및 설명
st.title("✨ AI 카피라이터")
st.markdown("### 🎯 37,671개 실제 광고 카피 데이터 기반 RAG 시스템")
st.markdown("---")

# 사이드바 설정
st.sidebar.header("🎛️ 카피 생성 설정")

# API 키 입력 (환경변수 우선 사용)
default_api_key = os.getenv("GEMINI_API_KEY", "")

api_key = st.sidebar.text_input(
    "🔑 Gemini API 키",
    value=default_api_key,
    type="password",
    help="환경변수에 GEMINI_API_KEY로 설정하면 자동 입력됩니다"
)

if not api_key:
    st.warning("⚠️ Gemini API 키를 입력해주세요")
    st.info("💡 Settings → Repository secrets에서 GEMINI_API_KEY를 설정하세요")
    st.stop()

# 시스템 초기화 (캐싱) - 임베딩 필수!
@st.cache_resource(show_spinner=False)
def load_system():
    """시스템 컴포넌트 로딩 - 임베딩 기반 RAG 시스템"""

    progress_container = st.container()

    with progress_container:
        # 전체 진행률
        total_progress = st.progress(0)
        status_text = st.empty()

        # 1단계: API 설정 (10%)
        status_text.text("🔑 Gemini API 초기화 중...")
        try:
            genai.configure(api_key=api_key)
            model = genai.GenerativeModel('gemini-2.0-flash')
            total_progress.progress(10)
            st.success("✅ Gemini API 설정 완료")
        except Exception as e:
            st.error(f"❌ Gemini API 설정 실패: {e}")
            return None, None, None, None

        # 2단계: 임베딩 모델 로드 (40%)
        status_text.text("🤖 한국어 임베딩 모델 로딩 중... (1-2분 소요)")
        embedding_model = None

        # 안정적인 모델 로딩 전략
        try:
            # 먼저 캐시 디렉토리 생성
            os.makedirs('/tmp/sentence_transformers', exist_ok=True)
            os.makedirs('/tmp/transformers', exist_ok=True)

            # sentence-transformers 임포트를 함수 내에서
            from sentence_transformers import SentenceTransformer
            from sklearn.metrics.pairwise import cosine_similarity

            # 한국어 모델 로딩 시도
            embedding_model = SentenceTransformer('jhgan/ko-sbert-nli',
                                                cache_folder='/tmp/sentence_transformers')
            total_progress.progress(40)
            st.success("✅ 한국어 임베딩 모델 로딩 완료")

        except Exception as e:
            st.error(f"❌ 임베딩 모델 로딩 실패: {e}")
            st.error("🚨 임베딩 모델 없이는 RAG 시스템이 작동할 수 없습니다!")
            return None, None, None, None

        # 3단계: 데이터 로드 (60%)
        status_text.text("📊 카피 데이터베이스 로딩 중...")
        try:
            df = pd.read_excel('광고카피데이터_브랜드추출완료.xlsx')
            total_progress.progress(60)
            st.success(f"✅ 데이터 로딩 완료: {len(df):,}개 카피")
        except Exception as e:
            st.error(f"❌ 데이터 로딩 실패: {e}")
            return None, None, None, None

        # 4단계: 임베딩 데이터 로드 (90%) - 이게 핵심!
        status_text.text("🔍 벡터 임베딩 로딩 중... (RAG 시스템 핵심)")
        try:
            with open('copy_embeddings.pkl', 'rb') as f:
                embeddings_data = pickle.load(f)
            embeddings = embeddings_data['embeddings']
            total_progress.progress(90)
            st.success(f"✅ 임베딩 로딩 완료: {embeddings.shape[0]:,}개 × {embeddings.shape[1]}차원")
        except Exception as e:
            st.error(f"❌ 임베딩 로딩 실패: {e}")
            st.error("🚨 임베딩 없이는 의미적 검색이 불가능합니다!")
            return None, None, None, None

        # 5단계: 최종 검증 (100%)
        status_text.text("✨ 시스템 검증 중...")
        if model and embedding_model and df is not None and embeddings is not None:
            total_progress.progress(100)
            status_text.text("🎉 RAG 시스템 로딩 완료!")

            # 성공 메시지
            success_col1, success_col2, success_col3 = st.columns(3)
            with success_col1:
                st.metric("카피 데이터", f"{len(df):,}개")
            with success_col2:
                st.metric("임베딩 차원", f"{embeddings.shape[1]}D")
            with success_col3:
                st.metric("검색 엔진", "Korean SBERT")

            # 진행률 바 제거
            time.sleep(1)
            total_progress.empty()
            status_text.empty()

            return model, embedding_model, df, embeddings
        else:
            st.error("❌ 시스템 로딩 실패: 필수 구성요소 누락")
            return None, None, None, None

# 시스템 로딩
with st.spinner("🚀 AI 카피라이터 시스템 초기화 중..."):
    model, embedding_model, df, embeddings = load_system()

if model is None or embedding_model is None or df is None or embeddings is None:
    st.error("❌ 시스템을 로딩할 수 없습니다. 페이지를 새로고침하거나 관리자에게 문의하세요.")
    st.stop()

# 사이드바 설정 (시스템 로딩 성공 후)
st.sidebar.success("🎉 RAG 시스템 준비 완료!")

# 카테고리 선택
categories = ['전체'] + sorted(df['카테고리'].unique().tolist())
selected_category = st.sidebar.selectbox(
    "📂 카테고리",
    categories,
    help="특정 카테고리로 검색을 제한할 수 있습니다"
)

# 타겟 고객 설정
target_audience = st.sidebar.selectbox(
    "🎯 타겟 고객",
    ['20대', '30대', '일반', '10대', '40대', '50대+', '남성', '여성', '직장인', '학생', '주부'],
    help="타겟 고객에 맞는 톤앤매너로 카피를 생성합니다"
)

# 브랜드 톤앤매너
brand_tone = st.sidebar.selectbox(
    "🎨 브랜드 톤",
    ['세련된', '친근한', '고급스러운', '활기찬', '신뢰할 수 있는', '젊은', '따뜻한', '전문적인'],
    help="원하는 브랜드 이미지를 선택하세요"
)

# 창의성 수준
creative_level = st.sidebar.select_slider(
    "🧠 창의성 수준",
    options=['보수적', '균형', '창의적'],
    value='균형',
    help="보수적: 안전한 표현, 창의적: 독창적 표현"
)

# 메인 입력 영역
st.markdown("## 💭 어떤 카피를 만들고 싶으신가요?")

# 입력 방식 선택
input_method = st.radio(
    "입력 방식 선택:",
    ["직접 입력", "템플릿 선택"],
    horizontal=True
)

if input_method == "직접 입력":
    user_request = st.text_area(
        "카피 요청을 자세히 작성해주세요:",
        placeholder="예: 30대 직장 여성용 프리미엄 스킨케어 신제품 런칭 카피",
        height=100
    )
else:
    # 템플릿 선택
    templates = {
        "신제품 런칭": "대상 {카테고리} 신제품 런칭 카피",
        "할인 이벤트": "{카테고리} 할인 이벤트 프로모션 카피",
        "브랜드 슬로건": "{카테고리} 브랜드의 대표 슬로건",
        "앱/서비스 리뉴얼": "{서비스명} 새 버전 출시 카피",
        "시즌 한정": "{시즌} 한정 {카테고리} 특별 에디션 카피"
    }

    selected_template = st.selectbox("템플릿 선택:", list(templates.keys()))

    col1, col2 = st.columns(2)
    with col1:
        template_category = st.text_input("제품/서비스:", value="")
    with col2:
        if selected_template == "앱/서비스 리뉴얼":
            service_name = st.text_input("서비스명:", placeholder="예: 배달앱, 금융앱")
            user_request = templates[selected_template].format(서비스명=service_name)
        elif selected_template == "시즌 한정":
            season = st.selectbox("시즌:", ["봄", "여름", "가을", "겨울", "크리스마스", "신년"])
            user_request = templates[selected_template].format(시즌=season, 카테고리=template_category)
        else:
            user_request = templates[selected_template].format(카테고리=template_category)

    st.text_area("생성된 요청:", value=user_request, height=80, disabled=True)

# 고급 옵션
with st.expander("🔧 고급 옵션"):
    col1, col2 = st.columns(2)
    with col1:
        num_concepts = st.slider("생성할 컨셉 수:", 1, 5, 3)
        min_similarity = st.slider("최소 유사도:", 0.0, 1.0, 0.3, 0.1)
    with col2:
        show_references = st.checkbox("참고 카피 보기", value=True)
        num_references = st.slider("참고 카피 수:", 3, 10, 5)

# RAG 카피 생성 함수 (임베딩 기반 필수!)
def generate_copy_with_rag(user_request, category, target, tone, creative, num_concepts):
    """RAG 기반 카피 생성 - 임베딩 필수 사용"""

    if not user_request.strip():
        st.error("❌ 카피 요청을 입력해주세요")
        return None

    # 진행 상황 표시
    progress_bar = st.progress(0)
    status_text = st.empty()

    # 1단계: 의미적 검색 (임베딩 기반)
    status_text.text("🔍 의미적 검색 중... (RAG 핵심 기능)")
    progress_bar.progress(20)

    try:
        # 검색 쿼리 생성 및 임베딩
        search_query = f"{user_request} {target} 광고 카피"
        from sklearn.metrics.pairwise import cosine_similarity
        query_embedding = embedding_model.encode([search_query])

        # 카테고리 필터링
        if category != '전체':
            filtered_df = df[df['카테고리'] == category]
        else:
            filtered_df = df

        progress_bar.progress(40)

        # 유사도 계산 (임베딩의 핵심!)
        filtered_indices = filtered_df.index.tolist()
        filtered_embeddings = embeddings[filtered_indices]
        similarities = cosine_similarity(query_embedding, filtered_embeddings)[0]

        # 상위 참고 카피 선별
        top_indices = np.argsort(similarities)[::-1][:num_references]

        reference_copies = []
        for idx in top_indices:
            original_idx = filtered_indices[idx]
            row = df.iloc[original_idx]
            if similarities[idx] >= min_similarity:
                reference_copies.append({
                    'copy': row['카피 내용'],
                    'brand': row['브랜드'],
                    'similarity': similarities[idx]
                })

        progress_bar.progress(60)

        if not reference_copies:
            st.warning(f"⚠️ 유사도 {min_similarity} 이상인 참고 카피를 찾을 수 없습니다. 유사도를 낮춰보세요.")
            progress_bar.empty()
            status_text.empty()
            return None

        # 2단계: AI 카피 생성
        status_text.text("🤖 AI 카피 생성 중...")
        progress_bar.progress(80)

        # 프롬프트 생성
        references_text = "\n".join([
            f"{i}. \"{ref['copy']}\" - {ref['brand']} (유사도: {ref['similarity']:.3f})"
            for i, ref in enumerate(reference_copies, 1)
        ])

        creativity_guidance = {
            "보수적": "안전하고 검증된 표현을 사용하여",
            "균형": "창의적이면서도 적절한 수준에서",
            "창의적": "독창적이고 혁신적인 표현으로"
        }

        prompt = f"""
당신은 한국의 전문 광고 카피라이터입니다.

**요청사항:** {user_request}
**타겟 고객:** {target}
**브랜드 톤:** {tone}
**창의성 수준:** {creative}

**참고 카피들 (의미적 유사도 기반 선별):**
{references_text}

**작성 가이드라인:**
1. 위 참고 카피들의 스타일과 톤을 분석하여 유사한 느낌으로 작성
2. {creativity_guidance[creative]} 새로운 카피 {num_concepts}개를 작성
3. 각 카피는 한국어로 자연스럽고 매력적이어야 함
4. {target}에게 어필할 수 있는 표현 사용
5. {tone} 톤앤매너 유지

**출력 형식:**
1. [카피1]
   - 설명: 왜 이 카피가 효과적인지 간단히 설명

2. [카피2]
   - 설명: 왜 이 카피가 효과적인지 간단히 설명

3. [카피3]
   - 설명: 왜 이 카피가 효과적인지 간단히 설명

**추천 카피:** 위 중 가장 추천하는 카피와 이유
"""

        response = model.generate_content(prompt)
        progress_bar.progress(100)
        status_text.text("✅ 완료!")

        time.sleep(0.5)
        progress_bar.empty()
        status_text.empty()

        return {
            'references': reference_copies,
            'generated_content': response.text,
            'search_info': {
                'query': search_query,
                'total_candidates': len(filtered_df),
                'selected_references': len(reference_copies)
            },
            'settings': {
                'category': category,
                'target': target,
                'tone': tone,
                'creative': creative
            }
        }

    except Exception as e:
        st.error(f"❌ 카피 생성 실패: {e}")
        progress_bar.empty()
        status_text.empty()
        return None

# 생성 버튼
if st.button("🚀 카피 생성하기", type="primary", use_container_width=True):

    if not user_request or not user_request.strip():
        st.error("❌ 카피 요청을 입력해주세요")
    else:
        # RAG 카피 생성
        result = generate_copy_with_rag(
            user_request=user_request,
            category=selected_category,
            target=target_audience,
            tone=brand_tone,
            creative=creative_level,
            num_concepts=num_concepts
        )

        if result:
            # 결과 표시
            st.markdown("## 🎉 생성된 카피")
            st.markdown("---")

            # 검색 정보 표시
            st.info(f"🔍 **검색 정보**: {result['search_info']['total_candidates']:,}개 후보에서 "
                   f"{result['search_info']['selected_references']}개 참고 카피 선별")

            # 참고 카피 표시
            if show_references and result['references']:
                with st.expander("📚 참고한 카피들 (의미적 유사도 기반 선별)"):
                    for i, ref in enumerate(result['references'], 1):
                        st.markdown(f"**{i}.** \"{ref['copy']}\"")
                        st.markdown(f"   - 브랜드: {ref['brand']}")
                        st.markdown(f"   - 유사도: {ref['similarity']:.3f}")
                        st.markdown("")

            # 생성된 카피 표시
            st.markdown("### ✨ AI가 생성한 카피:")
            st.markdown(result['generated_content'])

            # 결과 다운로드
            result_json = json.dumps({
                'timestamp': datetime.now().isoformat(),
                'request': user_request,
                'settings': result['settings'],
                'search_info': result['search_info'],
                'generated_content': result['generated_content']
            }, ensure_ascii=False, indent=2)

            st.download_button(
                label="💾 결과 다운로드 (JSON)",
                data=result_json,
                file_name=f"copy_result_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
                mime="application/json"
            )

# 시스템 정보 (사이드바 하단)
st.sidebar.markdown("---")
st.sidebar.markdown("### 📊 RAG 시스템 정보")
if df is not None and embeddings is not None:
    st.sidebar.markdown(f"**카피 데이터**: {len(df):,}개")
    st.sidebar.markdown(f"**카테고리**: {df['카테고리'].nunique()}개")
    st.sidebar.markdown(f"**브랜드**: {df['브랜드'].nunique()}개")
    st.sidebar.markdown(f"**임베딩**: {embeddings.shape[1]}차원")
    st.sidebar.markdown("**검색 엔진**: Korean SBERT")
    st.sidebar.markdown("**호스팅**: 🤗 Hugging Face")

# 사용법 가이드
with st.expander("💡 RAG 시스템 사용법 가이드"):
    st.markdown("""
    ### 🎯 효과적인 사용법

    **1. 구체적인 요청하기:**
    - ❌ "카피 써줘"
    - ✅ "30대 직장 여성용 프리미엄 스킨케어 신제품 런칭 카피"

    **2. RAG 시스템의 장점:**
    - 🧠 **의미적 검색**: 키워드뿐만 아니라 의미까지 이해
    - 🎯 **문맥 매칭**: 타겟과 상황에 맞는 카피 자동 선별
    - 📊 **데이터 기반**: 37,671개 실제 카피에서 학습한 패턴

    **3. 창의성 조절:**
    - **보수적**: 안전한 클라이언트, 검증된 접근
    - **균형**: 일반적인 프로젝트 (추천!)
    - **창의적**: 혁신적 브랜드, 파격적 캠페인

    **4. 참고 카피 활용:**
    - 생성된 카피와 참고 카피를 비교 분석
    - 트렌드와 패턴 파악 가능
    - 경쟁사 분석 자료로 활용
    """)

# 푸터
st.markdown("---")
st.markdown(
    "💡 **AI 카피라이터** | 37,671개 실제 광고 카피 데이터 기반 | "
    "RAG(검색 증강 생성) 시스템 powered by Korean SBERT + Gemini AI"
)

# 성능 모니터링 (개발자용)
if os.getenv("DEBUG_MODE"):
    st.sidebar.markdown("### 🔧 디버그 정보")
    if 'embeddings' in locals():
        st.sidebar.write(f"임베딩 메모리: {embeddings.nbytes / (1024*1024):.1f}MB")
    st.sidebar.write(f"Streamlit 버전: {st.__version__}")