에러 수정 및 리팩토링

npc_social_network/README.txt

@@ -117,7 +117,7 @@ portfolio/
 
 ## 🔁 주요 시퀀스 흐름
 
-### 🗨️ `interact_with_player()` 전체 흐름
+### 🗨️ `generate_dialogue()` 전체 흐름
 1. LLM으로 감정 추론 (`query_llm_for_emotion`)
 2. 기억 검색 (FAISS + embedding)
 3. LLM 프롬프트 생성 (`build_npc_prompt`)
@@ -152,7 +152,7 @@ GET /run_npc_simulation
 | 2단계 | NPC 감정 상태 및 감정 HUD 구현 | ✅ 완료 | 감정 상태 및 HUD 표시 (Pygame + 웹)
 | 3단계 | 감정 ↔ 행동 연동 구조 구현 | ✅ 완료 | 감정 ↔ 행동 매핑 구현
 | 4단계 | 감정 ↔ 기억 저장 및 decay 구현 | ✅ 완료 | Memory 감정 및 decay 적용 구조
-| 5단계 | 감정 ↔ 관계 변화 구조 구현 | 🔸 부분 완료 | 구조는 구현됨, 플레이어 대상 반영 보완 중
+| 5단계 | 감정 ↔ 관계 변화 구조 구현 | 🔸 부분 완료 | 구조는 구현됨, 다른 NPC 관련 확인 필요
 | 6단계 | 성격 시스템 도입 | ✅ 완료 | 성격 분리 + 초기 bias 설계
 | 7단계 | NPC 간 상호작용 구조화 | ✅ 완료 | NPC 상호작용 → 감정/관계 반영
 | 8단계 | Memory 임베딩 + FAISS 기반 검색 | ✅ 완료 | FAISS 검색 + 임베딩 저장 구조
@@ -160,7 +160,7 @@ GET /run_npc_simulation
 | 10단계 | 감정 상태 HUD 시각화 (웹 + 게임 화면) | ✅ 완료 | 감정 상태 HUD (웹/게임 연동)
 
 # 핵심 시스템 고도화
-| 11단계 | 감정/기억/관계 통합 정비 | 🔄 진행중 | 관계 통합, 감정-기억-관계 연결 완성도 향상 중
+| 11단계 | 감정/기억/관계 통합 정비 | ✅ 완료 | 관계 통합, 감정-기억-관계 연결 완성도 향상 중
 | 12단계 | LLM 대사 생성 고도화 | ✅ 완료 | LLM 대사 생성 개선, 프롬프트 완성
 | 13단계 | 기억 decay 정교화 | ⏳ 미진행 | decay 시점별 변화율 조정 등 정교화 미실행
 | 14-1단계 | 기억 임베딩 구조 확장 | ✅ 완료 | Memory 객체 임베딩 구조 도입
@@ -173,16 +173,16 @@ GET /run_npc_simulation
 | 20단계 | 	NPC 사회 네트워크 시각화 | ⏳ 미진행 | 
 
 # 고급 인간화 및 자각형 NPC 확장
-| 21단계 | 성격 지속적 변화 설계 완성 |
-| 22단계 | 행동 유도 기반 계획형 NPC |
-| 23단계 | 윤리 시스템 실험 (자각형 구조화) |
-| 24단계 | NPC 자아 형성 시퀀스 테스트 |
-| 25단계 | 플레이어 기억 및 반응 시스템 구축 |
-| 26단계 | 멀티캐릭터 다자 간 상호작용 루프 |
-| 27단계 | 시뮬레이션 UI 시각화 고도화 |
-| 28단계 | 메타기억 시스템 |
-| 29단계 | LLM+RAG+플래너 종합 구조 통합 |
-| 30단계 | 논문/연구 결과 정리 구조화 |
+| 21단계 | 성격 지속적 변화 설계 완성 | ⏳ 미진행 | 
+| 22단계 | 행동 유도 기반 계획형 NPC | ⏳ 미진행 | 
+| 23단계 | 윤리 시스템 실험 (자각형 구조화) | ⏳ 미진행 | 
+| 24단계 | NPC 자아 형성 시퀀스 테스트 | ⏳ 미진행 | 
+| 25단계 | 플레이어 기억 및 반응 시스템 구축 | ⏳ 미진행 | 
+| 26단계 | 멀티캐릭터 다자 간 상호작용 루프 | ⏳ 미진행 | 
+| 27단계 | 시뮬레이션 UI 시각화 고도화 | ⏳ 미진행 | 
+| 28단계 | 메타기억 시스템 | ⏳ 미진행 | 
+| 29단계 | LLM+RAG+플래너 종합 구조 통합 | ⏳ 미진행 | 
+| 30단계 | 논문/연구 결과 정리 구조화 | ⏳ 미진행 | 
 
 
 ---

npc_social_network/maps/engine/game_engine.py

@@ -142,7 +142,7 @@ class GameEngine:
         if npc:
             print(f"\n👤 {npc.name} ({npc.job})")
             print(f" - 위치: ({tile_x}, {tile_y})")
-            print(f" - 대화: {npc.generate_dialogue()}")
+            print(f" - 대화: {npc.generate_dialogue(user_input='', use_llm=False)}")
             print(f" - 기억: {npc.recall()}")
             self.set_selected_npc(npc)
 

npc_social_network/models/llm_helper.py

@@ -1,23 +1,12 @@
 # npc_social_network/models/llm_helper.py
 
 from npc_social_network.npc.emotion_config import EMOTION_LIST
+from npc_social_network.models.gemini_setup import load_gemini
+from npc_social_network.npc.npc_memory import Memory
+from typing import List
 
-# 임시 LLM 호출 함수 예시 (Gemini / GPT 연결 가능)
-def query_llm_for_response(npc_name, npc_job, user_input):
-    """
-    LLM을 통해 NPC 응답 생성
-    """
-
-    # 실제 구현시 Gemini API 호출 코드 사용 가능
-    prompt = f"""
-    NPC 이름: {npc_name}
-    NPC 직업: {npc_job}
-    플레이어가 다음과 같이 말했습니다. "{user_input}"
-
-    이에 대해 자연스럽고 친근한 한국어로 응답을 작성하세요.
-    """
-    # 예시 응답 (추후 LLM 연결 시 교체)
-    return f"{npc_name}이(가) 대답했습니다: '네, 정말 흥미롭네요!'"
+# Gemini 모델 초기화
+gemini_model = load_gemini()
 
 def query_llm_for_emotion(user_input):
     """
@@ -31,29 +20,39 @@ def query_llm_for_emotion(user_input):
 
     반드시 감정 이름을 한 개만 출력하세요. (예: joy)
     """
-    # 예시 결과 (추후 LLM 연결 시 교체)
-    return "joy"
+    try:
+        response = gemini_model.generate_content(prompt)
+        return response.text.strip()
+    except Exception as e:
+        return f"[LLM Error] {str(e)}"
 
 def query_llm_with_prompt(prompt: str) -> str:
     """
     prompt 문자열을 받아 LLM 호출
     """
-    print(f"[LLM 호출 프롬프트 미리보기]\n{prompt[:300]}...\n")
-    lines = [l.strip() for l in prompt.strip().splitlines() if l.strip()]
-    summary_line = lines[-1] if lines else "(요청 없음)"
-    return f"(응답 예시) {summary_line}"
+    try:
+        response = gemini_model.generate_content(prompt)
+        return response.text.strip()
+    except Exception as e:
+        return f"[LLM Error] {str(e)}"
 
-def summarize_memories(memory_texts: list[str]) -> str:
+def summarize_memories(memories: List[Memory]) -> str:
     """
-    기억 리스트를 1~2문장으로 요약
+    Memory 객체 리스트를 받아 LLM을 통해 1~2문장으로 요약
     """
-    joined = "\n".join([f"- {t}" for t in memory_texts])
-    prompt = f"""다듬은 한 인물의 과거 기억들입니다:
+    if not memories:
+        return ""
+    
+    # Memory 객체에서 .content를 추출하여 사용
+    memory_contents = [mem.content for mem in memories]
+    joined = "\n".join([f"- {content}" for content in memory_contents])
+
+    prompt = f"""다음은 한 인물의 과거 기억들입니다:
 
     {joined}
 
-    → 이 사람은 어떤 경험을 했는지 1~2문장으로 요약해 주세요.
-    """
+    → 이 사람은 어떤 경험을 했는지 1~2문장으로 요약해 주세요."""
 
-    print(f"[요약 프롬프트 미리보기]\n{prompt}")
-    return f"(요약 결과) {' / '.join(memory_texts)}"    # 실제 LLM 연결 시 교체
+    # LLM 호출 함수를 사용하여 요약 요청
+    summary = query_llm_with_prompt(prompt)
+    return summary

npc_social_network/models/llm_prompt_builder.py

@@ -1,29 +1,62 @@
 # portfolio/npc_social_network/models/llm_prompt_builder.py
 
-def build_npc_prompt(npc, user_input: str, matched_memories: list[str]) -> str:
+from typing import List, Optional, TYPE_CHECKING
+from ..npc.npc_memory import Memory
+
+# 타입 검사 시에만 NPC 클래스를 임포트하여 순환 참조 방지
+if TYPE_CHECKING:
+    from ..npc.npc_base import NPC
+    from ..npc.npc_memory import Memory
+
+def build_npc_prompt(npc:"NPC", user_input: str, matched_memories: List[Memory], target_npc: Optional["NPC"]=None) -> str:
     """
-    NPC 정보 + 사용자 입력 + 검색된 기억을 기반으로 프롬프트 생성
+    NPC 대사를 생성하기 위한 강화된 프롬프트 구성 함수
+    - 감정 요약 / 성격 요약 / 관계 / 기억 등 포함
+    - target_npc 인자를 받아 플레이어 또는 다른 NPC와의 대화 모두 처리
     """
+    # 대화 상대방의 이름을 동적으로 설정
+    interlocutor_name = target_npc.name if target_npc else "플레이어"
+
     # 감정 상태 요약
-    emotions_text = ", ".join([f"{e}({v})" for e, v in npc.get_composite_emotion_state()])
+    emotion_summary = npc.summarize_emotional_state()
+    # 성격 요약
+    personality_summary = npc.personality.get_personality_summary()
+    # 관계 요약
+    relationship_description = npc.get_relationship_description(interlocutor_name)
+
+    # 기억 요약 정비
+    memory_summaries = []
+    for mem in matched_memories:
+        # Memory 객체의 content 속성을 사용하도록 수정
+        short_content = mem.content[:50] + "..." if len(mem.content) > 50 else mem.content
+        memory_summaries.append(f"- {short_content} ({mem.emotion})")
 
-    # 관련 기억 구성
-    memory_block = "\n".join([f"- {m}" for m in matched_memories]) if matched_memories else "관련 기억 없음"
+    memory_section = "\n".join(memory_summaries[:3]) if memory_summaries else "없음"
 
     # 프롬프트 구성
     prompt = f"""
-        NPC 이름: {npc.name}
-        직업: {npc.job}
-        현재 감정 상태: {emotions_text}
-        성격 요약: {npc.personality}
-        플레이어와의 관계: {npc.get_relationship_description("플레이어")}
+        당신은 '{npc.name}'이라는 이름을 가진 사람입니다.
+        당신의 직업은 '{npc.job}'이고, 현재 '{interlocutor_name}'와(과) 대화를 나누고 있습니다.
+
+        # 당신의 현재 감정 상태:
+        {emotion_summary}
+
+        # 당신의 성격 요약:
+        {personality_summary}
+        
+        # 당신과 {interlocutor_name}와(과)의 현재 관계:
+        {relationship_description}
+
+        # 최근 기억:
+        {memory_section}
 
-        # 과거 관련 기억:
-        {memory_block}
+        # {interlocutor_name}의 발화
+        "{user_input}"
 
-        # 플레이어 질문:
-        {user_input}
+        ---
 
-        → 위 정보를 바탕으로 자연스럽고 상황에 맞는 대답을 해주세요.
+        → 이 상황에 어울리는 당신의 자연스럽고 인간적인 사람 반응을 생성하세요.
+        → 말투, 반응은 감정 상태에 맞추어 주세요.
+        → 대답은 NPC의 1인칭 시점으로 작성하세요.
 """
-    return prompt.strip()
+    return prompt

npc_social_network/npc/emotion_config.py

@@ -157,19 +157,43 @@ COGNITIVE_RELATION_EMOTIONS = [
 
 # 감정별 관계 영향도 정의 (관계에 영향 주는 감정만 등록, 정규화된 [-2.0 ~ +2.0] 범위 안에서 정의)
 EMOTION_RELATION_IMPACT = {
-    "joy": +1.0,
-    "gratitude": +1.2,
-    "love": +2.0,
-    "admiration": +0.8,
-    "pride": +0.7,
-    "calm": +0.5,
-    "sadness": -0.8,
-    "anger": -1.5,
+    "joy": 1.0,
+    "surprise": 0.2,
+    "gratitude": 1.2,
+    "pride": 0.5,
+    "love": 2.0,
+    "admiration": 0.8,
+    "empathy": 1.0,
+    "hope": 0.9,
+    "anticipatory_joy": 1.2,    
+    "calm": 0.7,
+    "engagement": 0.3,
+    "relief": 0.6,
+    "interest": 0.6,
+
+    "sadness": -1.0,
+    "anger": -1.8,
     "disgust": -2.0,
-    "fear": -1.0,
+    "fear": -1.2,
     "shame": -1.2,
-    "resentment": -1.5,
+    "guilt": 0.3,
+    "jealousy": -1.2,
+    "resentment": -1.8,
     "regret": -0.9,
-    "hope": +0.9,
-    "comfort": +0.6,
+    "schadenfreude": -1.5,
+    "anxiety": -0.5,
+    "confusion": -0.2,
+    "skepticism": -0.2,
+    "boredom": -0.2,
+
+    "compassion": 0.3,
+    "awe": 0.6,
+    "attachment": 1.7,
+    "anticipation": 0.7,
+    "curiosity": 0.6,
+    "nostalgia": 0.2,
+    "bittersweet": 0.1,
+    "rumination": -0.6,
+    "groundedness": 0.5,
+    "comfort": 0.6,
 }

npc_social_network/npc/npc_base.py

@@ -1,8 +1,9 @@
 # portfolio/npc_social_network/npc/npc_base.py
+from typing import Optional, List
 from .npc_memory import Memory, MemoryStore
 from .npc_emotion import EmotionManager
 from .npc_behavior import BehaviorManager
-from .emotion_config import EMOTION_CATEGORY_MAP, EMOTION_DECAY_RATE, PERSONALITY_TEMPLATE, EMOTION_RELATION_IMPACT
+from .emotion_config import EMOTION_LIST, EMOTION_CATEGORY_MAP, EMOTION_DECAY_RATE, PERSONALITY_TEMPLATE, EMOTION_RELATION_IMPACT
 from .emotion_config import POSITIVE_RELATION_EMOTIONS, NEGATIVE_RELATION_EMOTIONS, COGNITIVE_RELATION_EMOTIONS
 from .personality_config import AGE_PROFILE, PERSONALITY_PROFILE
 from .npc_relationship import RelationshipManager
@@ -13,6 +14,57 @@ from datetime import datetime
 import random
 import copy
 
+# Personality 데이터를 관리하고 요약 기능을 제공하는 클래스 정의
+class PersonalityManager:
+    """
+    NPC의 성격 데이터를 관리하고 관련 기능을 제공하는 클래스
+    """
+    def __init__(self, initial_traits=None):
+        self.traits = copy.deepcopy(initial_traits) if initial_traits else copy.deepcopy(PERSONALITY_TEMPLATE)
+    
+    def get(self, key, default=None):
+        return self.traits.get(key, default)
+    
+    def __getitem__(self, key):
+        return self.traits[key]
+    
+    def __setitem__(self, key, value):
+        self.traits[key] = value
+    
+    def keys(self):
+        return self.traits.keys()
+    
+    def get_personality_summary(self) -> str:
+        """
+        현재 성격 특성을 바탕으로 자연어 요약을 생성합니다.
+        """
+        sensitive = self.traits.get("sensitive", 0.5)
+        stoic = self.traits.get("stoic", 0.5)
+        cognitive_bias = self.traits.get("cognitive_bias", 0.5)
+
+        summary_parts = []
+        if sensitive > 0.7:
+            summary_parts.append("매우 민감하고 감정적인 편입니다.")
+        elif sensitive < 0.3:
+            summary_parts.append("상당히 무던하고 감정 표현이 적습니다.")
+        else:
+            summary_parts.append("보통 수준의 감수성을 지녔습니다.")
+        
+        if stoic > 0.7:
+            summary_parts.append("역경에 내성이 강하고 감정을 잘 드러내지 않습니다.")
+        elif stoic < 0.3:
+            summary_parts.append("감정의 영향을 쉽게 받는 편입니다.")
+        
+        if cognitive_bias > 0.7:
+            summary_parts.append("이성적이고 논리적인 사고를 선호합니다.")
+        elif cognitive_bias < 0.3:
+            summary_parts.append("직관과 감정에 따라 판단하는 경향이 있습니다.")
+
+        if not summary_parts:
+            return "평범하고 균형 잡힌 성격입니다."
+        
+        return " ".join(summary_parts)
+
 # NPC 클래스 정의
 class NPC:
     """
@@ -28,11 +80,11 @@ class NPC:
 
         # npc 기억
         self.memory_store = MemoryStore()
+
         # 감정 상태 등 감정 관리자 초기화
-        self.emotion_decay_rate = EMOTION_DECAY_RATE
-        self.personality = copy.deepcopy(personality) if personality else copy.deepcopy(PERSONALITY_TEMPLATE)
+        self.personality = PersonalityManager(personality)
         self.relationships = RelationshipManager()   # 관계 시스템 초기화
-        self.emotion = EmotionManager(self.emotion_decay_rate, self.personality)
+        self.emotion = EmotionManager(EMOTION_DECAY_RATE, self.personality)
 
         # 행동 관리자
         self.behavior = BehaviorManager()
@@ -43,8 +95,8 @@ class NPC:
         for emo in self._emotion_buffer:
             base_min = 0.05
             base_max = 0.3
-
             category = EMOTION_CATEGORY_MAP.get(emo, None)
+            bias = 1.0
 
             if category == "core":
                 bias = self.personality.get("affect_bias", 1.0)
@@ -107,87 +159,80 @@ class NPC:
         x, y = self.get_position()
         screen.blit(self.image, (x * tile_size, y * tile_size))
 
-    def generate_dialogue(self,user_input=None, use_llm=True):
+    def generate_dialogue(self, user_input: str, target_npc: Optional["NPC"]=None, use_llm: bool=True) -> str:
+        """
+        플레이어 또는 NPC와 상호작용 시 사용되는 통합 대사 생성 함수
+        - user_input: 입력 문장 (플레이어나 NPC로부터)
+        - target_npc: NPC 간 대화일 경우 상대 NPC
         """
-        대화 생성 함수 (기억 검색 기반 프롬프트 포함)
-        """       
         if use_llm and user_input:
-            # 관련 기억 검색
-            _, _, matched_memories = search_similar_memories(self.name, user_input)
-            # 요약 & 장기 기억화 (3개 이상일 때만)
+            # 1. 유사 기억 검색
+            _, _, matched_memories = search_similar_memories(self, user_input)
+
+            # 2. 기억 요약 및 장기 기억화
             if len(matched_memories) >= 3:
                 self.summarize_and_store_memories(matched_memories)
 
-            # 프롬프트 생성
-            prompt = build_npc_prompt(self, user_input, matched_memories)
+            # 3. LLM 프롬프트 생성
+            prompt = build_npc_prompt(self, user_input, matched_memories, target_npc)
 
-            # LLM 호출
+            # 4. LLM 호출
             npc_reply = query_llm_with_prompt(prompt)
 
-            # Memory 기록
+            # 5. 감정 추론
+            emotion = query_llm_for_emotion(npc_reply)
+            if emotion and emotion in EMOTION_LIST:
+                self.update_emotion(emotion, strength=2.0)
+
+            # 6. Memory 저장
             self.remember(
-                content = f"[플레이어] '{user_input}' → [NPC:{self.name}] '{npc_reply}'",
-                importance = 7,
-                emotion = self.emotion.get_dominant_emotion()
+                content=f"[입력] '{user_input}' → [응답] '{npc_reply}'",
+                importance=7,
+                emotion=emotion
             )
 
-            # Personality 업데이트
-            self.update_personality()
+            # 7. 관계 반영 (플레이어나 다른 NPC)
+            target = target_npc.name if target_npc else "플레이어"
+            if emotion and emotion in EMOTION_RELATION_IMPACT:
+                self.relationships.update_relationship(target, emotion, strength=2.0)
 
-            # Emotion update는 LLM 기반 generate 에서는 따로 역매핑이 애매하므로 dominant_emotion만 반영 (원하면 감정 분석 결과 기반으로 개선 가능)
-            dominant_emotion = self.emotion.get_dominant_emotion()
-            if dominant_emotion:
-                self.update_emotion(dominant_emotion, strength=2.0)
+            # 8. 성격 변화 반영
+            self.update_personality()
 
             return npc_reply
+
         else:
-            # 감정 상태와 직업에 따른 복합 행동 시퀀스 기반 대사 생성 + Behavior Trace Memory 기록   
+            # LLM 미사용 시: 감정 기반 행동 생성
             behavior_output, behavior_trace = self.behavior.perform_sequence(
-                self.name, self.job, emotion_buffer=self._emotion_buffer, return_trace = True
+                self.name, self.job, emotion_buffer=self._emotion_buffer, return_trace=True
             )
 
-            # fallback (감정 기반 행동)
-            behavior_output = self.behavior.perform_sequence(
-                self.name,
-                self.job,
-                emotion_buffer=self._emotion_buffer,
-                return_trace=False
-            )
+            # 행동 기반 감정 추론 및 반영
+            for action, score in behavior_trace:
+                emotion_name = self.behavior.action_to_emotion.get(action)
+                if emotion_name:
+                    self.update_emotion(emotion_name, strength=score)
 
-            # 단계별 dominant emotion sequence 계산
+            # dominant_score 기반 중요도 추정
             dominant_emotions = self.behavior.get_layer_dominant_emotions(self._emotion_buffer)
             dominant_sequence = self.behavior.decide_layered_sequence(dominant_emotions)
+            dominant_score = max([score for _, score in dominant_sequence]) if dominant_sequence else 5
+            importance = min(int(dominant_score), 10)
 
-            # dominant_sequence가 empty인 경우 방어적 처리
-            if dominant_sequence:
-                dominant_score = max([score for _, score in dominant_sequence])
-            else:
-                # dominant_sequence가 비었으면 기본값 사용 (예: 감정 없음 상태)
-                dominant_score = 5
-
-            # 중요도 제한
-            importance = min(int(dominant_score), 10)   # importance 1~10제한
-
-            # Behavior Trace를 Memory에 기록
+            # Memory 저장
             memory_entry = Memory(
                 content=f"행동 수행: {behavior_trace}",
                 importance=importance,
-                emotion = self.emotion.get_dominant_emotion(),
-                behavior_trace = behavior_trace
+                emotion=self.emotion.get_dominant_emotion(),
+                behavior_trace=behavior_trace
             )
             self.memory_store.add_memory(memory_entry)
 
-            # 행동에 해당하는 감정에 update_emotion 호출 (역매핑)
-            for action, score in behavior_trace:
-                emotion_name = self.behavior.action_to_emotion.get(action)
-                if emotion_name:
-                    self.update_emotion(emotion_name, strength=score)
-
-            # Personality 업데이트
+            # 성격 업데이트
             self.update_personality()
 
             return str(behavior_output)
-    
+
     def remember(self, content: str, importance: int = 5, emotion: str = None, strength: float = 1.0, memory_type:str = "Event"):
         """
         NPC가 새로운 기억을 저장하고 감정 상태에 반영
@@ -230,20 +275,9 @@ class NPC:
         """
         감정 상태 요약 텍스트 생성
         """
-        buffer = self.emotion.get_buffer() # EmotionManager에서 최�� 감정 상태 복사본 가져오기
-        nonzero = [v for v in buffer.values() if v > 0]
-        avg_strength = round(sum(nonzero) / len(nonzero), 2) if nonzero else 0.0
-        composite = sorted(buffer.items(), key=lambda x: x[1], reverse=True)
-        composite = [(emo, round(score, 2)) for emo, score in composite[:3] if score > 0]
-        composite_str = ", ".join(f"{emo}({val})" for emo, val in composite)
-        return f"감정 평균 강도: {avg_strength} / 대표 감정: {composite_str if composite else '없음' }"
-    
-    def interact_with(self, other_npc_name: str, emotion: str, positive: bool):
-        """
-        다른 NPC와 상호작용 시 감정에 따른 관계 변화를 반영
-        """
-        delta = self._get_emotion_influence(emotion, positive)
-        self.relationships.update_relationship(other_npc_name, delta)
+        composite = self.get_composite_emotion_state()
+        dominant = self.emotion.get_dominant_emotion()
+        return f"감정 평균 강도: {dominant} / 대표 감정: {composite if composite else '없음' }"
 
     def _get_emotion_influence(self, emotion: str, positive: bool) -> float:
         """
@@ -303,91 +337,6 @@ class NPC:
         """
         return self.emotion.get_top_emotions(top_n=top_n)
     
-    def interact_with_player(self, player_input: str) -> str:
-        """
-        플레이어 입력에 반응 (LLM 기반 응답 생성 + Memory/Emotion/관계 반영)
-        """
-        # STEP 1: 감정 추론 (선택적)
-        emotion = query_llm_for_emotion(player_input)
-        if emotion:
-            self.update_emotion(emotion, strength=2.0)
-
-        # STEP 2: 관련 기억 검색
-        matched_memories = search_similar_memories(self.name, player_input)
-
-        # STEP 3: 프롬프트 생성
-        prompt = build_npc_prompt(cnp=self,
-                                  user_input=player_input,
-                                  matched_memories=matched_memories)
-
-        # STEP 4: LLM 응답 생성
-        npc_reply = query_llm_with_prompt(prompt)
-
-        # STEP 5: 기억 기록
-        memory = Memory(
-            content=f"[플레이어] '{player_input}' → [NPC:{self.name}] '{npc_reply}'",
-            importance=6,
-            emotion=emotion
-        )
-        self.memory_store.add_memory(memory)
-
-        # STEP 6: 감정 기반 관계 변화 반영
-        if isinstance(emotion, dict):
-            delta = 0.0
-            for emo, strength in emotion.items():
-                if emo in EMOTION_RELATION_IMPACT:
-                    delta += EMOTION_RELATION_IMPACT[emo] * strength
-
-            if abs(delta) > 0.01:   # 영향이 충분히 있을 때만 반영
-                self.relationships.update_relationship("플레이어", delta=delta)
-                print(f"[관계 변화] '{self.name}' → 플레이어: {delta:+.2f}")
-
-        return npc_reply
-    
-    def interact_with_npc(self, target_npc):
-        """
-        다른 NPC와 상호작용 (기본적으로 감정적 메시지 주고 받기 → Memory/Emotion/Relationship 반영)
-        """
-        # 1. 상호작용 감정 선택 (가장 강한 감정 사용 예시)
-        dominant_emotion = self.emotion.get_dominant_emotion()
-
-        # 방어 코드: dominant_emotion이 None인 경우 → 기본값 대체
-        if dominant_emotion is None:
-            dominant_emotion = "neutral"
-
-        # 2. 메시지 구성 (단순 예시)
-        message = f"{self.name}이(가) {target_npc.name}에게 {dominant_emotion} 감정을 표현했습니다."
-
-        # 3. 상대방 Memory 기록
-        target_npc.remember(
-            content = message,
-            importance = 6,
-            emotion = dominant_emotion,
-            strength = 0.0  # 감정 중복 update 방지
-        )
-
-        # 상대방 Personality 업데이트
-        target_npc.update_personality()
-
-        # 4. 상대방 Emotion 반영
-        target_npc.update_emotion(dominant_emotion, strength=1.5)
-
-        # 5. 상대방 Relationship 반영
-        positive = dominant_emotion in POSITIVE_RELATION_EMOTIONS
-        target_npc.interact_with(self.name, dominant_emotion, positive)
-
-        # 6. 자신도 Memory 기록 (행동 기록)
-        self.remember(
-            content = f"{self.name}이(가) {target_npc.name}에게 감정을 표현함: {dominant_emotion}",
-            importance = 5,
-            emotion = dominant_emotion
-        )
-
-        # 자신 Personality 업데이트
-        self.update_personality()
-
-        return message
-    
     def update_personality(self):
         """
         Memory / Emotion 기반으로 Personality 변화 적용
@@ -555,15 +504,51 @@ class NPC:
             # fallback → 정상화
             return 1.0
 
-    def ummarize_and_store_memories(self, memory_texts: list[str]):
+    def summarize_and_store_memories(self, memories: List[Memory]):
         """
         기억 리스트를 요약하고, NPC 장기 기억으로 저장
         """
-        if not memory_texts:
+        if not memories:
+            return
+        
+        summary = summarize_memories(memories)
+
+        if "[LLM Error]" in summary:
+            print(f"[요약 실패] LLM 호출 중 에러가 발생하여 요약 기억을 저장하지 않습니다. 에러: {summary}")
             return
         
-        summary = summarize_memories(memory_texts)
         self.memory_store.add_memory(
             Memory(content=summary, importance=9, emotion=self.emotion.get_dominant_emotion(), memory_type="Summary")
         )
-        print(f"[요약 기억 저장됨] {summary}")
+        print(f"[요약 기억 저장됨] {summary}")
+
+    def reflect_memory_emotions_on_relationship(self, target_name: str, memory_limit: int=10):
+        """
+        최근 기억에 담긴 감정을 기반으로 대상과의 관계를 갱신
+        - 특정 대상 (플레이어 등)에 대해 감정이 담긴 Memory를 수집
+        - 각 감정에 대해 가중치를 곱해 관계 변화량 누적
+        """
+        recent_memories = self.memory_store.get_recent_memories(limit=memory_limit)
+        emotion_accumulator = {}
+
+        for mem in recent_memories:
+            if target_name not in mem.content:
+                continue # 대상이 언급된 기억만 추출
+
+            if isinstance(mem.emotion, dict):
+                for emo, value in mem.emotion.items():
+                    if emo not in EMOTION_RELATION_IMPACT:
+                        continue
+                    emotion_accumulator[emo] = emotion_accumulator.get(emo, 0.0) + value
+
+        # 전체 감정 누적값을 바탕으로 관계 변화량 계선
+        total_delta = 0.0
+        for emo, value in emotion_accumulator.items():
+            for emo, value in emotion_accumulator.items():
+                weight = EMOTION_RELATION_IMPACT[emo]
+                delta = weight * value
+                total_delta += delta
+            
+            if abs(total_delta) > 0.01:
+                self.relationships.update_relationship(target_name, delta=total_delta)
+                print(f"[기억 기반 관계 변화] {self.name} ↔ {target_name}: {total_delta:.2f}")

npc_social_network/npc/npc_memory_embedder.py

@@ -4,9 +4,10 @@ from sentence_transformers import SentenceTransformer
 import numpy as np
 import faiss
 import os
-from .npc_memory import MemoryStore
-from .npc_base import NPC
 import re
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from .npc_base import NPC
 
 # 사전 훈련된 문장 임베딩 모델
 model = SentenceTransformer("all-MiniLM-L6-v2")
@@ -36,7 +37,7 @@ def embed_memory(memory):
     embedding = model.encode(text)
     return embedding
 
-def embed_npc_memories(npc: NPC):
+def embed_npc_memories(npc: "NPC"):
     """
     특정 NPC의 기억 전체를 임베딩하고 FAISS index로 저장
     """
@@ -68,28 +69,21 @@ def load_npc_faiss_index(npc_name):
     index = faiss.read_index(index_path)
     return index
 
-def search_similar_memories(npc_name, query, top_k=3):
+def search_similar_memories(npc: "NPC", query: str, top_k=3):
     """
     질의 문장을 벡터로 변환하고 FAISS에서 유사한 기억 검색
     """
-    from ..routes.npc_route import npc_manager
-    
-    index = load_npc_faiss_index(npc_name)
+    index = load_npc_faiss_index(npc.name)
     query_vec = model.encode([query])
     distances, indices = index.search(np.array(query_vec, dtype=np.float32), top_k)
 
-    # 보다 정확한 디버깅을 위해 추가 (나중에 제거 가능)
-    npc = npc_manager.get_npc_by_name(npc_name)
     all_memories = npc.memory_store.get_all_memories()
 
-    matched_texts = [memory_to_text(all_memories[i]) for i in indices[0]]
+    # 검색된 인덱스가 메모리 범위를 벗어나지 않는지 확인
+    valid_indices = [i for i in indices[0] if i < len(all_memories)]
+    matched_memories = [all_memories[i] for i in valid_indices]
 
-    # 디버깅 출력
-    print(f"[{npc_name}] '{query}'에 대한 유사 기억 검색 결과:")
-    for rank, (idx, dist) in enumerate(zip(indices[0], distances[0])):
-        print(f"  {rank+1}. index: {idx}, distance: {dist:.4f} → {all_memories[idx].content}")
-
-    return indices[0], distances[0], matched_texts
+    return valid_indices, distances[0][:len(valid_indices)], matched_memories
 
 def sanitize_filename(name):
     """

npc_social_network/npc/npc_relationship.py

@@ -6,12 +6,26 @@ class RelationshipManager:
         # 관계 사전: {상대방 이름: 점수 (float)}
         self.relationships = {}
 
-    # 상대 NPC와의 관계 점수를 갱신
-    def update_relationship(self, other_npc_name: str, delta: float):
-        if other_npc_name not in self.relationships:
-            self.relationships[other_npc_name] = 0.0
-        self.relationships[other_npc_name] += delta
-        self.relationships[other_npc_name] = max(-100.0, min(100.0, self.relationships[other_npc_name]))    # [-100, 100] 제한
+    def update_relationship(self, other: str, emotion: str, strength: float=1.0):
+        """
+        특정 감정 기반으로 관계 수치 조정
+        - 긍정/부정만이 아니라 감정 유형에 따른 영향 차별화
+        """
+        from .emotion_config import EMOTION_RELATION_IMPACT
+
+        # 기본 로직
+        prev = self.relationships.get(other, 0.0)
+
+        impact = EMOTION_RELATION_IMPACT.get(emotion, 0.0)
+        new_value = prev + (impact * strength)
+
+        # 감쇠 적용 (값이 커질수록 변화폭을 줄여 급격한 변화 방지)
+        if abs(new_value) > abs(prev):
+            new_value = prev + (impact * strength * 0.7)    # 감쇠 비율 예시
+
+        # 클리핑 (-100 ~ 100 범위 제한)
+        new_value = max(min(new_value, 100), -100)
+        self.relationships[other] = round(new_value, 2)
 
     # 상대 NPC와의 현재 관계 점수를 반환
     def get_relationship(self, other_npc_name:str) -> float:

npc_social_network/routes/npc_route.py

@@ -63,12 +63,15 @@ def chat():
     if npc is None:
         return jsonify({"error": "NPC not found"}), 404
 
-    # 플레이어 상호 작용 진행
-    npc_reply, emotion = npc.interact_with_player(user_input, player_name = "플레이어")
+    # generate_dialogue를 통해 응답 생성 및 내부 상태 업데이트
+    npc_reply = npc.generate_dialogue(user_input, use_llm=True)
+
+    # 업데이트된 상태를 별도로 조회
+    dominant_emotion = npc.emotion.get_dominant_emotion()
 
     return jsonify({
         "npc_reply": npc_reply,
-        "dominant_emotion": emotion,
+        "dominant_emotion": dominant_emotion,
         "memory_summary": npc.summarize_emotional_state(),
         "emotion_state": npc.get_composite_emotion_state(),
         "relationship_with_player": npc.get_relationship_description("플레이어")

run_npc_interactions.py

@@ -1,14 +1,39 @@
 # portfolio/run_npc_interactions.py
 
 import time
-from npc_social_network.routes.npc_route import npc_manager
+from npc_social_network.npc.npc_manager import npc_manager
+from npc_social_network.npc.npc_base import NPC
 
-def run_npc_interactions(interval_seconds=10):
-    while True:
-        print(f"[Background] NPC interactions triggered.", flush=True)
-        npc_manager.npc_interactions()
-        time.sleep(interval_seconds)
+def run_npc_test_scenario(npc_name="엘라"):
+    npc = npc_manager.get_npc_by_name[npc_name]
 
-if __name__ == '__main__':
-    print("[Background] Starting NPC interactions loop...", flush=True)
-    run_npc_interactions(interval_seconds=10)
+    test_inputs = [
+        "오늘 하루는 최악이었어. 왜 다들 날 무시하는 거지?",
+        "고마워. 나 도와줘서 정말 감사했어.",
+        "그때 화낸 건 미안해. 내 잘못이었어.",
+        "내가 선물한 책 어땠어?",
+        "우리 예전에 함께 일했던 거 기억나?",
+    ]
+
+    for input_text in test_inputs:
+        print(f"\n[플레이어 입력] {input_text}")
+        response = npc.interact_with_player(input_text)
+        print(f"[NPC 응답] {response}")
+
+    # 기억 기반 관계 반영까지 테스트
+    npc.reflect_memory_emotions_on_relationship("플레이어")
+
+    # 상태 요약 출력
+    print("\n🧠 현재 감정 상태 요약:")
+    print(npc.summarize_emotional_state())
+
+    print("\n📚 최근 기억:")
+    for m in npc.memory_store.get_recent_memories(limit=5):
+        print(f"- {m.content} ({m.emotion})")
+
+    print("\n🔗 플레이어와의 관계:")
+    print(npc.get_relationship_description("플레이어"))
+
+
+if __name__ == "__main__":
+    run_npc_test_scenario()

test.ipynb

@@ -3133,6 +3133,139 @@
     "# 복합 감정 기반 행동 시퀀스 출력\n",
     "print(npc.generate_dialogue())"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "246a140b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\human\\.conda\\envs\\portfolio\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "[플레이어 입력] 오늘 하루는 최악이었어. 왜 다들 날 무시하는 거지?\n",
+      "[요약 기억 저장됨] 이 사람은 최근 찰리와 함께 농사일을 돕고, 밥에게 선물 받은 검을 마음에 들어 하는 긍정적이거나 일상적인 경험과 더불어 앨리스와 심하게 다투는 갈등 상황도 겪었습니다. 즉, 다양한 사람들과 여러 종류의 상호작용과 활동을 경험한 것으로 보입니다.\n",
+      "[Personality Update] 엘라 → sensitive: 1.00, stoic: 0.00, cognitive_bias: 1.00\n",
+      "[NPC 응답] 으음... 오늘 하루가 최악이었다니... 정말 힘들었겠네.\n",
+      "\n",
+      "'다들' 이라니... 정확히 누가, 왜 그랬다는 거야? 무시당하는 기분은... 나도 알 것 같기도 하고...\n",
+      "\n",
+      "[플레이어 입력] 고마워. 나 도와줘서 정말 감사했어.\n",
+      "[요약 실패] LLM 호출 중 에러가 발생하여 요약 기억을 저장하지 않습니다. 에러: [LLM Error] 500 An internal error has occurred. Please retry or report in https://developers.generativeai.google/guide/troubleshooting\n",
+      "[Personality Update] 엘라 → sensitive: 1.00, stoic: 0.00, cognitive_bias: 1.00\n",
+      "[NPC 응답] 아냐, 괜찮아. 별거 아니었는데 뭘. 네가 그렇게 말해주니 오히려 내가 다 고맙네.\n",
+      "\n",
+      "[플레이어 입력] 그때 화낸 건 미안해. 내 잘못이었어.\n",
+      "[요약 기억 저장됨] 이 인물은 최근 찰리와 농사일을 하고 밥에게 선물을 받는 등 긍정적인 경험과 더불어, 앨리스와 심하게 다투고 타인에게 무시당한다는 느낌을 받는 등 부정적인 갈등 상황도 겪었습니다. 즉, 다양한 사람들과 교류하며 좋은 경험과 나쁜 경험을 모두 경험했습니다.\n",
+      "[Personality Update] 엘라 → sensitive: 1.00, stoic: 0.00, cognitive_bias: 1.00\n",
+      "[NPC 응답] 아... 그때 화냈던 거 말이지...?\n",
+      "\n",
+      "음... 괜찮아. 누구나 가끔은 감정에 휩쓸릴 때가 있는 거니까. 나도 그런 걸.\n",
+      "\n",
+      "그렇게 말해줘서 고마워.\n",
+      "\n",
+      "[플레이어 입력] 내가 선물한 책 어땠어?\n",
+      "[요약 실패] LLM 호출 중 에러가 발생하여 요약 기억을 저장하지 않습니다. 에러: [LLM Error] 500 An internal error has occurred. Please retry or report in https://developers.generativeai.google/guide/troubleshooting\n",
+      "[Personality Update] 엘라 → sensitive: 1.00, stoic: 0.00, cognitive_bias: 1.00\n",
+      "[NPC 응답] 아... 네가 선물해 준 그 책 말이지...?\n",
+      "\n",
+      "(잠깐 생각에 잠긴 듯)\n",
+      "\n",
+      "음... 꽤... 아니, 아주 흥미로운 내용이었어. 특히 그... (책 내용 중 특정 부분을 떠올리려는 듯) 아, 맞아. 그 이론에 대해 설명하는 부분 말이야. 논리적으로 잘 정리되어 있어서 이해하기 쉬웠어. 내... 내 마법 연구에도 조금 도움이 될 것 같다는 생각도 들었고.\n",
+      "\n",
+      "...사실 요즘 이것저것 생각할 게 많아서 머리가 복잡했는데, 네가 준 책을 읽는 동안에는 다른 생각들을 다 잊고 내용에만 집중할 수 있었어.\n",
+      "\n",
+      "정말 좋은 선물이었어. 고마워.\n",
+      "\n",
+      "[플레이어 입력] 우리 예전에 함께 일했던 거 기억나?\n",
+      "[요약 실패] LLM 호출 중 에러가 발생하여 요약 기억을 저장하지 않습니다. 에러: [LLM Error] 500 An internal error has occurred. Please retry or report in https://developers.generativeai.google/guide/troubleshooting\n",
+      "[Personality Update] 엘라 → sensitive: 1.00, stoic: 0.00, cognitive_bias: 1.00\n",
+      "[NPC 응답] ```korean\n",
+      "엘라: 응... 우리 함께 일했던 거? 기억나지, 물론.\n",
+      "\n",
+      "엘라: 음... 어떤 때를 말하는 거야? 우리 함께 했던 일들은... 대부분 좋은 기억으로 남아있으니까.\n",
+      "```\n",
+      "\n",
+      "🧠 현재 감정 상태 요약:\n",
+      "감정 평균 강도: nostalgia / 대표 감정: [('nostalgia', 3.0)]\n",
+      "\n",
+      "📚 최근 기억:\n",
+      "- [입력] '우리 예전�� 함께 일했던 거 기억나?' → [응답] '```korean\n",
+      "엘라: 응... 우리 함께 일했던 거? 기억나지, 물론.\n",
+      "\n",
+      "엘라: 음... 어떤 때를 말하는 거야? 우리 함께 했던 일들은... 대부분 좋은 기억으로 남아있으니까.\n",
+      "```' (nostalgia)\n",
+      "- [입력] '내가 선물한 책 어땠어?' → [응답] '아... 네가 선물해 준 그 책 말이지...?\n",
+      "\n",
+      "(잠깐 생각에 잠긴 듯)\n",
+      "\n",
+      "음... 꽤... 아니, 아주 흥미로운 내용이었어. 특히 그... (책 내용 중 특정 부분을 떠올리려는 듯) 아, 맞아. 그 이론에 대해 설명하는 부분 말이야. 논리적으로 잘 정리되어 있어서 이해하기 쉬웠어. 내... 내 마법 연구에도 조금 도움이 될 것 같다는 생각도 들었고.\n",
+      "\n",
+      "...사실 요즘 이것저것 생각할 게 많아서 머리가 복잡했는데, 네가 준 책을 읽는 동안에는 다른 생각들을 다 잊고 내용에만 집중할 수 있었어.\n",
+      "\n",
+      "정말 좋은 선물이었어. 고마워.' (gratitude)\n",
+      "- [입력] '그때 화낸 건 미안해. 내 잘못이었어.' → [응답] '아... 그때 화냈던 거 말이지...?\n",
+      "\n",
+      "음... 괜찮아. 누구나 가끔은 감정에 휩쓸릴 때가 있는 거니까. 나도 그런 걸.\n",
+      "\n",
+      "그렇게 말해줘서 고마워.' (gratitude)\n",
+      "- 이 인물은 최근 찰리와 농사일을 하고 밥에게 선물을 받는 등 긍정적인 경험과 더불어, 앨리스와 심하게 다투고 타인에게 무시당한다는 느낌을 받는 등 부정적인 갈등 상황도 겪었습니다. 즉, 다양한 사람들과 교류하며 좋은 경험과 나쁜 경험을 모두 경험했습니다. (None)\n",
+      "- [입력] '고마워. 나 도와줘서 정말 감사했어.' → [응답] '아냐, 괜찮아. 별거 아니었는데 뭘. 네가 그렇게 말해주니 오히려 내가 다 고맙네.' (gratitude)\n",
+      "\n",
+      "🔗 플레이어와의 관계:\n",
+      "호감 있음\n"
+     ]
+    }
+   ],
+   "source": [
+    "# portfolio/test.ipynb\n",
+    "\n",
+    "import time\n",
+    "from npc_social_network.routes.npc_route import npc_manager\n",
+    "\n",
+    "def run_npc_test_scenario(npc_name=\"엘라\"):\n",
+    "    npc = npc_manager.get_npc_by_name(npc_name)\n",
+    "\n",
+    "    test_inputs = [\n",
+    "        \"오늘 하루는 최악이었어. 왜 다들 날 무시하는 거지?\",\n",
+    "        \"고마워. 나 도와줘서 정말 감사했어.\",\n",
+    "        \"그때 화낸 건 미안해. 내 잘못이었어.\",\n",
+    "        \"내가 선물한 책 어땠어?\",\n",
+    "        \"우리 예전에 함께 일했던 거 기억나?\",\n",
+    "    ]\n",
+    "\n",
+    "    for input_text in test_inputs:\n",
+    "        print(f\"\\n[플레이어 입력] {input_text}\")\n",
+    "        response = npc.generate_dialogue(input_text)\n",
+    "        print(f\"[NPC 응답] {response}\")\n",
+    "\n",
+    "    # 기억 기반 관계 반영까지 테스트\n",
+    "    npc.reflect_memory_emotions_on_relationship(\"플레이어\")\n",
+    "\n",
+    "    # 상태 요약 출력\n",
+    "    print(\"\\n🧠 현재 감정 상태 요약:\")\n",
+    "    print(npc.summarize_emotional_state())\n",
+    "\n",
+    "    print(\"\\n📚 최근 기억:\")\n",
+    "    for m in npc.memory_store.get_recent_memories(limit=5):\n",
+    "        print(f\"- {m.content} ({m.emotion})\")\n",
+    "\n",
+    "    print(\"\\n🔗 플레이어와의 관계:\")\n",
+    "    print(npc.get_relationship_description(\"플레이어\"))\n",
+    "\n",
+    "\n",
+    "run_npc_test_scenario()"
+   ]
   }
  ],
  "metadata": {