feat: Integrate Supabase for data management, replacing local PostgreSQL. Implement Supabase service for CRUD operations on patients and scenarios, and update application logic to utilize Supabase API. Add Dockerfile for containerization and .dockerignore for build optimization.

.dockerignore

@@ -0,0 +1,66 @@
+# Git
+.git
+.gitignore
+.gitattributes
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+dist/
+build/
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+.cursor/
+
+# Documentation
+*.md
+!README.md
+
+# Test files
+test_*.py
+*_test.py
+tests/
+examples/
+
+# Build files
+*.lock
+.pytest_cache/
+.coverage
+htmlcov/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Database
+*.db
+*.sqlite3
+
+# Logs
+*.log
+
+# Docker
+Dockerfile.*
+docker-compose*.yml
+.dockerignore
+
+# Misc
+.svn
+CVS
+*.orig
+*.rej
+

Dockerfile

@@ -0,0 +1,41 @@
+# Python 3.12 기반 이미지
+FROM python:3.12-slim
+
+# 작업 디렉토리 설정
+WORKDIR /app
+
+# 시스템 의존성 설치
+RUN apt-get update && apt-get install -y \
+    gcc \
+    postgresql-client \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# 환경 변수 설정
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1
+
+# uv 설치 (빠른 Python 패키지 관리자)
+RUN pip install --no-cache-dir uv
+
+# 의존성 파일 복사 및 설치
+COPY pyproject.toml ./
+RUN uv pip install --system -e .
+
+# 애플리케이션 코드 복사
+COPY config/ ./config/
+COPY models/ ./models/
+COPY services/ ./services/
+COPY data/ ./data/
+COPY app.py init_db.py ./
+
+# 포트 노출 (Gradio 기본 포트)
+EXPOSE 7860
+
+# 헬스체크 추가
+HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
+    CMD curl -f http://localhost:7860/ || exit 1
+
+# 시작 스크립트
+CMD ["sh", "-c", "uv run python init_db.py && uv run python app.py"]
+

README.md

@@ -1,2 +1,173 @@
-# nurse-handover-simulator
+# 🏥 간호 인수인계 교육 플랫폼
+
 Clinical Handover Training Chatbot utilizing SBAR/ISBAR, EMR data, and immersive technology (Metaverse/VR) for standardized, high-fidelity nursing handover practice.
+
+## 📋 개요
+
+간호사 SBAR 형식 인수인계 훈련을 위한 AI 기반 교육 플랫폼입니다. Gradio 기반 웹 인터페이스를 통해 실제 EMR 데이터를 활용한 인수인계 연습을 제공합니다.
+
+## 🚀 시작하기
+
+### 1. 저장소 클론
+
+```bash
+git clone https://github.com/your-username/nurse-handover-simulator.git
+cd nurse-handover-simulator
+```
+
+### 2. 환경 변수 설정
+
+#### Supabase 사용 (권장)
+
+1. `ENV_EXAMPLE` 파일을 `.env`로 복사합니다:
+```bash
+cp ENV_EXAMPLE .env
+```
+
+2. Supabase 프로젝트 설정에서 필요한 정보를 복사합니다:
+   - Project URL: `https://project_id.supabase.co`
+   - API Key (anon key)
+   - Database URL (Connection String)
+
+3. `.env` 파일에 Supabase 정보를 입력합니다:
+```env
+SUPABASE_URL=https://[project_id].supabase.co
+SUPABASE_ANON_KEY=your_anon_key_here
+SUPABASE_DB_URL=postgresql://postgres:[password]@aws-0-[region].pooler.supabase.com:6543/postgres
+GOOGLE_API_KEY=your_google_api_key_here
+```
+
+#### 로컬 PostgreSQL 사용 (개발 환경)
+
+환경 변수에 `SUPABASE_DB_URL`을 설정하지 않으면 자동으로 로컬 PostgreSQL을 사용합니다.
+
+### 3. 의존성 설치
+
+```bash
+# uv를 사용하는 경우
+uv sync
+
+# 또는 일반 pip 사용
+pip install -e .
+```
+
+### 4. Google Gemini API 키 발급
+
+1. [Google AI Studio](https://makersuite.google.com/app/apikey)에서 API 키 발급
+2. `.env` 파일에 `GOOGLE_API_KEY` 추가
+
+### 5. 애플리케이션 실행
+
+```bash
+# start.sh 사용 (권장)
+bash start.sh
+
+# 또는 직접 실행
+uv run app.py
+```
+
+## 🐳 Docker 배포
+
+### 로컬 Docker 실행
+
+```bash
+# Docker 이미지 빌드
+docker build -t nurse-handover-simulator .
+
+# Docker 컨테이너 실행 (환경 변수 포함)
+docker run -p 7860:7860 \
+  -e SUPABASE_URL="https://your-project.supabase.co" \
+  -e SUPABASE_ANON_KEY="your_key" \
+  -e SUPABASE_DB_URL="postgresql://..." \
+  -e GOOGLE_API_KEY="your_key" \
+  nurse-handover-simulator
+
+# 또는 .env 파일 사용
+docker run -p 7860:7860 --env-file .env nurse-handover-simulator
+```
+
+### Hugging Face Spaces 배포
+
+1. Hugging Face Spaces에 새 Space 생성 (Docker 타입 선택)
+2. Repository Secrets에 다음 환경 변수 등록:
+   - `SUPABASE_URL`
+   - `SUPABASE_ANON_KEY`
+   - `SUPABASE_DB_URL`
+   - `GOOGLE_API_KEY`
+3. Dockerfile과 코드 푸시
+4. 자동 빌드 및 배포 완료
+
+## 📁 프로젝트 구조
+
+```
+nurse-handover-simulator/
+├── app.py                    # Gradio 메인 애플리케이션
+├── config/
+│   └── database.py          # 데이터베이스 연결 설정
+├── models/
+│   ├── patient_data.py      # 환자 및 시나리오 모델
+│   ├── handoff_record.py    # 인수인계 기록 모델
+│   └── chat_history.py      # 채팅 히스토리 모델
+├── services/
+│   ├── db_service.py        # 데이터베이스 CRUD 서비스
+│   └── gemini_service.py   # Google Gemini AI 서비스
+├── data/
+│   └── scenarios.json      # 시나리오 데이터
+├── Dockerfile               # Docker 배포 설정
+├── docker-compose.yml       # 로컬 PostgreSQL 설정
+├── ENV_EXAMPLE              # 환경 변수 템플릿
+├── start.sh                 # 시작 스크립트
+└── init_db.py              # 데이터베이스 초기화 스크립트
+```
+
+## 🔑 환경 변수 설명
+
+| 변수 | 설명 | 필수 여부 |
+|------|------|---------|
+| `SUPABASE_URL` | Supabase 프로젝트 URL | Supabase 사용 시 |
+| `SUPABASE_ANON_KEY` | Supabase Anon API Key | Supabase 사용 시 |
+| `SUPABASE_DB_URL` | Supabase 데이터베이스 연결 URL | Supabase 사용 시 |
+| `GOOGLE_API_KEY` | Google Gemini API 키 | 필수 |
+| `DB_HOST` | 로컬 PostgreSQL 호스트 | 로컬 PostgreSQL 사용 시 |
+| `DB_PORT` | 로컬 PostgreSQL 포트 | 로컬 PostgreSQL 사용 시 |
+
+## 🔒 보안 가이드
+
+### 환경 변수 관리
+
+1. **절대 `.env` 파일을 Git에 커밋하지 마세요**
+   - `.gitignore`에 `.env`가 이미 포함되어 있습니다
+
+2. **Supabase Keys**
+   - `SUPABASE_ANON_KEY`: 클라이언트 노출 가능 (RLS로 보호됨)
+   - `SUPABASE_DB_URL`: 서버에서만 사용, 노출 금지
+
+3. **Google API Key**
+   - 서버에서만 사용, 노출 금지
+
+4. **Hugging Face Spaces**
+   - Repository Secrets를 사용하여 환경 변수를 안전하게 관리
+
+## 📊 주요 기능
+
+- 📋 **EMR 정보 조회**: 실제 병원 EMR과 유사한 인터페이스
+- 💬 **AI 피드백**: Google Gemini AI를 활용한 실시간 피드백
+- 📝 **SBAR 형식 인수인계**: 표준 인수인계 형식 연습
+- 📊 **평가 시스템**: 완전성, 정확성, 명료성, 우선순위 평가
+- 📚 **학생 이력 조회**: 학생별 학습 이력 및 통계
+
+## 🛠️ 기술 스택
+
+- **Backend**: Python 3.12
+- **UI**: Gradio
+- **Database**: Supabase (PostgreSQL) / 로컬 PostgreSQL
+- **AI**: Google Gemini 2.0 Flash
+- **ORM**: SQLAlchemy
+
+## 📝 라이선스
+
+MIT License
+
+## 🤝 기여하기
+
+Pull Request는 언제든 환영합니다!

app.py

@@ -2,24 +2,41 @@
 간호 인수인계 교육 플랫폼 - Gradio 멀티페이지 애플리케이션 (채팅 기반)
 """
 
+import os
+
 import gradio as gr
-from config.database import SessionLocal, init_db
-from services.db_service import DatabaseService, load_scenarios_to_db
 from services.gemini_service import GeminiEvaluator
+from services.supabase_service import SupabaseService
+
+from config.database import supabase_client
 
 # 데이터베이스 초기화
 try:
-    init_db()
-    print("✅ 데이터베이스 초기화 완료")
-
-    # 시나리오 데이터 로드
-    db = SessionLocal()
-    load_scenarios_to_db(db, "data/scenarios.json")
-    db.close()
-    print("✅ 시나리오 데이터 로드 완료")
+    print("🔗 Supabase 모드로 실행합니다...")
+    
+    # Supabase 서비스 초기화
+    if supabase_client:
+        supabase_service = SupabaseService()
+        print("✅ Supabase 클라이언트 초기화 완료")
+        
+        # 시나리오 데이터 로드 (테이블이 없는 경우 무시)
+        try:
+            print("📥 시나리오 데이터 로드 중...")
+            supabase_service.load_scenarios_from_json("data/scenarios.json")
+            print("✅ 시나리오 데이터 로드 완료")
+        except Exception as load_error:
+            print(f"⚠️  시나리오 데이터 로드 실패: {load_error}")
+            print("   Supabase Dashboard에서 테이블을 먼저 생성해주세요:")
+            print("   1. supabase_schema.sql 실행")
+            print("   2. supabase_rls_fix_complete.sql 실행")
+    else:
+        print("⚠️  Supabase 클라이언트가 초기화되지 않았습니다.")
+        print("   환경 변수 SUPABASE_URL과 SUPABASE_ANON_KEY를 확인하세요.")
 except Exception as e:
     print(f"⚠️  데이터베이스 초기화 중 오류: {e}")
-    print("ℹ️  Docker Compose로 PostgreSQL을 먼저 실행해주세요: docker-compose up -d")
+    import traceback
+    traceback.print_exc()
+    print("ℹ️  Supabase 사용 시: 환경 변수를 확인해주세요")
 
 # Gemini 평가기 초기화
 evaluator = GeminiEvaluator()
@@ -321,19 +338,45 @@ def load_scenario_data(scenario_id: str):
     if not scenario_id:
         return None, None, ""
 
-    db = SessionLocal()
-    db_service = DatabaseService(db)
-
-    scenario = db_service.get_scenario(scenario_id)
-    patient = db_service.get_patient(scenario.patient_id) if scenario else None
+    supabase_service = SupabaseService()
 
-    db.close()
+    scenario = supabase_service.get_scenario(scenario_id)
+    patient = supabase_service.get_patient(scenario['patient_id']) if scenario else None
 
     if not scenario or not patient:
         return None, None, "시나리오를 찾을 수 없습니다."
 
-    emr_display = create_emr_html(patient, scenario)
-    return scenario, patient, emr_display
+    # Supabase 데이터를 객체처럼 사용할 수 있도록 래핑
+    class Scenario:
+        def __init__(self, data):
+            self.id = data['id']
+            self.patient_id = data['patient_id']
+            self.title = data['title']
+            self.hospital_day = data.get('hospital_day')
+            self.vitals = data.get('vitals')
+            self.labs = data.get('labs')
+            self.orders = data.get('orders')
+            self.nursing_notes = data.get('nursing_notes')
+            self.surgery_info = data.get('surgery_info')
+            self.discharge_education = data.get('discharge_education')
+
+    class Patient:
+        def __init__(self, data):
+            self.id = data['id']
+            self.name = data['name']
+            self.age = data['age']
+            self.gender = data['gender']
+            self.diagnosis = data['diagnosis']
+            self.admission_date = data['admission_date']
+            self.allergies = data['allergies']
+            self.comorbidities = data.get('comorbidities', '')
+            self.attending_physician = data.get('attending_physician', '')
+            self.room_number = data.get('room_number', '')
+
+    scenario_obj = Scenario(scenario)
+    patient_obj = Patient(patient)
+    emr_display = create_emr_html(patient_obj, scenario_obj)
+    return scenario_obj, patient_obj, emr_display
 
 
 def handle_chat_message(message, chat_history, session_id, student_id, scenario_id):
@@ -354,16 +397,14 @@ def handle_chat_message(message, chat_history, session_id, student_id, scenario_
 """
         return chat_history + [[message, warning_msg]], ""
 
-    # 데이터베이스 연결
-    db = SessionLocal()
-    db_service = DatabaseService(db)
+    # Supabase 서비스 연결
+    supabase_service = SupabaseService()
 
     # 시나리오 및 환자 정보 조회
-    scenario = db_service.get_scenario(scenario_id)
-    patient = db_service.get_patient(scenario.patient_id) if scenario else None
+    scenario = supabase_service.get_scenario(scenario_id)
+    patient = supabase_service.get_patient(scenario['patient_id']) if scenario else None
 
     if not scenario or not patient:
-        db.close()
         error_msg = """
 ❌ **시나리오 정보를 찾을 수 없습니다.**
 
@@ -372,26 +413,26 @@ EMR 정보 조회 탭에서 시나리오를 다시 선택해주세요.
         return chat_history + [[message, error_msg]], ""
 
     # 사용자 메시지 저장
-    db_service.save_chat_message(session_id, student_id, scenario_id, "user", message)
+    supabase_service.save_chat_message(session_id, student_id, scenario_id, "user", message)
 
     # 시나리오 및 환자 데이터 준비
     scenario_data = {
-        "title": scenario.title,
-        "handoff_situation": scenario.handoff_situation,
-        "hospital_day": scenario.hospital_day,
-        "vitals": scenario.vitals,
-        "labs": scenario.labs,
-        "orders": scenario.orders,
-        "nursing_notes": scenario.nursing_notes,
+        "title": scenario['title'],
+        "handoff_situation": scenario.get('handoff_situation'),
+        "hospital_day": scenario.get('hospital_day'),
+        "vitals": scenario.get('vitals'),
+        "labs": scenario.get('labs'),
+        "orders": scenario.get('orders'),
+        "nursing_notes": scenario.get('nursing_notes'),
     }
 
     patient_data = {
-        "name": patient.name,
-        "age": patient.age,
-        "gender": patient.gender,
-        "diagnosis": patient.diagnosis,
-        "admission_date": str(patient.admission_date),
-        "allergies": patient.allergies,
+        "name": patient['name'],
+        "age": patient['age'],
+        "gender": patient['gender'],
+        "diagnosis": patient['diagnosis'],
+        "admission_date": str(patient['admission_date']),
+        "allergies": patient['allergies'],
     }
 
     # 이전 채팅 기록 포맷팅 (Gemini용)
@@ -406,9 +447,7 @@ EMR 정보 조회 탭에서 시나리오를 다시 선택해주세요.
     ai_response = evaluator.chat_feedback(message, history_for_gemini, scenario_data, patient_data)
 
     # AI 응답 저장
-    db_service.save_chat_message(session_id, student_id, scenario_id, "assistant", ai_response)
-
-    db.close()
+    supabase_service.save_chat_message(session_id, student_id, scenario_id, "assistant", ai_response)
 
     # 채팅 히스토리 업데이트
     updated_history = chat_history + [[message, ai_response]]
@@ -416,160 +455,113 @@ EMR 정보 조회 탭에서 시나리오를 다시 선택해주세요.
     return updated_history, ""
 
 
-def submit_final_handoff(chat_history, session_id, student_id, scenario_id):
-    """최종 제출 및 평가"""
+def finalize_chat_session(chat_history, session_id, student_id, scenario_id):
+    """
+    채팅 종료 시 전체 대화를 분석하여 피드백 제공
+    - 점수 없이 질적 피드백만 제공
+    - 전체 대화 내용을 Gemini에게 전달
+    """
     if not chat_history:
-        return chat_history + [[None, "먼저 SBAR 인수인계 내용을 작성해주세요."]], ""
-
-    # 채팅 기록에서 SBAR 추출 (학생의 마지막 메시지들 분석)
-    # 간단히 하기 위해 학생에게 명시적으로 SBAR 형식으로 작성하도록 요청
-    final_message = """
-최종 제출을 요청하셨습니다. 
-
-지금까지 작성하신 내용을 바탕으로 최종 평가를 진행하겠습니다.
-SBAR 형식으로 정리된 내용을 다시 한 번 작성해주세요:
-
-**S - Situation (상황):**
-[여기에 작성]
-
-**B - Background (배경):**
-[여기에 작성]
-
-**A - Assessment (평가):**
-[여기에 작성]
-
-**R - Recommendation (권고사항):**
-[여기에 작성]
-
-위 형식으로 작성 후 다시 "최종 제출" 버튼을 눌러주세요.
-"""
-
-    # 실제 구현에서는 채팅 기록을 파싱하여 SBAR 추출
-    # 여기서는 간단히 안내 메시지만 반환
-    return chat_history + [[None, final_message]], ""
-
-
-def extract_sbar_from_message(message):
-    """메시지에서 SBAR 추출"""
-    import re
-    
-    sbar = {
-        "situation": "",
-        "background": "",
-        "assessment": "",
-        "recommendation": ""
-    }
-    
-    # S, B, A, R 섹션 추출
-    s_match = re.search(r'\*\*S.*?Situation.*?\*\*:?\s*(.*?)(?=\*\*B|\*\*Background|$)', message, re.DOTALL | re.IGNORECASE)
-    b_match = re.search(r'\*\*B.*?Background.*?\*\*:?\s*(.*?)(?=\*\*A|\*\*Assessment|$)', message, re.DOTALL | re.IGNORECASE)
-    a_match = re.search(r'\*\*A.*?Assessment.*?\*\*:?\s*(.*?)(?=\*\*R|\*\*Recommendation|$)', message, re.DOTALL | re.IGNORECASE)
-    r_match = re.search(r'\*\*R.*?Recommendation.*?\*\*:?\s*(.*?)$', message, re.DOTALL | re.IGNORECASE)
+        return chat_history + [[None, "대화가 없습니다. 먼저 대화를 시작해주세요."]], ""
     
-    if s_match:
-        sbar["situation"] = s_match.group(1).strip()
-    if b_match:
-        sbar["background"] = b_match.group(1).strip()
-    if a_match:
-        sbar["assessment"] = a_match.group(1).strip()
-    if r_match:
-        sbar["recommendation"] = r_match.group(1).strip()
-    
-    return sbar
-
-
-def process_final_submission(message, chat_history, session_id, student_id, scenario_id):
-    """SBAR 형식 메시지를 받아 최종 평가 수행"""
-    # SBAR 추출
-    sbar_data = extract_sbar_from_message(message)
-    
-    # 모든 섹션이 작성되었는지 확인
-    if not all([sbar_data["situation"], sbar_data["background"], 
-                sbar_data["assessment"], sbar_data["recommendation"]]):
-        return chat_history + [[message, "SBAR 형식이 완전하지 않습니다. S, B, A, R 모든 섹션을 작성해주세요."]], ""
-    
-    # 데이터베이스 연결
-    db = SessionLocal()
-    db_service = DatabaseService(db)
+    # Supabase 서비스 연결
+    supabase_service = SupabaseService()
     
     # 시나리오 및 환자 정보 조회
-    scenario = db_service.get_scenario(scenario_id)
-    patient = db_service.get_patient(scenario.patient_id) if scenario else None
+    scenario = supabase_service.get_scenario(scenario_id)
+    patient = supabase_service.get_patient(scenario['patient_id']) if scenario else None
     
     if not scenario or not patient:
-        db.close()
-        return chat_history + [[message, "시나리오 정보를 찾을 수 없습니다."]], ""
+        return chat_history + [[None, "시나리오 정보를 찾을 수 없습니다."]], ""
     
     # 시나리오 및 환자 데이터 준비
     scenario_data = {
-        "title": scenario.title,
-        "handoff_situation": scenario.handoff_situation,
-        "hospital_day": scenario.hospital_day,
-        "vitals": scenario.vitals,
-        "labs": scenario.labs,
-        "orders": scenario.orders,
-        "nursing_notes": scenario.nursing_notes,
+        "title": scenario['title'],
+        "handoff_situation": scenario.get('handoff_situation'),
+        "hospital_day": scenario.get('hospital_day'),
+        "vitals": scenario.get('vitals'),
+        "labs": scenario.get('labs'),
+        "orders": scenario.get('orders'),
+        "nursing_notes": scenario.get('nursing_notes'),
     }
     
     patient_data = {
-        "name": patient.name,
-        "age": patient.age,
-        "gender": patient.gender,
-        "diagnosis": patient.diagnosis,
-        "admission_date": str(patient.admission_date),
-        "allergies": patient.allergies,
+        "name": patient['name'],
+        "age": patient['age'],
+        "gender": patient['gender'],
+        "diagnosis": patient['diagnosis'],
+        "admission_date": str(patient['admission_date']),
+        "allergies": patient['allergies'],
     }
     
-    # Gemini AI 평가
-    evaluation = evaluator.evaluate_handoff(sbar_data, scenario_data, patient_data)
+    # 전체 대화를 Gemini에게 전달하여 평가
+    evaluation = evaluator.evaluate_conversation(
+        chat_history=chat_history,
+        scenario_data=scenario_data,
+        patient_data=patient_data
+    )
     
-    # 데이터베이스에 저장
+    # 데이터베이스에 저장 (점수 없이)
     try:
-        record = db_service.create_handoff_record(
+        record = supabase_service.create_handoff_record(
             student_id=student_id,
             scenario_id=scenario_id,
-            sbar_data=sbar_data,
+            sbar_data={},  # 대화 기반 평가이므로 SBAR 데이터는 비움
             evaluation=evaluation,
             session_id=session_id
         )
-        print(f"✅ 인수인계 기록 저장 완료 (ID: {record.id})")
+        print(f"✅ 인수인계 기록 저장 완료 (ID: {record.get('id')})")
+        
+        # 세션 상태를 'completed'로 변경
+        supabase_service.update_session_status(session_id, 'completed')
     except Exception as e:
         print(f"⚠️  데이터베이스 저장 오류: {e}")
     
-    db.close()
-    
-    # 평가 결과 포맷팅
-    total_score = evaluation.get("total_score", 0)
-    category_scores = evaluation.get("category_scores", {})
-    strengths = evaluation.get("strengths", [])
-    improvements = evaluation.get("improvements", [])
-    detailed_feedback = evaluation.get("detailed_feedback", "")
+    # 피드백 메시지 포맷팅 (점수 없이)
+    strengths = evaluation.get('strengths', [])
+    improvements = evaluation.get('improvements', [])
+    detailed_feedback = evaluation.get('detailed_feedback', '')
+    missing_info = evaluation.get('missing_critical_info', [])
+    safety_concerns = evaluation.get('safety_concerns', [])
     
     result_message = f"""
-🎉 **최종 평가 완료!**
+🎓 **학습 종합 피드백**
 
-**총점: {total_score:.1f} / 100**
+{'='*50}
 
-**카테고리별 점수:**
-- 완전성 (Completeness): {category_scores.get('completeness', 0)} / 25
-- 정확성 (Accuracy): {category_scores.get('accuracy', 0)} / 25
-- 명료성 (Clarity): {category_scores.get('clarity', 0)} / 25
-- 우선순위 (Priority): {category_scores.get('priority', 0)} / 25
+### 💪 잘한 점
+{chr(10).join([f"- {s}" for s in strengths]) if strengths else "- 없음"}
 
-**💪 잘한 점:**
-{chr(10).join([f"- {s}" for s in strengths])}
+### 📈 개선할 점
+{chr(10).join([f"- {i}" for i in improvements]) if improvements else "- 없음"}
 
-**📈 개선할 점:**
-{chr(10).join([f"- {i}" for i in improvements])}
+### 🔍 종합 의견
+{detailed_feedback if detailed_feedback else "종합 피드백이 없습니다."}
 
-**📝 종합 피드백:**
-{detailed_feedback}
+"""
+    
+    if missing_info:
+        result_message += f"""
+### ⚠️ 누락된 중요 정보
+{chr(10).join([f"- {m}" for m in missing_info])}
 
----
-수고하셨습니다! 다른 시나리오로 연습을 계속하시려면 EMR 페이지로 돌아가 새로운 시나리오를 선택하세요.
 """
     
-    return chat_history + [[message, result_message]], ""
+    if safety_concerns:
+        result_message += f"""
+### 🏥 환자 안전 관련 주의사항
+{chr(10).join([f"- {s}" for s in safety_concerns])}
+
+"""
+    
+    result_message += f"""
+{'='*50}
+
+수고하셨습니다! 다른 시나리오로 연습을 계속하시려면 
+EMR 페이지로 돌아가 새로운 시나리오를 선택하세요.
+"""
+    
+    return chat_history + [[None, result_message]], ""
 
 
 def get_student_history(student_id: str):
@@ -577,13 +569,10 @@ def get_student_history(student_id: str):
     if not student_id:
         return "학생 ID를 입력해주세요."
 
-    db = SessionLocal()
-    db_service = DatabaseService(db)
+    supabase_service = SupabaseService()
 
-    stats = db_service.get_student_statistics(student_id)
-    records = db_service.get_records_by_student(student_id)
-
-    db.close()
+    stats = supabase_service.get_student_statistics(student_id)
+    records = supabase_service.get_records_by_student(student_id)
 
     if stats["total_submissions"] == 0:
         return f"학생 ID '{student_id}'의 제출 기록이 없습니다."
@@ -603,12 +592,20 @@ def get_student_history(student_id: str):
 """
 
     for i, record in enumerate(records[:10], 1):
-        submitted_time = record.submitted_at.strftime("%Y-%m-%d %H:%M") if record.submitted_at else "N/A"
+        submitted_time = record.get('submitted_at', 'N/A')
+        if submitted_time and isinstance(submitted_time, str):
+            # ISO 형식에서 시간 추출
+            try:
+                from datetime import datetime
+                dt = datetime.fromisoformat(submitted_time.replace('Z', '+00:00'))
+                submitted_time = dt.strftime("%Y-%m-%d %H:%M")
+            except:
+                pass
         history += f"""
-### {i}. {record.scenario_id}
+### {i}. {record.get('scenario_id', 'N/A')}
 - **제출 시간**: {submitted_time}
-- **점수**: {record.total_score:.1f}점
-- **강점**: {', '.join(record.strengths[:2]) if record.strengths else 'N/A'}
+- **점수**: {record.get('total_score', 0):.1f}점
+- **강점**: {', '.join(record.get('strengths', [])[:2]) if record.get('strengths') else 'N/A'}
 ---
 """
 
@@ -681,12 +678,12 @@ with gr.Blocks(title="간호 인수인계 교육 플랫폼", theme=gr.themes.Sof
         
         # 페이지 2: 채팅 기반 답안 작성
         with gr.Tab("💬 답안 작성 (채팅)", id=1) as tab_chat:
-            gr.Markdown("## SBAR 인수인계 작성 및 피드백")
+            gr.Markdown("## AI 교수와 함께하는 인수인계 연습")
             gr.Markdown("""
             **📌 시작하기:**
             1. 기본 시나리오는 **"Day 0 - 응급실→병동 인계"**입니다 (상단에서 확인 가능)
             2. EMR 정보를 확인하려면 **"EMR 정보 조회"** 탭을 클릭하세요
-            3. 준비가 되면 아래 메시지 입력창에 SBAR 내용을 작성하세요
+            3. 준비가 되면 AI 교수와 자유롭게 대화하며 인수인계 내용을 작성하세요
             """)
             
             with gr.Row():
@@ -702,37 +699,27 @@ with gr.Blocks(title="간호 인수인계 교육 플랫폼", theme=gr.themes.Sof
             with gr.Row():
                 msg_input = gr.Textbox(
                     label="메시지 입력",
-                    placeholder="SBAR 형식으로 인수인계 내용을 작성하거나, 질문을 입력하세요...",
+                    placeholder="자유롭게 대화하며 인수인계 내용을 작성하거나, AI 교수에게 질문하세요...",
                     lines=3,
                     scale=4
                 )
             
             with gr.Row():
                 send_btn = gr.Button("전송", variant="primary")
-                submit_final_btn = gr.Button("최종 제출하기", variant="stop")
+                finalize_btn = gr.Button("채팅 종료 및 평가받기", variant="stop")
                 clear_btn = gr.Button("대화 초기화")
             
             gr.Markdown("""
             **사용 방법:**
-            1. SBAR 형식으로 인수인계 내용을 작성하세요
-            2. AI 교수가 피드백을 제공합니다
-            3. 피드백을 바탕으로 수정하고 다시 작성할 수 있습니다
-            4. 준비가 되면 **최종 제출하기**를 눌러 평가를 받으세요
-            
-            **최종 제출 시 형식:**
-            ```
-            **S - Situation (상황):**
-            [내용]
-            
-            **B - Background (배경):**
-            [내용]
+            1. 자유롭게 대화하며 인수인계 내용을 작성하세요
+            2. AI 교수가 즉시 피드백을 제공합니다
+            3. 피드백을 바탕으로 수정하고 더 나은 내용을 작성할 수 있습니다
+            4. 준비가 되면 **채팅 종료 및 평가받기** 버튼을 눌러 종합 피드백을 받으세요
             
-            **A - Assessment (평가):**
-            [내용]
-            
-            **R - Recommendation (권고사항):**
-            [내용]
-            ```
+            **💡 팁:**
+            - 자연스러운 대화로 배우는 것이 핵심입니다
+            - SBAR 형식을 강제하지 않습니다. 대화를 통해 자동으로 평가됩니다
+            - 언제든지 AI 교수에게 질문하세요
             """)
         
         # 페이지 3: 관리자 이력 조회
@@ -769,10 +756,8 @@ with gr.Blocks(title="간호 인수인계 교육 플랫폼", theme=gr.themes.Sof
         
         if scenario:
             # 새 채팅 세션 생성
-            db = SessionLocal()
-            db_service = DatabaseService(db)
-            new_session_id = db_service.create_chat_session(student_id, scenario_id)
-            db.close()
+            supabase_service = SupabaseService()
+            new_session_id = supabase_service.create_chat_session(student_id, scenario_id)
             
             scenario_info = f"**현재 시나리오**: {scenario.title}"
             
@@ -801,20 +786,18 @@ with gr.Blocks(title="간호 인수인계 교육 플랫폼", theme=gr.themes.Sof
         show_progress="minimal"
     )
     
-    # 최종 제출
-    submit_final_btn.click(
-        fn=process_final_submission,
-        inputs=[msg_input, chatbot, session_id_state, student_id_state, scenario_id_state],
+    # 채팅 종료 및 평가
+    finalize_btn.click(
+        fn=finalize_chat_session,
+        inputs=[chatbot, session_id_state, student_id_state, scenario_id_state],
         outputs=[chatbot, msg_input]
     )
     
     # 대화 초기화
     def clear_chat(student_id, scenario_id):
         """대화 초기화 및 새 세션 생성"""
-        db = SessionLocal()
-        db_service = DatabaseService(db)
-        new_session_id = db_service.create_chat_session(student_id, scenario_id)
-        db.close()
+        supabase_service = SupabaseService()
+        new_session_id = supabase_service.create_chat_session(student_id, scenario_id)
         
         return [], new_session_id
     

config/database.py

@@ -1,53 +1,82 @@
 """
-데이터베이스 연결 설정
+Supabase REST API 설정
 """
 
 import os
 
 from dotenv import load_dotenv
-from sqlalchemy import create_engine
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
+
+try:
+    from supabase import Client, create_client
+except ImportError:
+    create_client = None
+    Client = None
 
 # 환경 변수 로드
 load_dotenv()
 
-# 데이터베이스 URL 구성
-DB_HOST = os.getenv("DB_HOST", "localhost")
-DB_PORT = os.getenv("DB_PORT", "5433")
-DB_NAME = os.getenv("DB_NAME", "nursing_handoff")
-DB_USER = os.getenv("DB_USER", "postgres")
-DB_PASSWORD = os.getenv("DB_PASSWORD", "postgres123")
-
-DATABASE_URL = f"postgresql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
+# Supabase 연결 설정
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_ANON_KEY = os.getenv("SUPABASE_ANON_KEY")
 
-# SQLAlchemy 엔진 및 세션 생성
-engine = create_engine(DATABASE_URL, echo=True)
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+# SUPABASE_KEY도 지원 (호환성)
+if not SUPABASE_ANON_KEY:
+    SUPABASE_ANON_KEY = os.getenv("SUPABASE_KEY")
 
-# Base 클래스
-Base = declarative_base()
 
-
-def get_db():
+def check_supabase_health() -> bool:
     """
-    데이터베이스 세션을 생성하고 반환하는 제너레이터
+    Supabase 연결 상태 확인
+    
+    Returns:
+        bool: Supabase 사용 가능 여부
     """
-    db = SessionLocal()
+    if not SUPABASE_URL:
+        return False
+    
     try:
-        yield db
-    finally:
-        db.close()
+        import requests
 
+        # 여러 엔드포인트 시도
+        health_endpoints = [
+            "/rest/v1/",
+            "/auth/v1/health",
+            "/health"
+        ]
+        
+        for endpoint in health_endpoints:
+            try:
+                health_url = f"{SUPABASE_URL}{endpoint}"
+                response = requests.get(health_url, timeout=3)
+                if response.status_code in [200, 301, 302, 404]:
+                    print(f"✅ Supabase 연결 확인: {endpoint}")
+                    return True
+            except Exception:
+                continue
+        
+        return False
+    except Exception as e:
+        print(f"⚠️  Supabase 헬스체크 실패: {e}")
+        return False
 
-def init_db():
-    """
-    데이터베이스 테이블 생성
-    """
-    # Import models to register them with SQLAlchemy
-    import models.chat_history  # noqa: F401
-    import models.handoff_record  # noqa: F401
-    import models.patient_data  # noqa: F401
 
-    Base.metadata.create_all(bind=engine)
-    print("✅ 데이터베이스 테이블이 생성되었습니다.")
+# Supabase 클라이언트 초기화 (REST API 사용)
+supabase_client: Client | None = None
+
+if SUPABASE_URL and SUPABASE_ANON_KEY and create_client:
+    try:
+        supabase_client = create_client(SUPABASE_URL, SUPABASE_ANON_KEY)
+        print("✅ Supabase REST API 클라이언트 초기화 완료")
+        
+        # Supabase 연결 상태 확인
+        is_supabase = check_supabase_health()
+        if is_supabase:
+            print("✅ Supabase 연결 확인 완료")
+        else:
+            print("⚠️  Supabase 헬스체크 실패, REST API는 사용 가능합니다")
+    except Exception as e:
+        print(f"⚠️  Supabase REST API 클라이언트 초기화 실패: {e}")
+        supabase_client = None
+else:
+    print("⚠️  Supabase 환경 변수가 설정되지 않았습니다.")
+    print("   SUPABASE_URL과 SUPABASE_ANON_KEY를 설정하세요.")

docker-compose.yml

@@ -1,23 +0,0 @@
-version: '3.8'
-
-services:
-  postgres:
-    image: postgres:15-alpine
-    container_name: nursing_handoff_db
-    environment:
-      POSTGRES_DB: nursing_handoff
-      POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres123
-    ports:
-      - "5433:5432"
-    volumes:
-      - postgres_data:/var/lib/postgresql/data
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres"]
-      interval: 10s
-      timeout: 5s
-      retries: 5
-
-volumes:
-  postgres_data:
-

init_db.py

@@ -1,23 +1,28 @@
 """
-데이터베이스 초기화 및 시나리오 데이터 로드 스크립트
+Supabase 시나리오 데이터 로드 스크립트
 """
 
-from config.database import SessionLocal, init_db
-from services.db_service import load_scenarios_to_db
+from services.supabase_service import SupabaseService
 
-if __name__ == "__main__":
-    print("🚀 데이터베이스 초기화 시작...")
+from config.database import supabase_client
 
-    # 테이블 생성
-    init_db()
+if __name__ == "__main__":
+    print("🚀 Supabase 시나리오 데이터 로드 시작...")
+    
+    if not supabase_client:
+        print("❌ Supabase 클라이언트가 초기화되지 않았습니다.")
+        print("   환경 변수 SUPABASE_URL과 SUPABASE_ANON_KEY를 확인하세요.")
+        exit(1)
 
+    # Supabase 서비스 초기화
+    supabase_service = SupabaseService()
+    
     # 시나리오 데이터 로드
     print("\n📥 시나리오 데이터 로드 중...")
-    db = SessionLocal()
     try:
-        load_scenarios_to_db(db, "data/scenarios.json")
+        supabase_service.load_scenarios_from_json("data/scenarios.json")
         print("\n✅ 모든 초기화 작업이 완료되었습니다!")
     except Exception as e:
         print(f"\n❌ 오류 발생: {e}")
-    finally:
-        db.close()
+        import traceback
+        traceback.print_exc()

models/chat_history.py

@@ -1,44 +0,0 @@
-"""
-채팅 히스토리 모델
-"""
-
-from config.database import Base
-from sqlalchemy import Column, DateTime, Integer, String, Text
-from sqlalchemy.sql import func
-
-
-class ChatHistory(Base):
-    """학생과 AI 간의 채팅 기록"""
-
-    __tablename__ = "chat_history"
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    session_id = Column(String(100), nullable=False, index=True)  # 채팅 세션 ID
-    student_id = Column(String(50), nullable=False, index=True)  # 학생 식별자
-    scenario_id = Column(String(50), nullable=False)  # 시나리오 ID
-    role = Column(String(20), nullable=False)  # 'user' 또는 'assistant'
-    message = Column(Text, nullable=False)  # 메시지 내용
-    timestamp = Column(DateTime(timezone=True), server_default=func.now())
-
-    def __repr__(self):
-        return f"<ChatHistory(id={self.id}, session_id={self.session_id}, role={self.role})>"
-
-
-class SbarDraft(Base):
-    """작성 중인 SBAR 임시 저장"""
-
-    __tablename__ = "sbar_drafts"
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    session_id = Column(String(100), nullable=False, unique=True, index=True)
-    student_id = Column(String(50), nullable=False)
-    scenario_id = Column(String(50), nullable=False)
-    situation = Column(Text, default="")
-    background = Column(Text, default="")
-    assessment = Column(Text, default="")
-    recommendation = Column(Text, default="")
-    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
-
-    def __repr__(self):
-        return f"<SbarDraft(session_id={self.session_id}, student_id={self.student_id})>"
-

models/handoff_record.py

@@ -1,42 +0,0 @@
-"""
-인수인계 기록 모델
-"""
-
-from config.database import Base
-from sqlalchemy import (JSON, Column, DateTime, Float, ForeignKey, Integer,
-                        String, Text)
-from sqlalchemy.orm import relationship
-from sqlalchemy.sql import func
-
-
-class HandoffRecord(Base):
-    """학생의 인수인계 기록 및 평가 결과"""
-
-    __tablename__ = "handoff_records"
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    session_id = Column(String(100), nullable=True, index=True)  # 채팅 세션 ID (채팅 기록과 연결)
-    student_id = Column(String(50), nullable=False)  # 학생 식별자
-    scenario_id = Column(String(50), ForeignKey("scenarios.id"), nullable=False)
-
-    # 제출 시간
-    submitted_at = Column(DateTime(timezone=True), server_default=func.now())
-
-    # SBAR 입력 내용
-    situation = Column(Text, nullable=False)
-    background = Column(Text, nullable=False)
-    assessment = Column(Text, nullable=False)
-    recommendation = Column(Text, nullable=False)
-
-    # Gemini AI 평가 결과
-    total_score = Column(Float)  # 총점 (0-100)
-    category_scores = Column(JSON)  # 카테고리별 점수
-    strengths = Column(JSON)  # 강점 목록
-    improvements = Column(JSON)  # 개선사항 목록
-    detailed_feedback = Column(Text)  # 상세 피드백
-
-    # 관계
-    scenario = relationship("Scenario", back_populates="handoff_records")
-
-    def __repr__(self):
-        return f"<HandoffRecord(id={self.id}, student_id={self.student_id}, score={self.total_score})>"

models/patient_data.py

@@ -1,65 +0,0 @@
-"""
-환자 및 시나리오 데이터 모델
-"""
-
-from config.database import Base
-from sqlalchemy import JSON, Column, Date, ForeignKey, Integer, String, Text
-from sqlalchemy.orm import relationship
-
-
-class Patient(Base):
-    """환자 기본 정보"""
-
-    __tablename__ = "patients"
-
-    id = Column(String(50), primary_key=True)  # 예: P001
-    name = Column(String(100), nullable=False)
-    age = Column(Integer, nullable=False)
-    gender = Column(String(10), nullable=False)
-    weight = Column(Integer)  # kg
-    height = Column(Integer)  # cm
-    diagnosis = Column(String(200), nullable=False)
-    admission_date = Column(Date, nullable=False)
-    attending_physician = Column(String(100))
-    allergies = Column(String(200))
-    comorbidities = Column(Text)
-    room_number = Column(String(20))
-
-    # 관계
-    scenarios = relationship("Scenario", back_populates="patient")
-
-    def __repr__(self):
-        return f"<Patient(id={self.id}, name={self.name}, diagnosis={self.diagnosis})>"
-
-
-class Scenario(Base):
-    """환자 시나리오 (인수인계 상황)"""
-
-    __tablename__ = "scenarios"
-
-    id = Column(String(50), primary_key=True)  # 예: S001_D0_ER_WARD
-    patient_id = Column(String(50), ForeignKey("patients.id"), nullable=False)
-    title = Column(String(200), nullable=False)
-    day = Column(Integer, nullable=False)  # 0, 1, 2
-    handoff_situation = Column(String(200))  # 예: 응급실→병동
-
-    # EMR 데이터 (JSON 형식)
-    vitals = Column(JSON)  # 활력징후
-    labs = Column(JSON)  # 검사 결과
-    orders = Column(JSON)  # 의사 처방
-    nursing_notes = Column(JSON)  # 간호 기록
-    physical_exam = Column(JSON)  # 신체 검진
-    imaging = Column(JSON)  # 영상 검사
-    surgery_info = Column(JSON)  # 수술 정보
-    discharge_education = Column(JSON)  # 퇴원 교육
-
-    # 추가 정보
-    hospital_day = Column(Integer)
-    status_badge = Column(String(20))  # stable, watch, critical
-
-    # 관계
-    patient = relationship("Patient", back_populates="scenarios")
-    handoff_records = relationship("HandoffRecord", back_populates="scenario")
-
-    def __repr__(self):
-        return f"<Scenario(id={self.id}, title={self.title})>"

pyproject.toml

@@ -6,7 +6,8 @@ requires-python = ">=3.12"
 dependencies = [
     "google-generativeai>=0.8.5",
     "gradio>=5.49.1",
-    "psycopg2-binary>=2.9.11",
     "python-dotenv>=1.1.1",
-    "sqlalchemy>=2.0.44",
+    "requests>=2.31.0",
+    "supabase>=2.0.0",
+    "tsidpy>=1.1.5",
 ]

services/db_service.py

@@ -1,296 +0,0 @@
-"""
-데이터베이스 CRUD 서비스
-"""
-
-import uuid
-from datetime import datetime
-
-from sqlalchemy.orm import Session
-
-from models.chat_history import ChatHistory, SbarDraft
-from models.handoff_record import HandoffRecord
-from models.patient_data import Patient, Scenario
-
-
-class DatabaseService:
-    """데이터베이스 관련 서비스"""
-
-    def __init__(self, db: Session):
-        self.db = db
-
-    # ===== Patient 관련 =====
-
-    def create_patient(self, patient_data: dict) -> Patient:
-        """환자 생성"""
-        patient = Patient(**patient_data)
-        self.db.add(patient)
-        self.db.commit()
-        self.db.refresh(patient)
-        return patient
-
-    def get_patient(self, patient_id: str) -> Patient:
-        """환자 조회"""
-        return self.db.query(Patient).filter(Patient.id == patient_id).first()
-
-    def get_all_patients(self):
-        """모든 환자 조회"""
-        return self.db.query(Patient).all()
-
-    # ===== Scenario 관련 =====
-
-    def create_scenario(self, scenario_data: dict) -> Scenario:
-        """시나리오 생성"""
-        scenario = Scenario(**scenario_data)
-        self.db.add(scenario)
-        self.db.commit()
-        self.db.refresh(scenario)
-        return scenario
-
-    def get_scenario(self, scenario_id: str) -> Scenario:
-        """시나리오 조회"""
-        return self.db.query(Scenario).filter(Scenario.id == scenario_id).first()
-
-    def get_scenarios_by_patient(self, patient_id: str):
-        """특정 환자의 모든 시나리오 조회"""
-        return self.db.query(Scenario).filter(Scenario.patient_id == patient_id).all()
-
-    def get_all_scenarios(self):
-        """모든 시나리오 조회"""
-        return self.db.query(Scenario).all()
-
-    # ===== HandoffRecord 관련 =====
-
-    def create_handoff_record(
-        self, student_id: str, scenario_id: str, sbar_data: dict, evaluation: dict, session_id: str = None
-    ) -> HandoffRecord:
-        """인수인계 기록 생성"""
-        record = HandoffRecord(
-            session_id=session_id,
-            student_id=student_id,
-            scenario_id=scenario_id,
-            situation=sbar_data.get("situation", ""),
-            background=sbar_data.get("background", ""),
-            assessment=sbar_data.get("assessment", ""),
-            recommendation=sbar_data.get("recommendation", ""),
-            total_score=evaluation.get("total_score", 0),
-            category_scores=evaluation.get("category_scores", {}),
-            strengths=evaluation.get("strengths", []),
-            improvements=evaluation.get("improvements", []),
-            detailed_feedback=evaluation.get("detailed_feedback", ""),
-        )
-        self.db.add(record)
-        self.db.commit()
-        self.db.refresh(record)
-        return record
-
-    def get_handoff_record(self, record_id: int) -> HandoffRecord:
-        """인수인계 기록 조회"""
-        return (
-            self.db.query(HandoffRecord).filter(HandoffRecord.id == record_id).first()
-        )
-
-    def get_records_by_student(self, student_id: str):
-        """특정 학생의 모든 인수인계 기록 조회"""
-        return (
-            self.db.query(HandoffRecord)
-            .filter(HandoffRecord.student_id == student_id)
-            .order_by(HandoffRecord.submitted_at.desc())
-            .all()
-        )
-
-    def get_records_by_scenario(self, scenario_id: str):
-        """특정 시나리오의 모든 인수인계 기록 조회"""
-        return (
-            self.db.query(HandoffRecord)
-            .filter(HandoffRecord.scenario_id == scenario_id)
-            .order_by(HandoffRecord.submitted_at.desc())
-            .all()
-        )
-
-    def get_all_handoff_records(self):
-        """모든 인수인계 기록 조회"""
-        return (
-            self.db.query(HandoffRecord)
-            .order_by(HandoffRecord.submitted_at.desc())
-            .all()
-        )
-
-    # ===== 통계 관련 =====
-
-    def get_student_statistics(self, student_id: str) -> dict:
-        """학생별 통계"""
-        records = self.get_records_by_student(student_id)
-
-        if not records:
-            return {
-                "total_submissions": 0,
-                "average_score": 0,
-                "highest_score": 0,
-                "lowest_score": 0,
-                "recent_submissions": [],
-            }
-
-        scores = [r.total_score for r in records if r.total_score is not None]
-
-        return {
-            "total_submissions": len(records),
-            "average_score": sum(scores) / len(scores) if scores else 0,
-            "highest_score": max(scores) if scores else 0,
-            "lowest_score": min(scores) if scores else 0,
-            "recent_submissions": [
-                {
-                    "id": r.id,
-                    "scenario_id": r.scenario_id,
-                    "score": r.total_score,
-                    "submitted_at": r.submitted_at.isoformat()
-                    if r.submitted_at
-                    else None,
-                }
-                for r in records[:5]  # 최근 5개
-            ],
-        }
-
-    def get_scenario_statistics(self, scenario_id: str) -> dict:
-        """시나리오별 통계"""
-        records = self.get_records_by_scenario(scenario_id)
-
-        if not records:
-            return {"total_attempts": 0, "average_score": 0, "score_distribution": {}}
-
-        scores = [r.total_score for r in records if r.total_score is not None]
-
-        # 점수 구간별 분포 (0-60: 미흡, 61-80: 보통, 81-100: 우수)
-        distribution = {
-            "excellent": len([s for s in scores if s >= 81]),
-            "good": len([s for s in scores if 61 <= s < 81]),
-            "needs_improvement": len([s for s in scores if s < 61]),
-        }
-
-        return {
-            "total_attempts": len(records),
-            "average_score": sum(scores) / len(scores) if scores else 0,
-            "score_distribution": distribution,
-        }
-
-    # ===== ChatHistory 관련 =====
-
-    def create_chat_session(self, student_id: str, scenario_id: str) -> str:
-        """새 채팅 세션 생성 및 세션 ID 반환"""
-        session_id = f"{student_id}_{scenario_id}_{uuid.uuid4().hex[:8]}"
-        return session_id
-
-    def save_chat_message(
-        self, session_id: str, student_id: str, scenario_id: str, role: str, message: str
-    ) -> ChatHistory:
-        """채팅 메시지 저장"""
-        chat = ChatHistory(
-            session_id=session_id,
-            student_id=student_id,
-            scenario_id=scenario_id,
-            role=role,
-            message=message,
-        )
-        self.db.add(chat)
-        self.db.commit()
-        self.db.refresh(chat)
-        return chat
-
-    def get_chat_history(self, session_id: str):
-        """특정 세션의 채팅 기록 조회"""
-        return (
-            self.db.query(ChatHistory)
-            .filter(ChatHistory.session_id == session_id)
-            .order_by(ChatHistory.timestamp.asc())
-            .all()
-        )
-
-    def get_chat_sessions_by_student(self, student_id: str):
-        """특정 학생의 모든 채팅 세션 조회"""
-        return (
-            self.db.query(ChatHistory.session_id, ChatHistory.scenario_id, ChatHistory.timestamp)
-            .filter(ChatHistory.student_id == student_id)
-            .distinct(ChatHistory.session_id)
-            .order_by(ChatHistory.session_id, ChatHistory.timestamp.desc())
-            .all()
-        )
-
-    # ===== SbarDraft 관련 =====
-
-    def save_draft_sbar(
-        self, session_id: str, student_id: str, scenario_id: str, sbar_data: dict
-    ) -> SbarDraft:
-        """작성 중인 SBAR 임시 저장"""
-        # 기존 draft가 있으면 업데이트, 없으면 생성
-        draft = self.db.query(SbarDraft).filter(SbarDraft.session_id == session_id).first()
-
-        if draft:
-            draft.situation = sbar_data.get("situation", "")
-            draft.background = sbar_data.get("background", "")
-            draft.assessment = sbar_data.get("assessment", "")
-            draft.recommendation = sbar_data.get("recommendation", "")
-        else:
-            draft = SbarDraft(
-                session_id=session_id,
-                student_id=student_id,
-                scenario_id=scenario_id,
-                situation=sbar_data.get("situation", ""),
-                background=sbar_data.get("background", ""),
-                assessment=sbar_data.get("assessment", ""),
-                recommendation=sbar_data.get("recommendation", ""),
-            )
-            self.db.add(draft)
-
-        self.db.commit()
-        self.db.refresh(draft)
-        return draft
-
-    def get_draft_sbar(self, session_id: str) -> dict:
-        """임시 저장된 SBAR 불러오기"""
-        draft = self.db.query(SbarDraft).filter(SbarDraft.session_id == session_id).first()
-
-        if draft:
-            return {
-                "situation": draft.situation or "",
-                "background": draft.background or "",
-                "assessment": draft.assessment or "",
-                "recommendation": draft.recommendation or "",
-            }
-        return {"situation": "", "background": "", "assessment": "", "recommendation": ""}
-
-
-def load_scenarios_to_db(db: Session, json_file_path: str):
-    """
-    JSON 파일에서 환자 및 시나리오 데이터를 읽어 DB에 저장
-    """
-    import json
-
-    with open(json_file_path, "r", encoding="utf-8") as f:
-        data = json.load(f)
-
-    db_service = DatabaseService(db)
-
-    # 환자 데이터 저장
-    patient_data = data["patient"]
-
-    # admission_date를 문자열에서 date 객체로 변환
-    if isinstance(patient_data.get("admission_date"), str):
-        patient_data["admission_date"] = datetime.strptime(
-            patient_data["admission_date"], "%Y-%m-%d"
-        ).date()
-
-    # 기존 환자가 없으면 생성
-    existing_patient = db_service.get_patient(patient_data["id"])
-    if not existing_patient:
-        db_service.create_patient(patient_data)
-        print(f"✅ 환자 생성: {patient_data['name']}")
-    else:
-        print(f"ℹ️  환자 이미 존재: {patient_data['name']}")
-
-    # 시나리오 데이터 저장
-    for scenario_data in data["scenarios"]:
-        existing_scenario = db_service.get_scenario(scenario_data["id"])
-        if not existing_scenario:
-            db_service.create_scenario(scenario_data)
-            print(f"✅ 시나리오 생성: {scenario_data['title']}")
-        else:
-            print(f"ℹ️  시나리오 이미 존재: {scenario_data['title']}")

services/gemini_service.py

@@ -380,3 +380,175 @@ class GeminiEvaluator:
 응답을 작성해주세요:
 """
         return prompt
+
+    def evaluate_conversation(
+        self,
+        chat_history: list,
+        scenario_data: dict,
+        patient_data: dict
+    ) -> dict:
+        """
+        전체 대화를 분석하여 질적 피드백 제공 (점수 없음)
+        
+        Args:
+            chat_history: 전체 대화 기록 [[user_msg, assistant_msg], ...]
+            scenario_data: 시나리오 데이터 (EMR 정보)
+            patient_data: 환자 기본 정보
+            
+        Returns:
+            평가 결과 딕셔너리 (점수 없이 질적 피드백만)
+        """
+        prompt = self._create_conversation_evaluation_prompt(
+            chat_history, scenario_data, patient_data
+        )
+        
+        try:
+            response = self.model.generate_content(
+                prompt,
+                generation_config={
+                    "temperature": 0.7,
+                    "top_p": 0.95,
+                    "max_output_tokens": 2048,
+                },
+            )
+            
+            # JSON 응답 파싱
+            result_text = response.text.strip()
+            
+            # Markdown 코드 블록 제거
+            if result_text.startswith("```"):
+                result_text = result_text.split("```")[1]
+                if result_text.startswith("json"):
+                    result_text = result_text[4:]
+                result_text = result_text.strip()
+            
+            evaluation = json.loads(result_text)
+            return evaluation
+            
+        except json.JSONDecodeError as e:
+            print(f"JSON 파싱 오류: {e}")
+            print(f"응답 텍스트: {response.text}")
+            return self._create_default_evaluation_conversation()
+        except Exception as e:
+            print(f"Gemini API 오류: {e}")
+            return self._create_default_evaluation_conversation()
+    
+    def _create_conversation_evaluation_prompt(
+        self, chat_history: list, scenario_data: dict, patient_data: dict
+    ) -> str:
+        """전체 대화 평가 프롬프트 생성"""
+        
+        # 전체 대화 내용 포맷팅
+        conversation_text = ""
+        for user_msg, bot_msg in chat_history:
+            if user_msg:
+                conversation_text += f"\n**학생**: {user_msg}\n"
+            if bot_msg:
+                conversation_text += f"\n**AI 교수**: {bot_msg}\n"
+        
+        prompt = f"""당신은 20년 경력의 한국 간호 교육 전문가이자 간호학 교수입니다. 
+간호 학생이 AI 교수와 나눈 대화를 분석하여 건설적인 종합 피드백을 제공해주세요.
+
+**중요**: 
+- 대화에서 "학생"이 적힌 부분이 실제 학습하는 간호 학생입니다.
+- "환자"는 EMR 정보에 나온 환자입니다.
+- 학생이 환자에 대한 인수인계 내용을 작성하는 것을 평가해주세요.
+
+## 📋 환자 정보 (EMR 데이터 - 학생이 인수인계해야 할 환자)
+- **환자명**: {patient_data.get('name')} ({patient_data.get('age')}세 {patient_data.get('gender')})
+- **진단명**: {patient_data.get('diagnosis')}
+- **입원일**: {patient_data.get('admission_date')}
+- **알레르기**: {patient_data.get('allergies')}
+
+## 🏥 인수인계 상황
+- **시나리오**: {scenario_data.get('title')}
+- **인계 상황**: {scenario_data.get('handoff_situation')}
+
+### 📊 활력징후 (Vital Signs)
+{json.dumps(scenario_data.get('vitals', {}), ensure_ascii=False, indent=2)}
+
+### 🧪 검사 결과 (Laboratory Results)
+{json.dumps(scenario_data.get('labs', {}), ensure_ascii=False, indent=2)}
+
+### 💊 의사 처방 (Physician Orders)
+{json.dumps(scenario_data.get('orders', []), ensure_ascii=False, indent=2)}
+
+### 📝 간호 기록 (Nursing Notes)
+{json.dumps(scenario_data.get('nursing_notes', []), ensure_ascii=False, indent=2)}
+
+---
+
+## 💬 학생과 AI 교수 간 대화 내용
+**학생이 작성한 인수인계 내용과 AI 교수의 피드백이 포함된 전체 대화:**
+
+{conversation_text if conversation_text else "(대화 없음)"}
+
+**위 대화에서 학생이 환자({patient_data.get('name')})에 대한 인수인계를 어떻게 작성했는지 분석하세요.**
+
+---
+
+## 📝 평가 가이드
+
+**중요:**
+- ❌ 점수를 매기지 마세요 (total_score, category_scores 사용 금지)
+- ✅ 질적 피드백에 집중하세요
+- ✅ 대화에서 나타난 강점을 구체적으로 언급하세요
+- ✅ 개선할 점을 건설적으로 제시하세요
+- ✅ 누락된 중요 정보를 파악하세요
+- ✅ 환자 안전과 관련된 주의사항을 강조하세요
+- ✅ 학습을 격려하는 톤을 유지하세요
+
+**평가 기준:**
+1. **완전성**: 필수 정보(환자 신원, 진단, 활력징후, 처방 등) 포함 여부
+2. **정확성**: 의료 정보의 정확성
+3. **명료성**: 의사소통의 명확성
+4. **우선순위**: 중요한 정보의 우선 전달
+5. **환자 안전**: 환자 안전�� 관련된 정보 강조
+
+---
+
+## 📤 출력 형식 (JSON)
+
+반드시 아래 JSON 형식으로만 응답하세요:
+
+```json
+{{
+  "strengths": [
+    "구체적으로 잘한 점 1",
+    "구체적으로 잘한 점 2",
+    "구체적으로 잘한 점 3"
+  ],
+  "improvements": [
+    "구체적으로 개선할 점 1",
+    "구체적으로 개선할 점 2",
+    "구체적으로 개선할 점 3"
+  ],
+  "detailed_feedback": "학생의 전반적인 학습 상태에 대한 종합적인 의견. 길게 작성하되 구체적으로.",
+  "missing_critical_info": [
+    "누락된 중요 정보 1",
+    "누락된 중요 정보 2"
+  ],
+  "safety_concerns": [
+    "환자 안전 관련 주의사항 1",
+    "환자 안전 관련 주의사항 2"
+  ]
+}}
+```
+
+**참고:**
+- 점수 필드(total_score, category_scores)는 포함하지 마세요
+- 배열 항목은 최소 2-3개 이상 작성하세요
+- detailed_feedback은 200자 이상 작성하세요
+- 한글로 작성하세요
+"""
+        return prompt
+    
+    def _create_default_evaluation_conversation(self) -> dict:
+        """평가 실패 시 기본 결과 반환 (점수 없이)"""
+        return {
+            "strengths": ["대화 내용을 분석했습니다."],
+            "improvements": ["평가 시스템 오류로 구체적인 피드백을 제공할 수 없습니다."],
+            "detailed_feedback": "평가 시스템에 문제가 발생했습니다. 나중에 다시 시도해주세요.",
+            "missing_critical_info": [],
+            "safety_concerns": []
+        }

services/supabase_service.py

@@ -0,0 +1,647 @@
+"""
+Supabase REST API 서비스
+
+Supabase Python Client를 활용한 CRUD 작업
+- Row Level Security (RLS) 자동 적용
+- 실시간 구독 지원
+- 자동 타입 변환
+"""
+
+from datetime import date, datetime
+from typing import Any, Dict, List, Optional
+
+from config.database import supabase_client
+
+
+class SupabaseService:
+    """Supabase REST API를 활용한 데이터베이스 서비스"""
+
+    def __init__(self):
+        if not supabase_client:
+            raise ValueError("Supabase 클라이언트가 초기화되지 않았습니다. 환경 변수를 확인하세요.")
+        self.client = supabase_client
+
+    # ===== Patient 관련 =====
+
+    def create_patient(self, patient_data: dict) -> Dict[str, Any]:
+        """
+        환자 생성
+        
+        Args:
+            patient_data: 환자 정보 딕셔너리
+            
+        Returns:
+            생성된 환자 데이터
+        """
+        # admission_date를 문자열로 변환
+        if isinstance(patient_data.get('admission_date'), date):
+            patient_data['admission_date'] = patient_data['admission_date'].isoformat()
+        
+        response = self.client.table('patients').insert(patient_data).execute()
+        return response.data[0] if response.data else None
+
+    def get_patient(self, patient_id: str) -> Optional[Dict[str, Any]]:
+        """
+        환자 조회
+        
+        Args:
+            patient_id: 환자 ID
+            
+        Returns:
+            환자 데이터 또는 None
+        """
+        response = self.client.table('patients')\
+            .select('*')\
+            .eq('id', patient_id)\
+            .execute()
+        
+        return response.data[0] if response.data else None
+
+    def get_all_patients(self) -> List[Dict[str, Any]]:
+        """
+        모든 환자 조회
+        
+        Returns:
+            환자 데이터 리스트
+        """
+        response = self.client.table('patients')\
+            .select('*')\
+            .order('created_at', desc=True)\
+            .execute()
+        
+        return response.data or []
+
+    def update_patient(self, patient_id: str, update_data: dict) -> Optional[Dict[str, Any]]:
+        """
+        환자 정보 업데이트
+        
+        Args:
+            patient_id: 환자 ID
+            update_data: 업데이트할 데이터
+            
+        Returns:
+            업데이트된 환자 데이터
+        """
+        response = self.client.table('patients')\
+            .update(update_data)\
+            .eq('id', patient_id)\
+            .execute()
+        
+        return response.data[0] if response.data else None
+
+    # ===== Scenario 관련 =====
+
+    def create_scenario(self, scenario_data: dict) -> Dict[str, Any]:
+        """
+        시나리오 생성
+        
+        Args:
+            scenario_data: 시나리오 정보 딕셔너리
+            
+        Returns:
+            생성된 시나리오 데이터
+        """
+        response = self.client.table('scenarios').insert(scenario_data).execute()
+        return response.data[0] if response.data else None
+
+    def get_scenario(self, scenario_id: str) -> Optional[Dict[str, Any]]:
+        """
+        시나리오 조회
+        
+        Args:
+            scenario_id: 시나리오 ID
+            
+        Returns:
+            시나리오 데이터 또는 None
+        """
+        response = self.client.table('scenarios')\
+            .select('*')\
+            .eq('id', scenario_id)\
+            .execute()
+        
+        return response.data[0] if response.data else None
+
+    def get_scenarios_by_patient(self, patient_id: str) -> List[Dict[str, Any]]:
+        """
+        특정 환자의 모든 시나리오 조회
+        
+        Args:
+            patient_id: 환자 ID
+            
+        Returns:
+            시나리오 데이터 리스트
+        """
+        response = self.client.table('scenarios')\
+            .select('*')\
+            .eq('patient_id', patient_id)\
+            .order('day')\
+            .execute()
+        
+        return response.data or []
+
+    def get_all_scenarios(self) -> List[Dict[str, Any]]:
+        """
+        모든 시나리오 조회
+        
+        Returns:
+            시나리오 데이터 리스트
+        """
+        response = self.client.table('scenarios')\
+            .select('*')\
+            .order('created_at', desc=True)\
+            .execute()
+        
+        return response.data or []
+
+    # ===== HandoffRecord 관련 =====
+
+    def create_handoff_record(
+        self,
+        student_id: str,
+        scenario_id: str,
+        sbar_data: dict,
+        evaluation: dict,
+        session_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        인수인계 기록 생성
+        
+        Args:
+            student_id: 학생 ID
+            scenario_id: 시나리오 ID
+            sbar_data: SBAR 데이터
+            evaluation: 평가 결과
+            session_id: 세션 ID (선택)
+            
+        Returns:
+            생성된 인수인계 기록
+        """
+        # 점수는 선택적 (대화 기반 평가에서는 NULL)
+        record_data = {
+            'session_id': session_id,
+            'student_id': student_id,
+            'scenario_id': scenario_id,
+            'situation': sbar_data.get('situation', '') if sbar_data else '',
+            'background': sbar_data.get('background', '') if sbar_data else '',
+            'assessment': sbar_data.get('assessment', '') if sbar_data else '',
+            'recommendation': sbar_data.get('recommendation', '') if sbar_data else '',
+            'total_score': evaluation.get('total_score'),  # NULL 허용
+            'category_scores': evaluation.get('category_scores'),  # NULL 허용
+            'strengths': evaluation.get('strengths', []),
+            'improvements': evaluation.get('improvements', []),
+            'detailed_feedback': evaluation.get('detailed_feedback', ''),
+            'missing_critical_info': evaluation.get('missing_critical_info', []),  # 새 필드
+            'safety_concerns': evaluation.get('safety_concerns', []),  # 새 필드
+        }
+        
+        response = self.client.table('handoff_records').insert(record_data).execute()
+        return response.data[0] if response.data else None
+
+    def get_handoff_record(self, record_id: int) -> Optional[Dict[str, Any]]:
+        """
+        인수인계 기록 조회
+        
+        Args:
+            record_id: 기록 IDㅂ
+            
+        Returns:
+            인수인계 기록 또는 None
+        """
+        response = self.client.table('handoff_records')\
+            .select('*')\
+            .eq('id', record_id)\
+            .execute()
+        
+        return response.data[0] if response.data else None
+
+    def get_records_by_student(self, student_id: str) -> List[Dict[str, Any]]:
+        """
+        특정 학생의 모든 인수인계 기록 조회
+        
+        Args:
+            student_id: 학생 ID
+            
+        Returns:
+            인수인계 기록 리스트
+        """
+        response = self.client.table('handoff_records')\
+            .select('*')\
+            .eq('student_id', student_id)\
+            .order('submitted_at', desc=True)\
+            .execute()
+        
+        return response.data or []
+
+    def get_records_by_scenario(self, scenario_id: str) -> List[Dict[str, Any]]:
+        """
+        특정 시나리오의 모든 인수인계 기록 조회
+        
+        Args:
+            scenario_id: 시나리오 ID
+            
+        Returns:
+            인수인계 기록 리스트
+        """
+        response = self.client.table('handoff_records')\
+            .select('*')\
+            .eq('scenario_id', scenario_id)\
+            .order('submitted_at', desc=True)\
+            .execute()
+        
+        return response.data or []
+
+    # ===== ChatHistory 관련 =====
+
+    def save_chat_message(
+        self,
+        session_id: str,
+        student_id: str,
+        scenario_id: str,
+        role: str,
+        message: str
+    ) -> Dict[str, Any]:
+        """
+        채팅 메시지 저장
+        
+        Args:
+            session_id: 세션 ID
+            student_id: 학생 ID
+            scenario_id: 시나리오 ID
+            role: 역할 ('user' 또는 'assistant')
+            message: 메시지 내용
+            
+        Returns:
+            저장된 채팅 메시지
+        """
+        chat_data = {
+            'session_id': session_id,
+            'student_id': student_id,
+            'scenario_id': scenario_id,
+            'role': role,
+            'message': message,
+        }
+        
+        response = self.client.table('chat_history').insert(chat_data).execute()
+        return response.data[0] if response.data else None
+
+    def get_chat_history(self, session_id: str) -> List[Dict[str, Any]]:
+        """
+        특정 세션의 채팅 기록 조회
+        
+        Args:
+            session_id: 세션 ID
+            
+        Returns:
+            채팅 메시지 리스트
+        """
+        response = self.client.table('chat_history')\
+            .select('*')\
+            .eq('session_id', session_id)\
+            .order('timestamp')\
+            .execute()
+        
+        return response.data or []
+
+    def get_chat_sessions_by_student(self, student_id: str) -> List[Dict[str, Any]]:
+        """
+        특정 학생의 모든 채팅 세션 조회
+        
+        Args:
+            student_id: 학생 ID
+            
+        Returns:
+            채팅 세션 리스트
+        """
+        response = self.client.table('chat_history')\
+            .select('session_id, scenario_id, timestamp')\
+            .eq('student_id', student_id)\
+            .order('timestamp', desc=True)\
+            .execute()
+        
+        # 중복 제거 (세션별로 그룹화)
+        sessions = {}
+        for chat in response.data or []:
+            session_id = chat['session_id']
+            if session_id not in sessions:
+                sessions[session_id] = chat
+        
+        return list(sessions.values())
+
+    # ===== SbarDraft 관련 =====
+
+    def save_draft_sbar(
+        self,
+        session_id: str,
+        student_id: str,
+        scenario_id: str,
+        sbar_data: dict
+    ) -> Dict[str, Any]:
+        """
+        작성 중인 SBAR 임시 저장 (Upsert)
+        
+        Args:
+            session_id: 세션 ID
+            student_id: 학생 ID
+            scenario_id: 시나리오 ID
+            sbar_data: SBAR 데이터
+            
+        Returns:
+            저장된 SBAR 초안
+        """
+        draft_data = {
+            'session_id': session_id,
+            'student_id': student_id,
+            'scenario_id': scenario_id,
+            'situation': sbar_data.get('situation', ''),
+            'background': sbar_data.get('background', ''),
+            'assessment': sbar_data.get('assessment', ''),
+            'recommendation': sbar_data.get('recommendation', ''),
+        }
+        
+        # Upsert: session_id가 있으면 업데이트, 없으면 삽입
+        response = self.client.table('sbar_drafts')\
+            .upsert(draft_data, on_conflict='session_id')\
+            .execute()
+        
+        return response.data[0] if response.data else None
+
+    def get_draft_sbar(self, session_id: str) -> Dict[str, str]:
+        """
+        임시 저장된 SBAR 불러오기
+        
+        Args:
+            session_id: 세션 ID
+            
+        Returns:
+            SBAR 데이터 딕셔너리
+        """
+        response = self.client.table('sbar_drafts')\
+            .select('*')\
+            .eq('session_id', session_id)\
+            .execute()
+        
+        if response.data:
+            draft = response.data[0]
+            return {
+                'situation': draft.get('situation', ''),
+                'background': draft.get('background', ''),
+                'assessment': draft.get('assessment', ''),
+                'recommendation': draft.get('recommendation', ''),
+            }
+        
+        return {
+            'situation': '',
+            'background': '',
+            'assessment': '',
+            'recommendation': '',
+        }
+
+    # ===== 통계 관련 =====
+
+    def get_student_statistics(self, student_id: str) -> dict:
+        """
+        학생별 통계
+        
+        Args:
+            student_id: 학생 ID
+            
+        Returns:
+            통계 데이터
+        """
+        records = self.get_records_by_student(student_id)
+        
+        if not records:
+            return {
+                'total_submissions': 0,
+                'average_score': 0,
+                'highest_score': 0,
+                'lowest_score': 0,
+                'recent_submissions': [],
+            }
+        
+        scores = [r['total_score'] for r in records if r.get('total_score') is not None]
+        
+        return {
+            'total_submissions': len(records),
+            'average_score': sum(scores) / len(scores) if scores else 0,
+            'highest_score': max(scores) if scores else 0,
+            'lowest_score': min(scores) if scores else 0,
+            'recent_submissions': [
+                {
+                    'id': r['id'],
+                    'scenario_id': r['scenario_id'],
+                    'score': r['total_score'],
+                    'submitted_at': r.get('submitted_at'),
+                }
+                for r in records[:5]  # 최근 5개
+            ],
+        }
+
+    def get_scenario_statistics(self, scenario_id: str) -> dict:
+        """
+        시나리오별 통계
+        
+        Args:
+            scenario_id: 시나리오 ID
+            
+        Returns:
+            통계 데이터
+        """
+        records = self.get_records_by_scenario(scenario_id)
+        
+        if not records:
+            return {
+                'total_attempts': 0,
+                'average_score': 0,
+                'score_distribution': {},
+            }
+        
+        scores = [r['total_score'] for r in records if r.get('total_score') is not None]
+        
+        # 점수 구간별 분포
+        distribution = {
+            'excellent': len([s for s in scores if s >= 81]),
+            'good': len([s for s in scores if 61 <= s < 81]),
+            'needs_improvement': len([s for s in scores if s < 61]),
+        }
+        
+        return {
+            'total_attempts': len(records),
+            'average_score': sum(scores) / len(scores) if scores else 0,
+            'score_distribution': distribution,
+        }
+
+    # ===== 실시간 구독 (선택적) =====
+
+    def subscribe_to_chat(self, session_id: str, callback):
+        """
+        채팅 메시지 실시간 구독
+        
+        Args:
+            session_id: 세션 ID
+            callback: 새 메시지 수신 시 호출할 콜백 함수
+        """
+        channel = self.client.channel(f'chat_{session_id}')
+        
+        channel.on_postgres_changes(
+            event='INSERT',
+            schema='public',
+            table='chat_history',
+            filter=f'session_id=eq.{session_id}',
+            callback=callback
+        ).subscribe()
+        
+        return channel
+
+    # ===== 시나리오 로드 및 세션 관리 =====
+
+    def create_chat_session(self, student_id: str, scenario_id: str) -> str:
+        """
+        새 채팅 세션 생성 및 세션 ID 반환 (TSID 사용)
+        
+        Args:
+            student_id: 학생 ID
+            scenario_id: 시나리오 ID
+            
+        Returns:
+            session_id: TSID 기반 세션 ID
+        """
+        from tsidpy import TSID
+
+        # TSID를 사용하여 시간 정렬 가능한 고유 ID 생성
+        tsid = TSID.create()
+        session_id = f"ses_{tsid.to_string()}"
+        
+        # 세션을 데이터베이스에 저장
+        try:
+            session_data = {
+                'session_id': session_id,
+                'student_id': student_id,
+                'scenario_id': scenario_id,
+                'status': 'active',
+                'started_at': 'now()'
+            }
+            
+            # 세션 테이블이 있다면 저장 (없으면 그냥 ID만 반환)
+            try:
+                self.client.table('sessions').insert(session_data).execute()
+            except Exception:
+                # sessions 테이블이 없을 경우 무시
+                pass
+                
+        except Exception as e:
+            print(f"⚠️  세션 저장 실패 (ID만 사용): {e}")
+        
+        return session_id
+
+    def get_session(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """
+        세션 조회
+        
+        Args:
+            session_id: 세션 ID
+            
+        Returns:
+            세션 데이터 또는 None
+        """
+        try:
+            response = self.client.table('sessions')\
+                .select('*')\
+                .eq('session_id', session_id)\
+                .execute()
+            
+            return response.data[0] if response.data else None
+        except Exception:
+            return None
+
+    def update_session_status(self, session_id: str, status: str):
+        """
+        세션 상태 업데이트
+        
+        Args:
+            session_id: 세션 ID
+            status: 상태 ('active', 'completed', 'archived')
+        """
+        try:
+            # sessions 테이블이 있을 때만 업데이트 시도
+            self.client.table('sessions')\
+                .update({'status': status})\
+                .eq('session_id', session_id)\
+                .execute()
+        except Exception as e:
+            # sessions 테이블이 없는 경우 무시 (선택적 기능)
+            pass
+
+    def get_active_sessions_by_student(self, student_id: str) -> List[Dict[str, Any]]:
+        """
+        학생의 활성 세션 목록 조회
+        
+        Args:
+            student_id: 학생 ID
+            
+        Returns:
+            세션 데이터 리스트
+        """
+        try:
+            response = self.client.table('sessions')\
+                .select('*')\
+                .eq('student_id', student_id)\
+                .eq('status', 'active')\
+                .order('started_at', desc=True)\
+                .execute()
+            
+            return response.data or []
+        except Exception:
+            return []
+
+    def load_scenarios_from_json(self, json_file_path: str):
+        """
+        JSON 파일에서 환자 및 시나리오 데이터를 읽어 Supabase에 저장
+        
+        Args:
+            json_file_path: JSON 파일 경로
+        """
+        import json
+        from datetime import datetime
+
+        with open(json_file_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+
+        # 환자 데이터 저장
+        patient_data = data["patient"]
+
+        # admission_date를 문자열에서 date 객체로 변환
+        if isinstance(patient_data.get("admission_date"), str):
+            patient_data["admission_date"] = datetime.strptime(
+                patient_data["admission_date"], "%Y-%m-%d"
+            ).date()
+
+        # 기존 환자가 없으면 생성
+        existing_patient = self.get_patient(patient_data["id"])
+        if not existing_patient:
+            self.create_patient(patient_data)
+            print(f"✅ 환자 생성: {patient_data['name']}")
+        else:
+            print(f"ℹ️  환자 이미 존재: {patient_data['name']}")
+
+        # 시나리오 데이터 저장
+        for scenario_data in data["scenarios"]:
+            existing_scenario = self.get_scenario(scenario_data["id"])
+            if not existing_scenario:
+                self.create_scenario(scenario_data)
+                print(f"✅ 시나리오 생성: {scenario_data['title']}")
+            else:
+                print(f"ℹ️  시나리오 이미 존재: {scenario_data['title']}")
+
+    def get_statistics_for_handoff(self, student_id: str) -> dict:
+        """
+        학생별 통계 (하위 호환성 유지)
+        
+        Args:
+            student_id: 학생 ID
+            
+        Returns:
+            통계 데이터
+        """
+        return self.get_student_statistics(student_id)
+

start.sh

@@ -3,19 +3,33 @@
 echo "🏥 간호 인수인계 교육 플랫폼 시작..."
 echo ""
 
-# 1. PostgreSQL 시작
-echo "📦 PostgreSQL 컨테이너 시작 중..."
-docker-compose up -d
+# 환경 변수 확인
+if [ -f .env ]; then
+    export $(cat .env | grep -v '^#' | xargs)
+fi
 
-# 2. PostgreSQL 준비 대기
-echo "⏳ PostgreSQL 준비 대기 중..."
-sleep 5
+# 1. 데이터베이스 설정 확인
+if [ -n "$SUPABASE_DB_URL" ]; then
+    echo "🔗 Supabase 모드로 실행합니다..."
+    USE_LOCAL_POSTGRES=false
+else
+    echo "🔗 로컬 PostgreSQL 모드로 실행합니다..."
+    USE_LOCAL_POSTGRES=true
+    
+    # PostgreSQL 시작
+    echo "📦 PostgreSQL 컨테이너 시작 중..."
+    docker-compose up -d
+    
+    # PostgreSQL 준비 대기
+    echo "⏳ PostgreSQL 준비 대기 중..."
+    sleep 5
+fi
 
-# 3. 데이터베이스 초기화
+# 2. 데이터베이스 초기화
 echo "🗄️  데이터베이스 초기화 중..."
 uv run init_db.py 
 
-# 4. Gradio 앱 실행
+# 3. Gradio 앱 실행
 echo ""
 echo "🚀 Gradio 애플리케이션 시작..."
 echo "브라우저에서 http://localhost:7860 으로 접속하세요."

supabase_init.sql

@@ -0,0 +1,331 @@
+-- =====================================================
+-- Supabase 초기 설정 통합 스크립트
+-- 간호 인수인계 교육 플랫폼
+-- 실행 순서: 이 파일을 Supabase SQL Editor에서 한 번만 실행하세요
+-- =====================================================
+
+-- =====================================================
+-- 1. 기본 테이블 생성
+-- =====================================================
+
+-- 1.1 patients 테이블 (환자 기본 정보)
+CREATE TABLE IF NOT EXISTS patients (
+    id VARCHAR(50) PRIMARY KEY,
+    name VARCHAR(100) NOT NULL,
+    age INTEGER NOT NULL,
+    gender VARCHAR(10) NOT NULL,
+    weight INTEGER,
+    height INTEGER,
+    diagnosis VARCHAR(200) NOT NULL,
+    admission_date DATE NOT NULL,
+    attending_physician VARCHAR(100),
+    allergies VARCHAR(200),
+    comorbidities TEXT,
+    room_number VARCHAR(20),
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+COMMENT ON TABLE patients IS '환자 기본 정보';
+COMMENT ON COLUMN patients.id IS '환자 ID (예: P001)';
+COMMENT ON COLUMN patients.name IS '환자 이름';
+COMMENT ON COLUMN patients.age IS '나이';
+COMMENT ON COLUMN patients.gender IS '성별 (남/여)';
+COMMENT ON COLUMN patients.diagnosis IS '진단명';
+COMMENT ON COLUMN patients.admission_date IS '입원일';
+COMMENT ON COLUMN patients.allergies IS '알레르기';
+
+-- 1.2 scenarios 테이블 (인수인계 시나리오)
+CREATE TABLE IF NOT EXISTS scenarios (
+    id VARCHAR(50) PRIMARY KEY,
+    patient_id VARCHAR(50) NOT NULL REFERENCES patients(id) ON DELETE CASCADE,
+    title VARCHAR(200) NOT NULL,
+    day INTEGER NOT NULL,
+    handoff_situation VARCHAR(200),
+    vitals JSONB,
+    labs JSONB,
+    orders JSONB,
+    nursing_notes JSONB,
+    physical_exam JSONB,
+    imaging JSONB,
+    surgery_info JSONB,
+    discharge_education JSONB,
+    hospital_day INTEGER,
+    status_badge VARCHAR(20),
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+COMMENT ON TABLE scenarios IS '인수인계 시나리오';
+COMMENT ON COLUMN scenarios.id IS '시나리오 ID (예: S001_D0_ER_WARD)';
+COMMENT ON COLUMN scenarios.patient_id IS '환자 ID (외래키)';
+COMMENT ON COLUMN scenarios.title IS '시나리오 제목';
+COMMENT ON COLUMN scenarios.day IS '재원 일수 (0, 1, 2...)';
+COMMENT ON COLUMN scenarios.handoff_situation IS '인수인계 상황 (예: 응급실→병동)';
+
+-- 1.3 handoff_records 테이블 (인수인계 기록 및 평가)
+-- 대화 기반 평가를 고려하여 NULL 허용
+CREATE TABLE IF NOT EXISTS handoff_records (
+    id SERIAL PRIMARY KEY,
+    session_id VARCHAR(100),
+    student_id VARCHAR(50) NOT NULL,
+    scenario_id VARCHAR(50) NOT NULL REFERENCES scenarios(id) ON DELETE CASCADE,
+    submitted_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    situation TEXT,
+    background TEXT,
+    assessment TEXT,
+    recommendation TEXT,
+    total_score FLOAT,
+    category_scores JSONB,
+    strengths JSONB,
+    improvements JSONB,
+    detailed_feedback TEXT,
+    -- 대화 기반 평가용 컬럼
+    missing_critical_info JSONB,
+    safety_concerns JSONB
+);
+
+COMMENT ON TABLE handoff_records IS '학생의 인수인계 기록 및 AI 평가 결과';
+COMMENT ON COLUMN handoff_records.session_id IS '채팅 세션 ID';
+COMMENT ON COLUMN handoff_records.student_id IS '학생 식별자';
+COMMENT ON COLUMN handoff_records.scenario_id IS '시나리오 ID (외래키)';
+COMMENT ON COLUMN handoff_records.missing_critical_info IS '누락된 중요 정보 목록';
+COMMENT ON COLUMN handoff_records.safety_concerns IS '환자 안전 관련 주의사항 목록';
+
+-- 1.4 chat_history 테이블 (학생과 AI 간의 채팅 기록)
+CREATE TABLE IF NOT EXISTS chat_history (
+    id SERIAL PRIMARY KEY,
+    session_id VARCHAR(100) NOT NULL,
+    student_id VARCHAR(50) NOT NULL,
+    scenario_id VARCHAR(50) NOT NULL,
+    role VARCHAR(20) NOT NULL CHECK (role IN ('user', 'assistant')),
+    message TEXT NOT NULL,
+    timestamp TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+COMMENT ON TABLE chat_history IS '학생과 AI 간의 채팅 기록';
+
+-- 1.5 sbar_drafts 테이블 (작성 중인 SBAR 임시 저장)
+CREATE TABLE IF NOT EXISTS sbar_drafts (
+    id SERIAL PRIMARY KEY,
+    session_id VARCHAR(100) NOT NULL UNIQUE,
+    student_id VARCHAR(50) NOT NULL,
+    scenario_id VARCHAR(50) NOT NULL,
+    situation TEXT DEFAULT '',
+    background TEXT DEFAULT '',
+    assessment TEXT DEFAULT '',
+    recommendation TEXT DEFAULT '',
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+COMMENT ON TABLE sbar_drafts IS '작성 중인 SBAR 임시 저장';
+
+-- 1.6 sessions 테이블 (세션 관리)
+CREATE TABLE IF NOT EXISTS sessions (
+    id SERIAL PRIMARY KEY,
+    session_id VARCHAR(50) UNIQUE NOT NULL,
+    student_id VARCHAR(50) NOT NULL,
+    scenario_id VARCHAR(50) NOT NULL,
+    status VARCHAR(20) DEFAULT 'active',
+    started_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    ended_at TIMESTAMP WITH TIME ZONE,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+COMMENT ON TABLE sessions IS 'TSID 기반 채팅 세션 관리 테이블';
+COMMENT ON COLUMN sessions.session_id IS 'TSID 기반 세션 식별자 (ses_XXXXX 형식)';
+COMMENT ON COLUMN sessions.status IS '세션 상태: active, completed, archived';
+
+-- =====================================================
+-- 2. 인덱스 생성 (성능 최적화)
+-- =====================================================
+
+-- handoff_records 인덱스
+CREATE INDEX IF NOT EXISTS idx_handoff_records_student ON handoff_records(student_id);
+CREATE INDEX IF NOT EXISTS idx_handoff_records_scenario ON handoff_records(scenario_id);
+CREATE INDEX IF NOT EXISTS idx_handoff_records_session ON handoff_records(session_id);
+CREATE INDEX IF NOT EXISTS idx_handoff_records_submitted ON handoff_records(submitted_at DESC);
+
+-- chat_history 인덱스
+CREATE INDEX IF NOT EXISTS idx_chat_history_session ON chat_history(session_id);
+CREATE INDEX IF NOT EXISTS idx_chat_history_student ON chat_history(student_id);
+CREATE INDEX IF NOT EXISTS idx_chat_history_timestamp ON chat_history(timestamp);
+
+-- sbar_drafts 인덱스
+CREATE INDEX IF NOT EXISTS idx_sbar_drafts_session ON sbar_drafts(session_id);
+CREATE INDEX IF NOT EXISTS idx_sbar_drafts_student ON sbar_drafts(student_id);
+
+-- scenarios 인덱스
+CREATE INDEX IF NOT EXISTS idx_scenarios_patient ON scenarios(patient_id);
+CREATE INDEX IF NOT EXISTS idx_scenarios_day ON scenarios(day);
+
+-- sessions 인덱스
+CREATE INDEX IF NOT EXISTS idx_sessions_student_id ON sessions(student_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_scenario_id ON sessions(scenario_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+CREATE INDEX IF NOT EXISTS idx_sessions_started_at ON sessions(started_at DESC);
+
+-- =====================================================
+-- 3. 트리거 함수 및 트리거 생성
+-- =====================================================
+
+-- updated_at 자동 업데이트 함수
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = NOW();
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+-- 세션 종료 시 ended_at 자동 업데이트 함수
+CREATE OR REPLACE FUNCTION update_session_ended_at()
+RETURNS TRIGGER AS $$
+BEGIN
+    IF NEW.status = 'completed' OR NEW.status = 'archived' THEN
+        IF NEW.ended_at IS NULL THEN
+            NEW.ended_at = NOW();
+        END IF;
+    END IF;
+    NEW.updated_at = NOW();
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+-- 트리거 생성
+CREATE TRIGGER update_patients_updated_at 
+    BEFORE UPDATE ON patients
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+CREATE TRIGGER update_scenarios_updated_at 
+    BEFORE UPDATE ON scenarios
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+CREATE TRIGGER update_sbar_drafts_updated_at 
+    BEFORE UPDATE ON sbar_drafts
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+CREATE TRIGGER update_sessions_updated_at
+    BEFORE UPDATE ON sessions
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+CREATE TRIGGER update_session_on_status_change
+    BEFORE UPDATE ON sessions
+    FOR EACH ROW
+    WHEN (OLD.status IS DISTINCT FROM NEW.status)
+    EXECUTE FUNCTION update_session_ended_at();
+
+-- =====================================================
+-- 4. Row Level Security (RLS) 설정
+-- =====================================================
+
+-- RLS 활성화
+ALTER TABLE patients ENABLE ROW LEVEL SECURITY;
+ALTER TABLE scenarios ENABLE ROW LEVEL SECURITY;
+ALTER TABLE handoff_records ENABLE ROW LEVEL SECURITY;
+ALTER TABLE chat_history ENABLE ROW LEVEL SECURITY;
+ALTER TABLE sbar_drafts ENABLE ROW LEVEL SECURITY;
+ALTER TABLE sessions ENABLE ROW LEVEL SECURITY;
+
+-- 기존 정책 삭제 (중복 방지)
+DO $$ 
+BEGIN
+    -- Chat History 정책 삭제
+    DROP POLICY IF EXISTS "Allow all for chat_history" ON chat_history;
+    DROP POLICY IF EXISTS "Allow all operations for anon users on chat_history" ON chat_history;
+    DROP POLICY IF EXISTS "Allow all operations for authenticated users on chat_history" ON chat_history;
+    DROP POLICY IF EXISTS "Enable all access for chat_history" ON chat_history;
+    DROP POLICY IF EXISTS "chat_history_all_access" ON chat_history;
+    
+    -- Handoff Records 정책 삭제
+    DROP POLICY IF EXISTS "Allow all for handoff_records" ON handoff_records;
+    DROP POLICY IF EXISTS "Allow all operations for anon users on handoff_records" ON handoff_records;
+    DROP POLICY IF EXISTS "Allow all operations for authenticated users on handoff_records" ON handoff_records;
+    DROP POLICY IF EXISTS "Enable all access for handoff_records" ON handoff_records;
+    DROP POLICY IF EXISTS "handoff_records_all_access" ON handoff_records;
+    
+    -- SBAR Drafts 정책 삭제
+    DROP POLICY IF EXISTS "Allow all for sbar_drafts" ON sbar_drafts;
+    DROP POLICY IF EXISTS "Allow all operations for anon users on sbar_drafts" ON sbar_drafts;
+    DROP POLICY IF EXISTS "Allow all operations for authenticated users on sbar_drafts" ON sbar_drafts;
+    DROP POLICY IF EXISTS "Enable all access for sbar_drafts" ON sbar_drafts;
+    DROP POLICY IF EXISTS "sbar_drafts_all_access" ON sbar_drafts;
+    
+    -- Patients 정책 삭제
+    DROP POLICY IF EXISTS "Allow read access for all users" ON patients;
+    DROP POLICY IF EXISTS "Allow all for patients" ON patients;
+    DROP POLICY IF EXISTS "Allow all operations for anon users on patients" ON patients;
+    DROP POLICY IF EXISTS "Allow all operations for authenticated users on patients" ON patients;
+    DROP POLICY IF EXISTS "Enable all operations for anon users" ON patients;
+    DROP POLICY IF EXISTS "Enable all operations for authenticated users" ON patients;
+    DROP POLICY IF EXISTS "patients_all_access" ON patients;
+    
+    -- Scenarios 정책 삭제
+    DROP POLICY IF EXISTS "Allow read access for all users" ON scenarios;
+    DROP POLICY IF EXISTS "Allow all for scenarios" ON scenarios;
+    DROP POLICY IF EXISTS "Allow all operations for anon users on scenarios" ON scenarios;
+    DROP POLICY IF EXISTS "Allow all operations for authenticated users on scenarios" ON scenarios;
+    DROP POLICY IF EXISTS "Enable all operations for anon users" ON scenarios;
+    DROP POLICY IF EXISTS "Enable all operations for authenticated users" ON scenarios;
+    DROP POLICY IF EXISTS "scenarios_all_access" ON scenarios;
+    
+    -- Sessions 정책 삭제
+    DROP POLICY IF EXISTS "Enable all operations for anon users" ON sessions;
+    DROP POLICY IF EXISTS "Enable all operations for authenticated users" ON sessions;
+    DROP POLICY IF EXISTS "sessions_all_access" ON sessions;
+END $$;
+
+-- 새 정책 생성 (모든 사용자 접근 허용)
+CREATE POLICY "patients_all_access" ON patients 
+    FOR ALL USING (true) WITH CHECK (true);
+
+CREATE POLICY "scenarios_all_access" ON scenarios 
+    FOR ALL USING (true) WITH CHECK (true);
+
+CREATE POLICY "handoff_records_all_access" ON handoff_records 
+    FOR ALL USING (true) WITH CHECK (true);
+
+CREATE POLICY "chat_history_all_access" ON chat_history 
+    FOR ALL USING (true) WITH CHECK (true);
+
+CREATE POLICY "sbar_drafts_all_access" ON sbar_drafts 
+    FOR ALL USING (true) WITH CHECK (true);
+
+CREATE POLICY "sessions_all_access" ON sessions 
+    FOR ALL USING (true) WITH CHECK (true);
+
+-- =====================================================
+-- 완료 메시지
+-- =====================================================
+
+DO $$
+BEGIN
+    RAISE NOTICE '';
+    RAISE NOTICE '╔══════════════════════════════════════════════════════════════╗';
+    RAISE NOTICE '║  ✅ Supabase 초기 설정 완료!                                  ║';
+    RAISE NOTICE '╚══════════════════════════════════════════════════════════════╝';
+    RAISE NOTICE '';
+    RAISE NOTICE '📊 생성된 테이블:';
+    RAISE NOTICE '   - patients (환자 정보)';
+    RAISE NOTICE '   - scenarios (시나리오)';
+    RAISE NOTICE '   - handoff_records (인수인계 기록)';
+    RAISE NOTICE '   - chat_history (채팅 기록)';
+    RAISE NOTICE '   - sbar_drafts (SBAR 초안)';
+    RAISE NOTICE '   - sessions (세션 관리)';
+    RAISE NOTICE '';
+    RAISE NOTICE '🔒 RLS 정책: 모든 테이블에 전체 접근 허용';
+    RAISE NOTICE '📈 인덱스: 성능 최적화 완료';
+    RAISE NOTICE '⚙️  트리거: 자동 updated_at 업데이트 및 세션 종료 처리';
+    RAISE NOTICE '';
+    RAISE NOTICE '📋 다음 단계:';
+    RAISE NOTICE '   1. uv run scripts/init_db.py - 시나리오 데이터 로드';
+    RAISE NOTICE '   2. uv run test_supabase_connection.py - 연결 테스트';
+    RAISE NOTICE '   3. uv run app.py - 앱 실행';
+    RAISE NOTICE '';
+END $$;
+