Update app.py

app.py

@@ -31,7 +31,8 @@ def get_embedding(text: str) -> List[float]:
     """텍스트를 임베딩 벡터로 변환합니다."""
     response = client.embeddings.create(
         input=text,
-        model="text-embedding-3-small"
+        model="text-embedding-3-small",
+        encoding_format="float"  # 명시적으로 float 형식 지정
     )
     return response.data[0].embedding
 
@@ -43,7 +44,9 @@ def get_text_value(node, field_name):
 
 def format_vector_for_pg(vector: List[float]) -> str:
     """벡터를 PostgreSQL 포맷으로 변환합니다."""
-    return f"[{','.join(str(x) for x in vector)}]"
+    # 정밀도 유지를 위해 str() 함수 대신 소수점 제한 없이 바로 join
+    vector_str = ','.join([f"{x}" for x in vector])
+    return f"[{vector_str}]"
 
 def search_similar_chat(query: str, max_results: int = 100) -> List[Dict]:
     """
@@ -68,106 +71,70 @@ 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"임베딩 생성 완료: 첫 5개 요소: {query_embedding[:5]}")
+        print(f"임베딩 생성 완료: 벡터 길이={len(query_embedding)}")
         
-        # Java 방식: 벡터를 문자열로 변환
+        # 벡터 포맷 변환
         query_vector = format_vector_for_pg(query_embedding)
         
         # DB 연결
         conn = get_db_conn()
         register_vector(conn)
         
-        # 개선된 SQL 쿼리 - 가중 평균 방식으로 계산하고 각 임베딩 유형별 점수 포함
+        # 자바 구현과 일치하도록 SQL 쿼리 수정
         sql = f"""
-            WITH embeddings AS (
+            WITH similarities AS (
                 SELECT 
                     id, 
                     metadata, 
                     content,
-                    -- 각 임베딩 유형별 유사도 계산 (NULL이 아닌 경우만)
-                    CASE WHEN full_embedding IS NOT NULL 
-                         THEN 1 - (full_embedding <=> '{query_vector}'::vector) 
-                         ELSE NULL END as full_sim,
-                    
-                    CASE WHEN topic_embedding IS NOT NULL 
-                         THEN 1 - (topic_embedding <=> '{query_vector}'::vector) 
-                         ELSE NULL END as topic_sim,
-                    
-                    CASE WHEN customer_embedding IS NOT NULL 
-                         THEN 1 - (customer_embedding <=> '{query_vector}'::vector) 
-                         ELSE NULL END as customer_sim,
-                    
-                    CASE WHEN agent_embedding IS NOT NULL 
-                         THEN 1 - (agent_embedding <=> '{query_vector}'::vector) 
-                         ELSE NULL END as agent_sim,
-                    
-                    -- 유효한 임베딩 카운트 (0으로 나누기 방지)
-                    (CASE WHEN full_embedding IS NOT NULL THEN 1 ELSE 0 END +
-                     CASE WHEN topic_embedding IS NOT NULL THEN 1 ELSE 0 END +
-                     CASE WHEN customer_embedding IS NOT NULL THEN 1 ELSE 0 END +
-                     CASE WHEN agent_embedding IS NOT NULL THEN 1 ELSE 0 END) as valid_count
+                    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
                 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)
-            ),
-            weighted_scores AS (
-                SELECT 
-                    id, 
-                    metadata, 
-                    content,
-                    full_sim,
-                    topic_sim,
-                    customer_sim,
-                    agent_sim,
-                    valid_count,
-                    
-                    -- 가중치를 적용한 총 유사도 점수 계산
-                    (COALESCE(full_sim, 0) * {full_w} +
-                     COALESCE(topic_sim, 0) * {topic_w} +
-                     COALESCE(customer_sim, 0) * {customer_w} +
-                     COALESCE(agent_sim, 0) * {agent_w}) as weighted_sum
-                FROM 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
             )
             SELECT 
                 id, 
                 metadata, 
                 content,
-                full_sim,
-                topic_sim,
-                customer_sim,
-                agent_sim,
-                weighted_sum as combined_similarity
-            FROM weighted_scores
-            WHERE weighted_sum >= {threshold}
+                (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
             ORDER BY combined_similarity DESC
             LIMIT {limit}
         """
         
         with conn.cursor() as cur:
-            print(f"쿼리 실행 - 개선된 방식, 가중치 설정={full_w}, {topic_w}, {customer_w}, {agent_w}, 결과 제한={limit}")
-            # Java 방식: 매개변수 없이 직접 쿼리 실행
+            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][7])}")
-                print(f"첫 번째 결과 세부 유사도 - full: {rows[0][3]}, topic: {rows[0][4]}, customer: {rows[0][5]}, agent: {rows[0][6]}")
+                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:
                 id_val = row[0]
                 metadata_json = row[1]
                 content = row[2]
-                full_similarity = None if row[3] is None else float(row[3])
-                topic_similarity = None if row[4] is None else float(row[4])
-                customer_similarity = None if row[5] is None else float(row[5])
-                agent_similarity = None if row[6] is None else float(row[6])
-                similarity_score = float(row[7])
+                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:
@@ -179,12 +146,7 @@ def search_similar_chat(query: str, max_results: int = 100) -> List[Dict]:
                         "content": content,
                         "chatId": get_text_value(metadata, "chatId"),
                         "topic": get_text_value(metadata, "topic"),
-                        "similarityDetails": {
-                            "full": full_similarity,
-                            "topic": topic_similarity,
-                            "customer": customer_similarity,
-                            "agent": agent_similarity
-                        }
+                        "rawSimilarities": raw_sims
                     }
                     
                     # 시간 필드 변환 없이 그대로 사용
@@ -199,15 +161,13 @@ def search_similar_chat(query: str, max_results: int = 100) -> List[Dict]:
                     print(f"메타데이터 파싱 오류: {e}")
                     print(f"문제가 발생한 메타데이터: {metadata_json[:200]}...")
                     continue
-        
-        print(f"임계값({threshold}) 이상 결과: {len(results)}개")
-        
-        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]['similarityDetails']}")
-        
-        return results
+            
+            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']}")
+            
+            return results
     
     except Exception as e:
         print(f"다중 임베딩 검색 중 오류 발생: {str(e)}")