Auto commit at 22-2025-08 23:59:11

lily_llm_api/app_v2.py

@@ -553,20 +553,131 @@ def generate_sync(prompt: str, image_data_list: Optional[List[bytes]], max_lengt
         # --- 2. 프롬프트 구성 ---
         print(f"🔍 [DEBUG] 프롬프트 구성 시작")
         
-        # 컨텍스트 통합 (대화 기록 포함) - 모델별 최적화
+        # 컨텍스트 통합 (대화 기록 + RAG 검색 결과 포함) - 모델별 최적화
         context_prompt = ""
         if use_context and session_id:
             try:
-                # 수정: 모델별 최적화된 컨텍스트 사용
+                # 1. 대화 기록 컨텍스트
                 context = context_manager.get_context_for_model(
                     current_profile.model_name, 
                     session_id
                 )
                 if context and len(context.strip()) > 0:
                     context_prompt = context + "\n\n"
-                    print(f"🔍 [DEBUG] 컨텍스트 포함됨 - 길이: {len(context_prompt)} (세션: {session_id})")
-                else:
+                    print(f"🔍 [DEBUG] 대화 컨텍스트 포함됨 - 길이: {len(context_prompt)} (세션: {session_id})")
+                
+                # 2. RAG 검색 결과 컨텍스트 (PDF 내용 포함)
+                try:
+                    # 🔄 간단하고 직접적인 RAG 컨텍스트 로드
+                    rag_context = ""
+                    
+                    # 🔄 간단한 파일 기반 RAG 컨텍스트 로드
+                    try:
+                        # vector_stores 디렉토리에서 최근 문서 내용 직접 읽기
+                        import os
+                        import json
+                        
+                        vector_store_dir = "vector_stores"
+                        if os.path.exists(vector_store_dir):
+                            user_dirs = [d for d in os.listdir(vector_store_dir) if os.path.isdir(os.path.join(vector_store_dir, d))]
+                            if user_dirs:
+                                user_dir = user_dirs[0]  # 첫 번째 사용자
+                                user_path = os.path.join(vector_store_dir, user_dir)
+                                
+                                if os.path.exists(user_path):
+                                    doc_dirs = [d for d in os.listdir(user_path) if os.path.isdir(os.path.join(user_path, d))]
+                                    if doc_dirs:
+                                        # 최근 문서 ID 사용
+                                        recent_doc_id = doc_dirs[-1]
+                                        print(f"🔍 [DEBUG] RAG 컨텍스트 검색: 사용자={user_dir}, 문서={recent_doc_id}")
+                                        
+                                        # 문서 내용 파일 직접 읽기 (pickle 파일 지원)
+                                        doc_path = os.path.join(user_path, recent_doc_id)
+                                        if os.path.exists(doc_path):
+                                            # 🔄 pickle 파일에서 내용 읽기 (우선)
+                                            pickle_file = os.path.join(doc_path, "simple_vector_store.pkl")
+                                            if os.path.exists(pickle_file):
+                                                try:
+                                                    import pickle
+                                                    with open(pickle_file, 'rb') as f:
+                                                        vector_store_data = pickle.load(f)
+                                                    
+                                                    # vector store에서 문서 내용 추출 (dict 구조)
+                                                    if isinstance(vector_store_data, dict) and 'documents' in vector_store_data:
+                                                        documents_data = vector_store_data['documents']
+                                                        if documents_data and len(documents_data) > 0:
+                                                            rag_context = "\n\n📄 업로드된 문서 내용:\n"
+                                                            for i, doc in enumerate(documents_data[:2]):  # 최대 2개 청크
+                                                                if hasattr(doc, 'page_content'):
+                                                                    content = doc.page_content.strip()
+                                                                    if content and len(content) > 30:
+                                                                        # 내용을 200자로 제한
+                                                                        truncated_content = content[:200] + "..." if len(content) > 200 else content
+                                                                        rag_context += f"--- 청크 {i+1} ---\n{truncated_content}\n\n"
+                                                            
+                                                            if len(rag_context) > 30:
+                                                                context_prompt += rag_context
+                                                                print(f"🔍 [DEBUG] RAG 컨텍스트 포함됨 - 길이: {len(rag_context)}")
+                                                                print(f"🔍 [DEBUG] RAG 컨텍스트 미리보기: {rag_context[:100]}...")
+                                                            else:
+                                                                print(f"⚠️ [DEBUG] RAG 컨텍스트가 너무 짧음: {len(rag_context)}")
+                                                        else:
+                                                            print(f"⚠️ [DEBUG] pickle 파일에 문서 데이터 없음")
+                                                    else:
+                                                        print(f"⚠️ [DEBUG] pickle 파일에 documents 키 없음: {list(vector_store_data.keys()) if isinstance(vector_store_data, dict) else 'Not a dict'}")
+                                                except Exception as e:
+                                                    print(f"⚠️ [DEBUG] pickle 파일 읽기 실패: {e}")
+                                                    
+                                                    # 🔄 fallback: documents.json 파일 시도
+                                                    docs_file = os.path.join(doc_path, "documents.json")
+                                                    if os.path.exists(docs_file):
+                                                        try:
+                                                            with open(docs_file, 'r', encoding='utf-8') as f:
+                                                                documents_data = json.load(f)
+                                                            
+                                                            if documents_data and len(documents_data) > 0:
+                                                                rag_context = "\n\n📄 업로드된 문서 내용:\n"
+                                                                for i, doc in enumerate(documents_data[:2]):  # 최대 2개 청크
+                                                                    if 'page_content' in doc:
+                                                                        content = doc['page_content'].strip()
+                                                                        if content and len(content) > 30:
+                                                                            # 내용을 200자로 제한
+                                                                            truncated_content = content[:200] + "..." if len(content) > 200 else content
+                                                                            rag_context += f"--- 청크 {i+1} ---\n{truncated_content}\n\n"
+                                                                
+                                                                if len(rag_context) > 30:
+                                                                    context_prompt += rag_context
+                                                                    print(f"🔍 [DEBUG] RAG 컨텍스트 포함됨 (JSON fallback) - 길이: {len(rag_context)}")
+                                                                    print(f"🔍 [DEBUG] RAG 컨텍스트 미리보기: {rag_context[:100]}...")
+                                                                else:
+                                                                    print(f"⚠️ [DEBUG] RAG 컨텍스트가 너무 짧음: {len(rag_context)}")
+                                                            else:
+                                                                print(f"⚠️ [DEBUG] documents.json 데이터 없음")
+                                                        except Exception as e:
+                                                            print(f"⚠️ [DEBUG] documents.json 읽기 실패: {e}")
+                                                    else:
+                                                        print(f"⚠️ [DEBUG] documents.json 파일 없음: {docs_file}")
+                                            else:
+                                                print(f"⚠️ [DEBUG] pickle 파일 없음: {pickle_file}")
+                                        else:
+                                            print(f"⚠️ [DEBUG] 문서 경로 없음: {doc_path}")
+                                    else:
+                                        print(f"⚠️ [DEBUG] 문서 디렉토리 없음: {user_path}")
+                                else:
+                                    print(f"⚠️ [DEBUG] 사용자 경로 없음: {user_path}")
+                            else:
+                                print(f"⚠️ [DEBUG] 사용자 디렉토리 없음: {vector_store_dir}")
+                        else:
+                            print(f"⚠️ [DEBUG] vector_stores 디렉토리 없음")
+                    except Exception as e:
+                        print(f"⚠️ [DEBUG] RAG 컨텍스트 파일 읽기 실패: {e}")
+                    
+                except Exception as e:
+                    print(f"⚠️ [DEBUG] RAG 컨텍스트 처리 실패: {e}")
+                
+                if not context_prompt:
                     print(f"🔍 [DEBUG] 컨텍스트 없음 또는 비어있음 (세션: {session_id})")
+                    
             except Exception as e:
                 print(f"⚠️ [DEBUG] 컨텍스트 로드 실패: {e} (세션: {session_id})")
                 context_prompt = ""
@@ -1223,6 +1334,8 @@ def generate_sync(prompt: str, image_data_list: Optional[List[bytes]], max_lengt
                 response = full_text.replace(formatted_prompt, "").strip() if formatted_prompt else full_text
                 print(f"🔍 [DEBUG] 기본 응답 추출 사용")
             
+
+            
             print(f"🔍 [DEBUG] 추출된 응답 길이: {len(response)}")
             print(f"🔍 [DEBUG] 최종 응답: {response}")
             
@@ -1641,18 +1754,65 @@ async def upload_document(
                 
                 logger.info(f"🤖 문서 업로드 후 AI 응답 생성 시작...")
                 
-                rag_result = rag_processor.generate_rag_response(
-                    user_id, document_id, summary_query, llm_model=model
-                )
-                
-                if rag_result["success"]:
-                    logger.info(f"✅ 자동 AI 응답 생성 완료: {len(rag_result['response'])} 문자")
-                    result["auto_response"] = rag_result["response"]
-                else:
-                    logger.warning(f"⚠️ 자동 AI 응답 생성 실패: {rag_result.get('error', 'Unknown error')}")
+                # 🔄 RAG 시스템을 사용하여 문서 내용 기반 응답 생성
+                try:
+                    # RAG 검색을 통해 문서 내용을 포함한 프롬프트 생성
+                    summary_query = f"업로드된 문서 '{file.filename}'의 주요 내용을 요약해주세요."
+                    
+                    # RAG 응답 생성 (문서 내용 포함)
+                    rag_result = rag_processor.generate_rag_response(
+                        user_id, document_id, summary_query, llm_model=model
+                    )
+                    
+                    if rag_result["success"]:
+                        logger.info(f"✅ 자동 AI 응답 생성 완료: {len(rag_result['response'])} 문자")
+                        result["auto_response"] = rag_result["response"]
+                    else:
+                        logger.warning(f"⚠️ 자동 AI 응답 생성 실패: {rag_result.get('error', 'Unknown error')}")
+                        # 🔄 RAG 실패 시 generate_sync 사용 (fallback)
+                        if model and hasattr(model, 'generate'):
+                            try:
+                                from .app_v2 import generate_sync
+                                
+                                # 문서 내용을 포함한 프롬프트 생성
+                                context_prompt = f"""
+다음 문서의 내용을 바탕으로 요약해주세요:
+
+문서명: {file.filename}
+문서 ID: {document_id}
+
+문서 내용:
+{result.get('chunks', [])}
+
+위 문서의 주요 내용을 요약해주세요.
+"""
+                                
+                                response = generate_sync(
+                                    prompt=context_prompt,
+                                    image_data_list=None,
+                                    session_id=None
+                                )
+                                
+                                if response and "response" in response:
+                                    result["auto_response"] = response["response"]
+                                    logger.info(f"✅ fallback AI 응답 생성 완료: {len(response['response'])} 문자")
+                                else:
+                                    result["auto_response"] = "문서 요약을 생성할 수 없습니다."
+                                    logger.warning(f"⚠️ generate_sync 응답 형식 오류")
+                                    
+                            except Exception as e:
+                                logger.error(f"❌ fallback generate_sync 호출 실패: {e}")
+                                result["auto_response"] = "문서 요약 생성 중 오류가 발생했습니다."
+                        else:
+                            result["auto_response"] = "문서 요약을 생성할 수 없습니다."
+                    
+                except Exception as e:
+                    logger.error(f"❌ RAG 응답 생성 중 오류: {e}")
+                    result["auto_response"] = "문서 요약 생성 중 오류가 발생했습니다."
                     
             except Exception as e:
                 logger.error(f"❌ 자동 AI 응답 생성 중 오류: {e}")
+                result["auto_response"] = "문서 요약 생성 중 오류가 발생했습니다."
         
         return DocumentUploadResponse(
             success=result["success"],

lily_llm_api/models/kanana_1_5_v_3b_instruct.py

@@ -243,6 +243,7 @@ class Kanana15V3bInstructProfile:
             "<|im_start|>assistant\n",
             "<|im_end|>",
             "<|im_in_end|>",            
+            "<|-im_end|>",  # 🔄 잘못된 토큰 추가
             "<image>",
             "user\n",
             "assistant\n"

lily_llm_api/models/polyglot_ko_1_3b_chat.py

@@ -184,6 +184,7 @@ class PolyglotKo13bChatProfile:
             "user:",
             "<|im_start|>user",
             "<|im_end|>",
+            "<|-im_end|>",  # 🔄 잘못된 토큰 추가
             "<|im_start|>assistant",
             "<|im_start|>system"
         ]

lily_llm_api/models/polyglot_ko_5_8b_chat.py

@@ -139,6 +139,17 @@ class PolyglotKo58bChatProfile:
             
             logger.info(f"추출된 응답: {response}")
             
+            # 🔄 잘못된 토큰 제거
+            if response:
+                # <|-im_end|> 같은 잘못된 토큰 제거
+                cleaned_response = response.replace('<|-im_end|>', '').replace('<|im_end|>', '')
+                # 앞뒤 공백 제거
+                cleaned_response = cleaned_response.strip()
+                
+                if cleaned_response != response:
+                    logger.info(f"🔧 잘못된 토큰 제거됨: {len(response)} → {len(cleaned_response)}")
+                    response = cleaned_response
+            
             # 응답 품질 검증 및 개선
             if not self._validate_response_quality(response):
                 logger.warning(f"⚠️ 응답 품질이 낮습니다. 품질 개선 제안을 추가합니다.")

lily_llm_core/document_processor.py

@@ -112,8 +112,10 @@ class DocumentProcessor:
             extension = path_obj.suffix.lower()
             
             if extension:
-                logger.info(f"📄 파일 확장자 인식: {extension}")
-                return extension
+                # 🔄 확장자 앞의 점(.) 제거하여 반환
+                file_type = extension[1:] if extension.startswith('.') else extension
+                logger.info(f"📄 파일 확장자 인식: {extension} -> {file_type}")
+                return file_type
             else:
                 logger.warning(f"⚠️ 파일 확장자를 찾을 수 없습니다: {file_path}")
                 return None

lily_llm_core/rag_processor.py

@@ -329,6 +329,26 @@ class RAGProcessor:
             if hasattr(llm_model, 'generate'):
                 # 실제 LLM 모델 사용
                 response = llm_model.generate(prompt)
+                
+                # 🔄 tensor를 문자열로 변환
+                if hasattr(response, 'tolist'):
+                    # tensor인 경우 문자열로 변환
+                    import torch
+                    if isinstance(response, torch.Tensor):
+                        # 토큰 ID를 텍스트로 디코딩
+                        if hasattr(llm_model, 'tokenizer'):
+                            try:
+                                response = llm_model.tokenizer.decode(response[0], skip_special_tokens=True)
+                            except:
+                                response = str(response.tolist())
+                        else:
+                            response = str(response.tolist())
+                    else:
+                        response = str(response)
+                elif not isinstance(response, str):
+                    # 문자열이 아닌 경우 문자열로 변환
+                    response = str(response)
+                
             else:
                 # 모의 응답 (테스트용)
                 response = f"RAG 기반 응답: {prompt[:100]}..."

requirements.txt

@@ -4,10 +4,8 @@
 numpy==1.26.4
 torch==2.3.1
 torchvision==0.18.1
-# transformers==4.29.2
-# tokenizers==0.13.3
-transformers
-tokenizers
+transformers==4.55.2
+tokenizers==0.21.4
 peft==0.10.0
 accelerate==0.30.1
 bitsandbytes
@@ -17,6 +15,10 @@ safetensors
 easyocr
 opencv-python-headless
 
+# DOC
+langchain-community 
+langchain
+
 # Web Framework & Parsers
 fastapi
 uvicorn[standard]