Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,11 +1,9 @@
-# Hugging Face Spaces용 app.py
-# 원본 streamlit_app.py에서 환경변수 처리만 개선
+# 안정적인 AI 카피라이터 - 임베딩 기반 RAG 시스템
+# Hugging Face Spaces 환경 최적화 버전
 
 import streamlit as st
 import pandas as pd
 import numpy as np
-from sentence_transformers import SentenceTransformer
-from sklearn.metrics.pairwise import cosine_similarity
 import pickle
 import google.generativeai as genai
 import time
@@ -13,6 +11,11 @@ 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 기반 광고 카피 생성",
@@ -23,7 +26,7 @@ st.set_page_config(
 
 # 제목 및 설명
 st.title("✨ AI 카피라이터")
-st.markdown("### 🎯 37,000개 실제 광고 카피 데이터 기반 RAG 시스템")
+st.markdown("### 🎯 37,671개 실제 광고 카피 데이터 기반 RAG 시스템")
 st.markdown("---")
 
 # 사이드바 설정
@@ -33,59 +36,123 @@ st.sidebar.header("🎛️ 카피 생성 설정")
 default_api_key = os.getenv("GEMINI_API_KEY", "")
 
 api_key = st.sidebar.text_input(
-    "🔑 Gemini API 키",
+    "🔑 Gemini API 키", 
     value=default_api_key,
     type="password",
-    help="https://makersuite.google.com/app/apikey 에서 발급\n환경변수에 GEMINI_API_KEY로 설정하면 자동 입력됩니다"
+    help="환경변수에 GEMINI_API_KEY로 설정하면 자동 입력됩니다"
 )
 
 if not api_key:
     st.warning("⚠️ Gemini API 키를 입력해주세요")
-    st.info("💡 Hugging Face Spaces 관리자라면 Settings → Repository secrets에서 GEMINI_API_KEY를 설정하세요")
+    st.info("💡 Settings → Repository secrets에서 GEMINI_API_KEY를 설정하세요")
     st.stop()
 
-# 시스템 초기화 (캐싱)
-@st.cache_resource
+# 시스템 초기화 (캐싱) - 임베딩 필수!
+@st.cache_resource(show_spinner=False)
 def load_system():
-    """시스템 컴포넌트 로딩 (한 번만 실행)"""
-    try:
-        # API 설정
-        genai.configure(api_key=api_key)
-        model = genai.GenerativeModel('gemini-2.5-flash-preview-05-20')
-
-        # 임베딩 모델 로드
-        with st.spinner("🤖 Korean SBERT 모델 로딩 중... (최초 1-2분 소요)"):
-            embedding_model = SentenceTransformer('jhgan/ko-sbert-nli')
-
-        # 데이터 로드
-        with st.spinner("📊 카피 데이터베이스 로딩 중..."):
+    """시스템 컴포넌트 로딩 - 임베딩 기반 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')
-
-        # 임베딩 로드
-        with st.spinner("🔍 벡터 임베딩 로딩 중..."):
+            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']
-
-        return model, embedding_model, df, embeddings
-    except FileNotFoundError as e:
-        st.error(f"❌ 파일을 찾을 수 없습니다: {e}")
-        st.error("필요한 파일들이 올바른 위치에 있는지 확인해주세요:")
-        st.code("- 광고카피데이터_브랜드추출완료.xlsx\n- copy_embeddings.pkl")
-        return None, None, None, None
-    except Exception as e:
-        st.error(f"❌ 시스템 로딩 실패: {e}")
-        return None, None, None, None
+            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:
-    st.error("❌ 시스템을 로딩할 수 없습니다.")
+if model is None or embedding_model is None or df is None or embeddings is None:
+    st.error("❌ 시스템을 로딩할 수 없습니다. 페이지를 새로고침하거나 관리자에게 문의하세요.")
     st.stop()
 
-st.success(f"✅ 시스템 로딩 완료: {len(df):,}개 카피 데이터베이스")
+# 사이드바 설정 (시스템 로딩 성공 후)
+st.sidebar.success("🎉 RAG 시스템 준비 완료!")
 
 # 카테고리 선택
 categories = ['전체'] + sorted(df['카테고리'].unique().tolist())
@@ -98,14 +165,14 @@ selected_category = st.sidebar.selectbox(
 # 타겟 고객 설정
 target_audience = st.sidebar.selectbox(
     "🎯 타겟 고객",
-    ['일반', '10대', '20대', '30대', '40대', '50대+', '남성', '여성', '직장인', '학생', '주부'],
-    index=2  # 20대 기본 선택
+    ['20대', '30대', '일반', '10대', '40대', '50대+', '남성', '여성', '직장인', '학생', '주부'],
+    help="타겟 고객에 맞는 톤앤매너로 카피를 생성합니다"
 )
 
 # 브랜드 톤앤매너
 brand_tone = st.sidebar.selectbox(
     "🎨 브랜드 톤",
-    ['친근한', '세련된', '고급스러운', '활기찬', '신뢰할 수 있는', '젊은', '따뜻한', '전문적인'],
+    ['세련된', '친근한', '고급스러운', '활기찬', '신뢰할 수 있는', '젊은', '따뜻한', '전문적인'],
     help="원하는 브랜드 이미지를 선택하세요"
 )
 
@@ -136,37 +203,28 @@ if input_method == "직접 입력":
 else:
     # 템플릿 선택
     templates = {
-        "신제품 런칭": "{타겟} 대상 {카테고리} 신제품 런칭 카피",
-        "할인 이벤트": "{카테고리} {타겟} 할인 이벤트 프로모션 카피",
+        "신제품 런칭": "대상 {카테고리} 신제품 런칭 카피",
+        "할인 이벤트": "{카테고리} 할인 이벤트 프로모션 카피", 
         "브랜드 슬로건": "{카테고리} 브랜드의 대표 슬로건",
-        "앱/서비스 리뉴얼": "{타겟} 대상 {서비스명} 새 버전 출시 카피",
+        "앱/서비스 리뉴얼": "{서비스명} 새 버전 출시 카피",
         "시즌 한정": "{시즌} 한정 {카테고리} 특별 에디션 카피"
     }
-
+    
     selected_template = st.selectbox("템플릿 선택:", list(templates.keys()))
-
-    # 템플릿 커스터마이징
+    
     col1, col2 = st.columns(2)
     with col1:
-        template_target = st.text_input("타겟 고객:", value=target_audience)
-    with col2:
         template_category = st.text_input("제품/서비스:", value="")
-
-    if selected_template == "앱/서비스 리뉴얼":
-        service_name = st.text_input("서비스명:", placeholder="예: 배달앱, 금융앱")
-        user_request = templates[selected_template].format(
-            타겟=template_target, 서비스명=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_target, 카테고리=template_category
-        )
-
+    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)
 
 # 고급 옵션
@@ -174,81 +232,85 @@ with st.expander("🔧 고급 옵션"):
     col1, col2 = st.columns(2)
     with col1:
         num_concepts = st.slider("생성할 컨셉 수:", 1, 5, 3)
-        exclude_brand = st.text_input("제외할 브랜드:", placeholder="경쟁사 브랜드명")
-    with col2:
         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)
 
-# 카피 생성 함수
-def generate_copy_web(user_request, category, target, tone, creative, num_concepts):
-    """웹용 카피 생성 함수"""
-
+# 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("🔍 관련 카피 검색 중...")
+    
+    # 1단계: 의미적 검색 (임베딩 기반)
+    status_text.text("🔍 의미적 검색 중... (RAG 핵심 기능)")
     progress_bar.progress(20)
-
-    # 검색 쿼리 생성
-    search_query = f"{user_request} {target} 광고 카피"
-    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]
-
-    # 상위 5개 선별
-    top_indices = np.argsort(similarities)[::-1][:5]
-
-    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} 이상인 참고 카피를 찾을 수 없습니다.")
-        return None
-
-    # 2단계: 카피 생성
-    status_text.text("🤖 AI 카피 생성 중...")
-    progress_bar.progress(80)
-
-    # 프롬프트 생성
-    references_text = "\n".join([
-        f"{i}. \"{ref['copy']}\" - {ref['brand']}"
-        for i, ref in enumerate(reference_copies, 1)
-    ])
-
-    creativity_guidance = {
-        "보수적": "안전하고 검증된 표현을 사용하여",
-        "균형": "창의적이면서도 적절한 수준에서",
-        "창의적": "독창적이고 혁신적인 표현으로"
-    }
-
-    prompt = f"""
+    
+    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}
@@ -256,7 +318,7 @@ def generate_copy_web(user_request, category, target, tone, creative, num_concep
 **브랜드 톤:** {tone}
 **창의성 수준:** {creative}
 
-**참고 카피들:**
+**참고 카피들 (의미적 유사도 기반 선별):**
 {references_text}
 
 **작성 가이드라인:**
@@ -270,7 +332,7 @@ def generate_copy_web(user_request, category, target, tone, creative, num_concep
 1. [카피1]
    - 설명: 왜 이 카피가 효과적인지 간단히 설명
 
-2. [카피2]
+2. [카피2] 
    - 설명: 왜 이 카피가 효과적인지 간단히 설명
 
 3. [카피3]
@@ -278,19 +340,23 @@ def generate_copy_web(user_request, category, target, tone, creative, num_concep
 
 **추천 카피:** 위 중 가장 추천하는 카피와 이유
 """
-
-    try:
+        
         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,
@@ -298,19 +364,21 @@ def generate_copy_web(user_request, category, target, tone, creative, num_concep
                 '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:
-        # 카피 생성
-        result = generate_copy_web(
+        # RAG 카피 생성
+        result = generate_copy_with_rag(
             user_request=user_request,
             category=selected_category,
             target=target_audience,
@@ -318,33 +386,38 @@ if st.button("🚀 카피 생성하기", type="primary", use_container_width=Tru
             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("📚 참고한 카피들"):
+                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['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,
@@ -352,35 +425,42 @@ if st.button("🚀 카피 생성하기", type="primary", use_container_width=Tru
                 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("💡 사용법 가이드"):
+with st.expander("💡 RAG 시스템 사용법 가이드"):
     st.markdown("""
     ### 🎯 효과적인 사용법
-
+    
     **1. 구체적인 요청하기:**
     - ❌ "카피 써줘"
     - ✅ "30대 직장 여성용 프리미엄 스킨케어 신제품 런칭 카피"
-
-    **2. 카테고리 활용:**
-    - 정확한 카테고리 선택으로 더 관련성 높은 참고 자료 확보
-
+    
+    **2. RAG 시스템의 장점:**
+    - 🧠 **의미적 검색**: 키워드뿐만 아니라 의미까지 이해
+    - 🎯 **문맥 매칭**: 타겟과 상황에 맞는 카피 자동 선별
+    - 📊 **데이터 기반**: 37,671개 실제 카피에서 학습한 패턴
+    
     **3. 창의성 조절:**
     - **보수적**: 안전한 클라이언트, 검증된 접근
     - **균형**: 일반적인 프로젝트 (추천!)
     - **창의적**: 혁신적 브랜드, 파격적 캠페인
-
-    **4. 여러 버전 생성:**
-    - 컨셉 수를 3-5개로 설정해서 다양한 옵션 확보
+    
+    **4. 참고 카피 활용:**
+    - 생성된 카피와 참고 카피를 비교 분석
+    - 트렌드와 패턴 파악 가능
+    - 경쟁사 분석 자료로 활용
     """)
 
-# 시스템 정보 (사이드바 하단)
-st.sidebar.markdown("---")
-st.sidebar.markdown("### 📊 시스템 정보")
-st.sidebar.markdown(f"**데이터**: {len(df):,}개 카피")
-st.sidebar.markdown(f"**카테고리**: {df['카테고리'].nunique()}개")
-st.sidebar.markdown(f"**브랜드**: {df['브랜드'].nunique()}개")
-st.sidebar.markdown("**호스팅**: 🤗 Hugging Face")
-
 # 푸터
 st.markdown("---")
 st.markdown(
@@ -388,6 +468,9 @@ st.markdown(
     "RAG(검색 증강 생성) 시스템 powered by Korean SBERT + Gemini AI"
 )
 
-# Hugging Face 전용 정보
-if os.getenv("SPACE_ID"):  # Hugging Face Spaces에서만 표시
-    st.markdown("🚀 **Powered by Hugging Face Spaces** | 완전 무료 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__}")