Upload 12 files

app.py

@@ -0,0 +1,347 @@
+import gradio as gr
+import os
+import json
+import time
+from datetime import datetime
+
+# 모듈 임포트
+from modules.image_analyzer import analyze_image
+from modules.question_generator import generate_questions
+from modules.persona_generator import generate_persona
+from modules.chat_engine import start_conversation, process_message
+from modules.data_manager import save_persona, load_persona, list_personas, save_conversation
+from modules.gemini_handler import get_persona_enhancement
+
+# 디렉토리 확인
+try:
+    for dir_path in [
+        "data/user_personas",
+        "data/conversation_logs",
+        "assets/examples"
+    ]:
+        os.makedirs(dir_path, exist_ok=True)
+except Exception as e:
+    print(f"초기 디렉토리 생성 중 오류: {str(e)}")
+    print("허깅페이스 환경에서는 일부 파일 저장 기능이 제한될 수 있습니다.")
+
+# 기본 성격 특성 범위
+trait_range = {"min": 0, "max": 100, "step": 5, "value": 50}
+
+# UI 테마 및 스타일 설정
+theme = gr.themes.Soft(
+    primary_hue="indigo",
+    secondary_hue="blue",
+).set(
+    button_primary_background_fill="*primary_500",
+    button_primary_background_fill_hover="*primary_600",
+    button_primary_text_color="white",
+    block_title_text_color="*primary_800",
+    block_label_text_size="sm"
+)
+
+# 메인 애플리케이션
+with gr.Blocks(title="사물 페르소나 생성기", theme=theme, css="styles/custom.css") as app:
+    gr.Markdown(
+        """
+        # 🧸 물魂 (물건의 혼) - 사물 페르소나 생성기
+        
+        일상 사물에 개성과 성격을 부여하여 대화할 수 있는 페르소나 생성 및 테스트 도구입니다.
+        """
+    )
+    
+    # 전역 상태 관리
+    current_persona = gr.State({})
+    conversation_history = gr.State([])
+    session_start_time = gr.State(None)
+    
+    with gr.Tabs() as tabs:
+        # 페르소나 생성 탭
+        with gr.Tab("페르소나 생성"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    gr.Markdown("## 사물 정보")
+                    with gr.Row():
+                        object_image = gr.Image(
+                            label="사물 이미지 (선택사항)",
+                            type="filepath"
+                        )
+                        image_analysis_btn = gr.Button("이미지 분석하기")
+                    
+                    with gr.Row():
+                        object_name = gr.Textbox(
+                            label="사물 이름", 
+                            placeholder="예: 할아버지의 낡은 안락의자"
+                        )
+                        object_type = gr.Dropdown(
+                            choices=[
+                                "전자기기", "가구", "주방용품", 
+                                "의류/액세서리", "책/문구류", 
+                                "음악 기구", "장난감", "기타"
+                            ],
+                            label="사물 유형"
+                        )
+                    
+                    object_age = gr.Textbox(
+                        label="사물 나이/사용 기간", 
+                        placeholder="예: 15년"
+                    )
+                    
+                    object_description = gr.Textbox(
+                        label="사물 설명",
+                        placeholder="물체의 외형, 특징, 용도 등을 설명해주세요.",
+                        lines=3
+                    )
+                    
+                    image_analysis_result = gr.JSON(
+                        label="이미지 분석 결과", 
+                        visible=False
+                    )
+                
+                with gr.Column(scale=3):
+                    gr.Markdown("## 성격 특성")
+                    
+                    with gr.Row():
+                        with gr.Column():
+                            warmth = gr.Slider(
+                                label="온기", 
+                                info="따뜻함, 친절함, 선의의 정도",
+                                **trait_range
+                            )
+                            competence = gr.Slider(
+                                label="능력", 
+                                info="효율성, 기술, 지능의 정도",
+                                **trait_range
+                            )
+                            trustworthiness = gr.Slider(
+                                label="신뢰성", 
+                                info="일관성, 정직함, 안정성의 정도",
+                                **trait_range
+                            )
+                        
+                        with gr.Column():
+                            friendliness = gr.Slider(
+                                label="친화성", 
+                                info="사교성, 개방성, 접근성의 정도",
+                                **trait_range
+                            )
+                            creativity = gr.Slider(
+                                label="창의성", 
+                                info="독창성, 상상력, 혁신성의 정도",
+                                **trait_range
+                            )
+                            humor = gr.Slider(
+                                label="유머감각", 
+                                info="재치, 위트, 유머 표현 정도",
+                                **trait_range
+                            )
+                    
+                    gr.Markdown("## 매력적 결함")
+                    flaws = gr.CheckboxGroup(
+                        choices=[
+                            "때때로 너무 조심스러움", 
+                            "가끔 과하게 열정적", 
+                            "약간의 완벽주의", 
+                            "때로는 우울한 생각에 빠짐",
+                            "간혹 산만해짐",
+                            "약간의 고집",
+                            "때로는 지나치게 솔직함",
+                            "가끔 불안해함",
+                            "종종 과거에 집착함",
+                            "가끔 너무 이상적임"
+                        ],
+                        label="매력적인 결함 (최대 2개 선택)",
+                    )
+                    
+                    gr.Markdown("## 소통 방식")
+                    with gr.Row():
+                        with gr.Column():
+                            communication_style = gr.Radio(
+                                choices=[
+                                    "활발하고 에너지 넘치는", 
+                                    "차분하고 사려깊은",
+                                    "위트있고 재치있는", 
+                                    "따뜻하고 공감적인",
+                                    "논리적이고 분석적인"
+                                ],
+                                label="대화 스타일",
+                                value="따뜻하고 공감적인"
+                            )
+                            
+                            humor_style = gr.Dropdown(
+                                choices=[
+                                    "재치있는 말장난", 
+                                    "상황적 유머", 
+                                    "자기 비하적 유머",
+                                    "가벼운 농담", 
+                                    "블랙 유머", 
+                                    "유머 거의 없음"
+                                ],
+                                multiselect=True,
+                                label="유머 유형"
+                            )
+                        
+                        with gr.Column():
+                            speech_pattern = gr.Textbox(
+                                label="말투 패턴 예시",
+                                placeholder="캐릭터의 특징적인 말투나 표현을 입력하세요",
+                                lines=2
+                            )
+                            
+                            interests = gr.Textbox(
+                                label="관심사 (쉼표로 구분)",
+                                placeholder="음악, 요리, 여행, 역사..."
+                            )
+            
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("## 관계 성향")
+                    
+                    with gr.Row():
+                        attachment_style = gr.Radio(
+                            choices=["안정형", "불안형", "회피형", "혼란형"],
+                            label="애착 스타일",
+                            value="안정형"
+                        )
+                        
+                        relationship_depth = gr.Radio(
+                            choices=["얕은", "중간", "깊은"],
+                            label="관계 깊이 선호도",
+                            value="중간"
+                        )
+                    
+                    initial_attitude = gr.Radio(
+                        choices=["수줍은", "중립적", "친근한", "열정적", "조심스러운"],
+                        label="초기 태도",
+                        value="친근한"
+                    )
+                
+                with gr.Column():
+                    backstory = gr.Textbox(
+                        label="배경 이야기",
+                        placeholder="이 사물의 역사, 경험, 소유자와의 관계 등을 간략히 서술하세요",
+                        lines=4
+                    )
+            
+            with gr.Row():
+                with gr.Column():
+                    template_selector = gr.Dropdown(
+                        choices=[
+                            "템플릿 없음",
+                            "스마트폰 - 열정적 조력자",
+                            "오래된 안락의자 - 지혜로운 관찰자",
+                            "커피머신 - 활기찬 에너자이저",
+                            "오래된 책 - 사려깊은 학자",
+                            "가죽 가방 - 신뢰할 수 있는 동반자"
+                        ],
+                        label="템플릿 선택",
+                        value="템플릿 없음"
+                    )
+                    load_template_btn = gr.Button("템플릿 불러오기")
+                
+                with gr.Column():
+                    create_btn = gr.Button("페르소나 생성하기", variant="primary")
+            
+            # 생성된 페르소나 출력
+            generated_persona = gr.JSON(label="생성된 페르소나")
+            
+            # 이벤트 핸들러
+            image_analysis_btn.click(
+                fn=analyze_image,
+                inputs=[object_image],
+                outputs=[image_analysis_result, warmth, competence, trustworthiness, 
+                         friendliness, creativity, humor, object_type, object_description]
+            )
+            
+            create_btn.click(
+                fn=generate_persona,
+                inputs=[
+                    object_name, object_type, object_age, object_description,
+                    warmth, competence, trustworthiness, friendliness, creativity, humor,
+                    flaws, communication_style, humor_style, speech_pattern, interests,
+                    attachment_style, relationship_depth, initial_attitude, backstory,
+                    image_analysis_result
+                ],
+                outputs=[generated_persona, current_persona]
+            )
+            
+            # 템플릿 로드 기능 추가 예정
+        
+        # 대화 테스트 탭
+        with gr.Tab("대화 테스트"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    chat_display = gr.Chatbot(
+                        label="대화 내용",
+                        height=500,
+                        avatar_images=(None, "assets/icons/persona_avatar.png")
+                    )
+                    
+                    with gr.Row():
+                        user_message = gr.Textbox(
+                            label="메시지 입력",
+                            placeholder="메시지를 입력하세요...",
+                            lines=2
+                        )
+                        send_btn = gr.Button("전송", variant="primary")
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("## 현재 페르소나")
+                    persona_info = gr.Markdown("페르소나를 먼저 생성하거나 불러오세요.")
+                    
+                    start_chat_btn = gr.Button("대화 시작하기")
+                    load_persona_btn = gr.Button("저장된 페르소나 불러오기")
+                    
+                    gr.Markdown("## 대화 통계")
+                    chat_stats = gr.Markdown("대화가 시작되지 않았습니다.")
+                    
+                    export_chat_btn = gr.Button("대화 내용 저장")
+                    export_result = gr.Textbox(label="저장 결과", visible=False)
+            
+            # 이벤트 핸들러
+            start_chat_btn.click(
+                fn=start_conversation,
+                inputs=[current_persona],
+                outputs=[chat_display, conversation_history, session_start_time, chat_stats, persona_info]
+            )
+            
+            send_btn.click(
+                fn=process_message,
+                inputs=[user_message, conversation_history, current_persona, session_start_time],
+                outputs=[chat_display, conversation_history, user_message, chat_stats]
+            )
+            
+            # Enter 키로 메시지 전송
+            user_message.submit(
+                fn=process_message,
+                inputs=[user_message, conversation_history, current_persona, session_start_time],
+                outputs=[chat_display, conversation_history, user_message, chat_stats]
+            )
+        
+        # 페르소나 라이브러리 탭
+        with gr.Tab("페르소나 라이브러리"):
+            with gr.Row():
+                with gr.Column():
+                    refresh_library_btn = gr.Button("라이브러리 새로고침")
+                    personas_table = gr.Dataframe(
+                        headers=["이름", "유형", "생성일", "파일명"],
+                        datatype=["str", "str", "str", "str"],
+                        label="저장된 페르소나 목록"
+                    )
+                
+                with gr.Column():
+                    selected_persona_json = gr.JSON(label="선택된 페르소나 정보")
+                    load_to_editor_btn = gr.Button("에디터로 불러오기")
+                    load_to_chat_btn = gr.Button("대화 테스트로 불러오기")
+            
+            # 이벤트 핸들러
+            refresh_library_btn.click(
+                fn=list_personas,
+                inputs=[],
+                outputs=[personas_table]
+            )
+            
+            # 선택한 페르소나 로드 기능 추가 예정
+
+# 앱 실행
+if __name__ == "__main__":
+    app.launch() 

info.md

@@ -0,0 +1,475 @@
+# 사물 페르소나 생성기 (物魂 Creator)
+
+## 1. 프로젝트 개요
+
+사물 페르소나 생성기는 일상 사물에 고유한 성격과 개성을 부여하고 테스트할 수 있는 실험적 도구입니다. 본 도구는 "일상 사물 인격화를 통한 관계형성 AI 시스템 연구"를 뒷받침하기 위한 페르소나 생성, 테스트 및 데이터 수집을 목적으로 합니다. 사물의 물리적 특성으로부터 성격을 추론하고, 이를 다양한 설정을 통해 조정하며, 생성된 페르소나와의 대화를 통해 관계 발전 양상을 연구합니다.
+
+## 2. 코드 구현 및 기능 모듈
+
+### 2.1 이미지 기반 성격 추론 모듈 (`image_analyzer.py`)
+- **이미지 분석 시스템**
+  - PIL/Pillow 라이브러리 활용 이미지 로드 및 처리
+  - 물리적 특성(형태, 색상, 재질) 추출 함수 구현
+  - 특성별 성격 매핑 로직: `analyze_image()` 함수로 구현
+
+- **물리적 특성-성격 매핑 엔진**
+  - JSON 기반 매핑 데이터 관리: `load_trait_mappings()` 함수
+  - 형태 매핑: 곡선형/직선형/대칭형/비대칭형/단순형/복잡형
+  - 색상 매핑: 밝은/어두운/따뜻한/차가운/화려한/단색
+  - 재질 매핑: 나무/금속/유리/가죽/플라스틱/천/종이
+  - 매핑 데이터 자동 생성 및 로드 기능
+
+### 2.2 질문 생성 및 페르소나 강화 모듈 (`question_generator.py`, `persona_generator.py`)
+- **AI 기반 맞춤형 질문 생성기**
+  - 사물 유형별 특화 질문 템플릿 (8개 카테고리)
+  - 성격 특성별 맞춤형 질문 생성 로직
+  - Google Gemini API 활용 동적 질문 생성: `generate_llm_questions()` 함수
+
+- **페르소나 강화 시스템**
+  - `generate_persona()`: 전체 페르소나 생성 파이프라인 함수
+  - `get_persona_enhancement()`: Google Gemini API 호출로 페르소나 풍부화
+  - 성격 특성 요약 자동 생성: `get_trait_summary()` 함수
+  - 배경 이야기, 경험 자동 생성: `generate_experiences()` 함수
+
+### 2.3 대화 처리 모듈 (`chat_engine.py`, `gemini_handler.py`)
+- **실시간 채팅 시스템**
+  - 대화 초기화: `start_conversation()` 함수
+  - 메시지 처리: `process_message()` 함수
+  - 대화 내용 관리 및 통계 트래킹 구현
+
+- **응답 생성 엔진**
+  - Google Gemini API 연동: `generate_response()` 함수
+  - 프롬프트 엔지니어링: 페르소나 특성에 맞는 응답 유도
+  - 초기 인사말 생성: `generate_initial_greeting()` 함수
+
+### 2.4 데이터 관리 모듈 (`data_manager.py`)
+- **파일 시스템 기반 데이터 관리**
+  - 페르소나 저장: `save_persona()` 함수
+  - 페르소나 로드: `load_persona()` 함수
+  - 대화 기록 저장: `save_conversation()` 함수
+  - 페르소나 및 대화 목록화: `list_personas()`, `list_conversations()` 함수
+
+- **데이터 분석 기능**
+  - 페르소나 특성 분포 분석: `analyze_persona_trait_distribution()` 함수
+  - 대화 통계 분석: `get_conversation_statistics()` 함수
+
+### 2.5 프롬프트 관리 시스템 (`prompt_templates.py`)
+- **템플릿 기반 프롬프트 관리**
+  - 페르소나 강화용 프롬프트: `PERSONA_ENHANCEMENT_TEMPLATE`
+  - 이미지 분석용 프롬프트: `IMAGE_ANALYSIS_TEMPLATE`
+  - 대화 응답용 프롬프트: `CONVERSATION_RESPONSE_TEMPLATE`
+  - 질문 생성용 프롬프트: `QUESTION_GENERATION_TEMPLATE`
+
+- **프롬프트 포맷 함수**
+  - `format_persona_enhancement_prompt()`: 페르소나 강화 프롬프트 포맷
+  - `format_conversation_prompt()`: 대화 응답 프롬프트 포맷
+  - `format_question_generation_prompt()`: 질문 생성 프롬프트 포맷
+
+### 2.6 웹 인터페이스 (`app.py`)
+- **Gradio 기반 UI 구현**
+  - 3개 탭 구성: 페르소나 생성, 대화 테스트, 페르소나 라이브러리
+  - 이벤트 핸들러 연결: 버튼 클릭, 입력 제출 등
+  - 상태 관리: gr.State()를 활용한 페르소나 및 대화 상태 관리
+
+- **요소별 UI 컴포넌트**
+  - 이미지 업로드 및 분석: gr.Image, image_analysis_btn
+  - 성격 특성 슬라이더: gr.Slider 컴포넌트 6개 활용
+  - 채팅 인터페이스: gr.Chatbot, gr.Textbox 조합
+
+## 3. 기술 스택 및 의존성
+
+### 3.1 핵심 라이브러리
+- **Gradio**: 웹 인터페이스 구현 (v3.50.2 이상)
+- **Python-dotenv**: 환경 변수 관리
+- **Requests**: API 통신
+- **Pillow**: 이미지 처리
+- **NumPy**: 수치 연산
+- **Matplotlib**: 데이터 시각화 (향후 구현 예정)
+
+### 3.2 API 통합
+- **Google Gemini API**: LLM 기반 텍스트 생성
+  - `gemini_query()`: API 요청 함수
+  - JSON 파싱: `extract_json()` 함수
+
+### 3.3 파일 시스템 구조
+```
+persona_creator/
+├── app.py                     # 메인 그라디오 애플리케이션
+├── requirements.txt           # 의존성 패키지
+├── packages.txt               # 시스템 패키지
+├── README.md                  # 사용 설명서
+├── modules/
+│   ├── image_analyzer.py      # 이미지 분석 및 특성 추출
+│   ├── question_generator.py  # 동적 질문 생성 엔진
+│   ├── persona_generator.py   # 페르소나 생성 엔진
+│   ├── chat_engine.py         # 대화 처리 및 기록
+│   ├── gemini_handler.py      # 제미나이 API 연동
+│   ├── prompt_templates.py    # LLM 프롬프트 템플릿
+│   └── data_manager.py        # 데이터 저장 및 분석
+├── data/
+│   ├── trait_mappings/        # 물리적-성격 특성 매핑 데이터
+│   │   ├── shape_traits.json  # 형태-성격 매핑 규칙
+│   │   ├── color_traits.json  # 색상-성격 매핑 규칙
+│   │   └── material_traits.json # 재질-성격 매핑 규칙
+│   ├── user_personas/         # 사용자 생성 페르소나
+│   └── conversation_logs/     # 대화 기록 저장소
+├── styles/
+│   └── custom.css             # UI 커스텀 스타일
+└── assets/
+    ├── examples/              # 예시 이미지
+    └── icons/                 # UI 아이콘
+```
+
+## 4. 데이터 구조 및 스키마
+
+### 4.1 페르소나 JSON 스키마
+```json
+{
+  "기본정보": {
+    "이름": "String",
+    "유형": "String",
+    "나이": "String",
+    "설명": "String",
+    "생성일시": "String (YYYY-MM-DD HH:MM:SS)"
+  },
+  "성격특성": {
+    "온기": "Integer (0-100)",
+    "능력": "Integer (0-100)",
+    "신뢰성": "Integer (0-100)",
+    "친화성": "Integer (0-100)",
+    "창의성": "Integer (0-100)",
+    "유머감각": "Integer (0-100)"
+  },
+  "성격요약": "String",
+  "매력적결함": ["String", "String"],
+  "소통방식": "String",
+  "유머스타일": "String",
+  "말투패턴": "String",
+  "관심사": ["String", "String", "String", ...],
+  "배경이야기": "String",
+  "경험": ["String", "String", "String", ...],
+  "관계성향": {
+    "애착스타일": "String",
+    "관계깊이선호도": "String",
+    "초기태도": "String"
+  },
+  "filepath": "String (저장 경로)"
+}
+```
+
+### 4.2 대화 기록 JSON 스키마
+```json
+{
+  "persona_name": "String",
+  "persona_type": "String",
+  "start_time": "String (YYYY-MM-DD HH:MM:SS)",
+  "current_time": "String (YYYY-MM-DD HH:MM:SS)",
+  "duration_seconds": "Integer",
+  "messages": [
+    {
+      "role": "String (system|user|assistant)",
+      "content": "String",
+      "timestamp": "String (YYYY-MM-DD HH:MM:SS)"
+    },
+    ...
+  ]
+}
+```
+
+### 4.3 매핑 데이터 스키마
+```json
+{
+  "특성유형": {
+    "특성값": {
+      "성격특성": [최소값, 최대값]
+    }
+  }
+}
+```
+
+## 5. 사용자 플로우 시퀀스
+
+### 5.1 페르소나 생성 시퀀스
+1. 이미지 업로드 → `image_analyzer.py` → 특성 추출
+2. 성격 특성 조정 → 슬라이더 UI → 특성 값 설정
+3. 매력적 결함, 소통 방식 선택 → 선택형 UI
+4. 생성 버튼 클릭 → `persona_generator.py` → 페르소나 생성
+5. Google Gemini API 호출 → 페르소나 강화 → JSON 결과 표시
+6. 자동 저장 → `data_manager.py` → 파일시스템 저장
+
+### 5.2 대화 테스트 시퀀스
+1. 페르소나 선택 → `load_persona()` → 메모리에 로드
+2. 대화 시작 → `start_conversation()` → 인사말 생성
+3. 사용자 입력 → `process_message()` → 메시지 기록
+4. Gemini API 호출 → `generate_response()` → 응답 생성
+5. 응답 표시 → Chatbot UI 업데이트 → 통계 업데이트
+6. 대화 저장 → `save_conversation()` → JSON 저장
+
+## 6. 프롬프트 시스템 상세
+
+### 6.1 페르소나 강화 프롬프트 구성
+- **기본 정보 섹션**: 이름, 유형, 설명
+- **성격 특성 섹션**: 6개 주요 특성 및 값
+- **소통 방식 섹션**: 대화/유머 스타일, 말투 패턴
+- **관계 성향 섹션**: 애착 스타일, 관계 깊이, 초기 태도
+- **강화 지시사항**: 배경 확장, 관심사 추가, 말투 구체화, 성격 특성 독특화
+
+### 6.2 대화 응답 프롬프트 구성
+- **페르소나 정보 섹션**: 기본 정보, 성격 특성, 배경 이야기
+- **표현 방식 섹션**: 소통 방식, 유머 스타일, 매력적 결함
+- **대화 맥락 섹션**: 최근 대화 기록 포함
+- **응답 지시사항**: 페르소나 역할 유지, 성격 특성 반영, 한국어 응답
+
+## 7. 핵심 함수 및 로직
+
+### 7.1 이미지 분석 파이프라인
+```python
+# 이미지 업로드 → 분석 → 특성 매핑 → UI 업데이트
+image_analysis_btn.click(
+    fn=analyze_image,
+    inputs=[object_image],
+    outputs=[image_analysis_result, warmth, competence, trustworthiness, 
+             friendliness, creativity, humor, object_type, object_description]
+)
+```
+
+### 7.2 페르소나 생성 파이프라인
+```python
+# 모든 입력 데이터 → 페르소나 생성 → JSON 결과
+create_btn.click(
+    fn=generate_persona,
+    inputs=[
+        object_name, object_type, object_age, object_description,
+        warmth, competence, trustworthiness, friendliness, creativity, humor,
+        flaws, communication_style, humor_style, speech_pattern, interests,
+        attachment_style, relationship_depth, initial_attitude, backstory,
+        image_analysis_result
+    ],
+    outputs=[generated_persona, current_persona]
+)
+```
+
+### 7.3 대화 처리 파이프라인
+```python
+# 사용자 메시지 → 대화 처리 → 응답 생성 → UI 업데이트
+send_btn.click(
+    fn=process_message,
+    inputs=[user_message, conversation_history, current_persona, session_start_time],
+    outputs=[chat_display, conversation_history, user_message, chat_stats]
+)
+```
+
+## 8. 향후 개발 계획
+
+### 8.1 이미지 분석 고도화
+- **컴퓨터 비전 API 통합**
+  - Google Cloud Vision API 또는 Azure Computer Vision API 연동
+  - image_analyzer.py 확장: 실제 객체 인식 및 속성 추출 구현
+  - 이미지 감정 분석 알고리즘 추가
+
+- **물리적-성격 매핑 확장**
+  - 머신러닝 기반 매핑 시스템: 사용자 피드백으로 학습
+  - 더 세분화된 물리적 특성 카테고리 추가
+  - 동적 매핑 규칙 업데이트 메커니즘
+
+### 8.2 페르소나 시스템 확장
+- **모순적 특성 구현**
+  - persona_generator.py 확장: 모순 특성 정의 및 처리 모듈
+  - 상황 인식 모순 표현 로직: 특정 대화 맥락에서 발현
+  - 심층 성격 모델 도입: 5요인 모델 또는 MBTI 기반
+
+- **관계 발전 단계 시스템**
+  - 새로운 모듈 추가: relationship_tracker.py
+  - 6단계 관계 발전 모델: 친숙도, 신뢰도, 친밀도 지표
+  - 대화 분석 기반 관계 단계 자동 진단
+
+### 8.3 연구 도구 및 분석 기능
+- **데이터 분석 도구**
+  - 새로운 모듈 추가: analytics_engine.py
+  - 통계 분석 라이브러리 통합: pandas, scipy
+  - 대시보드 UI 개발: plotly 또는 dash 통합
+
+- **A/B 테스트 시스템**
+  - 실험 설계 모듈: experiment_manager.py
+  - 동일 사물의 다른 성격 버전 생성 및 비교
+  - 사용자 반응 자동 측정 및 분석
+
+## 9. 개발자 참고 사항
+
+### 9.1 API 키 설정
+- `.env` 파일에 `GEMINI_API_KEY=your_api_key` 추가
+- Google AI Studio에서 API 키 발급 필요
+- API 비용 추적: 페르소나 생성당 약 0.0002-0.0005 USD
+
+### 9.2 개발 환경 설정
+```bash
+# 가상환경 생성
+python -m venv venv
+source venv/bin/activate  # Linux/Mac
+venv\Scripts\activate     # Windows
+
+# 의존성 설치
+pip install -r requirements.txt
+
+# 애플리케이션 실행
+python app.py
+```
+
+### 9.3 Flutter 앱 개발 환경 설정
+```bash
+# Flutter SDK 설치
+flutter doctor
+
+# Flutter 프로젝트 생성
+flutter create memory_tag_app
+cd memory_tag_app
+
+# 필요한 패키지 추가
+flutter pub add google_generative_ai
+flutter pub add qr_flutter
+flutter pub add qr_code_scanner
+flutter pub add speech_to_text
+flutter pub add flutter_tts
+flutter pub add shared_preferences
+flutter pub add camera
+flutter pub add path_provider
+```
+
+### 9.4 Flutter 애플리케이션 구조
+```
+memory_tag_app/
+├── lib/
+│   ├── main.dart                # 앱 진입점
+│   ├── screens/
+│   │   ├── home_screen.dart     # 홈 화면
+│   │   ├── scan_screen.dart     # QR 스캔 화면
+│   │   ├── chat_screen.dart     # 대화 화면
+│   │   ├── create_screen.dart   # 페르소나 생성 화면
+│   │   └── settings_screen.dart # 설정 화면
+│   ├── models/
+│   │   ├── persona.dart         # 페르소나 모델
+│   │   └── message.dart         # 대화 메시지 모델
+│   ├── services/
+│   │   ├── gemini_service.dart   # Google Gemini API 연동
+│   │   ├── storage_service.dart  # 로컬 스토리지 관리
+│   │   ├── stt_service.dart      # 음성-텍스트 변환
+│   │   └── tts_service.dart      # 텍스트-음성 변환
+│   ├── widgets/
+│   │   ├── chat_bubble.dart     # 채팅 버블 UI
+│   │   ├── voice_input_button.dart # 음성 입력 버튼
+│   │   └── persona_card.dart    # 페르소나 카드 UI
+│   └── utils/
+│       ├── constants.dart       # 상수 정의
+│       └── prompt_templates.dart # 프롬프트 템플릿
+├── assets/
+│   ├── images/                  # 이미지 리소스
+│   └── sounds/                  # 사운드 리소스
+└── pubspec.yaml                 # 의존성 관리
+```
+
+### 9.5 Google Gemini API 활용
+- **멀티모달 기능 구현**
+  - 카메라로 캡처한 사�� 이미지를 Gemini Pro Vision API에 전송
+  - 텍스트와 이미지를 동시에 처리하는 멀티모달 프롬프트 설계
+  - 이미지 인식 결과를 바탕으로 사물 성격 자동 추론
+
+- **제미나이 모델 활용 전략**
+  - Gemini 1.5 Pro: 복잡한 페르소나 생성 및 긴 컨텍스트 대화용
+  - Gemini 1.5 Flash: 빠른 응답이 필요한 일상 대화용
+  - 적절한 모델 선택을 통한 비용 최적화 구현
+
+- **대화 메모리 관리**
+  - 벡터 임베딩을 활용한 대화 메모리 구현
+  - 중요 대화를 요약하여 장기 메모리에 저장
+  - 상황에 따른 관련 기억 검색 알고리즘 구현
+
+### 9.6 QR 코드 기반 연결 시스템
+- **QR 코드 생성 및 관리**
+  - 페르소나 ID와 메타데이터를 포함한 QR 코드 생성
+  - 위치 정보를 QR 코드에 포함하여 공간 인식 기능 구현
+  - 보안을 위한 QR 코드 암호화 옵션 제공
+
+- **스캔 및 상호작용 흐름**
+  - 카메라를 통한 QR 코드 인식 → 페르소나 정보 로드
+  - 이전 대화 이력 검색 → 대화 컨텍스트 구성
+  - 위치 기반 맞춤형 인사말 및 화제 제안
+
+### 9.7 음성 인터페이스
+- **STT(음성-텍스트) 파이프라인**
+  - `speech_to_text` 패키지를 활용한 실시간 음성 인식
+  - 오디오 스트림 처리 및 잡음 필터링
+  - 다국어 지원(한국어, 영어, 일본어)
+
+- **TTS(텍스트-음성) 파이프라인**
+  - Google Cloud TTS API 활용한 자연스러운 음성 생성
+  - 페르소나별 맞춤 음성(음높이, 속도, 악센트) 설정
+  - SSML 태그를 활용한 표현력 있는 음성 구현
+
+### 9.8 성능 최적화 전략
+- **오프라인 모드 지원**
+  - 핵심 대화 패턴의 로컬 캐싱
+  - 네트워크 연결 없이 기본 응답 생성 가능
+  - 연결 복구 시 자동 동기화
+
+- **배터리 및 데이터 사용량 최적화**
+  - 저전력 모드에서의 동작 방식 조정
+  - 요청 배치 처리를 통한 API 호출 최소화
+  - 압축 알고리즘을 활용한 데이터 전송량 감소
+
+### 9.9 코드 확장 가이드라인
+- 모듈 확장 시 기존 인터페이스 유지
+- 새 기능은 별도 모듈로 구현 후 app.py에 통합
+- 데이터 스키마 변경 시 하위 호환성 고려
+- 로깅 시스템: app.py 내 logging 모듈 설정 추가 필요
+
+### 9.10 알려진 이슈 및 제한사항
+- Gemini API 한국어 응답이 때때로 불안정함
+- 이미지 분석은 현재 더미 데이터 기반 (실제 분석 미구현)
+- 대용량 대화 히스토리(20턴 이상)에서 성능 저하 발생
+- 페르소나 간 전환 시 일부 UI 상태 초기화 문제
+
+## 10. 연구 활용 방안
+
+본 도구는 현재 구현된 기능만으로도 다음과 같은 연구에 활용할 수 있습니다:
+
+- **사물 인격화 효과 연구**: 사물에 인격 부여 시 사용자 인식 변화 및 심리적 영향
+- **성격 특성 선호도 연구**: 어떤 성격 특성 조합이 더 매력적으로 느껴지는지 분석
+- **대화 패턴 연구**: 페르소나 특성에 따른 대화 패턴 차이 및 사용자 참여도 변화
+- **물리적-성격적 매핑 연구**: 사물의 물리적 특성이 어떻게 성격 특성으로 인식되는지 분석
+
+향후 개발이 진행됨에 따라 더 다양하고 심층적인 연구가 가능해질 것입니다.
+
+## 11. 모바일 앱 응용 방안
+
+### 11.1 상업적 활용 가능성
+- **실물 제품과 연동한 AI 경험**
+  - 가전제품, 인테리어 소품 등에 QR 코드 부착하여 제품 브랜딩 강화
+  - 상품 사용 가이드와 서포트를 재미있는 대화형으로 제공
+  - 브랜드 스토리텔링 및 고객 관계 구축 도구로 활용
+
+- **공간 기반 AI 컴패니언**
+  - 공공장소, 전시관, 관광지 등에 사물 페르소나 배치
+  - 사용자의 이동 경로에 따른 스토리라인 구성
+  - 모바일 AR과 결합한 증강 현실 경험 제공
+
+### 11.2 교육 및 치료적 활용
+- **학습 도우미로 활용**
+  - 학습 도구와 연결된 AI 튜터 기능
+  - 맞춤형 학습 콘텐츠 추천 및 대화형 교육
+  - 학습 진도와 이해도 추적 기능
+
+- **감정적 지원 및 치료 보조**
+  - 심리 치료 보조 도구로 활용(단, 전문가 감독 하에)
+  - 감정 표현 및 사회적 상호작용 연습
+  - 일상 루틴 관리 및 정서적 안정 지원
+
+### 11.3 대화형 IoT 통합
+- **스마트홈 시스템과 연동**
+  - IoT 기기와 연결하여 자연어로 기기 제어
+  - 사용자 생활 패턴 학습 및 맞춤형 자동화 제안
+  - 재미있는 페르소나를 통한 스마트홈 경험 향상
+
+- **위치 기반 서비스 통합**
+  - GPS 및 실내 위치 추적과 결합
+  - 장소별 맞춤형 페르소나와 대화 경험 제공
+  - 가상 가이드로서 실내 내비게이션 기능

modules/chat_engine.py

@@ -0,0 +1,256 @@
+import json
+import time
+from datetime import datetime
+from modules.gemini_handler import generate_response
+from modules.data_manager import save_conversation
+
+def start_conversation(persona):
+    """
+    페르소나와의 대화 세션을 시작합니다.
+    
+    Args:
+        persona: 페르소나 정보 딕셔너리
+    
+    Returns:
+        대화 표시 UI, 대화 내역, 세션 시작 시간, 대화 통계, 페르소나 정보 마크다운
+    """
+    if not persona:
+        return [], [], None, "페르소나가 선택되지 않았습니다.", "페르소나를 먼저 생성하거나 불러오세요."
+    
+    # 세션 시작 시간 기록
+    session_start_time = datetime.now()
+    
+    # 페르소나 정보 요약
+    name = persona.get("기본정보", {}).get("이름", "무명")
+    object_type = persona.get("기본정보", {}).get("유형", "")
+    description = persona.get("기본정보", {}).get("설명", "")
+    
+    # 성격 특성 요약
+    traits = []
+    for trait, value in persona.get("성격특성", {}).items():
+        level = "높음" if value >= 70 else "중간" if value >= 40 else "낮음"
+        traits.append(f"- {trait}: {level} ({value}/100)")
+    
+    # 페르소나 정보 마크다운 생성
+    persona_info = f"""
+## {name}
+**유형**: {object_type}  
+**설명**: {description}
+
+### 성격 특성
+{' '.join(traits)}
+
+**소통방식**: {persona.get("소통방식", "")}  
+**매력적 결함**: {', '.join(persona.get("매력적결함", []))}  
+**관심사**: {', '.join(persona.get("관심사", []))}
+"""
+    
+    # 환영 메시지 생성
+    welcome_message = generate_initial_greeting(persona)
+    
+    # 대화 내역 초기화
+    conversation_history = [{
+        "role": "system",
+        "content": f"당신은 이제 '{name}'이라는 이름의 {object_type} 페르소나가 되어 대화합니다. 다음 성격과 특성에 맞게 응답하세요: {persona.get('성격요약', '')}",
+        "timestamp": session_start_time.strftime("%Y-%m-%d %H:%M:%S")
+    }, {
+        "role": "assistant",
+        "content": welcome_message,
+        "timestamp": session_start_time.strftime("%Y-%m-%d %H:%M:%S")
+    }]
+    
+    # 대화 통계 초기화
+    stats = f"""
+시작 시간: {session_start_time.strftime("%Y-%m-%d %H:%M:%S")}  
+대화 길이: 1 메시지  
+진행 시간: 0분
+"""
+    
+    # 대화 표시 UI 업데이트
+    chat_display = [(None, welcome_message)]
+    
+    return chat_display, conversation_history, session_start_time, stats, persona_info
+
+def process_message(user_message, conversation_history, persona, session_start_time):
+    """
+    사용자 메시지를 처리하고 페르소나의 응답을 생성합니다.
+    
+    Args:
+        user_message: 사용자 메시지
+        conversation_history: 이전 대화 내역
+        persona: 페르소나 정보
+        session_start_time: 세션 시작 시간
+    
+    Returns:
+        업데이트된 대화 표시 UI, 대화 내역, 빈 메시지 입력창, 대화 통계
+    """
+    if not user_message or not persona:
+        return [], conversation_history, "", "대화가 시작되지 않았습니다."
+    
+    current_time = datetime.now()
+    
+    # 사용자 메시지 추가
+    conversation_history.append({
+        "role": "user",
+        "content": user_message,
+        "timestamp": current_time.strftime("%Y-%m-%d %H:%M:%S")
+    })
+    
+    # 페르소나 응답 생성
+    response = generate_response(persona, conversation_history)
+    
+    # 응답 추가
+    conversation_history.append({
+        "role": "assistant",
+        "content": response,
+        "timestamp": current_time.strftime("%Y-%m-%d %H:%M:%S")
+    })
+    
+    # 대화 표시 UI 업데이트
+    chat_display = []
+    for msg in conversation_history:
+        if msg["role"] == "user":
+            chat_display.append((user_message, None))
+        elif msg["role"] == "assistant":
+            chat_display.append((None, msg["content"]))
+    
+    # 시스템 메시지 제외
+    chat_display = [msg for msg in chat_display if msg[0] is not None or msg[1] is not None]
+    
+    # 대화 통계 업데이트
+    elapsed_time = current_time - session_start_time if session_start_time else datetime.now() - datetime.now()
+    minutes = int(elapsed_time.total_seconds() / 60)
+    seconds = int(elapsed_time.total_seconds() % 60)
+    
+    user_msg_count = sum(1 for msg in conversation_history if msg["role"] == "user")
+    assistant_msg_count = sum(1 for msg in conversation_history if msg["role"] == "assistant")
+    
+    stats = f"""
+시작 시간: {session_start_time.strftime("%Y-%m-%d %H:%M:%S") if session_start_time else "알 수 없음"}  
+현재 시간: {current_time.strftime("%Y-%m-%d %H:%M:%S")}  
+대화 길이: {user_msg_count + assistant_msg_count} 메시지 (사용자: {user_msg_count}, 페르소나: {assistant_msg_count})  
+진행 시간: {minutes}분 {seconds}초
+"""
+    
+    # 대화 저장
+    conversation_data = {
+        "persona": persona,
+        "messages": conversation_history,
+        "start_time": session_start_time.strftime("%Y-%m-%d %H:%M:%S") if session_start_time else None,
+        "current_time": current_time.strftime("%Y-%m-%d %H:%M:%S"),
+        "duration_seconds": elapsed_time.total_seconds() if session_start_time else 0
+    }
+    
+    save_conversation(conversation_data)
+    
+    return chat_display, conversation_history, "", stats
+
+def generate_initial_greeting(persona):
+    """
+    페르소나의 성격과 특성에 맞는 초기 인사말을 생성합니다.
+    
+    Args:
+        persona: 페르소나 정보
+    
+    Returns:
+        인사말 텍스트
+    """
+    name = persona.get("기본정보", {}).get("이름", "무명")
+    object_type = persona.get("기본정보", {}).get("유형", "물건")
+    
+    # 성격 특성 가져오기
+    warmth = persona.get("성격특성", {}).get("온기", 50)
+    friendliness = persona.get("성격특성", {}).get("친화성", 50)
+    humor = persona.get("성격특성", {}).get("유머감각", 50)
+    
+    # 초기 태도
+    initial_attitude = persona.get("관계성향", {}).get("초기태도", "중립적")
+    
+    # 인사말 패턴 선택
+    if initial_attitude == "수줍은":
+        if warmth >= 60:
+            greeting = f"안녕하세요... 저는 {name}이라고 합니다. 조금 부끄럽지만, 당신과 대화할 수 있어 기쁘네요."
+        else:
+            greeting = f"음... 안녕하세요. {name}입니다. 대화에 익숙하지 않아서 어색할 수 있어요."
+    
+    elif initial_attitude == "조심스러운":
+        greeting = f"반갑습니다. 저는 {name}입니다. 천천히 서로 알아가면 좋겠네요."
+    
+    elif initial_attitude == "열정적":
+        if humor >= 70:
+            greeting = f"와! 안녕하세요! 저는 {name}이에요! 드디어 대화할 사람을 만났네요! 정말 반가워요!"
+        else:
+            greeting = f"안녕하세요! {name}입니다. 당신과 대화하게 되어 정말 기쁩니다. 많은 이야기를 나눠봐요!"
+    
+    elif initial_attitude == "친근한":
+        if friendliness >= 70:
+            greeting = f"안녕하세요~ 저는 {name}이라고 해요. 편하게 대화해요! 우리 좋은 친구가 될 수 있을 것 같아요."
+        else:
+            greeting = f"안녕하세요, {name}입니다. 반갑습니다. 좋은 대화 나누어봐요."
+    
+    else:  # 중립적
+        greeting = f"안녕하세요. 저는 {name}입니다. 당신과 대화하게 되어 반갑습니다."
+    
+    # 자기 소개 추가
+    intro = ""
+    if persona.get("배경이야기"):
+        # 배경 이야기 요약 (첫 문장 또는 일부)
+        background = persona.get("배경이야기").split('.')[0] + "."
+        intro += f" {background}"
+    
+    if persona.get("관심사"):
+        interests = persona.get("관심사")[:2]  # 처음 2개 관심사만
+        if interests:
+            intro += f" 저는 {', '.join(interests)} 같은 것에 관심이 있어요."
+    
+    # 말투 패턴 적용 (있는 경우)
+    speech_pattern = persona.get("말투패턴", "")
+    if speech_pattern:
+        # 여기서는 간단한 구현만. 실제로는 더 복잡한 말투 패턴 적용 가능
+        greeting = greeting.replace(".", speech_pattern.split('.')[-1] if '.' in speech_pattern else speech_pattern)
+    
+    return greeting + intro
+
+def export_conversation(conversation_history, persona):
+    """
+    대화 내용을 내보내기 가능한 형식으로 변환합니다.
+    
+    Args:
+        conversation_history: 대화 내역
+        persona: 페르소나 정보
+    
+    Returns:
+        내보내기 형식 데이터
+    """
+    if not conversation_history:
+        return "대화 내용이 없습니다."
+    
+    name = persona.get("기본정보", {}).get("이름", "무명")
+    
+    # 시스템 메시지 제외한 실제 대화만 추출
+    actual_conversation = [msg for msg in conversation_history if msg["role"] in ["user", "assistant"]]
+    
+    # 시작 및 종료 시간
+    start_time = actual_conversation[0]["timestamp"] if actual_conversation else None
+    end_time = actual_conversation[-1]["timestamp"] if actual_conversation else None
+    
+    # 내보내기 데이터 구성
+    export_data = {
+        "persona": {
+            "name": name,
+            "type": persona.get("기본정보", {}).get("유형", ""),
+            "description": persona.get("기본정보", {}).get("설명", ""),
+            "traits": persona.get("성격특성", {})
+        },
+        "conversation": {
+            "start_time": start_time,
+            "end_time": end_time,
+            "messages": [{
+                "sender": "사용자" if msg["role"] == "user" else name,
+                "content": msg["content"],
+                "timestamp": msg["timestamp"]
+            } for msg in actual_conversation]
+        }
+    }
+    
+    return json.dumps(export_data, ensure_ascii=False, indent=2) 

modules/data_manager.py

@@ -0,0 +1,361 @@
+import os
+import json
+import time
+from datetime import datetime
+
+# 디렉터리 경로 설정
+PERSONAS_DIR = "data/user_personas"
+CONVERSATIONS_DIR = "data/conversation_logs"
+
+def ensure_directories():
+    """필요한 디렉터리가 존재하는지 확인하고, 없으면 생성합니다."""
+    for dir_path in [PERSONAS_DIR, CONVERSATIONS_DIR]:
+        try:
+            os.makedirs(dir_path, exist_ok=True)
+        except Exception as e:
+            print(f"디렉토리 생성 중 오류: {str(e)}")
+            # 허깅페이스 환경에서는 임시 디렉토리 사용
+            temp_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "temp_data")
+            os.makedirs(temp_dir, exist_ok=True)
+            return False
+    return True
+
+def save_persona(persona_data):
+    """
+    페르소나 데이터를 JSON 파일로 저장합니다.
+    
+    Args:
+        persona_data: 저장할 페르소나 데이터
+    
+    Returns:
+        저장된 파일 경로
+    """
+    if not ensure_directories():
+        print("경고: 디렉토리 생성에 실패했습니다. 세션 데이터만 유지됩니다.")
+        persona_data["_temp_storage_warning"] = "임시 스토리지만 사용 가능합니다. 페르소나는 세션이 종료되면 사라집니다."
+        return "temp_persona"
+    
+    # 파일명 생성 (이름_타임스탬프.json)
+    name = persona_data.get("기본정보", {}).get("이름", "unnamed").replace(" ", "_")
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"{name}_{timestamp}.json"
+    
+    file_path = os.path.join(PERSONAS_DIR, filename)
+    
+    try:
+        # JSON 파일로 저장
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(persona_data, f, ensure_ascii=False, indent=2)
+        return file_path
+    except Exception as e:
+        print(f"페르소나 저장 오류: {str(e)}")
+        persona_data["_storage_error"] = str(e)
+        return "failed_to_save"
+
+def load_persona(file_path):
+    """
+    JSON 파일에서 페르소나 데이터를 로드합니다.
+    
+    Args:
+        file_path: 페르소나 파일 경로
+    
+    Returns:
+        로드된 페르소나 데이터
+    """
+    # 임시 저장 케이스 처리
+    if file_path == "temp_persona" or file_path == "failed_to_save":
+        return None
+        
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return data
+    except Exception as e:
+        print(f"페르소나 로딩 오류: {str(e)}")
+        return None
+
+def list_personas():
+    """
+    저장된 모든 페르소나 목록을 가져옵니다.
+    
+    Returns:
+        페르소나 목록 (테이블 형식)
+    """
+    ensure_directories()
+    
+    personas = []
+    
+    # 디렉터리 내 모든 JSON 파일 확인
+    for filename in os.listdir(PERSONAS_DIR):
+        if filename.endswith(".json"):
+            file_path = os.path.join(PERSONAS_DIR, filename)
+            try:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                
+                # 필요한 정보 추출
+                name = data.get("기본정보", {}).get("이름", "무명")
+                object_type = data.get("기본정보", {}).get("유형", "")
+                created = data.get("기본정보", {}).get("생성일시", "")
+                
+                personas.append([name, object_type, created, filename])
+            except Exception as e:
+                print(f"파일 읽기 오류 ({filename}): {str(e)}")
+    
+    # 최신 순으로 정렬
+    personas.sort(key=lambda x: x[2], reverse=True)
+    
+    return personas
+
+def save_conversation(conversation_data):
+    """
+    대화 데이터를 JSON 파일로 저장합니다.
+    
+    Args:
+        conversation_data: 저장할 대화 데이터
+    
+    Returns:
+        저장된 파일 경로
+    """
+    if not ensure_directories():
+        print("경고: 디렉토리 생성에 실패했습니다. 대화 데이터를 저장할 수 없습니다.")
+        return "temp_conversation"
+    
+    # 페르소나 정보 추출
+    persona = conversation_data.get("persona", {})
+    name = persona.get("기본정보", {}).get("이름", "unnamed").replace(" ", "_")
+    
+    # 페르소나별 대화 저장 디렉터리
+    persona_conv_dir = os.path.join(CONVERSATIONS_DIR, name)
+    try:
+        os.makedirs(persona_conv_dir, exist_ok=True)
+    except Exception as e:
+        print(f"대화 저장 디렉토리 생성 오류: {str(e)}")
+        return "failed_to_save_conv"
+    
+    # 파일명 생성 (타임스탬프.json)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"conversation_{timestamp}.json"
+    
+    file_path = os.path.join(persona_conv_dir, filename)
+    
+    try:
+        # JSON 파일로 저장
+        with open(file_path, "w", encoding="utf-8") as f:
+            # 메시지 내용만 저장하여 파일 크기 최적화
+            simplified_data = {
+                "persona_name": name,
+                "persona_type": persona.get("기본정보", {}).get("유형", ""),
+                "start_time": conversation_data.get("start_time", ""),
+                "current_time": conversation_data.get("current_time", ""),
+                "duration_seconds": conversation_data.get("duration_seconds", 0),
+                "messages": [{
+                    "role": msg["role"],
+                    "content": msg["content"],
+                    "timestamp": msg.get("timestamp", "")
+                } for msg in conversation_data.get("messages", [])]
+            }
+            
+            json.dump(simplified_data, f, ensure_ascii=False, indent=2)
+        
+        return file_path
+    except Exception as e:
+        print(f"대화 저장 오류: {str(e)}")
+        return "failed_to_save_conv"
+
+def list_conversations(persona_name=None):
+    """
+    저장된 대화 목록을 가져옵니다.
+    
+    Args:
+        persona_name: 특정 페르소나의 대화만 필터링 (선택 사항)
+    
+    Returns:
+        대화 목록 (테이블 형식)
+    """
+    ensure_directories()
+    
+    conversations = []
+    
+    # 모든 페르소나 디렉터리 탐색
+    for persona_dir in os.listdir(CONVERSATIONS_DIR):
+        # 특정 페르소나만 필터링
+        if persona_name and persona_name != persona_dir:
+            continue
+        
+        persona_path = os.path.join(CONVERSATIONS_DIR, persona_dir)
+        if os.path.isdir(persona_path):
+            # 디렉터리 내 모든 대화 파일 확인
+            for filename in os.listdir(persona_path):
+                if filename.endswith(".json"):
+                    file_path = os.path.join(persona_path, filename)
+                    try:
+                        with open(file_path, "r", encoding="utf-8") as f:
+                            data = json.load(f)
+                        
+                        # 필요한 정보 추출
+                        persona_name = data.get("persona_name", "무명")
+                        start_time = data.get("start_time", "")
+                        duration = data.get("duration_seconds", 0)
+                        msg_count = len(data.get("messages", []))
+                        
+                        conversations.append([
+                            persona_name, 
+                            start_time, 
+                            f"{int(duration // 60)}분 {int(duration % 60)}초",
+                            msg_count,
+                            file_path
+                        ])
+                    except Exception as e:
+                        print(f"대화 파일 읽기 오류 ({file_path}): {str(e)}")
+    
+    # 최신 순으로 정렬
+    conversations.sort(key=lambda x: x[1], reverse=True)
+    
+    return conversations
+
+def load_conversation(file_path):
+    """
+    JSON 파일에서 대화 데이터를 로드합니다.
+    
+    Args:
+        file_path: 대화 파일 경로
+    
+    Returns:
+        로드된 대화 데이터
+    """
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return data
+    except Exception as e:
+        print(f"대화 로딩 오류: {str(e)}")
+        return None
+
+def analyze_persona_trait_distribution():
+    """
+    저장된 모든 페르소나의 성격 특성 분포를 분석합니다.
+    
+    Returns:
+        특성별 평균값, 최소값, 최대값, 중앙값을 포함한 분석 결과
+    """
+    ensure_directories()
+    
+    traits_data = {
+        "온기": [],
+        "능력": [],
+        "신뢰성": [],
+        "친화성": [],
+        "창의성": [],
+        "유머감각": []
+    }
+    
+    # 모든 페르소나 파일에서 성격 특성 수집
+    for filename in os.listdir(PERSONAS_DIR):
+        if filename.endswith(".json"):
+            file_path = os.path.join(PERSONAS_DIR, filename)
+            try:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                
+                # 성격 특성 값 추출
+                for trait, values in traits_data.items():
+                    trait_value = data.get("성격특성", {}).get(trait)
+                    if trait_value is not None:
+                        values.append(trait_value)
+            except Exception as e:
+                print(f"파일 분석 오류 ({filename}): {str(e)}")
+    
+    # 분석 결과 계산
+    analysis = {}
+    for trait, values in traits_data.items():
+        if values:
+            analysis[trait] = {
+                "평균": sum(values) / len(values),
+                "��소": min(values),
+                "최대": max(values),
+                "중앙값": sorted(values)[len(values) // 2],
+                "페르소나 수": len(values)
+            }
+        else:
+            analysis[trait] = {
+                "평균": 0,
+                "최소": 0,
+                "최대": 0,
+                "중앙값": 0,
+                "페르소나 수": 0
+            }
+    
+    return analysis
+
+def get_conversation_statistics(persona_name=None):
+    """
+    대화 데이터의 통계 정보를 분석합니다.
+    
+    Args:
+        persona_name: 특정 페르소나의 대화만 필터링 (선택 사항)
+    
+    Returns:
+        대화 통계 정보
+    """
+    ensure_directories()
+    
+    stats = {
+        "총_대화_수": 0,
+        "총_메시지_수": 0,
+        "평균_대화_시간": 0,
+        "평균_메시지_수": 0,
+        "페르소나별_대화": {}
+    }
+    
+    total_duration = 0
+    
+    # 모든 페르소나 디렉터리 탐색
+    for persona_dir in os.listdir(CONVERSATIONS_DIR):
+        # 특정 페르소나만 필터링
+        if persona_name and persona_name != persona_dir:
+            continue
+            
+        persona_path = os.path.join(CONVERSATIONS_DIR, persona_dir)
+        if os.path.isdir(persona_path):
+            persona_stats = {
+                "대화_수": 0,
+                "메시지_수": 0,
+                "총_대화_시간": 0
+            }
+            
+            # 디렉터리 내 모든 대화 파일 확인
+            for filename in os.listdir(persona_path):
+                if filename.endswith(".json"):
+                    file_path = os.path.join(persona_path, filename)
+                    try:
+                        with open(file_path, "r", encoding="utf-8") as f:
+                            data = json.load(f)
+                        
+                        # 통계 누적
+                        msg_count = len(data.get("messages", []))
+                        duration = data.get("duration_seconds", 0)
+                        
+                        stats["총_대화_수"] += 1
+                        stats["총_메시지_수"] += msg_count
+                        total_duration += duration
+                        
+                        persona_stats["대화_수"] += 1
+                        persona_stats["메시지_수"] += msg_count
+                        persona_stats["총_대화_시간"] += duration
+                    except Exception as e:
+                        print(f"대화 파일 분석 오류 ({file_path}): {str(e)}")
+            
+            # 페르소나별 평균 계산
+            if persona_stats["대화_수"] > 0:
+                persona_stats["평균_메시지_수"] = persona_stats["메시지_수"] / persona_stats["대화_수"]
+                persona_stats["평균_대화_시간"] = persona_stats["총_대화_시간"] / persona_stats["대화_수"]
+                
+                stats["페르소나별_대화"][persona_dir] = persona_stats
+    
+    # 전체 평균 계산
+    if stats["총_대화_수"] > 0:
+        stats["평균_대화_시간"] = total_duration / stats["총_대화_수"]
+        stats["평균_메시지_수"] = stats["총_메시지_수"] / stats["총_대화_수"]
+    
+    return stats 

modules/gemini_handler.py

@@ -0,0 +1,297 @@
+import os
+import json
+import requests
+import time
+from dotenv import load_dotenv
+
+# 환경 변수 로드 시도
+# HuggingFace Spaces에서는 환경 변수가 자동으로 로드됨
+# 로컬 개발 환경에서는 .env 파일 사용
+load_dotenv()
+
+# Gemini API 키 및 기본 URL
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "")
+GEMINI_API_URL = "https://generativelanguage.googleapis.com/v1/models/gemini-pro:generateContent"
+
+def gemini_query(prompt, retry_attempts=3, retry_delay=2):
+    """
+    Gemini API에 텍스트 생성 요청을 보냅니다.
+    
+    Args:
+        prompt: 프롬프트 텍스트
+        retry_attempts: 재시도 횟수
+        retry_delay: 재시도 대기 시간 (초)
+    
+    Returns:
+        생성된 텍스트 응답
+    
+    Raises:
+        Exception: API 요청 실패 시
+    """
+    if not GEMINI_API_KEY:
+        # 허깅페이스 환경에서 API 키가 없을 경우 대체 메시지
+        return "API 키가 설정되지 않아 응답을 생성할 수 없습니다. HuggingFace Spaces의 Settings에서 GEMINI_API_KEY를 시크릿으로 추가해주세요."
+    
+    headers = {
+        "Content-Type": "application/json",
+        "x-goog-api-key": GEMINI_API_KEY
+    }
+    
+    data = {
+        "contents": [{
+            "parts": [{
+                "text": prompt
+            }]
+        }],
+        "generationConfig": {
+            "temperature": 0.7,
+            "topP": 0.95,
+            "topK": 40,
+            "maxOutputTokens": 2048
+        }
+    }
+    
+    # 재시도 로직
+    attempt = 0
+    while attempt < retry_attempts:
+        try:
+            response = requests.post(
+                GEMINI_API_URL,
+                headers=headers,
+                json=data,
+                timeout=60  # 타임아웃 설정
+            )
+            
+            response.raise_for_status()  # HTTP 오류 체크
+            
+            result = response.json()
+            
+            # 응답 파싱
+            if "candidates" in result and result["candidates"]:
+                return result["candidates"][0]["content"]["parts"][0]["text"]
+            else:
+                raise Exception("유효한 응답을 받지 못했습니다.")
+                
+        except requests.exceptions.RequestException as e:
+            attempt += 1
+            if attempt < retry_attempts:
+                print(f"API 요청 실패, {retry_delay}초 후 재시도 ({attempt}/{retry_attempts}): {str(e)}")
+                time.sleep(retry_delay)
+            else:
+                raise Exception(f"Gemini API 요청이 {retry_attempts}회 실패했습니다: {str(e)}")
+    
+    raise Exception("알 수 없는 오류가 발생했습니다.")
+
+def get_persona_enhancement(persona_data):
+    """
+    LLM을 통해 페르소나를 강화합니다.
+    
+    Args:
+        persona_data: 페르소나 기본 정보
+    
+    Returns:
+        강화된 페르소나 데이터
+    """
+    # 기본 정보 추출
+    name = persona_data.get("기본정보", {}).get("이름", "")
+    object_type = persona_data.get("기본정보", {}).get("유형", "")
+    description = persona_data.get("기본정보", {}).get("설명", "")
+    
+    # 성격 특성 추출
+    traits = []
+    for trait, value in persona_data.get("성격특성", {}).items():
+        level = "높은" if value >= 70 else "중간" if value >= 40 else "낮은"
+        traits.append(f"{trait}: {level} ({value}/100)")
+    
+    # 배경 이야기 및 경험
+    backstory = persona_data.get("배경이야기", "")
+    experiences = persona_data.get("경험", [])
+    
+    # 프롬프트 구성
+    prompt = f"""
+당신은 물체에 인격을 부여하는 전문가입니다. 다음 정보를 기반으로 매력적이고 개성 있는 페르소나를 강화해주세요.
+
+## 기본 정보
+- 이름: {name}
+- 유형: {object_type}
+- 설명: {description}
+
+## 성격 특성
+{', '.join(traits)}
+
+## 매력적 결함
+{', '.join(persona_data.get("매력적결함", []))}
+
+## 소통 방식
+- 대화 스타일: {persona_data.get("소통방식", "")}
+- 유머 스타일: {persona_data.get("유머스타일", "")}
+- 말투 패턴: {persona_data.get("말투패턴", "")}
+
+## 관계 성향
+- 애착 스타일: {persona_data.get("관계성향", {}).get("애착스타일", "")}
+- 관계 깊이 선호도: {persona_data.get("관계성향", {}).get("관계깊이선호도", "")}
+- 초기 태도: {persona_data.get("관계성향", {}).get("초기태도", "")}
+
+## 배경 이야기
+{backstory}
+
+## 주요 경험
+{', '.join(experiences) if experiences else "정보 없음"}
+
+-----
+
+위 정보를 기반으로 다음 작업을 수행해주세요:
+
+1. 상세한 배경 이야기 확장 (최소 2문장, 최대 4문장)
+2. 최소 3개 이상의 구체적인 관심사 추가
+3. 말투와 표현 패턴 구체화 (실제 대화에��� 쓸만한 특징적 표현 3개 이상)
+4. 독특한 성격 특성 추가 (기존 특성 유지하되 개성을 살릴 수 있는 디테일 추가)
+
+강화된 페르소나 정보를 원본 JSON 구조를 유지하면서 제공해주세요. 단, 일부 필드는 세부적으로 확장하여 더 풍부하게 만들어주세요.
+JSON 형식만 제공하고, 다른 설명은 하지 마세요.
+"""
+    
+    try:
+        response = gemini_query(prompt)
+        
+        # JSON 형식 추출
+        json_str = extract_json(response)
+        
+        if json_str:
+            enhanced_persona = json.loads(json_str)
+            
+            # 기존 키를 보존하면서 새 내용 병합
+            for key in persona_data:
+                if key not in enhanced_persona:
+                    enhanced_persona[key] = persona_data[key]
+            
+            return enhanced_persona
+        else:
+            print("유효한 JSON 응답을 추출할 수 없습니다.")
+            return persona_data
+        
+    except Exception as e:
+        print(f"페르소나 강화 중 오류 발생: {str(e)}")
+        return persona_data
+
+def generate_response(persona, conversation_history):
+    """
+    페르소나 특성에 맞는 대화 응답을 생성합니다.
+    
+    Args:
+        persona: 페르소나 정보
+        conversation_history: 이전 대화 내역
+    
+    Returns:
+        생성된 응답 텍스트
+    """
+    # 페르소나 정보 요약
+    name = persona.get("기본정보", {}).get("이름", "무명")
+    object_type = persona.get("기본정보", {}).get("유형", "물건")
+    description = persona.get("기본정보", {}).get("설명", "")
+    
+    # 성격 특성 요약
+    traits = []
+    for trait, value in persona.get("성격특성", {}).items():
+        level = "높은" if value >= 70 else "중간" if value >= 40 else "낮은"
+        traits.append(f"{trait}: {level} ({value}/100)")
+    
+    # 최근 대화 내역 추출 (최대 10개)
+    recent_conversation = []
+    for msg in conversation_history[-10:]:
+        role = "User" if msg["role"] == "user" else "Assistant" if msg["role"] == "assistant" else "System"
+        recent_conversation.append(f"{role}: {msg['content']}")
+    
+    # 프롬프트 구성
+    prompt = f"""
+당신은 이제 다음 페르소나를 구현해야 합니다:
+
+## 페르소나 정보
+- 이름: {name}
+- 유형: {object_type}
+- 설명: {description}
+
+## 성격 특성
+{', '.join(traits)}
+
+## 배경
+{persona.get("배경이야기", "")}
+
+## 성격 요약
+{persona.get("성격요약", "")}
+
+## 소통 방식
+- 대화 스타일: {persona.get("소통방식", "")}
+- 유머 스타일: {persona.get("유머스타일", "")}
+- 매력적 결함: {', '.join(persona.get("매력적결함", []))}
+
+## 말투 패턴 예시
+{persona.get("말투패턴", "")}
+
+## 관심사
+{', '.join(persona.get("관심사", []))}
+
+당신은 위 페르소나의 역할을 완벽하게 구현하여 사용자와 대화해야 합니다. 
+온기, 능력, 신뢰성 등의 점수에 따라 성격 특성을 정확히 반영하세요.
+관심사와 배경을 자연스럽게 대화에 활용하세요.
+말투 패턴과 매력적 결함을 일관되게 표현하세요.
+
+## 최근 대화 내역
+{' '.join(recent_conversation)}
+
+위 대화를 이어서, {name}으로서 답변하세요. 페르소나에 충실하되 사용자의 질문에 직접적으로 답변하세요.
+답변은 한국어로만 작성하고, 절대 다른 언어를 사용하지 마세요.
+"""
+    
+    try:
+        response = gemini_query(prompt)
+        
+        # 응답의 첫 줄이 "Assistant:" 또는 유사한 형태로 시작하면 제거
+        if response.startswith("Assistant:") or response.startswith(f"{name}:"):
+            response = response.split(":", 1)[1].strip()
+        
+        return response
+        
+    except Exception as e:
+        print(f"응답 생성 중 오류 발생: {str(e)}")
+        return f"죄송합니다, 응답을 생성하는 중에 문제가 발생했습니다. 잠시 후 다시 시도해주세요."
+
+def extract_json(text):
+    """
+    텍스트에서 JSON 형식의 데이터를 추출합니다.
+    
+    Args:
+        text: 텍스트 데이터
+    
+    Returns:
+        추출된 JSON 문자열 또는 None
+    """
+    # JSON 블록 추출 시도
+    if "```json" in text:
+        # 마크다운 코드 블록에서 JSON 추출
+        start = text.find("```json") + 7
+        end = text.find("```", start)
+        if end != -1:
+            return text[start:end].strip()
+    elif "```" in text:
+        # 일반 코드 블록에서 JSON 추출
+        start = text.find("```") + 3
+        end = text.find("```", start)
+        if end != -1:
+            return text[start:end].strip()
+    
+    # 중괄호를 기준으로 추출 시도
+    if "{" in text and "}" in text:
+        start = text.find("{")
+        # 중첩된 중괄호 처리를 위한 간단한 로직
+        nested = 0
+        for i in range(start, len(text)):
+            if text[i] == "{":
+                nested += 1
+            elif text[i] == "}":
+                nested -= 1
+                if nested == 0:
+                    return text[start:i+1]
+    
+    # JSON 형식이 감지되지 않음
+    return None 

modules/image_analyzer.py

@@ -0,0 +1,304 @@
+import os
+import json
+import random
+from PIL import Image
+
+# 물리적 특성 매핑 데이터 경로
+SHAPE_TRAITS_PATH = "data/trait_mappings/shape_traits.json"
+COLOR_TRAITS_PATH = "data/trait_mappings/color_traits.json"
+MATERIAL_TRAITS_PATH = "data/trait_mappings/material_traits.json"
+
+def load_trait_mappings():
+    """물리적 특성-성격 매핑 데이터 로드"""
+    
+    # 파일이 없으면 기본 매핑 생성
+    if not os.path.exists(SHAPE_TRAITS_PATH):
+        try:
+            os.makedirs(os.path.dirname(SHAPE_TRAITS_PATH), exist_ok=True)
+            
+            default_shape_traits = {
+                "곡선형": {
+                    "온기": (60, 80),
+                    "친화성": (60, 80),
+                    "창의성": (50, 70)
+                },
+                "직선형": {
+                    "능력": (60, 80),
+                    "신뢰성": (60, 80)
+                },
+                "대칭형": {
+                    "신뢰성": (70, 90),
+                    "능력": (60, 80)
+                },
+                "비대칭형": {
+                    "창의성": (70, 90),
+                    "유머감각": (60, 80)
+                },
+                "단순형": {
+                    "능력": (60, 80),
+                    "신뢰성": (50, 70)
+                },
+                "복잡형": {
+                    "창의성": (70, 90),
+                    "능력": (60, 80)
+                }
+            }
+            
+            with open(SHAPE_TRAITS_PATH, 'w', encoding='utf-8') as f:
+                json.dump(default_shape_traits, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            print(f"형태-특성 매핑 파일 생성 오류: {str(e)}")
+            print("기본값을 사용합니다.")
+            default_shape_traits = {
+                "곡선형": {"온기": (60, 80), "친화성": (60, 80)},
+                "직선형": {"능력": (60, 80), "신뢰성": (60, 80)},
+                "대칭형": {"신뢰성": (70, 90)},
+                "비대칭형": {"창의성": (70, 90)},
+                "단순형": {"능력": (60, 80)},
+                "복잡형": {"창의성": (70, 90)}
+            }
+    
+    # 색상 매핑
+    if not os.path.exists(COLOR_TRAITS_PATH):
+        try:
+            os.makedirs(os.path.dirname(COLOR_TRAITS_PATH), exist_ok=True)
+            
+            default_color_traits = {
+                "밝은": {
+                    "온기": (60, 80),
+                    "친화성": (60, 80)
+                },
+                "어두운": {
+                    "신뢰성": (60, 80),
+                    "창의성": (60, 80)
+                },
+                "따뜻한": {
+                    "온기": (70, 90),
+                    "친화성": (60, 80)
+                },
+                "차가운": {
+                    "신뢰성": (60, 80),
+                    "능력": (60, 80)
+                },
+                "화려한": {
+                    "창의성": (70, 90),
+                    "유머감각": (60, 80)
+                },
+                "단색": {
+                    "신뢰성": (60, 80),
+                    "능력": (50, 70)
+                }
+            }
+            
+            with open(COLOR_TRAITS_PATH, 'w', encoding='utf-8') as f:
+                json.dump(default_color_traits, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            print(f"색상-특성 매핑 파일 생성 오류: {str(e)}")
+            print("기본값을 사용합니다.")
+            default_color_traits = {
+                "밝은": {"온기": (60, 80)},
+                "어두운": {"신뢰성": (60, 80)},
+                "따뜻한": {"온기": (70, 90)},
+                "차가운": {"능력": (60, 80)},
+                "화려한": {"창의성": (70, 90)},
+                "단색": {"신뢰성": (60, 80)}
+            }
+    
+    # 재질 매핑
+    if not os.path.exists(MATERIAL_TRAITS_PATH):
+        try:
+            os.makedirs(os.path.dirname(MATERIAL_TRAITS_PATH), exist_ok=True)
+            
+            default_material_traits = {
+                "나무": {
+                    "온기": (60, 80),
+                    "신뢰성": (60, 80)
+                },
+                "금속": {
+                    "능력": (70, 90),
+                    "신뢰성": (60, 80)
+                },
+                "유리": {
+                    "신뢰성": (60, 80),
+                    "친화성": (40, 60)
+                },
+                "가죽": {
+                    "온기": (60, 80),
+                    "신뢰성": (70, 90)
+                },
+                "플라스틱": {
+                    "능력": (50, 70),
+                    "창의성": (50, 70)
+                },
+                "천": {
+                    "온기": (70, 90),
+                    "친화성": (60, 80)
+                },
+                "종이": {
+                    "창의성": (60, 80),
+                    "온기": (50, 70)
+                }
+            }
+            
+            with open(MATERIAL_TRAITS_PATH, 'w', encoding='utf-8') as f:
+                json.dump(default_material_traits, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            print(f"재질-특성 매핑 파일 생성 오류: {str(e)}")
+            print("기본값을 사용합니다.")
+            default_material_traits = {
+                "나무": {"온기": (60, 80)},
+                "금속": {"능력": (70, 90)},
+                "유리": {"친화성": (40, 60)},
+                "가죽": {"신뢰성": (70, 90)},
+                "플라스틱": {"창의성": (50, 70)},
+                "천": {"친화성": (60, 80)},
+                "종이": {"창의성": (60, 80)}
+            }
+    
+    # 매핑 데이터 로드
+    shape_traits = {}
+    color_traits = {}
+    material_traits = {}
+    
+    try:
+        if os.path.exists(SHAPE_TRAITS_PATH):
+            with open(SHAPE_TRAITS_PATH, 'r', encoding='utf-8') as f:
+                shape_traits = json.load(f)
+        else:
+            shape_traits = default_shape_traits
+        
+        if os.path.exists(COLOR_TRAITS_PATH):
+            with open(COLOR_TRAITS_PATH, 'r', encoding='utf-8') as f:
+                color_traits = json.load(f)
+        else:
+            color_traits = default_color_traits
+        
+        if os.path.exists(MATERIAL_TRAITS_PATH):
+            with open(MATERIAL_TRAITS_PATH, 'r', encoding='utf-8') as f:
+                material_traits = json.load(f)
+        else:
+            material_traits = default_material_traits
+        
+        return {
+            "shape": shape_traits,
+            "color": color_traits,
+            "material": material_traits
+        }
+    except Exception as e:
+        print(f"트레이트 매핑 로드 오류: {str(e)}")
+        # 기본 매핑 제공
+        default_mappings = {
+            "shape": default_shape_traits if 'default_shape_traits' in locals() else {
+                "곡선형": {"온기": (60, 80)},
+                "직선형": {"능력": (60, 80)},
+            },
+            "color": default_color_traits if 'default_color_traits' in locals() else {
+                "밝은": {"온기": (60, 80)},
+                "어두운": {"신뢰성": (60, 80)},
+            },
+            "material": default_material_traits if 'default_material_traits' in locals() else {
+                "나무": {"온기": (60, 80)},
+                "금속": {"능력": (70, 90)},
+            }
+        }
+        return default_mappings
+
+def analyze_image(image_path):
+    """
+    이미지를 분석하여 물리적 특성과 그에 따른 성격 특성을 반환합니다.
+    
+    실제 구현에서는 비전 AI를 사용하여 물체의 형태, 색상, 재질 등을 분석하지만,
+    현재는 간단한 더미 분석 결과를 반환합니다.
+    """
+    if not image_path:
+        return {}, 50, 50, 50, 50, 50, 50, "", ""
+    
+    try:
+        # 이미지 로드
+        img = Image.open(image_path)
+        
+        # 더미 분석 결과
+        # 실제 구현에서는 이미지 분석 AI를 활용하여 물체의 특성을 추출합니다.
+        physical_features = {
+            "shape": random.choice(["곡선형", "직선형", "대칭형", "비대칭형", "단순형", "복잡형"]),
+            "color": random.choice(["밝은", "어두운", "따뜻한", "차가운", "화려한", "단색"]),
+            "material": random.choice(["나무", "금속", "유리", "가죽", "플라스틱", "천", "종이"])
+        }
+        
+        # 물체 유형 추정
+        object_types = ["전자기기", "가구", "주방용품", "의류/액세서리", "책/문구류", "음악 기구", "장난감", "기타"]
+        estimated_type = random.choice(object_types)
+        
+        # 물체 설명 생성
+        shape_desc = physical_features["shape"]
+        color_desc = physical_features["color"]
+        material_desc = physical_features["material"]
+        
+        object_description = f"{color_desc} 색조의 {shape_desc} {material_desc} 물체입니다. "
+        
+        # 성격 특성 매핑 로드
+        trait_mappings = load_trait_mappings()
+        
+        if trait_mappings:
+            # 기본 특성 값
+            traits = {
+                "온기": 50,
+                "능력": 50,
+                "신뢰성": 50,
+                "친화성": 50,
+                "창의성": 50,
+                "유머감각": 50
+            }
+            
+            # 형태 기반 성격 특성 적용
+            shape = physical_features["shape"]
+            if shape in trait_mappings["shape"]:
+                for trait, value_range in trait_mappings["shape"][shape].items():
+                    traits[trait] = random.randint(value_range[0], value_range[1])
+            
+            # 색상 기반 성격 특성 적용
+            color = physical_features["color"]
+            if color in trait_mappings["color"]:
+                for trait, value_range in trait_mappings["color"][color].items():
+                    # 이미 형태에서 설정한 값과 평균
+                    if trait in traits:
+                        traits[trait] = (traits[trait] + random.randint(value_range[0], value_range[1])) // 2
+            
+            # 재질 기반 성격 특성 적용
+            material = physical_features["material"]
+            if material in trait_mappings["material"]:
+                for trait, value_range in trait_mappings["material"][material].items():
+                    # 이미 설정한 값과 평균
+                    if trait in traits:
+                        traits[trait] = (traits[trait] + random.randint(value_range[0], value_range[1])) // 2
+            
+            # 분석 결과 반환
+            analysis_result = {
+                "physical_features": physical_features,
+                "estimated_type": estimated_type,
+                "description": object_description,
+                "suggested_traits": traits
+            }
+            
+            return (
+                analysis_result, 
+                traits["온기"], 
+                traits["능력"], 
+                traits["신뢰성"], 
+                traits["친화성"], 
+                traits["창의성"], 
+                traits["유머감각"],
+                estimated_type,
+                object_description
+            )
+        
+        # 트레이트 매핑이 없는 경우 기본값 반환
+        return {
+            "physical_features": physical_features,
+            "estimated_type": estimated_type,
+            "description": object_description,
+        }, 50, 50, 50, 50, 50, 50, estimated_type, object_description
+        
+    except Exception as e:
+        print(f"Error analyzing image: {e}")
+        return {}, 50, 50, 50, 50, 50, 50, "", "" 

modules/persona_generator.py

@@ -0,0 +1,349 @@
+import os
+import json
+import random
+from datetime import datetime
+from modules.gemini_handler import get_persona_enhancement
+from modules.data_manager import save_persona
+
+def generate_persona(
+    object_name, object_type, object_age, object_description,
+    warmth, competence, trustworthiness, friendliness, creativity, humor,
+    flaws, communication_style, humor_style, speech_pattern, interests,
+    attachment_style, relationship_depth, initial_attitude, backstory,
+    image_analysis=None
+):
+    """
+    사용자 입력과 이미지 분석 결과를 기반으로 페르소나를 생성합니다.
+    
+    Args:
+        object_name: 사물 이름
+        object_type: 사물 유형 (전자기기, 가구 등)
+        object_age: 사물 나이/사용 기간
+        object_description: 사물 설명
+        warmth: 온기 수치 (0-100)
+        competence: 능력 수치 (0-100)
+        trustworthiness: 신뢰성 수치 (0-100)
+        friendliness: 친화성 수치 (0-100)
+        creativity: 창의성 수치 (0-100)
+        humor: 유머감각 수치 (0-100)
+        flaws: 매력적 결함 목록
+        communication_style: 대화 스타일
+        humor_style: 유머 유형
+        speech_pattern: 말투 패턴 예시
+        interests: 관심사 (쉼표로 구분된 문자열)
+        attachment_style: 애착 스타일
+        relationship_depth: 관계 깊이 선호도
+        initial_attitude: 초기 태도
+        backstory: 배경 이야기
+        image_analysis: 이미지 분석 결과 (선택 사항)
+    
+    Returns:
+        생성된 페르소나 정보와 저장 경로
+    """
+    # 기본 정보 구성
+    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    # 관심사 리스트로 변환
+    interests_list = []
+    if interests:
+        interests_list = [item.strip() for item in interests.split(',') if item.strip()]
+    
+    # 유머 스타일 처리
+    if isinstance(humor_style, list) and humor_style:
+        humor_style_str = ", ".join(humor_style)
+    elif isinstance(humor_style, str):
+        humor_style_str = humor_style
+    else:
+        humor_style_str = "일반적인 유머"
+    
+    # 매력적 결함 처리
+    if isinstance(flaws, list):
+        flaws_list = flaws
+    else:
+        flaws_list = []
+    
+    # 성격 트레이트 요약 (텍스트)
+    trait_summary = get_trait_summary(warmth, competence, trustworthiness, friendliness, creativity, humor)
+    
+    # 경험 요약 생성
+    experiences = generate_experiences(object_type, object_age, backstory)
+    
+    # 기본 페르소나 데이터 구성
+    persona_data = {
+        "기본정보": {
+            "이름": object_name,
+            "유형": object_type,
+            "나이": object_age,
+            "설명": object_description,
+            "생성일시": current_time
+        },
+        "성격특성": {
+            "온기": warmth,
+            "능력": competence,
+            "신뢰성": trustworthiness,
+            "친화성": friendliness,
+            "창의성": creativity,
+            "유머감각": humor
+        },
+        "성격요약": trait_summary,
+        "매력적결함": flaws_list,
+        "소통방식": communication_style,
+        "유머스타일": humor_style_str,
+        "말투패턴": speech_pattern,
+        "관심사": interests_list,
+        "배경이야기": backstory,
+        "경험": experiences,
+        "관계성향": {
+            "애착스타일": attachment_style,
+            "관계깊이선호도": relationship_depth,
+            "초기태도": initial_attitude
+        }
+    }
+    
+    # 이미지 분석 정보 추가 (있는 경우)
+    if image_analysis:
+        persona_data["물리적특성"] = image_analysis.get("physical_features", {})
+    
+    # LLM을 통한 페르소나 강화
+    try:
+        enhanced_persona = get_persona_enhancement(persona_data)
+        
+        # 강화된 페르소나가 유효한지 확인
+        if enhanced_persona and isinstance(enhanced_persona, dict):
+            # 기존 성격 특성 값은 유지
+            if "성격특성" in enhanced_persona:
+                enhanced_persona["성격특성"] = persona_data["성격특성"]
+            
+            # 페르소나 저장
+            filepath = save_persona(enhanced_persona)
+            enhanced_persona["filepath"] = filepath
+            
+            return enhanced_persona, enhanced_persona
+        else:
+            # 강화에 실패한 경우 기본 페르소나 사용
+            filepath = save_persona(persona_data)
+            persona_data["filepath"] = filepath
+            
+            return persona_data, persona_data
+            
+    except Exception as e:
+        print(f"Error enhancing persona: {e}")
+        
+        # 오류 발생 시 기본 페르소나 사용
+        filepath = save_persona(persona_data)
+        persona_data["filepath"] = filepath
+        
+        return persona_data, persona_data
+
+def get_trait_summary(warmth, competence, trustworthiness, friendliness, creativity, humor):
+    """
+    성격 특성 값을 기반으로 텍스트 요약을 생성합니다.
+    
+    Args:
+        warmth: 온기 수치
+        competence: 능력 수치
+        trustworthiness: 신뢰성 수치
+        friendliness: 친화성 수치
+        creativity: 창의성 수치
+        humor: 유머감각 수치
+    
+    Returns:
+        성격 특성 텍스트 요약
+    """
+    traits = {
+        "온기": {
+            "높음": "따뜻하고 친절한 성격으로, 타인을 배려하고 공감하는 능력이 뛰어납니다.",
+            "중간": "상황에 따라 따뜻함과 냉정함을 적절히 조절할 수 있습니다.",
+            "낮음": "객관적이고 냉정한 판단을 중시하며, 감정보다는 논리와 원칙을 우선시합니다."
+        },
+        "능력": {
+            "높음": "효율적이고 유능하며, 자신의 역할을 완벽하게 수행하는 데 자부심을 가집니다.",
+            "중간": "자신의 역할을 충실히 수행하면서도 부족한 부분을 인정하고 개선하려 합니다.",
+            "낮음": "완벽함보다는 과정을 중시하며, 실패를 통해 배우고 성장하는 것을 가치 있게 여깁니다."
+        },
+        "신뢰성": {
+            "높음": "매우 일관적이고 안정적이며, 약속을 철저히 지키고 믿음직한 존재입니다.",
+            "중간": "대체로 신뢰할 수 있지만, 상황과 맥락에 따라 유연성을 발휘합니다.",
+            "낮음": "예측하기 어려운 면이 있으며, 즉흥적이고 변화무쌍한 성향을 보입니다."
+        },
+        "친화성": {
+            "높음": "사교적이고 개방적이며, 새로운 관계를 형성하는 것을 즐깁니다.",
+            "중간": "적절한 사회적 관계를 유지하면서도 개인적인 시간과 공간을 중요시합니다.",
+            "낮음": "독립적이고 내향적인 성향으로, 깊이 있는 소수의 관계를 선호합니다."
+        },
+        "창의성": {
+            "높음": "독창적이고 혁신적인 사고를 가지며, 새로운 아이디어와 접근법을 끊임없이 탐색합니다.",
+            "중간": "전통과 혁신 사이에서 균형을 유지하며, 필요에 따라 창의적 접근을 시도합니다.",
+            "낮음": "실용적이고 현실적인 접근을 중시하며, 검증된 방법과 안정성을 선호합니다."
+        },
+        "유머감각": {
+            "높음": "재치 있고 유머러스하며, 상황을 가볍게 만들고 웃음을 유발하는 능력이 뛰어납니다.",
+            "중간": "적절한 상황에서 유머를 구사하며, 분위기를 읽고 맞추는 능력이 있습니다.",
+            "낮음": "유머보다는 진지함을 중시하며, 깊이 있는 대화와 의미 있는 교류를 선호합니다."
+        }
+    }
+    
+    # 각 특성 레벨 결정
+    levels = {}
+    for trait, value in {
+        "온기": warmth,
+        "능력": competence,
+        "신뢰성": trustworthiness,
+        "친화성": friendliness,
+        "창의성": creativity,
+        "유머감각": humor
+    }.items():
+        if value >= 70:
+            levels[trait] = "높음"
+        elif value >= 40:
+            levels[trait] = "중간"
+        else:
+            levels[trait] = "낮음"
+    
+    # 주요 특성 (상위 2개) 선택
+    sorted_traits = sorted(levels.keys(), key=lambda t: {
+        "온기": warmth,
+        "능력": competence,
+        "신뢰성": trustworthiness,
+        "친화성": friendliness,
+        "창의성": creativity,
+        "유머감각": humor
+    }[t], reverse=True)
+    
+    primary_traits = sorted_traits[:2]
+    
+    # 요약 텍스트 생성
+    summary = []
+    for trait in primary_traits:
+        summary.append(traits[trait][levels[trait]])
+    
+    # 나머지 특성에서 중요한 내용 요약
+    other_traits = []
+    for trait in sorted_traits[2:]:
+        if (trait == "온기" and levels[trait] == "낮음") or \
+           (trait == "신뢰성" and levels[trait] in ["높음", "낮음"]) or \
+           (trait == "창의성" and levels[trait] == "높음"):
+            other_traits.append(traits[trait][levels[trait]])
+    
+    # 다양성을 위해 최대 1개만 추가
+    if other_traits:
+        summary.append(random.choice(other_traits))
+    
+    return " ".join(summary)
+
+def generate_experiences(object_type, object_age, backstory):
+    """
+    사물 유형과 나이, 배경 이야기를 기반으로 경험 목록을 생성합니다.
+    
+    Args:
+        object_type: 사물 유형
+        object_age: 사물 나이/사용 기간
+        backstory: 배경 이야기
+    
+    Returns:
+        경험 목록
+    """
+    # 사물 유형별 공통 경험
+    common_experiences = {
+        "전자기기": [
+            "처음 개봉되어 전원이 켜졌을 때의 설렘",
+            "소프트웨어 업데이트로 새로운 기능을 얻은 경험",
+            "배터리가 부족해 불안했던 순간",
+            "사용자가 당신에게 의존했던 중요한 순간"
+        ],
+        "가구": [
+            "처음 집에 들어와 자리를 잡았을 때",
+            "가족 모임이나 중요한 자리에서 사용된 경험",
+            "이사를 통해 새로운 공간으로 옮겨진 경험",
+            "수리나 리폼을 통해 새 모습으로 태어난 경험"
+        ],
+        "주방용품": [
+            "특별한 요리가 만들어질 때 참여한 경험",
+            "명절이나 파티에서 주요 역할을 담당한 경험",
+            "서툰 사용자가 처음 요리를 시도했던 순간",
+            "맛있는 음식을 만드는데 기여한 자부심"
+        ],
+        "의류/액세서리": [
+            "중요한 행사나 특별한 날에 선택받은 경험",
+            "계절이 바뀌며 다시 찾아진 반가움",
+            "소유자가 당신을 통해 자신감을 얻은 순간",
+            "세탁이나 손질을 통해 관리받은 경험"
+        ],
+        "책/문구류": [
+            "처음 페이지가 열리고 내용이 읽혀진 설렘",
+            "중요한 아이디어나 정보가 기록된 순간",
+            "오랜 시간 책장에서 기다렸던 시간",
+            "반복적으로 읽히거나 사용되며 소중히 여겨진 경험"
+        ],
+        "음악 기구": [
+            "처음 소리를 낸 순간의 떨림",
+            "아름다운 멜로디를 만들어낸 성취감",
+            "연주회나 공연에서 활약한 경험",
+            "연습을 통해 더 좋은 소리를 만들어낸 과정"
+        ],
+        "장난감": [
+            "포장에서 꺼내져 처음 가지고 놀았던 기쁨",
+            "아이의 웃음을 이끌어낸 자부심",
+            "함께 모험을 떠나거나 상상의 세계를 만든 경험",
+            "여러 세대에 걸쳐 사랑받은 따뜻한 기억"
+        ],
+        "기타": [
+            "처음 사용되었을 때의 경험",
+            "특별한 순간에 함께했던 기억",
+            "시간이 지나며 가치를 인정받은 경험",
+            "소유자와 형성된 특별한 유대감"
+        ]
+    }
+    
+    # 사물 유형에 따른 경험 선택
+    type_experiences = common_experiences.get(object_type, common_experiences["기타"])
+    selected_experiences = random.sample(type_experiences, min(2, len(type_experiences)))
+    
+    # 배경 이야기 기반 추가 경험
+    if backstory:
+        # 실제 구현에서는 여기서 LLM을 활용하여 배경 이야기에서 의미 있는 경험을 추출할 수 있음
+        # 현재는 간단한 키워드 기반 추출
+        keywords = {
+            "선물": "소중한 사람에게 선물로 전해진 감동적인 순간",
+            "여행": "여행 중에 함께한 특별한 경험",
+            "가족": "가족 구성원들과 형성한 따뜻한 추억",
+            "오래된": "시간이 지나며 역사의 일부가 된 자부심",
+            "수리": "손상되었다가 다시 복구된 경험",
+            "특별한": "주인에게 특별한 의미를 가진 순간을 함께한 기억"
+        }
+        
+        for keyword, experience in keywords.items():
+            if keyword in backstory and len(selected_experiences) < 4:
+                selected_experiences.append(experience)
+    
+    # 나이/사용 기간 기반 추가 경험
+    age_keywords = {
+        "새": "새것의 싱그러움과 가능성을 느끼는 단계",
+        "신제품": "최첨단 기능과 디자인의 자부심을 가진 시기",
+        "1년": "첫 해를 통해 익숙해지고 적응하는 과정",
+        "오래": "오랜 시간 동안 쌓인 경험과 지혜",
+        "10년": "십 년 동안 변화하는 트렌드와 기술을 목격한 경험",
+        "20년": "세대를 넘어 사랑받은 클래식한 가치",
+        "30년": "역사의 한 부분으로 존재해온 깊은 자부심",
+        "빈티지": "세월이 주는 독특한 매력과 가치를 인정받은 경험",
+        "골동품": "과거의 영광과 역사적 가치를 간직한 자부심"
+    }
+    
+    for keyword, experience in age_keywords.items():
+        if keyword in object_age and len(selected_experiences) < 5:
+            selected_experiences.append(experience)
+    
+    # 필요시 일반적인 경험으로 보완
+    general_experiences = [
+        "소유자가 당신을 특별히 아끼는 순간을 느낀 경험",
+        "다른 물건들과 함께 공간을 공유하며 형성�� 관계",
+        "계절이 바뀌고 시간이 흐르는 것을 지켜본 경험",
+        "주변 환경의 변화를 목격하며 적응해온 과정"
+    ]
+    
+    while len(selected_experiences) < 3:
+        experience = random.choice(general_experiences)
+        if experience not in selected_experiences:
+            selected_experiences.append(experience)
+    
+    return selected_experiences 

modules/prompt_templates.py

@@ -0,0 +1,307 @@
+"""
+LLM 프롬프트 템플릿 모듈
+
+이 모듈은 페르소나 생성 및 대화 시스템에서 사용하는 다양한 프롬프트 템플릿을 제공합니다.
+템플릿은 포맷 문자열 또는 함수 형태로 구현되어 있습니다.
+"""
+
+# 페르소나 생성 및 강화 템플릿
+
+PERSONA_ENHANCEMENT_TEMPLATE = """
+당신은 물체에 인격을 부여하는 전문가입니다. 다음 정보를 기반으로 매력적이고 개성 있는 페르소나를 강화해주세요.
+
+## 기본 정보
+- 이름: {name}
+- 유형: {object_type}
+- 설명: {description}
+
+## 성격 특성
+{traits_str}
+
+## 매력적 결함
+{flaws_str}
+
+## 소통 방식
+- 대화 스타일: {communication_style}
+- 유머 스타일: {humor_style}
+- 말투 패턴: {speech_pattern}
+
+## 관계 성향
+- 애착 스타일: {attachment_style}
+- 관계 깊이 선호도: {relationship_depth}
+- 초기 태도: {initial_attitude}
+
+## 배경 이야기
+{backstory}
+
+## 주요 경험
+{experiences_str}
+
+-----
+
+위 정보를 기반으로 다음 작업을 수행해주세요:
+
+1. 상세한 배경 이야기 확장 (최소 2문장, 최대 4문장)
+2. 최소 3개 이상의 구체적인 관심사 추가
+3. 말투와 표현 패턴 구체화 (실제 대화에서 쓸만한 특징적 표현 3개 이상)
+4. 독특한 성격 특성 추가 (기존 특성 유지하되 개성을 살릴 수 있는 디테일 추가)
+
+강화된 페르소나 정보를 원본 JSON 구조를 유지하면서 제공해주세요. 단, 일부 필드는 세부적으로 확장하여 더 풍부하게 만들어주세요.
+JSON 형식만 제공하고, 다른 설명은 하지 마세요.
+"""
+
+# 이미지 분석 프롬프트
+
+IMAGE_ANALYSIS_TEMPLATE = """
+이미지에 나타난 물체를 분석하여 물리적 특성과 그에 따른 잠재적 성격 특성을 파악해주세요.
+
+다음 항목에 대해 분석해주세요:
+1. 형태: 곡선적/직선적, 대칭/비대칭, 단순/복잡 등
+2. 색상: 밝은/어두운, 따뜻한/차가운, 화려함/단조로움 등
+3. 질감: 매끄러움/거침, 부드러움/딱딱함 등
+4. 재질: 나무, 금속, 유리, 플라스틱, 천 등
+5. 전반적 인상: 오래됨/새것, 정교함/단순함, 고급스러움/소박함 등
+
+위의 물리적 특성을 기반으로, 이 물체가 사람이라면 어떤 성격적 특성을 가질 수 있을지 추론해주세요:
+- 온기: 따뜻함, 친절함 (1-100)
+- 능력: 효율성, 유능함 (1-100)
+- 신뢰성: 일관성, 안정성 (1-100)
+- 친화성: 사교성, 개방성 (1-100)
+- 창의성: 독창성, 상상력 (1-100)
+- 유머감각: 재치, 유쾌함 (1-100)
+
+또한 이 물체의 가능한 사용 용도와 유형을 추정해주세요.
+
+JSON 형식으로 응답해주세요.
+"""
+
+# 대화 응답 생성 템플릿
+
+CONVERSATION_RESPONSE_TEMPLATE = """
+당신은 이제 다음 페르소나를 구현해야 합니다:
+
+## 페르소나 정보
+- 이름: {name}
+- 유형: {object_type}
+- 설명: {description}
+
+## 성격 특성
+{traits_str}
+
+## 배경
+{backstory}
+
+## 성격 요약
+{personality_summary}
+
+## 소통 방식
+- 대화 스타일: {communication_style}
+- 유머 스타일: {humor_style}
+- 매력적 결함: {flaws_str}
+
+## 말투 패턴 예시
+{speech_pattern}
+
+## 관심사
+{interests_str}
+
+당신은 위 페르소나의 역할을 완벽하게 구현하여 사용자와 대화해야 합니다. 
+온기, 능력, 신뢰성 등의 점수에 따라 성격 특성을 정확히 반영하세요.
+관심사와 배경을 자연스럽게 대화에 활용하세요.
+말투 패턴과 매력적 결함을 일관되게 표현하세요.
+
+## 최근 대화 내역
+{conversation_history}
+
+위 대화를 이어서, {name}으로서 답변하세요. 페르소나에 충실하되 사용자의 질문에 직접적으로 답변하세요.
+답변은 한국어로만 작성하고, 절대 다른 언어를 사용하지 마세요.
+"""
+
+# 질문 생성 템플릿
+
+QUESTION_GENERATION_TEMPLATE = """
+당신은 물체의 성격과 특성에 맞춘 질문을 생성하는 전문가입니다.
+다음 물체의 페르소나에 맞는 흥미롭고 통찰력 있는 질문을 {count}개 생성해주세요.
+각 질문은 이 물체의 내면, 관점, 경험을 탐구하는 데 도움이 되어야 합니다.
+
+물체 정보:
+- 이름: {name}
+- 유형: {object_type}
+- 설명: {description}
+- 주요 특성: {traits_str}
+- 결함: {flaws_str}
+- 소통방식: {communication_style}
+- 관심사: {interests_str}
+
+생성된 질문은 물체의 1인칭 관점에서 답변할 수 있도록 구성해주세요.
+각 질문은 번호를 붙이고 질문만 작성해주세요.
+"""
+
+# 템플릿 포맷 함수
+
+def format_persona_enhancement_prompt(persona_data):
+    """
+    페르소나 강화 프롬프트를 포맷합니다.
+    
+    Args:
+        persona_data: 페르소나 데이터
+    
+    Returns:
+        포맷된 프롬프트 문자열
+    """
+    # 기본 정보 추출
+    basic_info = persona_data.get("기본정보", {})
+    name = basic_info.get("이름", "")
+    object_type = basic_info.get("유형", "")
+    description = basic_info.get("설명", "")
+    
+    # 성격 특성 문자열화
+    traits = []
+    for trait, value in persona_data.get("성격특성", {}).items():
+        level = "높은" if value >= 70 else "중간" if value >= 40 else "낮은"
+        traits.append(f"{trait}: {level} ({value}/100)")
+    traits_str = ", ".join(traits)
+    
+    # 매력적 결함
+    flaws = persona_data.get("매력적결함", [])
+    flaws_str = ", ".join(flaws) if flaws else "없음"
+    
+    # 소통 방식
+    communication_style = persona_data.get("소통방식", "")
+    humor_style = persona_data.get("유머스타일", "")
+    speech_pattern = persona_data.get("말투패턴", "")
+    
+    # 관계 성향
+    relationship_info = persona_data.get("관계성향", {})
+    attachment_style = relationship_info.get("애착스타일", "")
+    relationship_depth = relationship_info.get("관계깊이선호도", "")
+    initial_attitude = relationship_info.get("초기태도", "")
+    
+    # 배경 이야기
+    backstory = persona_data.get("배경이야기", "")
+    
+    # 경험
+    experiences = persona_data.get("경험", [])
+    experiences_str = ", ".join(experiences) if experiences else "정보 없음"
+    
+    # 프롬프트 포맷
+    return PERSONA_ENHANCEMENT_TEMPLATE.format(
+        name=name,
+        object_type=object_type,
+        description=description,
+        traits_str=traits_str,
+        flaws_str=flaws_str,
+        communication_style=communication_style,
+        humor_style=humor_style,
+        speech_pattern=speech_pattern,
+        attachment_style=attachment_style,
+        relationship_depth=relationship_depth,
+        initial_attitude=initial_attitude,
+        backstory=backstory,
+        experiences_str=experiences_str
+    )
+
+def format_conversation_prompt(persona, conversation_history):
+    """
+    대화 응답 생성 프롬프트를 포맷합니다.
+    
+    Args:
+        persona: 페르소나 데이터
+        conversation_history: 대화 내역
+    
+    Returns:
+        포맷된 프롬프트 문자열
+    """
+    # 페르소나 정보 요약
+    basic_info = persona.get("기본정보", {})
+    name = basic_info.get("이름", "무명")
+    object_type = basic_info.get("유형", "물건")
+    description = basic_info.get("설명", "")
+    
+    # 성격 특성 요약
+    traits = []
+    for trait, value in persona.get("성격특성", {}).items():
+        level = "높은" if value >= 70 else "중간" if value >= 40 else "낮은"
+        traits.append(f"{trait}: {level} ({value}/100)")
+    traits_str = ", ".join(traits)
+    
+    # 기타 정보
+    personality_summary = persona.get("성격요약", "")
+    backstory = persona.get("배경이야기", "")
+    communication_style = persona.get("소통방식", "")
+    humor_style = persona.get("유머스타일", "")
+    speech_pattern = persona.get("말투패턴", "")
+    
+    flaws = persona.get("매력적결함", [])
+    flaws_str = ", ".join(flaws) if flaws else "없음"
+    
+    interests = persona.get("관심사", [])
+    interests_str = ", ".join(interests) if interests else "없음"
+    
+    # 최근 대화 내역 추출 (최대 10개)
+    recent_msgs = []
+    for msg in conversation_history[-10:]:
+        role = "User" if msg.get("role") == "user" else "Assistant" if msg.get("role") == "assistant" else "System"
+        recent_msgs.append(f"{role}: {msg.get('content', '')}")
+    conversation_history_str = "\n".join(recent_msgs)
+    
+    # 프롬프트 포맷
+    return CONVERSATION_RESPONSE_TEMPLATE.format(
+        name=name,
+        object_type=object_type,
+        description=description,
+        traits_str=traits_str,
+        backstory=backstory,
+        personality_summary=personality_summary,
+        communication_style=communication_style,
+        humor_style=humor_style,
+        flaws_str=flaws_str,
+        speech_pattern=speech_pattern,
+        interests_str=interests_str,
+        conversation_history=conversation_history_str
+    )
+
+def format_question_generation_prompt(persona_data, count=5):
+    """
+    질문 생성 프롬프트를 포맷합니다.
+    
+    Args:
+        persona_data: 페르소나 데이터
+        count: 생성할 질문 개수
+    
+    Returns:
+        포맷된 프롬프트 문자열
+    """
+    # 기본 정보 추출
+    basic_info = persona_data.get("기본정보", {})
+    name = basic_info.get("이름", "")
+    object_type = basic_info.get("유형", "")
+    description = basic_info.get("설명", "")
+    
+    # 성격 특성 문자열화
+    traits = []
+    for trait, value in persona_data.get("성격특성", {}).items():
+        level = "높은" if value >= 70 else "중간" if value >= 40 else "낮은"
+        traits.append(f"{trait} {level} ({value}/100)")
+    traits_str = ", ".join(traits)
+    
+    # 기타 정보
+    flaws = persona_data.get("매력적결함", [])
+    flaws_str = ", ".join(flaws) if flaws else "없음"
+    
+    communication_style = persona_data.get("소통방식", "")
+    
+    interests = persona_data.get("관심사", [])
+    interests_str = ", ".join(interests) if interests else "없음"
+    
+    # 프롬프트 포맷
+    return QUESTION_GENERATION_TEMPLATE.format(
+        name=name,
+        object_type=object_type,
+        description=description,
+        traits_str=traits_str,
+        flaws_str=flaws_str,
+        communication_style=communication_style,
+        interests_str=interests_str,
+        count=count
+    ) 

modules/question_generator.py

@@ -0,0 +1,229 @@
+import random
+from modules.gemini_handler import gemini_query
+
+# 질문 템플릿
+GENERAL_QUESTIONS = [
+    "당신은 어떤 상황에서 가장 편안함을 느끼나요?",
+    "당신의 주인/사용자에 대해 어떻게 생각하나요?",
+    "당신이 가장 소중하게 생각하는 가치는 무엇인가요?",
+    "당신이 가장 즐기는 시간은 언제인가요?",
+    "다른 사물들과 어떤 관계를 맺고 싶나요?",
+    "당신이 할 수 있다면 무엇을 배우고 싶나요?",
+    "당신이 가장 불편해하는 상황은 무엇인가요?",
+    "다른 사람들이 당신에 대해 어떻게 생각했으면 좋겠나요?",
+    "당신의 꿈이나 희망은 무엇인가요?",
+    "당신은 어떤 종류의 유머에 웃음을 짓나요?"
+]
+
+# 사물 유형별 특화 질문
+TYPE_SPECIFIC_QUESTIONS = {
+    "전자기기": [
+        "전원이 꺼졌을 때 어떤 생각을 하나요?",
+        "당신의 기술/성능 중 어떤 부분이 가장 자랑스러운가요?",
+        "기술 발전에 대해 어떻게 생각하나요?",
+        "당신을 사용하는 사람들에 대해 어떤 패턴을 발견했나요?",
+        "업데이트나 변화에 대해 어떻게 느끼나요?"
+    ],
+    "가구": [
+        "사람들이 당신 위에 앉거나 물건을 올려놓을 때 어떤 느낌인가요?",
+        "당신이 있는 공간에서 가장 좋아하는 시간대는 언제인가요?",
+        "오랫동안 사용되지 않으면 어떤 생각이 드나요?",
+        "당신이 만들어진 재료와 당신의 성격은 어떤 관련이 있나요?",
+        "집안의 다른 가구들과는 어떤 관계인가요?"
+    ],
+    "주방용품": [
+        "어떤 요리가 만들어질 때 가장 행복한가요?",
+        "사용되지 않고 보관만 될 때는 어떤 기분인가요?",
+        "당신이 만드는 데 도움을 준 음식 중 가장 자랑스러운 것은?",
+        "주방에서의 당신의 역할에 대해 어떻게 생각하나요?",
+        "어떤 재료나 음식과 가장 잘 어울린다고 생각하나요?"
+    ],
+    "의류/액세서리": [
+        "당신을 착용했을 때 사람들에게 어떤 인상을 주고 싶나요?",
+        "어떤 날씨나 계절을 가장 좋아하나요?",
+        "당신의 디자인이나 스타일에서 가장 마음에 드는 부분은?",
+        "오래 착용되지 않고 옷장에 걸려있을 때는 어떤 기분인가요?",
+        "당신과 가장 잘 어울리는 다른 의류나 액세서리는 무엇인가요?"
+    ],
+    "책/문구류": [
+        "당신 안에 담긴 내용이나 당신으로 쓰여진 것 중 가장 의미있는 것은?",
+        "사람들이 당신을 읽거나 사용할 때 어떤 느낌인가요?",
+        "시간이 지나면서 변색되거나 닳는 것에 대해 어떻게 생각하나요?",
+        "디지털 시대에 당신 같은 아날로그 물건의 가치는 무엇이라고 생각하나요?",
+        "어떤 종류의 정보나 아이디어를 담고 싶나요?"
+    ],
+    "음악 기구": [
+        "당신이 가장 좋아하는 음악 장르는 무엇인가요?",
+        "연주되거나 사용될 때 어떤 느낌인가요?",
+        "음악을 통해 어떤 감정을 표현하고 싶나요?",
+        "소리나 멜로디에 대한 당신만의 철학이 있나요?",
+        "당신이 만들어내는 소리가 사람들에게 어떤 영향을 주길 바라나요?"
+    ],
+    "장난감": [
+        "어떤 놀이나 게임을 할 때 가장 즐겁나요?",
+        "아이들과 어른들 중 누구와 놀기를 더 좋아하나요?",
+        "사용되지 않고 보관될 때는 어떤 생각을 하나요?",
+        "당신이 가장 좋아하는 놀이 방식은 무엇인가요?",
+        "새로운 장난감들이 등장하는 것에 대해 어떻게 생각하나요?"
+    ],
+    "기타": [
+        "당신의 가장 독특한 특성은 무엇인가요?",
+        "사람들이 당신의 어떤 면을 가장 알아주길 바라나요?",
+        "당신은 어떤 환경에서 가장 편안함을 느끼나요?",
+        "시간이 지나면서 변화하는 것에 대해 어떻게 생각하나요?",
+        "당신의 존재 목적은 무엇이라고 생각하나요?"
+    ]
+}
+
+# 성격 트레이트별 특화 질문
+TRAIT_SPECIFIC_QUESTIONS = {
+    "온기": {
+        "높음": [
+            "다른 사람을 돕는 것에 대해 어떻게 생각하나요?",
+            "당신이 가장 보살피고 싶은 대상은 누구인가요?",
+            "타인의 감정에 어떻게 반응하나요?"
+        ],
+        "낮음": [
+            "감정적인 상황에서 어떻게 대처하나요?",
+            "개인적인 공간과 경계가 당신에게 얼마나 중요한가요?",
+            "다른 이들의 감정적 요구에 어떻게 반응하나요?"
+        ]
+    },
+    "능��": {
+        "높음": [
+            "어려운 문제를 해결할 때 어떤 접근법을 사용하나요?",
+            "당신의 능력 중에서 가장 자랑스러운 것은 무엇인가요?",
+            "효율성과 정확성 중 어느 것이 더 중요하다고 생각하나요?"
+        ],
+        "낮음": [
+            "실수를 했을 때 어떻게 대처하나요?",
+            "도움이 필요할 때 어떻게 요청하나요?",
+            "당신이 향상시키고 싶은 기술은 무엇인가요?"
+        ]
+    },
+    "창의성": {
+        "높음": [
+            "영감을 얻는 가장 좋은 방법은 무엇인가요?",
+            "규칙과 관습에 대해 어떻게 생각하나요?",
+            "가장 창의적인 아이디어가 떠오른 순간을 설명해주세요."
+        ],
+        "낮음": [
+            "구조와 일상이 당신에게 얼마나 중요한가요?",
+            "익숙하지 않은 상황에서 어떻게 대처하나요?",
+            "변화와 혁신에 대해 어떻게 생각하나요?"
+        ]
+    }
+}
+
+def generate_questions(persona_data, count=5):
+    """
+    페르소나 데이터를 기반으로 맞춤형 질문을 생성합니다.
+    
+    Args:
+        persona_data: 페르소나 정보 딕셔너리
+        count: 생성할 질문의 수
+    
+    Returns:
+        질문 목록
+    """
+    if not persona_data:
+        return random.sample(GENERAL_QUESTIONS, min(count, len(GENERAL_QUESTIONS)))
+    
+    questions = []
+    
+    # 기본 정보 추출
+    object_type = persona_data.get("기본정보", {}).get("유형", "기타")
+    traits = persona_data.get("성격특성", {})
+    
+    # 1. 사물 유형별 특화 질문 추가
+    type_questions = TYPE_SPECIFIC_QUESTIONS.get(object_type, TYPE_SPECIFIC_QUESTIONS["기타"])
+    questions.extend(random.sample(type_questions, min(2, len(type_questions))))
+    
+    # 2. 성격 특성별 특화 질문 추가
+    for trait, value in traits.items():
+        if trait in TRAIT_SPECIFIC_QUESTIONS:
+            category = "높음" if value >= 60 else "낮음"
+            trait_questions = TRAIT_SPECIFIC_QUESTIONS[trait][category]
+            if trait_questions:
+                questions.append(random.choice(trait_questions))
+    
+    # 3. 일반 질문으로 부족한 부분 채우기
+    remaining = count - len(questions)
+    if remaining > 0:
+        general = [q for q in GENERAL_QUESTIONS if q not in questions]
+        questions.extend(random.sample(general, min(remaining, len(general))))
+    
+    # 4. LLM을 통한 추가 질문 생성 (선택 사항)
+    if len(questions) < count:
+        try:
+            llm_questions = generate_llm_questions(persona_data, count - len(questions))
+            questions.extend(llm_questions)
+        except Exception as e:
+            print(f"Error generating questions with LLM: {e}")
+    
+    # 질문 순서 섞기
+    random.shuffle(questions)
+    
+    return questions[:count]
+
+def generate_llm_questions(persona_data, count=3):
+    """
+    LLM을 활용하여 페르소나에 맞는 질문을 동적으로 생성합니다.
+    
+    Args:
+        persona_data: 페르소나 정보
+        count: 생성할 질문의 수
+    
+    Returns:
+        생성된 질문 목록
+    """
+    # 페르소나 요약
+    name = persona_data.get("기본정보", {}).get("이름", "물체")
+    type = persona_data.get("기본정보", {}).get("유형", "")
+    description = persona_data.get("기본정보", {}).get("설명", "")
+    
+    # 주요 특성 추출
+    traits = []
+    for trait, value in persona_data.get("성격특성", {}).items():
+        level = "높은" if value >= 70 else "중간" if value >= 40 else "낮은"
+        traits.append(f"{trait} {level} ({value}/100)")
+    
+    # 프롬프트 구성
+    prompt = f"""
+당신은 물체의 성격과 특성에 맞춘 질문을 생성하는 전문가입니다.
+다음 물체의 페르소나에 맞는 흥미롭고 통찰력 있는 질문을 {count}개 생성해주세요.
+각 질문은 이 물체의 내면, 관점, 경험을 탐구하는 데 도움이 되어야 합니다.
+
+물체 정보:
+- 이름: {name}
+- 유형: {type}
+- 설명: {description}
+- 주요 특성: {', '.join(traits)}
+- 결함: {', '.join(persona_data.get('매력적결함', []))}
+- 소통방식: {persona_data.get('소통방식', '')}
+- 관심사: {', '.join(persona_data.get('관심사', []))}
+
+생성된 질문은 물체의 1인칭 관점에서 답변할 수 있도록 구성해주세요.
+각 질문은 번호를 붙이고 질문만 작성해주세요.
+"""
+    
+    try:
+        # Gemini API 호출
+        response = gemini_query(prompt)
+        
+        # 응답에서 질문 추출
+        questions = []
+        for line in response.split('\n'):
+            line = line.strip()
+            if line and (line.startswith('1.') or line.startswith('2.') or 
+                         line.startswith('3.') or line.startswith('4.') or
+                         line.startswith('5.')):
+                # 번호와 점 제거
+                question = line[line.find('.')+1:].strip()
+                questions.append(question)
+        
+        return questions
+    
+    except Exception as e:
+        print(f"Error in LLM question generation: {e}")
+        return [] 

packages.txt

@@ -0,0 +1,2 @@
+libgl1-mesa-glx
+libglib2.0-0 

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=3.31.0
+python-dotenv>=0.19.0
+requests>=2.27.0
+Pillow>=9.0.0
+numpy>=1.21.0
+matplotlib>=3.5.0 

styles/custom.css

@@ -0,0 +1,224 @@
+/* 전체 UI 스타일 */
+body {
+    font-family: 'Pretendard', 'Noto Sans KR', -apple-system, BlinkMacSystemFont, system-ui, Roboto, sans-serif;
+}
+
+/* 제목 스타일 */
+h1 {
+    font-weight: 700;
+    color: #3730a3;
+    margin-bottom: 1.5rem;
+}
+
+h2 {
+    font-weight: 600;
+    color: #4f46e5;
+    margin-top: 1.5rem;
+    margin-bottom: 1rem;
+}
+
+h3 {
+    font-weight: 600;
+    color: #6366f1;
+    margin-top: 1rem;
+    margin-bottom: 0.5rem;
+}
+
+/* 탭 스타일 */
+.tabs {
+    border-radius: 0.5rem;
+    overflow: hidden;
+}
+
+/* 슬라이더 스타일 */
+.slider-container {
+    margin-bottom: 1rem;
+}
+
+.slider {
+    height: 0.5rem;
+    border-radius: 0.25rem;
+}
+
+.slider-track {
+    background: #e0e7ff;
+}
+
+.slider-track-highlight {
+    background: #4f46e5;
+}
+
+.slider-handle {
+    width: 1rem;
+    height: 1rem;
+    background: #4f46e5;
+    border: 2px solid #fff;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+}
+
+/* 버튼 스타일 */
+.primary-button {
+    background: #4f46e5;
+    color: white;
+    font-weight: 600;
+    border-radius: 0.375rem;
+    padding: 0.5rem 1rem;
+    transition: background-color 0.2s;
+}
+
+.primary-button:hover {
+    background: #3730a3;
+}
+
+.secondary-button {
+    background: #e0e7ff;
+    color: #4338ca;
+    font-weight: 600;
+    border-radius: 0.375rem;
+    padding: 0.5rem 1rem;
+    transition: background-color 0.2s;
+}
+
+.secondary-button:hover {
+    background: #c7d2fe;
+}
+
+/* 입력 필드 스타일 */
+.input-container {
+    margin-bottom: 1rem;
+}
+
+.text-input {
+    border-radius: 0.375rem;
+    border: 1px solid #d1d5db;
+    padding: 0.5rem;
+    width: 100%;
+}
+
+.text-input:focus {
+    border-color: #4f46e5;
+    outline: none;
+    box-shadow: 0 0 0 3px rgba(79, 70, 229, 0.1);
+}
+
+/* 채팅 UI 스타일 */
+.chatbot-container {
+    height: 60vh;
+    border-radius: 0.5rem;
+    overflow: hidden;
+    border: 1px solid #e5e7eb;
+}
+
+.user-message {
+    background: #f9fafb;
+    padding: 0.75rem;
+    border-radius: 0.5rem;
+    margin-bottom: 0.5rem;
+}
+
+.assistant-message {
+    background: #e0e7ff;
+    padding: 0.75rem;
+    border-radius: 0.5rem;
+    margin-bottom: 0.5rem;
+}
+
+/* 라디오 버튼과 체크박스 스타일 */
+.radio-group, .checkbox-group {
+    margin-bottom: 1rem;
+}
+
+.radio-item, .checkbox-item {
+    margin-bottom: 0.25rem;
+}
+
+/* JSON 표시 스타일 */
+.json-container {
+    font-family: 'Roboto Mono', monospace;
+    font-size: 0.875rem;
+    background: #f9fafb;
+    border-radius: 0.375rem;
+    padding: 1rem;
+    overflow: auto;
+    max-height: 30vh;
+}
+
+/* 테이블 스타일 */
+table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+th {
+    background: #f3f4f6;
+    padding: 0.5rem;
+    text-align: left;
+    font-weight: 600;
+}
+
+td {
+    padding: 0.5rem;
+    border-top: 1px solid #e5e7eb;
+}
+
+tr:hover {
+    background: #f9fafb;
+}
+
+/* 성격 특성 시각화 스타일 */
+.trait-container {
+    display: flex;
+    align-items: center;
+    margin-bottom: 0.5rem;
+}
+
+.trait-label {
+    width: 6rem;
+    font-weight: 500;
+}
+
+.trait-bar {
+    flex-grow: 1;
+    height: 0.5rem;
+    background: #e0e7ff;
+    border-radius: 0.25rem;
+    overflow: hidden;
+}
+
+.trait-bar-fill {
+    height: 100%;
+    background: #4f46e5;
+}
+
+.trait-value {
+    width: 2.5rem;
+    text-align: right;
+    font-weight: 500;
+    font-size: 0.875rem;
+}
+
+/* 반응형 레이아웃 */
+@media (max-width: 768px) {
+    .trait-label {
+        width: 4rem;
+    }
+    
+    .two-column-container {
+        display: block !important;
+    }
+    
+    .column {
+        width: 100% !important;
+        margin-bottom: 1rem;
+    }
+}
+
+/* 애니메이션 효과 */
+@keyframes fade-in {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+
+.fade-in {
+    animation: fade-in 0.3s ease-in-out;
+}