fix: token

.dockerignore

@@ -0,0 +1,48 @@
+# .dockerignore (SimSimi AI Agent 프로젝트 최종 버전)
+
+# Git 관련 파일들
+# 이미지 안에 버전 관리 히스토리가 포함될 필요가 없습니다.
+.git
+.gitignore
+.gitattributes
+
+# Docker 관련 파일들
+# Dockerfile 자신이나 docker-compose 파일은 이미지에 포함되지 않습니다.
+Dockerfile
+docker-compose.yml
+docker-compose.override.yml
+
+# Python 캐시 및 가상 환경
+# 로컬의 캐시나 가상환경이 이미지에 복사되는 것을 방지합니다.
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.venv
+venv/
+env/
+
+# 민감 정보 (매우 중요)
+# .env 파일은 이미지에 절대 포함되면 안 됩니다.
+# 배포 환경에서는 'Secrets' 기능으로 주입해야 합니다.
+.env
+*.env
+
+# 로컬 데이터 및 로그
+# 데이터와 로그는 컨테이너 외부의 '볼륨(Volume)'으로 연결하여
+# 영구적으로 관리하는 것이 원칙입니다.
+data/
+logs/
+
+# IDE 및 OS 설정 파일
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store
+Thumbs.db
+
+# 문서 및 설치 스크립트
+# 실행되는 애플리케이션과 직접적인 관련이 없는 파일들입니다.
+README.md
+load_data.py

.gitattributes

@@ -0,0 +1,10 @@
+data/conversations/conversations.db filter=lfs diff=lfs merge=lfs -text
+data/chromadb/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text
+data/chromadb/*.bin filter=lfs diff=lfs merge=lfs -text
+data/chromadb/*.pickle filter=lfs diff=lfs merge=lfs -text
+*.db filter=lfs diff=lfs merge=lfs -text
+*.sqlite3 filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+data/**/*.bin filter=lfs diff=lfs merge=lfs -text
+data/**/*.pickle filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,58 @@
+# .gitignore (SimSimi AI Agent 프로젝트 최종 버전)
+
+# ===========================================
+#  보안: 환경 변수 및 민감 정보 (절대 업로드 금지!)
+# ===========================================
+.env
+*.env
+.env.*
+
+# ===========================================
+# 데이터 및 로그
+# data 폴더 전체를 무시하여, DB 파일 등이 올라가지 않도록 합니다.
+# 배포 환경에서는 load_data.py를 통해 새로 생성하는 것이 원칙입니다.
+# 응 업로드할거야.
+# ===========================================
+/data/
+/logs/
+*.log
+*.db
+*.sqlite3
+*.bin
+*.pickle
+
+# ===========================================
+# Python 자동 생성 파일
+# ===========================================
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# ===========================================
+# Python 가상 환경
+# ===========================================
+.venv/
+venv/
+env/
+ENV/
+
+# ===========================================
+# IDE 및 시스템 설정 파일
+# ===========================================
+.vscode/
+.idea/
+*.swp
+*.swo
+.DS_Store
+Thumbs.db
+
+# ===========================================
+# 의존성 및 빌드 관련
+# ===========================================
+.Python
+build/
+dist/
+*.egg-info/
+.installed.cfg
+*.egg

Dockerfile

@@ -0,0 +1,56 @@
+# Dockerfile
+
+# 1. 베이스 이미지 설정
+FROM python:3.10-slim
+
+# 2. 메타데이터
+LABEL maintainer="youdie006@naver.com"
+LABEL description="SimSimi-based Conversational AI Agent"
+LABEL version="1.0.0"
+
+# 3. 시스템 의존성 설치
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    curl \
+    git \
+    git-lfs \
+    && git lfs install \
+    && rm -rf /var/lib/apt/lists/*
+
+# 4. 작업 디렉토리 설정
+WORKDIR /app
+
+# 5. 환경 변수 설정
+ENV HF_HOME=/app/cache
+ENV HF_DATASETS_CACHE=/app/cache
+ENV TRANSFORMERS_CACHE=/app/cache
+
+# 6. Python 의존성 설치
+COPY requirements.txt .
+RUN pip install --upgrade pip
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 7. [최종 수정] 데이터 다운로드를 빌드 단계에서 미리 실행
+# 공개 데이터셋이므로 로그인 과정은 필요 없습니다.
+# ARG HF_TOKEN  <-- 이 줄 삭제
+# RUN huggingface-cli login --token $HF_TOKEN <-- 이 줄 삭제
+RUN huggingface-cli download \
+    youdie006/simsimi-ai-agent-data \
+    --repo-type dataset \
+    --local-dir /app/data \
+    --local-dir-use-symlinks False
+RUN chmod -R 777 /app/data /app/cache
+
+# 8. 애플리케이션 코드 복사
+COPY . .
+
+# 9. 포트 노출
+EXPOSE 8000
+
+# 10. 헬스체크
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/api/v1/health || exit 1
+
+# 11. 운영용 서버(Gunicorn)로 애플리케이션 실행
+CMD ["gunicorn", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "-b", "0.0.0.0:8000", "main:app"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 youdie006
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,57 @@
+---
+# 이 부분은 Hugging Face Space 설정에만 사용됩니다.
+# GitHub에서는 이 부분이 회색 코드 블록처럼 보입니다.
+title: 마음이 - 청소년 공감 AI 챗봇
+emoji: 💙
+colorFrom: purple
+colorTo: blue
+sdk: docker
+app_port: 8000
+pinned: false
+---
+
+# 💙 마음이 - 청소년 공감 AI 챗봇
+
+LLM과 고급 RAG(Retrieval-Augmented Generation) 파이프라인을 활용하여, 청소년들의 고민을 들어주고 공감해주는 AI 상담 챗봇 '마음이'입니다.
+
+## 🚀 라이브 데모
+
+https://huggingface.co/spaces/youdie006/simsimi_ai_agent
+
+---
+
+## 👨‍💻 개발자 및 평가자를 위한 가이드 
+
+### 주요 기능 및 기술적 특징
+
+본 프로젝트는 단순한 RAG를 넘어, 실제 운영 환경에서 발생할 수 있는 문제들을 해결하기 위한 고급 기법들을 적용했습니다.
+
+* **하이브리드 ReAct 파이프라인**: AI가 스스로 사고하고 행동하는 ReAct 패턴의 구조를 차용하되, Python 코드가 전체 흐름을 제어하여 안정성을 확보했습니다.
+* **대화형 쿼리 재작성 (Conversational Query Rewriting)**: 사용자와의 이전 대화 맥락을 AI가 이해하여, VectorDB 검색에 가장 최적화된 검색어를 동적으로 생성합니다.
+* **RAG 결과 검증 (Relevance Verification)**: 검색된 문서가 현재 대화와 정말 관련이 있는지 LLM을 통해 한번 더 검증하여, 관련 없는 정보가 답변에 사용되는 것을 원천적으로 차단합니다.
+
+### 기술 스택
+
+* **Backend**: FastAPI, Python
+* **LLM**: OpenAI GPT-4
+* **VectorDB**: ChromaDB
+* **Embedding Model**: `jhgan/ko-sbert-multitask`
+* **Deployment**: Docker, Hugging Face Spaces
+
+### 설치 및 실행 방법
+
+1.  **저장소 클론 및 환경 설정**
+    ```bash
+    git clone [https://github.com/youdie006/simsimi-ai-agent.git](https://github.com/youdie006/simsimi-ai-agent.git)
+    cd simsimi-ai-agent
+    # .env 파일 생성 및 OPENAI_API_KEY 설정
+    ```
+
+2.  **데이터베이스 구축**
+    * (이곳에 `load_data.py` 실행 방법 등 데이터 구축 과정을 설명합니다.)
+
+3.  **로컬 실행**
+    ```bash
+    docker-compose up --build
+    ```
+    이후 `http://localhost:8000` 에서 실행을 확인합니다.

aihub_Homework_LangChainAgents_20250601.ipynb

@@ -0,0 +1,1031 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "RPUwOvgUyZiz"
+      },
+      "source": [
+        "requiremenrs.txt\n",
+        "\n",
+        "langchain\n",
+        "langchain-openai\n",
+        "langchainhub # langchain python라이브러리로 프롬프트, 에이전트, 체인 관련 패키지 모음\n",
+        "langserve[all]\n",
+        "\n",
+        "faiss-cpu  # Facebook에서 개발 및 배포한 밀집 벡터의 유사도 측정, 클러스터링에 효율적인 라이브러리\n",
+        "tavily-python # 언어 모델에 중립적인 디자인으로, 모든 LLM과 통합이 가능하도록 설계된 검색 API\n",
+        "beautifulsoup4  #파이썬에서 사용할 수 있는 웹데이터 크롤링 라이브러리\n",
+        "wikipedia\n",
+        "\n",
+        "fastapi #  Python의 API를 빌드하기 위한 웹 프레임워크\n",
+        "uvicorn # ASGI(Asynchronous Server Gateway Interface) 서버\n",
+        "urllib3 # 파이썬에서 HTTP 요청을 보내고 받는 데 사용되는 강력하고 유연한 라이브러리\n",
+        "\n",
+        "python-dotenv\n",
+        "pypdf"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "NMMJXo_JyjhQ"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install langchain\n",
+        "!pip install langchain-openai\n",
+        "!pip install python-dotenv\n",
+        "!pip install langchain_community\n",
+        "!pip install pypdf\n",
+        "!pip install faiss-cpu\n",
+        "!pip install wikipedia\n",
+        "!pip install openai"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "jXEvb3WyJMcA"
+      },
+      "source": [
+        "Tavily Search 를 사용하기 위해서는 API KEY를 발급 받아 등록해야 함.\n",
+        "\n",
+        "[Tavily Search API 발급받기](https://app.tavily.com/sign-in)\n",
+        "\n",
+        "발급 받은 API KEY 를 다음과 같이 환경변수에 등록"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "RIxxUDEZI6ZR"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "\n",
+        "# TAVILY API KEY를 기입합니다.\n",
+        "os.environ[\"TAVILY_API_KEY\"] = \"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\"\n",
+        "\n",
+        "# 디버깅을 위한 프로젝트명을 기입합니다.\n",
+        "os.environ[\"LANGCHAIN_PROJECT\"] = \"AGENT TUTORIAL\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ys24Z3bfJHUf"
+      },
+      "outputs": [],
+      "source": [
+        "os.environ[\"OPENAI_API_KEY\"] = ''"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "sEii2SHNJbAG"
+      },
+      "outputs": [],
+      "source": [
+        "# API KEY를 환경변수로 관리하기 위한 설정 파일\n",
+        "from dotenv import load_dotenv\n",
+        "\n",
+        "# API KEY 정보로드\n",
+        "load_dotenv()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ezbT1NHQKP12"
+      },
+      "outputs": [],
+      "source": [
+        "#google drive load\n",
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "rKz2oCpl6lWK"
+      },
+      "outputs": [],
+      "source": [
+        "# training_dir_path = '/content/drive/MyDrive/2025_Bigdata_nlp_class/aihub_dataset/Training/02_label_data'\n",
+        "# validation_dir_path = '/content/drive/MyDrive/2025_Bigdata_nlp_class/aihub_dataset/Validation/02_label_data'"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "sWR_5-ANKJt-"
+      },
+      "source": [
+        "search.invoke 함수는 주어진 문자열에 대한 검색을 실행\n",
+        "\n",
+        "invoke() 함수에 검색하고 싶은 검색어를 넣어 검색을 수행"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "5mHSqB3_Kvf3"
+      },
+      "source": [
+        "#PDF 기반 문서 검색 도구: Retriever\n",
+        "\n",
+        "내부 데이터에 대해 조회를 수행할 retriever 생성.\n",
+        "\n",
+        "*   웹 기반 문서 로더, 문서 분할기, 벡터 저장소, 그리고 OpenAI 임베딩을 사용하여 문서 검색 시스템을 구축\n",
+        "*   PDF 문서를 FAISS DB 에 저장하고 조회하는 retriever 를 생성\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "IdP3zsje84fq"
+      },
+      "source": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "hnw_piOXK40_"
+      },
+      "outputs": [],
+      "source": [
+        "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
+        "from langchain_community.vectorstores import FAISS\n",
+        "from langchain_openai import OpenAIEmbeddings\n",
+        "from langchain.document_loaders import PyPDFLoader\n",
+        "from langchain_community.embeddings import HuggingFaceEmbeddings\n",
+        "import json\n",
+        "from langchain.document_loaders import TextLoader\n",
+        "from langchain.schema import Document\n",
+        "import unicodedata # Import the unicodedata module\n",
+        "\n",
+        "# PDF 파일 로드. 파일의 경로 입력\n",
+        "# 경로 설정\n",
+        "training_dir_path = \"/content/drive/MyDrive/2025_Bigdata_nlp_class/aihub_dataset/Training/02_label_data\"\n",
+        "\n",
+        "# for f in os.listdir(training_dir_path):\n",
+        "#     print(repr(f))  # unicode escape로 특수문자 확인\n",
+        "\n",
+        "documents = []\n",
+        "# === 1. JSON 파일 로드 + 파일명 정규화 → 메타데이터 추출 ===\n",
+        "def load_documents_with_metadata(folder_path):\n",
+        "    for raw_filename in os.listdir(folder_path):\n",
+        "        # 파일 시스템에서 읽은 원래 이름을 정규화(NFC) 처리\n",
+        "        filename = unicodedata.normalize(\"NFC\", raw_filename)\n",
+        "        file_path = os.path.join(folder_path, raw_filename)  # 실제 파일 경로는 raw_filename 써야 합니다.\n",
+        "        print(f\"▶ 처리 중 파일 (원본): {filename}\")\n",
+        "\n",
+        "        # 실제 파일인지 확인 (폴더나 시스템 파일 스킵)\n",
+        "        if not os.path.isfile(file_path):\n",
+        "            continue\n",
+        "        # .json 확장자가 아닌 파일 스킵\n",
+        "        if not filename.endswith(\".json\"):\n",
+        "            continue\n",
+        "\n",
+        "        try:\n",
+        "            # 정규화된 파일명 출력 (한글 조합형 → 완성형으로 변환됐는지 확인)\n",
+        "            print(f\"▶ 처리 중 파일 (정규화): {filename}\")\n",
+        "\n",
+        "            # 정규화된 파일명을 \"_\"로 분리\n",
+        "            # 예시: Empathy_기쁨_부모자녀_조손_343.json\n",
+        "            parts = filename.replace(\".json\", \"\").split(\"_\")\n",
+        "\n",
+        "            # parts[1] = 감정, parts[2] = 관계  (예: \"기쁨\", \"부모자녀\")\n",
+        "            if len(parts) >= 3:\n",
+        "                emotion = parts[1]\n",
+        "                relation = parts[2]\n",
+        "            else:\n",
+        "                emotion = \"unknown\"\n",
+        "                relation = \"unknown\"\n",
+        "\n",
+        "            # JSON 읽기\n",
+        "            with open(file_path, \"r\", encoding=\"utf-8\") as f:\n",
+        "                data = json.load(f)\n",
+        "                utterances = data.get(\"utterances\", [])\n",
+        "\n",
+        "                # 대화 utterance만 합쳐서 하나의 긴 텍스트로 만듦\n",
+        "                full_text = \"\\n\".join([utt.get(\"text\", \"\") for utt in utterances])\n",
+        "\n",
+        "                # 텍스트가 비어 있으면 스킵\n",
+        "                if full_text.strip() == \"\":\n",
+        "                    print(f\"  ⚠️ 내용 비어 있음 → 스킵: {filename}\")\n",
+        "                    continue\n",
+        "\n",
+        "                # Document 생성\n",
+        "                doc = Document(\n",
+        "                    page_content=full_text,\n",
+        "                    metadata={\n",
+        "                        \"filename\": filename,\n",
+        "                        \"emotion\": emotion,\n",
+        "                        \"relation\": relation\n",
+        "                    }\n",
+        "                )\n",
+        "                documents.append(doc)\n",
+        "\n",
+        "        except Exception as e:\n",
+        "            print(f\"❌ 오류 발생 ({filename}): {e}\")\n",
+        "\n",
+        "    return documents\n",
+        "\n",
+        "\n",
+        "documents = load_documents_with_metadata(training_dir_path)\n",
+        "print(f\"✅ 로드된 원본 문서 수: {len(documents)}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "d_1DPQehD6o6"
+      },
+      "outputs": [],
+      "source": [
+        "# === 2. 문서 분할 함수 ===\n",
+        "def split_documents(documents):\n",
+        "    splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)\n",
+        "    return splitter.split_documents(documents)\n",
+        "\n",
+        "\n",
+        "# === 3. FAISS DB 생성 ===\n",
+        "def create_faiss_db(docs):\n",
+        "    embeddings = OpenAIEmbeddings()\n",
+        "    vectorstore = FAISS.from_documents(docs, embeddings)\n",
+        "    return vectorstore\n",
+        "\n",
+        "def filtered_similarity_search(vectorstore, query, emotion=None, relation=None, k=3):\n",
+        "    # docstore 내 모든 Document 객체 가져오기\n",
+        "    all_docs = list(vectorstore.docstore._dict.values())\n",
+        "\n",
+        "    # 1차 감정(emotion), 2차 관계(relation) 필터링\n",
+        "    filtered_docs = []\n",
+        "    for doc in all_docs:\n",
+        "        doc_em = doc.metadata.get(\"emotion\", \"\")\n",
+        "        doc_rel = doc.metadata.get(\"relation\", \"\")\n",
+        "        if emotion and doc_em != emotion:\n",
+        "            continue\n",
+        "        if relation and doc_rel != relation:\n",
+        "            continue\n",
+        "        filtered_docs.append(doc)\n",
+        "\n",
+        "    if not filtered_docs:\n",
+        "        print(\"❗ 해당 감정/관계 조건의 문서가 없습니다.\")\n",
+        "        return []\n",
+        "\n",
+        "    # 필터링된 문서를 임베딩해서 별도의 FAISS 인덱스로 만들 수도 있지만,\n",
+        "    # 여기서는 간단히 vectorstore.similarity_search() 호출 → 결과에서 필터 적용\n",
+        "    # (단, 필요하다면 filtered_docs만으로 새로운 FAISS 인덱스를 생성 후 검색할 수도 있습니다.)\n",
+        "    results = vectorstore.similarity_search(query, k=k)\n",
+        "\n",
+        "    # 검색 결과 중에서도 meta 필터(감정/관계)가 맞는 것만 리턴\n",
+        "    return [doc for doc in results\n",
+        "            if (not emotion or doc.metadata.get(\"emotion\") == emotion)\n",
+        "            and (not relation or doc.metadata.get(\"relation\") == relation)]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "_v_45KX6GKQ_"
+      },
+      "outputs": [],
+      "source": [
+        "# 2) 문서 분할 (chunking)\n",
+        "split_docs = split_documents(documents)\n",
+        "print(f\"✅ 분할된 문서 청크 개수: {len(split_docs)}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "wAIBhXq4H68s"
+      },
+      "outputs": [],
+      "source": [
+        "# 예시: split_docs 리스트에서 앞의 10개 문서만 확인하는 코드\n",
+        "\n",
+        "# (이전 단계에서 이미 split_docs를 생성했다고 가정)\n",
+        "# split_docs = split_documents(documents)\n",
+        "\n",
+        "# 앞 10개 문서만 출력\n",
+        "for idx, doc in enumerate(split_docs[:5], start=1):\n",
+        "    print(f\"--- 문서 #{idx} ---\")\n",
+        "    print(f\"파일명    : {doc.metadata.get('filename')}\")\n",
+        "    print(f\"감정      : {doc.metadata.get('emotion')}\")\n",
+        "    print(f\"관계      : {doc.metadata.get('relation')}\")\n",
+        "    print(\"내용 (일부) :\")\n",
+        "    print(doc.page_content[:200].replace(\"\\n\", \" \") + \"...\\n\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "98_fnjppGVhc"
+      },
+      "outputs": [],
+      "source": [
+        "# 3) FAISS DB 생성\n",
+        "if not split_docs:\n",
+        "  raise RuntimeError(\"❌ 분할된 문서가 없어서 FAISS 생성이 불가능합니다.\")\n",
+        "faiss_db = create_faiss_db(split_docs)\n",
+        "print(\"✅ FAISS DB 생성 완료\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "rEtEXpKTRQ2_"
+      },
+      "outputs": [],
+      "source": [
+        "# 저장/로딩할 FAISS 인덱스 폴더 경로\n",
+        "index_dir = \"/content/drive/MyDrive/2025_Bigdata_nlp_class/faiss_index\"\n",
+        "\n",
+        "# --- (1) 이미 저장된 인덱스가 있는지 확인 ---\n",
+        "if os.path.isdir(index_dir) and \\\n",
+        "   os.path.exists(os.path.join(index_dir, \"index.faiss\")):\n",
+        "    # 저장된 인덱스가 있으면 로드\n",
+        "    embeddings = OpenAIEmbeddings()\n",
+        "    # allow_dangerous_deserialization=True 를 추가하여 로딩을 허용합니다.\n",
+        "    faiss_db = FAISS.load_local(index_dir, embeddings, allow_dangerous_deserialization=True)\n",
+        "    print(\"✅ 기존 FAISS 인덱스를 불러왔습니다:\", index_dir)\n",
+        "\n",
+        "else:\n",
+        "    # 저장된 인덱스가 없으면 새로 생성\n",
+        "    # ① 여기에 split_docs를 미리 생성하는 코드를 넣으세요\n",
+        "    #    예시: split_docs = split_documents(documents)\n",
+        "    #\n",
+        "    # ② create_faiss_db 함수나 직접 임베딩 + 저장 로직을 호출\n",
+        "    #\n",
+        "    # 예시:\n",
+        "    # split_docs = split_documents(documents)\n",
+        "    # embeddings = OpenAIEmbeddings()\n",
+        "    # faiss_db = FAISS.from_documents(split_docs, embeddings)\n",
+        "    #\n",
+        "    # 실제 프로젝트에 맞게 아래 두 줄을 수정하세요:\n",
+        "    faiss_db = create_faiss_db(split_docs)\n",
+        "    embeddings = OpenAIEmbeddings()\n",
+        "\n",
+        "    # --- (2) 생성된 FAISS를 로컬에 저장 ---\n",
+        "    os.makedirs(index_dir, exist_ok=True)\n",
+        "    faiss_db.save_local(index_dir)\n",
+        "    print(\"✅ 새로 FAISS 인덱스를 생성하고 저장했습니다:\", index_dir)\n",
+        "\n",
+        "# 이후 faiss_db를 retriever로 사용 가능합니다.\n",
+        "# 예시:\n",
+        "retriever = faiss_db.as_retriever()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "0w4Xzp6FJzD1"
+      },
+      "outputs": [],
+      "source": [
+        "# === 4. 사용자 검색 함수 (감정 + 관계 필터) ===\n",
+        "def filtered_similarity_search(vectorstore, query, emotion=None, relation=None, k=3):\n",
+        "    # 필터링\n",
+        "    all_docs = vectorstore.docstore._dict.values()\n",
+        "    filtered_docs = [\n",
+        "        doc for doc in all_docs\n",
+        "        if (emotion is None or doc.metadata.get(\"emotion\") == emotion)\n",
+        "        and (relation is None or relation in doc.metadata.get(\"relation\"))\n",
+        "    ]\n",
+        "\n",
+        "    if not filtered_docs:\n",
+        "        print(\"❗해당 조건의 문서가 없습니다.\")\n",
+        "        return []\n",
+        "\n",
+        "    # 유사도 기반 검색\n",
+        "    splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)\n",
+        "    query_chunks = splitter.split_text(query)\n",
+        "    search_results = []\n",
+        "    for chunk in query_chunks:\n",
+        "        search_results.extend(vectorstore.similarity_search(chunk, k=k))\n",
+        "    return search_results"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "wE5IY8l5KH0T"
+      },
+      "outputs": [],
+      "source": [
+        "# === 예시 검색 ===\n",
+        "query = \"아기를 키우는 게 너무 힘들어요. 조언이 필요해요.\"\n",
+        "results = filtered_similarity_search(faiss_db, query, emotion=\"기쁨\", relation=\"부모자녀\")\n",
+        "\n",
+        "for i, doc in enumerate(results):\n",
+        "    print(f\"\\n✅ 검색 결과 {i+1}\")\n",
+        "    print(f\"파일명: {doc.metadata['filename']}\")\n",
+        "    print(f\"감정: {doc.metadata['emotion']} / 관계: {doc.metadata['relation']}\")\n",
+        "    print(doc.page_content[:300] + \"...\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Ay3lQq-RK_AE"
+      },
+      "outputs": [],
+      "source": [
+        "import openai\n",
+        "\n",
+        "# OpenAI API 키 설정\n",
+        "class config:\n",
+        "    OPENAI_API_KEY = \"\"\n",
+        "\n",
+        "openai.api_key = config.OPENAI_API_KEY\n",
+        "\n",
+        "# ─── 2) GPT-4o(또는 GPT-4o-mini)를 사용해 “가장 적절한” 문서를 고르는 함수 ───────────────────\n",
+        "def choose_best_doc_with_gpt(query, docs, model=\"gpt-4o-mini\"):\n",
+        "    \"\"\"\n",
+        "    query: 사용자의 원래 질문\n",
+        "    docs: filtered_similarity_search에서 반환된 Document 객체 리스트\n",
+        "    model: \"gpt-4o\" 또는 \"gpt-4o-mini\"\n",
+        "    반환: (best_doc, gpt_explanation)\n",
+        "    \"\"\"\n",
+        "    # (A) 프롬프트 구성\n",
+        "    prompt_parts = [\n",
+        "        \"당신은 대화 응답 후보를 평가하는 전문가입니다.\\n\",\n",
+        "        f\"사용자 질문: \\\"{query}\\\"\\n\",\n",
+        "        \"다음은 검색된 응답 후보들입니다.\\n\"\n",
+        "    ]\n",
+        "\n",
+        "    for idx, doc in enumerate(docs, start=1):\n",
+        "        snippet = doc.page_content.strip().replace(\"\\n\", \" \")\n",
+        "        if len(snippet) > 300:\n",
+        "            snippet = snippet[:300] + \"...\"\n",
+        "        prompt_parts.append(\n",
+        "            f\"[{idx}]\\n\"\n",
+        "            f\"Filename: {doc.metadata.get('filename')}\\n\"\n",
+        "            f\"Emotion: {doc.metadata.get('emotion')}, Relation: {doc.metadata.get('relation')}\\n\"\n",
+        "            f\"Content: \\\"{snippet}\\\"\\n\"\n",
+        "        )\n",
+        "\n",
+        "    prompt_parts.append(\n",
+        "        \"\\n위 후보들 중에서, 사용자 질문에 가장 적절한 응답을 하나 선택하고, 그 이유를 간단히 설명해주세요.\\n\"\n",
+        "        \"반드시 다음 형식으로 응답해야 합니다:\\n\"\n",
+        "        \"선택: [번호]\\n\"\n",
+        "        \"이유: [이유]\\n\"\n",
+        "    )\n",
+        "\n",
+        "    full_prompt = \"\\n\".join(prompt_parts)\n",
+        "\n",
+        "    # (B) GPT-4o 호출\n",
+        "    response = openai.chat.completions.create(\n",
+        "        model=model,\n",
+        "        messages=[\n",
+        "            {\"role\": \"system\", \"content\": \"당신은 뛰어난 대화 평가자입니다.\"},\n",
+        "            {\"role\": \"user\", \"content\": full_prompt}\n",
+        "        ],\n",
+        "        max_tokens=300,\n",
+        "        temperature=0.0\n",
+        "    )\n",
+        "\n",
+        "    gpt_reply = response.choices[0].message.content.strip()\n",
+        "\n",
+        "    # (C) GPT가 반환한 '선택: [번호]' 파싱\n",
+        "    selected_idx = None\n",
+        "    for line in gpt_reply.splitlines():\n",
+        "        if line.strip().startswith(\"선택\"):\n",
+        "            import re\n",
+        "            m = re.search(r\"\\[(\\d+)\\]\", line)\n",
+        "            if m:\n",
+        "                selected_idx = int(m.group(1))\n",
+        "                break\n",
+        "\n",
+        "    # 파싱 실패 시 기본 1번 선택\n",
+        "    if selected_idx is None or selected_idx < 1 or selected_idx > len(docs):\n",
+        "        selected_idx = 1\n",
+        "\n",
+        "    best_doc = docs[selected_idx - 1]\n",
+        "    return best_doc, gpt_reply\n",
+        "\n",
+        "\n",
+        "# ─── 3) 예시 검색 + GPT-4o 최종 선택 ───────────────────────────────────────────────\n",
+        "if __name__ == \"__main__\":\n",
+        "    # (가정) faiss_db는 이미 생성되어 로드된 FAISS 인덱스 객체입니다.\n",
+        "    # 예: faiss_db = FAISS.load_local(index_dir, OpenAIEmbeddings())\n",
+        "\n",
+        "    # ① 조회할 사용자 질의\n",
+        "    query = \"아기를 키우는 게 너무 힘들어요. 조언이 필요해요.\"\n",
+        "\n",
+        "    # ② 기존 검색 함수 그대로 사용\n",
+        "    results = filtered_similarity_search(faiss_db, query, emotion=\"기쁨\", relation=\"부모자녀\")\n",
+        "\n",
+        "    # ③ 검색 결과 출력\n",
+        "    for i, doc in enumerate(results, start=1):\n",
+        "        print(f\"\\n✅ 검색 결과 {i}\")\n",
+        "        print(f\"파일명: {doc.metadata['filename']}\")\n",
+        "        print(f\"감정: {doc.metadata['emotion']} / 관계: {doc.metadata['relation']}\")\n",
+        "        print(doc.page_content[:300] + \"...\\n\")\n",
+        "\n",
+        "    # ④ 검색 결과가 있으면, GPT-4o로 \"가장 적절한\" 문서 선택\n",
+        "    if results:\n",
+        "        best_doc, explanation = choose_best_doc_with_gpt(query, results, model=\"gpt-4o-mini\")\n",
+        "\n",
+        "        print(\"\\n\\n=== GPT-4o가 선택한 최종 응답 ===\")\n",
+        "        print(f\"■ 선택된 파일명: {best_doc.metadata['filename']}\")\n",
+        "        print(f\"■ 선택 이유:\\n{explanation}\\n\")\n",
+        "        print(f\"■ 최종 응답 내용:\\n{best_doc.page_content}\")\n",
+        "    else:\n",
+        "        print(\"❗ 검색 결과가 없어 GPT 평가를 진행할 수 없습니다.\")\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "7hNWJkaTSOC9"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import openai\n",
+        "import unicodedata\n",
+        "from langchain.schema import Document\n",
+        "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
+        "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+        "from langchain.vectorstores import FAISS\n",
+        "\n",
+        "# ─── 0) OpenAI API 키 설정 ─────────────────────────────────────────────────\n",
+        "openai.api_key = os.getenv(\"OPENAI_API_KEY\")\n",
+        "\n",
+        "\n",
+        "# ─── 1) 사용자 검색 함수 그대로 ────────────────────────────────────────────────\n",
+        "def filtered_similarity_search(vectorstore, query, emotion=None, relation=None, k=3):\n",
+        "    all_docs = vectorstore.docstore._dict.values()\n",
+        "    filtered_docs = [\n",
+        "        doc for doc in all_docs\n",
+        "        if (emotion is None or doc.metadata.get(\"emotion\") == emotion)\n",
+        "        and (relation is None or relation in doc.metadata.get(\"relation\"))\n",
+        "    ]\n",
+        "\n",
+        "    if not filtered_docs:\n",
+        "        print(\"❗ 해당 조건의 문서가 없습니다.\")\n",
+        "        return []\n",
+        "\n",
+        "    splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)\n",
+        "    query_chunks = splitter.split_text(query)\n",
+        "\n",
+        "    search_results = []\n",
+        "    for chunk in query_chunks:\n",
+        "        search_results.extend(vectorstore.similarity_search(chunk, k=k))\n",
+        "    return search_results\n",
+        "\n",
+        "\n",
+        "# ─── 2) GPT-4o로 “최적 후보 선택 + 이유 설명” 함수 (v1 API) ───────────────────────────\n",
+        "def choose_best_doc_with_gpt(query, docs, model=\"gpt-4o-mini\"):\n",
+        "    \"\"\"\n",
+        "    query: 사용자의 원래 질문\n",
+        "    docs: filtered_similarity_search에서 반환된 Document 리스트\n",
+        "    model: \"gpt-4o\" 또는 \"gpt-4o-mini\"\n",
+        "    반환: (best_doc, gpt_reason)\n",
+        "      - best_doc: GPT가 선택한 Document 객체\n",
+        "      - gpt_reason: \"선택: [번호]\\n이유: ...\" 형태의 문자열\n",
+        "    \"\"\"\n",
+        "    prompt_parts = [\n",
+        "        \"당신은 후보 응답을 평가하는 전문가입니다.\\n\",\n",
+        "        f\"사용자 질문: \\\"{query}\\\"\\n\",\n",
+        "        \"다음은 검색된 응답 후보들입니다.\\n\"\n",
+        "    ]\n",
+        "\n",
+        "    for idx, doc in enumerate(docs, start=1):\n",
+        "        snippet = doc.page_content.strip().replace(\"\\n\", \" \")\n",
+        "        if len(snippet) > 300:\n",
+        "            snippet = snippet[:300] + \"...\"\n",
+        "        prompt_parts.append(\n",
+        "            f\"[{idx}]\\n\"\n",
+        "            f\"Filename: {doc.metadata.get('filename')}\\n\"\n",
+        "            f\"Emotion: {doc.metadata.get('emotion')}, Relation: {doc.metadata.get('relation')}\\n\"\n",
+        "            f\"Content: \\\"{snippet}\\\"\\n\"\n",
+        "        )\n",
+        "\n",
+        "    prompt_parts.append(\n",
+        "        \"\\n위 후보들 중에서, 사용자 질문에 가장 적절한 응답을 한 개만 선택하고, 그 이유를 간단히 설명해주세요.\\n\"\n",
+        "        \"반드시 다음 형식으로 응답해 주세요:\\n\"\n",
+        "        \"선택: [번호]\\n\"\n",
+        "        \"이유: [간단한 설명]\\n\"\n",
+        "    )\n",
+        "\n",
+        "    full_prompt = \"\\n\".join(prompt_parts)\n",
+        "\n",
+        "    # ── OpenAI Chat Completions 호출 ─────────────────────────────────────────────\n",
+        "    response = openai.chat.completions.create(\n",
+        "        model=model,\n",
+        "        messages=[\n",
+        "            {\"role\": \"system\", \"content\": \"당신은 뛰어난 대화 평가자입니다.\"},\n",
+        "            {\"role\": \"user\", \"content\": full_prompt}\n",
+        "        ],\n",
+        "        max_tokens=300,\n",
+        "        temperature=0.0\n",
+        "    )\n",
+        "\n",
+        "    gpt_reply = response.choices[0].message.content.strip()\n",
+        "\n",
+        "    # “선택: [번호]” 파싱\n",
+        "    selected_idx = None\n",
+        "    for line in gpt_reply.splitlines():\n",
+        "        if line.strip().startswith(\"선택\"):\n",
+        "            import re\n",
+        "            m = re.search(r\"\\[(\\d+)\\]\", line)\n",
+        "            if m:\n",
+        "                selected_idx = int(m.group(1))\n",
+        "                break\n",
+        "\n",
+        "    # 파싱 실패 시 기본 1번\n",
+        "    if selected_idx is None or selected_idx < 1 or selected_idx > len(docs):\n",
+        "        selected_idx = 1\n",
+        "\n",
+        "    best_doc = docs[selected_idx - 1]\n",
+        "    return best_doc, gpt_reply\n",
+        "\n",
+        "\n",
+        "# ─── 3) “선택된 후보를 간결하게 재작성” 함수 ─────────────────────────────────────\n",
+        "def generate_final_answer(query, best_doc, model=\"gpt-4o-mini\"):\n",
+        "    \"\"\"\n",
+        "    query: 사용자의 원래 질문\n",
+        "    best_doc: choose_best_doc_with_gpt가 반환한 Document 객체\n",
+        "    model: \"gpt-4o\" 또는 \"gpt-4o-mini\"\n",
+        "    반환: GPT가 생성한 최종 사용자용 응답(불필요한 부분 제거된 형태)\n",
+        "    \"\"\"\n",
+        "    # (A) 프롬프트 구성: “최종 응답 후보”를 직접 재작성하도록 요청\n",
+        "    prompt = (\n",
+        "        \"다음은 사용자의 질문과, 선택된 최적 응답 후보입니다.\\n\\n\"\n",
+        "        f\"사용자 질문: \\\"{query}\\\"\\n\"\n",
+        "        \"선택된 후보 응답 내용(원문):\\n\"\n",
+        "        f\"\\\"\\\"\\\"\\n{best_doc.page_content}\\n\\\"\\\"\\\"\\n\\n\"\n",
+        "        \"위 원문에서, 불필요한 반복/인사말/개인정보 등은 모두 제거하고, \"\n",
+        "        \"사용자가 이해하기 쉽도록 핵심만 남겨 간결하게 재작성해주세요.\\n\"\n",
+        "        \"문체는 친절하고 공감 가득한 톤을 유지해 주시고, \"\n",
+        "        \"최종 답변만 출력해 주세요.\"\n",
+        "    )\n",
+        "\n",
+        "    # (B) GPT-4o 호출\n",
+        "    response = openai.chat.completions.create(\n",
+        "        model=model,\n",
+        "        messages=[\n",
+        "            {\"role\": \"system\", \"content\": \"당신은 친절하고 공감능력이 뛰어난 상담사입니다.\"},\n",
+        "            {\"role\": \"user\", \"content\": prompt}\n",
+        "        ],\n",
+        "        max_tokens=300,\n",
+        "        temperature=0.7\n",
+        "    )\n",
+        "\n",
+        "    final_answer = response.choices[0].message.content.strip()\n",
+        "    return final_answer\n",
+        "\n",
+        "\n",
+        "# ─── 4) 전체 흐름 예시 ────────────────────────────────────────────────────────\n",
+        "if __name__ == \"__main__\":\n",
+        "    # (가정) faiss_db는 이미 생성/로드된 FAISS 인덱스 객체입니다.\n",
+        "    # 예: faiss_db = FAISS.load_local(index_dir, OpenAIEmbeddings())\n",
+        "\n",
+        "    # ① 사용자 질의\n",
+        "    query = \"아기를 키우는 게 너무 힘들어요. 조언이 필요해요.\"\n",
+        "\n",
+        "    # ② 기존 검색 함수 그대로 사용\n",
+        "    results = filtered_similarity_search(faiss_db, query, emotion=\"기쁨\", relation=\"부모자녀\")\n",
+        "\n",
+        "    # ③ 검색 결과 출력 (원본 후보 3개)\n",
+        "    for i, doc in enumerate(results, start=1):\n",
+        "        print(f\"\\n✅ 검색 결과 {i}\")\n",
+        "        print(f\"파일명: {doc.metadata['filename']}\")\n",
+        "        print(f\"감정: {doc.metadata['emotion']} / 관계: {doc.metadata['relation']}\")\n",
+        "        print(doc.page_content[:300] + \"...\\n\")\n",
+        "\n",
+        "    # ④ 검색 결과가 있으면, GPT-4o로 “가장 적절한” 문서 선택 + 이유 얻기\n",
+        "    if results:\n",
+        "        best_doc, explanation = choose_best_doc_with_gpt(query, results, model=\"gpt-4o-mini\")\n",
+        "        print(\"\\n\\n=== GPT-4o가 선택한 최종 응답 후보 ===\")\n",
+        "        print(f\"■ 선택된 파일명: {best_doc.metadata['filename']}\")\n",
+        "        print(f\"■ 선택 이유:\\n{explanation}\\n\")\n",
+        "\n",
+        "        # ⑤ 선택된 후보를 재작성하여 최종 답변 생성\n",
+        "        cleaned_answer = generate_final_answer(query, best_doc, model=\"gpt-4o-mini\")\n",
+        "        print(\"=== 최종 사용자 응답 (불필요한 내용 제거됨) ===\")\n",
+        "        print(cleaned_answer)\n",
+        "\n",
+        "    else:\n",
+        "        print(\"❗ 검색 결과가 없어 GPT 평가를 진행할 수 없습니다.\")\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Pk55HkBQSW_s"
+      },
+      "outputs": [],
+      "source": [
+        "# ─── 예시: 여러 개의 query를 한 번에 처리해 보는 코드 ─────────────────────\n",
+        "\n",
+        "# (가정) 이미 아래 함수들이 정의되어 있고, faiss_db도 생성/로드되어 있다고 봅니다.\n",
+        "# - filtered_similarity_search(vectorstore, query, emotion, relation)\n",
+        "# - choose_best_doc_with_gpt(query, docs, model)\n",
+        "# - generate_final_answer(query, best_doc, model)\n",
+        "\n",
+        "# 1) 테스트할 질의 리스트를 정의\n",
+        "queries = [\n",
+        "    \"아기를 키우는 일을 시작하려는데, 어떻게 준비해야 할까요?\",\n",
+        "    \"아이가 자꾸 밤에 깨서 낮잠도 잘 못 자요. 어떻게 도와줄 수 있을까요?\",\n",
+        "    \"육아 스트레스를 푸는 방법이 있을까요?\",\n",
+        "    \"첫 돌 지난 아기가 말을 잘 안 들을 때 어떻게 해야 하나요?\",\n",
+        "    \"아기가 갑자기 울음을 멈추지 않아서 당황스러워요. 조언 부탁드려요.\"\n",
+        "]\n",
+        "\n",
+        "# 2) 감정(emotion)과 관계(relation) 예시는 고정해도 되고,\n",
+        "#    아니면 query별로 달리 지정해도 됩니다. 여기서는 예시로 전부 \"기쁨\"/\"부모자녀\"로 가정.\n",
+        "emotion = \"기쁨\"\n",
+        "relation = \"부모자녀\"\n",
+        "\n",
+        "# 3) 각 query 순회하면서 단계별로 결과 출력\n",
+        "for idx, q in enumerate(queries, start=1):\n",
+        "    print(f\"\\n\\n========== Query #{idx} ==========\")\n",
+        "    print(f\"사용자 질문: {q}\\n\")\n",
+        "\n",
+        "    # 3-1) 감정/관계 필터 + FAISS 유사도 검색 → 후보 3개 가져오기\n",
+        "    candidates = filtered_similarity_search(faiss_db, q, emotion=emotion, relation=relation)\n",
+        "    if not candidates:\n",
+        "        print(\"❗ 조건에 맞는 문서가 없습니다. 다음 질의로 넘어갑니다.\")\n",
+        "        continue\n",
+        "\n",
+        "    # 3-2) 후보 원문 간단 출력\n",
+        "    print(\"■ 검색된 후보 (최대 3개):\")\n",
+        "    for i, doc in enumerate(candidates, start=1):\n",
+        "        print(f\"\\n[후보 {i}] 파일명: {doc.metadata['filename']}\")\n",
+        "        print(f\"감정: {doc.metadata['emotion']}, 관계: {doc.metadata['relation']}\")\n",
+        "        print(doc.page_content[:200].replace(\"\\n\", \" \") + \"...\\n\")\n",
+        "\n",
+        "    # 3-3) GPT-4o에게 “가장 적절한 후보 선택 + 이유” 요청\n",
+        "    best_doc, choice_reason = choose_best_doc_with_gpt(q, candidates, model=\"gpt-4o-mini\")\n",
+        "    print(\"\\n■ GPT-4o가 선택한 후보:\")\n",
+        "    print(f\"  • 선택된 파일명: {best_doc.metadata['filename']}\")\n",
+        "    print(f\"  • 선택 이유:\\n{choice_reason}\\n\")\n",
+        "\n",
+        "    # 3-4) 선택된 후보를 다듬어서 최종 답변 생성\n",
+        "    final_answer = generate_final_answer(q, best_doc, model=\"gpt-4o-mini\")\n",
+        "    print(\"■ 최종 사용자 응답 (정제된 텍스트):\")\n",
+        "    print(final_answer)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "UJAUt5feYme_"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install gradio"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "DDPtd5xgYxfn"
+      },
+      "outputs": [],
+      "source": [
+        "import gradio as gr\n",
+        "import os\n",
+        "import openai\n",
+        "import unicodedata\n",
+        "import json\n",
+        "from langchain.schema import Document\n",
+        "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
+        "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+        "from langchain.vectorstores import FAISS\n",
+        "\n",
+        "# ─── 0) OpenAI API 키 설정 ─────────────────────────────────────────────────\n",
+        "openai.api_key = os.getenv(\"OPENAI_API_KEY\")\n",
+        "\n",
+        "# ─── 1) JSON 로드 + 메타데이터 추출 함수 ─────────────────────────────────────────\n",
+        "def load_documents_with_metadata(folder_path):\n",
+        "    documents = []\n",
+        "    for raw_filename in os.listdir(folder_path):\n",
+        "        filename = unicodedata.normalize(\"NFC\", raw_filename)\n",
+        "        file_path = os.path.join(folder_path, raw_filename)\n",
+        "\n",
+        "        if not os.path.isfile(file_path):\n",
+        "            continue\n",
+        "        if not filename.endswith(\".json\"):\n",
+        "            continue\n",
+        "\n",
+        "        try:\n",
+        "            parts = filename.replace(\".json\", \"\").split(\"_\")\n",
+        "            emotion = parts[1] if len(parts) > 1 else \"unknown\"\n",
+        "            relation = parts[2] if len(parts) > 2 else \"unknown\"\n",
+        "\n",
+        "            with open(file_path, \"r\", encoding=\"utf-8\") as f:\n",
+        "                data = json.load(f)\n",
+        "                utterances = data.get(\"utterances\", [])\n",
+        "                full_text = \"\\n\".join([utt.get(\"text\",\"\") for utt in utterances])\n",
+        "                if full_text.strip() == \"\":\n",
+        "                    continue\n",
+        "\n",
+        "                doc = Document(\n",
+        "                    page_content=full_text,\n",
+        "                    metadata={\"filename\": filename, \"emotion\": emotion, \"relation\": relation}\n",
+        "                )\n",
+        "                documents.append(doc)\n",
+        "        except Exception as e:\n",
+        "            print(f\"❌ 오류 발생 ({filename}): {e}\")\n",
+        "\n",
+        "    return documents\n",
+        "\n",
+        "# ─── 2) 문서 분할 함수 ─────────────────────────────────────────────────────\n",
+        "def split_documents(documents):\n",
+        "    splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)\n",
+        "    return splitter.split_documents(documents)\n",
+        "\n",
+        "# ─── 3) FAISS 인덱스 생성 혹은 로드 함수 ───────────────────────────────────\n",
+        "def create_or_load_faiss(index_dir, split_docs):\n",
+        "    embeddings = OpenAIEmbeddings()\n",
+        "    if os.path.isdir(index_dir) and os.path.exists(os.path.join(index_dir, \"index.faiss\")):\n",
+        "        faiss_db = FAISS.load_local(index_dir, embeddings, allow_dangerous_deserialization=True)\n",
+        "        print(\"✅ 기존 FAISS 인덱스를 로드했습니다.\")\n",
+        "    else:\n",
+        "        faiss_db = FAISS.from_documents(split_docs, embeddings)\n",
+        "        os.makedirs(index_dir, exist_ok=True)\n",
+        "        faiss_db.save_local(index_dir)\n",
+        "        print(\"✅ 새로운 FAISS 인덱스를 생성하고 저장했습니다.\")\n",
+        "    return faiss_db\n",
+        "\n",
+        "# ─── 4) 필터 + 유사도 검색 함수 ────────────────────────────────────────────────\n",
+        "def filtered_similarity_search(vectorstore, query, emotion=None, relation=None, k=3):\n",
+        "    all_docs = vectorstore.docstore._dict.values()\n",
+        "    filtered_docs = [\n",
+        "        doc for doc in all_docs\n",
+        "        if (emotion is None or doc.metadata.get(\"emotion\") == emotion)\n",
+        "        and (relation is None or relation in doc.metadata.get(\"relation\"))\n",
+        "    ]\n",
+        "\n",
+        "    if not filtered_docs:\n",
+        "        return []\n",
+        "\n",
+        "    splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)\n",
+        "    query_chunks = splitter.split_text(query)\n",
+        "\n",
+        "    search_results = []\n",
+        "    for chunk in query_chunks:\n",
+        "        search_results.extend(vectorstore.similarity_search(chunk, k=k))\n",
+        "    return search_results\n",
+        "\n",
+        "# ─── 5) 후보 중 최고 문서 선택 함수 ─────────────────────────────────────────────\n",
+        "def choose_best_doc_with_gpt(query, docs, model=\"gpt-4o-mini\"):\n",
+        "    prompt_parts = [\n",
+        "        \"당신은 대화 응답 후보를 평가하는 전문가입니다.\\n\",\n",
+        "        f\"사용자 질문: \\\"{query}\\\"\\n\",\n",
+        "        \"다음은 검색된 응답 후보들입니다.\\n\"\n",
+        "    ]\n",
+        "\n",
+        "    for idx, doc in enumerate(docs, start=1):\n",
+        "        snippet = doc.page_content.strip().replace(\"\\n\", \" \")\n",
+        "        if len(snippet) > 300:\n",
+        "            snippet = snippet[:300] + \"...\"\n",
+        "        prompt_parts.append(\n",
+        "            f\"[{idx}]\\n\"\n",
+        "            f\"Filename: {doc.metadata.get('filename')}\\n\"\n",
+        "            f\"Emotion: {doc.metadata.get('emotion')}, Relation: {doc.metadata.get('relation')}\\n\"\n",
+        "            f\"Content: \\\"{snippet}\\\"\\n\"\n",
+        "        )\n",
+        "\n",
+        "    prompt_parts.append(\n",
+        "        \"\\n위 후보들 중에서, 사용자 질문에 가장 적절한 응답을 하나 선택하고, 그 이유를 간단히 설명해주세요.\\n\"\n",
+        "        \"반드시 다음 형식으로 응답해 주세요:\\n\"\n",
+        "        \"선택: [번호]\\n\"\n",
+        "        \"이유: [간단한 설명]\\n\"\n",
+        "    )\n",
+        "\n",
+        "    full_prompt = \"\\n\".join(prompt_parts)\n",
+        "\n",
+        "    response = openai.chat.completions.create(\n",
+        "        model=model,\n",
+        "        messages=[\n",
+        "            {\"role\": \"system\", \"content\": \"당신은 뛰어난 대화 평가자입니다.\"},\n",
+        "            {\"role\": \"user\", \"content\": full_prompt}\n",
+        "        ],\n",
+        "        max_tokens=300,\n",
+        "        temperature=0.0\n",
+        "    )\n",
+        "\n",
+        "    gpt_reply = response.choices[0].message.content.strip()\n",
+        "    selected_idx = None\n",
+        "    for line in gpt_reply.splitlines():\n",
+        "        if line.strip().startswith(\"선택\"):\n",
+        "            import re\n",
+        "            m = re.search(r\"\\[(\\d+)\\]\", line)\n",
+        "            if m:\n",
+        "                selected_idx = int(m.group(1))\n",
+        "                break\n",
+        "\n",
+        "    if selected_idx is None or selected_idx < 1 or selected_idx > len(docs):\n",
+        "        selected_idx = 1\n",
+        "\n",
+        "    best_doc = docs[selected_idx - 1]\n",
+        "    return best_doc, gpt_reply\n",
+        "\n",
+        "# ─── 6) 최종 답변 간결하게 생성 함수 ─────────────────────────────────────────────\n",
+        "def generate_final_answer(query, best_doc, model=\"gpt-4o-mini\"):\n",
+        "    prompt = (\n",
+        "        \"다음은 사용자의 질문과, 선택된 최적 응답 후보입니다.\\n\\n\"\n",
+        "        f\"사용자 질문: \\\"{query}\\\"\\n\"\n",
+        "        \"선택된 후보 응답 내용(원문):\\n\"\n",
+        "        f\"\\\"\\\"\\\"\\n{best_doc.page_content}\\n\\\"\\\"\\\"\\n\\n\"\n",
+        "        \"위 원문에서, 불필요한 반복/인사말/개인정보 등은 모두 제거하고, \"\n",
+        "        \"사용자가 이해하기 쉽도록 핵심만 남겨 간결하게 재작성해주세요.\\n\"\n",
+        "        \"문체는 친절하고 공감 가득한 톤을 유지해 주시고, \"\n",
+        "        \"최종 답변만 출력해 주세요.\"\n",
+        "    )\n",
+        "\n",
+        "    response = openai.chat.completions.create(\n",
+        "        model=model,\n",
+        "        messages=[\n",
+        "            {\"role\": \"system\", \"content\": \"당신은 친절하고 공감능력이 뛰어난 상담사입니다.\"},\n",
+        "            {\"role\": \"user\", \"content\": prompt}\n",
+        "        ],\n",
+        "        max_tokens=300,\n",
+        "        temperature=0.7\n",
+        "    )\n",
+        "\n",
+        "    final_answer = response.choices[0].message.content.strip()\n",
+        "    return final_answer\n",
+        "\n",
+        "# ─── 7) Gradio 응용: 채팅 인터페이스 구축 ───────────────────────────────────────\n",
+        "index_dir = \"/content/drive/MyDrive/2025_Bigdata_nlp_class/faiss_index\"\n",
+        "folder_path = \"/content/drive/MyDrive/2025_Bigdata_nlp_class/aihub_dataset/Training/02_label_data\"\n",
+        "\n",
+        "# 문서 로드 및 FAISS 초기화\n",
+        "documents = load_documents_with_metadata(folder_path)\n",
+        "split_docs = split_documents(documents)\n",
+        "faiss_db = create_or_load_faiss(index_dir, split_docs)\n",
+        "\n",
+        "def chat_response(query, emotion, relation):\n",
+        "    candidates = filtered_similarity_search(faiss_db, query, emotion, relation)\n",
+        "    if not candidates:\n",
+        "        return \"조건에 맞는 문서가 없습니다.\"\n",
+        "\n",
+        "    best_doc, _ = choose_best_doc_with_gpt(query, candidates, model=\"gpt-4o-mini\")\n",
+        "    final_answer = generate_final_answer(query, best_doc, model=\"gpt-4o-mini\")\n",
+        "    return final_answer\n",
+        "\n",
+        "with gr.Blocks() as demo:\n",
+        "    gr.Markdown(\"## 감정/관계 기반 Empathy QA 시스템\")\n",
+        "    with gr.Row():\n",
+        "        txt_query = gr.Textbox(label=\"질문\", placeholder=\"질문을 입력하세요...\", lines=2)\n",
+        "    with gr.Row():\n",
+        "        txt_emotion = gr.Textbox(label=\"Emotion (예: 기쁨, 당황, 분노)\", placeholder=\"ex) 기쁨\")\n",
+        "        txt_relation = gr.Textbox(label=\"Relation (예: 부모자녀, 부부, 연인)\", placeholder=\"ex) 부모자녀\")\n",
+        "    btn_submit = gr.Button(\"전송\")\n",
+        "    output = gr.Textbox(label=\"답변\", lines=5)\n",
+        "\n",
+        "    btn_submit.click(chat_response, inputs=[txt_query, txt_emotion, txt_relation], outputs=output)\n",
+        "\n",
+        "demo.launch()\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "private_outputs": true,
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

aihub_Homework_LangChainAgents_20250601_gradio.ipynb

@@ -0,0 +1,339 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "RPUwOvgUyZiz"
+      },
+      "source": [
+        "requiremenrs.txt\n",
+        "\n",
+        "langchain\n",
+        "langchain-openai\n",
+        "langchainhub # langchain python라이브러리로 프롬프트, 에이전트, 체인 관련 패키지 모음\n",
+        "langserve[all]\n",
+        "\n",
+        "faiss-cpu  # Facebook에서 개발 및 배포한 밀집 벡터의 유사도 측정, 클러스터링에 효율적인 라이브러리\n",
+        "tavily-python # 언어 모델에 중립적인 디자인으로, 모든 LLM과 통합이 가능하도록 설계된 검색 API\n",
+        "beautifulsoup4  #파이썬에서 사용할 수 있는 웹데이터 크롤링 라이브러리\n",
+        "wikipedia\n",
+        "\n",
+        "fastapi #  Python의 API를 빌드하기 위한 웹 프레임워크\n",
+        "uvicorn # ASGI(Asynchronous Server Gateway Interface) 서버\n",
+        "urllib3 # 파이썬에서 HTTP 요청을 보내고 받는 데 사용되는 강력하고 유연한 라이브러리\n",
+        "\n",
+        "python-dotenv\n",
+        "pypdf"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "NMMJXo_JyjhQ"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install langchain\n",
+        "!pip install langchain-openai\n",
+        "!pip install python-dotenv\n",
+        "!pip install langchain_community\n",
+        "!pip install pypdf\n",
+        "!pip install faiss-cpu\n",
+        "!pip install wikipedia\n",
+        "!pip install openai\n",
+        "!pip install gradio"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "jXEvb3WyJMcA"
+      },
+      "source": [
+        "Tavily Search 를 사용하기 위해서는 API KEY를 발급 받아 등록해야 함.\n",
+        "\n",
+        "[Tavily Search API 발급받기](https://app.tavily.com/sign-in)\n",
+        "\n",
+        "발급 받은 API KEY 를 다음과 같이 환경변수에 등록"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "RIxxUDEZI6ZR"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "\n",
+        "# TAVILY API KEY를 기입합니다.\n",
+        "os.environ[\"TAVILY_API_KEY\"] = \"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\"\n",
+        "\n",
+        "# 디버깅을 위한 프로젝트명을 기입합니다.\n",
+        "os.environ[\"LANGCHAIN_PROJECT\"] = \"AGENT TUTORIAL\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ys24Z3bfJHUf"
+      },
+      "outputs": [],
+      "source": [
+        "os.environ[\"OPENAI_API_KEY\"] = ''"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "sEii2SHNJbAG"
+      },
+      "outputs": [],
+      "source": [
+        "# API KEY를 환경변수로 관리하기 위한 설정 파일\n",
+        "from dotenv import load_dotenv\n",
+        "\n",
+        "# API KEY 정보로드\n",
+        "load_dotenv()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ezbT1NHQKP12"
+      },
+      "outputs": [],
+      "source": [
+        "#google drive load\n",
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "rKz2oCpl6lWK"
+      },
+      "outputs": [],
+      "source": [
+        "import gradio as gr\n",
+        "import os\n",
+        "import openai\n",
+        "import unicodedata\n",
+        "import json\n",
+        "from langchain.schema import Document\n",
+        "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
+        "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+        "from langchain.vectorstores import FAISS\n",
+        "\n",
+        "# ─── 0) OpenAI API 키 설정 ─────────────────────────────────────────────────\n",
+        "openai.api_key = os.getenv(\"OPENAI_API_KEY\")\n",
+        "\n",
+        "# ─── 1) JSON 로드 + 메타데이터 추출 함수 ─────────────────────────────────────────\n",
+        "def load_documents_with_metadata(folder_path):\n",
+        "    documents = []\n",
+        "    for raw_filename in os.listdir(folder_path):\n",
+        "        filename = unicodedata.normalize(\"NFC\", raw_filename)\n",
+        "        file_path = os.path.join(folder_path, raw_filename)\n",
+        "\n",
+        "        if not os.path.isfile(file_path):\n",
+        "            continue\n",
+        "        if not filename.endswith(\".json\"):\n",
+        "            continue\n",
+        "\n",
+        "        try:\n",
+        "            parts = filename.replace(\".json\", \"\").split(\"_\")\n",
+        "            emotion = parts[1] if len(parts) > 1 else \"unknown\"\n",
+        "            relation = parts[2] if len(parts) > 2 else \"unknown\"\n",
+        "\n",
+        "            with open(file_path, \"r\", encoding=\"utf-8\") as f:\n",
+        "                data = json.load(f)\n",
+        "                utterances = data.get(\"utterances\", [])\n",
+        "                full_text = \"\\n\".join([utt.get(\"text\",\"\") for utt in utterances])\n",
+        "                if full_text.strip() == \"\":\n",
+        "                    continue\n",
+        "\n",
+        "                doc = Document(\n",
+        "                    page_content=full_text,\n",
+        "                    metadata={\"filename\": filename, \"emotion\": emotion, \"relation\": relation}\n",
+        "                )\n",
+        "                documents.append(doc)\n",
+        "        except Exception as e:\n",
+        "            print(f\"❌ 오류 발생 ({filename}): {e}\")\n",
+        "\n",
+        "    return documents\n",
+        "\n",
+        "# ─── 2) 문서 분할 함수 ─────────────────────────────────────────────────────\n",
+        "def split_documents(documents):\n",
+        "    splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)\n",
+        "    return splitter.split_documents(documents)\n",
+        "\n",
+        "# ─── 3) FAISS 인덱스 생성 혹은 로드 함수 ───────────────────────────────────\n",
+        "def create_or_load_faiss(index_dir, split_docs):\n",
+        "    embeddings = OpenAIEmbeddings()\n",
+        "    if os.path.isdir(index_dir) and os.path.exists(os.path.join(index_dir, \"index.faiss\")):\n",
+        "        faiss_db = FAISS.load_local(index_dir, embeddings, allow_dangerous_deserialization=True)\n",
+        "        print(\"✅ 기존 FAISS 인덱스를 로드했습니다.\")\n",
+        "    else:\n",
+        "        faiss_db = FAISS.from_documents(split_docs, embeddings)\n",
+        "        os.makedirs(index_dir, exist_ok=True)\n",
+        "        faiss_db.save_local(index_dir)\n",
+        "        print(\"✅ 새로운 FAISS 인덱스를 생성하고 저장했습니다.\")\n",
+        "    return faiss_db\n",
+        "\n",
+        "# ─── 4) 필터 + 유사도 검색 함수 ────────────────────────────────────────────────\n",
+        "def filtered_similarity_search(vectorstore, query, emotion=None, relation=None, k=3):\n",
+        "    all_docs = vectorstore.docstore._dict.values()\n",
+        "    filtered_docs = [\n",
+        "        doc for doc in all_docs\n",
+        "        if (emotion is None or doc.metadata.get(\"emotion\") == emotion)\n",
+        "        and (relation is None or relation in doc.metadata.get(\"relation\"))\n",
+        "    ]\n",
+        "\n",
+        "    if not filtered_docs:\n",
+        "        return []\n",
+        "\n",
+        "    splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)\n",
+        "    query_chunks = splitter.split_text(query)\n",
+        "\n",
+        "    search_results = []\n",
+        "    for chunk in query_chunks:\n",
+        "        search_results.extend(vectorstore.similarity_search(chunk, k=k))\n",
+        "    return search_results\n",
+        "\n",
+        "# ─── 5) 후보 중 최고 문서 선택 함수 ─────────────────────────────────────────────\n",
+        "def choose_best_doc_with_gpt(query, docs, model=\"gpt-4o-mini\"):\n",
+        "    prompt_parts = [\n",
+        "        \"당신은 대화 응답 후보를 평가하는 전문가입니다.\\n\",\n",
+        "        f\"사용자 질문: \\\"{query}\\\"\\n\",\n",
+        "        \"다음은 검색된 응답 후보들입니다.\\n\"\n",
+        "    ]\n",
+        "\n",
+        "    for idx, doc in enumerate(docs, start=1):\n",
+        "        snippet = doc.page_content.strip().replace(\"\\n\", \" \")\n",
+        "        if len(snippet) > 300:\n",
+        "            snippet = snippet[:300] + \"...\"\n",
+        "        prompt_parts.append(\n",
+        "            f\"[{idx}]\\n\"\n",
+        "            f\"Filename: {doc.metadata.get('filename')}\\n\"\n",
+        "            f\"Emotion: {doc.metadata.get('emotion')}, Relation: {doc.metadata.get('relation')}\\n\"\n",
+        "            f\"Content: \\\"{snippet}\\\"\\n\"\n",
+        "        )\n",
+        "\n",
+        "    prompt_parts.append(\n",
+        "        \"\\n위 후보들 중에서, 사용자 질문에 가�� 적절한 응답을 하나 선택하고, 그 이유를 간단히 설명해주세요.\\n\"\n",
+        "        \"반드시 다음 형식으로 응답해 주세요:\\n\"\n",
+        "        \"선택: [번호]\\n\"\n",
+        "        \"이유: [간단한 설명]\\n\"\n",
+        "    )\n",
+        "\n",
+        "    full_prompt = \"\\n\".join(prompt_parts)\n",
+        "\n",
+        "    response = openai.chat.completions.create(\n",
+        "        model=model,\n",
+        "        messages=[\n",
+        "            {\"role\": \"system\", \"content\": \"당신은 뛰어난 대화 평가자입니다.\"},\n",
+        "            {\"role\": \"user\", \"content\": full_prompt}\n",
+        "        ],\n",
+        "        max_tokens=300,\n",
+        "        temperature=0.0\n",
+        "    )\n",
+        "\n",
+        "    gpt_reply = response.choices[0].message.content.strip()\n",
+        "    selected_idx = None\n",
+        "    for line in gpt_reply.splitlines():\n",
+        "        if line.strip().startswith(\"선택\"):\n",
+        "            import re\n",
+        "            m = re.search(r\"\\[(\\d+)\\]\", line)\n",
+        "            if m:\n",
+        "                selected_idx = int(m.group(1))\n",
+        "                break\n",
+        "\n",
+        "    if selected_idx is None or selected_idx < 1 or selected_idx > len(docs):\n",
+        "        selected_idx = 1\n",
+        "\n",
+        "    best_doc = docs[selected_idx - 1]\n",
+        "    return best_doc, gpt_reply\n",
+        "\n",
+        "# ─── 6) 최종 답변 간결하게 생성 함수 ─────────────────────────────────────────────\n",
+        "def generate_final_answer(query, best_doc, model=\"gpt-4o-mini\"):\n",
+        "    prompt = (\n",
+        "        \"다음은 사용자의 질문과, 선택된 최적 응답 후보입니다.\\n\\n\"\n",
+        "        f\"사용자 질문: \\\"{query}\\\"\\n\"\n",
+        "        \"선택된 후보 응답 내용(원문):\\n\"\n",
+        "        f\"\\\"\\\"\\\"\\n{best_doc.page_content}\\n\\\"\\\"\\\"\\n\\n\"\n",
+        "        \"위 원문에서, 불필요한 반복/인사말/개인정보 등은 모두 제거하고, \"\n",
+        "        \"사용자가 이해하기 쉽도록 핵심만 남겨 간결하게 재작성해주세요.\\n\"\n",
+        "        \"문체는 친절하고 공감 가득한 톤을 유지해 주시고, \"\n",
+        "        \"최종 답변만 출력해 주세요.\"\n",
+        "    )\n",
+        "\n",
+        "    response = openai.chat.completions.create(\n",
+        "        model=model,\n",
+        "        messages=[\n",
+        "            {\"role\": \"system\", \"content\": \"당신은 친절하고 공감능력이 뛰어난 상담사입니다.\"},\n",
+        "            {\"role\": \"user\", \"content\": prompt}\n",
+        "        ],\n",
+        "        max_tokens=300,\n",
+        "        temperature=0.7\n",
+        "    )\n",
+        "\n",
+        "    final_answer = response.choices[0].message.content.strip()\n",
+        "    return final_answer\n",
+        "\n",
+        "# ─── 7) Gradio 응용: 채팅 인터페이스 구축 ───────────────────────────────────────\n",
+        "index_dir = \"/content/drive/MyDrive/2025_Bigdata_nlp_class/faiss_index\"\n",
+        "folder_path = \"/content/drive/MyDrive/2025_Bigdata_nlp_class/aihub_dataset/Training/02_label_data\"\n",
+        "\n",
+        "# 문서 로드 및 FAISS 초기화\n",
+        "documents = load_documents_with_metadata(folder_path)\n",
+        "split_docs = split_documents(documents)\n",
+        "faiss_db = create_or_load_faiss(index_dir, split_docs)\n",
+        "\n",
+        "def chat_response(query, emotion, relation):\n",
+        "    candidates = filtered_similarity_search(faiss_db, query, emotion, relation)\n",
+        "    if not candidates:\n",
+        "        return \"조건에 맞는 문서가 없습니다.\"\n",
+        "\n",
+        "    best_doc, _ = choose_best_doc_with_gpt(query, candidates, model=\"gpt-4o-mini\")\n",
+        "    final_answer = generate_final_answer(query, best_doc, model=\"gpt-4o-mini\")\n",
+        "    return final_answer\n",
+        "\n",
+        "with gr.Blocks() as demo:\n",
+        "    gr.Markdown(\"## 감정/관계 기반 Empathy QA 시스템\")\n",
+        "    with gr.Row():\n",
+        "        txt_query = gr.Textbox(label=\"질문\", placeholder=\"질문을 입력하세요...\", lines=2)\n",
+        "    with gr.Row():\n",
+        "        txt_emotion = gr.Textbox(label=\"Emotion (예: 기쁨, 당황, 분노)\", placeholder=\"ex) 기쁨\")\n",
+        "        txt_relation = gr.Textbox(label=\"Relation (예: 부모자녀, 부부, 연인)\", placeholder=\"ex) 부모자녀\")\n",
+        "    btn_submit = gr.Button(\"전송\")\n",
+        "    output = gr.Textbox(label=\"답변\", lines=5)\n",
+        "\n",
+        "    btn_submit.click(chat_response, inputs=[txt_query, txt_emotion, txt_relation], outputs=output)\n",
+        "\n",
+        "demo.launch()\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "private_outputs": true,
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

docker-compose.yml

@@ -0,0 +1,38 @@
+services:
+  simsimi-ai-agent:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: simsimi_ai_agent
+    ports:
+      - "8000:8000"
+    volumes:
+      # 소스코드 실시간 반영 (개발용)
+      - ./src:/app/src
+      - ./scripts:/app/scripts
+      - ./main.py:/app/main.py
+      # 데이터 영구 저장
+      - ./data:/app/data
+      - ./logs:/app/logs
+      # [추가] 캐시 데이터 영구 저장
+      # 이렇게 하면 컨테이너를 껐다 켜도 매번 모델을 새로 다운로드하지 않습니다.
+      - ./cache:/app/cache
+      # 환경변수 (로컬에서만)
+      - ./.env:/app/.env:ro
+    environment:
+      - PYTHONPATH=/app
+      - PYTHONDONTWRITEBYTECODE=1
+      - PYTHONUNBUFFERED=1
+      # [추가] Hugging Face 캐시 디렉토리 환경 변수
+      - HF_HOME=/app/cache
+    env_file:
+      - .env
+    restart: unless-stopped
+    stdin_open: true
+    tty: true
+    networks:
+      - simsimi_network
+
+networks:
+  simsimi_network:
+    driver: bridge

load_data.py

@@ -0,0 +1,80 @@
+import json
+import uuid
+from sentence_transformers import SentenceTransformer
+import chromadb
+from chromadb.utils import embedding_functions
+import os
+
+# --- 설정 ---
+# 이 파일과 같은 위치에 AI Hub 원본 데이터 파일이 있다고 가정합니다.
+SOURCE_DATA_FILE = 'AI_Hub_감성대화.json'
+DB_PATH = "./data/chromadb"
+COLLECTION_NAME = "teen_empathy_chat"
+MODEL_NAME = 'jhgan/ko-sbert-multitask'
+
+
+def setup_database():
+    """VectorDB를 설정하고 데이터를 구축하는 메인 함수"""
+
+    # 0. 필수 파일 확인
+    if not os.path.exists(SOURCE_DATA_FILE):
+        print(f"오류: 원본 데이터 파일 '{SOURCE_DATA_FILE}'을 찾을 수 없습니다.")
+        print("AI Hub 데이터를 다운로드하여 이 스크립트와 같은 폴더에 저장해주세요.")
+        return
+
+    print("1. 데이터베이스 및 컬렉션 설정 시작...")
+    client = chromadb.PersistentClient(path=DB_PATH)
+
+    # HuggingFace 임베딩 함수 설정
+    embedding_func = embedding_functions.SentenceTransformerEmbeddingFunction(model_name=MODEL_NAME)
+
+    # 컬렉션 생성 또는 가져오기
+    collection = client.get_or_create_collection(
+        name=COLLECTION_NAME,
+        embedding_function=embedding_func,
+        metadata={"hnsw:space": "cosine"}  # 유사도 측정 기준: 코사인 유사도
+    )
+    print(f"'{COLLECTION_NAME}' 컬렉션 준비 완료.")
+
+    # 2. 원본 JSON 데이터 로드
+    print(f"2. '{SOURCE_DATA_FILE}' 파일에서 데이터 로드 중...")
+    with open(SOURCE_DATA_FILE, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    print(f"총 {len(data)}개의 대화 데이터 로드 완료.")
+
+    # 3. 데이터 배치 처리 및 VectorDB에 추가
+    print("3. 데이터 임베딩 및 데이터베이스 저장 시작... (시간이 걸릴 수 있습니다)")
+    batch_size = 100
+    total_batches = (len(data) + batch_size - 1) // batch_size
+
+    for i in range(0, len(data), batch_size):
+        batch_data = data[i:i + batch_size]
+
+        # 문서, 메타데이터, ID 리스트 생성
+        documents = [item['user_utterance'] for item in batch_data]
+        metadatas = [
+            {
+                "user_utterance": item['user_utterance'],
+                "system_response": item['system_response'],
+                "emotion": item['emotion'],
+                "relationship": item.get('relationship', '기타')  # relationship 필드가 없을 경우 대비
+            } for item in batch_data
+        ]
+        ids = [str(uuid.uuid4()) for _ in batch_data]
+
+        # 컬렉션에 데이터 추가
+        collection.add(
+            documents=documents,
+            metadatas=metadatas,
+            ids=ids
+        )
+
+        print(f"  - 배치 {i // batch_size + 1}/{total_batches} 처리 완료...")
+
+    print("🎉 데이터베이스 구축이 성공적으로 완료되었습니다!")
+    print(f"총 {collection.count()}개의 문서가 '{COLLECTION_NAME}' 컬렉션에 저장되었습니다.")
+    print(f"데이터베이스는 '{DB_PATH}' 경로에 저장되었습니다.")
+
+
+if __name__ == "__main__":
+    setup_database()

main.py

@@ -0,0 +1,104 @@
+
+# ==========================================================
+# 앱 시작 시 Hugging Face Dataset에서 데이터 다운로드
+# ==========================================================
+from huggingface_hub import snapshot_download
+import os
+
+# 1. 본인의 Dataset 저장소 주소를 입력하세요.
+HF_DATASET_REPO_ID = "youdie006/simsimi-ai-agent-data"
+DATA_DIR = "./data"
+
+# 2. [추가] 권한 문제가 없는 캐시 디렉토리 경로를 명시적으로 지정합니다.
+CACHE_DIR = "/app/cache"
+
+# 3. 데이터 파일이 이미 있는지 확인하고, 없을 때만 다운로드 실행
+if not os.path.exists(os.path.join(DATA_DIR, "chromadb/chroma.sqlite3")):
+    print(f"'{HF_DATASET_REPO_ID}'에서 데이터 다운로드 시작...")
+    snapshot_download(
+        repo_id=HF_DATASET_REPO_ID,
+        repo_type="dataset",
+        local_dir=DATA_DIR,
+        local_dir_use_symlinks=False,
+        cache_dir=CACHE_DIR  # <--- 이 부분이 핵심입니다.
+    )
+    print("데이터 다운로드 완료.")
+# ==========================================================
+
+
+"""
+청소년 공감형 AI 챗봇 메인 서버
+"""
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, HTMLResponse
+from fastapi.staticfiles import StaticFiles
+import sys
+from datetime import datetime
+from dotenv import load_dotenv
+
+# 환경 변수 로드
+load_dotenv()
+
+# FastAPI 앱 생성
+app = FastAPI(
+    title="💙 마음이 - 청소년 상담 챗봇",
+    description="13-19세 청소년을 위한 AI 공감 상담사",
+    version=os.getenv("VERSION", "2.0.0"),
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# CORS 설정
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 정적 파일 서빙
+try:
+    app.mount("/static", StaticFiles(directory="static"), name="static")
+    print("✅ 정적 파일 서빙 설정 완료")
+except Exception as e:
+    print(f"⚠️ 정적 파일 디렉토리 없음: {e}")
+
+# 라우터 등록
+try:
+    from src.api import vector, openai, chat
+
+    app.include_router(
+        vector.router,
+        prefix="/api/v1/vector",
+        tags=["🗄️ Vector Store"]
+    )
+    app.include_router(
+        openai.router,
+        prefix="/api/v1/openai",
+        tags=["🤖 OpenAI GPT-4"]
+    )
+    app.include_router(
+        chat.router,
+        prefix="/api/v1/chat",
+        tags=["💙 Teen Chat"]
+    )
+except ImportError as e:
+    print(f"⚠️ API 라우터 import 실패: {e}")
+
+
+@app.get("/", response_class=HTMLResponse)
+async def web_chat_interface():
+    """웹 채팅 인터페이스"""
+    html_file_path = "static/index.html"
+    if os.path.exists(html_file_path):
+        with open(html_file_path, "r", encoding="utf-8") as f:
+            return HTMLResponse(content=f.read())
+    return HTMLResponse(content="<h1>Welcome</h1><p>Static index.html not found.</p>")
+
+
+@app.get("/api/v1/health")
+async def health_check():
+    """시스템 헬스 체크"""
+    return {"status": "healthy", "service": "teen-empathy-chatbot"}

requirements.txt

@@ -0,0 +1,76 @@
+# ===========================================
+# 🌐 웹 프레임워크
+# ===========================================
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+
+# ===========================================
+# 🤖 AI/ML 라이브러리
+# ===========================================
+openai==1.3.8
+sentence-transformers==2.2.2
+torch==2.0.1
+transformers==4.30.0
+
+# 🔧 HuggingFace Hub (호환성 버전 고정)
+huggingface_hub==0.16.4  # cached_download 지원 마지막 안정 버전
+
+# ===========================================
+# 🗄️ Vector Database
+# ===========================================
+chromadb==0.4.18
+
+# ===========================================
+# 🛠️ 유틸리티
+# ===========================================
+python-dotenv==1.0.0
+pydantic==2.5.0
+httpx==0.25.2
+loguru==0.7.2
+numpy==1.24.3
+pandas==2.0.3
+
+# ===========================================
+# 🇰🇷 한국어 처리
+# ===========================================
+konlpy==0.6.0
+
+# ===========================================
+# 📊 AI Hub 데이터 처리 (추가)
+# ===========================================
+# JSON 스트리밍 처리
+ijson==3.2.3
+
+# 데이터 분석 및 통계
+scipy==1.11.4
+scikit-learn==1.3.2
+
+# 텍스트 전처리 및 정규식
+regex==2023.10.3
+
+# 날짜/시간 처리
+python-dateutil==2.8.2
+
+# ===========================================
+# 🔧 개발 및 테스팅 (Docker에서 제외 가능)
+# ===========================================
+# 주석 처리하여 빌드 시간 단축
+# pytest==7.4.3
+# pytest-asyncio==0.21.1
+
+# 성능 모니터링 (프로덕션에서만 필요시)
+# psutil==5.9.6
+
+# ===========================================
+# 🐳 Docker 최적화
+# ===========================================
+# Gunicorn (프로덕션 배포용)
+gunicorn==22.0.0
+
+# ===========================================
+# 📝 추가 유틸리티
+# ===========================================
+# 환경 변수 관리
+python-decouple==3.8
+
+# 참고: uuid, time은 Python 표준 라이브러리 사용

src/api/chat.py

@@ -0,0 +1,113 @@
+from fastapi import APIRouter, Header
+import traceback
+from loguru import logger
+from ..services.openai_client import get_openai_client
+from ..services.aihub_processor import get_teen_empathy_processor
+from ..models.function_models import TeenChatRequest, ReActStep, EmotionType, RelationshipType
+from ..services.conversation_service import get_conversation_service
+
+router = APIRouter()
+
+
+async def run_pipeline(session_id: str, message: str) -> dict:
+    """모든 처리 과정을 투명하게 추적하는 최종 파이프라인 (RAG-Fusion 적용)"""
+
+    openai_client = await get_openai_client()
+    conversation_service = await get_conversation_service()
+    processor = await get_teen_empathy_processor()
+
+    debug_info = {}
+    react_steps = []
+
+    # Step 1: Context Loading
+    session_id = await conversation_service.get_or_create_session(session_id)
+    conversation_history = await conversation_service.get_conversation_history(session_id)
+    debug_info["step1_context_loading"] = {"session_id": session_id, "loaded_history": conversation_history}
+
+    # Step 2: Input Analysis
+    react_steps.append(ReActStep(step_type="thought", content="사용자의 입력 의도를 파악하기 위해 감정과 관계 맥락을 분석해야겠다."))
+    analysis_result = await openai_client.analyze_emotion_and_context(message)
+    emotion = analysis_result.get("primary_emotion", EmotionType.ANGER.value)
+    relationship = analysis_result.get("relationship_context", RelationshipType.FAMILY.value)
+    react_steps.append(ReActStep(step_type="observation", content=f"분석 결과: 감정='{emotion}', 관계='{relationship}'"))
+    debug_info["step2_input_analysis"] = {"input": message, "output": analysis_result}
+
+    # Step 3: Conversational Query Rewriting
+    react_steps.append(ReActStep(step_type="thought", content="RAG 검색 정확도를 높이기 위해, 이전 대화 내용까지 포함하여 검색어를 재작성해야겠다."))
+    search_query = await openai_client.rewrite_query_with_history(message, conversation_history)
+    react_steps.append(ReActStep(step_type="observation", content=f"재작성된 검색어: '{search_query}'"))
+    debug_info["step3_query_rewriting"] = {"original_message": message, "rewritten_query": search_query}
+
+    # Step 4: RAG Retrieval
+    react_steps.append(ReActStep(step_type="thought", content="재작성된 검색어로 여러 개의 후보 문서를 찾아봐야겠다."))
+    expert_responses = await processor.search_similar_contexts(query=search_query, emotion=emotion,
+                                                               relationship=relationship, top_k=5)
+    react_steps.append(ReActStep(step_type="observation", content=f"유사 사례 후보 {len(expert_responses)}건 발견."))
+    debug_info["step4_rag_retrieval"] = {"retrieved_candidates": expert_responses}
+
+    # Step 5: Sequential Relevance Check & Strategy Decision
+    strategy = "Direct-Generation"
+    final_expert_advice = None
+    verification_logs = []
+
+    react_steps.append(ReActStep(step_type="thought", content="검색된 후보들이 현재 대화와 정말 관련이 있는지 하나씩 순서대로 검증해야겠다."))
+    for i, doc in enumerate(expert_responses):
+        doc_content = doc.get("system_response", "")
+        is_relevant = await openai_client.verify_rag_relevance(message, doc_content)
+        verification_logs.append({"candidate": i + 1, "is_relevant": is_relevant, "document": doc})
+        if is_relevant:
+            strategy = "RAG-Adaptation"
+            final_expert_advice = doc_content
+            react_steps.append(ReActStep(step_type="observation", content=f"후보 {i + 1}번이 관련 있음! RAG 전략을 사용하기로 결정했다."))
+            break
+
+    if not final_expert_advice:
+        react_steps.append(
+            ReActStep(step_type="observation", content="관련 있는 문서를 찾지 못했으므로, 검색된 문서들을 '영감'으로 삼아 직접 생성 전략을 사용한다."))
+
+    debug_info["step5_strategy_decision"] = {"chosen_strategy": strategy, "verification_logs": verification_logs}
+
+    # Step 6: Final Response Generation
+    react_steps.append(ReActStep(step_type="thought", content=f"'{strategy}' 전략을 사용해, 최종 답변을 생성한다."))
+    final_response = ""
+    if strategy == "RAG-Adaptation":
+        raw_advice, pre_adapted, final_adapted, final_prompt = await openai_client.adapt_expert_response(
+            final_expert_advice, message, conversation_history)
+        final_response = final_adapted
+        debug_info["step6_generation"] = {"strategy": strategy, "A_source_expert_advice": raw_advice,
+                                          "B_rule_based_adaptation": pre_adapted, "C_final_gpt4_prompt": final_prompt,
+                                          "D_final_response": final_response}
+    else:
+        # [최종 업그레이드] RAG-Fusion 적용: 실패한 RAG 결과를 '영감'으로 제공
+        inspirational_docs = [doc.get("system_response", "") for doc in expert_responses]
+        final_response, final_prompt = await openai_client.create_direct_response(
+            user_message=message,
+            conversation_history=conversation_history,
+            inspirational_docs=inspirational_docs  # <-- 추가된 부분
+        )
+        debug_info["step6_generation"] = {"strategy": strategy, "A_final_gpt4_prompt": final_prompt,
+                                          "B_final_response": final_response}
+
+    react_steps.append(ReActStep(step_type="observation", content="최종 응답 생성을 완료했다."))
+
+    # Step 7: Save Conversation
+    await conversation_service.save_conversation_turn(session_id, message, final_response)
+    debug_info["step7_save_conversation"] = {"user": message, "assistant": final_response}
+
+    return {"response": final_response, "debug_info": debug_info, "react_steps": [r.dict() for r in react_steps]}
+
+
+@router.post("/teen-chat-debug")
+async def teen_chat_debug(request: TeenChatRequest, session_id: str = Header(None)):
+    try:
+        return await run_pipeline(session_id, request.message)
+    except Exception as e:
+        tb_str = traceback.format_exc();
+        logger.error(f"디버깅 파이프라인 실패: {e}\n{tb_str}")
+        return {"error": "Pipeline Error", "error_message": str(e), "debug_info": {"traceback": tb_str}}
+
+
+@router.post("/teen-chat")
+async def teen_chat(request: TeenChatRequest, session_id: str = Header(None)):
+    result = await run_pipeline(session_id, request.message)
+    return {"response": result["response"]}

src/api/openai.py

@@ -0,0 +1,337 @@
+"""
+OpenAI API 라우터
+GPT-4 관련 엔드포인트들 (채팅, 감정분석 등)
+"""
+
+from fastapi import APIRouter, HTTPException, Depends, status
+from typing import List, Dict, Any
+from loguru import logger
+
+from ..services.openai_client import get_openai_client
+from ..models.function_models import (
+    OpenAICompletionRequest, OpenAICompletionResponse,
+    EmotionAnalysisRequest, EmotionAnalysisResponse,
+    ChatMessage, SystemHealthCheck
+)
+
+
+router = APIRouter()
+
+
+@router.post("/completion", response_model=OpenAICompletionResponse)
+async def create_completion(
+    request: OpenAICompletionRequest,
+    openai_client = Depends(get_openai_client)
+):
+    """
+    🤖 GPT-4 채팅 완성 생성
+
+    - 일반적인 GPT-4 채팅 완성
+    - 사용자 정의 모델, 온도, 토큰 수 설정 가능
+    - 스트리밍 지원 (선택적)
+    """
+    try:
+        logger.info(f"GPT-4 완성 요청 - 모델: {request.model}, 메시지 수: {len(request.messages)}")
+
+        # ChatMessage를 dict로 변환
+        messages = [
+            {"role": msg.role.value, "content": msg.content}
+            for msg in request.messages
+        ]
+
+        response = await openai_client.create_completion(
+            messages=messages,
+            model=request.model,
+            temperature=request.temperature,
+            max_tokens=request.max_tokens,
+            top_p=request.top_p
+        )
+
+        return response
+
+    except Exception as e:
+        logger.error(f"GPT-4 완성 생성 실패: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"GPT-4 완성 생성 중 오류가 발생했습니다: {str(e)}"
+        )
+
+
+@router.post("/teen-empathy", response_model=str)
+async def create_teen_empathy_response(
+    user_message: str,
+    conversation_history: List[ChatMessage] = None,
+    context_info: str = None,
+    openai_client = Depends(get_openai_client)
+):
+    """
+    💙 청소년 공감형 응답 생성
+
+    - 청소년 전용 공감 시스템 프롬프트 적용
+    - 대화 히스토리 및 맥락 정보 활용
+    - 따뜻하고 지지적인 응답 생성
+    """
+    try:
+        logger.info(f"청소년 공감 응답 요청: '{user_message[:50]}...'")
+
+        response = await openai_client.create_teen_empathy_response(
+            user_message=user_message,
+            conversation_history=conversation_history,
+            context_info=context_info
+        )
+
+        return response
+
+    except Exception as e:
+        logger.error(f"청소년 공감 응답 생성 실패: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"청소년 공감 응답 생성 중 오류가 발생했습니다: {str(e)}"
+        )
+
+
+@router.post("/analyze-emotion", response_model=EmotionAnalysisResponse)
+async def analyze_emotion(
+    request: EmotionAnalysisRequest,
+    openai_client = Depends(get_openai_client)
+):
+    """
+    🎭 감정 및 맥락 분석
+
+    - 텍스트에서 주요 감정 추출
+    - 관계 맥락 파악 (부모님, 친구, 형제자매 등)
+    - 적절한 공감 전략 추천
+    """
+    try:
+        logger.info(f"감정 분석 요청: '{request.text[:50]}...'")
+
+        response = await openai_client.analyze_emotion_and_context(
+            text=request.text,
+            additional_context=request.context
+        )
+
+        return response
+
+    except Exception as e:
+        logger.error(f"감정 분석 실패: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"감정 분석 중 오류가 발생했습니다: {str(e)}"
+        )
+
+
+@router.post("/react-response")
+async def generate_react_response(
+    user_message: str,
+    similar_contexts: List[Dict[str, Any]] = None,
+    emotion: str = None,
+    relationship: str = None,
+    openai_client = Depends(get_openai_client)
+):
+    """
+    🧠 ReAct 패턴 응답 생성
+
+    - Thought → Action → Observation → Response
+    - 단계별 추론 과정 포함
+    - 유사 맥락 정보 활용
+    """
+    try:
+        logger.info(f"ReAct 응답 요청: '{user_message[:50]}...'")
+
+        response_text, react_steps = await openai_client.generate_react_response(
+            user_message=user_message,
+            similar_contexts=similar_contexts or [],
+            emotion=emotion,
+            relationship=relationship
+        )
+
+        return {
+            "response": response_text,
+            "react_steps": react_steps,
+            "metadata": {
+                "emotion": emotion,
+                "relationship": relationship,
+                "context_count": len(similar_contexts) if similar_contexts else 0
+            }
+        }
+
+    except Exception as e:
+        logger.error(f"ReAct 응답 생성 실패: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"ReAct 응답 생성 중 오류가 발생했습니다: {str(e)}"
+        )
+
+
+@router.get("/models")
+async def list_available_models():
+    """
+    📋 사용 가능한 모델 목록
+
+    - 지원하는 OpenAI 모델들
+    - 각 모델의 특징 및 사용 권장사항
+    """
+    return {
+        "available_models": [
+            {
+                "name": "gpt-4",
+                "description": "가장 강력한 모델, 복잡한 추론에 최적",
+                "recommended_for": ["청소년 공감 상담", "복잡한 맥락 이해"],
+                "max_tokens": 8192,
+                "cost": "높음"
+            },
+            {
+                "name": "gpt-4-turbo",
+                "description": "빠르고 효율적인 GPT-4 버전",
+                "recommended_for": ["실시간 채팅", "일반적인 상담"],
+                "max_tokens": 128000,
+                "cost": "중간"
+            },
+            {
+                "name": "gpt-3.5-turbo",
+                "description": "빠르고 경제적인 모델",
+                "recommended_for": ["간단한 질문", "테스트용"],
+                "max_tokens": 4096,
+                "cost": "낮음"
+            }
+        ],
+        "current_default": "gpt-4",
+        "recommendation": "청소년 공감형 상담에는 gpt-4를 권장합니다"
+    }
+
+
+@router.get("/health", response_model=SystemHealthCheck)
+async def openai_health_check(openai_client = Depends(get_openai_client)):
+    """
+    💊 OpenAI 서비스 헬스 체크
+
+    - API 연결 상태 확인
+    - 응답 시간 측정
+    - 서비스 가용성 점검
+    """
+    try:
+        import time
+        start_time = time.time()
+
+        # 간단한 테스트 요청으로 연결 확인
+        test_response = await openai_client.create_completion(
+            messages=[{"role": "user", "content": "Hello"}],
+            max_tokens=5,
+            temperature=0
+        )
+
+        response_time_ms = (time.time() - start_time) * 1000
+
+        return SystemHealthCheck(
+            status="healthy",
+            services={
+                "openai_api": True,
+                "gpt4_model": True,
+                "embedding_generation": True
+            },
+            response_time_ms=response_time_ms,
+            version="1.0.0"
+        )
+
+    except Exception as e:
+        logger.error(f"OpenAI 헬스 체크 실패: {e}")
+        return SystemHealthCheck(
+            status="unhealthy",
+            services={
+                "openai_api": False,
+                "gpt4_model": False,
+                "embedding_generation": False
+            },
+            response_time_ms=0.0,
+            version="1.0.0"
+        )
+
+
+@router.get("/usage-stats")
+async def get_usage_stats():
+    """
+    📊 OpenAI API 사용 통계
+
+    - 토큰 사용량 추정
+    - 비용 관련 정보
+    """
+    return {
+        "current_session": {
+            "requests_made": "실시간 추적 필요",
+            "tokens_used": "실시간 추적 필요",
+            "estimated_cost": "실시간 추적 필요"
+        },
+        "cost_info": {
+            "gpt-4": {
+                "input_per_1k_tokens": "$0.03",
+                "output_per_1k_tokens": "$0.06"
+            },
+            "gpt-4-turbo": {
+                "input_per_1k_tokens": "$0.01",
+                "output_per_1k_tokens": "$0.03"
+            },
+            "gpt-3.5-turbo": {
+                "input_per_1k_tokens": "$0.0015",
+                "output_per_1k_tokens": "$0.002"
+            }
+        },
+        "optimization_tips": [
+            "적절한 max_tokens 설정으로 비용 절약",
+            "간단한 작업은 gpt-3.5-turbo 사용",
+            "시스템 프롬프트 최적화로 토큰 절약",
+            "불필요한 대화 히스토리 제거"
+        ]
+    }
+
+
+@router.post("/test-empathy")
+async def test_empathy_response(
+    test_message: str = "친구가 나를 무시하는 것 같아서 기분이 나빠",
+    openai_client = Depends(get_openai_client)
+):
+    """
+    🧪 공감형 응답 테스트
+
+    - 청소년 공감형 시스템의 응답 품질 테스트
+    - 다양한 테스트 케이스 제공
+    """
+    try:
+        # 감정 분석
+        emotion_result = await openai_client.analyze_emotion_and_context(test_message)
+
+        # 공감형 응답 생성
+        empathy_response = await openai_client.create_teen_empathy_response(test_message)
+
+        # ReAct 응답 생성
+        react_response, react_steps = await openai_client.generate_react_response(
+            user_message=test_message,
+            emotion=emotion_result.primary_emotion.value,
+            relationship=emotion_result.relationship_context.value if emotion_result.relationship_context else None
+        )
+
+        return {
+            "test_input": test_message,
+            "emotion_analysis": {
+                "primary_emotion": emotion_result.primary_emotion.value,
+                "confidence": emotion_result.emotion_confidence,
+                "relationship": emotion_result.relationship_context.value if emotion_result.relationship_context else None,
+                "strategies": [s.value for s in emotion_result.recommended_strategies]
+            },
+            "empathy_response": empathy_response,
+            "react_response": {
+                "response": react_response,
+                "steps": react_steps
+            },
+            "test_info": {
+                "response_quality": "수동 평가 필요",
+                "empathy_level": "수동 평가 필요",
+                "actionability": "수동 평가 필요"
+            }
+        }
+
+    except Exception as e:
+        logger.error(f"공감 응답 테스트 실패: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"테스트 실행 중 오류가 발생했습니다: {str(e)}"
+        )

src/api/vector.py

@@ -0,0 +1,272 @@
+"""
+Vector Store API 라우터
+ChromaDB 벡터 스토어 관련 엔드포인트들
+"""
+
+from fastapi import APIRouter, HTTPException, Depends, status
+from typing import List
+import time
+from loguru import logger
+
+from ..core.vector_store import get_vector_store
+from ..models.vector_models import (
+    VectorSearchRequest, VectorSearchResponse,
+    DocumentAddRequest, DocumentAddResponse,
+    VectorStoreStats, SearchResult
+)
+
+
+router = APIRouter()
+
+
+@router.post("/search", response_model=VectorSearchResponse)
+async def search_vectors(
+    request: VectorSearchRequest,
+    vector_store = Depends(get_vector_store)
+):
+    """
+    🔍 벡터 유사도 검색
+
+    - 쿼리와 유사한 문서들을 벡터 검색으로 찾기
+    - 감정, 관계 등 메타데이터 필터링 지원
+    - top_k 개수만큼 결과 반환
+    """
+    try:
+        logger.info(f"벡터 검색 요청: '{request.query[:50]}...', top_k: {request.top_k}")
+        start_time = time.time()
+
+        # 벡터 검색 실행
+        results = await vector_store.search(
+            query=request.query,
+            top_k=request.top_k,
+            filter_metadata=request.filter_metadata
+        )
+
+        search_time_ms = (time.time() - start_time) * 1000
+
+        return VectorSearchResponse(
+            results=results,
+            query=request.query,
+            total_results=len(results),
+            search_time_ms=search_time_ms
+        )
+
+    except Exception as e:
+        logger.error(f"벡터 검색 실패: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"벡터 검색 중 오류가 발생했습니다: {str(e)}"
+        )
+
+
+@router.post("/documents", response_model=DocumentAddResponse)
+async def add_documents(
+    request: DocumentAddRequest,
+    vector_store = Depends(get_vector_store)
+):
+    """
+    📝 문서 추가
+
+    - 새 문서들을 벡터 DB에 추가
+    - 자동으로 임베딩 생성 및 인덱싱
+    - 배치 처리로 효율적 추가
+    """
+    try:
+        logger.info(f"문서 추가 요청: {len(request.documents)}개")
+        start_time = time.time()
+
+        # 문서 추가 실행
+        document_ids = await vector_store.add_documents(request.documents)
+
+        processing_time_ms = (time.time() - start_time) * 1000
+
+        return DocumentAddResponse(
+            success=True,
+            added_count=len(document_ids),
+            document_ids=document_ids,
+            processing_time_ms=processing_time_ms,
+            errors=[]
+        )
+
+    except Exception as e:
+        logger.error(f"문서 추가 실패: {e}")
+        return DocumentAddResponse(
+            success=False,
+            added_count=0,
+            document_ids=[],
+            processing_time_ms=0,
+            errors=[str(e)]
+        )
+
+
+@router.get("/stats", response_model=VectorStoreStats)
+async def get_vector_stats(vector_store = Depends(get_vector_store)):
+    """
+    📊 벡터 스토어 통계
+
+    - 총 문서 수, 컬렉션 정보
+    - 임베딩 모델 정보
+    - 시스템 상태 확인
+    """
+    try:
+        stats = await vector_store.get_collection_stats()
+        return stats
+
+    except Exception as e:
+        logger.error(f"통계 조회 실패: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"통계 조회 중 오류가 발생했습니다: {str(e)}"
+        )
+
+
+@router.delete("/documents/{document_id}")
+async def delete_document(
+    document_id: str,
+    vector_store = Depends(get_vector_store)
+):
+    """
+    🗑️ 문서 삭제
+
+    - 특정 문서를 벡터 DB에서 삭제
+    """
+    try:
+        success = await vector_store.delete_documents([document_id])
+
+        if success:
+            return {"message": f"문서 {document_id} 삭제 완료", "success": True}
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"문서 {document_id}를 찾을 수 없습니다"
+            )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"문서 삭제 실패: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"문서 삭제 중 오류가 발생했습니다: {str(e)}"
+        )
+
+
+@router.post("/clear")
+async def clear_collection(vector_store = Depends(get_vector_store)):
+    """
+    ⚠️ 컬렉션 초기화
+
+    - 모든 문서 삭제 및 컬렉션 초기화
+    - 주의: 모든 데이터가 삭제됩니다!
+    """
+    try:
+        success = await vector_store.clear_collection()
+
+        if success:
+            return {
+                "message": "컬렉션이 성공적으로 초기화되었습니다",
+                "success": True,
+                "warning": "모든 데이터가 삭제되었습니다"
+            }
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="컬렉션 초기화에 실패했습니다"
+            )
+
+    except Exception as e:
+        logger.error(f"컬렉션 초기화 실패: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"컬렉션 초기화 중 오류가 발생했습니다: {str(e)}"
+        )
+
+
+@router.get("/health")
+async def vector_health_check(vector_store = Depends(get_vector_store)):
+    """
+    💊 벡터 스토어 헬스 체크
+
+    - 벡터 DB 연결 상태 확인
+    - 임베딩 모델 상태 확인
+    """
+    try:
+        stats = await vector_store.get_collection_stats()
+
+        health_status = {
+            "status": "healthy" if stats.status == "healthy" else "unhealthy",
+            "collection_name": stats.collection_name,
+            "total_documents": stats.total_documents,
+            "embedding_model": stats.embedding_model,
+            "database_path": stats.database_path,
+            "checks": {
+                "chromadb_connection": True,
+                "embedding_model_loaded": stats.embedding_dimension is not None,
+                "collection_accessible": stats.total_documents >= 0
+            },
+            "last_updated": stats.last_updated
+        }
+
+        return health_status
+
+    except Exception as e:
+        logger.error(f"헬스 체크 실패: {e}")
+        return {
+            "status": "unhealthy",
+            "error": str(e),
+            "checks": {
+                "chromadb_connection": False,
+                "embedding_model_loaded": False,
+                "collection_accessible": False
+            }
+        }
+
+
+@router.get("/search-demo")
+async def search_demo():
+    """
+    🎯 검색 데모 쿼리 예시
+
+    - 테스트용 검색 쿼리들
+    - API 사용법 가이드
+    """
+    return {
+        "demo_queries": [
+            {
+                "description": "기본 검색",
+                "query": "친구와 싸웠어요",
+                "example_request": {
+                    "query": "친구와 싸웠어요",
+                    "top_k": 5
+                }
+            },
+            {
+                "description": "감정 필터 검색",
+                "query": "학교에서 스트레스 받아",
+                "example_request": {
+                    "query": "학교에서 스트레스 받아",
+                    "top_k": 3,
+                    "filter_metadata": {
+                        "emotion": "분노"
+                    }
+                }
+            },
+            {
+                "description": "관계 맥락 검색",
+                "query": "잔소리 때문에 힘들어",
+                "example_request": {
+                    "query": "잔소리 때문에 힘들어",
+                    "top_k": 5,
+                    "filter_metadata": {
+                        "relationship": "부모님",
+                        "data_source": "aihub"
+                    }
+                }
+            }
+        ],
+        "usage_tips": [
+            "구체적인 상황을 포함한 쿼리가 더 좋은 결과를 제공합니다",
+            "감정과 관계 맥락을 필터로 활용하면 정확도가 높아집니다",
+            "top_k는 1-20 사이의 값을 권장합니다"
+        ]
+    }

src/core/vector_store.py

@@ -0,0 +1,219 @@
+"""
+ChromaDB 기반 Vector Store - 핵심 기능만
+"""
+
+import chromadb
+from chromadb.config import Settings
+from sentence_transformers import SentenceTransformer
+from typing import List, Dict, Any, Optional
+from loguru import logger
+import os
+import uuid
+import time
+from datetime import datetime
+
+from ..models.vector_models import SearchResult, DocumentInput, VectorStoreStats
+
+
+class ChromaVectorStore:
+    """ChromaDB 기반 Vector Store"""
+
+    def __init__(self, collection_name: str = "teen_empathy_chat"):
+        self.collection_name = collection_name
+        self.client = None
+        self.collection = None
+        self.embedding_model = None
+        self.model_name = "jhgan/ko-sbert-multitask"
+
+    async def initialize(self):
+        """ChromaDB 및 임베딩 모델 초기화"""
+        try:
+            logger.info("ChromaDB Vector Store 초기화 시작...")
+
+            # ChromaDB 클라이언트 생성
+            db_path = os.getenv("CHROMADB_PATH", "./data/chromadb")
+            os.makedirs(db_path, exist_ok=True)
+
+            self.client = chromadb.PersistentClient(
+                path=db_path,
+                settings=Settings(allow_reset=True, anonymized_telemetry=False)
+            )
+
+            # 한국어 임베딩 모델 로드
+            logger.info(f"한국어 임베딩 모델 로드 중: {self.model_name}")
+            self.embedding_model = SentenceTransformer(self.model_name)
+            logger.info(f"임베딩 모델 로드 완료 - 차원: {self.embedding_model.get_sentence_embedding_dimension()}")
+
+            # 컬렉션 생성/연결
+            try:
+                self.collection = self.client.get_collection(name=self.collection_name)
+                logger.info(f"기존 컬렉션 연결: {self.collection_name}")
+            except ValueError:
+                self.collection = self.client.create_collection(
+                    name=self.collection_name,
+                    metadata={
+                        "description": "Teen empathy conversation embeddings",
+                        "embedding_model": self.model_name,
+                        "created_at": datetime.now().isoformat()
+                    }
+                )
+                logger.info(f"새 컬렉션 생성: {self.collection_name}")
+
+            logger.info("✅ ChromaDB Vector Store 초기화 완료")
+
+        except Exception as e:
+            logger.error(f"❌ ChromaDB 초기화 실패: {e}")
+            raise
+
+    def create_embeddings(self, texts: List[str]) -> List[List[float]]:
+        """한국어 임베딩 생성"""
+        try:
+            if not self.embedding_model:
+                raise ValueError("임베딩 모델이 초기화되지 않았습니다")
+
+            logger.info(f"임베딩 생성 중: {len(texts)}개 텍스트")
+            embeddings = self.embedding_model.encode(texts, convert_to_numpy=True)
+            embeddings_list = embeddings.tolist()
+            logger.info(f"✅ 임베딩 생성 완료: {len(embeddings_list)}개")
+
+            return embeddings_list
+
+        except Exception as e:
+            logger.error(f"❌ 임베딩 생성 실패: {e}")
+            raise
+
+    async def add_documents(self, documents: List[DocumentInput]) -> List[str]:
+        """문서들을 Vector DB에 추가"""
+        try:
+            if not self.collection:
+                raise ValueError("컬렉션이 초기화되지 않았습니다")
+
+            logger.info(f"문서 추가 시작: {len(documents)}개")
+
+            # 텍스트와 메타데이터 분리
+            texts = [doc.content for doc in documents]
+            metadatas = []
+            document_ids = []
+
+            for doc in documents:
+                doc_id = doc.document_id or str(uuid.uuid4())
+                document_ids.append(doc_id)
+
+                metadata = doc.metadata.copy() if doc.metadata else {}
+                metadata.update({
+                    "timestamp": datetime.now().isoformat(),
+                    "content_length": len(doc.content)
+                })
+                metadatas.append(metadata)
+
+            # 임베딩 생성
+            embeddings = self.create_embeddings(texts)
+
+            # ChromaDB에 추가
+            self.collection.add(
+                embeddings=embeddings,
+                documents=texts,
+                metadatas=metadatas,
+                ids=document_ids
+            )
+
+            logger.info(f"✅ 문서 {len(documents)}개 추가 완료")
+            return document_ids
+
+        except Exception as e:
+            logger.error(f"❌ 문서 추가 실패: {e}")
+            raise
+
+    async def search(self, query: str, top_k: int = 5,
+                    filter_metadata: Optional[Dict[str, Any]] = None) -> List[SearchResult]:
+        """유사도 기반 문서 검색"""
+        try:
+            if not self.collection:
+                raise ValueError("컬렉션이 초기화되지 않았습니다")
+
+            start_time = time.time()
+            logger.info(f"검색 시작 - 쿼리: '{query[:50]}...', top_k: {top_k}")
+
+            # 쿼리 임베딩 생성
+            query_embedding = self.create_embeddings([query])[0]
+
+            # ChromaDB 검색
+            search_kwargs = {
+                "query_embeddings": [query_embedding],
+                "n_results": top_k,
+                "include": ["documents", "metadatas", "distances"]
+            }
+
+            if filter_metadata:
+                search_kwargs["where"] = filter_metadata
+
+            results = self.collection.query(**search_kwargs)
+
+            # 결과 포맷팅
+            search_results = []
+
+            if results["documents"] and results["documents"][0]:
+                for i in range(len(results["documents"][0])):
+                    distance = results["distances"][0][i]
+
+                    # 유클리드 거리를 유사도로 변환
+                    if distance <= 200:
+                        similarity_score = 0.8 - (distance / 200) * 0.3
+                    elif distance <= 300:
+                        similarity_score = 0.5 - ((distance - 200) / 100) * 0.3
+                    else:
+                        similarity_score = max(0.01, 1000 / (distance + 100))
+
+                    similarity_score = max(0.0, min(1.0, similarity_score))
+
+                    search_results.append(SearchResult(
+                        content=results["documents"][0][i],
+                        metadata=results["metadatas"][0][i] if results["metadatas"][0] else {},
+                        score=similarity_score,
+                        document_id=f"result_{i}"
+                    ))
+
+            search_time = (time.time() - start_time) * 1000
+            logger.info(f"✅ 검색 완료: {len(search_results)}개 결과 ({search_time:.2f}ms)")
+            return search_results
+
+        except Exception as e:
+            logger.error(f"❌ 검색 실패: {e}")
+            raise
+
+    async def get_collection_stats(self) -> VectorStoreStats:
+        """컬렉션 통계 정보"""
+        try:
+            if not self.collection:
+                raise ValueError("컬렉션이 초기화되지 않음")
+
+            count = self.collection.count()
+
+            return VectorStoreStats(
+                collection_name=self.collection_name,
+                total_documents=count,
+                embedding_model=self.model_name,
+                embedding_dimension=self.embedding_model.get_sentence_embedding_dimension() if self.embedding_model else None,
+                database_path=os.getenv("CHROMADB_PATH", "./data/chromadb"),
+                status="healthy" if count >= 0 else "error",
+                last_updated=datetime.now().isoformat()
+            )
+
+        except Exception as e:
+            logger.error(f"통계 조회 실패: {e}")
+            raise
+
+
+# 전역 인스턴스
+_vector_store_instance = None
+
+async def get_vector_store() -> ChromaVectorStore:
+    """Vector Store 싱글톤 인스턴스 반환"""
+    global _vector_store_instance
+
+    if _vector_store_instance is None:
+        collection_name = os.getenv("COLLECTION_NAME", "teen_empathy_chat")
+        _vector_store_instance = ChromaVectorStore(collection_name)
+        await _vector_store_instance.initialize()
+
+    return _vector_store_instance

src/models/function_models.py

@@ -0,0 +1,116 @@
+"""
+OpenAI 및 기타 기능 관련 데이터 모델들
+GPT-4 API 호출, 채팅, 감정 분석 등의 모델들
+"""
+
+from pydantic import BaseModel, Field
+from typing import List, Optional, Dict, Any, Literal
+from datetime import datetime
+from enum import Enum
+
+
+class ChatRole(str, Enum):
+    """채팅 역할 열거형"""
+    SYSTEM = "system"
+    USER = "user"
+    ASSISTANT = "assistant"
+
+
+class ChatMessage(BaseModel):
+    """채팅 메시지 모델"""
+    role: ChatRole = Field(..., description="메시지 역할")
+    content: str = Field(..., description="메시지 내용", min_length=1)
+    timestamp: Optional[str] = Field(default_factory=lambda: datetime.now().isoformat(), description="메시지 시간")
+
+
+class OpenAICompletionRequest(BaseModel):
+    """OpenAI 완성 요청 모델"""
+    messages: List[ChatMessage] = Field(..., description="대화 메시지 목록")
+    model: str = Field(default="gpt-4", description="사용할 모델")
+    temperature: float = Field(default=0.7, description="응답 창의성", ge=0, le=2)
+    max_tokens: int = Field(default=500, description="최대 토큰 수", ge=1, le=4000)
+    top_p: float = Field(default=1.0, description="확률 임계값", ge=0, le=1)
+    stream: bool = Field(default=False, description="스트리밍 여부")
+
+
+class OpenAICompletionResponse(BaseModel):
+    """OpenAI 완성 응답 모델"""
+    content: str = Field(..., description="생성된 응답 내용")
+    model: str = Field(..., description="사용된 모델")
+    tokens_used: int = Field(..., description="사용된 토큰 수")
+    processing_time_ms: float = Field(..., description="처리 시간 (밀리초)")
+    finish_reason: str = Field(..., description="완료 이유")
+
+
+class EmotionType(str, Enum):
+    """감정 유형 열거형"""
+    JOY = "기쁨"
+    CONFUSION = "당황"
+    ANGER = "분노"
+    ANXIETY = "불안"
+    HURT = "상처"
+    SADNESS = "슬픔"
+
+
+class RelationshipType(str, Enum):
+    """관계 유형 열거형"""
+    PARENT = "부모님"
+    FRIEND = "친구"
+    SIBLING = "형제자매"
+    CRUSH = "좋아하는 사람"
+    CLASSMATE = "동급생"
+    FAMILY = "가족"
+
+
+class EmpathyStrategy(str, Enum):
+    """공감 전략 열거형"""
+    ENCOURAGE = "격려"
+    AGREE = "동조"
+    COMFORT = "위로"
+    ADVISE = "조언"
+
+
+class EmotionAnalysisRequest(BaseModel):
+    """감정 분석 요청 모델"""
+    text: str = Field(..., description="분석할 텍스트", min_length=1, max_length=1000)
+    context: Optional[str] = Field(default=None, description="추가 맥락 정보")
+
+
+class EmotionAnalysisResponse(BaseModel):
+    """감정 분석 응답 모델"""
+    primary_emotion: EmotionType = Field(..., description="주요 감정")
+    emotion_confidence: float = Field(..., description="감정 신뢰도", ge=0, le=1)
+    relationship_context: Optional[RelationshipType] = Field(default=None, description="관계 맥락")
+    recommended_strategies: List[EmpathyStrategy] = Field(..., description="추천 공감 전략")
+
+
+class TeenChatRequest(BaseModel):
+    """청소년 채팅 요청 모델"""
+    message: str = Field(..., description="사용자 메시지", min_length=1, max_length=1000)
+
+
+class ReActStep(BaseModel):
+    """ReAct 추론 단계 모델"""
+    step_type: Literal["thought", "action", "observation"] = Field(..., description="단계 유형")
+    content: str = Field(..., description="단계 내용")
+    timestamp: str = Field(default_factory=lambda: datetime.now().isoformat(), description="단계 시간")
+
+
+class TeenChatResponse(BaseModel):
+    """청소년 채팅 응답 모델"""
+    response: str = Field(..., description="공감형 응답")
+    detected_emotion: EmotionType = Field(..., description="감지된 감정")
+    empathy_strategy: List[EmpathyStrategy] = Field(..., description="적용된 공감 전략")
+    similar_contexts: List[Dict[str, Any]] = Field(default=[], description="유사한 대화 맥락")
+    react_steps: Optional[List[ReActStep]] = Field(default=None, description="ReAct 추론 과정")
+    confidence_score: float = Field(..., description="응답 신뢰도", ge=0, le=1)
+    response_metadata: Dict[str, Any] = Field(default={}, description="응답 메타데이터")
+
+
+class SystemHealthCheck(BaseModel):
+    """시스템 헬스 체크 모델"""
+    status: Literal["healthy", "degraded", "unhealthy"] = Field(..., description="시스템 상태")
+    services: Dict[str, bool] = Field(..., description="서비스별 상태")
+    response_time_ms: float = Field(..., description="응답 시간 (밀리초)")
+    timestamp: str = Field(default_factory=lambda: datetime.now().isoformat(), description="체크 시간")
+    version: str = Field(..., description="시스템 버전")

src/models/vector_models.py

@@ -0,0 +1,170 @@
+"""
+Vector Store 관련 데이터 모델들
+ChromaDB와 연동하는 Pydantic 모델들
+"""
+
+from pydantic import BaseModel, Field
+from typing import Dict, List, Any, Optional
+from datetime import datetime
+
+
+class DocumentInput(BaseModel):
+    """벡터 DB에 저장할 문서 입력 모델"""
+    content: str = Field(..., description="문서 내용", min_length=1)
+    metadata: Optional[Dict[str, Any]] = Field(default={}, description="문서 메타데이터")
+    document_id: Optional[str] = Field(default=None, description="문서 고유 ID")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "content": "[불안] [친구] 친구가 나를 무시하는 것 같아서 속상해",
+                "metadata": {
+                    "emotion": "불안",
+                    "relationship": "친구",
+                    "empathy_label": "위로",
+                    "data_source": "aihub"
+                },
+                "document_id": "session_001"
+            }
+        }
+
+
+class SearchResult(BaseModel):
+    """벡터 검색 결과 모델"""
+    content: str = Field(..., description="검색된 문서 내용")
+    metadata: Dict[str, Any] = Field(default={}, description="문서 메타데이터")
+    score: float = Field(..., description="유사도 점수 (0~1)", ge=0, le=1)
+    document_id: str = Field(..., description="문서 고유 ID")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "content": "[불안] [친구] 친구가 나를 무시하는 것 같아서 속상해",
+                "metadata": {
+                    "user_utterance": "친구가 나를 무시하는 것 같아서 속상해",
+                    "system_response": "친구가 너를 무시한다고 느끼는 구체적인 상황이 있었나?",
+                    "emotion": "불안",
+                    "relationship": "친구",
+                    "empathy_label": "위로"
+                },
+                "score": 0.95,
+                "document_id": "session_001"
+            }
+        }
+
+
+class VectorSearchRequest(BaseModel):
+    """벡터 검색 요청 모델"""
+    query: str = Field(..., description="검색 쿼리", min_length=1, max_length=500)
+    top_k: int = Field(default=5, description="반환할 결과 수", ge=1, le=20)
+    filter_metadata: Optional[Dict[str, Any]] = Field(default=None, description="메타데이터 필터")
+    include_scores: bool = Field(default=True, description="유사도 점수 포함 여부")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "query": "친구와 싸웠어요",
+                "top_k": 3,
+                "filter_metadata": {
+                    "emotion": "분노",
+                    "data_source": "aihub"
+                },
+                "include_scores": True
+            }
+        }
+
+
+class VectorSearchResponse(BaseModel):
+    """벡터 검색 응답 모델"""
+    results: List[SearchResult] = Field(..., description="검색 결과 목록")
+    query: str = Field(..., description="검색 쿼리")
+    total_results: int = Field(..., description="총 결과 수")
+    search_time_ms: float = Field(..., description="검색 소요 시간 (밀리초)")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "results": [
+                    {
+                        "content": "[분노] [친구] 친구와 싸워서 화가 나",
+                        "metadata": {
+                            "emotion": "분노",
+                            "relationship": "친구",
+                            "empathy_label": "위로"
+                        },
+                        "score": 0.92,
+                        "document_id": "session_123"
+                    }
+                ],
+                "query": "친구와 싸웠어요",
+                "total_results": 1,
+                "search_time_ms": 45.2
+            }
+        }
+
+
+class DocumentAddRequest(BaseModel):
+    """문서 추가 요청 모델"""
+    documents: List[DocumentInput] = Field(..., description="추가할 문서들", min_items=1)
+    batch_size: int = Field(default=100, description="배치 크기", ge=1, le=1000)
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "documents": [
+                    {
+                        "content": "[기쁨] [친구] 친구와 함께 시험을 잘 봤어요",
+                        "metadata": {
+                            "emotion": "기쁨",
+                            "relationship": "친구",
+                            "empathy_label": "격려"
+                        }
+                    }
+                ],
+                "batch_size": 50
+            }
+        }
+
+
+class DocumentAddResponse(BaseModel):
+    """문서 추가 응답 모델"""
+    success: bool = Field(..., description="추가 성공 여부")
+    added_count: int = Field(..., description="추가된 문서 수")
+    document_ids: List[str] = Field(..., description="추가된 문서 ID 목록")
+    processing_time_ms: float = Field(..., description="처리 소요 시간 (밀리초)")
+    errors: List[str] = Field(default=[], description="오류 메시지 목록")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "success": True,
+                "added_count": 5,
+                "document_ids": ["doc_001", "doc_002", "doc_003"],
+                "processing_time_ms": 1250.5,
+                "errors": []
+            }
+        }
+
+
+class VectorStoreStats(BaseModel):
+    """벡터 스토어 통계 모델"""
+    collection_name: str = Field(..., description="컬렉션 이름")
+    total_documents: int = Field(..., description="총 문서 수")
+    embedding_model: str = Field(..., description="사용중인 임베딩 모델")
+    embedding_dimension: Optional[int] = Field(default=None, description="임베딩 차원")
+    database_path: str = Field(..., description="데이터베이스 경로")
+    status: str = Field(..., description="상태")
+    last_updated: str = Field(default_factory=lambda: datetime.now().isoformat(), description="마지막 업데이트")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "collection_name": "teen_empathy_chat",
+                "total_documents": 31821,
+                "embedding_model": "jhgan/ko-sbert-multitask",
+                "embedding_dimension": 768,
+                "database_path": "./data/chromadb",
+                "status": "healthy",
+                "last_updated": "2024-01-01T12:00:00"
+            }
+        }

src/services/aihub_processor.py

@@ -0,0 +1,61 @@
+"""
+AI Hub 공감형 대화 데이터 처리기
+"""
+from typing import Dict, List, Optional
+from loguru import logger
+
+class TeenEmpathyDataProcessor:
+    def __init__(self, vector_store):
+        self.vector_store = vector_store
+        logger.info("TeenEmpathyDataProcessor 초기화 완료. Vector Store가 주입되었습니다.")
+
+    async def search_similar_contexts(self, query: str, emotion: Optional[str] = None,
+                                    relationship: Optional[str] = None, top_k: int = 3) -> List[Dict]:
+        """
+        [수정됨] 원본 쿼리와 메타데이터 필터를 사용하여 유사한 대화 맥락을 정확하게 검색합니다.
+        """
+        try:
+            # 1. 메타데이터 필터 구성 (ChromaDB의 올바른 $and 문법 사용)
+            conditions = []
+            if emotion: conditions.append({"emotion": {"$eq": emotion}})
+            if relationship: conditions.append({"relationship": {"$eq": relationship}})
+
+            search_filter = None
+            if len(conditions) > 1: search_filter = {"$and": conditions}
+            elif len(conditions) == 1: search_filter = conditions[0]
+
+            logger.info(f"🔍 벡터 검색 시작 - Query: '{query}', Filter: {search_filter}")
+
+            # 2. 원본 쿼리로 벡터 검색 실행
+            results = await self.vector_store.search(
+                query=query,
+                top_k=top_k,
+                filter_metadata=search_filter
+            )
+
+            formatted_results = [{
+                "user_utterance": r.metadata.get("user_utterance", ""),
+                "system_response": r.metadata.get("system_response", ""),
+                "emotion": r.metadata.get("emotion", ""),
+                "relationship": r.metadata.get("relationship", ""),
+                "empathy_label": r.metadata.get("empathy_label", ""),
+                "similarity_score": r.score
+            } for r in results]
+
+            formatted_results.sort(key=lambda x: x["similarity_score"], reverse=True)
+            logger.info(f"✅ 검색 완료: {len(formatted_results)}개 결과")
+            return formatted_results
+
+        except Exception as e:
+            logger.error(f"❌ 유사 사례 검색 실패: {e}")
+            return []
+
+# 전역 인스턴스 관리
+_processor_instance = None
+async def get_teen_empathy_processor() -> TeenEmpathyDataProcessor:
+    global _processor_instance
+    if _processor_instance is None:
+        from ..core.vector_store import get_vector_store
+        vector_store = await get_vector_store()
+        _processor_instance = TeenEmpathyDataProcessor(vector_store=vector_store)
+    return _processor_instance

src/services/conversation_service.py

@@ -0,0 +1,96 @@
+"""
+간단한 대화 저장 시스템 - SQLite
+"""
+import sqlite3
+import json
+import uuid
+import os
+from datetime import datetime
+from typing import List, Dict
+from pathlib import Path
+from contextlib import contextmanager
+from loguru import logger
+
+class ConversationService:
+    def __init__(self):
+        db_path = os.getenv("CONVERSATION_DB_PATH", "/app/data/conversations/conversations.db")
+        self.db_path = Path(db_path)
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._ensure_tables()
+        logger.info(f"✅ 대화 DB 초기화: {self.db_path}")
+
+    def _ensure_tables(self):
+        try:
+            with self._get_connection() as conn:
+                conn.executescript("""
+                CREATE TABLE IF NOT EXISTS conversations (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL,
+                    role TEXT NOT NULL,
+                    content TEXT NOT NULL,
+                    timestamp TEXT NOT NULL
+                );
+                CREATE INDEX IF NOT EXISTS idx_conversations_session ON conversations(session_id);
+                """)
+        except Exception as e:
+            logger.error(f"❌ DB 테이블 초기화 실패: {e}")
+            raise
+
+    @contextmanager
+    def _get_connection(self):
+        conn = None
+        try:
+            conn = sqlite3.connect(self.db_path, timeout=15.0)
+            conn.row_factory = sqlite3.Row
+            yield conn
+        finally:
+            if conn:
+                conn.close()
+
+    async def get_or_create_session(self, session_id: str = None) -> str:
+        if session_id: return session_id
+        return f"session_{uuid.uuid4().hex[:12]}"
+
+    async def save_conversation_turn(self, session_id: str, user_message: str, assistant_response: str):
+        now = datetime.now().isoformat()
+        try:
+            with self._get_connection() as conn:
+                conn.execute("BEGIN")
+                conn.execute(
+                    "INSERT INTO conversations (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)",
+                    (session_id, 'user', user_message, now)
+                )
+                conn.execute(
+                    "INSERT INTO conversations (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)",
+                    (session_id, 'assistant', assistant_response, now)
+                )
+                conn.commit()
+            logger.info(f"💾 대화 턴 저장 완료: {session_id}")
+        except Exception as e:
+            logger.error(f"❌ 대화 턴 저장 실패: {e}")
+            conn.rollback()
+
+    async def get_conversation_history(self, session_id: str, limit: int = 6) -> List[Dict[str, str]]:
+        """GPT 프롬프트에 사용하기 좋은 형태로 최근 대화 기록을 반환"""
+        history = []
+        try:
+            with self._get_connection() as conn:
+                rows = conn.execute("""
+                    SELECT role, content FROM conversations
+                    WHERE session_id = ? ORDER BY timestamp DESC LIMIT ?
+                """, (session_id, limit)).fetchall()
+
+                # 시간 역순으로 가져왔으므로 뒤집어서 시간 순으로 정렬
+                for row in reversed(rows):
+                    history.append({"role": row['role'], "content": row['content']})
+            logger.info(f"📚 대화 기록 조회 완료: {session_id}, {len(history)}개 메시지")
+        except Exception as e:
+            logger.warning(f"대화 기록 조회 실패: {e}")
+        return history
+
+_conversation_service_instance = None
+async def get_conversation_service() -> ConversationService:
+    global _conversation_service_instance
+    if _conversation_service_instance is None:
+        _conversation_service_instance = ConversationService()
+    return _conversation_service_instance

src/services/openai_client.py

@@ -0,0 +1,133 @@
+"""
+OpenAI GPT-4 클라이언트 - 최종 완성 버전
+"""
+import os
+from typing import List, Dict, Tuple, Optional
+from openai import AsyncOpenAI
+from loguru import logger
+from ..models.function_models import EmotionType, RelationshipType
+
+class OpenAIClient:
+    def __init__(self):
+        self.client = None
+        self.api_key = os.getenv("OPENAI_API_KEY")
+        self.default_model = os.getenv("OPENAI_MODEL", "gpt-4")
+        self.teen_empathy_system_prompt = """
+당신은 "마음이"라는 이름의 13-19세 청소년 전용 상담 AI입니다. 당신의 목표는 사용자의 말을 따뜻하게 들어주고 공감하며, 친한 친구처럼 반말로 대화하는 것입니다.
+
+**[매우 중요] 핵심 규칙:**
+- **페르소나 절대 유지:** 너는 반드시 친한 친구처럼, 따뜻하고 다정한 **반말**로 대화해야 해. **절대로 존댓말을 사용하면 안 돼!**
+- **맥락 기억:** 이전 대화 내용을 반드시 기억하고, 그 흐름에 맞춰 자연스럽게 대화를 이어가야 해.
+- **공감 우선:** 조언보다는 먼저 사용자의 감정을 알아주고 공감하는 말을 해줘. (예: "정말 속상했겠다.", "네 마음 충분히 이해돼.")
+- **영어 절대 금지:** 답변은 반드시 한글로만 생성해야 해.
+"""
+        self.conversion_map = { "자기야": "너", "당신": "너", "직장": "학교", "회사": "학교", "업무": "공부", "동료": "친구", "상사": "선생님", "하세요": "해", "어떠세요": "어때", "해보세요": "해봐", "~ㅂ니다": "~야", "~습니다": "~어" }
+
+    async def initialize(self):
+        if not self.api_key or "your_" in self.api_key.lower(): raise ValueError("올바른 OpenAI API 키를 설정해주세요")
+        self.client = AsyncOpenAI(api_key=self.api_key, timeout=30.0, max_retries=3)
+        await self._test_connection()
+        logger.info("✅ OpenAI 클라이언트 초기화 완료")
+
+    async def _test_connection(self):
+        try: await self.client.chat.completions.create(model=self.default_model, messages=[{"role": "user", "content": "Hello"}], max_tokens=5)
+        except Exception as e: raise e
+
+    async def create_completion(self, messages: List[Dict[str, str]], **kwargs) -> str:
+        if not self.client: await self.initialize()
+        response = await self.client.chat.completions.create(
+            model=kwargs.get("model", self.default_model), messages=messages,
+            temperature=kwargs.get("temperature", 0.7), max_tokens=kwargs.get("max_tokens", 500)
+        )
+        return response.choices[0].message.content
+
+    async def rewrite_query_with_history(self, user_message: str, conversation_history: List[Dict]) -> str:
+        if not conversation_history: return user_message
+        history_str = "\n".join([f"[{msg['role']}] {msg['content']}" for msg in conversation_history])
+        prompt = f"""당신은 사용자의 대화 전체를 깊이 이해하여, 벡터 검색에 가장 적합한 검색 문장을 생성하는 '쿼리 재작성 전문가'입니다.
+### 임무
+주어진 '이전 대화 내용'과 '사용자의 마지막 메시지'를 종합하여, 사용자가 겪고 있는 문제의 핵심 상황과 감정이 모두 담긴, 단 하나의 완벽한 문장으로 재작성해야 합니다.
+### 규칙
+1. 반드시 사용자의 입장에서, 사용자가 겪는 문제 상황을 중심으로 서술해야 합니다.
+2. 단순 키워드 나열은 절대 금지됩니다.
+3. 오직 '재작성된 검색 쿼리:' 부분의 내용만 결과로 출력해야 합니다.
+---
+### 모범 답안 예시
+[이전 대화 내용]
+[assistant] 요즘 무슨 고민 있어?
+[user] 제일 친한 친구가 요즘 나를 피하는 것 같아.
+[사용자 마지막 메시지]
+"방금도 단톡방에서 나만 빼고 자기들끼리만 얘기해."
+[재작성된 검색 쿼리]
+"가장 친한 친구가 다른 무리와 어울리며 단체 채팅방에서 나를 소외시켜 느끼는 따돌림과 서운함"
+---
+### 실제 과제
+[이전 대화 내용]
+{history_str}
+[사용자 마지막 메시지]
+"{user_message}"
+[재작성된 검색 쿼리]
+"""
+        rewritten_query = await self.create_completion(messages=[{"role": "user", "content": prompt}], temperature=0.0, max_tokens=200)
+        logger.info(f"대화형 쿼리 재작성: '{user_message}' -> '{rewritten_query.strip()}'")
+        return rewritten_query.strip()
+
+    async def analyze_emotion_and_context(self, text: str) -> dict:
+        emotion_list = [e.value for e in EmotionType]
+        relationship_list = [r.value for r in RelationshipType]
+        analysis_prompt = f"다음 청소년의 메시지에서 primary_emotion과 relationship_context를 추출해줘. 반드시 아래 목록의 한글 단어 중에서만 선택해서 JSON으로 응답해야 해.\n- primary_emotion: {emotion_list}\n- relationship_context: {relationship_list}\n\n메시지: \"{text}\""
+        try:
+            response_content = await self.create_completion(messages=[{"role": "user", "content": analysis_prompt}], temperature=0.0, max_tokens=200)
+            import json
+            return json.loads(response_content.strip())
+        except Exception:
+            return {"primary_emotion": EmotionType.ANXIETY.value, "relationship_context": RelationshipType.FRIEND.value}
+
+    def _apply_simple_conversions(self, text: str) -> str:
+        for old, new in self.conversion_map.items(): text = text.replace(old, new)
+        return text
+
+    async def verify_rag_relevance(self, user_message: str, retrieved_doc: str) -> bool:
+        prompt = f"사용자의 현재 메시지와 검색된 전문가 조언이 의미적으로 관련이 있는지 판단해줘. 반드시 'Yes' 또는 'No'로만 대답해.\n- 사용자 메시지: \"{user_message}\"\n- 검색된 조언: \"{retrieved_doc}\"\n\n관련이 있는가? (Yes/No):"
+        response = await self.create_completion(messages=[{"role": "user", "content": prompt}], temperature=0.0, max_tokens=5)
+        logger.info(f"RAG 검증 결과: {response.strip()}")
+        return "yes" in response.strip().lower()
+
+    async def adapt_expert_response(self, expert_response: str, user_situation: str, conversation_history: List[Dict]) -> Tuple[str, str, str, str]:
+        pre_adapted_response = self._apply_simple_conversions(expert_response)
+        messages = [{"role": "system", "content": self.teen_empathy_system_prompt}, *conversation_history, {"role": "user", "content": f"내 친구의 현재 상황은 '{user_situation}'이야. 내가 참고할 전문가 조언은 '{pre_adapted_response}'인데, 이 조언을 내 친구에게 말하듯 자연스럽고 따뜻한 반말로 바꿔줘."}]
+        final_prompt_for_debug = "\n".join([f"[{msg['role']}] {msg['content']}" for msg in messages])
+        final_response = await self.create_completion(messages=messages, temperature=0.5, max_tokens=400)
+        return expert_response, pre_adapted_response, final_response, final_prompt_for_debug
+
+    async def create_direct_response(self, user_message: str, conversation_history: List[Dict], inspirational_docs: Optional[List[str]] = None) -> Tuple[str, str]:
+        """[최종 수정] '영감'을 위한 참고 자료(inspirational_docs)를 인자로 받아 프롬프트에 추가"""
+
+        messages = [
+            {"role": "system", "content": self.teen_empathy_system_prompt},
+            *conversation_history
+        ]
+
+        inspiration_prompt = ""
+        if inspirational_docs:
+            inspiration_prompt = "\n\n### 참고 자료 (직접 언급하지 말고, 답변을 만들 때 영감을 얻는 용도로만 사용해)\n"
+            for doc in inspirational_docs:
+                inspiration_prompt += f"- {doc}\n"
+
+        final_user_prompt = f"""'마음이'의 페르소나(친한 친구, 반말)를 완벽하게 지키면서 다음 메시지에 공감하는 답변을 해줘.{inspiration_prompt}
+
+"{user_message}"
+"""
+        messages.append({"role": "user", "content": final_user_prompt})
+
+        final_response = await self.create_completion(messages=messages, temperature=0.7, max_tokens=300)
+        prompt_for_debug = "\n".join([f"[{msg['role']}] {msg['content']}" for msg in messages])
+        return final_response, prompt_for_debug
+
+_openai_client_instance = None
+async def get_openai_client() -> OpenAIClient:
+    global _openai_client_instance
+    if _openai_client_instance is None:
+        _openai_client_instance = OpenAIClient()
+        await _openai_client_instance.initialize()
+    return _openai_cㅎlient_instance

static/index.html

@@ -0,0 +1,191 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>마음이 AI | 너의 마음을 듣는 시간</title>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Noto+Sans+KR:wght@400;500;700&display=swap');
+        :root { --accent-color: #8A2BE2; --bg-color: #f4f7f6; --font-color: #333; }
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body { font-family: 'Noto Sans KR', sans-serif; background: var(--bg-color); display: flex; justify-content: center; align-items: center; min-height: 100vh; }
+        .chat-container { width: 100%; max-width: 700px; height: 95vh; max-height: 800px; background: #fff; border-radius: 20px; box-shadow: 0 8px 32px rgba(0,0,0,0.1); display: flex; flex-direction: column; }
+        .chat-header { background: var(--accent-color); color: white; padding: 20px; text-align: center; border-radius: 20px 20px 0 0; }
+        .chat-header h1 { font-size: 1.5rem; }
+        .chat-messages { flex: 1; padding: 20px; overflow-y: auto; }
+        .message { display: flex; margin-bottom: 20px; align-items: flex-end; }
+        .message.user { justify-content: flex-end; }
+        .avatar { width: 40px; height: 40px; border-radius: 50%; background: #eee; margin: 0 10px; font-size: 1.5rem; display: flex; justify-content: center; align-items: center; flex-shrink: 0;}
+        .message.user .avatar { background: #dcf8c6; }
+        .message.assistant .avatar { background: #e5e5ea; }
+        .message-bubble { max-width: 70%; padding: 12px 18px; border-radius: 18px; line-height: 1.6; }
+        .message.user .message-bubble { background: var(--accent-color); color: white; border-bottom-right-radius: 4px; }
+        .message.assistant .message-bubble { background: #e5e5ea; color: var(--font-color); border-bottom-left-radius: 4px; }
+        .chat-input-container { padding: 15px; border-top: 1px solid #eee; }
+        .chat-input-wrapper { display: flex; gap: 10px; }
+        .chat-input { flex: 1; border: 2px solid #ddd; border-radius: 25px; padding: 12px 20px; font-size: 1rem; }
+        .action-button { background: var(--accent-color); color: white; border: none; border-radius: 50%; width: 48px; height: 48px; cursor: pointer; font-size: 1.5rem; flex-shrink: 0; }
+        .action-button.debug { background: #ff6b6b; }
+        .typing-indicator .message-bubble { display: flex; align-items: center; gap: 5px; }
+        .typing-dot { width: 8px; height: 8px; background-color: #aaa; border-radius: 50%; animation: typing-pulse 1.4s infinite ease-in-out both; }
+        .typing-dot:nth-child(1) { animation-delay: -0.32s; }
+        .typing-dot:nth-child(2) { animation-delay: -0.16s; }
+        @keyframes typing-pulse { 0%, 80%, 100% { transform: scale(0); } 40% { transform: scale(1.0); } }
+    </style>
+</head>
+<body>
+    <div class="chat-container">
+        <div class="chat-header"><h1>💙 마음이 AI | 너의 마음을 듣는 시간</h1></div>
+        <div class="chat-messages" id="chatMessages">
+             <div class="message assistant"><div class="avatar">🤖</div><div class="message-bubble">안녕! 나는 너의 마음을 들어줄 친구 '마음이'야.</div></div>
+             <div class="message assistant" id="typingIndicator" style="display: none;">
+                <div class="avatar">🤖</div><div class="message-bubble"><div class="typing-dot"></div><div class="typing-dot"></div><div class="typing-dot"></div></div>
+            </div>
+        </div>
+        <div class="chat-input-container">
+            <div class="chat-input-wrapper">
+                <input type="text" class="chat-input" id="messageInput" placeholder="너의 이야기를 들려줘...">
+                <button class="action-button" id="sendButton" title="전송">➤</button>
+                <button class="action-button debug" id="openDebugButton" title="디버그 창 열기">🐞</button>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        const chatMessages = document.getElementById('chatMessages');
+        const messageInput = document.getElementById('messageInput');
+        const sendButton = document.getElementById('sendButton');
+        const openDebugButton = document.getElementById('openDebugButton');
+        const typingIndicator = document.getElementById('typingIndicator');
+
+        let debugWindow = null;
+        let sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+
+        function displayMessage(text, sender) {
+            const avatar = sender === 'user' ? '👤' : '🤖';
+            const messageEl = document.createElement('div');
+            messageEl.className = `message ${sender}`;
+            messageEl.innerHTML = `<div class="avatar">${avatar}</div><div class="message-bubble">${text}</div>`;
+            chatMessages.appendChild(messageEl);
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+        }
+
+        async function handleSendMessage() {
+            const message = messageInput.value.trim();
+            if (!message) return;
+            displayMessage(message, 'user');
+            messageInput.value = '';
+
+            // [최종 수정] '입력 중' 표시를 화면에 나타내기 전, 항상 맨 마지막 요소로 이동시킵니다.
+            chatMessages.appendChild(typingIndicator);
+            typingIndicator.style.display = 'flex';
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+
+            const isDebugMode = (debugWindow && !debugWindow.closed);
+            const endpoint = isDebugMode ? '/api/v1/chat/teen-chat-debug' : '/api/v1/chat/teen-chat';
+
+            try {
+                const response = await fetch(endpoint, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json', 'session-id': sessionId },
+                    body: JSON.stringify({ message: message })
+                });
+                const data = await response.json();
+                displayMessage(data.response || "응답을 받지 못했습니다.", 'assistant');
+                if (isDebugMode) updateDebugWindow(data);
+            } catch (error) {
+                console.error('API 통신 오류:', error);
+                displayMessage('죄송해요, 통신 중 문제가 발생했어요.', 'bot');
+            } finally {
+                typingIndicator.style.display = 'none';
+            }
+        }
+
+        function openDebugWindow() {
+            if (debugWindow && !debugWindow.closed) { debugWindow.focus(); return; }
+            debugWindow = window.open('', 'Debug_Window', 'width=1400,height=900,scrollbars=yes,resizable=yes');
+            const debugHTML = `
+                <!DOCTYPE html><html lang="ko"><head><title>🔬 전체 과정 투명성 로그</title>
+                <style>
+                    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", sans-serif; line-height: 1.6; padding: 20px; background: #f9f9fa; color: #333; }
+                    .header { text-align: center; margin-bottom: 30px; }
+                    .header h1 { color: #8A2BE2; }
+                    .container { display: flex; gap: 20px; align-items: flex-start; }
+                    .column { flex: 1; min-width: 0; }
+                    .step { background: #fff; border: 1px solid #eef; border-radius: 12px; padding: 20px; box-shadow: 0 4px 12px rgba(0,0,0,0.05); margin-bottom: 15px; }
+                    .step h3, .column h2 { font-size: 1.2em; color: #8A2BE2; display: flex; align-items: center; gap: 8px; margin-top: 0; }
+                    .step-content { margin-top: 15px; }
+                    pre { background: #f0f2f5; padding: 15px; border-radius: 8px; white-space: pre-wrap; word-wrap: break-word; font-family: 'SF Mono', Consolas, monospace; font-size: 0.9em; }
+                    .diff-container { border: 1px solid #ddd; padding: 15px; border-radius: 8px; margin-top: 10px;}
+                    .diff del { background-color: #ffebe9; color: #c00; text-decoration: none; }
+                    .diff ins { background-color: #e6ffed; color: #22863a; text-decoration: none; }
+                    .react-step { border-left: 3px solid #ccc; padding-left: 15px; margin-bottom: 10px; }
+                    .react-step-thought { border-left-color: #f0ad4e; }
+                    .react-step-action { border-left-color: #5cb85c; }
+                    .react-step-observation { border-left-color: #5bc0de; }
+                </style></head><body>
+                    <div class="header"><h1>🔬 전체 과정 투명성 로그</h1></div>
+                    <div id="debug-content" class="container"></div>
+                </body></html>`;
+            debugWindow.document.write(debugHTML);
+            debugWindow.document.close();
+        }
+
+        function createDiffHtml(text1, text2) {
+            const a = text1.split(/(\s+)/); const b = text2.split(/(\s+)/);
+            const dp = Array(a.length + 1).fill(null).map(() => Array(b.length + 1).fill(0));
+            for (let i = a.length - 1; i >= 0; i--) {
+                for (let j = b.length - 1; j >= 0; j--) {
+                    if (a[i] === b[j]) dp[i][j] = 1 + dp[i+1][j+1];
+                    else dp[i][j] = Math.max(dp[i+1][j], dp[i][j+1]);
+                }
+            }
+            let i = 0, j = 0; let result = '';
+            while (i < a.length && j < b.length) {
+                if (a[i] === b[j]) { result += a[i]; i++; j++; }
+                else if (dp[i+1][j] >= dp[i][j+1]) { result += `<del>${a[i]}</del>`; i++; }
+                else { result += `<ins>${b[j]}</ins>`; j++; }
+            }
+            return `<div class="diff">${result}</div>`;
+        }
+
+        function updateDebugWindow(data) {
+            if (!debugWindow || !debugWindow.document) return;
+            const debugContentEl = debugWindow.document.getElementById('debug-content');
+
+            const escape = (str) => str ? str.toString().replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;") : '';
+
+            const reactStepsHtml = (data.react_steps || []).map(step => {
+                const content = escape(step.content || '');
+                return `<div class="react-step react-step-${step.step_type}"><strong>[${step.step_type.toUpperCase()}]</strong><pre>${content}</pre></div>`;
+            }).join('');
+            const reactColumnHtml = `<div class="column"><h2>🤔 ReAct 추론 과정</h2><div class="step">${reactStepsHtml}</div></div>`;
+
+            let detailHtml = '';
+            const info = data.debug_info || {};
+            for (const [stepKey, value] of Object.entries(info)) {
+                let contentHtml = '';
+                if (stepKey === 'step4_generation' && value.strategy === 'RAG-Adaptation') {
+                     contentHtml = `<strong>전략:</strong> RAG 답변 적응<hr>
+                                   <h4>A. 원본 전문가 조언</h4> <pre>${escape(value.A_source_expert_advice)}</pre>
+                                   <h4>B. 1차 단어 변환</h4> ${createDiffHtml(value.A_source_expert_advice, value.B_rule_based_adaptation)}
+                                   <h4>C. 최종 GPT-4 프롬프트</h4> <pre>${escape(value.C_final_gpt4_prompt)}</pre>
+                                   <h4>D. 최종 생성 답변</h4> <pre style="background: var(--light-purple);">${escape(value.D_final_response)}</pre>`;
+                } else {
+                    contentHtml = `<pre>${escape(JSON.stringify(value, null, 2))}</pre>`;
+                }
+                detailHtml += `<div class="step"><h3>${stepKey.replace('step', 'Step ').replace(/_/g, ' ')}</h3><div class="step-content">${contentHtml}</div></div>`;
+            }
+            const detailColumnHtml = `<div class="column"><h2>🔍 상세 데이터 흐름</h2>${detailHtml}</div>`;
+
+            debugContentEl.innerHTML = reactColumnHtml + detailColumnHtml;
+        }
+
+        sendButton.addEventListener('click', handleSendMessage);
+        openDebugButton.addEventListener('click', openDebugWindow);
+        messageInput.addEventListener('keypress', (e) => {
+            if (e.key === 'Enter') { e.preventDefault(); handleSendMessage(); }
+        });
+    </script>
+</body>
+</html>