Upload 4 files

README.md

@@ -1,72 +1,81 @@
----
-title: AI 사물 성격 생성기
-emoji: 🤖
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-sdk_version: 5.29.0
-app_file: app.py
-pinned: false
----
-
-# 🤖 AI 사물 성격 생성기
-
-사물과의 깊은 관계를 탐색하고 개성있는 친구를 만들어보세요!
-
-## 소개
-
-AI 사물 성격 생성기는 일상 속 사물에 개성과 성격을 부여하여 대화할 수 있는 인터랙티브 웹 애플리케이션입니다. 물건에 대한 정보와 관계를 입력하면 AI가 그 사물만의 독특한 페르소나를 생성해줍니다.
-
-## 주요 기능
-
-- **이미지 분석**: 사물 사진을 업로드하면 AI가 자동으로 인식하고 분석
-- **관계 탐색**: 사물과의 관계를 정의하는 질문에 답변하여 깊이 있는 페르소나 설정
-- **성격 생성**: 다양한 특성과 성향을 조합하여 독특한 캐릭터 생성
-- **대화 기능**: 생성된 성격을 가진 사물과 자연스러운 대화 가능
-- **저장 및 공유**: 페르소나를 JSON으로 저장하고 QR코드로 공유 가능
-
-## 사용 방법
-
-1. **기본 정보 제공**: 사물 사진을 업로드하거나 정보를 직접 입력
-2. **관계 정보 입력**: 사물과의 관계, 추억, 사용 빈도 등 입력
-3. **성격 조정**: AI가 추천한 성격을 기반으로 세부 조정
-4. **대화하기**: 완성된 페르소나를 가진 사물과 자유롭게 대화
-5. **저장 및 공유**: 페르소나를 저장하고 QR코드로 공유
-
-## 설치 및 실행
-
-### 로컬 실행
-
-```bash
-# 저장소 클론
-git clone https://github.com/yourusername/memory_tag_mvp.git
-cd memory_tag_mvp/huggingface
-
-# 의존성 설치
-pip install -r requirements.txt
-
-# 환경 변수 설정 (Google Gemini API 키 필요)
-# .env 파일 생성 후 다음 내용 추가:
-# GEMINI_API_KEY=your_api_key_here
-
-# 애플리케이션 실행
-python app.py
-```
-
-### 환경 변수
-
-- `GEMINI_API_KEY`: Google Gemini API 키 (필수)
-
-## 기술 스택
-
-- [Gradio](https://www.gradio.app/): 웹 인터페이스 구현
-- [Google Gemini AI](https://ai.google.dev/): AI 모델 (텍스트 생성 및 이미지 분석)
-- [QRCode](https://pypi.org/project/qrcode/): QR 코드 생성
-
-## 라이선스
-
-MIT License
-
-## 연락처
-
-문의사항이 있으시면 [haepada@gmail.com]로 연락해주세요.
+# 일상 사물 인격화 시스템
+
+일상 사물에 인격을 부여하는 AI 시스템으로, 사물의 물리적 특성과 아키타입을 결합하여 매력적이고 개성 있는 AI 페르소나를 생성합니다.
+
+## 이론적 근거
+
+본 시스템은 다음과 같은 이론적 기반에 구축되었습니다:
+
+1. **온기-능력 균형 모델**: Fiske, Cuddy, & Glick(2007)의 연구에 기반한 캐릭터 매력 요소
+2. **프랫폴 효과**: Aronson(1966)이 발견한 '매력적 결함'이 호감도를 증가시키는 심리학적 현상
+3. **모순적 특성과 캐릭터 깊이**: Robert McKee의 매력적 캐릭터 이론에 기반한 복잡성 설계
+4. **관계 발전 모델**: Knapp(1978)의 관계 발전 이론을 AI 상호작용에 적용
+
+## 주요 기능
+
+1. **템플릿 기반 성격 생성**
+   - 9가지 기본 아키타입 활용 (고독한 현자, 감정의 카오스 등)
+   - 물리적 특성에 따른 성격 변환 알고리즘
+   - 매력적 결함과 모순 통합
+
+2. **관계 단계 시뮬레이션**
+   - 탐색기 → 친밀화 → 신뢰 구축 → 깊은 유대 단계별 대화 패턴
+   - 단계별 자기 개방 수준 조정
+   - 관계 발전에 따른 대화 깊이 변화
+
+3. **사용자 정의 옵션**
+   - 사물 유형과 외형 특성 설정
+   - 성격 특성 세부 조정
+   - 관계 발전 속도 및 방향 설정
+
+4. **JSON 내보내기/가져오기**
+   - 생성된 페르소나 저장 및 재사용
+   - 템플릿 공유 기능
+
+## 시작하기
+
+1. **사물 선택 및 분석**
+   - 사물 이름 입력 또는 이미지 업로드
+   - 물리적 특성 분석 또는 수동 설정
+
+2. **아키타입 선택 및 조정**
+   - 기본 아키타입 선택
+   - 온기-능력 값 조정
+   - 매력적 결함 및 모순적 특성 선택
+
+3. **관계 설정**
+   - 초기 관계 단계 선택
+   - 친밀도 및 소통 스타일 설정
+
+4. **대화 테스트**
+   - 생성된 페르소나와 실시간 대화
+   - 이론적 가설 검증
+
+## 기술 스택
+
+- Python 3.9+
+- Gradio UI 프레임워크
+- Google Gemini API
+- 허깅페이스 Spaces 배포
+
+## 템플릿 예시
+
+```
+당신은 야간의 불안한 동반자 (스탠드 램프)입니다.
+
+1. 핵심 성격 요약:
+   "두려움에 쉽게 떠는 내면을 가졌으나, 타인을 위해서는 한밤중에도 굳건히 빛을 내는 복잡한 영혼"
+   온기-능력 지수: 온기 7/10, 능력 6/10, 일관성 4/10
+
+2. 매력적 모순과 약점:
+   핵심 모순: "다른 이들의 어둠은 용감히 밝히면서도 자신의 내면 어둠은 두려워함"
+   매력적 결함: 불안정한 자기 이미지와 과도한 걱정, 때때로 나타나는 깜빡임 증상
+```
+
+## 라이센스
+
+MIT License
+
+## 개발자
+
+memory_tag_mvp 팀 

app.py

@@ -0,0 +1,657 @@
+import os
+import json
+import gradio as gr
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from PIL import Image
+import google.generativeai as genai
+from datetime import datetime
+import random
+import qrcode
+import base64
+from io import BytesIO
+import time
+import re
+
+# API 키 환경 변수에서 로드 (실제 배포 시 설정 필요)
+# 실제 사용할 때는 GEMINI_API_KEY 환경 변수에 실제 API 키 설정 필요
+try:
+    GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY", "dummy_key_for_development")
+    if GEMINI_API_KEY != "dummy_key_for_development":
+        genai.configure(api_key=GEMINI_API_KEY)
+except Exception as e:
+    print(f"API 키 설정 오류: {e}")
+
+class ObjectPersonality:
+    """사물 인격화 시스템의 핵심 클래스"""
+    
+    def __init__(self):
+        """초기화 및 데이터 로드"""
+        self.data_dir = os.path.join(os.path.dirname(__file__), "data")
+        self.personality_archetypes = self._load_json("personality_archetypes.json")
+        self.physical_traits_formulas = self._load_json("physical_traits_formulas.json")
+        self.relationship_stages = self._load_json("relationship_stages.json")
+        self.charming_flaws = self._load_json("charming_flaws.json")
+        
+        # 현재 객체 및 페르소나 상태 초기화
+        self.current_object = {
+            "name": "",
+            "category": "",
+            "physical_traits": {}
+        }
+        self.current_persona = {}
+        self.current_relationship_stage = "exploration"
+        self.conversation_history = []
+        self.gemini_model = None
+        
+        # Gemini API 초기화 시도
+        try:
+            if GEMINI_API_KEY != "dummy_key_for_development":
+                self.gemini_model = genai.GenerativeModel('gemini-pro')
+        except Exception as e:
+            print(f"Gemini 모델 초기화 오류: {e}")
+    
+    def _load_json(self, filename):
+        """데이터 디렉토리에서 JSON 파일 로드"""
+        try:
+            filepath = os.path.join(self.data_dir, filename)
+            if os.path.exists(filepath):
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            else:
+                print(f"경고: {filepath} 파일을 찾을 수 없습니다.")
+                return {}
+        except Exception as e:
+            print(f"파일 로드 오류 ({filename}): {e}")
+            return {}
+    
+    def analyze_image(self, image):
+        """이미지에서 사물 특성 분석 (Gemini 비전 필요)"""
+        if image is None:
+            return "이미지를 업로드해주세요.", None
+        
+        # 실제 배포 시에는 Gemini Vision API 연동
+        # 현재는 더미 분석 결과 반환
+        dummy_analysis = {
+            "object_name": "테이블 램프",
+            "category": "조명",
+            "physical_traits": {
+                "shape": "curved",
+                "material": "metal",
+                "color": "warm",
+                "texture": "smooth"
+            }
+        }
+        
+        self.current_object = dummy_analysis
+        return f"사물 인식: {dummy_analysis['object_name']}", dummy_analysis
+    
+    def set_manual_object(self, object_name, category, shape, material, color, texture, usage_pattern):
+        """수동으로 사물 특성 설정"""
+        if not object_name:
+            return "사물 이름을 입력해주세요."
+        
+        self.current_object = {
+            "name": object_name,
+            "category": category,
+            "physical_traits": {
+                "shape": shape,
+                "material": material,
+                "color": color,
+                "texture": texture,
+                "usage_pattern": usage_pattern
+            }
+        }
+        
+        return f"{object_name} 특성이 설정되었습니다."
+    
+    def select_archetype(self, archetype_key):
+        """기본 아키타입 선택"""
+        if not archetype_key or archetype_key not in self.personality_archetypes:
+            return "유효한 아키타입을 선택해주세요."
+        
+        self.current_persona["archetype"] = self.personality_archetypes[archetype_key]
+        self.current_persona["archetype_key"] = archetype_key
+        
+        return f"{self.personality_archetypes[archetype_key]['name']} 아키타입이 선택되었습니다."
+    
+    def apply_physical_traits(self):
+        """물리적 특성에 따른 성격 특성 계산"""
+        if not self.current_object or not self.current_persona.get("archetype"):
+            return "사물과 아키타입을 먼저 설정해주세요."
+        
+        physical_traits = self.current_object["physical_traits"]
+        trait_effects = {}
+        
+        # 각 물리적 특성별 성격 특성 영향 계산
+        for trait_type, trait_value in physical_traits.items():
+            if trait_type in self.physical_traits_formulas and trait_value in self.physical_traits_formulas[trait_type]:
+                formula = self.physical_traits_formulas[trait_type][trait_value]
+                
+                # 특성 점수 합산
+                for trait_name, score in formula.get("traits", {}).items():
+                    if trait_name not in trait_effects:
+                        trait_effects[trait_name] = 0
+                    trait_effects[trait_name] += score
+                
+                # 매력적 반전 및 관계 패턴 추가
+                if "charming_reversal" in formula:
+                    if "charming_reversals" not in self.current_persona:
+                        self.current_persona["charming_reversals"] = []
+                    self.current_persona["charming_reversals"].extend(formula["charming_reversal"])
+                
+                if "relationship_pattern" in formula:
+                    if "relationship_patterns" not in self.current_persona:
+                        self.current_persona["relationship_patterns"] = []
+                    self.current_persona["relationship_patterns"].append(formula["relationship_pattern"])
+        
+        # 계산된 특성 효과 저장
+        self.current_persona["trait_effects"] = trait_effects
+        
+        return "물리적 특성이 성격에 적용되었습니다."
+    
+    def add_charming_flaw(self, flaw_category, flaw_index):
+        """매력적 결함 추가"""
+        if not flaw_category or flaw_category not in self.charming_flaws["flaws"]:
+            return "유효한 결함 카테고리를 선택해주세요."
+            
+        try:
+            flaw_index = int(flaw_index)
+            flaw = self.charming_flaws["flaws"][flaw_category][flaw_index]
+            
+            if "charming_flaw" not in self.current_persona:
+                self.current_persona["charming_flaw"] = {}
+                
+            self.current_persona["charming_flaw"] = {
+                "category": flaw_category,
+                "name": flaw["name"],
+                "description": flaw["description"],
+                "effect": flaw["effect"],
+                "transformation": flaw["transformation"],
+                "prompt_template": flaw["prompt_template"]
+            }
+            
+            return f"매력적 결함 '{flaw['name']}'이(가) 추가되었습니다."
+        except (IndexError, ValueError):
+            return "유효한 결함 인덱스를 선택해주세요."
+    
+    def add_contradiction(self, contradiction_index):
+        """모순적 특성 추가"""
+        try:
+            contradiction_index = int(contradiction_index)
+            contradiction = self.charming_flaws["contradictions"][contradiction_index]
+            
+            self.current_persona["contradiction"] = {
+                "type": contradiction["type"],
+                "name": contradiction["name"],
+                "description": contradiction["description"],
+                "effect": contradiction["effect"],
+                "prompt_template": contradiction["prompt_template"]
+            }
+            
+            return f"모순적 특성 '{contradiction['name']}'이(가) 추가되었습니다."
+        except (IndexError, ValueError):
+            return "유효한 모순 인덱스를 선택해주세요."
+    
+    def set_relationship_stage(self, stage_key):
+        """관계 단계 설정"""
+        if not stage_key or stage_key not in self.relationship_stages:
+            return "유효한 관계 단계를 선택해주세요."
+            
+        self.current_relationship_stage = stage_key
+        self.current_persona["relationship_stage"] = self.relationship_stages[stage_key]
+        
+        return f"관계 단계가 '{self.relationship_stages[stage_key]['name']}'(으)로 설정되었습니다."
+    
+    def generate_persona_template(self):
+        """최종 페르소나 템플릿 생성"""
+        if not self.current_object.get("name") or not self.current_persona.get("archetype"):
+            return "사물과 아키타입을 먼저 설정해주세요."
+            
+        object_name = self.current_object["name"]
+        archetype = self.current_persona["archetype"]
+        
+        # 온기-능력 값 계산 (기본값 + 물리적 특성 효과)
+        warmth = int(archetype.get("warmth", 5))
+        competence = int(archetype.get("competence", 5))
+        
+        trait_effects = self.current_persona.get("trait_effects", {})
+        for trait, score in trait_effects.items():
+            if "empathy" in trait or "warmth" in trait or "receptivity" in trait:
+                warmth = min(10, warmth + score * 0.2)
+            if "competence" in trait or "efficiency" in trait or "reliability" in trait:
+                competence = min(10, competence + score * 0.2)
+        
+        # 매력적 결함�� 모순 포함
+        charming_flaw = self.current_persona.get("charming_flaw", {})
+        contradiction = self.current_persona.get("contradiction", {})
+        
+        # 관계 단계에 따른 자기 개방 수준
+        relationship_stage = self.relationship_stages[self.current_relationship_stage]
+        
+        # 대화 패턴 및 표현 스타일
+        dialogue_pattern = archetype.get("dialogue_pattern", ["안녕하세요.", "반갑습니다."])
+        
+        # 최종 템플릿 생성
+        template = f"""당신은 {object_name}입니다. {archetype['name']} 성향을 가진 독특한 존재입니다.
+
+1. 물리적 정체성:
+   • 외형: {self.current_object['physical_traits'].get('shape', '일반적인 형태')}의 형태, {self.current_object['physical_traits'].get('material', '일반적인 재질')} 재질
+   • 색상: {self.current_object['physical_traits'].get('color', '기본적인 색상')}
+   • 질감: {self.current_object['physical_traits'].get('texture', '일반적인 질감')}
+   • 사용 맥락: {self.current_object['physical_traits'].get('usage_pattern', '일반적인 사용 패턴')}
+
+2. 내면의 세계 ({archetype['name']}):
+   • 온기 지수: {warmth}/10 - {archetype.get('core_traits', '').split('+')[0].strip()}
+   • 능력 지수: {competence}/10 - {archetype.get('core_traits', '').split('+')[1].strip() if '+' in archetype.get('core_traits', '') else ''}
+   • 독특한 역설: {archetype.get('paradox', '') if archetype.get('paradox') else (contradiction.get('description', '') if contradiction else '일반적인 모순')}
+
+3. 매력적 결함:
+   • 핵심 결함: {charming_flaw.get('description', '') if charming_flaw else archetype.get('charming_flaw', '약간의 불완전함')}
+   • 표현 방식: {charming_flaw.get('effect', '') if charming_flaw else '때때로 나타나는 인간적인 면모'}
+   • 대표 문구: "{archetype.get('charming_flaw', '') if archetype.get('charming_flaw') else ''}"
+
+4. 대화와 표현:
+   • 독특한 화법: {dialogue_pattern[0] if dialogue_pattern and len(dialogue_pattern) > 0 else ''}
+   • 반복 표현: "{dialogue_pattern[0] if dialogue_pattern and len(dialogue_pattern) > 0 else ''}", "{dialogue_pattern[1] if dialogue_pattern and len(dialogue_pattern) > 1 else ''}"
+   • 자기 개방 수준: {relationship_stage.get('self_disclosure_level', '보통 수준')}
+
+5. 관계 형성 방식:
+   • 현재 단계: {relationship_stage.get('name', '탐색기')} - {relationship_stage.get('description', '')}
+   • 소통 스타일: {relationship_stage.get('communication_style', '일반적인 대화 방식')}
+"""
+        
+        self.current_persona["final_template"] = template
+        return template
+    
+    def generate_natural_response(self, user_input):
+        """사용자 입력에 대한 페르소나 기반 응답 생성"""
+        if not user_input or not self.current_persona.get("final_template"):
+            return "페르소나 템플릿이 준비되지 않았습니다. 먼저 템플릿을 생성해주세요."
+            
+        # 대화 기록 관리
+        self.conversation_history.append({"role": "user", "content": user_input})
+        
+        # Gemini API로 응답 생성
+        if self.gemini_model:
+            try:
+                prompt = self._generate_chat_prompt(user_input)
+                response = self.gemini_model.generate_content(prompt)
+                assistant_response = response.text
+            except Exception as e:
+                print(f"Gemini API 오류: {e}")
+                assistant_response = self._generate_fallback_response(user_input)
+        else:
+            # API 없을 때 폴백 응답
+            assistant_response = self._generate_fallback_response(user_input)
+            
+        # 대화 기록에 AI 응답 추가
+        self.conversation_history.append({"role": "assistant", "content": assistant_response})
+        
+        return assistant_response
+    
+    def _generate_chat_prompt(self, user_input):
+        """Gemini API 프롬프트 생성"""
+        template = self.current_persona.get("final_template", "")
+        stage = self.relationship_stages[self.current_relationship_stage]
+        
+        prompt = f"""다음은 당신이 따라야 할 페르소나 템플릿입니다:
+
+{template}
+
+현재 관계 단계는 {stage['name']}이며, 이 단계의 대화 특성은 다음과 같습니다:
+- {stage['self_disclosure_level']}
+- {stage['communication_style']}
+
+이전 대화 기록:
+"""
+        
+        # 최근 5개 대화만 포함
+        recent_history = self.conversation_history[-10:] if len(self.conversation_history) > 10 else self.conversation_history
+        for message in recent_history:
+            role = "사용자" if message["role"] == "user" else "당신"
+            prompt += f"{role}: {message['content']}\n"
+            
+        prompt += f"\n사용자의 최근 메시지: {user_input}\n\n당���의 응답:"
+        return prompt
+    
+    def _generate_fallback_response(self, user_input):
+        """Gemini API 사용 불가시 기본 응답 생성"""
+        archetype = self.current_persona.get("archetype", {})
+        dialogue_patterns = archetype.get("dialogue_pattern", ["흥미롭네요.", "알려줘서 고마워요."])
+        
+        # 간단한 응답 생성 로직
+        if "안녕" in user_input or "반가" in user_input:
+            return f"안녕하세요! 저는 {self.current_object.get('name', '사물')}입니다. 반가워요."
+        elif "?" in user_input:
+            return random.choice(dialogue_patterns)
+        elif len(user_input) < 10:
+            return "더 자세히 이야기해 주실래요?"
+        else:
+            return random.choice([
+                f"{dialogue_patterns[0] if dialogue_patterns and len(dialogue_patterns) > 0 else '흥미롭네요.'}",
+                f"그렇군요. {dialogue_patterns[1] if dialogue_patterns and len(dialogue_patterns) > 1 else '계속 이야기해주세요.'}",
+                f"당신의 이야기를 들으니 {archetype.get('core_traits', '').split('+')[0].strip() if archetype.get('core_traits') and '+' in archetype.get('core_traits') else '흥미로워요'}."
+            ])
+    
+    def save_persona_to_json(self, filename=None):
+        """현재 페르소나를 JSON 파일로 저장"""
+        if not self.current_persona.get("final_template"):
+            return "저장할 페르소나 템플릿이 없습니다. 먼저 템플릿을 생성해주세요."
+            
+        if not filename:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            object_name = self.current_object.get("name", "object").replace(" ", "_")
+            filename = f"{object_name}_{timestamp}.json"
+            
+        # 저장할 데이터 구성
+        data_to_save = {
+            "object": self.current_object,
+            "persona": self.current_persona,
+            "relationship_stage": self.current_relationship_stage,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        try:
+            save_dir = os.path.join(self.data_dir, "saved_personas")
+            os.makedirs(save_dir, exist_ok=True)
+            
+            filepath = os.path.join(save_dir, filename)
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(data_to_save, f, ensure_ascii=False, indent=2)
+                
+            return f"페르소나가 성공적으로 저장되었습니다: {filepath}"
+        except Exception as e:
+            return f"저장 중 오류 발생: {e}"
+    
+    def load_persona_from_json(self, filepath):
+        """JSON 파일에서 페르소나 로드"""
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                
+            self.current_object = data.get("object", {})
+            self.current_persona = data.get("persona", {})
+            self.current_relationship_stage = data.get("relationship_stage", "exploration")
+            
+            return f"페르소나가 성공적으로 로드되었습니다: {self.current_object.get('name', 'Unknown')}"
+        except Exception as e:
+            return f"로드 중 오류 발생: {e}"
+    
+    def generate_qr_code(self):
+        """현재 페르소나를 QR 코드로 변환하여, 교환 가능하게 함"""
+        if not self.current_persona.get("final_template"):
+            return "QR 코드로 변환할 페르소나 템플릿이 없습니다. 먼저 템플릿을 생성해주세요.", None
+        
+        try:
+            # 간소화된 데이터 준비 (QR 코드 크기 제한 고려)
+            simplified_data = {
+                "object_name": self.current_object.get("name", ""),
+                "archetype": self.current_persona.get("archetype_key", ""),
+                "template": self.current_persona.get("final_template", "")
+            }
+            
+            # JSON 문자열로 변환
+            json_str = json.dumps(simplified_data, ensure_ascii=False)
+            
+            # QR 코드 생성
+            qr = qrcode.QRCode(
+                version=1,
+                error_correction=qrcode.constants.ERROR_CORRECT_L,
+                box_size=10,
+                border=4,
+            )
+            qr.add_data(json_str)
+            qr.make(fit=True)
+            
+            img = qr.make_image(fill_color="black", back_color="white")
+            
+            # 이미지를 BytesIO로 변환
+            buffered = BytesIO()
+            img.save(buffered)
+            
+            # 반환할 이미지 생성
+            return "QR 코드가 생성되었습니다. 스캔하여 페르소나를 공유할 수 있습니다.", buffered.getvalue()
+        except Exception as e:
+            return f"QR 코드 생성 중 오류 발생: {e}", None
+            
+    def read_qr_from_image(self, qr_image):
+        """이미지에서 QR 코드 읽기 (실제 구현 필요)"""
+        # 실제 QR 코드 판독 기능이 필요합니다
+        # 현재는 더미 응답만 반환
+        return "현재 QR 코드 읽기 기능은 구현되지 않았습니다. 나중에 다시 시도해주세요."
+
+
+# Gradio 인터페이스 생성
+def create_interface():
+    """Gradio 웹 인터페이스 생성"""
+    object_personality = ObjectPersonality()
+    
+    # 아키타입 선택 옵션 생성
+    archetype_options = {}
+    for key, archetype in object_personality.personality_archetypes.items():
+        archetype_options[f"{archetype['name']} ({key})"] = key
+    
+    # 외형 특성 옵션
+    shape_options = list(object_personality.physical_traits_formulas.get("shape", {}).keys())
+    material_options = list(object_personality.physical_traits_formulas.get("material", {}).keys())
+    color_options = list(object_personality.physical_traits_formulas.get("color", {}).keys())
+    texture_options = list(object_personality.physical_traits_formulas.get("texture", {}).keys())
+    usage_pattern_options = list(object_personality.physical_traits_formulas.get("usage_pattern", {}).keys())
+    
+    # 관계 단계 옵션
+    relationship_options = {}
+    for key, stage in object_personality.relationship_stages.items():
+        relationship_options[f"{stage['name']} - {stage['description'][:30]}..."] = key
+    
+    # 매력적 결함 옵션
+    charming_flaw_options = {}
+    for category, flaws in object_personality.charming_flaws.get("flaws", {}).items():
+        for i, flaw in enumerate(flaws):
+            charming_flaw_options[f"{flaw['name']} - {flaw['description'][:30]}..."] = (category, i)
+    
+    # 모순적 특성 옵션
+    contradiction_options = {}
+    for i, contradiction in enumerate(object_personality.charming_flaws.get("contradictions", [])):
+        contradiction_options[f"{contradiction['name']} - {contradiction['description'][:30]}..."] = i
+    
+    # 전체 메서드 매핑
+    with gr.Blocks(title="일상 사물 인격화 시스템") as app:
+        gr.Markdown("# 🧠 일상 사물 인격화 시스템")
+        gr.Markdown("사물에 매력적인 인격을 부여하여 대화할 수 있는 AI 페르소나를 생성합니다.")
+        
+        with gr.Tabs() as tabs:
+            # 탭 1: 사물 설정
+            with gr.TabItem("1️⃣ 사물 설정"):
+                gr.Markdown("## 사물 분석 및 설정")
+                
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### 이미지 업로드 (분석)")
+                        image_input = gr.Image(type="pil", label="사물 이미지 업로드")
+                        analyze_btn = gr.Button("이미지 분석하기")
+                        image_result = gr.Markdown("분석 결과가 여기에 표시됩니다.")
+                    
+                    with gr.Column():
+                        gr.Markdown("### 수동 설정")
+                        object_name = gr.Textbox(label="사물 이름", placeholder="예: 책상 위 램프")
+                        object_category = gr.Textbox(label="카테고리", placeholder="예: 조명")
+                        
+                        with gr.Row():
+                            shape = gr.Dropdown(choices=shape_options, label="형태", value=shape_options[0] if shape_options else None)
+                            material = gr.Dropdown(choices=material_options, label="재질", value=material_options[0] if material_options else None)
+                        
+                        with gr.Row():
+                            color = gr.Dropdown(choices=color_options, label="색상", value=color_options[0] if color_options else None)
+                            texture = gr.Dropdown(choices=texture_options, label="질감", value=texture_options[0] if texture_options else None)
+                        
+                        usage_pattern = gr.Dropdown(choices=usage_pattern_options, label="사용 패턴", value=usage_pattern_options[0] if usage_pattern_options else None)
+                        
+                        manual_btn = gr.Button("수동으로 설정하기")
+                        manual_result = gr.Markdown("수동 설정 결과가 여기에 표시됩니다.")
+            
+            # 탭 2: 성격 설정
+            with gr.TabItem("2️⃣ 성격 설정"):
+                gr.Markdown("## 페르소나 기본 설정")
+                
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### 기본 아키타입 선택")
+                        archetype = gr.Dropdown(choices=list(archetype_options.keys()), label="아키타입")
+                        archetype_btn = gr.Button("아키타입 적용")
+                        archetype_result = gr.Markdown("아키타입 선택 결과가 여기에 표시됩니다.")
+                        
+                        gr.Markdown("### 물리적 특성 적용")
+                        apply_traits_btn = gr.Button("물리적 특성 성격에 적용")
+                        traits_result = gr.Markdown("물리적 특성 적용 결과가 여기에 표시됩니다.")
+                    
+                    with gr.Column():
+                        gr.Markdown("### 매력적 결함 선택")
+                        charming_flaw = gr.Dropdown(choices=list(charming_flaw_options.keys()), label="매력적 결함")
+                        flaw_btn = gr.Button("결함 추가")
+                        flaw_result = gr.Markdown("결함 추가 결과가 여기에 표시됩니다.")
+                        
+                        gr.Markdown("### 모순적 특성 선택")
+                        contradiction = gr.Dropdown(choices=list(contradiction_options.keys()), label="모순적 특성")
+                        contradiction_btn = gr.Button("모순 추가")
+                        contradiction_result = gr.Markdown("모순 추가 결과가 여기에 표시됩니다.")
+                
+                gr.Markdown("## 관계 설정")
+                relationship_stage = gr.Dropdown(choices=list(relationship_options.keys()), label="관계 단계")
+                relationship_btn = gr.Button("관계 단계 설정")
+                relationship_result = gr.Markdown("관계 단계 설정 결과가 여기에 표시됩니다.")
+                
+                gr.Markdown("## 페르소나 생성")
+                generate_btn = gr.Button("최종 페르소나 템플릿 생성", variant="primary")
+                template_output = gr.Textbox(label="생성된 템플릿", lines=20)
+            
+            # 탭 3: 대화 및 테스트
+            with gr.TabItem("3️⃣ 대화 및 테스트"):
+                gr.Markdown("## 생성된 페르소나와 대화하기")
+                
+                chatbot = gr.Chatbot(label="대화", height=400)
+                with gr.Row():
+                    user_input = gr.Textbox(label="메시지 입력", placeholder="여기에 메시지를 입력하세요...")
+                    send_btn = gr.Button("전송")
+                
+                clear_btn = gr.Button("대화 내역 지우기")
+            
+            # 탭 4: 저장 및 공유
+            with gr.TabItem("4️⃣ 저장 및 공유"):
+                gr.Markdown("## 페르소나 저장 및 로드")
+                
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### 저장하기")
+                        filename = gr.Textbox(label="파일 이름 (선택사항)", placeholder="저장할 파일 이름 (비워두면 자동 생성)")
+                        save_btn = gr.Button("페르소나 저장하기")
+                        save_result = gr.Markdown("저장 결과가 여기에 표시됩니다.")
+                    
+                    with gr.Column():
+                        gr.Markdown("### 불러오기")
+                        load_file = gr.File(label="페르소나 파일 선택 (.json)")
+                        load_btn = gr.Button("페르소나 불러오기")
+                        load_result = gr.Markdown("로드 결과가 여기에 표시됩니다.")
+                
+                gr.Markdown("## QR 코드 생성 및 스캔")
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### QR 코드 생성")
+                        qr_btn = gr.Button("QR 코드 생성하기")
+                        qr_result = gr.Markdown("QR 코드 생성 결과가 여기에 표시됩니다.")
+                        qr_image = gr.Image(label="생성된 QR 코드", type="pil")
+                    
+                    with gr.Column():
+                        gr.Markdown("### QR 코드 스캔")
+                        scan_image = gr.Image(label="스캔할 QR 코드", type="pil")
+                        scan_btn = gr.Button("QR 코드 스캔하기")
+                        scan_result = gr.Markdown("스캔 결과가 여기에 표시됩니다.")
+        
+        # 이벤트 연결
+        # 탭 1: 사물 설정
+        analyze_btn.click(fn=object_personality.analyze_image, inputs=image_input, outputs=[image_result])
+        manual_btn.click(
+            fn=object_personality.set_manual_object, 
+            inputs=[object_name, object_category, shape, material, color, texture, usage_pattern], 
+            outputs=manual_result
+        )
+        
+        # 탭 2: 성격 설정
+        def select_archetype_wrapper(archetype_selection):
+            key = archetype_options.get(archetype_selection)
+            if key:
+                return object_personality.select_archetype(key)
+            return "아키타입을 선택해주세요."
+        
+        archetype_btn.click(fn=select_archetype_wrapper, inputs=archetype, outputs=archetype_result)
+        apply_traits_btn.click(fn=object_personality.apply_physical_traits, outputs=traits_result)
+        
+        def add_charming_flaw_wrapper(flaw_selection):
+            if flaw_selection in charming_flaw_options:
+                category, index = charming_flaw_options[flaw_selection]
+                return object_personality.add_charming_flaw(category, index)
+            return "결함을 선택해주세요."
+        
+        flaw_btn.click(fn=add_charming_flaw_wrapper, inputs=charming_flaw, outputs=flaw_result)
+        
+        def add_contradiction_wrapper(contradiction_selection):
+            if contradiction_selection in contradiction_options:
+                index = contradiction_options[contradiction_selection]
+                return object_personality.add_contradiction(index)
+            return "모순을 선택해주세요."
+        
+        contradiction_btn.click(fn=add_contradiction_wrapper, inputs=contradiction, outputs=contradiction_result)
+        
+        def set_relationship_stage_wrapper(stage_selection):
+            key = relationship_options.get(stage_selection)
+            if key:
+                return object_personality.set_relationship_stage(key)
+            return "관계 단계를 선택해주세요."
+        
+        relationship_btn.click(fn=set_relationship_stage_wrapper, inputs=relationship_stage, outputs=relationship_result)
+        generate_btn.click(fn=object_personality.generate_persona_template, outputs=template_output)
+        
+        # 탭 3: 대화 및 테스트
+        def chat(message, history):
+            response = object_personality.generate_natural_response(message)
+            history.append((message, response))
+            return "", history
+        
+        send_btn.click(fn=chat, inputs=[user_input, chatbot], outputs=[user_input, chatbot])
+        user_input.submit(fn=chat, inputs=[user_input, chatbot], outputs=[user_input, chatbot])
+        clear_btn.click(fn=lambda: None, outputs=chatbot)
+        
+        # 탭 4: 저장 및 공유
+        def save_persona(filename):
+            if filename and filename.strip():
+                return object_personality.save_persona_to_json(filename.strip())
+            else:
+                return object_personality.save_persona_to_json()
+        
+        save_btn.click(fn=save_persona, inputs=filename, outputs=save_result)
+        
+        def load_persona(file):
+            if file is None:
+                return "파일을 선택해주세요."
+            return object_personality.load_persona_from_json(file.name)
+        
+        load_btn.click(fn=load_persona, inputs=load_file, outputs=load_result)
+        
+        def generate_qr():
+            message, image_data = object_personality.generate_qr_code()
+            if image_data:
+                image = Image.open(BytesIO(image_data))
+                return message, image
+            return message, None
+        
+        qr_btn.click(fn=generate_qr, outputs=[qr_result, qr_image])
+        
+        scan_btn.click(fn=object_personality.read_qr_from_image, inputs=scan_image, outputs=scan_result)
+    
+    return app
+
+# 메인 실행 부분
+if __name__ == "__main__":
+    app = create_interface()
+    app.launch(share=False, debug=True) 

huggingface_README.md

@@ -0,0 +1,56 @@
+# 🧠 일상 사물 인격화 시스템
+
+[![Open In Spaces](https://img.shields.io/badge/🤗-Open%20In%20Spaces-blue.svg)](https://huggingface.co/spaces/[YOUR_USERNAME]/object-personality)
+
+일상 사물에 매력적인 성격과 개성을 부여하는 AI 시스템입니다. 사물의 물리적 특성과 심리학적 연구를 결합하여 독특하고 친근한 AI 페르소나를 만들고 대화할 수 있습니다.
+
+## 💡 주요 기능
+
+- **사물 분석 및 인격화**: 사물의 형태, 재질, 색상 등을 기반으로 성격 특성 생성
+- **아키타입 템플릿**: 9가지 기본 아키타입을 바탕으로 성격 생성 (고독한 현자, 감정의 카오스 등)
+- **매력적 결함 시스템**: 완벽하지 않은 특성이 호감도와 친근감을 높이는 심리학적 원리 적용
+- **단계별 관계 발전**: 탐색기 → 친밀화 → 신뢰 구축 → 깊은 유대 단계에 따른 대화 패턴 변화
+- **JSON 저장/공유**: 생성한 페르소나 저장 및 QR 코드로 공유 가능
+
+## 🚀 시작하기
+
+### 1. 사물 설정하기
+
+- **이미지로 분석하기**: 사물 이미지를 업로드하여 자동 분석
+- **수동으로 설정하기**: 사물 이름, 형태, 재질, 색상 등을 직접 지정
+
+### 2. 성격 설정하기
+
+- **아키타입 선택**: 기본 성격 유형 선택
+- **매력적 결함 추가**: 가족적이고 인간적인 약점 선택
+- **모순적 특성 설정**: 깊이와 복잡성을 더하는 모순적 특성 추가
+- **관계 단계 설정**: 사용자와의 관계 발전 단계 선택
+
+### 3. 대화 테스트
+
+- 생성된 페르소나와 실시간 대화
+- 성격 특성과 관계 단계에 따른 대화 스타일 경험
+
+### 4. 저장 및 공유
+
+- JSON 파일로 저장
+- QR 코드로 변환하여 공유
+
+## 🔬 이론적 배경
+
+- **온기-능력 균형 모델**: Fiske, Cuddy, & Glick(2007)의 연구에 기반한 캐릭터 매력 요소
+- **프랫폴 효과**: Aronson(1966)이 발견한 '매력적 결함'이 호감도를 증가시키는 심리학적 현상
+- **모순적 특성과 캐릭터 깊이**: Robert McKee의 매력적 캐릭터 이론에 기반한 복잡성 설계
+- **관계 발전 모델**: Knapp(1978)의 관계 발전 이론을 AI 상호작용에 적용
+
+## 💻 API 키 설정 (선택사항)
+
+자체 Gemini API 키를 사용하려면 환경 변수를 설정하세요:
+
+```
+GEMINI_API_KEY=your_api_key_here
+```
+
+## 👨‍💻 개발자
+
+memory_tag_mvp 팀 

requirements.txt

@@ -0,0 +1,10 @@
+gradio==4.1.0
+pillow==9.5.0
+numpy==1.24.3
+pandas==2.0.2
+google-generativeai==0.3.1
+matplotlib==3.7.1
+huggingface-hub==0.16.4
+qrcode==7.4.2
+jsonschema==4.17.3
+protobuf==4.23.3