Private-AI

Running

App Files Files Community

seawolf2357 commited on 8 days ago

Commit

a71a8c0

verified ·

1 Parent(s): d754924

Update app.py

Browse files

Files changed (1) hide show

app.py +173 -17

app.py CHANGED Viewed

@@ -650,6 +650,8 @@ HTML_CONTENT = """<!DOCTYPE html>
                 userMemories = {};
                 memoryList.innerHTML = '';
                 memories.forEach(memory => {
                     if (!userMemories[memory.category]) {
                         userMemories[memory.category] = [];
@@ -665,7 +667,10 @@ HTML_CONTENT = """<!DOCTYPE html>
                     memoryList.appendChild(item);
                 });
-                console.log('Loaded memories:', userMemories);
             } catch (error) {
                 console.error('Failed to load memories:', error);
             }
@@ -911,6 +916,12 @@ HTML_CONTENT = """<!DOCTYPE html>
         }
         async function setupWebRTC() {
             const config = __RTC_CONFIGURATION__;
             peerConnection = new RTCPeerConnection(config);
             const timeoutId = setTimeout(() => {
@@ -972,6 +983,9 @@ HTML_CONTENT = """<!DOCTYPE html>
                 webrtc_id = Math.random().toString(36).substring(7);
                 const response = await fetch('/webrtc/offer', {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
@@ -1123,9 +1137,16 @@ HTML_CONTENT = """<!DOCTYPE html>
             }
         }
-        startButton.addEventListener('click', () => {
             console.log('clicked');
             console.log(peerConnection, peerConnection?.connectionState);
             if (!peerConnection || peerConnection.connectionState !== 'connected') {
                 setupWebRTC();
             } else {
@@ -1488,22 +1509,27 @@ def update_chatbot(chatbot: list[dict], response: ResponseAudioTranscriptDoneEve
     chatbot.append({"role": "assistant", "content": response.transcript})
     return chatbot
 def format_memories_for_prompt(memories: Dict[str, List[str]]) -> str:
     """Format memories for inclusion in system prompt"""
     if not memories:
         return ""
     memory_text = "\n\n=== 기억된 정보 ===\n"
     for category, items in memories.items():
         if items and isinstance(items, list):
-            memory_text += f"\n[{category}]\n"
-            for item in items:
-                if item:  # Check if item is not None or empty
                     memory_text += f"- {item}\n"
-    return memory_text
 async def process_text_chat(message: str, web_search_enabled: bool, session_id: str,
                           user_name: str = "", memories: Dict = None) -> Dict[str, str]:
@@ -1610,12 +1636,20 @@ class OpenAIHandler(AsyncStreamHandler):
         self.session_id = session_id
         self.user_name = user_name
         self.memories = memories or {}
-        self.is_responding = False  # Track if already responding
-        self.should_stop = False  # Track if conversation should stop
-        print(f"[INIT] Handler created with web_search={web_search_enabled}, session_id={session_id}, user={user_name}")
     def copy(self):
         if connection_settings:
             recent_ids = sorted(connection_settings.keys(),
                               key=lambda k: connection_settings[k].get('timestamp', 0),
@@ -1625,17 +1659,64 @@ class OpenAIHandler(AsyncStreamHandler):
                 settings = connection_settings[recent_id]
                 print(f"[COPY] Copying settings from {recent_id}:")
                 return OpenAIHandler(
                     web_search_enabled=settings.get('web_search_enabled', False),
                     webrtc_id=recent_id,
                     session_id=settings.get('session_id'),
                     user_name=settings.get('user_name', ''),
-                    memories=settings.get('memories', {})
                 )
         print(f"[COPY] No settings found, creating default handler")
         return OpenAIHandler(web_search_enabled=False)
     async def search_web(self, query: str) -> str:
         """Perform web search and return formatted results"""
@@ -1681,6 +1762,23 @@ class OpenAIHandler(AsyncStreamHandler):
                 print(f"[START_UP] Updated settings from storage for {self.webrtc_id}")
         self.client = openai.AsyncOpenAI()
         print(f"[REALTIME API] Connecting...")
@@ -1696,6 +1794,9 @@ IMPORTANT: Give only ONE response per user input. Do not repeat yourself or give
         if self.memories:
             memory_text = format_memories_for_prompt(self.memories)
             base_instructions += memory_text
         # Define the web search function
         tools = []
@@ -1941,15 +2042,51 @@ IMPORTANT: Give only ONE response per user input. Do not repeat yourself or give
             print("[REALTIME API] Connection closed")
-# Create initial handler instance
-handler = OpenAIHandler(web_search_enabled=False)
 # Create components
 chatbot = gr.Chatbot(type="messages")
-# Create stream with handler instance
 stream = Stream(
-    handler,
     mode="send-receive",
     modality="audio",
     additional_inputs=[chatbot],
@@ -1960,6 +2097,8 @@ stream = Stream(
     time_limit=300 if get_space() else None,
 )
 app = FastAPI()
 # Mount stream
@@ -2005,6 +2144,23 @@ async def custom_offer(request: Request):
     print(f"[OFFER] web_search_enabled: {web_search_enabled}")
     print(f"[OFFER] session_id: {session_id}")
     print(f"[OFFER] user_name: {user_name}")
     # Store settings with timestamp
     if webrtc_id:
@@ -2012,11 +2168,11 @@ async def custom_offer(request: Request):
             'web_search_enabled': web_search_enabled,
             'session_id': session_id,
             'user_name': user_name,
-            'memories': memories,
             'timestamp': asyncio.get_event_loop().time()
         }
-        print(f"[OFFER] Stored settings for {webrtc_id}")
     # Remove our custom route temporarily
     custom_route = None

                 userMemories = {};
                 memoryList.innerHTML = '';
+                console.log('[LoadMemories] Loaded memories from DB:', memories);
                 memories.forEach(memory => {
                     if (!userMemories[memory.category]) {
                         userMemories[memory.category] = [];
                     memoryList.appendChild(item);
                 });
+                console.log('[LoadMemories] Formatted memories:', userMemories);
+                console.log('[LoadMemories] Total categories:', Object.keys(userMemories).length);
+                console.log('[LoadMemories] Total items:', Object.values(userMemories).flat().length);
             } catch (error) {
                 console.error('Failed to load memories:', error);
             }
         }
         async function setupWebRTC() {
+            // 메모리가 로드되지 않았다면 먼저 로드
+            if (Object.keys(userMemories).length === 0) {
+                console.log('[WebRTC] No memories loaded, loading now...');
+                await loadMemories();
+            }
             const config = __RTC_CONFIGURATION__;
             peerConnection = new RTCPeerConnection(config);
             const timeoutId = setTimeout(() => {
                 webrtc_id = Math.random().toString(36).substring(7);
+                console.log('[WebRTC] Sending offer with memories:', userMemories);
+                console.log('[WebRTC] Total memory items:', Object.values(userMemories).flat().length);
                 const response = await fetch('/webrtc/offer', {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
             }
         }
+        startButton.addEventListener('click', async () => {
             console.log('clicked');
             console.log(peerConnection, peerConnection?.connectionState);
+            // 메모리가 로드되지 않았다면 먼저 로드
+            if (Object.keys(userMemories).length === 0) {
+                console.log('[StartButton] Loading memories before starting...');
+                await loadMemories();
+            }
             if (!peerConnection || peerConnection.connectionState !== 'connected') {
                 setupWebRTC();
             } else {
     chatbot.append({"role": "assistant", "content": response.transcript})
     return chatbot
 def format_memories_for_prompt(memories: Dict[str, List[str]]) -> str:
     """Format memories for inclusion in system prompt"""
     if not memories:
         return ""
     memory_text = "\n\n=== 기억된 정보 ===\n"
+    memory_count = 0
     for category, items in memories.items():
         if items and isinstance(items, list):
+            valid_items = [item for item in items if item]  # None이나 빈 문자열 제외
+            if valid_items:
+                memory_text += f"\n[{category}]\n"
+                for item in valid_items:
                     memory_text += f"- {item}\n"
+                    memory_count += 1
+    print(f"[FORMAT_MEMORIES] Formatted {memory_count} memory items")
+    return memory_text if memory_count > 0 else ""
 async def process_text_chat(message: str, web_search_enabled: bool, session_id: str,
                           user_name: str = "", memories: Dict = None) -> Dict[str, str]:
         self.session_id = session_id
         self.user_name = user_name
         self.memories = memories or {}
+        self.is_responding = False
+        self.should_stop = False
+        # 메모리 정보 로깅
+        memory_count = sum(len(items) for items in self.memories.values() if isinstance(items, list))
+        print(f"[INIT] Handler created with:")
+        print(f"  - web_search={web_search_enabled}")
+        print(f"  - session_id={session_id}")
+        print(f"  - user={user_name}")
+        print(f"  - memory categories={list(self.memories.keys())}")
+        print(f"  - total memory items={memory_count}")
     def copy(self):
+        # 가장 최근의 connection settings 가져오기
         if connection_settings:
             recent_ids = sorted(connection_settings.keys(),
                               key=lambda k: connection_settings[k].get('timestamp', 0),
                 settings = connection_settings[recent_id]
                 print(f"[COPY] Copying settings from {recent_id}:")
+                print(f"[COPY] - web_search: {settings.get('web_search_enabled', False)}")
+                print(f"[COPY] - session_id: {settings.get('session_id')}")
+                print(f"[COPY] - user_name: {settings.get('user_name', '')}")
+                memories = settings.get('memories', {})
+                # 메모리가 없으면 DB에서 직접 로드 (동기적으로)
+                if not memories:
+                    print(f"[COPY] No memories in settings, loading from DB...")
+                    import asyncio
+                    try:
+                        # 현재 이벤트 루프가 있는지 확인
+                        loop = asyncio.get_event_loop()
+                        if loop.is_running():
+                            # 이미 실행 중인 루프가 있으면 run_in_executor 사용
+                            import concurrent.futures
+                            with concurrent.futures.ThreadPoolExecutor() as executor:
+                                future = executor.submit(self._load_memories_sync)
+                                memories_list = future.result()
+                        else:
+                            # 새 루프에서 실행
+                            memories_list = loop.run_until_complete(PersonalAssistantDB.get_all_memories())
+                    except:
+                        # 새 루프 생성
+                        new_loop = asyncio.new_event_loop()
+                        asyncio.set_event_loop(new_loop)
+                        memories_list = new_loop.run_until_complete(PersonalAssistantDB.get_all_memories())
+                        new_loop.close()
+                    # 메모리를 카테고리별로 그룹화
+                    for memory in memories_list:
+                        category = memory['category']
+                        if category not in memories:
+                            memories[category] = []
+                        memories[category].append(memory['content'])
+                    print(f"[COPY] Loaded {len(memories_list)} memories from DB")
+                print(f"[COPY] - memories count: {sum(len(items) for items in memories.values() if isinstance(items, list))}")
                 return OpenAIHandler(
                     web_search_enabled=settings.get('web_search_enabled', False),
                     webrtc_id=recent_id,
                     session_id=settings.get('session_id'),
                     user_name=settings.get('user_name', ''),
+                    memories=memories
                 )
         print(f"[COPY] No settings found, creating default handler")
         return OpenAIHandler(web_search_enabled=False)
+    def _load_memories_sync(self):
+        """동기적으로 메모리 로드 (Thread에서 실행용)"""
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        result = loop.run_until_complete(PersonalAssistantDB.get_all_memories())
+        loop.close()
+        return result
     async def search_web(self, query: str) -> str:
         """Perform web search and return formatted results"""
                 print(f"[START_UP] Updated settings from storage for {self.webrtc_id}")
+        # 메모리가 비어있고 session_id가 있으면 DB에서 로드
+        if not self.memories:
+            print(f"[START_UP] No memories found, loading from DB...")
+            memories_list = await PersonalAssistantDB.get_all_memories()
+            # 메모리를 카테고리별로 그룹화
+            self.memories = {}
+            for memory in memories_list:
+                category = memory['category']
+                if category not in self.memories:
+                    self.memories[category] = []
+                self.memories[category].append(memory['content'])
+            print(f"[START_UP] Loaded {len(memories_list)} memories from DB")
+        print(f"[START_UP] Final memory count: {sum(len(items) for items in self.memories.values() if isinstance(items, list))}")
         self.client = openai.AsyncOpenAI()
         print(f"[REALTIME API] Connecting...")
         if self.memories:
             memory_text = format_memories_for_prompt(self.memories)
             base_instructions += memory_text
+            print(f"[START_UP] Added memories to system prompt: {len(memory_text)} characters")
+        else:
+            print(f"[START_UP] No memories to add to system prompt")
         # Define the web search function
         tools = []
             print("[REALTIME API] Connection closed")
+# Factory function to create new handler with latest settings
+def create_handler():
+    """Factory function to create new handler with latest settings"""
+    # 가장 최근의 설정 가져오기
+    if connection_settings:
+        recent_ids = sorted(connection_settings.keys(),
+                          key=lambda k: connection_settings[k].get('timestamp', 0),
+                          reverse=True)
+        if recent_ids:
+            recent_id = recent_ids[0]
+            settings = connection_settings[recent_id]
+            memories = settings.get('memories', {})
+            # 메모리가 없으면 DB에서 직접 로드 (동기적으로)
+            if not memories:
+                import asyncio
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                memories_list = loop.run_until_complete(PersonalAssistantDB.get_all_memories())
+                loop.close()
+                # 메모리를 카테고리별로 그룹화
+                for memory in memories_list:
+                    category = memory['category']
+                    if category not in memories:
+                        memories[category] = []
+                    memories[category].append(memory['content'])
+            return OpenAIHandler(
+                web_search_enabled=settings.get('web_search_enabled', False),
+                webrtc_id=recent_id,
+                session_id=settings.get('session_id'),
+                user_name=settings.get('user_name', ''),
+                memories=memories
+            )
+    return OpenAIHandler(web_search_enabled=False)
 # Create components
 chatbot = gr.Chatbot(type="messages")
+# Create stream with factory function
 stream = Stream(
+    create_handler,  # handler 대신 factory function 전달
     mode="send-receive",
     modality="audio",
     additional_inputs=[chatbot],
     time_limit=300 if get_space() else None,
 )
 app = FastAPI()
 # Mount stream
     print(f"[OFFER] web_search_enabled: {web_search_enabled}")
     print(f"[OFFER] session_id: {session_id}")
     print(f"[OFFER] user_name: {user_name}")
+    print(f"[OFFER] memories categories: {list(memories.keys())}")
+    print(f"[OFFER] memories total items: {sum(len(items) for items in memories.values() if isinstance(items, list))}")
+    # 메모리가 비어있으면 DB에서 로드
+    if not memories and session_id:
+        print(f"[OFFER] No memories received, loading from DB...")
+        memories_list = await PersonalAssistantDB.get_all_memories()
+        # 메모리를 카테고리별로 그룹화
+        memories = {}
+        for memory in memories_list:
+            category = memory['category']
+            if category not in memories:
+                memories[category] = []
+            memories[category].append(memory['content'])
+        print(f"[OFFER] Loaded {len(memories_list)} memories from DB")
     # Store settings with timestamp
     if webrtc_id:
             'web_search_enabled': web_search_enabled,
             'session_id': session_id,
             'user_name': user_name,
+            'memories': memories,  # DB에서 로드한 메모리 저장
             'timestamp': asyncio.get_event_loop().time()
         }
+        print(f"[OFFER] Stored settings for {webrtc_id} with {sum(len(items) for items in memories.values() if isinstance(items, list))} memory items")
     # Remove our custom route temporarily
     custom_route = None