Add Gemini API integration with REST API support, improve error handling, and add markdown bold formatting for messages

app/database.py

@@ -155,4 +155,63 @@ class ParentChunk(db.Model):
             'updated_at': self.updated_at.isoformat() if self.updated_at else None
         }
 
+# 시스템 설정 모델 (API 키 등)
+class SystemConfig(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    key = db.Column(db.String(100), unique=True, nullable=False)  # 설정 키 (예: 'gemini_api_key')
+    value = db.Column(db.Text, nullable=True)  # 설정 값 (암호화된 API 키)
+    description = db.Column(db.String(255), nullable=True)  # 설정 설명
+    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'key': self.key,
+            'value': self.value,  # 실제 값 반환 (보안을 위해 마스킹 필요할 수 있음)
+            'description': self.description,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None
+        }
+    
+    @staticmethod
+    def get_config(key, default=None):
+        """설정 값 가져오기"""
+        try:
+            config = SystemConfig.query.filter_by(key=key).first()
+            return config.value if config else default
+        except Exception as e:
+            # 테이블이 없거나 오류 발생 시 기본값 반환
+            print(f"[SystemConfig.get_config] 오류: {e}")
+            return default
+    
+    @staticmethod
+    def set_config(key, value, description=None):
+        """설정 값 저장/업데이트"""
+        try:
+            # 테이블이 없으면 생성 시도
+            from sqlalchemy import inspect
+            inspector = inspect(db.engine)
+            if 'system_config' not in inspector.get_table_names():
+                print("[SystemConfig.set_config] SystemConfig 테이블 생성 중...")
+                db.create_all()
+            
+            config = SystemConfig.query.filter_by(key=key).first()
+            if config:
+                config.value = value
+                if description:
+                    config.description = description
+                config.updated_at = datetime.utcnow()
+            else:
+                config = SystemConfig(key=key, value=value, description=description)
+                db.session.add(config)
+            db.session.commit()
+            return config
+        except Exception as e:
+            db.session.rollback()
+            print(f"[SystemConfig.set_config] 오류: {e}")
+            import traceback
+            traceback.print_exc()
+            raise
+
 

app/gemini_client.py

@@ -0,0 +1,662 @@
+"""
+Google Gemini API 클라이언트
+"""
+
+import os
+import time
+import requests
+import google.generativeai as genai
+from google.api_core import retry
+from typing import Optional, List, Dict
+import functools
+import json
+
+# Gemini API 키 (환경 변수 또는 데이터베이스에서 가져오기)
+def get_gemini_api_key():
+    """Gemini API 키 가져오기 (환경 변수 우선, 없으면 DB에서)"""
+    # 환경 변수에서 먼저 확인
+    api_key = os.getenv('GEMINI_API_KEY', '').strip()
+    if api_key:
+        print(f"[Gemini] 환경 변수에서 API 키 가져옴 (길이: {len(api_key)}자)")
+        return api_key
+    
+    # DB에서 가져오기 (순환 참조 방지를 위해 여기서 임포트)
+    try:
+        from app.database import SystemConfig
+        api_key = SystemConfig.get_config('gemini_api_key', '').strip()
+        if api_key:
+            print(f"[Gemini] DB에서 API 키 가져옴 (길이: {len(api_key)}자)")
+        else:
+            print(f"[Gemini] DB에 API 키가 없거나 비어있음")
+        return api_key
+    except Exception as e:
+        print(f"[Gemini] DB에서 API 키 조회 실패: {e}")
+        return ''
+
+GEMINI_API_KEY = get_gemini_api_key()
+
+# 사용 가능한 Gemini 모델 목록 (최신 버전 우선)
+AVAILABLE_GEMINI_MODELS = [
+    'gemini-2.0-flash-exp',
+    'gemini-1.5-pro',
+    'gemini-1.5-flash',
+    'gemini-1.5-pro-latest',
+    'gemini-1.5-flash-latest',
+    'gemini-pro',
+    'gemini-pro-vision'
+]
+
+class GeminiClient:
+    """Google Gemini API 클라이언트 클래스"""
+    
+    def __init__(self, api_key: Optional[str] = None):
+        """Gemini 클라이언트 초기화"""
+        if api_key:
+            self.api_key = api_key
+        else:
+            # 최신 API 키 가져오기 (DB에서 동적으로)
+            self.api_key = get_gemini_api_key()
+        
+        if not self.api_key:
+            print("[Gemini] 경고: GEMINI_API_KEY가 설정되지 않았습니다. 환경 변수나 관리 페이지에서 설정하세요.")
+            return
+        
+        try:
+            # API 키 설정 및 타임아웃 설정 (기본 60초 -> 300초(5분)로 증가)
+            # 전역 타임아웃 설정
+            self.request_timeout = 300  # 5분(300초) 타임아웃
+            
+            # 재시도 정책 설정
+            self.retry_policy = retry.Retry(
+                initial=10.0,      # 초기 대기 시간 (10초)
+                maximum=60.0,      # 최대 대기 시간 (60초)
+                multiplier=2.0,    # 대기 시간 배수
+                deadline=600.0     # 전체 재시도 기간 (600초 = 10분)
+            )
+            
+            # REST API 사용을 위한 설정
+            # 환경 변수를 통해 HTTP 클라이언트 타임아웃 설정
+            os.environ.setdefault('HTTPX_TIMEOUT', str(self.request_timeout))
+            os.environ.setdefault('GOOGLE_API_TIMEOUT', str(self.request_timeout))
+            
+            # REST API 엔드포인트 설정 (v1 사용)
+            self.rest_base_url = 'https://generativelanguage.googleapis.com/v1'
+            self.use_rest_api = True  # REST API 강제 사용
+            
+            # API 키 설정 (fallback용, REST API가 실패할 경우)
+            try:
+                genai.configure(api_key=self.api_key)
+                print(f"[Gemini] API 키 설정 완료 (REST API 모드, 타임아웃: {self.request_timeout}초)")
+            except Exception as e:
+                print(f"[Gemini] API 키 설정 오류: {e}")
+            
+            # API 키가 실제로 설정되었는지 확인
+            try:
+                # genai 모듈의 전역 API 키 확인
+                configured_key = getattr(genai, '_api_key', None) or getattr(genai, 'api_key', None)
+                if configured_key:
+                    print(f"[Gemini] 전역 API 키 확인: 설정됨 (길이: {len(str(configured_key))}자)")
+                else:
+                    print(f"[Gemini] 경고: 전역 API 키가 확인되지 않습니다. API 호출이 실패할 수 있습니다.")
+            except Exception as e:
+                print(f"[Gemini] API 키 확인 오류: {e}")
+            
+            print(f"[Gemini] 재시도 정책 적용됨")
+        except Exception as e:
+            print(f"[Gemini] API 키 설정 오류: {e}")
+    
+    def reload_api_key(self):
+        """API 키를 다시 로드 (DB에서 최신 값 가져오기)"""
+        self.api_key = get_gemini_api_key()
+        if self.api_key:
+            try:
+                genai.configure(api_key=self.api_key)
+                print(f"[Gemini] API 키 재로드 완료")
+                return True
+            except Exception as e:
+                print(f"[Gemini] API 키 재로드 오류: {e}")
+                return False
+        return False
+    
+    def is_configured(self) -> bool:
+        """Gemini API가 제대로 설정되었는지 확인"""
+        return bool(self.api_key)
+    
+    def get_available_models(self) -> List[str]:
+        """사용 가능한 Gemini 모델 목록 반환"""
+        if not self.is_configured():
+            return []
+        
+        try:
+            # 실제 사용 가능한 모델 확인
+            available_models = []
+            for model_name in AVAILABLE_GEMINI_MODELS:
+                try:
+                    model = genai.GenerativeModel(model_name)
+                    # 모델 접근 가능 여부 확인
+                    available_models.append(model_name)
+                except Exception as e:
+                    # 모델을 찾을 수 없으면 건너뛰기
+                    continue
+            
+            # 모델을 찾지 못한 경우 기본 모델 시도
+            if not available_models:
+                try:
+                    # 기본적으로 gemini-1.5-flash 시도
+                    model = genai.GenerativeModel('gemini-1.5-flash')
+                    available_models.append('gemini-1.5-flash')
+                except:
+                    pass
+            
+            print(f"[Gemini] 사용 가능한 모델: {available_models}")
+            return available_models
+        except Exception as e:
+            print(f"[Gemini] 모델 목록 조회 오류: {e}")
+            return []
+    
+    def generate_response(self, prompt: str, model_name: str = 'gemini-1.5-flash', **kwargs) -> Dict:
+        """
+        Gemini API를 사용하여 응답 생성
+        
+        Args:
+            prompt: 입력 프롬프트
+            model_name: 사용할 모델 이름
+            **kwargs: 추가 파라미터 (temperature, max_tokens 등)
+        
+        Returns:
+            Dict: {'response': str, 'error': str or None}
+        """
+        if not self.is_configured():
+            return {
+                'response': None,
+                'error': 'Gemini API 키가 설정되지 않았습니다. GEMINI_API_KEY 환경 변수를 설정하세요.'
+            }
+        
+        try:
+            # API 키를 항상 최신으로 다시 가져와서 설정 (DB에서 변경되었을 수 있음)
+            current_api_key = get_gemini_api_key()
+            if not current_api_key:
+                return {
+                    'response': None,
+                    'error': 'Gemini API 키가 설정되지 않았습니다. 관리 페이지에서 API 키를 설정하세요.'
+                }
+            
+            # API 키가 변경되었거나 없는 경우 재설정
+            if not self.api_key or self.api_key != current_api_key:
+                self.api_key = current_api_key
+                genai.configure(api_key=self.api_key)
+                print(f"[Gemini] API 키 재설정 완료 (길이: {len(self.api_key)}자)")
+            else:
+                # API 키가 이미 설정되어 있어도 매번 재설정하여 확실히 함
+                genai.configure(api_key=self.api_key)
+            
+            # 모델 생성
+            model = genai.GenerativeModel(model_name)
+            print(f"[Gemini] 모델 생성 완료: {model_name}")
+            
+            # 생성 설정
+            generation_config = {
+                'temperature': kwargs.get('temperature', 0.7),
+                'top_p': kwargs.get('top_p', 0.95),
+                'top_k': kwargs.get('top_k', 40),
+                'max_output_tokens': kwargs.get('max_output_tokens', 8192),
+            }
+            
+            # 응답 생성 (타임아웃 설정)
+            timeout_seconds = getattr(self, 'request_timeout', 300)  # 5분 타임아웃
+            print(f"[Gemini] 모델 {model_name}로 응답 생성 중... (타임아웃: {timeout_seconds}초)")
+            print(f"[Gemini] API 키 확인: 설정됨 (길이: {len(self.api_key)}자)")
+            print(f"[Gemini] 프롬프트 길이: {len(prompt)}자")
+            
+            # 타임아웃을 위한 시작 시간 기록
+            start_time = time.time()
+            
+            # google-generativeai는 retry 파라미터를 지원하지 않으므로
+            # 재시도 정책을 수동으로 구현하여 적용
+            retry_policy = getattr(self, 'retry_policy', None)
+            print(f"[Gemini] API 호출 시작 (타임아웃: {timeout_seconds}초, 재시도 정책 적용)")
+            
+            # 재시도 로직 구현 (재시도 정책 객체의 설정 사용)
+            # retry.Retry 객체를 생성했지만, 실제로는 그 설정값들을 직접 사용
+            initial_wait = 10.0      # 초기 대기 시간
+            max_wait = 60.0          # 최대 대기 시간
+            multiplier = 2.0         # 대기 시간 배수
+            deadline = 600.0         # 전체 재시도 기간 (10분)
+            
+            wait_time = initial_wait
+            deadline_time = time.time() + deadline
+            retry_count = 0
+            last_error = None
+            
+            while True:
+                try:
+                    # API 호출 전 API 키 재확인 및 재설정
+                    current_key = get_gemini_api_key()
+                    if not current_key:
+                        raise Exception("API 키가 설정되지 않았습니다. 관리 페이지에서 API 키를 설정하세요.")
+                    
+                    # API 키가 변경되었거나 설정되지 않은 경우 재설정
+                    if not self.api_key or self.api_key != current_key:
+                        self.api_key = current_key.strip() if current_key else None  # 공백 제거
+                        print(f"[Gemini] API 키 재설정 완료 (길이: {len(self.api_key) if self.api_key else 0}자)")
+                    
+                    # API 키 유효성 검사
+                    if not self.api_key or not self.api_key.strip():
+                        raise Exception("API 키가 비어있습니다. 관리 페이지에서 API 키를 설정하세요.")
+                    
+                    # API 키 앞뒤 공백 제거
+                    api_key_clean = self.api_key.strip()
+                    if not api_key_clean:
+                        raise Exception("API 키가 유효하지 않습니다 (공백만 포함).")
+                    
+                    # API 키 형식 확인 (Google API 키는 보통 AIza로 시작)
+                    if not api_key_clean.startswith('AIza'):
+                        print(f"[Gemini] 경고: API 키가 일반적인 Google API 키 형식이 아닙니다 (AIza로 시작하지 않음)")
+                    
+                    # API 키 길이 확인 (일반적으로 39자 이상)
+                    if len(api_key_clean) < 20:
+                        raise Exception(f"API 키 길이가 너무 짧습니다 ({len(api_key_clean)}자). 올바른 API 키인지 확인하세요.")
+                    
+                    print(f"[Gemini] API 키 검증 완료 (길이: {len(api_key_clean)}자, 시작: {api_key_clean[:10]}..., 끝: ...{api_key_clean[-5:]})")
+                    
+                    # REST API를 직접 사용하여 호출
+                    use_rest = getattr(self, 'use_rest_api', True)
+                    if use_rest:
+                        print(f"[Gemini] REST API 직접 호출 모드")
+                        
+                        # API 버전 및 모델 이름 정규화
+                        # 모델 이름에서 'gemini:' 접두사 제거 및 정규화
+                        model_name_clean = model_name.strip()
+                        if ':' in model_name_clean:
+                            # "gemini:gemini-1.5-flash" 형식인 경우
+                            model_name_clean = model_name_clean.split(':', 1)[1].strip()
+                        elif model_name_clean.startswith('gemini-'):
+                            # "gemini-1.5-flash" 형식인 경우 그대로 사용
+                            pass
+                        
+                        # REST API 베이스 URL (v1 사용)
+                        rest_base_url = 'https://generativelanguage.googleapis.com/v1'
+                        url = f"{rest_base_url}/models/{model_name_clean}:generateContent"
+                        
+                        print(f"[Gemini] - API 버전: v1")
+                        print(f"[Gemini] - 원본 모델 이름: {model_name}")
+                        print(f"[Gemini] - 정규화된 모델 이름: {model_name_clean}")
+                        print(f"[Gemini] - 전체 URL: {url}")
+                        
+                        # REST API 요청 본문 구성
+                        request_body = {
+                            "contents": [{
+                                "parts": [{
+                                    "text": prompt
+                                }]
+                            }],
+                            "generationConfig": generation_config
+                        }
+                        
+                        # REST API 헤더 (API 키를 헤더로 전달 시도)
+                        headers = {
+                            "Content-Type": "application/json",
+                            "x-goog-api-key": api_key_clean
+                        }
+                        
+                        print(f"[Gemini] REST API 호출 전송 중...")
+                        print(f"[Gemini] - URL: {url}")
+                        print(f"[Gemini] - 모델: {model_name}")
+                        print(f"[Gemini] - API 키: 설정됨 (길이: {len(api_key_clean)}자)")
+                        print(f"[Gemini] - API 키 시작: {api_key_clean[:15]}...")
+                        print(f"[Gemini] - API 키 끝: ...{api_key_clean[-10:]}")
+                        print(f"[Gemini] - 프롬프트 길이: {len(prompt)}자")
+                        
+                        # REST API 호출 (API 키를 헤더와 params 양쪽으로 전달 시도)
+                        # Google Gemini API는 헤더 또는 params 중 하나만 필요하지만, 양쪽 모두 시도
+                        api_params = {"key": api_key_clean}
+                        print(f"[Gemini] - API 키 전��� 방식: 헤더 (x-goog-api-key) 및 파라미터 (key)")
+                        
+                        rest_response = requests.post(
+                            url,
+                            headers=headers,
+                            json=request_body,
+                            params=api_params,
+                            timeout=timeout_seconds
+                        )
+                        
+                        # 요청 URL에서 API 키 부분만 제거하여 로깅 (보안)
+                        request_url = rest_response.request.url
+                        if 'key=' in request_url:
+                            # API 키 부분을 마스킹
+                            from urllib.parse import urlparse, parse_qs, urlencode, urlunparse
+                            parsed = urlparse(request_url)
+                            params = parse_qs(parsed.query)
+                            if 'key' in params:
+                                masked_params = params.copy()
+                                masked_key = masked_params['key'][0][:10] + '...' + masked_params['key'][0][-5:]
+                                masked_params['key'] = [masked_key]
+                                masked_query = urlencode(masked_params, doseq=True)
+                                masked_url = urlunparse((parsed.scheme, parsed.netloc, parsed.path, parsed.params, masked_query, parsed.fragment))
+                                print(f"[Gemini] - 요청 URL (마스킹됨): {masked_url[:150]}...")
+                        else:
+                            print(f"[Gemini] - 요청 URL: {request_url[:150]}...")
+                        
+                        print(f"[Gemini] REST API 응답 상태 코드: {rest_response.status_code}")
+                        
+                        # 응답 본문 확인 (상태 코드가 200이어도 에러가 있을 수 있음)
+                        response_has_error = False
+                        try:
+                            response_data_check = rest_response.json()
+                            # 응답에 error 필드가 있는지 확인
+                            if 'error' in response_data_check:
+                                response_has_error = True
+                                error_info = response_data_check['error']
+                                error_code = error_info.get('code', rest_response.status_code)
+                                error_message = error_info.get('message', '알 수 없는 오류')
+                                print(f"[Gemini] 응답 본문에 에러 감지: code={error_code}, message={error_message}")
+                                
+                                # 에러 코드에 따라 처리
+                                if error_code == 404:
+                                    # 404 오류인 경우 v1beta로 재시도
+                                    print(f"[Gemini] v1에서 모델을 찾을 수 없음, v1beta로 재시도...")
+                                    rest_base_url_v1beta = 'https://generativelanguage.googleapis.com/v1beta'
+                                    url_v1beta = f"{rest_base_url_v1beta}/models/{model_name_clean}:generateContent"
+                                    
+                                    rest_response = requests.post(
+                                        url_v1beta,
+                                        headers=headers,
+                                        json=request_body,
+                                        params=api_params,
+                                        timeout=timeout_seconds
+                                    )
+                                    
+                                    print(f"[Gemini] v1beta REST API 응답 상태 코드: {rest_response.status_code}")
+                                    
+                                    # v1beta 응답도 확인
+                                    if rest_response.status_code == 200:
+                                        response_data_check_v1beta = rest_response.json()
+                                        if 'error' in response_data_check_v1beta:
+                                            # v1beta에서도 에러 발생
+                                            error_info_v1beta = response_data_check_v1beta['error']
+                                            error_code_v1beta = error_info_v1beta.get('code', 404)
+                                            error_message_v1beta = error_info_v1beta.get('message', '알 수 없는 오류')
+                                            
+                                            # 모델 목록 조회 시도
+                                            available_models_str = "확인 불가"
+                                            try:
+                                                list_models_url_v1 = f"{rest_base_url}/models"
+                                                list_response = requests.get(
+                                                    list_models_url_v1,
+                                                    headers={"x-goog-api-key": api_key_clean},
+                                                    params={"key": api_key_clean},
+                                                    timeout=10
+                                                )
+                                                if list_response.status_code == 200:
+                                                    models_data = list_response.json()
+                                                    available_models = []
+                                                    for m in models_data.get('models', []):
+                                                        model_name_full = m.get('name', '')
+                                                        if '/' in model_name_full:
+                                                            model_name_short = model_name_full.split('/')[-1]
+                                                        else:
+                                                            model_name_short = model_name_full
+                                                        # generateContent를 지원하는 모델만 필터링
+                                                        supported_methods = m.get('supportedGenerationMethods', [])
+                                                        if 'generateContent' in supported_methods:
+                                                            available_models.append(model_name_short)
+                                                    available_models_str = ', '.join(available_models[:10]) if available_models else '없음'
+                                                    print(f"[Gemini] 사용 가능한 모델 목록 (v1): {available_models[:10]}")
+                                            except Exception as list_error:
+                                                print(f"[Gemini] 모델 목록 조회 실패: {list_error}")
+                                            
+                                            error_text_v1beta = json.dumps(error_info_v1beta)
+                                            raise Exception(f"REST API 오류 {error_code_v1beta}: {error_text_v1beta}\n사용 가능한 모델: {available_models_str}")
+                                        else:
+                                            # v1beta에서 성공
+                                            response_has_error = False
+                                            print(f"[Gemini] v1beta에서 정상 응답 받음")
+                                    elif rest_response.status_code != 200:
+                                        error_text_v1beta = rest_response.text[:1000] if rest_response.text else '상세 정보 없음'
+                                        raise Exception(f"REST API 오류 {rest_response.status_code}: {error_text_v1beta}")
+                                else:
+                                    # 404가 아닌 다른 에러
+                                    error_text = json.dumps(error_info)
+                                    raise Exception(f"REST API 오류 {error_code}: {error_text}")
+                        except ValueError:
+                            # JSON 파싱 실패
+                            pass
+                        
+                        # 이미 에러가 처리되지 않은 경우에만 추가 에러 처리
+                        # (response_has_error가 True면 이미 위에서 처리되었거나 Exception이 발생했을 것)
+                        if rest_response.status_code != 200 and not response_has_error:
+                            error_text = rest_response.text[:1000] if rest_response.text else '상세 정보 없음'
+                            
+                            # API 키 오류인 경우 더 상세한 안내 제공
+                            if rest_response.status_code == 400 and ('API key' in error_text or 'API_KEY' in error_text):
+                                print(f"[Gemini] ❌ API 키 오류 감지")
+                                print(f"[Gemini] 현재 API 키 정보:")
+                                print(f"[Gemini] - 길이: {len(api_key_clean)}자")
+                                print(f"[Gemini] - 시작: {api_key_clean[:15]}...")
+                                print(f"[Gemini] - 끝: ...{api_key_clean[-10:]}")
+                                print(f"[Gemini] - 형식 확인: {'AIza로 시작' if api_key_clean.startswith('AIza') else 'AIza로 시작하지 않음 (비정상)'}")
+                                raise Exception(f"""REST API 오류 400: API 키가 유효하지 않습니다.
+
+확인 사항:
+1. 관리 페이지에서 API 키가 올바르게 설정되었는지 확인하세요.
+2. Google AI Studio (https://aistudio.google.com/app/apikey)에서 API 키가 활성화되어 있는지 확인하세요.
+3. API 키 형식이 올바른지 확인하세요 (일반적으로 'AIza'로 시작).
+4. API 키에 불필요한 공백이나 줄바꿈이 포함되지 않았는지 확인하세요.
+
+오류 상세: {error_text[:300]}""")
+                            
+                            raise Exception(f"REST API 오류 {rest_response.status_code}: {error_text}")
+                        
+                        # 에러가 있었지만 처리되지 않은 경우 (정상 응답이 아님)
+                        if response_has_error:
+                            # 이미 위에서 Exception이 발생했어야 하지만, 혹시 모르니 확인
+                            error_text = rest_response.text[:1000] if rest_response.text else '상세 정보 없음'
+                            raise Exception(f"REST API 오류: 응답에 에러가 포함되어 있습니다. {error_text}")
+                        
+                        # REST API 응답 파싱
+                        response_data = rest_response.json()
+                        
+                        # 응답에서 텍스트 추출
+                        if 'candidates' in response_data and len(response_data['candidates']) > 0:
+                            candidate = response_data['candidates'][0]
+                            if 'content' in candidate and 'parts' in candidate['content']:
+                                parts = candidate['content']['parts']
+                                if len(parts) > 0 and 'text' in parts[0]:
+                                    response_text = parts[0]['text']
+                                    print(f"[Gemini] REST API 응답 수신 성공 (길이: {len(response_text)}자)")
+                                    
+                                    # genai 라이브러리 형식으로 변환 (호환성을 위해)
+                                    class MockResponse:
+                                        def __init__(self, text):
+                                            self.text = text
+                                    
+                                    response = MockResponse(response_text)
+                                    break
+                                else:
+                                    raise Exception("REST API 응답에 텍스트가 없습니다.")
+                            else:
+                                raise Exception("REST API 응답 형식이 올바르지 않습니다.")
+                        else:
+                            raise Exception("REST API 응답에 candidates가 없습니다.")
+                    else:
+                        # 기존 genai 라이브러리 사용 (fallback)
+                        genai.configure(api_key=self.api_key)
+                        print(f"[Gemini] genai 라이브러리 사용 (fallback)")
+                        response = model.generate_content(
+                            prompt,
+                            generation_config=generation_config
+                        )
+                        print(f"[Gemini] Gemini API 응답 수신 성공")
+                        break
+                    # 성공 시 루프 종료
+                    if retry_count > 0:
+                        print(f"[Gemini] 재시도 성공 (총 {retry_count}회 재시도)")
+                    break
+                except Exception as e:
+                    last_error = e
+                    error_str = str(e).lower()
+                    
+                    # 재시도 가능한 오류인지 확인 (타임아웃, 네트워크 오류 등)
+                    retryable_errors = ['timeout', '503', '502', '504', 'connection', 'network', 'illegal metadata']
+                    is_retryable = any(err in error_str for err in retryable_errors)
+                    
+                    # deadline 확인
+                    if time.time() >= deadline_time:
+                        print(f"[Gemini] 재시도 deadline 초과 ({deadline}초), 마지막 오류 반환")
+                        raise
+                    
+                    if is_retryable:
+                        retry_count += 1
+                        print(f"[Gemini] 재시도 {retry_count} - {wait_time:.1f}초 후 재시도 (오류: {str(e)[:100]})")
+                        time.sleep(wait_time)
+                        wait_time = min(wait_time * multiplier, max_wait)  # 배수로 증가, 최대값 제한
+                    else:
+                        # 재시도 불가능한 오류
+                        print(f"[Gemini] 재시도 불가능한 오류: {str(e)[:100]}")
+                        raise
+            
+            # 응답 시간 확인
+            elapsed_time = time.time() - start_time
+            print(f"[Gemini] 응답 수신 완료 (경과 시간: {elapsed_time:.2f}초)")
+            
+            # 응답 텍스트 추출
+            response_text = response.text if hasattr(response, 'text') else str(response)
+            
+            print(f"[Gemini] 응답 생성 완료: {len(response_text)}자")
+            return {
+                'response': response_text,
+                'error': None
+            }
+            
+        except Exception as e:
+            error_msg = f'Gemini API 오류: {str(e)}'
+            print(f"[Gemini] {error_msg}")
+            return {
+                'response': None,
+                'error': error_msg
+            }
+    
+    def generate_chat_response(self, messages: List[Dict], model_name: str = 'gemini-1.5-flash', **kwargs) -> Dict:
+        """
+        Gemini API를 사용하여 채팅 응답 생성
+        
+        Args:
+            messages: 메시지 리스트 [{'role': 'user', 'content': '...'}, ...]
+            model_name: 사용할 모델 이름
+            **kwargs: 추가 파라미터
+        
+        Returns:
+            Dict: {'response': str, 'error': str or None}
+        """
+        if not self.is_configured():
+            return {
+                'response': None,
+                'error': 'Gemini API 키가 설정되지 않았습니다. GEMINI_API_KEY 환경 변수를 설정하세요.'
+            }
+        
+        try:
+            # 모델 생성
+            model = genai.GenerativeModel(model_name)
+            
+            # 채팅 세션 시작
+            chat = model.start_chat(history=[])
+            
+            # 이전 대화 내역 추가 (user와 assistant 메시지)
+            for msg in messages[:-1]:  # 마지막 메시지 제외
+                if msg['role'] == 'user':
+                    chat.send_message(msg['content'])
+                elif msg['role'] == 'assistant' or msg['role'] == 'ai':
+                    # Gemini는 사용자 메시지만 직접 보내므로, assistant 메시지는 히스토리로 처리하지 않음
+                    pass
+            
+            # 마지막 사용자 메시지로 응답 생성 (타임아웃 설정)
+            last_message = messages[-1] if messages else {'content': ''}
+            timeout_seconds = getattr(self, 'timeout', 600)  # 5분 타임아웃
+            print(f"[Gemini] 채팅 응답 생성 중... (타임아웃: {timeout_seconds}초)")
+            
+            # 타임아웃을 위한 시작 시간 기록
+            start_time = time.time()
+            
+            # google-generativeai는 retry 파라미터를 지원하지 않으므로
+            # 재시도 정책을 수동으로 구현하여 적용
+            print(f"[Gemini] 채팅 API 호출 시작 (타임아웃: {timeout_seconds}초, 재시도 정책 적용)")
+            
+            # 재시도 로직 구현 (재시도 정책 객체의 설정 사용)
+            initial_wait = 10.0      # 초기 대기 시간
+            max_wait = 60.0          # 최대 대기 시간
+            multiplier = 2.0         # 대기 시간 배수
+            deadline = 600.0         # 전체 재시도 기간 (10분)
+            
+            wait_time = initial_wait
+            deadline_time = time.time() + deadline
+            retry_count = 0
+            last_error = None
+            
+            while True:
+                try:
+                    response = chat.send_message(last_message['content'])
+                    # 성공 시 루프 종료
+                    if retry_count > 0:
+                        print(f"[Gemini] 채팅 재시도 성공 (총 {retry_count}회 재시도)")
+                    break
+                except Exception as e:
+                    last_error = e
+                    error_str = str(e).lower()
+                    
+                    # 재시도 가능한 오류인지 확인 (타임아웃, 네트워크 오류 등)
+                    retryable_errors = ['timeout', '503', '502', '504', 'connection', 'network', 'illegal metadata']
+                    is_retryable = any(err in error_str for err in retryable_errors)
+                    
+                    # deadline 확인
+                    if time.time() >= deadline_time:
+                        print(f"[Gemini] 채팅 재시도 deadline 초과 ({deadline}초), 마지막 오류 반환")
+                        raise
+                    
+                    if is_retryable:
+                        retry_count += 1
+                        print(f"[Gemini] 채팅 재시도 {retry_count} - {wait_time:.1f}초 후 재시도 (오류: {str(e)[:100]})")
+                        time.sleep(wait_time)
+                        wait_time = min(wait_time * multiplier, max_wait)  # 배수로 증가, 최대값 제한
+                    else:
+                        # 재시도 불가능한 오류
+                        print(f"[Gemini] 채팅 재시도 불가능한 오류: {str(e)[:100]}")
+                        raise
+            
+            elapsed_time = time.time() - start_time
+            print(f"[Gemini] 채팅 응답 수신 완료 (경과 시간: {elapsed_time:.2f}초)")
+            
+            response_text = response.text if hasattr(response, 'text') else str(response)
+            
+            print(f"[Gemini] 채팅 응답 생성 완료: {len(response_text)}자")
+            return {
+                'response': response_text,
+                'error': None
+            }
+            
+        except Exception as e:
+            error_msg = f'Gemini API 오류: {str(e)}'
+            print(f"[Gemini] {error_msg}")
+            return {
+                'response': None,
+                'error': error_msg
+            }
+
+# 전역 Gemini 클라이언트 인스턴스
+_gemini_client = None
+
+def get_gemini_client() -> GeminiClient:
+    """Gemini 클라이언트 싱글톤 인스턴스 반환"""
+    global _gemini_client
+    if _gemini_client is None:
+        _gemini_client = GeminiClient()
+    else:
+        # API 키가 변경되었을 수 있으므로 재로드 시도
+        _gemini_client.reload_api_key()
+    return _gemini_client
+
+def reset_gemini_client():
+    """Gemini 클라이언트 리셋 (API 키 변경 후 호출)"""
+    global _gemini_client
+    _gemini_client = None
+    return get_gemini_client()
+

app/routes.py

@@ -1,8 +1,9 @@
 from flask import Blueprint, render_template, request, jsonify, send_from_directory, redirect, url_for, flash
 from flask_login import login_user, logout_user, login_required, current_user
 from werkzeug.utils import secure_filename
-from app.database import db, UploadedFile, User, ChatSession, ChatMessage, DocumentChunk, ParentChunk
+from app.database import db, UploadedFile, User, ChatSession, ChatMessage, DocumentChunk, ParentChunk, SystemConfig
 from app.vector_db import get_vector_db
+from app.gemini_client import get_gemini_client
 import requests
 import os
 from datetime import datetime
@@ -19,6 +20,9 @@ def admin_required(f):
     @login_required
     def decorated_function(*args, **kwargs):
         if not current_user.is_admin:
+            # API 요청인 경우 JSON 응답 반환
+            if request.path.startswith('/api/'):
+                return jsonify({'error': '관리자 권한이 필요합니다.'}), 403
             flash('관리자 권한이 필요합니다.', 'error')
             return redirect(url_for('main.index'))
         return f(*args, **kwargs)
@@ -262,6 +266,11 @@ def create_parent_chunk_with_ai(file_id, content, model_name):
         print(f"[Parent Chunk 생성] 사용 모델: {model_name}")
         print(f"[Parent Chunk 생성] 원본 텍스트 길이: {len(content)}자")
         
+        # 모델명이 None이거나 빈 문자열인 경우 처리
+        if not model_name or not model_name.strip():
+            print(f"[Parent Chunk 생성] ❌ 오류: 모델명이 제공되지 않았습니다.")
+            return None
+        
         # 텍스트가 너무 길면 일부만 사용 (최대 50000자)
         content_preview = content[:50000] if len(content) > 50000 else content
         if len(content) > 50000:
@@ -292,35 +301,95 @@ def create_parent_chunk_with_ai(file_id, content, model_name):
 
 각 항목을 명확하게 구분하여 작성해주세요."""
         
-        print(f"[Parent Chunk 생성] Ollama API에 분석 요청 전송 중...")
-        
-        # Ollama API 호출
-        ollama_response = requests.post(
-            f'{OLLAMA_BASE_URL}/api/chat',
-            json={
-                'model': model_name,
-                'messages': [
-                    {
-                        'role': 'user',
-                        'content': analysis_prompt
-                    }
-                ],
-                'stream': False
-            },
-            timeout=300  # 5분 타임아웃
-        )
+        # 모델 타입 확인 (Gemini 또는 Ollama)
+        # Gemini 모델명 형식: "gemini:모델명" 또는 "gemini-1.5-flash" (접두사 없는 경우도 지원)
+        model_name_lower = model_name.lower().strip()
+        is_gemini = model_name_lower.startswith('gemini:') or model_name_lower.startswith('gemini-')
         
-        if ollama_response.status_code != 200:
-            error_detail = ollama_response.text if ollama_response.text else '상세 정보 없음'
-            if ollama_response.status_code == 404:
-                error_msg = f'Ollama API 오류 404: 모델 "{model_name}"을(를) 찾을 수 없습니다. 모델이 Ollama에 설치되어 있는지 확인하세요.'
-            else:
-                error_msg = f'Ollama API 오류: {ollama_response.status_code} - {error_detail[:200]}'
-            print(f"[Parent Chunk 생성] ❌ 오류: {error_msg}")
-            return None
+        print(f"[Parent Chunk 생성] 모델 타입 확인: is_gemini={is_gemini}, model_name={model_name}")
         
-        response_data = ollama_response.json()
-        analysis_result = response_data.get('message', {}).get('content', '')
+        if is_gemini:
+            # Gemini API 호출
+            # 모델명에서 "gemini:" 접두사 제거 (대소문자 구분 없이)
+            gemini_model_name = model_name.strip()
+            if gemini_model_name.lower().startswith('gemini:'):
+                gemini_model_name = gemini_model_name.split(':', 1)[1].strip()
+            # "gemini-"로 시작하는 경우 (예: "gemini-1.5-flash") 그대로 사용
+            
+            print(f"[Parent Chunk 생성] Gemini API에 분석 요청 전송 중... (모델: {gemini_model_name})")
+            print(f"[Parent Chunk 생성] 원본 모델명: {model_name} -> Gemini 모델명: {gemini_model_name}")
+            
+            gemini_client = get_gemini_client()
+            if not gemini_client.is_configured():
+                print(f"[Parent Chunk 생성] ❌ 오류: Gemini API 키가 설정되지 않았습니다.")
+                print(f"[Parent Chunk 생성] 디버그: Gemini 클라이언트 상태 확인 중...")
+                # API 키 상태 다시 확인
+                from app.gemini_client import get_gemini_api_key
+                api_key = get_gemini_api_key()
+                if api_key:
+                    print(f"[Parent Chunk 생성] 디버그: API 키는 존재하지만 클라이언트가 설정되지 않았습니다. (길이: {len(api_key)})")
+                else:
+                    print(f"[Parent Chunk 생성] 디버그: API 키가 데이터베이스에 없습니다.")
+                return None
+            
+            print(f"[Parent Chunk 생성] Gemini API 키 확인 완료. API 호출 시작...")
+            result = gemini_client.generate_response(
+                prompt=analysis_prompt,
+                model_name=gemini_model_name,
+                temperature=0.7,
+                max_output_tokens=8192
+            )
+            
+            if result['error']:
+                print(f"[Parent Chunk 생성] ❌ 오류: Gemini API 호출 실패 - {result['error']}")
+                print(f"[Parent Chunk 생성] 디버그: result 객체 내용: {result}")
+                return None
+            
+            if not result.get('response'):
+                print(f"[Parent Chunk 생성] ❌ 오류: Gemini API 응답이 비어있습니다.")
+                print(f"[Parent Chunk 생성] 디버그: result 객체 내용: {result}")
+                return None
+            
+            analysis_result = result['response']
+            print(f"[Parent Chunk 생성] Gemini API 응답 수신 성공: {len(analysis_result)}자")
+        else:
+            # Ollama API 호출
+            print(f"[Parent Chunk 생성] Ollama API에 분석 요청 전송 중... (모델: {model_name})")
+            
+            try:
+                ollama_response = requests.post(
+                    f'{OLLAMA_BASE_URL}/api/chat',
+                    json={
+                        'model': model_name,
+                        'messages': [
+                            {
+                                'role': 'user',
+                                'content': analysis_prompt
+                            }
+                        ],
+                        'stream': False
+                    },
+                    timeout=300  # 5분 타임아웃
+                )
+                
+                if ollama_response.status_code != 200:
+                    error_detail = ollama_response.text if ollama_response.text else '상세 정보 없음'
+                    if ollama_response.status_code == 404:
+                        error_msg = f'Ollama API 오류 404: 모델 "{model_name}"을(를) 찾을 수 없습니다. 모델이 Ollama에 설치되어 있는지 확인하세요.'
+                        print(f"[Parent Chunk 생성] ❌ 오류: {error_msg}")
+                        print(f"[Parent Chunk 생성] 디버그: 만약 Gemini 모델을 사용하려면 모델명이 'gemini:' 또는 'gemini-'로 시작해야 합니다.")
+                    else:
+                        error_msg = f'Ollama API 오류: {ollama_response.status_code} - {error_detail[:200]}'
+                    print(f"[Parent Chunk 생성] ❌ 오류: {error_msg}")
+                    return None
+                
+                response_data = ollama_response.json()
+                analysis_result = response_data.get('message', {}).get('content', '')
+                print(f"[Parent Chunk 생성] Ollama API 응답 수신 성공: {len(analysis_result)}자")
+            except requests.exceptions.RequestException as e:
+                print(f"[Parent Chunk 생성] ❌ Ollama API 연결 오류: {str(e)}")
+                print(f"[Parent Chunk 생성] 디버그: Ollama URL: {OLLAMA_BASE_URL}")
+                raise
         
         if not analysis_result:
             print(f"[Parent Chunk 생성] ⚠️ 경고: 분석 결과가 비어있습니다.")
@@ -849,24 +918,107 @@ def delete_user(user_id):
         db.session.rollback()
         return jsonify({'error': f'사용자 삭제 중 오류가 발생했습니다: {str(e)}'}), 500
 
+@main_bp.route('/api/admin/gemini-api-key', methods=['GET'])
+@admin_required
+def get_gemini_api_key():
+    """Gemini API 키 조회"""
+    try:
+        # SystemConfig에서 API 키 가져오기 (테이블이 없으면 빈 문자열 반환)
+        api_key = SystemConfig.get_config('gemini_api_key', '')
+        
+        # 보안을 위해 마스킹된 값 반환 (처음 8자만 표시)
+        masked_key = api_key[:8] + '...' if api_key and len(api_key) > 8 else ''
+        return jsonify({
+            'has_api_key': bool(api_key),
+            'masked_key': masked_key
+        }), 200
+    except Exception as e:
+        print(f"[Gemini API 키 조회] 오류: {e}")
+        import traceback
+        traceback.print_exc()
+        return jsonify({'error': f'API 키 조회 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/admin/gemini-api-key', methods=['POST'])
+@admin_required
+def set_gemini_api_key():
+    """Gemini API 키 저장/업데이트"""
+    
+    try:
+        if not request.is_json:
+            return jsonify({'error': 'Content-Type이 application/json이 아닙니다.'}), 400
+        
+        data = request.json
+        if not data:
+            return jsonify({'error': '요청 데이터가 없습니다.'}), 400
+        
+        api_key = data.get('api_key', '').strip()
+        
+        if not api_key:
+            return jsonify({'error': 'API 키를 입력해주세요.'}), 400
+        
+        # API 키 저장 (SystemConfig.set_config 내부에서 테이블 생성 처리)
+        SystemConfig.set_config(
+            key='gemini_api_key',
+            value=api_key,
+            description='Google Gemini API 키'
+        )
+        
+        # Gemini 클라이언트에 API 키 재로드 알림
+        try:
+            from app.gemini_client import reset_gemini_client
+            reset_gemini_client()
+            print(f"[Gemini] API 키가 업데이트되어 클라이언트가 재로드되었습니다.")
+        except Exception as e:
+            print(f"[Gemini] API 키 재로드 실패: {e}")
+        
+        return jsonify({
+            'message': 'Gemini API 키가 성공적으로 저장되었습니다.',
+            'has_api_key': True
+        }), 200
+        
+    except Exception as e:
+        db.session.rollback()
+        print(f"[Gemini API 키 저장] 오류: {e}")
+        import traceback
+        traceback.print_exc()
+        return jsonify({'error': f'API 키 저장 중 오류가 발생했습니다: {str(e)}'}), 500
+
 @main_bp.route('/api/ollama/models', methods=['GET'])
 @login_required
 def get_ollama_models():
-    """Ollama에서 사용 가능한 모델 목록 가져오기 (실제 설치된 모델만 반환)"""
+    """Ollama 및 Gemini에서 사용 가능한 모델 목록 가져오기"""
     try:
-        response = requests.get(f'{OLLAMA_BASE_URL}/api/tags', timeout=5)
-        if response.status_code == 200:
-            data = response.json()
-            ollama_models = [{'name': model['name']} for model in data.get('models', [])]
-            
-            # 실제 설치된 모델만 반환
-            return jsonify({'models': ollama_models})
+        all_models = []
+        
+        # 1. Ollama 모델 목록 가져오기
+        try:
+            response = requests.get(f'{OLLAMA_BASE_URL}/api/tags', timeout=5)
+            if response.status_code == 200:
+                data = response.json()
+                ollama_models = [{'name': model['name'], 'type': 'ollama'} for model in data.get('models', [])]
+                all_models.extend(ollama_models)
+                print(f"[모델 목록] Ollama 모델 {len(ollama_models)}개 추가")
+        except Exception as e:
+            print(f"[모델 목록] Ollama 모델 목록 조회 실패: {e}")
+        
+        # 2. Gemini 모델 목록 가져오기
+        try:
+            gemini_client = get_gemini_client()
+            if gemini_client.is_configured():
+                gemini_models = gemini_client.get_available_models()
+                gemini_model_list = [{'name': f'gemini:{model_name}', 'type': 'gemini'} for model_name in gemini_models]
+                all_models.extend(gemini_model_list)
+                print(f"[모델 목록] Gemini 모델 {len(gemini_model_list)}개 추가")
+            else:
+                print(f"[모델 목록] Gemini API 키가 설정되지 않아 Gemini 모델을 불러올 수 없습니다.")
+        except Exception as e:
+            print(f"[모델 목록] Gemini 모델 목록 조회 실패: {e}")
+        
+        if all_models:
+            return jsonify({'models': all_models})
         else:
-            return jsonify({'error': 'Ollama 서버에 연결할 수 없습니다.', 'models': []}), 500
-    except requests.exceptions.ConnectionError:
-        return jsonify({'error': 'Ollama 서버에 연결할 수 없습니다. Ollama가 실행 중인지 확인하세요.', 'models': []}), 503
-    except requests.exceptions.Timeout:
-        return jsonify({'error': 'Ollama 서버 응답 시간이 초과되었습니다.', 'models': []}), 504
+            return jsonify({'error': '사용 가능한 모델이 없습니다. Ollama가 실행 중인지, 또는 Gemini API 키가 설정되었는지 확인하세요.', 'models': []}), 500
+            
     except Exception as e:
         return jsonify({'error': f'모델 목록을 가져오는 중 오류가 발생했습니다: {str(e)}', 'models': []}), 500
 
@@ -1098,111 +1250,134 @@ def chat():
                 # 프롬프트 구성
                 full_prompt = context + message if context else message
                 
-                # Ollama API 호출
-                ollama_response = requests.post(
-                    f'{OLLAMA_BASE_URL}/api/generate',
-                    json={
-                        'model': model,
-                        'prompt': full_prompt,
-                        'stream': False
-                    },
-                    timeout=120  # 파일이 많을 수 있으므로 타임아웃 증가
-                )
+                # 모델 타입 확인 (Gemini 또는 Ollama)
+                is_gemini = model.startswith('gemini:')
                 
-                if ollama_response.status_code == 200:
-                    ollama_data = ollama_response.json()
-                    response_text = ollama_data.get('response', '응답을 생성할 수 없습니다.')
+                if is_gemini:
+                    # Gemini API ��출
+                    gemini_model_name = model.replace('gemini:', '')
+                    print(f"[Gemini] 모델: {gemini_model_name}, 질문: {message[:50]}...")
+                    
+                    gemini_client = get_gemini_client()
+                    if not gemini_client.is_configured():
+                        return jsonify({'error': 'Gemini API 키가 설정되지 않았습니다. GEMINI_API_KEY 환경 변수를 설정하세요.'}), 500
+                    
+                    result = gemini_client.generate_response(
+                        prompt=full_prompt,
+                        model_name=gemini_model_name,
+                        temperature=0.7,
+                        max_output_tokens=8192
+                    )
                     
-                    # 대화 세션에 메시지 저장
-                    session_id = data.get('session_id')
-                    if session_id:
+                    if result['error']:
+                        return jsonify({'error': result['error']}), 500
+                    
+                    response_text = result['response']
+                else:
+                    # Ollama API 호출
+                    ollama_response = requests.post(
+                        f'{OLLAMA_BASE_URL}/api/generate',
+                        json={
+                            'model': model,
+                            'prompt': full_prompt,
+                            'stream': False
+                        },
+                        timeout=120  # 파일이 많을 수 있으므로 타임아웃 증가
+                    )
+                    
+                    if ollama_response.status_code != 200:
+                        # 오류 상세 정보 가져오기
                         try:
-                            session = ChatSession.query.filter_by(
-                                id=session_id,
-                                user_id=current_user.id
-                            ).first()
+                            error_detail = ollama_response.json().get('error', ollama_response.text[:200])
+                        except:
+                            error_detail = ollama_response.text[:200] if ollama_response.text else '상세 정보 없음'
+                        
+                        if ollama_response.status_code == 404:
+                            error_msg = f'모델 "{model}"을(를) 찾을 수 없습니다. 모델이 Ollama에 설치되어 있는지 확인하세요. (오류: {error_detail})'
+                        else:
+                            error_msg = f'Ollama 서버 오류: {ollama_response.status_code} (오류: {error_detail})'
+                        return jsonify({'error': error_msg}), ollama_response.status_code
+                    
+                    ollama_data = ollama_response.json()
+                    response_text = ollama_data.get('response', '응답을 생성할 수 없습니다.')
+                
+                # 대화 세션에 메시지 저장 (Gemini와 Ollama 공통)
+                session_id = data.get('session_id')
+                session_dict = None
+                if session_id:
+                    try:
+                        session = ChatSession.query.filter_by(
+                            id=session_id,
+                            user_id=current_user.id
+                        ).first()
+                        
+                        if session:
+                            # 사용자 메시지가 이미 저장되어 있는지 확인 (중복 방지)
+                            # 가장 최근 메시지를 확인하여 중복 저장 방지
+                            latest_user_msg = ChatMessage.query.filter_by(
+                                session_id=session_id,
+                                role='user'
+                            ).order_by(ChatMessage.created_at.desc()).first()
                             
-                            if session:
-                                # 사용자 메시지가 이미 저장되어 있는지 확인 (중복 방지)
-                                # 가장 최근 메시지를 확인하여 중복 저장 방지
-                                latest_user_msg = ChatMessage.query.filter_by(
-                                    session_id=session_id,
-                                    role='user'
-                                ).order_by(ChatMessage.created_at.desc()).first()
-                                
-                                # 최근 10초 이내에 같은 내용의 메시지가 없으면 저장
-                                should_save = True
-                                if latest_user_msg:
-                                    time_diff = (datetime.utcnow() - latest_user_msg.created_at).total_seconds()
-                                    if latest_user_msg.content == message and time_diff < 10:
-                                        should_save = False
-                                        print(f"[중복 방지] 최근 {time_diff:.2f}초 전에 같은 메시지가 저장되어 있습니다. 저장을 건너뜁니다.")
-                                
-                                if should_save:
-                                    user_msg = ChatMessage(
-                                        session_id=session_id,
-                                        role='user',
-                                        content=message
-                                    )
-                                    db.session.add(user_msg)
-                                    print(f"[메시지 저장] 사용자 메시지 저장: {message[:50]}...")
-                                    
-                                    # 세션 제목 업데이트 (첫 사용자 메시지인 경우)
-                                    title_needs_update = (
-                                        not session.title or 
-                                        session.title.strip() == '' or 
-                                        session.title == '새 대화'
-                                    )
-                                    
-                                    if title_needs_update and message.strip():
-                                        # 메시지 내용을 제목으로 사용 (최대 30자)
-                                        title = message.strip()[:30]
-                                        if len(message.strip()) > 30:
-                                            title += '...'
-                                        session.title = title
-                                        print(f"[세션 제목] 업데이트: '{title}' (원본 길이: {len(message.strip())}자)")
-                                    elif title_needs_update:
-                                        print(f"[세션 제목] 메시지가 비어있어 제목을 업데이트하지 않습니다.")
-                                else:
-                                    print(f"[메시지 저장] 중복 메시지로 인해 저장을 건너뜁니다.")
-                                
-                                # AI 응답 저장
-                                ai_msg = ChatMessage(
+                            # 최근 10초 이내에 같은 내용의 메시지가 없으면 저장
+                            should_save = True
+                            if latest_user_msg:
+                                time_diff = (datetime.utcnow() - latest_user_msg.created_at).total_seconds()
+                                if latest_user_msg.content == message and time_diff < 10:
+                                    should_save = False
+                                    print(f"[중복 방지] 최근 {time_diff:.2f}초 전에 같은 메시지가 저장되어 있습니다. 저장을 건너뜁니다.")
+                            
+                            if should_save:
+                                user_msg = ChatMessage(
                                     session_id=session_id,
-                                    role='ai',
-                                    content=response_text
+                                    role='user',
+                                    content=message
                                 )
-                                db.session.add(ai_msg)
+                                db.session.add(user_msg)
+                                print(f"[메시지 저장] 사용자 메시지 저장: {message[:50]}...")
                                 
-                                session.updated_at = datetime.utcnow()
-                                db.session.commit()
+                                # 세션 제목 업데이트 (첫 사용자 메시지인 경우)
+                                title_needs_update = (
+                                    not session.title or 
+                                    session.title.strip() == '' or 
+                                    session.title == '새 대화'
+                                )
                                 
-                                # 세션 정보를 응답에 포함 (제목 업데이트 반영)
-                                session_dict = session.to_dict()
-                        except Exception as e:
-                            print(f"메시지 저장 오류: {str(e)}")
-                            db.session.rollback()
-                            session_dict = None
-                    
-                    response_data = {'response': response_text, 'session_id': session_id}
-                    if session_dict:
-                        response_data['session'] = session_dict
-                    
-                    return jsonify(response_data)
-                else:
-                    # 오류 상세 정보 가져오기
-                    try:
-                        error_detail = ollama_response.json().get('error', ollama_response.text[:200])
-                    except:
-                        error_detail = ollama_response.text[:200] if ollama_response.text else '상세 정보 없음'
-                    
-                    if ollama_response.status_code == 404:
-                        error_msg = f'모델 "{model}"을(를) 찾을 수 없습니다. 모델이 Ollama에 설치되어 있는지 확인하세요. (오류: {error_detail})'
-                    else:
-                        error_msg = f'Ollama 서버 오류 {ollama_response.status_code}: {error_detail}'
-                    
-                    print(f"[채팅 API] 오류 발생: {error_msg}")
-                    return jsonify({'error': error_msg}), ollama_response.status_code
+                                if title_needs_update and message.strip():
+                                    # 메시지 내용을 제목으로 사용 (최대 30자)
+                                    title = message.strip()[:30]
+                                    if len(message.strip()) > 30:
+                                        title += '...'
+                                    session.title = title
+                                    print(f"[세션 제목] 업데이트: '{title}' (원본 길이: {len(message.strip())}자)")
+                                elif title_needs_update:
+                                    print(f"[세션 제목] 메시지가 비어있어 제목을 업데이트하지 않습니다.")
+                            else:
+                                print(f"[메시지 저장] 중복 메시지로 인해 저장을 건너뜁니다.")
+                            
+                            # AI 응답 저장
+                            ai_msg = ChatMessage(
+                                session_id=session_id,
+                                role='ai',
+                                content=response_text
+                            )
+                            db.session.add(ai_msg)
+                            
+                            session.updated_at = datetime.utcnow()
+                            db.session.commit()
+                            
+                            # 세션 정보를 응답에 포함 (제목 업데이트 반영)
+                            session_dict = session.to_dict()
+                    except Exception as e:
+                        print(f"메시지 저장 오류: {str(e)}")
+                        db.session.rollback()
+                        session_dict = None
+                
+                response_data = {'response': response_text, 'session_id': session_id}
+                if session_dict:
+                    response_data['session'] = session_dict
+                
+                return jsonify(response_data)
                     
             except requests.exceptions.ConnectionError:
                 return jsonify({'error': 'Ollama 서버에 연결할 수 없습니다. Ollama가 실행 중인지 확인하세요.'}), 503

requirements.txt

@@ -7,5 +7,6 @@ werkzeug==3.0.1
 chromadb==0.4.22
 sentence-transformers==2.3.1
 numpy==1.24.3
+google-generativeai==0.3.2
 
 

templates/admin.html

@@ -460,6 +460,27 @@
 
         <div id="alertContainer"></div>
 
+        <!-- Gemini API 키 설정 섹션 -->
+        <div class="card">
+            <div class="card-header">
+                <div class="card-title">Gemini API 키 설정</div>
+            </div>
+            <div style="padding: 16px 0;">
+                <div class="form-group">
+                    <label for="geminiApiKey">Gemini API 키</label>
+                    <div style="display: flex; gap: 8px;">
+                        <input type="password" id="geminiApiKey" placeholder="Gemini API 키를 입력하세요" style="flex: 1; padding: 8px 12px; border: 1px solid #dadce0; border-radius: 4px; font-size: 14px;">
+                        <button class="btn btn-primary" onclick="saveGeminiApiKey()">저장</button>
+                        <button class="btn btn-secondary" onclick="loadGeminiApiKey()">현재 상태 확인</button>
+                    </div>
+                    <small style="color: #5f6368; font-size: 12px; display: block; margin-top: 4px;">
+                        Google AI Studio(<a href="https://aistudio.google.com/app/apikey" target="_blank">https://aistudio.google.com/app/apikey</a>)에서 API 키를 발급받을 수 있습니다.
+                    </small>
+                    <div id="geminiApiKeyStatus" style="margin-top: 8px; font-size: 13px;"></div>
+                </div>
+            </div>
+        </div>
+
         <div class="card">
             <div class="card-header">
                 <div class="card-title">사용자 목록</div>
@@ -668,6 +689,88 @@
             }
         });
 
+        // Gemini API 키 관련 함수
+        async function loadGeminiApiKey() {
+            try {
+                const response = await fetch('/api/admin/gemini-api-key');
+                
+                // 응답이 JSON인지 확인
+                const contentType = response.headers.get('content-type');
+                if (!contentType || !contentType.includes('application/json')) {
+                    const text = await response.text();
+                    console.error('Non-JSON response:', text.substring(0, 200));
+                    const statusDiv = document.getElementById('geminiApiKeyStatus');
+                    statusDiv.innerHTML = `<span style="color: #ea4335;">서버 오류: 응답 형식이 올바르지 않습니다.</span>`;
+                    return;
+                }
+                
+                const data = await response.json();
+                
+                const statusDiv = document.getElementById('geminiApiKeyStatus');
+                if (!response.ok) {
+                    statusDiv.innerHTML = `<span style="color: #ea4335;">오류: ${data.error || '알 수 없는 오류'}</span>`;
+                    return;
+                }
+                
+                if (data.has_api_key) {
+                    statusDiv.innerHTML = `<span style="color: #137333;">✓ API 키가 설정되어 있습니다 (${data.masked_key})</span>`;
+                } else {
+                    statusDiv.innerHTML = `<span style="color: #ea4335;">⚠ API 키가 설정되지 않았습니다</span>`;
+                }
+            } catch (error) {
+                console.error('Gemini API 키 로드 오류:', error);
+                const statusDiv = document.getElementById('geminiApiKeyStatus');
+                statusDiv.innerHTML = `<span style="color: #ea4335;">오류: ${error.message}</span>`;
+            }
+        }
+
+        async function saveGeminiApiKey() {
+            const apiKeyInput = document.getElementById('geminiApiKey');
+            const apiKey = apiKeyInput.value.trim();
+            
+            if (!apiKey) {
+                showAlert('API 키를 입력해주세요.', 'error');
+                return;
+            }
+
+            try {
+                const response = await fetch('/api/admin/gemini-api-key', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ api_key: apiKey })
+                });
+
+                // 응답이 JSON인지 확인
+                const contentType = response.headers.get('content-type');
+                if (!contentType || !contentType.includes('application/json')) {
+                    const text = await response.text();
+                    console.error('Non-JSON response:', text.substring(0, 200));
+                    showAlert('서버 오류: 응답 형식이 올바르지 않습니다.', 'error');
+                    return;
+                }
+
+                const data = await response.json();
+
+                if (response.ok) {
+                    showAlert(data.message, 'success');
+                    apiKeyInput.value = ''; // 보안을 위해 입력 필드 초기화
+                    loadGeminiApiKey(); // 상태 업데이트
+                } else {
+                    showAlert(data.error || 'API 키 저장 중 오류가 발생했습니다.', 'error');
+                }
+            } catch (error) {
+                console.error('Gemini API 키 저장 오류:', error);
+                showAlert(`오류: ${error.message}`, 'error');
+            }
+        }
+
+        // 페이지 로드 시 API 키 상태 확인
+        window.addEventListener('load', () => {
+            loadGeminiApiKey();
+        });
+
     </script>
 </body>
 </html>

templates/index.html

@@ -552,6 +552,10 @@
             word-wrap: break-word;
             white-space: pre-wrap;
         }
+        
+        .message-bubble strong {
+            font-weight: 700;
+        }
 
         .message.user .message-bubble {
             background: var(--accent);
@@ -1215,6 +1219,26 @@
             }
         });
 
+        // Markdown 스타일 강조 표시를 HTML로 변환
+        function formatMessageText(text) {
+            if (!text) return '';
+            
+            // HTML 특수문자 이스케이프
+            let html = text
+                .replace(/&/g, '&')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;');
+            
+            // **텍스트** 패턴을 <strong>텍스트</strong>로 변환
+            // 단, ** 사이에 내용이 있어야 함
+            html = html.replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
+            
+            // 줄바꿈 처리
+            html = html.replace(/\n/g, '<br>');
+            
+            return html;
+        }
+        
         // 메시지 추가
         function addMessage(role, content, save = true) {
             // 빈 상태 숨기기
@@ -1234,7 +1258,7 @@
 
             const bubble = document.createElement('div');
             bubble.className = 'message-bubble';
-            bubble.textContent = content;
+            bubble.innerHTML = formatMessageText(content);
 
             const time = document.createElement('div');
             time.className = 'message-time';