Update app.py

app.py

@@ -1,152 +1,1799 @@
-def main():
-    from dotenv import load_dotenv
-    load_dotenv()
-
-    # Step_1 : Setup UI with streamlit (model provider, model, system prompt, web search query)
-    import requests
-    import streamlit as st
-    from streamlit_lottie import st_lottie
-
-    # ---------- Page Configuration ----------
-    st.set_page_config(
-        page_title="LangGraph AI Chatbot",
-        layout="centered",
-        initial_sidebar_state="collapsed"
-    )
-
-    # ----------------- CUSTOM CSS ------------------
-    st.markdown(
-        """
-        <style>
-            body {
-                background-color: #111827;
-                color: #d1d5db;
-                font-family: 'Segoe UI', sans-serif;
-            }
-            .sidebar-content {
-                background-color: #1f2937;
-                padding: 20px;
-            }
-            .chat-message {
-                padding: 10px;
-                border-radius: 10px;
-                margin-bottom: 10px;
-                font-size: 16px;
-            }
-            .user-message {
-                background-color: #374151;
-            }
-            .bot-message {
-                background-color: #4b5563;
-            }
-            .avatar {
-                width: 30px;
-                height: 30px;
-                border-radius: 50%;
-                margin-right: 10px;
-            }
-            button[kind="primary"] {
-                background-color: #10b981;
-                color: white;
-                border-radius: 10px;
-                border: none;
-            }
-        </style>
-        """,
-        unsafe_allow_html=True
-    )
-
-    # ---------- Lottie Animation ----------
-    def load_lottie_url(url: str):
-        r = requests.get(url)
-        if r.status_code != 200:
-            return None
-        return r.json()
-
-    lottie_ai = load_lottie_url("https://assets10.lottiefiles.com/packages/lf20_kkflmtur.json")
-    st_lottie(lottie_ai, height=200)
-
-
-    # ---------- Avatar Config ----------
-    USER_AVATAR = "https://cdn-icons-png.flaticon.com/512/9131/9131529.png"
-    AGENT_AVATAR = "https://cdn-icons-png.flaticon.com/512/4712/4712100.png"
-
-
-    # ---------- Title and Prompt ----------
-    st.title("AI Chatbot")
-    st.caption("Ask your AI agent anything — powered by Groq and LangGraph!")
-
-    # ---------- Initialize Session State ----------
-    if "chat_history" not in st.session_state:
-        st.session_state.chat_history = []
-
-    # ---------- Inputs ----------
-    MODEL_NAMES_GROQ = ["llama-3.3-70b-versatile", "llama3-70b-8192"]
-    system_prompt = st.text_area("Define your AI Agent : ", height=68, placeholder="Type your system prompt here...")
-    select_model  = st.selectbox("Select Model  (Groq Only) : ", MODEL_NAMES_GROQ)
-    allow_web_search = st.checkbox("Allow Web Search")
-    user_query = st.text_area("Enter you query :", height=150, placeholder="Ask Anything!")
-
-    API_URL = "https://ai-agent-backend-uzhn.onrender.com/chat"
-
-    # ---------- Chat History Display ----------
-    for entry in st.session_state.chat_history:
-        with st.chat_message("user", avatar=USER_AVATAR):
-            st.markdown(entry["user"])
-        with st.chat_message("assistant", avatar=AGENT_AVATAR):
-            st.markdown(entry["agent"])
-
-    # ---------- Submit Button ----------
-    if st.button("Ask Agent!"):
-        if user_query.strip():
-            # Step_2 : Connect with backend via URL
-        
-            payload = {
-                "model_name" : select_model,
-                "system_prompt" : system_prompt,
-                "messages" : [user_query],
-                "allow_search" : allow_web_search
-            }
-            with st.spinner("Thinking... 💭"):
-                try:
-                    response = requests.post(API_URL, json=payload)
-
-                    if response.status_code == 200:
-                        try:
-                            response_data = response.json()
-                        except ValueError:
-                            st.error("⚠️ Unable to parse the server response.")
-                            response_data = {"response": response.text}
-
-                        if isinstance(response_data, dict) and "error" in response_data:
-                                st.error(response_data["error"])
-                        else:
-                            final_response = (
-                                response_data if isinstance(response_data, str)
-                                else response_data .get("response", str(response_data))
-                            )
-
-                        # Display new message
-                        with st.chat_message("user", avatar=USER_AVATAR):
-                            st.markdown(user_query)
-                        with st.chat_message("assistant", avatar=AGENT_AVATAR):
-                            st.markdown(final_response)
-
-                        # Feedback section
-                        feedback = st.radio("Was this helpful?", ["👍 Yes", "👎 No"], horizontal=True)
-                        # Export option
-                        st.download_button(
-                            label = "📄 Download Response",
-                            data = final_response,
-                            file_name = "agent_response.txt",
-                            mime = "text/plain"
-                    )
-                    else:
-                        st.error(f"🚫 Server error: {response.status_code}")
-                except Exception as e:
-                    st.error(f"❌ Backend connection error: {e}")
-
-
-# End of main
-if __name__ == "__main__":
-    main()
+import os
+import re
+import glob
+import tempfile
+from typing import Dict, List, TypedDict, Optional, Tuple, Set, Any, Union
+from dataclasses import dataclass
+from enum import Enum
+import numpy as np
+import pandas as pd
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.schema import Document
+from langgraph.graph import StateGraph, END
+import json
+from datetime import datetime
+import logging
+import streamlit as st
+from streamlit_lottie import st_lottie
+import requests
+
+# 로깅 설정
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# ========== 데이터 모델 정의 ==========
+
+class DiseaseStage(Enum):
+    """신장 질환 단계"""
+    CKD_1 = "CKD Stage 1"
+    CKD_2 = "CKD Stage 2"
+    CKD_3 = "CKD Stage 3"
+    CKD_4 = "CKD Stage 4"
+    CKD_5 = "CKD Stage 5"
+    DIALYSIS = "Dialysis"
+    TRANSPLANT = "Transplant"
+
+class TaskType(Enum):
+    """질문 유형 분류"""
+    DIET_RECOMMENDATION = "diet_recommendation"  # 식단 추천
+    DIET_ANALYSIS = "diet_analysis"  # 특정 식품 분석
+    MEDICATION = "medication"  # 복약 관련
+    LIFESTYLE = "lifestyle"  # 생활 관리
+    DIAGNOSIS = "diagnosis"  # 진단/검사
+    EXERCISE = "exercise"  # 운동
+    GENERAL = "general"  # 일반 정보
+
+@dataclass
+class PatientConstraints:
+    """환자 개별 제약조건"""
+    egfr: float  # 사구체여과율
+    disease_stage: DiseaseStage
+    on_dialysis: bool
+    comorbidities: List[str]  # 동반질환 목록
+    medications: List[str]  # 복용 약물 목록
+    age: int
+    gender: str
+    
+    # 영양 제한사항
+    protein_restriction: Optional[float] = None  # g/day
+    sodium_restriction: Optional[float] = None  # mg/day
+    potassium_restriction: Optional[float] = None  # mg/day
+    phosphorus_restriction: Optional[float] = None  # mg/day
+    fluid_restriction: Optional[float] = None  # ml/day
+    calorie_target: Optional[float] = None  # kcal/day
+
+@dataclass
+class RecommendationItem:
+    """추천 항목"""
+    name: str
+    category: str  # 식이, 운동, 약물 등
+    description: str
+    constraints_satisfied: bool
+    embedding: Optional[np.ndarray] = None
+
+@dataclass
+class FoodItem:
+    """식품 정보 (실제 CSV 구조 반영)"""
+    food_code: str  # 식품코드
+    name: str  # 식품명
+    food_category_major: str  # 식품대분류명
+    food_category_minor: str  # 식품중분류명
+    serving_size: float  # 영양성분함량기준량 (보통 100g)
+    calories: float  # 에너지(kcal)
+    water: float  # 수분(g)
+    protein: float  # 단백질(g)
+    fat: float  # 지방(g)
+    carbohydrate: float  # 탄수화물(g)
+    sugar: float  # 당류(g)
+    dietary_fiber: float  # 식이섬유(g)
+    calcium: float  # 칼슘(mg)
+    iron: float  # 철(mg)
+    phosphorus: float  # 인(mg)
+    potassium: float  # 칼륨(mg)
+    sodium: float  # 나트륨(mg)
+    cholesterol: float  # 콜레스테롤(mg)
+    saturated_fat: float  # 포화지방산(g)
+    
+    def get_nutrients_per_serving(self, serving_g: float = 100) -> Dict[str, float]:
+        """지정된 양(g)에 대한 영양소 함량 계산"""
+        ratio = serving_g / self.serving_size
+        return {
+            'calories': self.calories * ratio,
+            'protein': self.protein * ratio,
+            'fat': self.fat * ratio,
+            'carbohydrate': self.carbohydrate * ratio,
+            'sodium': self.sodium * ratio,
+            'potassium': self.potassium * ratio,
+            'phosphorus': self.phosphorus * ratio
+        }
+    
+    def is_suitable_for_patient(self, constraints: PatientConstraints, 
+                              serving_g: float = 100) -> Tuple[bool, List[str]]:
+        """환자 제약조건에 적합한지 확인"""
+        issues = []
+        nutrients = self.get_nutrients_per_serving(serving_g)
+        
+        # 일일 제한량의 30%를 한 끼 기준으로 설정
+        meal_ratio = 0.3
+        
+        # 단백질 체크
+        if constraints.protein_restriction:
+            if nutrients['protein'] > constraints.protein_restriction * meal_ratio:
+                issues.append(f"단백질 함량이 높음 ({nutrients['protein']:.1f}g)")
+                
+        # 나트륨 체크
+        if constraints.sodium_restriction:
+            if nutrients['sodium'] > constraints.sodium_restriction * meal_ratio:
+                issues.append(f"나트륨 함량이 높음 ({nutrients['sodium']:.0f}mg)")
+                
+        # 칼륨 체크
+        if constraints.potassium_restriction:
+            if nutrients['potassium'] > constraints.potassium_restriction * meal_ratio:
+                issues.append(f"칼륨 함량이 높음 ({nutrients['potassium']:.0f}mg)")
+                
+        # 인 체크
+        if constraints.phosphorus_restriction:
+            if nutrients['phosphorus'] > constraints.phosphorus_restriction * meal_ratio:
+                issues.append(f"인 함량이 높음 ({nutrients['phosphorus']:.0f}mg)")
+                
+        return len(issues) == 0, issues
+
+# ========== State 정의 ==========
+
+class GraphState(TypedDict):
+    """LangGraph State"""
+    user_query: str
+    patient_constraints: PatientConstraints
+    task_type: TaskType
+    draft_response: str
+    draft_items: List[RecommendationItem]
+    corrected_items: List[RecommendationItem]
+    final_response: str
+    catalog_results: List[Document]
+    iteration_count: int
+    error: Optional[str]
+    food_analysis_results: Optional[Dict[str, Any]]
+    recommended_foods: Optional[List[FoodItem]]
+    meal_plan: Optional[Dict[str, List[FoodItem]]]
+    current_node: str  # 현재 처리 중인 노드
+    processing_log: List[str]  # 처리 로그
+
+# ========== Catalog 관리 ==========
+
+class KidneyDiseaseCatalog:
+    """신장질환 정보 카탈로그 - 싱글톤 패턴 적용"""
+    
+    _instance = None
+    _initialized = False
+    
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(KidneyDiseaseCatalog, cls).__new__(cls)
+        return cls._instance
+    
+    def __init__(self, documents_path: str = "./data"):
+        if KidneyDiseaseCatalog._initialized:
+            return
+            
+        self.embeddings = OpenAIEmbeddings()
+        self.vectorstore = None
+        self.documents_path = documents_path
+        self.metadata_index = {}  # 문서 메타데이터 인덱스
+        
+        # 태그 매핑 정의
+        self.field_mapping = {
+            "식이": "diet", "운동": "exercise", "진단": "diagnosis",
+            "복약": "medication", "치료": "treatment", "교육": "education", 
+            "생활": "lifestyle"
+        }
+        
+        self.status_mapping = {
+            "CKD": "chronic_kidney_disease", "HD": "hemodialysis",
+            "PD": "peritoneal_dialysis", "DIA": "dialysis",
+            "TX": "transplant", "ALL": "all"
+        }
+        
+        self.level_mapping = {
+            "COM": "common", "STD": "standard", "DM": "diabetes",
+            "HTN": "hypertension", "OLD": "elderly", "PREG": "pregnancy",
+            "OBES": "obesity", "SYM": "symptom"
+        }
+        
+        self.priority_mapping = {
+            "S1": "emergency", "S2": "caution", "S3": "general", "S4": "reference"
+        }
+        
+        # 초기화 시 문서 로드
+        self.load_documents()
+        KidneyDiseaseCatalog._initialized = True
+    
+    def parse_filename_tags(self, filename: str) -> Dict[str, str]:
+        """파일명에서 태그 파싱"""
+        pattern = r'\[([^-]+)-([^-]+)-([^-]+)-([^\]]+)\]'
+        match = re.search(pattern, filename)
+        
+        if match:
+            field, status, level, priority = match.groups()
+            return {
+                "field": self.field_mapping.get(field, field),
+                "patient_status": self.status_mapping.get(status, status),
+                "personalization_level": self.level_mapping.get(level, level),
+                "safety_priority": self.priority_mapping.get(priority, priority),
+                "raw_tags": f"{field}-{status}-{level}-{priority}"
+            }
+        return {}
+        
+    def load_documents(self):
+        """권위있는 기관의 문서들을 로드"""
+        if self.vectorstore is not None:
+            logger.info("Documents already loaded")
+            return
+            
+        documents = []
+    
+        
+        # data 폴더의 모든 txt 파일 로드
+        file_pattern = os.path.join(self.documents_path, "*.txt")
+        file_paths = glob.glob(file_pattern)
+        
+        if not file_paths:
+            logger.warning(f"No documents found in {self.documents_path}. Creating sample files...")
+            file_paths = self._create_comprehensive_sample_files()
+        
+        for file_path in file_paths:
+            try:
+                filename = os.path.basename(file_path)
+                tags = self.parse_filename_tags(filename)
+                
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                
+                title_pattern = r'^#\s*(.+)$'
+                title_match = re.search(title_pattern, content, re.MULTILINE)
+                if title_match:
+                    title = title_match.group(1)
+                else:
+                    title = filename.split(']')[-1].replace('.txt', '').strip()
+                    if not title:
+                        title = filename.replace('.txt', '')
+                
+                source = self._extract_source(content, filename)
+                
+                doc = Document(
+                    page_content=content,
+                    metadata={
+                        "filename": filename,
+                        "title": title,
+                        "source": source,
+                        "timestamp": datetime.now().isoformat(),
+                        **tags
+                    }
+                )
+                documents.append(doc)
+                self.metadata_index[filename] = doc.metadata
+                logger.info(f"Loaded document: {filename}")
+                
+            except Exception as e:
+                logger.error(f"Error loading file {file_path}: {e}")
+                continue
+        
+        # 텍스트 분할
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=2000,
+            chunk_overlap=100,
+            separators=["\n\n", "\n", ".", "!", "?", ",", " ", ""]
+        )
+        split_docs = text_splitter.split_documents(documents)
+        
+        for doc in split_docs:
+            doc.metadata["chunk_id"] = f"{doc.metadata['filename']}_{hash(doc.page_content)}"
+        
+        self.vectorstore = FAISS.from_documents(split_docs, self.embeddings)
+        logger.info(f"Loaded {len(documents)} documents ({len(split_docs)} chunks) into vectorstore")
+        
+    def _extract_source(self, content: str, filename: str) -> str:
+        """문서 내용에서 출처 기관 추출"""
+        source_patterns = [
+            "보건복지부", "질병관리청", "대한의학회", "대한신장학회",
+            "대한당뇨병학회", "대한의료사회복지사협회"
+        ]
+        
+        for pattern in source_patterns:
+            if pattern in content:
+                return pattern
+                
+        return "관련 기관"
+    
+    def _create_comprehensive_sample_files(self) -> List[str]:
+        """포괄적인 샘플 파일 생성"""
+        sample_files = []
+        samples = [
+            ("[식이-CKD-STD-S3] 만성콩팥병 환자의 단백질 섭취 가이드.txt", 
+             """# 만성콩팥병 환자의 단백질 섭취 가이드
+
+## 개요
+만성콩팥병(CKD) 환자의 적절한 단백질 섭취는 질병 진행을 늦추고 영양 상태를 유지하는 데 중요합니다.
+
+## 단계별 단백질 섭취 권장량
+- CKD 1-2단계: 정상 섭취 (체중 kg당 0.8-1.0g)
+- CKD 3-4단계: 제한 필요 (체중 kg당 0.6-0.8g)
+- CKD 5단계(투석 전): 엄격한 제한 (체중 kg당 0.6g)
+- 혈액투석 환자: 증가 필요 (체중 kg당 1.2g)
+- 복막투석 환자: 더 증가 필요 (체중 kg당 1.2-1.3g)
+
+## 양질의 단백질 선택
+1. 동물성 단백질: 달걀, 생선, 닭가슴살
+2. 식물성 단백질: 두부, 콩류 (인 함량 주의)
+
+## 주의사항
+- 과도한 단백질 섭취는 신장에 부담을 줍니다
+- 개인별 상태에 따라 섭취량 조절이 필요합니다
+- 정기적인 영양 상담을 받으세요
+
+출처: 대한신장학회"""),
+            
+            ("[복약-HD-HTN-S2] 혈액투석 환자의 고혈압 약물 관리.txt",
+             """# 혈액투석 환자의 고혈압 약물 관리
+
+## 주요 원칙
+혈액투석 환자의 약 70-80%가 고혈압을 동반하며, 적절한 약물 관리가 필수적입니다.
+
+## 복약 시간 조절
+1. 투석 후 복용 권장 약물
+   - ACE 억제제, ARB: 투석으로 제거될 수 있음
+   - 베타차단제: 투석 중 저혈압 위험
+
+2. 투석과 무관하게 복용 가능한 약물
+   - 칼슘채널차단제: 투석으로 제거되지 않음
+
+## 약물 상호작용 주의
+- 인결합제와 다른 약물은 최소 2시간 간격
+- 철분제와 일부 항생제는 동시 복용 금지
+
+## 혈압 목표
+- 투석 전: 140/90 mmHg 미만
+- 투석 후: 130/80 mmHg 미만
+
+출처: 대한신장학회"""),
+            
+            ("[식이-HD-STD-S2] 혈액투석 환자의 칼륨 제한 식이요법.txt",
+             """# 혈액투석 환자의 칼륨 제한 식이요법
+
+## 칼륨 제한의 중요성
+혈액투석 환자는 소변량 감소로 칼륨 배설이 어려워 고칼륨혈증 위험이 높습니다.
+
+## 일일 칼륨 섭취 권장량
+- 혈액투석 환자: 2000-2500mg/일
+- 잔여 신기능에 따라 조절 필요
+
+## 고칼륨 식품 (제한 필요)
+- 과일: 바나나, 참외, 토마토, 오렌지
+- 채소: 시금치, 감자, 고구마, 버섯
+- 기타: 초콜릿, 견과류, 우유
+
+## 칼륨 감소 조리법
+1. 채소는 잘게 썰어 물에 2시간 담근 후 헹구기
+2. 끓는 물에 데친 후 국물은 버리기
+3. 과일은 통조림 사용 (시럽 제거)
+
+출처: 보건복지부"""),
+            
+            ("[생활-CKD-STD-S3] 만성콩팥병 환자의 수분 섭취 관리.txt",
+             """# 만성콩팥병 환자의 수분 섭취 관리
+
+## 수분 제한이 필요한 경우
+- 소변량이 하루 500ml 이하로 감소
+- 부종이 있는 경우
+- 심부전을 동반한 경우
+
+## 일일 수분 섭취량 계산
+- 기본 공식: 전날 소변량 + 500ml
+- 투석 환자: 투석 간 체중 증가 1kg 이내
+
+## 수분 섭취 관리 요령
+1. 모든 액체류 포함 (국, 우유, 아이스크림 등)
+2. 작은 컵 사용하기
+3. 얼음 조각으로 갈증 해소
+4. 무설탕 껌이나 신 사탕 활용
+
+## 주의사항
+- 과도한 수분 제한도 위험
+- 개인별 상태에 따라 조절
+- 정기적인 체중 측정 필요
+
+출처: 대한의학회"""),
+            
+            ("[운동-CKD-STD-S3] 만성콩팥병 환자의 운동 가이드.txt",
+             """# 만성콩팥병 환자의 운동 가이드
+
+## 운동의 이점
+- 심혈관 기능 개선
+- 혈압 조절
+- 근력 유지
+- 우울감 감소
+
+## 권장 운동
+1. 유산소 운동
+   - 걷기: 주 5회, 30분
+   - 자전거: 저강도로 시작
+   - 수영: 관절에 무리 없음
+
+2. 근력 운동
+   - 가벼운 덤벨 운동
+   - 저항 밴드 운동
+   - 주 2-3회, 15-20분
+
+## 운동 시 주의사항
+- 투석 직후는 피하기
+- 탈수 주의
+- 가슴 통증, 호흡곤란 시 즉시 중단
+- 운동 전후 혈압 체크
+
+출처: 대한의료사회복지사협회"""),
+            
+            ("[진단-CKD-STD-S3] 만성콩팥병의 진단과 검사.txt",
+             """# 만성콩팥병의 진단과 검사
+
+## 진단 기준
+3개월 이상 다음 중 하나 이상 존재 시:
+- eGFR < 60 ml/min/1.73m²
+- 알부민뇨 (ACR ≥ 30mg/g)
+- 신장 손상의 증거
+
+## 주요 검사
+1. 혈액검사
+   - 크레아티닌, eGFR
+   - 전해질 (Na, K, Ca, P)
+   - 빈혈 지표 (Hb, ferritin)
+
+2. 소변검사
+   - 단백뇨/알부민뇨
+   - 현미경 검사
+
+3. 영상검사
+   - 신장 초음파
+   - 필요시 CT, MRI
+
+## 정기 검진 주기
+- CKD 1-2단계: 연 1회
+- CKD 3단계: 6개월마다
+- CKD 4-5단계: 3개월마다
+
+출처: 질병관리청"""),
+            
+            ("[식이-CKD-DM-S2] 당뇨병성 신증 환자의 식사 관리.txt",
+             """# 당뇨병성 신증 환자의 식사 관리
+
+## 특별 고려사항
+당뇨병과 신장병을 함께 관리해야 하는 복잡한 상황입니다.
+
+## 영양 관리 원칙
+1. 혈당 조절
+   - 규칙적인 식사 시간
+   - 당지수가 낮은 식품 선택
+   - 단순당 제한
+
+2. 단백질 조절
+   - CKD 3-4단계: 0.6-0.8g/kg/일
+   - 양질의 단백질 위주
+
+3. 나트륨 제한
+   - 2000mg/일 이하
+   - 가공식품 피하기
+
+## 주의 식품
+- 과일: 당도 높은 과일 제한
+- 곡류: 현미, 잡곡 (인 함량 주의)
+- 음료: 과일주스, 스포츠음료 금지
+
+출처: 대한당뇨병학회""")
+        ]
+        
+        for filename, content in samples:
+            filepath = os.path.join(self.documents_path, filename)
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(content)
+            sample_files.append(filepath)
+            logger.info(f"Created sample file: {filename}")
+                
+        return sample_files
+        
+    def search(self, query: str, k: int = 5, 
+              filters: Optional[Dict[str, Any]] = None) -> List[Document]:
+        """관련 문서 검색"""
+        if not self.vectorstore:
+            logger.warning("Vectorstore not loaded, loading now...")
+            self.load_documents()
+            
+        logger.info(f"Searching for: '{query}' with k={k}, filters={filters}")
+        results = self.vectorstore.similarity_search(query, k=k*2)
+        
+        if filters:
+            filtered_results = []
+            for doc in results:
+                match = True
+                for key, value in filters.items():
+                    if key in doc.metadata and doc.metadata[key] != value:
+                        match = False
+                        break
+                if match:
+                    filtered_results.append(doc)
+            results = filtered_results[:k]
+        else:
+            results = results[:k]
+        
+        logger.info(f"Found {len(results)} documents")
+        return results
+    
+    def search_by_patient_context(self, query: str, 
+                                constraints: PatientConstraints,
+                                task_type: TaskType,
+                                k: int = 5) -> List[Document]:
+        """환자 상태와 작업 유형을 고려한 맞춤형 검색"""
+        filters = {}
+        
+        # 작업 유형에 따른 필터
+        task_field_mapping = {
+            TaskType.DIET_RECOMMENDATION: "diet",
+            TaskType.DIET_ANALYSIS: "diet",
+            TaskType.MEDICATION: "medication",
+            TaskType.LIFESTYLE: "lifestyle",
+            TaskType.DIAGNOSIS: "diagnosis",
+            TaskType.EXERCISE: "exercise"
+        }
+        
+        if task_type in task_field_mapping:
+            filters["field"] = task_field_mapping[task_type]
+        
+        # 환자 상태에 따른 필터
+        if constraints.on_dialysis:
+            filters["patient_status"] = "hemodialysis"
+        elif constraints.disease_stage in [DiseaseStage.CKD_3, DiseaseStage.CKD_4]:
+            filters["patient_status"] = "chronic_kidney_disease"
+            
+        # 동반질환에 따른 검색
+        additional_results = []
+        if "당뇨" in constraints.comorbidities:
+            additional_results.extend(
+                self.search(query, k=k//3, filters={"personalization_level": "diabetes"})
+            )
+        if "고혈압" in constraints.comorbidities:
+            additional_results.extend(
+                self.search(query, k=k//3, filters={"personalization_level": "hypertension"})
+            )
+            
+        main_results = self.search(query, k=k-len(additional_results), filters=filters)
+        
+        all_results = main_results + additional_results
+        logger.info(f"Patient context search found {len(all_results)} total documents")
+        
+        return all_results
+
+# ========== 식품 영양 분석 ==========
+
+class FoodNutritionDatabase:
+    """식품 영양 성분 데이터베이스 - 싱글톤 패턴 적용"""
+    
+    _instance = None
+    _initialized = False
+    
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(FoodNutritionDatabase, cls).__new__(cls)
+        return cls._instance
+    
+    def __init__(self, csv_path: str = "통합식품영양성분정보(음식)_20241224.csv"):
+        if FoodNutritionDatabase._initialized:
+            return
+            
+        self.csv_path = csv_path
+        self.food_data = None
+        self.load_food_data()
+        FoodNutritionDatabase._initialized = True
+        
+    def load_food_data(self):
+        """CSV 파일에서 식품 데이터 로드"""
+        try:
+            # CSV 파일 로드 시도
+            if os.path.exists(self.csv_path):
+                self.food_data = pd.read_csv(self.csv_path, encoding='utf-8')
+                logger.info(f"Loaded food data from {self.csv_path}")
+            else:
+                raise FileNotFoundError(f"CSV file not found: {self.csv_path}")
+            
+            # 컬럼명 정리 (실제 CSV 구조에 맞게)
+            column_mapping = {
+                '식품코드': 'food_code',
+                '식품명': 'name',
+                '식품대분류명': 'category_major',
+                '식품중분류명': 'category_minor',
+                '영양성분함량기준량': 'serving_size',
+                '에너지(kcal)': 'calories',
+                '수분(g)': 'water',
+                '단백질(g)': 'protein',
+                '지방(g)': 'fat',
+                '탄수화물(g)': 'carbohydrate',
+                '당류(g)': 'sugar',
+                '식이섬유(g)': 'dietary_fiber',
+                '칼슘(mg)': 'calcium',
+                '철(mg)': 'iron',
+                '인(mg)': 'phosphorus',
+                '칼륨(mg)': 'potassium',
+                '나트륨(mg)': 'sodium',
+                '콜레스테롤(mg)': 'cholesterol',
+                '포화지방산(g)': 'saturated_fat'
+            }
+            
+            self.food_data = self.food_data.rename(columns=column_mapping)
+            
+            # 숫자형 컬럼 변환
+            numeric_columns = ['calories', 'protein', 'fat', 'carbohydrate', 
+                             'sodium', 'potassium', 'phosphorus', 'calcium',
+                             'water', 'sugar', 'dietary_fiber', 'iron',
+                             'cholesterol', 'saturated_fat']
+            for col in numeric_columns:
+                if col in self.food_data.columns:
+                    self.food_data[col] = pd.to_numeric(self.food_data[col], errors='coerce')
+            
+            # serving_size를 숫자로 변환 (예: "100g" -> 100)
+            if 'serving_size' in self.food_data.columns:
+                if self.food_data['serving_size'].dtype == 'object':
+                    self.food_data['serving_size'] = self.food_data['serving_size'].str.extract('(\d+)').astype(float)
+                else:
+                    self.food_data['serving_size'] = pd.to_numeric(self.food_data['serving_size'], errors='coerce')
+            
+            # NaN 값을 0으로 채우기
+            self.food_data = self.food_data.fillna(0)
+            
+            logger.info(f"Loaded {len(self.food_data)} food items from database")
+            
+        except Exception as e:
+            logger.error(f"Error loading food database: {e}")
+            logger.info("Creating sample food data...")
+            self.food_data = self._create_sample_data()
+    
+    def _create_sample_data(self):
+        """샘플 식품 데이터 생성"""
+        sample_data = {
+            'food_code': ['D101-001', 'D101-002', 'D101-003', 'D101-004', 'D101-005', 'D101-006', 
+                         'D101-007', 'D101-008', 'D101-009', 'D101-010'],
+            'name': ['쌀밥', '닭가슴살', '브로콜리', '사과', '두부', '달걀', '감자', '우유', '연어', '시금치'],
+            'category_major': ['곡류', '육류', '채소류', '과일류', '콩류', '난류', '서류', '유제품류', '어패류', '채소류'],
+            'category_minor': ['밥류', '가금류', '녹황색채소', '과일', '두부', '계란', '감자류', '우유류', '생선류', '엽채류'],
+            'serving_size': [100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
+            'calories': [130, 165, 34, 52, 76, 155, 77, 61, 208, 23],
+            'water': [68.5, 65.3, 89.3, 85.6, 84.6, 76.2, 79.3, 87.7, 68.5, 91.4],
+            'protein': [2.7, 31.0, 2.8, 0.3, 8.1, 13.0, 2.0, 3.3, 20.4, 2.9],
+            'fat': [0.3, 3.6, 0.4, 0.2, 4.8, 11.0, 0.1, 3.3, 13.4, 0.4],
+            'carbohydrate': [28.2, 0, 6.6, 13.8, 1.9, 1.1, 17.6, 4.8, 0, 3.6],
+            'sugar': [0.1, 0, 1.7, 10.4, 0.7, 0.4, 0.8, 5.0, 0, 0.4],
+            'dietary_fiber': [0.4, 0, 2.6, 2.4, 0.3, 0, 1.8, 0, 0, 2.2],
+            'calcium': [10, 11, 47, 6, 350, 56, 10, 113, 12, 99],
+            'iron': [0.5, 0.9, 0.7, 0.1, 5.4, 1.8, 0.8, 0.1, 0.8, 2.7],
+            'phosphorus': [43, 210, 66, 11, 110, 198, 57, 93, 252, 49],
+            'potassium': [35, 256, 316, 107, 121, 138, 421, 150, 490, 558],
+            'sodium': [1, 74, 30, 1, 7, 142, 6, 50, 44, 79],
+            'cholesterol': [0, 85, 0, 0, 0, 373, 0, 12, 55, 0],
+            'saturated_fat': [0.1, 1.0, 0.1, 0, 0.7, 3.3, 0, 1.9, 3.1, 0.1]
+        }
+        
+        return pd.DataFrame(sample_data)
+    
+    def search_foods(self, query: str, limit: int = 10) -> List[FoodItem]:
+        """식품 검색"""
+        logger.info(f"Searching for food: '{query}'")
+        
+        # 검색어가 포함된 식품 찾기
+        mask = self.food_data['name'].str.contains(query, case=False, na=False)
+        results = self.food_data[mask].head(limit)
+        
+        food_items = []
+        for _, row in results.iterrows():
+            food_item = FoodItem(
+                food_code=str(row.get('food_code', '')),
+                name=row['name'],
+                food_category_major=row.get('category_major', ''),
+                food_category_minor=row.get('category_minor', ''),
+                serving_size=float(row.get('serving_size', 100)),
+                calories=float(row['calories']),
+                water=float(row.get('water', 0)),
+                protein=float(row['protein']),
+                fat=float(row['fat']),
+                carbohydrate=float(row['carbohydrate']),
+                sugar=float(row.get('sugar', 0)),
+                dietary_fiber=float(row.get('dietary_fiber', 0)),
+                calcium=float(row.get('calcium', 0)),
+                iron=float(row.get('iron', 0)),
+                phosphorus=float(row['phosphorus']),
+                potassium=float(row['potassium']),
+                sodium=float(row['sodium']),
+                cholesterol=float(row.get('cholesterol', 0)),
+                saturated_fat=float(row.get('saturated_fat', 0))
+            )
+            food_items.append(food_item)
+        
+        logger.info(f"Found {len(food_items)} food items for '{query}'")
+        return food_items
+    
+    def recommend_foods_for_patient(self, constraints: PatientConstraints, 
+                                  meal_type: str = "all",
+                                  limit: int = 20) -> List[FoodItem]:
+        """환자 제약조건에 맞는 식품 추천"""
+        logger.info(f"Recommending foods for patient with constraints, meal_type={meal_type}")
+        
+        # 필터링 조건 설정
+        filtered_data = self.food_data.copy()
+        
+        # 단백질 제한 (한 끼 기준 = 일일 제한량의 30%)
+        if constraints.protein_restriction:
+            max_protein = constraints.protein_restriction * 0.3
+            filtered_data = filtered_data[filtered_data['protein'] <= max_protein]
+        
+        # 나트륨 제한
+        if constraints.sodium_restriction:
+            max_sodium = constraints.sodium_restriction * 0.3
+            filtered_data = filtered_data[filtered_data['sodium'] <= max_sodium]
+        
+        # 칼륨 제한
+        if constraints.potassium_restriction:
+            max_potassium = constraints.potassium_restriction * 0.3
+            filtered_data = filtered_data[filtered_data['potassium'] <= max_potassium]
+        
+        # 인 제한
+        if constraints.phosphorus_restriction:
+            max_phosphorus = constraints.phosphorus_restriction * 0.3
+            filtered_data = filtered_data[filtered_data['phosphorus'] <= max_phosphorus]
+        
+        # 식사 유형에 따른 필터링
+        if meal_type == "breakfast":
+            # 아침식사에 적합한 카테고리
+            breakfast_categories = ['곡류', '유제품류', '과일류', '난류']
+            mask = filtered_data['category_major'].isin(breakfast_categories)
+            if mask.any():
+                filtered_data = filtered_data[mask]
+        elif meal_type == "lunch" or meal_type == "dinner":
+            # 점심/저녁에 적합한 카테고리
+            main_categories = ['곡류', '육류', '어패류', '채소류', '콩류']
+            mask = filtered_data['category_major'].isin(main_categories)
+            if mask.any():
+                filtered_data = filtered_data[mask]
+        
+        # 칼로리 기준으로 정렬 (적절한 칼로리 범위 우선)
+        if constraints.calorie_target:
+            target_cal_per_meal = constraints.calorie_target / 3
+            filtered_data['cal_diff'] = abs(filtered_data['calories'] - target_cal_per_meal * 0.5)
+            filtered_data = filtered_data.sort_values('cal_diff')
+        
+        # 상위 N개 선택
+        top_foods = filtered_data.head(limit)
+        
+        # FoodItem 객체로 변환
+        recommended_foods = []
+        for _, row in top_foods.iterrows():
+            food_item = FoodItem(
+                food_code=str(row.get('food_code', '')),
+                name=row['name'],
+                food_category_major=row.get('category_major', ''),
+                food_category_minor=row.get('category_minor', ''),
+                serving_size=float(row.get('serving_size', 100)),
+                calories=float(row['calories']),
+                water=float(row.get('water', 0)),
+                protein=float(row['protein']),
+                fat=float(row['fat']),
+                carbohydrate=float(row['carbohydrate']),
+                sugar=float(row.get('sugar', 0)),
+                dietary_fiber=float(row.get('dietary_fiber', 0)),
+                calcium=float(row.get('calcium', 0)),
+                iron=float(row.get('iron', 0)),
+                phosphorus=float(row['phosphorus']),
+                potassium=float(row['potassium']),
+                sodium=float(row['sodium']),
+                cholesterol=float(row.get('cholesterol', 0)),
+                saturated_fat=float(row.get('saturated_fat', 0))
+            )
+            recommended_foods.append(food_item)
+        
+        logger.info(f"Recommended {len(recommended_foods)} foods for {meal_type}")
+        return recommended_foods
+    
+    def create_daily_meal_plan(self, constraints: PatientConstraints) -> Dict[str, List[FoodItem]]:
+        """하루 식단 계획 생성"""
+        logger.info("Creating daily meal plan")
+        
+        meal_plan = {
+            'breakfast': [],
+            'lunch': [],
+            'dinner': [],
+            'snack': []
+        }
+        
+        # 각 식사별 추천 식품
+        meal_plan['breakfast'] = self.recommend_foods_for_patient(
+            constraints, meal_type='breakfast', limit=5
+        )
+        meal_plan['lunch'] = self.recommend_foods_for_patient(
+            constraints, meal_type='lunch', limit=5
+        )
+        meal_plan['dinner'] = self.recommend_foods_for_patient(
+            constraints, meal_type='dinner', limit=5
+        )
+        
+        # 간식 추천 (칼로리가 낮은 식품)
+        snack_data = self.food_data[self.food_data['calories'] < 100]
+        if constraints.protein_restriction:
+            snack_data = snack_data[snack_data['protein'] < constraints.protein_restriction * 0.1]
+        
+        snack_foods = []
+        for _, row in snack_data.head(3).iterrows():
+            food_item = FoodItem(
+                food_code=str(row.get('food_code', '')),
+                name=row['name'],
+                food_category_major=row.get('category_major', ''),
+                food_category_minor=row.get('category_minor', ''),
+                serving_size=float(row.get('serving_size', 100)),
+                calories=float(row['calories']),
+                water=float(row.get('water', 0)),
+                protein=float(row['protein']),
+                fat=float(row['fat']),
+                carbohydrate=float(row['carbohydrate']),
+                sugar=float(row.get('sugar', 0)),
+                dietary_fiber=float(row.get('dietary_fiber', 0)),
+                calcium=float(row.get('calcium', 0)),
+                iron=float(row.get('iron', 0)),
+                phosphorus=float(row['phosphorus']),
+                potassium=float(row['potassium']),
+                sodium=float(row['sodium']),
+                cholesterol=float(row.get('cholesterol', 0)),
+                saturated_fat=float(row.get('saturated_fat', 0))
+            )
+            snack_foods.append(food_item)
+        
+        meal_plan['snack'] = snack_foods
+        
+        logger.info("Daily meal plan created successfully")
+        return meal_plan
+
+# ========== LLM 응답 생성 ==========
+
+class DraftGenerator:
+    """초안 응답 생성기"""
+    
+    def __init__(self):
+        self.llm = ChatOpenAI(temperature=0.7, model="gpt-4o")
+        
+    def generate_draft(self, query: str, constraints: PatientConstraints, 
+                      context_docs: List[Document]) -> Tuple[str, List[RecommendationItem]]:
+        """제약조건을 고려한 초안 생성"""
+        logger.info("Generating draft response")
+        
+        context = "\n".join([doc.page_content for doc in context_docs])
+        
+        constraints_text = f"""
+        환자 정보:
+        - eGFR: {constraints.egfr} ml/min
+        - 질병 단계: {constraints.disease_stage.value}
+        - 투석 여부: {'예' if constraints.on_dialysis else '아니오'}
+        - 동반질환: {', '.join(constraints.comorbidities) if constraints.comorbidities else '없음'}
+        - 복용 약물: {', '.join(constraints.medications) if constraints.medications else '없음'}
+        - 연령: {constraints.age}세
+        - 성별: {constraints.gender}
+        
+        영양 제한사항:
+        - 단백질: {constraints.protein_restriction}g/일
+        - 나트륨: {constraints.sodium_restriction}mg/일
+        - 칼륨: {constraints.potassium_restriction}mg/일
+        - 인: {constraints.phosphorus_restriction}mg/일
+        - 수분: {constraints.fluid_restriction}ml/일
+        """
+        
+        prompt = f"""
+        다음 신장질환 환자의 질문에 대해 답변하세요.
+        
+        질문: {query}
+        
+        참고 문서:
+        {context}
+        
+        {constraints_text}
+        
+        답변 시 다음 사항을 준수하세요:
+        1. 환자의 개별 상태를 반영한 맞춤형 답변 제공
+        2. 구체적인 권장사항은 <item>태그</item>로 표시
+        3. 의학적으로 정확하고 이해하기 쉬운 설명 제공
+        4. 참고 문서의 내용을 활용하여 근거 있는 답변 작성
+        """
+        
+        response = self.llm.predict(prompt)
+        items = self._extract_items(response)
+        
+        logger.info(f"Generated draft with {len(items)} recommendation items")
+        return response, items
+    
+    def _extract_items(self, response: str) -> List[RecommendationItem]:
+        """응답에서 추천 항목 추출"""
+        items = []
+        pattern = r'<item>(.*?)</item>'
+        matches = re.findall(pattern, response, re.DOTALL)
+        
+        for match in matches:
+            category = "식이" if any(word in match for word in ["섭취", "식사", "음식"]) else "기타"
+            
+            item = RecommendationItem(
+                name=match.strip(),
+                category=category,
+                description=match.strip(),
+                constraints_satisfied=False
+            )
+            items.append(item)
+            
+        return items
+
+# ========== Correction Algorithm ==========
+
+class CorrectionAlgorithm:
+    """제약조건 만족을 위한 보정 알고리즘"""
+    
+    def __init__(self, catalog: KidneyDiseaseCatalog):
+        self.catalog = catalog
+        self.embeddings = OpenAIEmbeddings()
+        
+    def correct_items(self, draft_items: List[RecommendationItem], 
+                     constraints: PatientConstraints) -> List[RecommendationItem]:
+        """초안 항목들을 제약조건에 맞게 보정"""
+        logger.info(f"Correcting {len(draft_items)} draft items")
+        
+        corrected_items = []
+        
+        for item in draft_items:
+            item.embedding = self._get_embedding(item.name)
+            similar_docs = self.catalog.search(item.name, k=10)
+            
+            best_replacement = self._find_best_replacement(
+                item, similar_docs, constraints
+            )
+            
+            if best_replacement:
+                corrected_items.append(best_replacement)
+            else:
+                item.constraints_satisfied = False
+                corrected_items.append(item)
+        
+        logger.info(f"Corrected to {len(corrected_items)} items")
+        return corrected_items
+    
+    def _get_embedding(self, text: str) -> np.ndarray:
+        """텍스트 임베딩 생성"""
+        return np.array(self.embeddings.embed_query(text))
+    
+    def _find_best_replacement(self, original_item: RecommendationItem,
+                              candidates: List[Document],
+                              constraints: PatientConstraints) -> Optional[RecommendationItem]:
+        """제약조건을 만족하는 최적 대체 항목 찾기"""
+        
+        best_item = None
+        best_score = float('inf')
+        
+        for doc in candidates:
+            if self._check_constraints(doc, constraints):
+                doc_embedding = self._get_embedding(doc.page_content)
+                distance = np.linalg.norm(original_item.embedding - doc_embedding)
+                
+                if distance < best_score:
+                    best_score = distance
+                    best_item = RecommendationItem(
+                        name=doc.metadata.get('title', doc.page_content[:50]),
+                        category=doc.metadata.get('field', original_item.category),
+                        description=doc.page_content,
+                        constraints_satisfied=True,
+                        embedding=doc_embedding
+                    )
+                    
+        return best_item
+    
+    def _check_constraints(self, doc: Document, constraints: PatientConstraints) -> bool:
+        """문서가 환자 제약조건을 만족하는지 검증"""
+        
+        content = doc.page_content.lower()
+        
+        if constraints.on_dialysis:
+            if "투석 금지" in content or "투석 환자 제외" in content:
+                return False
+                
+        if constraints.disease_stage in [DiseaseStage.CKD_4, DiseaseStage.CKD_5]:
+            if "진행성 신부전 주의" in content:
+                return False
+                
+        for comorbidity in constraints.comorbidities:
+            if comorbidity == "당뇨" and "당뇨 금기" in content:
+                return False
+            if comorbidity == "고혈압" and "혈압 상승 주의" in content:
+                return False
+                
+        return True
+
+# ========== LangGraph Nodes ==========
+
+def classify_task(state: GraphState) -> GraphState:
+    """질문 유형 분류 - LLM 사용"""
+    logger.info("=== CLASSIFY TASK NODE ===")
+    logger.info(f"User query: {state['user_query']}")
+    
+    state["current_node"] = "분류"
+    state["processing_log"].append("질문 유형 분석 중...")
+    
+    llm = ChatOpenAI(temperature=0.3, model="gpt-4o")
+    
+    prompt = f"""
+    다음 질문을 분석하여 적절한 카테고리로 분류하세요.
+    
+    질문: {state['user_query']}
+    
+    카테고리:
+    - diet_recommendation: 식단 추천, 하루 식사 계획, 무엇을 먹어야 할지 묻는 질문
+    - diet_analysis: 특정 음식의 영양 성분, 섭취 가능 여부, 영양소 함량 분석
+    - medication: 약물 복용 방법, 시간, 부작용, 상호작용
+    - lifestyle: 일상생활 관리, 수면, 스트레스, 수분 섭취
+    - diagnosis: 검사 결과 해석, 질병 단계, 수치 의미
+    - exercise: 운동 방법, 종류, 강도, 주의사항
+    - general: 위 카테고리에 속하지 않는 일반적인 질문
+    
+    카테고리 이름만 반환하세요.
+    """
+    
+    response = llm.predict(prompt).strip().lower()
+    
+    # 카테고리 매핑
+    category_mapping = {
+        'diet_recommendation': TaskType.DIET_RECOMMENDATION,
+        'diet_analysis': TaskType.DIET_ANALYSIS,
+        'medication': TaskType.MEDICATION,
+        'lifestyle': TaskType.LIFESTYLE,
+        'diagnosis': TaskType.DIAGNOSIS,
+        'exercise': TaskType.EXERCISE,
+        'general': TaskType.GENERAL
+    }
+    
+    selected_task = category_mapping.get(response, TaskType.GENERAL)
+    state["task_type"] = selected_task
+    
+    logger.info(f"Task classified as: {selected_task.value}")
+    state["processing_log"].append(f"질문 유형: {selected_task.value}")
+    logger.info("=== END CLASSIFY TASK ===\n")
+    
+    return state
+
+def retrieve_context(state: GraphState) -> GraphState:
+    """관련 문서 검색"""
+    logger.info("=== RETRIEVE CONTEXT NODE ===")
+    logger.info(f"Query: {state['user_query']}")
+    logger.info(f"Task type: {state['task_type'].value}")
+    
+    state["current_node"] = "검색"
+    state["processing_log"].append("관련 문서 검색 중...")
+    
+    catalog = KidneyDiseaseCatalog()
+    
+    results = catalog.search_by_patient_context(
+        state["user_query"],
+        state["patient_constraints"],
+        state["task_type"]
+    )
+    
+    state["catalog_results"] = results
+    
+    for i, doc in enumerate(results[:3]):
+        logger.info(f"Document {i+1}: {doc.metadata.get('title', 'Unknown')} "
+                   f"[{doc.metadata.get('raw_tags', 'No tags')}]")
+    
+    state["processing_log"].append(f"{len(results)}개 관련 문서 검색 완료")
+    logger.info("=== END RETRIEVE CONTEXT ===\n")
+    return state
+
+def analyze_diet_request(state: GraphState) -> GraphState:
+    """식이 관련 요청 분석 및 식품 데이터베이스 검색"""
+    logger.info("=== ANALYZE DIET REQUEST NODE ===")
+    
+    state["current_node"] = "식품 분석"
+    state["processing_log"].append("식품 정보 분석 중...")
+    
+    food_db = FoodNutritionDatabase()
+    query = state["user_query"]
+    constraints = state["patient_constraints"]
+    
+    # LLM을 사용하여 질문에서 언급된 식품 추출
+    llm = ChatOpenAI(temperature=0.3, model="gpt-4o")
+    
+    prompt = f"""
+    다음 질문에서 언급된 모든 식품명을 추출하세요.
+    
+    질문: {query}
+    
+    식품명만 쉼표로 구분하여 나열하세요. 없으면 "없음"이라고 답하세요.
+    """
+    
+    food_names_response = llm.predict(prompt).strip()
+    logger.info(f"Extracted food names: {food_names_response}")
+    
+    mentioned_foods = []
+    if food_names_response != "없음":
+        food_names = [name.strip() for name in food_names_response.split(',')]
+        for food_name in food_names:
+            found_foods = food_db.search_foods(food_name, limit=3)
+            mentioned_foods.extend(found_foods)
+    
+    # 식품 분석 결과 생성
+    analysis_results = {
+        'mentioned_foods': [],
+        'suitable_foods': [],
+        'unsuitable_foods': [],
+        'nutritional_summary': {}
+    }
+    
+    # 언급된 식품 분석
+    for food in mentioned_foods:
+        is_suitable, issues = food.is_suitable_for_patient(constraints)
+        food_info = {
+            'name': food.name,
+            'nutrients': food.get_nutrients_per_serving(100),
+            'suitable': is_suitable,
+            'issues': issues
+        }
+        
+        analysis_results['mentioned_foods'].append(food_info)
+        
+        if is_suitable:
+            analysis_results['suitable_foods'].append(food)
+        else:
+            analysis_results['unsuitable_foods'].append((food, issues))
+    
+    state["food_analysis_results"] = analysis_results
+    
+    logger.info(f"Analyzed {len(mentioned_foods)} foods")
+    state["processing_log"].append(f"{len(mentioned_foods)}개 식품 분석 완료")
+    logger.info("=== END ANALYZE DIET REQUEST ===\n")
+    
+    return state
+
+def generate_meal_plan(state: GraphState) -> GraphState:
+    """일일 식단 계획 생성"""
+    logger.info("=== GENERATE MEAL PLAN NODE ===")
+    
+    state["current_node"] = "식단 생성"
+    state["processing_log"].append("일일 식단 계획 생성 중...")
+    
+    food_db = FoodNutritionDatabase()
+    constraints = state["patient_constraints"]
+    
+    # 하루 식단 생성
+    meal_plan = food_db.create_daily_meal_plan(constraints)
+    
+    # 영양소 총량 계산
+    daily_totals = {
+        'calories': 0,
+        'protein': 0,
+        'sodium': 0,
+        'potassium': 0,
+        'phosphorus': 0
+    }
+    
+    for meal_type, foods in meal_plan.items():
+        for food in foods:
+            nutrients = food.get_nutrients_per_serving(100)
+            for nutrient, value in nutrients.items():
+                if nutrient in daily_totals:
+                    daily_totals[nutrient] += value
+    
+    state["meal_plan"] = meal_plan
+    
+    # 기존 food_analysis_results가 있으면 업데이트, 없으면 생성
+    if state.get("food_analysis_results") is None:
+        state["food_analysis_results"] = {}
+    
+    state["food_analysis_results"].update({
+        'meal_plan': meal_plan,
+        'daily_totals': daily_totals,
+        'recommendations': []
+    })
+    
+    # 제약조건 대비 검증
+    if daily_totals['protein'] > constraints.protein_restriction:
+        state["food_analysis_results"]['recommendations'].append(
+            f"주의: 추천 식단의 단백질 총량({daily_totals['protein']:.1f}g)이 "
+            f"일일 제한량({constraints.protein_restriction}g)을 초과합니다."
+        )
+    
+    logger.info("Meal plan generated successfully")
+    state["processing_log"].append("식단 계획 생성 완료")
+    logger.info("=== END GENERATE MEAL PLAN ===\n")
+    
+    return state
+
+def generate_diet_response(state: GraphState) -> GraphState:
+    """식이 관련 최종 응답 생성"""
+    logger.info("=== GENERATE DIET RESPONSE NODE ===")
+    
+    state["current_node"] = "응답 생성"
+    state["processing_log"].append("식이 관련 답변 생성 중...")
+    
+    llm = ChatOpenAI(temperature=0.5, model="gpt-4o")
+    
+    task_type = state["task_type"]
+    constraints = state["patient_constraints"]
+    context_docs = state.get("catalog_results", [])
+    
+    # 참고 문서 내용 추출
+    context = "\n\n".join([
+        f"[{doc.metadata.get('title', 'Document')}]\n{doc.page_content[:500]}..."
+        for doc in context_docs[:3]
+    ])
+    
+    if task_type == TaskType.DIET_RECOMMENDATION and state.get("meal_plan"):
+        # 식단 추천 응답
+        meal_plan = state["meal_plan"]
+        daily_totals = state["food_analysis_results"]["daily_totals"]
+        
+        prompt = f"""
+        신장질환 환자를 위한 일일 식단을 추천합니다.
+        
+        환자 정보:
+        - 질병 단계: {constraints.disease_stage.value}
+        - 단백질 제한: {constraints.protein_restriction}g/일
+        - 나트륨 제한: {constraints.sodium_restriction}mg/일
+        - 칼륨 제한: {constraints.potassium_restriction}mg/일
+        - 인 제한: {constraints.phosphorus_restriction}mg/일
+        
+        추천 식단:
+        아침: {', '.join([f.name for f in meal_plan['breakfast'][:3]])}
+        점심: {', '.join([f.name for f in meal_plan['lunch'][:3]])}
+        저녁: {', '.join([f.name for f in meal_plan['dinner'][:3]])}
+        간식: {', '.join([f.name for f in meal_plan['snack'][:2]])}
+        
+        영양소 총량:
+        - 칼로리: {daily_totals['calories']:.0f} kcal
+        - 단백질: {daily_totals['protein']:.1f} g
+        - 나트륨: {daily_totals['sodium']:.0f} mg
+        - 칼륨: {daily_totals['potassium']:.0f} mg
+        - 인: {daily_totals['phosphorus']:.0f} mg
+        
+        참고 자료:
+        {context}
+        
+        위 정보를 바탕으로 환자가 이해하기 쉽게 설명하고,
+        각 식사의 영양학적 장점과 주의사항을 포함해주세요.
+        의료진과의 상담 필요성도 언급하세요.
+        """
+        
+    elif task_type == TaskType.DIET_ANALYSIS and state.get("food_analysis_results"):
+        # 특정 식품 분석 응답
+        analysis = state["food_analysis_results"]
+        
+        foods_summary = []
+        for food_info in analysis.get('mentioned_foods', []):
+            summary = f"{food_info['name']}: "
+            if food_info['suitable']:
+                summary += "섭취 가능"
+            else:
+                summary += f"주의 필요 ({', '.join(food_info['issues'])})"
+            foods_summary.append(summary)
+        
+        prompt = f"""
+        환자가 질문한 식품들의 영양 분석 결과입니다.
+        
+        질문: {state['user_query']}
+        
+        분석 결과:
+        {chr(10).join(foods_summary) if foods_summary else "분석된 식품이 없습니다."}
+        
+        환자의 제한사항:
+        - 단백질: {constraints.protein_restriction}g/일
+        - 나트륨: {constraints.sodium_restriction}mg/일
+        - 칼륨: {constraints.potassium_restriction}mg/일
+        - 인: {constraints.phosphorus_restriction}mg/일
+        
+        참고 자료:
+        {context}
+        
+        위 분석을 바탕으로 각 식품의 섭취 가능 여부와 
+        적절한 섭취량을 구체적으로 설명해주세요.
+        """
+        
+    else:
+        # 일반 식이 관련 응답
+        prompt = f"""
+        신장질환 환자의 식이 관련 질문에 답변하세요.
+        
+        질문: {state['user_query']}
+        
+        환자 정보:
+        - 질병 단계: {constraints.disease_stage.value}
+        - 영양 제한사항이 있습니다.
+        
+        참고 자료:
+        {context}
+        
+        환자 상태를 고려한 구체적이고 실용적인 답변을 제공하세요.
+        의료진과의 상담 필요성도 언급하세요.
+        """
+    
+    response = llm.predict(prompt)
+    state["final_response"] = response
+    
+    logger.info("Diet response generated")
+    state["processing_log"].append("답변 생성 완료")
+    logger.info("=== END GENERATE DIET RESPONSE ===\n")
+    
+    return state
+
+def generate_general_response(state: GraphState) -> GraphState:
+    """일반 질문에 대한 응답 생성"""
+    logger.info("=== GENERATE GENERAL RESPONSE NODE ===")
+    
+    state["current_node"] = "응답 생성"
+    state["processing_log"].append("일반 답변 생성 중...")
+    
+    generator = DraftGenerator()
+    
+    draft_response, draft_items = generator.generate_draft(
+        state["user_query"],
+        state["patient_constraints"],
+        state.get("catalog_results", [])
+    )
+    
+    state["draft_response"] = draft_response
+    state["draft_items"] = draft_items
+    
+    # 보정이 필요한 경우
+    if draft_items:
+        catalog = KidneyDiseaseCatalog()
+        corrector = CorrectionAlgorithm(catalog)
+        corrected_items = corrector.correct_items(draft_items, state["patient_constraints"])
+        state["corrected_items"] = corrected_items
+    
+    # 최종 응답 생성
+    llm = ChatOpenAI(temperature=0.3, model="gpt-4o")
+    
+    context_docs = state.get("catalog_results", [])
+    context = "\n\n".join([
+        f"[{doc.metadata.get('title', 'Document')}]\n{doc.page_content[:500]}..."
+        for doc in context_docs[:3]
+    ])
+    
+    if state.get("corrected_items"):
+        corrected_names = [item.name for item in state["corrected_items"]]
+        prompt = f"""
+        다음 정보를 포함하여 환자 질문에 답변하세요:
+        
+        질문: {state["user_query"]}
+        
+        환자 정보:
+        - 질병 단계: {state["patient_constraints"].disease_stage.value}
+        - 투석 여부: {'예' if state["patient_constraints"].on_dialysis else '아니오'}
+        
+        참고 자료:
+        {context}
+        
+        초안 답변: {draft_response}
+        
+        검증된 권장사항: {json.dumps(corrected_names, ensure_ascii=False)}
+        
+        위 정보를 종합하여 환자에게 도움이 되는 답변을 작성하세요.
+        의료진과의 상담 필요성을 반드시 언급하세요.
+        """
+    else:
+        prompt = f"""
+        다음 질문에 대해 정확하고 이해하기 쉽게 답변하세요:
+        
+        질문: {state["user_query"]}
+        
+        환자 정보:
+        - 질병 단계: {state["patient_constraints"].disease_stage.value}
+        - 투석 여부: {'예' if state["patient_constraints"].on_dialysis else '아니오'}
+        
+        참고 자료:
+        {context}
+        
+        초안: {draft_response}
+        
+        위 정보를 바탕으로 환자에게 도움이 되는 답변을 작성하세요.
+        의료진과의 상담 필요성을 반드시 언급하세요.
+        """
+    
+    final_response = llm.predict(prompt)
+    state["final_response"] = final_response
+    
+    logger.info("General response generated")
+    state["processing_log"].append("답변 생성 완료")
+    logger.info("=== END GENERATE GENERAL RESPONSE ===\n")
+    
+    return state
+
+def route_after_classification(state: GraphState) -> str:
+    """태스크 분류 후 라우팅"""
+    task_type = state["task_type"]
+    
+    if task_type in [TaskType.DIET_RECOMMENDATION, TaskType.DIET_ANALYSIS]:
+        logger.info(f"Routing to diet_path for task type: {task_type.value}")
+        return "diet_path"
+    else:
+        logger.info(f"Routing to general_path for task type: {task_type.value}")
+        return "general_path"
+
+def route_diet_subtask(state: GraphState) -> str:
+    """식이 관련 세부 태스크 라우팅"""
+    if state["task_type"] == TaskType.DIET_RECOMMENDATION:
+        logger.info("Routing to meal_plan for diet recommendation")
+        return "meal_plan"
+    else:
+        logger.info("Routing to food_analysis for diet analysis")
+        return "food_analysis"
+
+def route_after_retrieve(state: GraphState) -> str:
+    """문서 검색 후 라우팅"""
+    if state["task_type"] in [TaskType.DIET_RECOMMENDATION, TaskType.DIET_ANALYSIS]:
+        logger.info("Routing to diet_response")
+        return "diet_response"
+    else:
+        logger.info("Routing to general_response")
+        return "general_response"
+
+# ========== Workflow 구성 ==========
+
+def create_kidney_disease_rag_workflow():
+    """신장질환 RAG 워크플로우 생성"""
+    logger.info("Creating kidney disease RAG workflow")
+    
+    workflow = StateGraph(GraphState)
+    
+    # 노드 추가
+    workflow.add_node("classify", classify_task)
+    workflow.add_node("retrieve", retrieve_context)
+    workflow.add_node("analyze_diet", analyze_diet_request)
+    workflow.add_node("generate_meal_plan", generate_meal_plan)
+    workflow.add_node("generate_diet_response", generate_diet_response)
+    workflow.add_node("generate_general_response", generate_general_response)
+    
+    # 시작점
+    workflow.set_entry_point("classify")
+    
+    # 분류 후 라우팅
+    workflow.add_conditional_edges(
+        "classify",
+        route_after_classification,
+        {
+            "diet_path": "analyze_diet",
+            "general_path": "retrieve"
+        }
+    )
+    
+    # 식이 경로 - 세부 분기
+    workflow.add_conditional_edges(
+        "analyze_diet",
+        route_diet_subtask,
+        {
+            "meal_plan": "generate_meal_plan",
+            "food_analysis": "retrieve"
+        }
+    )
+    
+    # 식단 생성 후 문서 검색
+    workflow.add_edge("generate_meal_plan", "retrieve")
+    
+    # 문서 검색 후 응답 생성으로 라우팅
+    workflow.add_conditional_edges(
+        "retrieve",
+        route_after_retrieve,
+        {
+            "diet_response": "generate_diet_response",
+            "general_response": "generate_general_response"
+        }
+    )
+    
+    # 최종 노드들은 END로
+    workflow.add_edge("generate_diet_response", END)
+    workflow.add_edge("generate_general_response", END)
+    
+    compiled_workflow = workflow.compile()
+    logger.info("Workflow compiled successfully")
+    
+    return compiled_workflow
+
+# ========== Streamlit UI ==========
+
+def main():
+    # 페이지 설정
+    st.set_page_config(
+        page_title="신장질환 AI 상담 시스템",
+        page_icon="🏥",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+    
+    # 사용자 정의 CSS
+    st.markdown("""
+        <style>
+        .main {
+            padding: 2rem;
+        }
+        .stButton>button {
+            background-color: #10b981;
+            color: white;
+            border-radius: 10px;
+            border: none;
+            padding: 0.5rem 1rem;
+            font-weight: bold;
+            transition: background-color 0.3s;
+        }
+        .stButton>button:hover {
+            background-color: #059669;
+        }
+        .chat-message {
+            padding: 1.5rem;
+            border-radius: 1rem;
+            margin-bottom: 1rem;
+            background-color: #f3f4f6;
+        }
+        .user-message {
+            background-color: #e0f2fe;
+        }
+        .assistant-message {
+            background-color: #f0fdf4;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+    
+    # Lottie 애니메이션 로드
+    def load_lottie_url(url: str):
+        try:
+            r = requests.get(url)
+            if r.status_code == 200:
+                return r.json()
+        except:
+            pass
+        return None
+    
+    # 헤더
+    col1, col2, col3 = st.columns([1, 2, 1])
+    with col2:
+        st.title("🏥 신장질환 AI 상담 시스템")
+        st.caption("맞춤형 의료 정보를 제공하는 AI 시스템 - OpenAI & LangGraph 기반")
+    
+    # 사이드바 - 환자 정보 입력
+    with st.sidebar:
+        st.header("⚙️ 설정")
+        
+        # API 키 입력
+        api_key = st.text_input(
+            "OpenAI API Key",
+            type="password",
+            placeholder="sk-...",
+            help="OpenAI API 키를 입력하세요"
+        )
+        
+        if api_key:
+            os.environ["OPENAI_API_KEY"] = api_key
+        
+        st.divider()
+        
+        st.header("👤 환자 정보")
+        
+        # 기본 정보
+        col1, col2 = st.columns(2)
+        with col1:
+            age = st.number_input("나이", min_value=0, max_value=150, value=65)
+            gender = st.selectbox("성별", ["남성", "여성"])
+        
+        with col2:
+            egfr = st.number_input("eGFR (ml/min)", min_value=0.0, max_value=150.0, value=25.0)
+        
+        disease_stage = st.selectbox(
+            "신장 질환 단계",
+            options=[stage.value for stage in DiseaseStage],
+            index=3  # CKD Stage 4
+        )
+        
+        on_dialysis = st.checkbox("투석 중", value=False)
+        
+        # 동반질환 및 약물
+        st.subheader("🏥 동반질환")
+        comorbidities = st.multiselect(
+            "동반질환 선택",
+            ["당뇨", "고혈압", "심부전", "간질환", "통풍"],
+            default=["당뇨", "고혈압"]
+        )
+        
+        st.subheader("💊 복용 약물")
+        medications = st.text_area(
+            "복용 중인 약물 (쉼표로 구분)",
+            value="ARB, 인결합제",
+            help="예: ARB, 인결합제, 베타차단제"
+        ).split(",")
+        medications = [med.strip() for med in medications if med.strip()]
+        
+        st.divider()
+        
+        # 영양 제한사항
+        st.header("🥗 영양 제한사항 (일일)")
+        
+        protein = st.number_input("단백질 (g)", min_value=0.0, value=40.0)
+        sodium = st.number_input("나트륨 (mg)", min_value=0.0, value=2000.0)
+        potassium = st.number_input("칼륨 (mg)", min_value=0.0, value=2000.0)
+        phosphorus = st.number_input("인 (mg)", min_value=0.0, value=800.0)
+        fluid = st.number_input("수분 (ml)", min_value=0.0, value=1500.0)
+        calorie = st.number_input("칼로리 (kcal)", min_value=0.0, value=1800.0)
+    
+    # 메인 영역
+    # 세션 상태 초기화
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+    
+    if "workflow" not in st.session_state:
+        st.session_state.workflow = None
+    
+    # 워크플로우 초기화
+    if api_key and st.session_state.workflow is None:
+        with st.spinner("시스템 초기화 중..."):
+            try:
+                st.session_state.workflow = create_kidney_disease_rag_workflow()
+                st.success("✅ 시스템이 준비되었습니다!")
+            except Exception as e:
+                st.error(f"초기화 실패: {e}")
+    
+    # 채팅 기록 표시
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+            
+            # 처리 로그가 있으면 표시
+            if "processing_log" in message:
+                with st.expander("🔍 처리 과정 보기"):
+                    for log in message["processing_log"]:
+                        st.caption(log)
+    
+    # 사용자 입력
+    if prompt := st.chat_input("신장질환에 대해 무엇이든 물어보세요..."):
+        if not api_key:
+            st.error("⚠️ OpenAI API 키를 입력해주세요!")
+            return
+        
+        if not st.session_state.workflow:
+            st.error("⚠️ 시스템이 초기화되지 않았습니다!")
+            return
+        
+        # 사용자 메시지 추가
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        
+        with st.chat_message("user"):
+            st.markdown(prompt)
+        
+        # AI 응답 생성
+        with st.chat_message("assistant"):
+            with st.spinner("생각 중..."):
+                try:
+                    # 환자 제약조건 생성
+                    patient_constraints = PatientConstraints(
+                        egfr=egfr,
+                        disease_stage=next(s for s in DiseaseStage if s.value == disease_stage),
+                        on_dialysis=on_dialysis,
+                        comorbidities=comorbidities,
+                        medications=medications,
+                        age=age,
+                        gender=gender,
+                        protein_restriction=protein,
+                        sodium_restriction=sodium,
+                        potassium_restriction=potassium,
+                        phosphorus_restriction=phosphorus,
+                        fluid_restriction=fluid,
+                        calorie_target=calorie
+                    )
+                    
+                    # 초기 상태 생성
+                    initial_state = GraphState(
+                        user_query=prompt,
+                        patient_constraints=patient_constraints,
+                        task_type=TaskType.GENERAL,
+                        draft_response="",
+                        draft_items=[],
+                        corrected_items=[],
+                        final_response="",
+                        catalog_results=[],
+                        iteration_count=0,
+                        error=None,
+                        food_analysis_results=None,
+                        recommended_foods=None,
+                        meal_plan=None,
+                        current_node="",
+                        processing_log=[]
+                    )
+                    
+                    # 워크플로우 실행
+                    result = st.session_state.workflow.invoke(initial_state)
+                    
+                    # 응답 표시
+                    response = result["final_response"]
+                    st.markdown(response)
+                    
+                    # 식단 계획이 있으면 표시
+                    if result.get("meal_plan"):
+                        st.divider()
+                        st.subheader("📋 추천 식단")
+                        
+                        meal_plan = result["meal_plan"]
+                        cols = st.columns(4)
+                        
+                        for idx, (meal_type, foods) in enumerate(meal_plan.items()):
+                            with cols[idx % 4]:
+                                st.markdown(f"**{meal_type.upper()}**")
+                                for food in foods[:3]:
+                                    nutrients = food.get_nutrients_per_serving(100)
+                                    st.caption(f"• {food.name}")
+                                    st.caption(f"  칼로리: {nutrients['calories']:.0f}kcal")
+                                    st.caption(f"  단백질: {nutrients['protein']:.1f}g")
+                    
+                    # 식품 분석 결과가 있으면 표시
+                    if result.get("food_analysis_results") and result["food_analysis_results"].get("mentioned_foods"):
+                        st.divider()
+                        st.subheader("🔍 식품 영양 분석")
+                        
+                        for food_info in result["food_analysis_results"]["mentioned_foods"]:
+                            col1, col2 = st.columns([1, 3])
+                            
+                            with col1:
+                                if food_info['suitable']:
+                                    st.success("✅ 적합")
+                                else:
+                                    st.warning("⚠️ 주의")
+                            
+                            with col2:
+                                st.markdown(f"**{food_info['name']}**")
+                                if not food_info['suitable']:
+                                    for issue in food_info['issues']:
+                                        st.caption(f"• {issue}")
+                                
+                                nutrients = food_info['nutrients']
+                                st.caption(
+                                    f"100g당: 단백질 {nutrients['protein']:.1f}g, "
+                                    f"나트륨 {nutrients['sodium']:.0f}mg, "
+                                    f"칼륨 {nutrients['potassium']:.0f}mg"
+                                )
+                    
+                    # 응답 저장
+                    message_data = {
+                        "role": "assistant",
+                        "content": response,
+                        "processing_log": result.get("processing_log", [])
+                    }
+                    st.session_state.messages.append(message_data)
+                    
+                except Exception as e:
+                    st.error(f"오류 발생: {str(e)}")
+                    logger.error(f"Error: {e}", exc_info=True)
+    
+    # 하단 정보
+    st.divider()
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.caption("⚠️ 이 시스템은 의료 정보 제공 목적이며, 실제 진료를 대체할 수 없습니다.")
+    
+    with col2:
+        if st.button("💬 새 대화 시작"):
+            st.session_state.messages = []
+            st.rerun()
+    
+    with col3:
+        if st.button("📥 대화 내용 다운로드"):
+            conversation = "\n\n".join([
+                f"{'사용자' if msg['role'] == 'user' else 'AI'}: {msg['content']}"
+                for msg in st.session_state.messages
+            ])
+            st.download_button(
+                label="다운로드",
+                data=conversation,
+                file_name=f"kidney_consultation_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt",
+                mime="text/plain"
+            )
+
+if __name__ == "__main__":
+    main()