Update app.py

app.py

@@ -6,7 +6,7 @@ import os
 from typing import List, Dict, Tuple, Any
 from pgvector.psycopg2 import register_vector
 import numpy as np
-from datetime import datetime
+from datetime import datetime, timezone
 
 # 가중치 및 임계값 설정
 DEFAULT_FULL_WEIGHT = 0.2
@@ -15,8 +15,12 @@ DEFAULT_CUSTOMER_WEIGHT = 0.2
 DEFAULT_AGENT_WEIGHT = 0.1
 DEFAULT_SIMILARITY_THRESHOLD = 0
 
+# OpenAI 클라이언트 초기화
+client = OpenAI()
+
 # DB 연결 설정
 def get_db_conn():
+    """PostgreSQL 데이터베이스에 연결합니다."""
     return psycopg2.connect(
         host=os.environ["VECTOR_HOST"],
         port=5432,
@@ -25,32 +29,49 @@ def get_db_conn():
         password=os.environ["VECTOR_SECRET"]
     )
 
-client = OpenAI()
-
 def get_embedding(text: str) -> List[float]:
-    """텍스트를 임베딩 벡터로 변환합니다."""
-    response = client.embeddings.create(
-        input=text,
-        model="text-embedding-3-small",
-        encoding_format="float"  # 명시적으로 float 형식 지정
-    )
-    return response.data[0].embedding
-
-def get_text_value(node, field_name):
-    """JSON 노드에서 텍스트 값을 안전하게 추출합니다."""
-    if node and field_name in node and node[field_name] is not None:
-        return node[field_name]
-    return None
+    """
+    텍스트를 OpenAI의 text-embedding-3-small 모델을 사용하여 임베딩 벡터로 변환합니다.
+    
+    Args:
+        text (str): 임베딩할 텍스트
+    
+    Returns:
+        List[float]: 임베딩 벡터
+    """
+    try:
+        response = client.embeddings.create(
+            input=text,
+            model="text-embedding-3-small",
+            encoding_format="float",  # 명시적으로 float 형식 지정
+            dimensions=1536  # 차원 수 명시
+        )
+        return response.data[0].embedding
+    except Exception as e:
+        print(f"임베딩 생성 중 오류 발생: {str(e)}")
+        raise
 
 def format_vector_for_pg(vector: List[float]) -> str:
-    """벡터를 PostgreSQL 포맷으로 변환합니다."""
-    # 정밀도 유지를 위해 str() 함수 대신 소수점 제한 없이 바로 join
+    """
+    임베딩 벡터를 PostgreSQL 포맷으로 변환합니다.
+    자바의 formatVectorForPg() 메소드와 동일한 기능입니다.
+    """
+    # 자바 구현과 동일하게 StringBuilder 방식으로 구현
     vector_str = ','.join([f"{x}" for x in vector])
     return f"[{vector_str}]"
 
+def get_text_value(node: Dict, field_name: str) -> str:
+    """
+    딕셔너리에서 텍스트 값을 안전하게 추출합니다.
+    자바의 getTextValue() 메소드와 동일한 기능입니다.
+    """
+    if node and field_name in node and node[field_name] is not None:
+        return node[field_name]
+    return None
+
 def search_similar_chat(query: str, max_results: int = 100) -> List[Dict]:
     """
-    다중 임베딩된 채팅 데이터에서 유사한 콘텐츠를 검색합니다.
+    채팅 데이터에서 유사한 콘텐츠를 검색합니다.
     
     Args:
         query (str): 검색할 쿼리 텍스트
@@ -61,7 +82,7 @@ def search_similar_chat(query: str, max_results: int = 100) -> List[Dict]:
     """
     limit = max_results if max_results is not None else 100
     
-    # 가중치 설정
+    # 자바와 동일한 가중치 설정
     full_w = DEFAULT_FULL_WEIGHT
     topic_w = DEFAULT_TOPIC_WEIGHT
     customer_w = DEFAULT_CUSTOMER_WEIGHT
@@ -71,28 +92,27 @@ def search_similar_chat(query: str, max_results: int = 100) -> List[Dict]:
     print(f"다중 임베딩 검색 시작: 쿼리='{query}', 가중치=(full={full_w}, topic={topic_w}, customer={customer_w}, agent={agent_w}), 최대 결과={limit}")
     
     try:
-        # 쿼리 임베딩 생성 - 인코딩 포맷 명시
+        # 쿼리 임베딩 생성
         query_embedding = get_embedding(query)
-        print(f"임베딩 생성 완료: 벡터 길이={len(query_embedding)}")
         
-        # 벡터 포맷 변환
+        # PostgreSQL 포맷으로 벡터 변환
         query_vector = format_vector_for_pg(query_embedding)
         
         # DB 연결
         conn = get_db_conn()
         register_vector(conn)
         
-        # 자바 구현과 일치하도록 SQL 쿼리 수정
-        sql = f"""
-            WITH similarities AS (
+        # 자바 코드와 동일한 SQL 쿼리 구현
+        sql = """
+            WITH embeddings AS (
                 SELECT 
                     id, 
                     metadata, 
                     content,
-                    CASE WHEN full_embedding IS NOT NULL THEN 1 - (full_embedding <=> '{query_vector}'::vector) ELSE 0 END * {full_w} as full_sim,
-                    CASE WHEN topic_embedding IS NOT NULL THEN 1 - (topic_embedding <=> '{query_vector}'::vector) ELSE 0 END * {topic_w} as topic_sim,
-                    CASE WHEN customer_embedding IS NOT NULL THEN 1 - (customer_embedding <=> '{query_vector}'::vector) ELSE 0 END * {customer_w} as customer_sim,
-                    CASE WHEN agent_embedding IS NOT NULL THEN 1 - (agent_embedding <=> '{query_vector}'::vector) ELSE 0 END * {agent_w} as agent_sim
+                    CASE WHEN full_embedding IS NOT NULL THEN 1 - (full_embedding <=> '%s'::vector) ELSE 0 END * %f as full_sim,
+                    CASE WHEN topic_embedding IS NOT NULL THEN 1 - (topic_embedding <=> '%s'::vector) ELSE 0 END * %f as topic_sim,
+                    CASE WHEN customer_embedding IS NOT NULL THEN 1 - (customer_embedding <=> '%s'::vector) ELSE 0 END * %f as customer_sim,
+                    CASE WHEN agent_embedding IS NOT NULL THEN 1 - (agent_embedding <=> '%s'::vector) ELSE 0 END * %f as agent_sim
                 FROM vector_store_multi_embeddings
                 WHERE full_embedding IS NOT NULL
                 OR topic_embedding IS NOT NULL
@@ -103,25 +123,20 @@ def search_similar_chat(query: str, max_results: int = 100) -> List[Dict]:
                 id, 
                 metadata, 
                 content,
-                (full_sim + topic_sim + customer_sim + agent_sim) as combined_similarity,
-                full_sim / {full_w} as full_raw_sim,
-                topic_sim / {topic_w} as topic_raw_sim,
-                customer_sim / {customer_w} as customer_raw_sim,
-                agent_sim / {agent_w} as agent_raw_sim
-            FROM similarities
+                (full_sim + topic_sim + customer_sim + agent_sim) as combined_similarity
+            FROM embeddings
             ORDER BY combined_similarity DESC
-            LIMIT {limit}
-        """
+            LIMIT %s
+        """ % (query_vector, full_w, query_vector, topic_w, query_vector, customer_w, query_vector, agent_w, limit)
         
         with conn.cursor() as cur:
-            print(f"쿼리 실행: 자바 구현과 일치하도록 수정")
+            print(f"쿼리 실행: 자바 구현과 동일하게 수정")
             cur.execute(sql)
             rows = cur.fetchall()
             
             print(f"검색 결과: 총 {len(rows)}개 데이터 조회됨")
             if len(rows) > 0:
                 print(f"첫 번째 결과 ID: {rows[0][0]}, 유사도: {float(rows[0][3])}")
-                print(f"첫 번째 결과 원시 유사도 - full: {rows[0][4]}, topic: {rows[0][5]}, customer: {rows[0][6]}, agent: {rows[0][7]}")
             
             results = []
             for row in rows:
@@ -129,12 +144,6 @@ def search_similar_chat(query: str, max_results: int = 100) -> List[Dict]:
                 metadata_json = row[1]
                 content = row[2]
                 similarity_score = float(row[3])
-                raw_sims = {
-                    "full": None if row[4] is None else float(row[4]),
-                    "topic": None if row[5] is None else float(row[5]),
-                    "customer": None if row[6] is None else float(row[6]),
-                    "agent": None if row[7] is None else float(row[7])
-                }
                 
                 # 메타데이터 파싱
                 try:
@@ -145,11 +154,10 @@ def search_similar_chat(query: str, max_results: int = 100) -> List[Dict]:
                         "similarityScore": similarity_score,
                         "content": content,
                         "chatId": get_text_value(metadata, "chatId"),
-                        "topic": get_text_value(metadata, "topic"),
-                        "rawSimilarities": raw_sims
+                        "topic": get_text_value(metadata, "topic")
                     }
                     
-                    # 시간 필드 변환 없이 그대로 사용
+                    # 시간 필드 변환 없이 그대로 사용 (이미 KST로 저장되어 있음)
                     if "startTime" in metadata and metadata["startTime"] is not None:
                         result["startTime"] = metadata["startTime"]
                     
@@ -162,12 +170,17 @@ def search_similar_chat(query: str, max_results: int = 100) -> List[Dict]:
                     print(f"문제가 발생한 메타데이터: {metadata_json[:200]}...")
                     continue
             
-            if len(results) > 0:
-                print(f"가장 높은 유사도 점수: {results[0]['similarityScore']}")
-                print(f"상위 결과 챗ID: {results[0].get('chatId')}, 주제: {results[0].get('topic', '')[:50]}...")
-                print(f"상위 결과 원시 유사도: {results[0]['rawSimilarities']}")
+            # 임계값 필터링 (자바 코드와 동일하게 구현)
+            filtered_results = [r for r in results if r["similarityScore"] >= threshold]
             
-            return results
+            if len(filtered_results) > 0:
+                print(f"임계값({threshold}) 이상 결과: {len(filtered_results)}개 / 전체 {len(results)}개")
+                print(f"가장 높은 유사도 점수: {filtered_results[0]['similarityScore']}")
+                print(f"상위 결과 챗ID: {filtered_results[0].get('chatId')}, 주제: {filtered_results[0].get('topic', '')[:50]}...")
+            else:
+                print(f"임계값({threshold}) 이상의 결과�� 없습니다")
+            
+            return filtered_results
     
     except Exception as e:
         print(f"다중 임베딩 검색 중 오류 발생: {str(e)}")
@@ -184,7 +197,7 @@ def search_similar_chat_by_date(
     max_results: int = 100
 ) -> List[Dict]:
     """
-    지정된 날짜 범위 내의 다중 임베딩 채팅 데이터를 검색합니다.
+    지정된 날짜 범위 내의 채팅 데이터를 검색합니다.
     
     Args:
         query (str): 검색할 쿼리 텍스트
@@ -197,7 +210,7 @@ def search_similar_chat_by_date(
     """
     limit = max_results if max_results is not None else 100
     
-    # 가중치 설정
+    # 자바와 동일한 가중치 설정
     full_w = DEFAULT_FULL_WEIGHT
     topic_w = DEFAULT_TOPIC_WEIGHT
     customer_w = DEFAULT_CUSTOMER_WEIGHT
@@ -207,13 +220,14 @@ def search_similar_chat_by_date(
     print(f"다중 임베딩 날짜 검색 시작: 쿼리='{query}', 시작일={start_date}, 종료일={end_date}, 최대 결과={limit}")
     
     try:
-        # 날짜 필터 파라미터 생성
+        # 날짜 필터 파라미터 생성 (자바 코드와 동일하게 구현)
         start_timestamp = None
         end_timestamp = None
         
         if start_date and start_date.strip():
             try:
-                start_datetime = datetime.strptime(start_date, '%Y-%m-%d')
+                # 자바에서는 LocalDateTime.parse() 사용하므로 동일하게 구현
+                start_datetime = datetime.strptime(start_date + "T00:00:00", '%Y-%m-%dT%H:%M:%S')
                 start_timestamp = int(start_datetime.timestamp() * 1000)  # 밀리초 단위로 변환
             except ValueError as e:
                 print(f"시작 날짜 형식 오류: {str(e)}")
@@ -221,43 +235,42 @@ def search_similar_chat_by_date(
         
         if end_date and end_date.strip():
             try:
-                # 종료일의 23:59:59로 설정
-                end_datetime = datetime.strptime(end_date + ' 23:59:59', '%Y-%m-%d %H:%M:%S')
+                # 자바에서는 LocalDateTime.parse() 사용하므로 동일하게 구현
+                end_datetime = datetime.strptime(end_date + "T23:59:59", '%Y-%m-%dT%H:%M:%S')
                 end_timestamp = int(end_datetime.timestamp() * 1000)  # 밀리초 단위로 변환
             except ValueError as e:
                 print(f"종료 날짜 형식 오류: {str(e)}")
                 return []
         
-        # 쿼리 임베딩 생성 - 정규화 제거
+        # 쿼리 임베딩 생성
         query_embedding = get_embedding(query)
-        print(f"날짜 검색 - 임베딩 생성 완료: 첫 5개 요소: {query_embedding[:5]}")
         
-        # Java 방식: 벡터를 문자열로 변환
+        # PostgreSQL 포맷으로 벡터 변환
         query_vector = format_vector_for_pg(query_embedding)
         
         # DB 연결
         conn = get_db_conn()
         register_vector(conn)
         
-        # Java 방식: 문자열 포맷팅 사용한 SQL 쿼리 시작
-        sql = f"""
+        # 자바 코드와 동일한 SQL 쿼리 시작
+        sql = """
             WITH embeddings AS (
                 SELECT 
                     id, 
                     metadata, 
                     content,
-                    CASE WHEN full_embedding IS NOT NULL THEN 1 - (full_embedding <=> '{query_vector}'::vector) ELSE 0 END * {full_w} as full_sim,
-                    CASE WHEN topic_embedding IS NOT NULL THEN 1 - (topic_embedding <=> '{query_vector}'::vector) ELSE 0 END * {topic_w} as topic_sim,
-                    CASE WHEN customer_embedding IS NOT NULL THEN 1 - (customer_embedding <=> '{query_vector}'::vector) ELSE 0 END * {customer_w} as customer_sim,
-                    CASE WHEN agent_embedding IS NOT NULL THEN 1 - (agent_embedding <=> '{query_vector}'::vector) ELSE 0 END * {agent_w} as agent_sim
+                    CASE WHEN full_embedding IS NOT NULL THEN 1 - (full_embedding <=> '%s'::vector) ELSE 0 END * %f as full_sim,
+                    CASE WHEN topic_embedding IS NOT NULL THEN 1 - (topic_embedding <=> '%s'::vector) ELSE 0 END * %f as topic_sim,
+                    CASE WHEN customer_embedding IS NOT NULL THEN 1 - (customer_embedding <=> '%s'::vector) ELSE 0 END * %f as customer_sim,
+                    CASE WHEN agent_embedding IS NOT NULL THEN 1 - (agent_embedding <=> '%s'::vector) ELSE 0 END * %f as agent_sim
                 FROM vector_store_multi_embeddings
                 WHERE full_embedding IS NOT NULL
                 OR topic_embedding IS NOT NULL
                 OR customer_embedding IS NOT NULL
                 OR agent_embedding IS NOT NULL
-        """
+        """ % (query_vector, full_w, query_vector, topic_w, query_vector, customer_w, query_vector, agent_w)
         
-        # 날짜 필터 추가
+        # 날짜 필터 추가 (자바 코드와 동일하게 구현)
         if start_timestamp is not None:
             sql += f" AND (metadata->>'startTime')::bigint >= {start_timestamp}"
         
@@ -278,7 +291,7 @@ def search_similar_chat_by_date(
         
         with conn.cursor() as cur:
             print(f"날짜 검색 쿼리 실행: 시작일={start_date}({start_timestamp}), 종료일={end_date}({end_timestamp})")
-            # 여기서는 limit만 매개변수로 전달
+            # 여기서는 limit를 파라미터로 전달
             cur.execute(sql, (limit,))
             rows = cur.fetchall()
             
@@ -305,7 +318,7 @@ def search_similar_chat_by_date(
                         "topic": get_text_value(metadata, "topic")
                     }
                     
-                    # 시간 필드 변환 없이 그대로 사용
+                    # 시간 필드 변환 없이 그대로 사용 (이미 KST로 저장되어 있음)
                     if "startTime" in metadata and metadata["startTime"] is not None:
                         result["startTime"] = metadata["startTime"]
                     
@@ -318,13 +331,15 @@ def search_similar_chat_by_date(
                     print(f"문제가 발생한 메타데이터: {metadata_json[:200]}...")
                     continue
         
-        # 임계값 필터링
+        # 임계값 필터링 (자바 코드와 동일하게 구현)
         filtered_results = [r for r in results if r["similarityScore"] >= threshold]
-        print(f"날짜 검색 - 임계값({threshold}) 이상 결과: {len(filtered_results)}개 / 전체 {len(results)}개")
         
         if len(filtered_results) > 0:
+            print(f"날짜 검색 - 임계값({threshold}) 이상 결과: {len(filtered_results)}개 / 전체 {len(results)}개")
             print(f"날짜 검색 - 가장 높은 유사도 점수: {filtered_results[0]['similarityScore']}")
             print(f"날짜 검색 - 상위 결과 챗ID: {filtered_results[0].get('chatId')}, 시작시간: {filtered_results[0].get('startTime')}")
+        else:
+            print(f"날짜 검색 - 임계값({threshold}) 이상의 결과가 없습니다")
         
         return filtered_results
     
@@ -336,11 +351,11 @@ def search_similar_chat_by_date(
         if 'conn' in locals():
             conn.close()
 
-# Gradio Blocks에 함수 등록
+# Gradio 웹 인터페이스 설정
 with gr.Blocks() as demo:
-    gr.Markdown("# Chat Analysis Search")
+    gr.Markdown("# 채팅 분석 검색")
     gr.Interface(fn=search_similar_chat, inputs=["text", "number"], outputs="json", api_name="search_similar_chat")
     gr.Interface(fn=search_similar_chat_by_date, inputs=["text", "text", "text", "number"], outputs="json", api_name="search_similar_chat_by_date")
 
 if __name__ == "__main__":
-    demo.launch(mcp_server=True) 
+    demo.launch(server_name="0.0.0.0", server_port=7860)