Complete step 14

npc_social_network/models/llm_helper.py

@@ -34,28 +34,26 @@ def query_llm_for_emotion(user_input):
     # 예시 결과 (추후 LLM 연결 시 교체)
     return "joy"
 
-def query_llm_for_response_with_context(npc_name, npc_job, emotion_state, recent_memories,
-                                        personality, relationship_with_player):
+def query_llm_with_prompt(prompt: str) -> str:
     """
-    LLM에 컨텍스트 정보를 전달하여 자연스러운 대사 생성
+    prompt 문자열을 받아 LLM 호출
     """
-    memory_text = "\n".join([f"- {m.content}" for m in recent_memories])
-    emotion_text = ", ".join([f"{emo}({score})" for emo, score in emotion_state])
+    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}"
 
-    # 최근 대화 내용은 기억에 다 들어가나?
-    # 행동이 들어갈 거니까, 기억도 단순 문장형이 아니라 가공해서 기억하고,
-    # 대화 내용은 가장 최근 대화 내용을 넘겨주는 방식이 좋을거 같은데, 시간이 지나면 잊혀지고
-    prompt = f"""
-        NPC 이름: {npc_name}
-        NPC 직업: {npc_job}
-        현재 감정 상태: {emotion_text}
-        최근 기억:
-        {memory_text}
-        현재 플레이어와의 관계: {relationship_with_player}
-        Personality: {personality}
+def summarize_memories(memory_texts: list[str]) -> str:
+    """
+    기억 리스트를 1~2문장으로 요약
+    """
+    joined = "\n".join([f"- {t}" for t in memory_texts])
+    prompt = f"""다듬은 한 인물의 과거 기억들입니다:
+
+    {joined}
 
-    위 정보를 참고하여, 한국어로 자연스럽고 상황에 맞는 대화 문장을 생성하세요.
+    → 이 사람은 어떤 경험을 했는지 1~2문장으로 요약해 주세요.
     """
 
-    # 임시 응답 (LLM 연결 시 교체)
-    return f"{npc_name}이(가) 말했습니다. '오늘은 기분이 좋아요!' "
+    print(f"[요약 프롬프트 미리보기]\n{prompt}")
+    return f"(요약 결과) {' / '.join(memory_texts)}"    # 실제 LLM 연결 시 교체

npc_social_network/models/llm_prompt_builder.py

@@ -0,0 +1,29 @@
+# portfolio/npc_social_network/models/llm_prompt_builder.py
+
+def build_npc_prompt(npc, user_input: str, matched_memories: list[str]) -> str:
+    """
+    NPC 정보 + 사용자 입력 + 검색된 기억을 기반으로 프롬프트 생성
+    """
+    # 감정 상태 요약
+    emotions_text = ", ".join([f"{e}({v})" for e, v in npc.get_composite_emotion_state()])
+
+    # 관련 기억 구성
+    memory_block = "\n".join([f"- {m}" for m in matched_memories]) if matched_memories else "관련 기억 없음"
+
+    # 프롬프트 구성
+    prompt = f"""
+        NPC 이름: {npc.name}
+        직업: {npc.job}
+        현재 감정 상태: {emotions_text}
+        성격 요약: {npc.personality}
+        플레이어와의 관계: {npc.get_relationship_description("플레이어")}
+
+        # 과거 관련 기억:
+        {memory_block}
+
+        # 플레이어 질문:
+        {user_input}
+
+        → 위 정보를 바탕으로 자연스럽고 상황에 맞는 대답을 해주세요.
+"""
+    return prompt.strip()

npc_social_network/npc/emotion_config.py

@@ -153,15 +153,4 @@ NEGATIVE_RELATION_EMOTIONS = [
 COGNITIVE_RELATION_EMOTIONS = [
     "compassion", "awe", "attachment", "anticipation", "curiosity",
     "nostalgia", "bittersweet", "rumination", "groundedness", "comfort",
-]
-
-# 인생 단계별 Personality 변화율 정의
-AGE_PROFILE = {
-    "infancy_and_toddlerhood": 3.0,  # (0-3 세) Temperament & attachment foundation — change rate very high
-    "early_childhood": 2.0,          # (3-6 세) Initial personality structure emergence — high change rate
-    "middle_childhood": 1.5,         # (6-12 세) Personality structure solidification — still high change rate
-    "adolescence": 1.0,              # (12-18 세) Identity formation — moderate to high change rate
-    "young_adulthood": 0.5,          # (18-30 세) Personality stabilization — moderate change rate
-    "middle_adulthood": 0.2,         # (30-65 세) Personality highly stable — low change rate
-    "older_adulthood": 0.02          # (65- 세) Personality largely fixed — minimal change
-}
+]

npc_social_network/npc/npc_base.py

@@ -6,7 +6,9 @@ from .emotion_config import EMOTION_LIST, EMOTION_CATEGORY_MAP, EMOTION_DECAY_RA
 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
-from ..models.llm_helper import query_llm_for_emotion, query_llm_for_response, query_llm_for_response_with_context
+from ..models.llm_helper import query_llm_with_prompt, query_llm_for_emotion, summarize_memories
+from ..models.llm_prompt_builder import build_npc_prompt
+from .npc_memory_embedder import search_similar_memories
 from datetime import datetime
 import random
 import copy
@@ -105,24 +107,26 @@ class NPC:
         x, y = self.get_position()
         screen.blit(self.image, (x * tile_size, y * tile_size))
 
-    def generate_dialogue(self, use_llm=True):
+    def generate_dialogue(self,user_input=None, use_llm=True):
         """
-        대화 생성 함수
+        대화 생성 함수 (기억 검색 기반 프롬프트 포함)
         """       
-        if use_llm:
-            # LLM 기반 generate
-            npc_reply = query_llm_for_response_with_context(
-                npc_name = self.name,
-                npc_job = self.job,
-                emotion_state = self.get_composite_emotion_state(),
-                recent_memories = self.memory_store.get_recent_memories(limit=5),
-                personality = self.personality,
-                relationship_with_player = self.get_relationship_description("플레이어"),
-            )
+        if use_llm and user_input:
+            # 관련 기억 검색
+            _, _, matched_memories = search_similar_memories(self.name, user_input)
+            # 요약 & 장기 기억화 (3개 이상일 때만)
+            if len(matched_memories) >= 3:
+                self.summarize_and_store_memories(matched_memories)
+
+            # 프롬프트 생성
+            prompt = build_npc_prompt(self, user_input, matched_memories)
+
+            # LLM 호출
+            npc_reply = query_llm_with_prompt(prompt)
 
             # Memory 기록
             self.remember(
-                content = f"[NPC: {self.name}] LLM 대사: '{npc_reply}'",
+                content = f"[플레이어] '{user_input}' → [NPC:{self.name}] '{npc_reply}'",
                 importance = 7,
                 emotion = self.emotion.get_dominant_emotion()
             )
@@ -142,6 +146,14 @@ class NPC:
                 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
+            )
+
             # 단계별 dominant emotion sequence 계산
             dominant_emotions = self.behavior.get_layer_dominant_emotions(self._emotion_buffer)
             dominant_sequence = self.behavior.decide_layered_sequence(dominant_emotions)
@@ -174,7 +186,7 @@ class NPC:
             # Personality 업데이트
             self.update_personality()
 
-            return behavior_output
+            return str(behavior_output)
     
     def remember(self, content: str, importance: int = 5, emotion: str = None, strength: float = 1.0, memory_type:str = "Event"):
         """
@@ -291,35 +303,35 @@ class NPC:
         """
         return self.emotion.get_top_emotions(top_n=top_n)
     
-    def interact_with_player(self, user_input:str, player_name:str="플레이어"):
+    def interact_with_player(self, player_input: str) -> str:
         """
         플레이어 입력에 반응 (LLM 기반 응답 생성 + Memory/Emotion/관계 반영)
         """
-        # 1. LLM 응답 생성
-        npc_reply = query_llm_for_response(self.name, self.job, user_input)
-
-        # 2. LLM 감정 추출
-        dominant_emotion = query_llm_for_emotion(user_input)
+        # STEP 1: 감정 추론 (선택적)
+        emotion = query_llm_for_emotion(player_input)
+        if emotion:
+            self.update_emotion(emotion, strength=2.0)
 
-        # 3. Memory 기록
-        self.remember(
-            content = f"[플레이어:{player_name}] '{user_input}' → [NPC:{self.name}] '{npc_reply}'",
-            importance = 7, # 플레이어 상호작용은 높은 중요도로 저장(나중에 내용에 따라 변경하도록 수정)
-            emotion = dominant_emotion
-        )
+        # STEP 2: 관련 기억 검색
+        _, _, matched_memories = search_similar_memories(self.name, player_input)
+        # 요약 & 장기 기억화 (3개 이상일 때만)
+        if len(matched_memories) >= 3:
+            self.summarize_and_store_memories(matched_memories)
 
-        # Personality 업데이트
-        self.update_personality()
+        # STEP 3: 프롬프트 생성
+        prompt = build_npc_prompt(self, player_input, matched_memories)
 
-        # 4. Emotion 반영
-        if dominant_emotion:
-            self.update_emotion(dominant_emotion, strength=2.0)
+        # STEP 4: LLM 응답 생성
+        npc_reply = query_llm_with_prompt(prompt)
 
-        # 5. 관계 반영 (상호작용 기반 - 지금 상태면 긍정적인 관계만 반영되는거 아닌가?)
-        positive = dominant_emotion in POSITIVE_RELATION_EMOTIONS
-        self.interact_with(player_name, dominant_emotion, positive)
+        # STEP 5: 기억 기록
+        self.remember(
+            content=f"[플레이어] '{player_input}' → [NPC:{self.name}] '{npc_reply}'",
+            importance=6,
+            emotion=emotion
+        )
 
-        return npc_reply, dominant_emotion
+        return npc_reply
     
     def interact_with_npc(self, target_npc):
         """
@@ -531,3 +543,16 @@ class NPC:
         else:
             # fallback → 정상화
             return 1.0
+
+    def ummarize_and_store_memories(self, memory_texts: list[str]):
+        """
+        기억 리스트를 요약하고, NPC 장기 기억으로 저장
+        """
+        if not memory_texts:
+            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}")