diff --git a/.github/workflows/ci-java.yml b/.github/workflows/ci-java.yml
index 773b9102..f19d3b00 100644
--- a/.github/workflows/ci-java.yml
+++ b/.github/workflows/ci-java.yml
@@ -15,21 +15,47 @@ on:
       - ".github/workflows/ci-java.yml"
 
 permissions:
-  contents: read
+  contents: write   # Dependency graph 생성용
   packages: write
   security-events: write
   checks: write
   pull-requests: write
   pages: write      # GitHub Pages 배포
   id-token: write   # GitHub Pages 배포
+  actions: write
 
 jobs:
+  dependency-submission:
+    if: github.event_name != 'pull_request'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '21'
+
+      - name: Generate and submit dependency graph
+        uses: gradle/actions/dependency-submission@v4
+        with:
+          build-root-directory: apps/user-service
+
   spotless-check:
     if: github.event.pull_request.draft == false
     name: Lint Check
     runs-on: ubuntu-latest
 
     steps:
+      - name: Debug cache settings
+        run: |
+          echo "Event name: ${{ github.event_name }}"
+          echo "Event type: ${{ github.event.action }}"
+          echo "Cache read-only condition: ${{ github.event_name == 'pull_request' }}"
+          echo "GitHub ref: ${{ github.ref }}"
+
       - name: Checkout repository
         uses: actions/checkout@v4
 
@@ -44,6 +70,11 @@ jobs:
         uses: gradle/actions/setup-gradle@v3
         with:
           cache-read-only: ${{ github.event_name == 'pull_request' }}
+          gradle-home-cache-cleanup: false
+          gradle-home-cache-includes: |
+            caches
+            notifications
+            wrapper
 
       - name: Grant execute permission for Gradle wrapper
         run: chmod +x ./gradlew
@@ -73,7 +104,7 @@ jobs:
           distribution: 'temurin'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v3
+        uses: gradle/actions/setup-gradle@v4
         with:
           cache-read-only: ${{ github.event_name == 'pull_request' }}
 
diff --git a/.github/workflows/deploy-java.yml b/.github/workflows/deploy-java.yml
index bb4483dd..facbdd1c 100644
--- a/.github/workflows/deploy-java.yml
+++ b/.github/workflows/deploy-java.yml
@@ -79,7 +79,7 @@ jobs:
           source: "docker/production/promtail-config.yml"
           target: "~/app"
 
-      - name: Copy promtail-config to EC2
+      - name: Copy agent-config to EC2
         uses: appleboy/scp-action@v0.1.7
         with:
           host: ${{ secrets.SERVER_HOST }}
@@ -89,6 +89,26 @@ jobs:
           target: "~/app"
           overwrite: true
 
+      - name: Copy application-production.yml to EC2
+        uses: appleboy/scp-action@v0.1.7
+        with:
+          host: ${{ secrets.SERVER_HOST }}
+          username: ubuntu
+          key: ${{ secrets.SERVER_SSH_KEY }}
+          source: "apps/user-service/src/main/resources/application-production.yml"
+          target: "~/app/docker/production/config/application-production.yml"
+          overwrite: true
+
+      - name: Copy log4j2-production.yml to EC2
+        uses: appleboy/scp-action@v0.1.7
+        with:
+          host: ${{ secrets.SERVER_HOST }}
+          username: ubuntu
+          key: ${{ secrets.SERVER_SSH_KEY }}
+          source: "apps/user-service/src/main/resources/log4j2-production.yml"
+          target: "~/app/docker/production/config/log4j2-production.yml"
+          overwrite: true
+
       - name: Deploy on EC2
         uses: appleboy/ssh-action@v1.0.3
         with:
diff --git a/apps/pre-processing-service/Dockerfile b/apps/pre-processing-service/Dockerfile
index 13af476a..5efac953 100644
--- a/apps/pre-processing-service/Dockerfile
+++ b/apps/pre-processing-service/Dockerfile
@@ -2,13 +2,11 @@
 FROM python:3.11-slim AS builder
 WORKDIR /app
 
-# 필수 OS 패키지 (기존 + Chrome 설치용 패키지 추가)
+# 필수 OS 패키지 설치
 RUN apt-get update && apt-get install -y --no-install-recommends \
     curl \
-    wget \
-    unzip \
-    gnupg \
     ca-certificates \
+    build-essential \
   && rm -rf /var/lib/apt/lists/*
 
 # Poetry 설치
@@ -20,16 +18,15 @@ RUN poetry self add "poetry-plugin-export>=1.7.0"
 RUN python -m venv /opt/venv
 ENV PATH="/opt/venv/bin:$PATH"
 
-# 의존성 해결 → requirements로 export → pip로 설치(= 반드시 /opt/venv에 설치됨)
+# poetry → requirements로 export → pip로 설치
 COPY pyproject.toml poetry.lock ./
 RUN poetry export --without dev -f requirements.txt -o requirements.txt \
  && pip install --no-cache-dir -r requirements.txt
-
 # ---- runtime ----
 FROM python:3.11-slim AS final
 WORKDIR /app
 
-# Chrome과 ChromeDriver 설치를 위한 패키지 설치
+# Chrome과 ChromeDriver 설치를 위한 패키지 설치 (삭제 예정 - 마운트 방식)
 RUN apt-get update && apt-get install -y --no-install-recommends \
     wget \
     unzip \
@@ -38,14 +35,14 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     ca-certificates \
     && rm -rf /var/lib/apt/lists/*
 
-# Chrome 설치 (블로그 방식 - 직접 .deb 파일 다운로드)
+# Chrome 설치 (삭제 예정 - 마운트 방식)
 RUN wget -q https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb \
     && apt-get update \
     && apt-get install -y ./google-chrome-stable_current_amd64.deb \
     && rm ./google-chrome-stable_current_amd64.deb \
     && rm -rf /var/lib/apt/lists/*
 
-# MeCab & 사전 설치 (형태소 분석 의존)
+# MeCab & 사전 설치 (삭제 예정 - 마운트 방식)
 RUN apt-get update && apt-get install -y --no-install-recommends \
     mecab \
     libmecab-dev \
@@ -53,7 +50,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     build-essential \
     && rm -rf /var/lib/apt/lists/*
 
-# 한국어 사전 수동 설치
+# 한국어 사전 수동 설치 (삭제 예정 - 마운트 방식)
 RUN cd /tmp && \
     wget https://bitbucket.org/eunjeon/mecab-ko-dic/downloads/mecab-ko-dic-2.1.1-20180720.tar.gz && \
     tar -zxf mecab-ko-dic-2.1.1-20180720.tar.gz && \
@@ -70,5 +67,5 @@ ENV PATH="/opt/venv/bin:$PATH"
 # 앱 소스
 COPY . .
 
-# (권장 대안) 코드에서 uvicorn import 안 하고 프로세스 매니저로 실행하려면:
-ENTRYPOINT ["gunicorn", "-k", "uvicorn.workers.UvicornWorker", "app.main:app", "-b", "0.0.0.0:8000", "--timeout", "120"]
\ No newline at end of file
+# gunicorn으로 FastAPI 앱 실행 - 타임아웃 240초 설정
+ENTRYPOINT ["gunicorn", "-k", "uvicorn.workers.UvicornWorker", "app.main:app", "-b", "0.0.0.0:8000", "--timeout", "240"]
diff --git a/apps/pre-processing-service/app/api/endpoints/blog.py b/apps/pre-processing-service/app/api/endpoints/blog.py
index d0d078e8..f7043f14 100644
--- a/apps/pre-processing-service/app/api/endpoints/blog.py
+++ b/apps/pre-processing-service/app/api/endpoints/blog.py
@@ -10,10 +10,27 @@
 from app.utils.response import Response
 from app.service.blog.blog_create_service import BlogContentService
 from app.service.blog.blog_publish_service import BlogPublishService
+from app.service.ocr.S3OCRProcessor import S3OCRProcessor
 
 router = APIRouter()
 
 
+@router.post(
+    "/ocr/extract",
+    response_model=ResponseImageTextExtract,
+    summary="S3 이미지에서 텍스트 추출 및 번역",
+)
+async def ocr_extract(request: RequestImageTextExtract):
+    """
+    S3 이미지에서 텍스트 추출 및 번역
+    """
+    processor = S3OCRProcessor(request.keyword)
+
+    result = processor.process_images()
+
+    return Response.ok(result)
+
+
 @router.post(
     "/rag/create",
     response_model=ResponseBlogCreate,
diff --git a/apps/pre-processing-service/app/core/config.py b/apps/pre-processing-service/app/core/config.py
index ad7005ea..8e6b70f2 100644
--- a/apps/pre-processing-service/app/core/config.py
+++ b/apps/pre-processing-service/app/core/config.py
@@ -106,6 +106,9 @@ class BaseSettingsConfig(BaseSettings):
     # 테스트/추가용 필드
     OPENAI_API_KEY: Optional[str] = None  # << 이 부분 추가
 
+    # OCR 번역기 설정
+    google_application_credentials: Optional[str] = None
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
diff --git a/apps/pre-processing-service/app/model/schemas.py b/apps/pre-processing-service/app/model/schemas.py
index 4001b705..fb6c0612 100644
--- a/apps/pre-processing-service/app/model/schemas.py
+++ b/apps/pre-processing-service/app/model/schemas.py
@@ -186,6 +186,13 @@ class S3ImageInfo(BaseModel):
         ..., title="원본 URL", description="크롤링된 원본 이미지 URL"
     )
     s3_url: str = Field(..., title="S3 URL", description="S3에서 접근 가능한 URL")
+    # 새로 추가: 파일 크기 정보 (이미지 선별용)
+    file_size_kb: Optional[float] = Field(
+        None, title="파일 크기(KB)", description="이미지 파일 크기"
+    )
+    file_name: Optional[str] = Field(
+        None, title="파일명", description="S3에 저장된 파일명"
+    )
 
 
 # 상품별 S3 업로드 결과
@@ -274,14 +281,18 @@ class RequestBlogCreate(RequestBase):
     keyword: Optional[str] = Field(
         None, title="키워드", description="콘텐츠 생성용 키워드"
     )
+    translation_language: Optional[str] = Field(
+        None,
+        title="번역한 언어",
+        description="이미지에서 중국어를 한국어로 번역한 언어",
+    )
     product_info: Optional[Dict] = Field(
         None, title="상품 정보", description="블로그 콘텐츠에 포함할 상품 정보"
     )
-    content_type: Optional[str] = Field(
-        None, title="콘텐츠 타입", description="생성할 콘텐츠 유형"
-    )
-    target_length: Optional[int] = Field(
-        None, title="목표 글자 수", description="생성할 콘텐츠의 목표 길이"
+    uploaded_images: Optional[List[Dict]] = Field(
+        None,
+        title="업로드된 이미지",
+        description="S3에 업로드된 이미지 목록 (크기 정보 포함)",
     )
 
 
@@ -301,6 +312,29 @@ class ResponseBlogCreate(ResponseBase[BlogCreateData]):
     pass
 
 
+# ================== 이미지에서 텍스트 추출 및 번역 ==================
+class RequestImageTextExtract(RequestBase):
+    keyword: Optional[str] = Field(
+        ..., title="키워드", description="텍스트 추출용 키워드"
+    )
+
+
+class ImageTextExtract(BaseModel):
+    keyword: Optional[str] = Field(
+        ..., title="키워드", description="텍스트 추출용 키워드"
+    )
+    extraction_language: str = Field(
+        ..., title="추출된 텍스트", description="이미지에서 추출된 텍스트"
+    )
+    translation_language: str = Field(
+        ..., title="번역된 텍스트", description="추출된 텍스트의 번역본"
+    )
+
+
+class ResponseImageTextExtract(ResponseBase[ImageTextExtract]):
+    pass
+
+
 # ============== 블로그 배포 ==============
 
 
diff --git a/apps/pre-processing-service/app/service/blog/blog_create_service.py b/apps/pre-processing-service/app/service/blog/blog_create_service.py
index a66fa609..fdc8b6a0 100644
--- a/apps/pre-processing-service/app/service/blog/blog_create_service.py
+++ b/apps/pre-processing-service/app/service/blog/blog_create_service.py
@@ -1,5 +1,6 @@
-import json
 import logging
+import os
+import boto3
 from loguru import logger
 from datetime import datetime
 from typing import Dict, List, Optional, Any
@@ -19,19 +20,98 @@ def __init__(self):
         if not self.openai_api_key:
             raise ValueError("OPENAI_API_KEY가 .env.dev 파일에 설정되지 않았습니다.")
 
-        # 인스턴스 레벨에서 클라이언트 생성
         self.client = OpenAI(api_key=self.openai_api_key)
+
+        # S3 클라이언트 추가
+        self.s3_client = boto3.client(
+            "s3",
+            aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
+            aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
+            region_name=os.getenv("AWS_REGION", "ap-northeast-2"),
+        )
+        self.bucket_name = os.getenv("S3_BUCKET_NAME", "icebang4-dev-bucket")
+
         logging.basicConfig(level=logging.INFO)
 
-    def generate_blog_content(self, request: RequestBlogCreate) -> Dict[str, Any]:
-        """
-        요청 데이터를 기반으로 블로그 콘텐츠 생성
+    def _fetch_images_from_s3(self, keyword: str, product_index: int = 1) -> List[Dict]:
+        """S3에서 해당 상품의 이미지 정보를 조회"""
+        try:
+            # 폴더 패턴: 20250922_키워드_1/ 형식으로 검색
+            from datetime import datetime
+
+            date_str = datetime.now().strftime("%Y%m%d")
+
+            # 키워드 정리 (S3UploadUtil과 동일한 방식)
+            safe_keyword = (
+                keyword.replace("/", "-")
+                .replace("\\", "-")
+                .replace(" ", "_")
+                .replace(":", "-")
+                .replace("*", "-")
+                .replace("?", "-")
+                .replace('"', "-")
+                .replace("<", "-")
+                .replace(">", "-")
+                .replace("|", "-")[:20]
+            )
 
-        Args:
-            request: RequestBlogCreate 객체
+            folder_prefix = f"product/{date_str}_{safe_keyword}_{product_index}/"
+
+            logger.debug(f"S3에서 이미지 조회: {folder_prefix}")
+
+            # S3에서 해당 폴더의 파일 목록 조회
+            response = self.s3_client.list_objects_v2(
+                Bucket=self.bucket_name, Prefix=folder_prefix
+            )
+
+            if "Contents" not in response:
+                logger.warning(f"S3에서 이미지를 찾을 수 없음: {folder_prefix}")
+                return []
+
+            images = []
+            base_url = f"https://{self.bucket_name}.s3.ap-northeast-2.amazonaws.com"
+
+            # 이미지 파일만 필터링 (image_*.jpg 패턴)
+            for obj in response["Contents"]:
+                key = obj["Key"]
+                file_name = key.split("/")[-1]  # 마지막 부분이 파일명
+
+                # 이미지 파일인지 확인
+                if file_name.startswith("image_") and file_name.endswith(
+                    (".jpg", ".jpeg", ".png")
+                ):
+                    # 파일 크기 정보 (bytes -> KB)
+                    file_size_kb = obj["Size"] / 1024
+
+                    # 인덱스 추출 (image_001.jpg -> 1)
+                    try:
+                        index = int(file_name.split("_")[1].split(".")[0])
+                    except:
+                        index = len(images) + 1
+
+                    images.append(
+                        {
+                            "index": index,
+                            "s3_url": f"{base_url}/{key}",
+                            "file_name": file_name,
+                            "file_size_kb": round(file_size_kb, 2),
+                            "original_url": "",  # 원본 URL은 S3에서 조회 불가
+                        }
+                    )
+
+            # 인덱스 순으로 정렬
+            images.sort(key=lambda x: x["index"])
+
+            logger.success(f"S3에서 이미지 {len(images)}개 조회 완료")
+            return images
+
+        except Exception as e:
+            logger.error(f"S3 이미지 조회 실패: {e}")
+            return []
 
-        Returns:
-            Dict: {"title": str, "content": str, "tags": List[str]} 형태의 결과
+    def generate_blog_content(self, request: RequestBlogCreate) -> Dict[str, Any]:
+        """
+        요청 데이터를 기반으로 블로그 콘텐츠 생성 (이미지 자동 배치 포함)
         """
         try:
             logger.debug("[STEP1] 콘텐츠 컨텍스트 준비 시작")
@@ -50,6 +130,21 @@ def generate_blog_content(self, request: RequestBlogCreate) -> Dict[str, Any]:
             result = self._parse_generated_content(generated_content, request)
             logger.debug("[STEP4 완료]")
 
+            # STEP5: S3에서 이미지 정보 조회 (새로 추가)
+            uploaded_images = request.uploaded_images
+            if not uploaded_images and request.keyword:
+                logger.debug("[STEP5-1] S3에서 이미지 정보 조회 시작")
+                uploaded_images = self._fetch_images_from_s3(request.keyword)
+                logger.debug(f"[STEP5-1 완료] 조회된 이미지: {len(uploaded_images)}개")
+
+            # STEP6: 이미지 자동 배치
+            if uploaded_images and len(uploaded_images) > 0:
+                logger.debug("[STEP6] 이미지 자동 배치 시작")
+                result["content"] = self._insert_images_to_content(
+                    result["content"], uploaded_images
+                )
+                logger.debug("[STEP6 완료] 이미지 배치 완료")
+
             return result
 
         except Exception as e:
@@ -60,29 +155,31 @@ def _prepare_content_context(self, request: RequestBlogCreate) -> str:
         """요청 데이터를 콘텐츠 생성용 컨텍스트로 변환"""
         context_parts = []
 
-        # 키워드 정보 추가
+        # 키워드 정보
         if request.keyword:
             context_parts.append(f"주요 키워드: {request.keyword}")
 
-        # 상품 정보 추가
+        # 상품 정보
         if request.product_info:
             context_parts.append("\n상품 정보:")
 
-            # 상품 기본 정보
             if request.product_info.get("title"):
                 context_parts.append(f"- 상품명: {request.product_info['title']}")
 
             if request.product_info.get("price"):
-                context_parts.append(f"- 가격: {request.product_info['price']:,}원")
+                try:
+                    context_parts.append(
+                        f"- 가격: {int(request.product_info['price']):,}원"
+                    )
+                except Exception:
+                    context_parts.append(f"- 가격: {request.product_info.get('price')}")
 
             if request.product_info.get("rating"):
                 context_parts.append(f"- 평점: {request.product_info['rating']}/5.0")
 
-            # 상품 상세 정보
             if request.product_info.get("description"):
                 context_parts.append(f"- 설명: {request.product_info['description']}")
 
-            # 상품 사양 (material_info 등)
             if request.product_info.get("material_info"):
                 context_parts.append("- 주요 사양:")
                 specs = request.product_info["material_info"]
@@ -90,18 +187,16 @@ def _prepare_content_context(self, request: RequestBlogCreate) -> str:
                     for key, value in specs.items():
                         context_parts.append(f"  * {key}: {value}")
 
-            # 상품 옵션
             if request.product_info.get("options"):
                 options = request.product_info["options"]
                 context_parts.append(f"- 구매 옵션 ({len(options)}개):")
-                for i, option in enumerate(options[:5], 1):  # 최대 5개만
+                for i, option in enumerate(options[:5], 1):
                     if isinstance(option, dict):
                         option_name = option.get("name", f"옵션 {i}")
                         context_parts.append(f"  {i}. {option_name}")
                     else:
                         context_parts.append(f"  {i}. {option}")
 
-            # 구매 링크
             if request.product_info.get("url") or request.product_info.get(
                 "product_url"
             ):
@@ -110,8 +205,123 @@ def _prepare_content_context(self, request: RequestBlogCreate) -> str:
                 )
                 context_parts.append(f"- 구매 링크: {url}")
 
+        # 번역 텍스트 (translation_language) 추가
+        if request.translation_language:
+            context_parts.append("\n이미지(OCR)에서 추출·번역된 텍스트:")
+            context_parts.append(request.translation_language.strip())
+
         return "\n".join(context_parts) if context_parts else "키워드 기반 콘텐츠 생성"
 
+    def _select_best_images(
+        self, uploaded_images: List[Dict], target_count: int = 4
+    ) -> List[Dict]:
+        """크기 기반으로 최적의 이미지 4개 선별"""
+        if not uploaded_images:
+            return []
+
+        logger.debug(
+            f"이미지 선별 시작: 전체 {len(uploaded_images)}개 -> 목표 {target_count}개"
+        )
+
+        # 1단계: 너무 작은 이미지 제외 (20KB 이하는 아이콘, 로고 가능성)
+        filtered = [img for img in uploaded_images if img.get("file_size_kb", 0) > 20]
+        logger.debug(f"크기 필터링 후: {len(filtered)}개 이미지 남음")
+
+        if len(filtered) == 0:
+            # 모든 이미지가 너무 작다면 원본에서 선택
+            filtered = uploaded_images
+
+        # 2단계: 크기순 정렬 (큰 이미지 = 메인 상품 사진일 가능성)
+        sorted_images = sorted(
+            filtered, key=lambda x: x.get("file_size_kb", 0), reverse=True
+        )
+
+        # 3단계: 상위 이미지 선택하되, 너무 많으면 균등 분산
+        if len(sorted_images) <= target_count:
+            selected = sorted_images
+        else:
+            # 상위 2개 (메인 이미지) + 나머지에서 균등분산으로 2개
+            selected = sorted_images[:2]  # 큰 이미지 2개
+
+            remaining = sorted_images[2:]
+            if len(remaining) >= 2:
+                step = len(remaining) // 2
+                selected.extend([remaining[i * step] for i in range(2)])
+
+        result = selected[:target_count]
+
+        logger.debug(f"최종 선택된 이미지: {len(result)}개")
+        for i, img in enumerate(result):
+            logger.debug(
+                f"  {i + 1}. {img.get('file_name', 'unknown')} ({img.get('file_size_kb', 0):.1f}KB)"
+            )
+
+        return result
+
+    def _insert_images_to_content(
+        self, content: str, uploaded_images: List[Dict]
+    ) -> str:
+        """AI가 적절한 위치에 이미지 4개를 자동 배치"""
+
+        # 1단계: 최적의 이미지 4개 선별
+        selected_images = self._select_best_images(uploaded_images, target_count=4)
+
+        if not selected_images:
+            logger.warning("선별된 이미지가 없어서 이미지 배치를 건너뜀")
+            return content
+
+        logger.debug(f"이미지 배치 시작: {len(selected_images)}개 이미지")
+
+        # 2단계: AI에게 이미지 배치 위치 물어보기
+        image_placement_prompt = f"""
+다음 HTML 콘텐츠에서 이미지 {len(selected_images)}개를 적절한 위치에 배치해주세요.
+
+콘텐츠:
+{content}
+
+이미지 개수: {len(selected_images)}개
+
+요구사항:
+- 각 섹션(h2, h3 태그)마다 골고루 분산 배치
+- 너무 몰려있지 않게 적절한 간격 유지
+- 글의 흐름을 방해하지 않는 자연스러운 위치
+- [IMAGE_1], [IMAGE_2], [IMAGE_3], [IMAGE_4] 형식의 플레이스홀더로 표시
+
+⚠️ 주의사항:
+- 기존 HTML 구조와 내용은 그대로 유지
+- 오직 이미지 플레이스홀더만 적절한 위치에 삽입
+- 코드 블록(```)은 사용하지 말고 수정된 HTML만 반환
+
+수정된 HTML을 반환해주세요.
+"""
+
+        try:
+            # 3단계: AI로 배치 위치 결정
+            modified_content = self._generate_with_openai(image_placement_prompt)
+
+            # 4단계: 플레이스홀더를 실제 img 태그로 교체
+            for i, img in enumerate(selected_images):
+                img_tag = f"""
+<div style="text-align: center; margin: 20px 0;">
+    <img src="{img["s3_url"]}" alt="상품 이미지 {i + 1}" 
+         style="max-width: 100%; height: auto; border-radius: 8px; box-shadow: 0 2px 8px rgba(0,0,0,0.1);">
+</div>"""
+
+                placeholder = f"[IMAGE_{i + 1}]"
+                modified_content = modified_content.replace(placeholder, img_tag)
+
+            # 5단계: 남은 플레이스홀더 제거 (혹시 AI가 더 많이 만들었을 경우)
+            import re
+
+            modified_content = re.sub(r"\[IMAGE_\d+\]", "", modified_content)
+
+            logger.success(f"이미지 배치 완료: {len(selected_images)}개 이미지 삽입")
+            return modified_content
+
+        except Exception as e:
+            logger.error(f"이미지 배치 중 오류: {e}, 원본 콘텐츠 반환")
+            return content
+
     def _create_content_prompt(self, context: str, request: RequestBlogCreate) -> str:
         """콘텐츠 생성용 프롬프트 생성"""
 
@@ -138,7 +348,7 @@ def _create_content_prompt(self, context: str, request: RequestBlogCreate) -> st
 작성 요구사항:
 1. SEO 친화적이고 클릭하고 싶은 매력적인 제목
 2. 독자의 관심을 끄는 도입부
-3. 핵심 특징과 장점을 구체적으로 설명
+3. 핵심 특징과 장점을 구체적으로 설명 (h2, h3 태그로 구조화)
 4. 실제 사용 시나리오나 활용 팁
 5. 구매 결정에 도움이 되는 정보
 
@@ -147,6 +357,7 @@ def _create_content_prompt(self, context: str, request: RequestBlogCreate) -> st
 - 출력 시 ```나 ```html 같은 코드 블록 구문을 포함하지 마세요.
 - 오직 HTML 태그만 사용하여 구조화된 콘텐츠를 작성해주세요.
 (예: <h2>, <h3>, <p>, <ul>, <li> 등)
+- 이미지는 나중에 자동으로 삽입되므로 img 태그를 작성하지 마세요.
 """
 
         return prompt
@@ -170,7 +381,7 @@ def _generate_with_openai(self, prompt: str) -> str:
             return response.choices[0].message.content
 
         except Exception as e:
-            self.logger.error(f"OpenAI API 호출 실패: {e}")
+            logger.error(f"OpenAI API 호출 실패: {e}")
             raise
 
     def _parse_generated_content(
@@ -304,43 +515,3 @@ def _create_fallback_content(self, request: RequestBlogCreate) -> Dict[str, Any]
             "content": content,
             "tags": self._generate_tags(request),
         }
-
-
-# if __name__ == '__main__':
-#     # 테스트용 요청 데이터
-#     test_request = RequestBlogCreate(
-#         keyword="아이폰 케이스",
-#         product_info={
-#             "title": "아이폰 15 프로 투명 케이스",
-#             "price": 29900,
-#             "rating": 4.8,
-#             "description": "9H 강화 보호 기능을 제공하는 투명 케이스",
-#             "material_info": {
-#                 "소재": "TPU + PC",
-#                 "두께": "1.2mm",
-#                 "색상": "투명",
-#                 "호환성": "아이폰 15 Pro"
-#             },
-#             "options": [
-#                 {"name": "투명"},
-#                 {"name": "반투명"},
-#                 {"name": "블랙"}
-#             ],
-#             "url": "https://example.com/iphone-case"
-#         }
-#     )
-#
-#     # 서비스 실행
-#     service = BlogContentService()
-#     print("=== 블로그 콘텐츠 생성 테스트 ===")
-#     print(f"키워드: {test_request.keyword}")
-#     print(f"상품: {test_request.product_info['title']}")
-#     print("\n--- 생성 시작 ---")
-#
-#     result = service.generate_blog_content(test_request)
-#
-#     print(f"\n=== 생성 결과 ===")
-#     print(f"제목: {result['title']}")
-#     print(f"\n태그: {', '.join(result['tags'])}")
-#     print(f"\n내용:\n{result['content']}")
-#     print(f"\n글자수: {len(result['content'])}자")
diff --git a/apps/pre-processing-service/app/service/ocr/OCRTranslator.py b/apps/pre-processing-service/app/service/ocr/OCRTranslator.py
new file mode 100644
index 00000000..3c639b82
--- /dev/null
+++ b/apps/pre-processing-service/app/service/ocr/OCRTranslator.py
@@ -0,0 +1,254 @@
+import os
+import json
+from google.cloud import vision
+from google.oauth2 import service_account
+from deep_translator import GoogleTranslator
+from loguru import logger
+import io
+
+
+class OCRTranslator:
+
+    def __init__(self):
+        """다국어 OCR 번역기 초기화 (중국어, 일본어, 영어 -> 한국어)"""
+
+        self.source_languages = ["zh-CN", "ja", "en"]
+        self.target_language = "ko"
+
+        # 각 언어별 번역기 초기화
+        self.translators = {}
+        for lang in self.source_languages:
+            try:
+                self.translators[lang] = GoogleTranslator(
+                    source=lang, target=self.target_language
+                )
+                logger.info(f"{lang} -> {self.target_language} 번역기 초기화 완료")
+            except Exception as e:
+                logger.error(f"{lang} 번역기 초기화 실패: {e}")
+
+        # Google Vision API 클라이언트 초기화
+        self.vision_client = self._initialize_vision_client()
+
+    def _initialize_vision_client(self):
+        """Google Vision API 클라이언트 초기화"""
+        try:
+            # # 환경변수에서 JSON 문자열로 인증정보 가져오기
+            # creds_json = os.getenv('GOOGLE_APPLICATION_CREDENTIALS_JSON')
+            # if creds_json:
+            #     logger.info("환경변수에서 Google 인증정보 로드")
+            #     creds_dict = json.loads(creds_json)
+            #     if "private_key" in creds_dict:
+            #         while "\\n" in creds_dict["private_key"]:
+            #             creds_dict["private_key"] = creds_dict["private_key"].replace("\\n", "\n")
+            #     credentials = service_account.Credentials.from_service_account_info(creds_dict)
+            #     return vision.ImageAnnotatorClient(credentials=credentials)
+
+            # 파일 경로에서 인증정보 가져오기
+            creds_file = os.getenv("GOOGLE_APPLICATION_CREDENTIALS")
+            if creds_file and os.path.exists(creds_file):
+                logger.info(f"파일에서 Google 인증정보 로드: {creds_file}")
+                return vision.ImageAnnotatorClient()
+
+            # 기본 인증 (Cloud Shell, GCE 등)
+            logger.info("기본 인증으로 Google Vision 클라이언트 초기화")
+            return vision.ImageAnnotatorClient()
+
+        except Exception as e:
+            logger.error(f"Google Vision 클라이언트 초기화 실패: {e}")
+            raise
+
+    def _detect_language(self, text):
+        """텍스트에서 언어 감지"""
+        if not text:
+            return None
+
+        # 각 언어별 특징 문자 카운트
+        chinese_chars = sum(1 for char in text if "\u4e00" <= char <= "\u9fff")
+        hiragana_chars = sum(1 for char in text if "\u3040" <= char <= "\u309f")
+        katakana_chars = sum(1 for char in text if "\u30a0" <= char <= "\u30ff")
+        english_chars = sum(1 for char in text if char.isascii() and char.isalpha())
+
+        total_chars = len(
+            [
+                char
+                for char in text
+                if char.isalpha()
+                or "\u4e00" <= char <= "\u9fff"
+                or "\u3040" <= char <= "\u30ff"
+            ]
+        )
+
+        if total_chars == 0:
+            return None
+
+        # 일본어 특징 문자(히라가나/가타카나)가 있으면 일본어로 판단
+        if (hiragana_chars + katakana_chars) > 0:
+            return "ja"
+
+        # 영어 문자가 대부분이면 영어로 판단
+        if english_chars / total_chars > 0.7:
+            return "en"
+
+        # 중국어 문자가 있으면 중국어로 판단
+        if chinese_chars > 0:
+            return "zh-CN"
+
+        # 기본값은 중국어로 설정
+        return "zh_CN"
+
+    def _extract_text_from_content(self, image_content: bytes):
+        """Google Vision API를 사용해 이미지에서 텍스트 추출"""
+        try:
+            # Vision API Image 객체 생성
+            image = vision.Image(content=image_content)
+
+            # 텍스트 감지 요청
+            response = self.vision_client.text_detection(image=image)
+
+            if response.error.message:
+                raise Exception(f"Vision API Error: {response.error.message}")
+
+            # 텍스트 추출
+            texts = response.text_annotations
+            if texts:
+                # 첫 번째 요소가 전체 텍스트
+                extracted_text = texts[0].description
+                logger.info(f"Vision API로 추출된 텍스트: {extracted_text}")
+                return extracted_text.strip()
+            else:
+                logger.warning("이미지에서 텍스트를 찾을 수 없습니다")
+                return ""
+
+        except Exception as e:
+            logger.error(f"Vision API 텍스트 추출 오류: {e}")
+            raise
+
+    def _extract_text_from_path(self, image_path):
+        """이미지에서 텍스트 추출 (파일 경로)"""
+        try:
+            # 이미지 파일 읽기
+            with io.open(image_path, "rb") as image_file:
+                content = image_file.read()
+
+            return self._extract_text_from_content(content)
+
+        except Exception as e:
+            logger.error(f"Error during OCR: {e}")
+            raise
+
+    def _extract_text_from_bytes(self, image_data: bytes):
+        """이미지에서 텍스트 추출 (바이트 데이터)"""
+        try:
+            return self._extract_text_from_content(image_data)
+        except Exception as e:
+            logger.error(f"Error during OCR from bytes: {e}")
+            raise
+
+    def translate_text(self, text, source_lang=None):
+        """텍스트를 한국어로 번역"""
+        if not text:
+            return "", None
+
+        # 언어가 지정되지 않은 경우 자동 감지
+        if source_lang is None:
+            source_lang = self._detect_language(text)
+
+        if source_lang is None or source_lang not in self.translators:
+            logger.warning(f"지원하지 않는 언어이거나 감지할 수 없음: {source_lang}")
+            return "", source_lang
+
+        try:
+            result = self.translators[source_lang].translate(text)
+            return result if result is not None else "", source_lang
+        except Exception as e:
+            logger.error(f"번역 오류 ({source_lang}): {e}")
+            return "", source_lang
+
+    def process_image(self, image_path, source_lang=None):
+        """이미지에서 텍스트 추출 후 한국어로 번역 (파일 경로)"""
+        try:
+            # 텍스트 추출
+            extracted_text = self._extract_text_from_path(image_path)
+            logger.info(f"추출된 텍스트: {extracted_text}")
+
+            # 번역
+            translated_text, detected_lang = self.translate_text(
+                extracted_text, source_lang
+            )
+            logger.info(f"번역된 텍스트 ({detected_lang}): {translated_text}")
+
+            return {
+                "original_text": extracted_text,
+                "translated_text": translated_text,
+                "detected_language": detected_lang,
+                "success": True,
+                "error": None,
+            }
+
+        except Exception as e:
+            logger.error(f"이미지 처리 오류: {e}")
+            return {
+                "original_text": "",
+                "translated_text": "",
+                "detected_language": None,
+                "success": False,
+                "error": str(e),
+            }
+
+    def process_image_from_bytes(self, image_data: bytes, source_lang=None):
+        """이미지에서 텍스트 추출 후 한국어로 번역 (바이트 데이터)"""
+        try:
+            # 텍스트 추출
+            extracted_text = self._extract_text_from_bytes(image_data)
+            logger.info(f"추출된 텍스트: {extracted_text}")
+
+            # 번역
+            translated_text, detected_lang = self.translate_text(
+                extracted_text, source_lang
+            )
+            logger.info(f"번역된 텍스트 ({detected_lang}): {translated_text}")
+
+            return {
+                "original_text": extracted_text,
+                "translated_text": translated_text,
+                "detected_language": detected_lang,
+                "success": True,
+                "error": None,
+            }
+
+        except Exception as e:
+            logger.error(f"이미지 처리 오류: {e}")
+            return {
+                "original_text": "",
+                "translated_text": "",
+                "detected_language": None,
+                "success": False,
+                "error": str(e),
+            }
+
+    def process_chinese_only(self, image_data):
+        """중국어 전용 처리"""
+        result = self.process_image_from_bytes(image_data, source_lang="zh-CN")
+        return {
+            "chinese_text": result["original_text"],
+            "korean_text": result["translated_text"],
+            "success": result["success"],
+        }
+
+    def process_japanese_only(self, image_data):
+        """일본어 전용 처리"""
+        result = self.process_image_from_bytes(image_data, source_lang="ja")
+        return {
+            "japanese_text": result["original_text"],
+            "korean_text": result["translated_text"],
+            "success": result["success"],
+        }
+
+    def process_english_only(self, image_data):
+        """영어 전용 처리"""
+        result = self.process_image_from_bytes(image_data, source_lang="en")
+        return {
+            "english_text": result["original_text"],
+            "korean_text": result["translated_text"],
+            "success": result["success"],
+        }
diff --git a/apps/pre-processing-service/app/service/ocr/S3OCRProcessor.py b/apps/pre-processing-service/app/service/ocr/S3OCRProcessor.py
new file mode 100644
index 00000000..4e97c47d
--- /dev/null
+++ b/apps/pre-processing-service/app/service/ocr/S3OCRProcessor.py
@@ -0,0 +1,127 @@
+from datetime import datetime
+import re
+from typing import List, Dict, Any
+from loguru import logger
+
+from app.service.ocr.OCRTranslator import OCRTranslator
+from app.service.ocr.S3Service import S3Service
+
+
+class S3OCRProcessor:
+
+    def __init__(self, keyword: str):
+        """S3 OCR 처리기 초기화"""
+        self.keyword = keyword
+        self.s3_service = S3Service(keyword)
+        self.ocr_translator = OCRTranslator()
+
+    def _preprocess_text(self, text: str) -> str:
+        """
+        텍스트 전처리
+        - 개행 문자(\n) 제거
+        - 영어 문자 제거
+        """
+        if not text:
+            return ""
+
+        # 개행 문자를 공백으로 변경
+        text = text.replace("\n", " ")
+
+        # 영어 문자만 제거 (알파벳만, 숫자는 유지)
+        text = re.sub(r"[a-zA-Z]+", " ", text)
+
+        # 특수문자 제거
+        text = re.sub(r'[\'\/\\;:<>"|\-~•]+', " ", text)
+
+        # 연속된 공백을 하나로 정리
+        text = re.sub(r"\s+", " ", text)
+
+        # 앞뒤 공백 제거
+        return text.strip()
+
+    def process_images(self) -> Dict[str, Any]:
+        """
+        S3에서 이미지들을 가져와서 OCR 처리 후 지정된 형식으로 반환
+
+        Returns:
+            Dict: {
+                "keyword": "키워드",
+                "extraction_language": "전처리된 원본 언어 텍스트",
+                "translation_language": "전처리된 번역된 한국어 텍스트"
+            }
+        """
+        try:
+            logger.info(f"키워드 '{self.keyword}' OCR 처리 시작")
+
+            # S3에서 객체 목록 가져오기
+            all_objects = self.s3_service.get_folder_objects()
+
+            if not all_objects:
+                logger.warning("S3에서 객체를 찾을 수 없습니다")
+                return self._create_empty_response()
+
+            # JPG 파일만 필터링
+            jpg_files = self.s3_service.get_jpg_files(all_objects)
+            logger.info(f"총 {len(jpg_files)}개의 JPG 파일 발견")
+
+            if not jpg_files:
+                logger.warning("JPG 파일을 찾을 수 없습니다")
+                return self._create_empty_response()
+
+            # 모든 추출된 텍스트와 번역된 텍스트를 수집
+            all_extracted_texts = []
+            all_translated_texts = []
+
+            for jpg_file in jpg_files:
+                try:
+                    logger.info(f"처리 중: {jpg_file}")
+
+                    # S3에서 이미지 데이터 가져오기
+                    image_data = self.s3_service.get_image_data(jpg_file)
+
+                    # OCR 및 번역 처리
+                    ocr_result = self.ocr_translator.process_image_from_bytes(
+                        image_data
+                    )
+
+                    # 성공한 경우에만 텍스트 추가
+                    if ocr_result["success"] and ocr_result["original_text"]:
+                        all_extracted_texts.append(ocr_result["original_text"])
+
+                    if ocr_result["success"] and ocr_result["translated_text"]:
+                        all_translated_texts.append(ocr_result["translated_text"])
+
+                except Exception as e:
+                    logger.error(f"이미지 처리 실패 ({jpg_file}): {e}")
+                    continue
+
+            # 텍스트 전처리 적용
+            raw_extracted = " ".join(all_extracted_texts)
+            raw_translated = " ".join(all_translated_texts)
+
+            processed_extracted = self._preprocess_text(raw_extracted)
+            processed_translated = self._preprocess_text(raw_translated)
+
+            # 최종 응답 생성
+            response = {
+                "keyword": self.keyword,
+                "extraction_language": processed_extracted,
+                "translation_language": processed_translated,
+            }
+
+            logger.info(
+                f"처리 완료: {len(all_extracted_texts)}개 텍스트 추출, {len(all_translated_texts)}개 번역"
+            )
+            return response
+
+        except Exception as e:
+            logger.error(f"OCR 처리 과정에서 오류 발생: {e}")
+            return self._create_empty_response()
+
+    def _create_empty_response(self) -> Dict[str, Any]:
+        """빈 응답 생성"""
+        return {
+            "keyword": self.keyword,
+            "extraction_language": "",
+            "translation_language": "",
+        }
diff --git a/apps/pre-processing-service/app/service/ocr/S3Service.py b/apps/pre-processing-service/app/service/ocr/S3Service.py
new file mode 100644
index 00000000..3ba66e35
--- /dev/null
+++ b/apps/pre-processing-service/app/service/ocr/S3Service.py
@@ -0,0 +1,59 @@
+from datetime import datetime
+
+import boto3
+import os
+from loguru import logger
+from typing import List
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class S3Service:
+
+    def __init__(self, keyword: str):
+        self.s3_client = boto3.client(
+            "s3",
+            aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
+            aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
+            region_name=os.getenv("AWS_REGION"),
+        )
+        self.bucket_name = os.getenv("S3_BUCKET_NAME")
+        self.date = datetime.now().strftime("%Y%m%d")
+        self.keyword = keyword
+
+    def get_folder_objects(self):
+        """S3 버킷에서 특정 폴더 내의 모든 객체를 가져오는 메서드"""
+
+        try:
+            response = self.s3_client.list_objects_v2(
+                Bucket=self.bucket_name, Prefix=f"product/{self.date}_{self.keyword}_1"
+            )
+
+            objects = []
+            if "Contents" in response:
+                for obj in response["Contents"]:
+                    objects.append(obj["Key"])
+
+            return objects
+        except Exception as e:
+            logger.error(f"S3 객체 조회 실패: {e}")
+            return []
+
+    def get_jpg_files(self, object_keys: List[str]) -> List[str]:
+        """객체 키 리스트에서 JPG 파일만 필터링"""
+        jpg_files = []
+        for key in object_keys:
+            if key.lower().endswith((".jpg", ".jpeg")):
+                jpg_files.append(key)
+        return jpg_files
+
+    def get_image_data(self, key: str) -> bytes:
+        """S3에서 이미지 데이터 가져오기"""
+        try:
+            response = self.s3_client.get_object(Bucket=self.bucket_name, Key=key)
+            image_data = response["Body"].read()
+            return image_data
+        except Exception as e:
+            logger.error(f"S3 이미지 데이터 가져오기 실패 ({key}): {e}")
+            raise
diff --git a/apps/pre-processing-service/app/service/ocr/__init__.py b/apps/pre-processing-service/app/service/ocr/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/apps/pre-processing-service/app/utils/s3_upload_util.py b/apps/pre-processing-service/app/utils/s3_upload_util.py
index 0aaa5ace..374bfd8e 100644
--- a/apps/pre-processing-service/app/utils/s3_upload_util.py
+++ b/apps/pre-processing-service/app/utils/s3_upload_util.py
@@ -161,14 +161,13 @@ def get_s3_url(self, s3_key: str) -> str:
     async def upload_single_product_images(
         self,
         session: aiohttp.ClientSession,
-        product_info: Dict,  # 🔸 이름 변경: product_data → product_info (전체 크롤링 데이터)
+        product_info: Dict,
         product_index: int,
-        keyword: str,  # 키워드 파라미터 추가
-        base_folder: str = "product",  # 🔸 기본 폴더 변경: product-images → product
+        keyword: str,
+        base_folder: str = "product",
     ) -> Dict:
         """단일 상품의 모든 데이터(이미지 + JSON)를 S3에 업로드"""
 
-        # 🔸 전체 크롤링 데이터에서 필요한 정보 추출
         product_detail = product_info.get("product_detail", {})
         product_title = product_detail.get("title", "Unknown")
         product_images = product_detail.get("product_images", [])
@@ -179,18 +178,15 @@ async def upload_single_product_images(
             f"상품 {product_index} 업로드 시작: {len(product_images)}개 이미지, keyword='{keyword}'"
         )
 
-        # 키워드 기반 폴더명 한 번만 생성
         folder_name = self.generate_product_folder_name(product_index, keyword)
-
         fail_count = 0
         folder_s3_url = f"{self.base_url}/{base_folder}/{folder_name}"
 
-        # 🆕 1. 먼저 상품 데이터 JSON 파일 업로드
+        # 1. JSON 파일 업로드
         try:
-            # 전체 크롤링 데이터를 JSON으로 저장 (S3 업로드 메타데이터 추가)
             product_data_with_meta = {
-                **product_info,  # 전체 크롤링 데이터 (index, url, product_detail, status, crawled_at 포함)
-                "s3_upload_keyword": keyword,  # 추가 메타데이터
+                **product_info,
+                "s3_upload_keyword": keyword,
                 "s3_uploaded_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
             }
 
@@ -206,7 +202,7 @@ async def upload_single_product_images(
         except Exception as e:
             logger.error(f"상품 {product_index} JSON 업로드 오류: {e}")
 
-        # 2. 이미지 업로드 (기존 로직)
+        # 2. 이미지 업로드
         if not product_images:
             logger.warning(f"상품 {product_index}: 업로드할 이미지가 없음")
             return {
@@ -236,7 +232,10 @@ async def upload_single_product_images(
                     fail_count += 1
                     continue
 
-                # S3 키 생성 (키워드 기반 폴더명 사용)
+                # 파일 크기 계산 (KB 단위)
+                file_size_kb = len(image_data) / 1024
+
+                # S3 키 생성
                 file_extension = self.get_file_extension(original_url)
                 image_file_name = f"image_{img_idx:03d}{file_extension}"
                 s3_key = self.generate_s3_key(base_folder, folder_name, image_file_name)
@@ -246,15 +245,20 @@ async def upload_single_product_images(
 
                 if self.upload_to_s3(image_data, s3_key, content_type):
                     s3_url = self.get_s3_url(s3_key)
+                    # 파일 크기 정보 추가
                     uploaded_images.append(
                         {
                             "index": img_idx,
                             "original_url": original_url,
                             "s3_url": s3_url,
+                            "file_size_kb": round(file_size_kb, 2),
+                            "file_name": image_file_name,
                         }
                     )
 
-                    logger.debug(f"상품 {product_index}, 이미지 {img_idx} 업로드 완료")
+                    logger.debug(
+                        f"상품 {product_index}, 이미지 {img_idx} 업로드 완료 ({file_size_kb:.1f}KB)"
+                    )
                 else:
                     fail_count += 1
 
@@ -273,8 +277,8 @@ async def upload_single_product_images(
             "product_index": product_index,
             "product_title": product_title,
             "status": "completed",
-            "folder_s3_url": folder_s3_url,  # 🔸 폴더 전체를 가리킴 (이미지 + JSON 포함)
-            "json_s3_url": f"{folder_s3_url}/product_data.json",  # 🆕 JSON 파일 직접 링크
+            "folder_s3_url": folder_s3_url,
+            "json_s3_url": f"{folder_s3_url}/product_data.json",
             "uploaded_images": uploaded_images,
             "success_count": len(uploaded_images),
             "fail_count": fail_count,
diff --git a/apps/pre-processing-service/poetry.lock b/apps/pre-processing-service/poetry.lock
index f02855bc..16e99d6b 100644
--- a/apps/pre-processing-service/poetry.lock
+++ b/apps/pre-processing-service/poetry.lock
@@ -150,14 +150,14 @@ files = [
 
 [[package]]
 name = "anyio"
-version = "4.10.0"
+version = "4.11.0"
 description = "High-level concurrency and networking framework on top of asyncio or Trio"
 optional = false
 python-versions = ">=3.9"
 groups = ["main"]
 files = [
-    {file = "anyio-4.10.0-py3-none-any.whl", hash = "sha256:60e474ac86736bbfd6f210f7a61218939c318f43f9972497381f1c5e930ed3d1"},
-    {file = "anyio-4.10.0.tar.gz", hash = "sha256:3f3fae35c96039744587aa5b8371e7e8e603c0702999535961dd336026973ba6"},
+    {file = "anyio-4.11.0-py3-none-any.whl", hash = "sha256:0287e96f4d26d4149305414d4e3bc32f0dcd0862365a4bddea19d7a1ec38c4fc"},
+    {file = "anyio-4.11.0.tar.gz", hash = "sha256:82a8d0b81e318cc5ce71a5f1f8b5c4e63619620b63141ef8c995fa0db95a57c4"},
 ]
 
 [package.dependencies]
@@ -166,7 +166,7 @@ sniffio = ">=1.1"
 typing_extensions = {version = ">=4.5", markers = "python_version < \"3.13\""}
 
 [package.extras]
-trio = ["trio (>=0.26.1)"]
+trio = ["trio (>=0.31.0)"]
 
 [[package]]
 name = "asyncpg"
@@ -323,18 +323,18 @@ uvloop = ["uvloop (>=0.15.2)"]
 
 [[package]]
 name = "boto3"
-version = "1.40.35"
+version = "1.40.39"
 description = "The AWS SDK for Python"
 optional = false
 python-versions = ">=3.9"
 groups = ["main"]
 files = [
-    {file = "boto3-1.40.35-py3-none-any.whl", hash = "sha256:f4c1b01dd61e7733b453bca38b004ce030e26ee36e7a3d4a9e45a730b67bc38d"},
-    {file = "boto3-1.40.35.tar.gz", hash = "sha256:d718df3591c829bcca4c498abb7b09d64d1eecc4e5a2b6cef14b476501211b8a"},
+    {file = "boto3-1.40.39-py3-none-any.whl", hash = "sha256:e2cab5606269fe9f428981892aa592b7e0c087a038774475fa4cd6c8b5fe0a99"},
+    {file = "boto3-1.40.39.tar.gz", hash = "sha256:27ca06d4d6f838b056b4935c9eceb92c8d125dbe0e895c5583bcf7130627dcd2"},
 ]
 
 [package.dependencies]
-botocore = ">=1.40.35,<1.41.0"
+botocore = ">=1.40.39,<1.41.0"
 jmespath = ">=0.7.1,<2.0.0"
 s3transfer = ">=0.14.0,<0.15.0"
 
@@ -343,14 +343,14 @@ crt = ["botocore[crt] (>=1.21.0,<2.0a0)"]
 
 [[package]]
 name = "botocore"
-version = "1.40.35"
+version = "1.40.39"
 description = "Low-level, data-driven core of boto 3."
 optional = false
 python-versions = ">=3.9"
 groups = ["main"]
 files = [
-    {file = "botocore-1.40.35-py3-none-any.whl", hash = "sha256:c545de2cbbce161f54ca589fbb677bae14cdbfac7d5f1a27f6a620cb057c26f4"},
-    {file = "botocore-1.40.35.tar.gz", hash = "sha256:67e062752ff579c8cc25f30f9c3a84c72d692516a41a9ee1cf17735767ca78be"},
+    {file = "botocore-1.40.39-py3-none-any.whl", hash = "sha256:144e0e887a9fc198c6772f660fc006028bd1a9ce5eea3caddd848db3e421bc79"},
+    {file = "botocore-1.40.39.tar.gz", hash = "sha256:c6efc55cac341811ba90c693d20097db6e2ce903451d94496bccd3f672b1709d"},
 ]
 
 [package.dependencies]
@@ -650,6 +650,27 @@ docs = ["docutils"]
 pg = ["PyGreSQL (>=5)"]
 tests = ["pytest (>=7)", "ruff"]
 
+[[package]]
+name = "deep-translator"
+version = "1.11.4"
+description = "A flexible free and unlimited python tool to translate between different languages in a simple way using multiple translators"
+optional = false
+python-versions = ">=3.7,<4.0"
+groups = ["main"]
+files = [
+    {file = "deep_translator-1.11.4-py3-none-any.whl", hash = "sha256:d635df037e23fa35d12fd42dab72a0b55c9dd19e6292009ee7207e3f30b9e60a"},
+    {file = "deep_translator-1.11.4.tar.gz", hash = "sha256:801260c69231138707ea88a0955e484db7d40e210c9e0ae0f77372ffda5f4bf5"},
+]
+
+[package.dependencies]
+beautifulsoup4 = ">=4.9.1,<5.0.0"
+requests = ">=2.23.0,<3.0.0"
+
+[package.extras]
+ai = ["openai (>=0.27.6,<0.28.0) ; python_full_version >= \"3.7.1\" and python_full_version < \"4.0.0\""]
+docx = ["docx2txt (>=0.8,<0.9)"]
+pdf = ["pypdf (>=3.3.0,<4.0.0)"]
+
 [[package]]
 name = "distro"
 version = "1.9.0"
@@ -698,14 +719,14 @@ files = [
 
 [[package]]
 name = "flatbuffers"
-version = "25.2.10"
+version = "25.9.23"
 description = "The FlatBuffers serialization format for Python"
 optional = false
 python-versions = "*"
 groups = ["main"]
 files = [
-    {file = "flatbuffers-25.2.10-py2.py3-none-any.whl", hash = "sha256:ebba5f4d5ea615af3f7fd70fc310636fbb2bbd1f566ac0a23d98dd412de50051"},
-    {file = "flatbuffers-25.2.10.tar.gz", hash = "sha256:97e451377a41262f8d9bd4295cc836133415cc03d8cb966410a4af92eb00d26e"},
+    {file = "flatbuffers-25.9.23-py2.py3-none-any.whl", hash = "sha256:255538574d6cb6d0a79a17ec8bc0d30985913b87513a01cce8bcdb6b4c44d0e2"},
+    {file = "flatbuffers-25.9.23.tar.gz", hash = "sha256:676f9fa62750bb50cf531b42a0a2a118ad8f7f797a511eda12881c016f093b12"},
 ]
 
 [[package]]
@@ -892,9 +913,11 @@ files = [
 [package.dependencies]
 google-auth = ">=2.14.1,<3.0.0"
 googleapis-common-protos = ">=1.56.2,<2.0.0"
+grpcio = {version = ">=1.49.1,<2.0.0", optional = true, markers = "python_version >= \"3.11\" and extra == \"grpc\""}
+grpcio-status = {version = ">=1.49.1,<2.0.0", optional = true, markers = "python_version >= \"3.11\" and extra == \"grpc\""}
 proto-plus = [
     {version = ">=1.25.0,<2.0.0", markers = "python_version >= \"3.13\""},
-    {version = ">=1.22.3,<2.0.0", markers = "python_version < \"3.13\""},
+    {version = ">=1.22.3,<2.0.0"},
 ]
 protobuf = ">=3.19.5,<3.20.0 || >3.20.0,<3.20.1 || >3.20.1,<4.21.0 || >4.21.0,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<7.0.0"
 requests = ">=2.18.0,<3.0.0"
@@ -907,14 +930,14 @@ grpcio-gcp = ["grpcio-gcp (>=0.2.2,<1.0.0)"]
 
 [[package]]
 name = "google-api-python-client"
-version = "2.182.0"
+version = "2.183.0"
 description = "Google API Client Library for Python"
 optional = false
 python-versions = ">=3.7"
 groups = ["main"]
 files = [
-    {file = "google_api_python_client-2.182.0-py3-none-any.whl", hash = "sha256:a9b071036d41a17991d8fbf27bedb61f2888a39ae5696cb5a326bf999b2d5209"},
-    {file = "google_api_python_client-2.182.0.tar.gz", hash = "sha256:cb2aa127e33c3a31e89a06f39cf9de982db90a98dee020911b21013afafad35f"},
+    {file = "google_api_python_client-2.183.0-py3-none-any.whl", hash = "sha256:2005b6e86c27be1db1a43f43e047a0f8e004159f3cceddecb08cf1624bddba31"},
+    {file = "google_api_python_client-2.183.0.tar.gz", hash = "sha256:abae37e04fecf719388e5c02f707ed9cdf952f10b217c79a3e76c636762e3ea9"},
 ]
 
 [package.dependencies]
@@ -986,6 +1009,27 @@ requests-oauthlib = ">=0.7.0"
 [package.extras]
 tool = ["click (>=6.0.0)"]
 
+[[package]]
+name = "google-cloud-vision"
+version = "3.10.2"
+description = "Google Cloud Vision API client library"
+optional = false
+python-versions = ">=3.7"
+groups = ["main"]
+files = [
+    {file = "google_cloud_vision-3.10.2-py3-none-any.whl", hash = "sha256:42a17fbc2219b0a88e325e2c1df6664a8dafcbae66363fb37ebcb511b018fc87"},
+    {file = "google_cloud_vision-3.10.2.tar.gz", hash = "sha256:649380faab8933440b632bf88072c0c382a08d49ab02bc0b4fba821882ae1765"},
+]
+
+[package.dependencies]
+google-api-core = {version = ">=1.34.1,<2.0.dev0 || >=2.11.dev0,<3.0.0", extras = ["grpc"]}
+google-auth = ">=2.14.1,<2.24.0 || >2.24.0,<2.25.0 || >2.25.0,<3.0.0"
+proto-plus = [
+    {version = ">=1.25.0,<2.0.0", markers = "python_version >= \"3.13\""},
+    {version = ">=1.22.3,<2.0.0", markers = "python_version < \"3.13\""},
+]
+protobuf = ">=3.20.2,<4.21.0 || >4.21.0,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<7.0.0"
+
 [[package]]
 name = "googleapis-common-protos"
 version = "1.70.0"
@@ -1073,6 +1117,100 @@ files = [
 docs = ["Sphinx", "furo"]
 test = ["objgraph", "psutil", "setuptools"]
 
+[[package]]
+name = "grpcio"
+version = "1.75.1"
+description = "HTTP/2-based RPC framework"
+optional = false
+python-versions = ">=3.9"
+groups = ["main"]
+files = [
+    {file = "grpcio-1.75.1-cp310-cp310-linux_armv7l.whl", hash = "sha256:1712b5890b22547dd29f3215c5788d8fc759ce6dd0b85a6ba6e2731f2d04c088"},
+    {file = "grpcio-1.75.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:8d04e101bba4b55cea9954e4aa71c24153ba6182481b487ff376da28d4ba46cf"},
+    {file = "grpcio-1.75.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:683cfc70be0c1383449097cba637317e4737a357cfc185d887fd984206380403"},
+    {file = "grpcio-1.75.1-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:491444c081a54dcd5e6ada57314321ae526377f498d4aa09d975c3241c5b9e1c"},
+    {file = "grpcio-1.75.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ce08d4e112d0d38487c2b631ec8723deac9bc404e9c7b1011426af50a79999e4"},
+    {file = "grpcio-1.75.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5a2acda37fc926ccc4547977ac3e56b1df48fe200de968e8c8421f6e3093df6c"},
+    {file = "grpcio-1.75.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:745c5fe6bf05df6a04bf2d11552c7d867a2690759e7ab6b05c318a772739bd75"},
+    {file = "grpcio-1.75.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:259526a7159d39e2db40d566fe3e8f8e034d0fb2db5bf9c00e09aace655a4c2b"},
+    {file = "grpcio-1.75.1-cp310-cp310-win32.whl", hash = "sha256:f4b29b9aabe33fed5df0a85e5f13b09ff25e2c05bd5946d25270a8bd5682dac9"},
+    {file = "grpcio-1.75.1-cp310-cp310-win_amd64.whl", hash = "sha256:cf2e760978dcce7ff7d465cbc7e276c3157eedc4c27aa6de7b594c7a295d3d61"},
+    {file = "grpcio-1.75.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:573855ca2e58e35032aff30bfbd1ee103fbcf4472e4b28d4010757700918e326"},
+    {file = "grpcio-1.75.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:6a4996a2c8accc37976dc142d5991adf60733e223e5c9a2219e157dc6a8fd3a2"},
+    {file = "grpcio-1.75.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b1ea1bbe77ecbc1be00af2769f4ae4a88ce93be57a4f3eebd91087898ed749f9"},
+    {file = "grpcio-1.75.1-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:e5b425aee54cc5e3e3c58f00731e8a33f5567965d478d516d35ef99fd648ab68"},
+    {file = "grpcio-1.75.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0049a7bf547dafaeeb1db17079ce79596c298bfe308fc084d023c8907a845b9a"},
+    {file = "grpcio-1.75.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5b8ea230c7f77c0a1a3208a04a1eda164633fb0767b4cefd65a01079b65e5b1f"},
+    {file = "grpcio-1.75.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:36990d629c3c9fb41e546414e5af52d0a7af37ce7113d9682c46d7e2919e4cca"},
+    {file = "grpcio-1.75.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b10ad908118d38c2453ade7ff790e5bce36580c3742919007a2a78e3a1e521ca"},
+    {file = "grpcio-1.75.1-cp311-cp311-win32.whl", hash = "sha256:d6be2b5ee7bea656c954dcf6aa8093c6f0e6a3ef9945c99d99fcbfc88c5c0bfe"},
+    {file = "grpcio-1.75.1-cp311-cp311-win_amd64.whl", hash = "sha256:61c692fb05956b17dd6d1ab480f7f10ad0536dba3bc8fd4e3c7263dc244ed772"},
+    {file = "grpcio-1.75.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:7b888b33cd14085d86176b1628ad2fcbff94cfbbe7809465097aa0132e58b018"},
+    {file = "grpcio-1.75.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:8775036efe4ad2085975531d221535329f5dac99b6c2a854a995456098f99546"},
+    {file = "grpcio-1.75.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bb658f703468d7fbb5dcc4037c65391b7dc34f808ac46ed9136c24fc5eeb041d"},
+    {file = "grpcio-1.75.1-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:4b7177a1cdb3c51b02b0c0a256b0a72fdab719600a693e0e9037949efffb200b"},
+    {file = "grpcio-1.75.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7d4fa6ccc3ec2e68a04f7b883d354d7fea22a34c44ce535a2f0c0049cf626ddf"},
+    {file = "grpcio-1.75.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3d86880ecaeb5b2f0a8afa63824de93adb8ebe4e49d0e51442532f4e08add7d6"},
+    {file = "grpcio-1.75.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a8041d2f9e8a742aeae96f4b047ee44e73619f4f9d24565e84d5446c623673b6"},
+    {file = "grpcio-1.75.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3652516048bf4c314ce12be37423c79829f46efffb390ad64149a10c6071e8de"},
+    {file = "grpcio-1.75.1-cp312-cp312-win32.whl", hash = "sha256:44b62345d8403975513af88da2f3d5cc76f73ca538ba46596f92a127c2aea945"},
+    {file = "grpcio-1.75.1-cp312-cp312-win_amd64.whl", hash = "sha256:b1e191c5c465fa777d4cafbaacf0c01e0d5278022082c0abbd2ee1d6454ed94d"},
+    {file = "grpcio-1.75.1-cp313-cp313-linux_armv7l.whl", hash = "sha256:3bed22e750d91d53d9e31e0af35a7b0b51367e974e14a4ff229db5b207647884"},
+    {file = "grpcio-1.75.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:5b8f381eadcd6ecaa143a21e9e80a26424c76a0a9b3d546febe6648f3a36a5ac"},
+    {file = "grpcio-1.75.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5bf4001d3293e3414d0cf99ff9b1139106e57c3a66dfff0c5f60b2a6286ec133"},
+    {file = "grpcio-1.75.1-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:9f82ff474103e26351dacfe8d50214e7c9322960d8d07ba7fa1d05ff981c8b2d"},
+    {file = "grpcio-1.75.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0ee119f4f88d9f75414217823d21d75bfe0e6ed40135b0cbbfc6376bc9f7757d"},
+    {file = "grpcio-1.75.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:664eecc3abe6d916fa6cf8dd6b778e62fb264a70f3430a3180995bf2da935446"},
+    {file = "grpcio-1.75.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:c32193fa08b2fbebf08fe08e84f8a0aad32d87c3ad42999c65e9449871b1c66e"},
+    {file = "grpcio-1.75.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5cebe13088b9254f6e615bcf1da9131d46cfa4e88039454aca9cb65f639bd3bc"},
+    {file = "grpcio-1.75.1-cp313-cp313-win32.whl", hash = "sha256:4b4c678e7ed50f8ae8b8dbad15a865ee73ce12668b6aaf411bf3258b5bc3f970"},
+    {file = "grpcio-1.75.1-cp313-cp313-win_amd64.whl", hash = "sha256:5573f51e3f296a1bcf71e7a690c092845fb223072120f4bdb7a5b48e111def66"},
+    {file = "grpcio-1.75.1-cp314-cp314-linux_armv7l.whl", hash = "sha256:c05da79068dd96723793bffc8d0e64c45f316248417515f28d22204d9dae51c7"},
+    {file = "grpcio-1.75.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:06373a94fd16ec287116a825161dca179a0402d0c60674ceeec8c9fba344fe66"},
+    {file = "grpcio-1.75.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4484f4b7287bdaa7a5b3980f3c7224c3c622669405d20f69549f5fb956ad0421"},
+    {file = "grpcio-1.75.1-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:2720c239c1180eee69f7883c1d4c83fc1a495a2535b5fa322887c70bf02b16e8"},
+    {file = "grpcio-1.75.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:07a554fa31c668cf0e7a188678ceeca3cb8fead29bbe455352e712ec33ca701c"},
+    {file = "grpcio-1.75.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:3e71a2105210366bfc398eef7f57a664df99194f3520edb88b9c3a7e46ee0d64"},
+    {file = "grpcio-1.75.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:8679aa8a5b67976776d3c6b0521e99d1c34db8a312a12bcfd78a7085cb9b604e"},
+    {file = "grpcio-1.75.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:aad1c774f4ebf0696a7f148a56d39a3432550612597331792528895258966dc0"},
+    {file = "grpcio-1.75.1-cp314-cp314-win32.whl", hash = "sha256:62ce42d9994446b307649cb2a23335fa8e927f7ab2cbf5fcb844d6acb4d85f9c"},
+    {file = "grpcio-1.75.1-cp314-cp314-win_amd64.whl", hash = "sha256:f86e92275710bea3000cb79feca1762dc0ad3b27830dd1a74e82ab321d4ee464"},
+    {file = "grpcio-1.75.1-cp39-cp39-linux_armv7l.whl", hash = "sha256:c09fba33327c3ac11b5c33dbdd8218eef8990d78f83b1656d628831812a8c0fb"},
+    {file = "grpcio-1.75.1-cp39-cp39-macosx_11_0_universal2.whl", hash = "sha256:7e21400b037be29545704889e72e586c238e346dcb2d08d8a7288d16c883a9ec"},
+    {file = "grpcio-1.75.1-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c12121e509b9f8b0914d10054d24120237d19e870b1cd82acbb8a9b9ddd198a3"},
+    {file = "grpcio-1.75.1-cp39-cp39-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:73577a93e692b3474b1bfe84285d098de36705dbd838bb4d6a056d326e4dc880"},
+    {file = "grpcio-1.75.1-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e19e7dfa0d7ca7dea22be464339e18ac608fd75d88c56770c646cdabe54bc724"},
+    {file = "grpcio-1.75.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:4e1c28f51c1cf67eccdfc1065e8e866c9ed622f09773ca60947089c117f848a1"},
+    {file = "grpcio-1.75.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:030a6164bc2ca726052778c0cf8e3249617a34e368354f9e6107c27ad4af8c28"},
+    {file = "grpcio-1.75.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:67697efef5a98d46d5db7b1720fa4043536f8b8e5072a5d61cfca762f287e939"},
+    {file = "grpcio-1.75.1-cp39-cp39-win32.whl", hash = "sha256:52015cf73eb5d76f6404e0ce0505a69b51fd1f35810b3a01233b34b10baafb41"},
+    {file = "grpcio-1.75.1-cp39-cp39-win_amd64.whl", hash = "sha256:9fe51e4a1f896ea84ac750900eae34d9e9b896b5b1e4a30b02dc31ad29f36383"},
+    {file = "grpcio-1.75.1.tar.gz", hash = "sha256:3e81d89ece99b9ace23a6916880baca613c03a799925afb2857887efa8b1b3d2"},
+]
+
+[package.dependencies]
+typing-extensions = ">=4.12,<5.0"
+
+[package.extras]
+protobuf = ["grpcio-tools (>=1.75.1)"]
+
+[[package]]
+name = "grpcio-status"
+version = "1.75.1"
+description = "Status proto mapping for gRPC"
+optional = false
+python-versions = ">=3.9"
+groups = ["main"]
+files = [
+    {file = "grpcio_status-1.75.1-py3-none-any.whl", hash = "sha256:f681b301be26dcf7abf5c765d4a22e4098765e1a65cbdfa3efca384edf8e4e3c"},
+    {file = "grpcio_status-1.75.1.tar.gz", hash = "sha256:8162afa21833a2085c91089cc395ad880fac1378a1d60233d976649ed724cbf8"},
+]
+
+[package.dependencies]
+googleapis-common-protos = ">=1.5.5"
+grpcio = ">=1.75.1"
+protobuf = ">=6.31.1,<7.0.0"
+
 [[package]]
 name = "gunicorn"
 version = "23.0.0"
@@ -1193,14 +1331,14 @@ zstd = ["zstandard (>=0.18.0)"]
 
 [[package]]
 name = "huggingface-hub"
-version = "0.35.0"
+version = "0.35.1"
 description = "Client library to download and publish models, datasets and other repos on the huggingface.co hub"
 optional = false
 python-versions = ">=3.8.0"
 groups = ["main"]
 files = [
-    {file = "huggingface_hub-0.35.0-py3-none-any.whl", hash = "sha256:f2e2f693bca9a26530b1c0b9bcd4c1495644dad698e6a0060f90e22e772c31e9"},
-    {file = "huggingface_hub-0.35.0.tar.gz", hash = "sha256:ccadd2a78eef75effff184ad89401413629fabc52cefd76f6bbacb9b1c0676ac"},
+    {file = "huggingface_hub-0.35.1-py3-none-any.whl", hash = "sha256:2f0e2709c711e3040e31d3e0418341f7092910f1462dd00350c4e97af47280a8"},
+    {file = "huggingface_hub-0.35.1.tar.gz", hash = "sha256:3585b88c5169c64b7e4214d0e88163d4a709de6d1a502e0cd0459e9ee2c9c572"},
 ]
 
 [package.dependencies]
@@ -1709,30 +1847,34 @@ signedtoken = ["cryptography (>=3.0.0)", "pyjwt (>=2.0.0,<3)"]
 
 [[package]]
 name = "onnxruntime"
-version = "1.22.1"
+version = "1.23.0"
 description = "ONNX Runtime is a runtime accelerator for Machine Learning models"
 optional = false
 python-versions = ">=3.10"
 groups = ["main"]
 files = [
-    {file = "onnxruntime-1.22.1-cp310-cp310-macosx_13_0_universal2.whl", hash = "sha256:80e7f51da1f5201c1379b8d6ef6170505cd800e40da216290f5e06be01aadf95"},
-    {file = "onnxruntime-1.22.1-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b89ddfdbbdaf7e3a59515dee657f6515601d55cb21a0f0f48c81aefc54ff1b73"},
-    {file = "onnxruntime-1.22.1-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bddc75868bcf6f9ed76858a632f65f7b1846bdcefc6d637b1e359c2c68609964"},
-    {file = "onnxruntime-1.22.1-cp310-cp310-win_amd64.whl", hash = "sha256:01e2f21b2793eb0c8642d2be3cee34cc7d96b85f45f6615e4e220424158877ce"},
-    {file = "onnxruntime-1.22.1-cp311-cp311-macosx_13_0_universal2.whl", hash = "sha256:f4581bccb786da68725d8eac7c63a8f31a89116b8761ff8b4989dc58b61d49a0"},
-    {file = "onnxruntime-1.22.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7ae7526cf10f93454beb0f751e78e5cb7619e3b92f9fc3bd51aa6f3b7a8977e5"},
-    {file = "onnxruntime-1.22.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f6effa1299ac549a05c784d50292e3378dbbf010346ded67400193b09ddc2f04"},
-    {file = "onnxruntime-1.22.1-cp311-cp311-win_amd64.whl", hash = "sha256:f28a42bb322b4ca6d255531bb334a2b3e21f172e37c1741bd5e66bc4b7b61f03"},
-    {file = "onnxruntime-1.22.1-cp312-cp312-macosx_13_0_universal2.whl", hash = "sha256:a938d11c0dc811badf78e435daa3899d9af38abee950d87f3ab7430eb5b3cf5a"},
-    {file = "onnxruntime-1.22.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:984cea2a02fcc5dfea44ade9aca9fe0f7a8a2cd6f77c258fc4388238618f3928"},
-    {file = "onnxruntime-1.22.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2d39a530aff1ec8d02e365f35e503193991417788641b184f5b1e8c9a6d5ce8d"},
-    {file = "onnxruntime-1.22.1-cp312-cp312-win_amd64.whl", hash = "sha256:6a64291d57ea966a245f749eb970f4fa05a64d26672e05a83fdb5db6b7d62f87"},
-    {file = "onnxruntime-1.22.1-cp313-cp313-macosx_13_0_universal2.whl", hash = "sha256:d29c7d87b6cbed8fecfd09dca471832384d12a69e1ab873e5effbb94adc3e966"},
-    {file = "onnxruntime-1.22.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:460487d83b7056ba98f1f7bac80287224c31d8149b15712b0d6f5078fcc33d0f"},
-    {file = "onnxruntime-1.22.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b0c37070268ba4e02a1a9d28560cd00cd1e94f0d4f275cbef283854f861a65fa"},
-    {file = "onnxruntime-1.22.1-cp313-cp313-win_amd64.whl", hash = "sha256:70980d729145a36a05f74b573435531f55ef9503bcda81fc6c3d6b9306199982"},
-    {file = "onnxruntime-1.22.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33a7980bbc4b7f446bac26c3785652fe8730ed02617d765399e89ac7d44e0f7d"},
-    {file = "onnxruntime-1.22.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6e7e823624b015ea879d976cbef8bfaed2f7e2cc233d7506860a76dd37f8f381"},
+    {file = "onnxruntime-1.23.0-cp310-cp310-macosx_13_0_arm64.whl", hash = "sha256:009bf5ecad107a7f11af8214fcff19e844214887b38c6673bd63a25af2f6121f"},
+    {file = "onnxruntime-1.23.0-cp310-cp310-macosx_13_0_x86_64.whl", hash = "sha256:9f875c93891200a946a3387d2c66c66668b9b60a1a053a83d4ee025d8b8892de"},
+    {file = "onnxruntime-1.23.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c613fd9280e506d237f7701c1275b6ff30f517a523ced62d1def11a8cf5acf7c"},
+    {file = "onnxruntime-1.23.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8984f38de1a2d57fead5c791c5a6e1921dadfe0bc9f5ea26a5acfcc78908e3e9"},
+    {file = "onnxruntime-1.23.0-cp310-cp310-win_amd64.whl", hash = "sha256:08efde1dd5c4881aaf49e79cd2f03d0cd977e8f657217e2796c343c06fefac51"},
+    {file = "onnxruntime-1.23.0-cp311-cp311-macosx_13_0_arm64.whl", hash = "sha256:ecf8c589d7d55bd645237442a97c9a2b4bd35bab35b20fc7f2bc81b70c062071"},
+    {file = "onnxruntime-1.23.0-cp311-cp311-macosx_13_0_x86_64.whl", hash = "sha256:b703c42e6aee8d58d23b39ea856c4202173fcd4260e87fe08fc1d4e983d76f92"},
+    {file = "onnxruntime-1.23.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e8634c5f54774df1e4d1debfdf2ca8f3274fe4ffc816ff5f861c01c48468a2c4"},
+    {file = "onnxruntime-1.23.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3c681ab5ae4fce92d09f4a86ac088a18ea36f8739115b8abf55e557cb6729e97"},
+    {file = "onnxruntime-1.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:a91e14627c08fbbde3c54fbce21e0903ce07a985f664f24d097cbfb01a930a69"},
+    {file = "onnxruntime-1.23.0-cp312-cp312-macosx_13_0_arm64.whl", hash = "sha256:5921f2e106f5faf2b32095b2ecdfae047e445c3bce063e439dadc75c212e7be7"},
+    {file = "onnxruntime-1.23.0-cp312-cp312-macosx_13_0_x86_64.whl", hash = "sha256:053df2f9c6522b258055bce4b776aa9ea3adb4b28d2530ab07b204a3d4b04bf9"},
+    {file = "onnxruntime-1.23.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:974e327ca3b6d43da404b9a45df1f61e2503667fde46843ee7ad1567a98f3f0b"},
+    {file = "onnxruntime-1.23.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:05f67edb93678cab5cd77eda89b65bb1b58f3d4c0742058742cfad8b172cfa83"},
+    {file = "onnxruntime-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:e100f3869da4c12b17a9b942934a96a542406f860eb8beb74a68342ea43aaa55"},
+    {file = "onnxruntime-1.23.0-cp313-cp313-macosx_13_0_arm64.whl", hash = "sha256:b6659f17326e64f2902cd31aa5efc1af41d0e0e3bd1357a75985e358412c35ca"},
+    {file = "onnxruntime-1.23.0-cp313-cp313-macosx_13_0_x86_64.whl", hash = "sha256:9ef62369a0261aa15b1399addaaf17ed398e4e2128c8548fafcd73aac13820fd"},
+    {file = "onnxruntime-1.23.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0edee45d4119f7a6f187dc1b63e177e3e6c76932446006fd4f3e81540f260dfa"},
+    {file = "onnxruntime-1.23.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2dc1993aa91d665faf2b17772e4e29a2999821e110c0e3d17e2b1c00d0e7f48"},
+    {file = "onnxruntime-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:e52c8603c4cc74746ece9966102e4fc6c2b355efc0102a9deb107f3ff86680af"},
+    {file = "onnxruntime-1.23.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:24ac2a8b2c6dd00a152a08a9cf1ba3f06b38915f6cb6cf1adbe714e16e5ff460"},
+    {file = "onnxruntime-1.23.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ed85686e08cfb29ee96365b9a49e8a350aff7557c13d63d9f07ca3ad68975074"},
 ]
 
 [package.dependencies]
@@ -1745,14 +1887,14 @@ sympy = "*"
 
 [[package]]
 name = "openai"
-version = "1.108.1"
+version = "1.109.1"
 description = "The official Python library for the openai API"
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
 files = [
-    {file = "openai-1.108.1-py3-none-any.whl", hash = "sha256:952fc027e300b2ac23be92b064eac136a2bc58274cec16f5d2906c361340d59b"},
-    {file = "openai-1.108.1.tar.gz", hash = "sha256:6648468c1aec4eacfa554001e933a9fa075f57bacfc27588c2e34456cee9fef9"},
+    {file = "openai-1.109.1-py3-none-any.whl", hash = "sha256:6bcaf57086cf59159b8e27447e4e7dd019db5d29a438072fbd49c290c7e65315"},
+    {file = "openai-1.109.1.tar.gz", hash = "sha256:d173ed8dbca665892a6db099b4a2dfac624f94d20a93f46eb0b56aae940ed869"},
 ]
 
 [package.dependencies]
@@ -2285,14 +2427,14 @@ typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0"
 
 [[package]]
 name = "pydantic-settings"
-version = "2.10.1"
+version = "2.11.0"
 description = "Settings management using Pydantic"
 optional = false
 python-versions = ">=3.9"
 groups = ["main"]
 files = [
-    {file = "pydantic_settings-2.10.1-py3-none-any.whl", hash = "sha256:a60952460b99cf661dc25c29c0ef171721f98bfcb52ef8d9ea4c943d7c8cc796"},
-    {file = "pydantic_settings-2.10.1.tar.gz", hash = "sha256:06f0062169818d0f5524420a360d632d5857b83cffd4d42fe29597807a1614ee"},
+    {file = "pydantic_settings-2.11.0-py3-none-any.whl", hash = "sha256:fe2cea3413b9530d10f3a5875adffb17ada5c1e1bab0b2885546d7310415207c"},
+    {file = "pydantic_settings-2.11.0.tar.gz", hash = "sha256:d0e87a1c7d33593beb7194adb8470fc426e95ba02af83a0f23474a04c9a08180"},
 ]
 
 [package.dependencies]
@@ -2355,14 +2497,14 @@ diagrams = ["jinja2", "railroad-diagrams"]
 
 [[package]]
 name = "pyperclip"
-version = "1.10.0"
+version = "1.11.0"
 description = "A cross-platform clipboard module for Python. (Only handles plain text for now.)"
 optional = false
 python-versions = "*"
 groups = ["main"]
 files = [
-    {file = "pyperclip-1.10.0-py3-none-any.whl", hash = "sha256:596fbe55dc59263bff26e61d2afbe10223e2fccb5210c9c96a28d6887cfcc7ec"},
-    {file = "pyperclip-1.10.0.tar.gz", hash = "sha256:180c8346b1186921c75dfd14d9048a6b5d46bfc499778811952c6dd6eb1ca6be"},
+    {file = "pyperclip-1.11.0-py3-none-any.whl", hash = "sha256:299403e9ff44581cb9ba2ffeed69c7aa96a008622ad0c46cb575ca75b5b84273"},
+    {file = "pyperclip-1.11.0.tar.gz", hash = "sha256:244035963e4428530d9e3a6101a1ef97209c6825edab1567beac148ccc1db1b6"},
 ]
 
 [[package]]
@@ -2463,65 +2605,78 @@ dev = ["black", "build", "mypy", "pytest", "pytest-cov", "setuptools", "tox", "t
 
 [[package]]
 name = "pyyaml"
-version = "6.0.2"
+version = "6.0.3"
 description = "YAML parser and emitter for Python"
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
 files = [
-    {file = "PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086"},
-    {file = "PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf"},
-    {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237"},
-    {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b"},
-    {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed"},
-    {file = "PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180"},
-    {file = "PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68"},
-    {file = "PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99"},
-    {file = "PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e"},
-    {file = "PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774"},
-    {file = "PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee"},
-    {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c"},
-    {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317"},
-    {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85"},
-    {file = "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4"},
-    {file = "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e"},
-    {file = "PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5"},
-    {file = "PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44"},
-    {file = "PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab"},
-    {file = "PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725"},
-    {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5"},
-    {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425"},
-    {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476"},
-    {file = "PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48"},
-    {file = "PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b"},
-    {file = "PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4"},
-    {file = "PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8"},
-    {file = "PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba"},
-    {file = "PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1"},
-    {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133"},
-    {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484"},
-    {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5"},
-    {file = "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc"},
-    {file = "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652"},
-    {file = "PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183"},
-    {file = "PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563"},
-    {file = "PyYAML-6.0.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:24471b829b3bf607e04e88d79542a9d48bb037c2267d7927a874e6c205ca7e9a"},
-    {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7fded462629cfa4b685c5416b949ebad6cec74af5e2d42905d41e257e0869f5"},
-    {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d84a1718ee396f54f3a086ea0a66d8e552b2ab2017ef8b420e92edbc841c352d"},
-    {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9056c1ecd25795207ad294bcf39f2db3d845767be0ea6e6a34d856f006006083"},
-    {file = "PyYAML-6.0.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:82d09873e40955485746739bcb8b4586983670466c23382c19cffecbf1fd8706"},
-    {file = "PyYAML-6.0.2-cp38-cp38-win32.whl", hash = "sha256:43fa96a3ca0d6b1812e01ced1044a003533c47f6ee8aca31724f78e93ccc089a"},
-    {file = "PyYAML-6.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:01179a4a8559ab5de078078f37e5c1a30d76bb88519906844fd7bdea1b7729ff"},
-    {file = "PyYAML-6.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:688ba32a1cffef67fd2e9398a2efebaea461578b0923624778664cc1c914db5d"},
-    {file = "PyYAML-6.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8786accb172bd8afb8be14490a16625cbc387036876ab6ba70912730faf8e1f"},
-    {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e03406cac8513435335dbab54c0d385e4a49e4945d2909a581c83647ca0290"},
-    {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f753120cb8181e736c57ef7636e83f31b9c0d1722c516f7e86cf15b7aa57ff12"},
-    {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b1fdb9dc17f5a7677423d508ab4f243a726dea51fa5e70992e59a7411c89d19"},
-    {file = "PyYAML-6.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0b69e4ce7a131fe56b7e4d770c67429700908fc0752af059838b1cfb41960e4e"},
-    {file = "PyYAML-6.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a9f8c2e67970f13b16084e04f134610fd1d374bf477b17ec1599185cf611d725"},
-    {file = "PyYAML-6.0.2-cp39-cp39-win32.whl", hash = "sha256:6395c297d42274772abc367baaa79683958044e5d3835486c16da75d2a694631"},
-    {file = "PyYAML-6.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8"},
-    {file = "pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e"},
+    {file = "pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b"},
+    {file = "pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956"},
+    {file = "pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8"},
+    {file = "pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198"},
+    {file = "pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b"},
+    {file = "pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0"},
+    {file = "pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69"},
+    {file = "pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e"},
+    {file = "pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c"},
+    {file = "pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e"},
+    {file = "pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824"},
+    {file = "pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c"},
+    {file = "pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00"},
+    {file = "pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d"},
+    {file = "pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a"},
+    {file = "pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4"},
+    {file = "pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b"},
+    {file = "pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf"},
+    {file = "pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196"},
+    {file = "pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0"},
+    {file = "pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28"},
+    {file = "pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c"},
+    {file = "pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc"},
+    {file = "pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e"},
+    {file = "pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea"},
+    {file = "pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5"},
+    {file = "pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b"},
+    {file = "pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd"},
+    {file = "pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8"},
+    {file = "pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1"},
+    {file = "pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c"},
+    {file = "pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5"},
+    {file = "pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6"},
+    {file = "pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6"},
+    {file = "pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be"},
+    {file = "pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26"},
+    {file = "pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c"},
+    {file = "pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb"},
+    {file = "pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac"},
+    {file = "pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310"},
+    {file = "pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7"},
+    {file = "pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788"},
+    {file = "pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5"},
+    {file = "pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764"},
+    {file = "pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35"},
+    {file = "pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac"},
+    {file = "pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3"},
+    {file = "pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3"},
+    {file = "pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba"},
+    {file = "pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c"},
+    {file = "pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702"},
+    {file = "pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c"},
+    {file = "pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065"},
+    {file = "pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65"},
+    {file = "pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9"},
+    {file = "pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b"},
+    {file = "pyyaml-6.0.3-cp39-cp39-macosx_10_13_x86_64.whl", hash = "sha256:b865addae83924361678b652338317d1bd7e79b1f4596f96b96c77a5a34b34da"},
+    {file = "pyyaml-6.0.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c3355370a2c156cffb25e876646f149d5d68f5e0a3ce86a5084dd0b64a994917"},
+    {file = "pyyaml-6.0.3-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3c5677e12444c15717b902a5798264fa7909e41153cdf9ef7ad571b704a63dd9"},
+    {file = "pyyaml-6.0.3-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5ed875a24292240029e4483f9d4a4b8a1ae08843b9c54f43fcc11e404532a8a5"},
+    {file = "pyyaml-6.0.3-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0150219816b6a1fa26fb4699fb7daa9caf09eb1999f3b70fb6e786805e80375a"},
+    {file = "pyyaml-6.0.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:fa160448684b4e94d80416c0fa4aac48967a969efe22931448d853ada8baf926"},
+    {file = "pyyaml-6.0.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:27c0abcb4a5dac13684a37f76e701e054692a9b2d3064b70f5e4eb54810553d7"},
+    {file = "pyyaml-6.0.3-cp39-cp39-win32.whl", hash = "sha256:1ebe39cb5fc479422b83de611d14e2c0d3bb2a18bbcb01f229ab3cfbd8fee7a0"},
+    {file = "pyyaml-6.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:2e71d11abed7344e42a8849600193d15b6def118602c4c176f748e4583246007"},
+    {file = "pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f"},
 ]
 
 [[package]]
@@ -3526,4 +3681,4 @@ propcache = ">=0.2.1"
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.11,<3.14"
-content-hash = "fe9799a3d3a101e05d75d5e193c6e9e4ef17a7581cb273f41101e12129f80a2f"
+content-hash = "e9a01f0153fc072624975c8d42f585bb18b4122b9b762868712eaa5d21a66d13"
diff --git a/apps/pre-processing-service/pyproject.toml b/apps/pre-processing-service/pyproject.toml
index 8cb11c0f..2db7750e 100644
--- a/apps/pre-processing-service/pyproject.toml
+++ b/apps/pre-processing-service/pyproject.toml
@@ -39,6 +39,10 @@ aiohttp = "^3.12.15"
 prometheus-client = "^0.23.1"
 prometheus-fastapi-instrumentator = "^7.1.0"
 boto3 = "^1.40.35"
+deep-translator = "^1.11.4"
+google-cloud-vision = "^3.10.2"
+google-auth = "^2.40.3"
+
 
 [build-system]
 requires = ["poetry-core>=2.0.0,<3.0.0"]
diff --git a/apps/user-service/build.gradle b/apps/user-service/build.gradle
index 16905e8e..3660ab02 100644
--- a/apps/user-service/build.gradle
+++ b/apps/user-service/build.gradle
@@ -160,6 +160,13 @@ bootJar {
 	from ("${asciidoctor.outputDir}/html5") {
 		into 'static/docs'
 	}
+
+	// 프로덕션 JAR에서 불필요한 파일들 제외
+	exclude 'application-test-*.yml'
+	exclude 'log4j2-test-*.yml'
+	exclude 'application-develop.yml'
+	exclude 'log4j2-develop.yml'
+	exclude 'sql/**'
 }
 
 spotless {
diff --git a/apps/user-service/src/main/java/site/icebang/domain/schedule/mapper/ScheduleMapper.java b/apps/user-service/src/main/java/site/icebang/domain/schedule/mapper/ScheduleMapper.java
index 12567a60..07ac19ea 100644
--- a/apps/user-service/src/main/java/site/icebang/domain/schedule/mapper/ScheduleMapper.java
+++ b/apps/user-service/src/main/java/site/icebang/domain/schedule/mapper/ScheduleMapper.java
@@ -3,10 +3,94 @@
 import java.util.List;
 
 import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
 
 import site.icebang.domain.schedule.model.Schedule;
 
+/**
+ * Schedule 데이터베이스 접근을 위한 MyBatis Mapper 인터페이스
+ *
+ * <p>워크플로우의 스케줄 정보를 관리하며, 한 워크플로우에 여러 스케줄을 등록할 수 있지만 같은 크론식의 중복 등록은 방지합니다.
+ *
+ * @author bwnfo0702@gmail.com
+ * @since v0.1.0
+ */
 @Mapper
 public interface ScheduleMapper {
+
+  /**
+   * 활성화된 모든 스케줄 조회
+   *
+   * @return 활성 상태인 스케줄 목록
+   */
   List<Schedule> findAllActive();
+
+  /**
+   * 새로운 스케줄 등록
+   *
+   * @param schedule 등록할 스케줄 정보
+   * @return 영향받은 행 수 (1: 성공, 0: 실패)
+   */
+  int insertSchedule(Schedule schedule);
+
+  /**
+   * 특정 워크플로우의 모든 활성 스케줄 조회
+   *
+   * @param workflowId 조회할 워크플로우 ID
+   * @return 해당 워크플로우의 활성 스케줄 목록
+   */
+  List<Schedule> findAllByWorkflowId(@Param("workflowId") Long workflowId);
+
+  /**
+   * 특정 워크플로우에서 특정 크론식이 이미 존재하는지 확인
+   *
+   * @param workflowId 워크플로우 ID
+   * @param cronExpression 확인할 크론 표현식
+   * @return 중복 여부 (true: 이미 존재함, false: 존재하지 않음)
+   */
+  boolean existsByWorkflowIdAndCronExpression(
+      @Param("workflowId") Long workflowId, @Param("cronExpression") String cronExpression);
+
+  /**
+   * 특정 워크플로우의 특정 크론식을 가진 스케줄 조회
+   *
+   * @param workflowId 워크플로우 ID
+   * @param cronExpression 크론 표현식
+   * @return 해당하는 스케줄 (없으면 null)
+   */
+  Schedule findByWorkflowIdAndCronExpression(
+      @Param("workflowId") Long workflowId, @Param("cronExpression") String cronExpression);
+
+  /**
+   * 스케줄 활성화 상태 변경
+   *
+   * @param id 스케줄 ID
+   * @param isActive 활성화 여부
+   * @return 영향받은 행 수
+   */
+  int updateActiveStatus(@Param("id") Long id, @Param("isActive") boolean isActive);
+
+  /**
+   * 스케줄 정보 수정 (크론식, 설명 등)
+   *
+   * @param schedule 수정할 스케줄 정보
+   * @return 영향받은 행 수
+   */
+  int updateSchedule(Schedule schedule);
+
+  /**
+   * 스케줄 삭제 (soft delete)
+   *
+   * @param id 삭제할 스케줄 ID
+   * @return 영향받은 행 수
+   */
+  int deleteSchedule(@Param("id") Long id);
+
+  /**
+   * 워크플로우의 모든 스케줄 비활성화
+   *
+   * @param workflowId 워크플로우 ID
+   * @return 영향받은 행 수
+   */
+  int deactivateAllByWorkflowId(@Param("workflowId") Long workflowId);
 }
diff --git a/apps/user-service/src/main/java/site/icebang/domain/workflow/dto/ScheduleCreateDto.java b/apps/user-service/src/main/java/site/icebang/domain/workflow/dto/ScheduleCreateDto.java
new file mode 100644
index 00000000..87fdcb5a
--- /dev/null
+++ b/apps/user-service/src/main/java/site/icebang/domain/workflow/dto/ScheduleCreateDto.java
@@ -0,0 +1,103 @@
+package site.icebang.domain.workflow.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import site.icebang.domain.schedule.model.Schedule;
+
+/**
+ * 스케줄 생성 요청 DTO
+ *
+ * <p>워크플로우 생성 시 함께 등록할 스케줄 정보를 담습니다.
+ *
+ * <p>역할: - API 요청 시 클라이언트로부터 스케줄 정보 수신 - 입력값 검증 (형식, 길이 등) - Schedule(Model)로 변환되어 DB 저장
+ *
+ * <p>기존 ScheduleDto(응답용)와 통일성을 위해 camelCase 사용
+ *
+ * @author bwnfo0702@gmail.com
+ * @since v0.1.0
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ScheduleCreateDto {
+  /**
+   * 크론 표현식 (필수)
+   *
+   * <p>Quartz 크론 표현식 형식을 따릅니다.
+   *
+   * <ul>
+   *   <li>초 분 시 일 월 요일 (년도)
+   *   <li>예시: "0 9 * * *" (매일 9시 0분 0초)
+   *   <li>예시: "0 0 14 * * MON-FRI" (평일 오후 2시)
+   * </ul>
+   *
+   * <p>정밀한 유효성 검증은 서비스 레이어에서 Quartz CronExpression으로 수행됩니다.
+   */
+  @NotBlank(message = "크론 표현식은 필수입니다")
+  @Size(max = 50, message = "크론 표현식은 50자를 초과할 수 없습니다")
+  private String cronExpression;
+
+  /**
+   * 사용자 친화적 스케줄 설명
+   *
+   * <p>UI에 표시될 스케줄 설명입니다. 자동으로 생성됩니다.
+   *
+   * <ul>
+   *   <li>예시: "매일 오전 9시"
+   *   <li>예시: "평일 오후 2시"
+   *   <li>예시: "매주 금요일 6시"
+   * </ul>
+   */
+  @Size(max = 20, message = "스케줄 설명은 자동으로 생성됩니다")
+  private String scheduleText;
+
+  /**
+   * 스케줄 활성화 여부 (기본값: true)
+   *
+   * <p>false일 경우 DB에는 저장되지만 Quartz에 등록되지 않습니다.
+   */
+  @Builder.Default private Boolean isActive = true;
+
+  /**
+   * 스케줄 실행 시 추가 파라미터 (선택, JSON 형식)
+   *
+   * <p>워크플로우 실행 시 전달할 추가 파라미터를 JSON 문자열로 저장합니다.
+   *
+   * <pre>{@code
+   * // 예시:
+   * {
+   *   "retryCount": 3,
+   *   "timeout": 300,
+   *   "notifyOnFailure": true
+   * }
+   * }</pre>
+   */
+  private String parameters;
+
+  /**
+   * Schedule(Model) 엔티티로 변환
+   *
+   * <p>DTO의 정보를 DB 저장용 엔티티로 변환하며, 서비스 레이어에서 주입되는 workflowId와 userId를 함께 설정합니다.
+   *
+   * @param workflowId 연결할 워크플로우 ID
+   * @param userId 생성자 ID
+   * @return DB 저장 가능한 Schedule 엔티티
+   */
+  public Schedule toEntity(Long workflowId, Long userId) {
+    return Schedule.builder()
+        .workflowId(workflowId)
+        .cronExpression(this.cronExpression)
+        .scheduleText(this.scheduleText)
+        .isActive(this.isActive != null ? this.isActive : true)
+        .parameters(this.parameters)
+        .createdBy(userId)
+        .updatedBy(userId)
+        .build();
+  }
+}
diff --git a/apps/user-service/src/main/java/site/icebang/domain/workflow/dto/WorkflowCreateDto.java b/apps/user-service/src/main/java/site/icebang/domain/workflow/dto/WorkflowCreateDto.java
index bcd0cc56..f14b2aeb 100644
--- a/apps/user-service/src/main/java/site/icebang/domain/workflow/dto/WorkflowCreateDto.java
+++ b/apps/user-service/src/main/java/site/icebang/domain/workflow/dto/WorkflowCreateDto.java
@@ -1,9 +1,11 @@
 package site.icebang.domain.workflow.dto;
 
 import java.math.BigInteger;
+import java.util.List;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 
+import jakarta.validation.Valid;
 import jakarta.validation.constraints.*;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -14,7 +16,10 @@
  * 워크플로우 생성 요청 DTO
  *
  * <p>프론트엔드에서 워크플로우 생성 시 필요한 모든 정보를 담는 DTO - 기본 정보: 이름, 설명 - 플랫폼 설정: 검색 플랫폼, 포스팅 플랫폼 - 계정 설정: 포스팅 계정
- * 정보 (JSON 형태로 저장)
+ * 정보 (JSON 형태로 저장) - 스케줄 설정: 선택적으로 여러 스케줄 등록 가능
+ *
+ * @author bwnfo0702@gmail.com
+ * @since v0.1.0
  */
 @Data
 @Builder
@@ -59,6 +64,18 @@ public class WorkflowCreateDto {
   @JsonProperty("is_enabled")
   private Boolean isEnabled = true;
 
+  /**
+   * 워크플로우에 등록할 스케줄 목록 (선택사항)
+   *
+   * <p>사용 시나리오:
+   *
+   * <ul>
+   *   <li>null 또는 빈 리스트: 스케줄 없이 워크플로우만 생성
+   *   <li>1개 이상: 해당 스케줄들을 함께 등록 (트랜잭션 보장)
+   * </ul>
+   */
+  @Valid private List<@Valid ScheduleCreateDto> schedules;
+
   // JSON 변환용 필드 (MyBatis에서 사용)
   private String defaultConfigJson;
 
@@ -109,4 +126,13 @@ public boolean hasPostingConfig() {
         && postingAccountPassword != null
         && !postingAccountPassword.isBlank();
   }
+
+  /**
+   * 스케줄 설정이 있는지 확인
+   *
+   * @return 스케줄이 1개 이상 있으면 true
+   */
+  public boolean hasSchedules() {
+    return schedules != null && !schedules.isEmpty();
+  }
 }
diff --git a/apps/user-service/src/main/java/site/icebang/domain/workflow/service/WorkflowService.java b/apps/user-service/src/main/java/site/icebang/domain/workflow/service/WorkflowService.java
index 06a9ee5c..30a00c55 100644
--- a/apps/user-service/src/main/java/site/icebang/domain/workflow/service/WorkflowService.java
+++ b/apps/user-service/src/main/java/site/icebang/domain/workflow/service/WorkflowService.java
@@ -2,9 +2,12 @@
 
 import java.math.BigInteger;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
+import org.quartz.CronExpression;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -13,7 +16,12 @@
 
 import site.icebang.common.dto.PageParams;
 import site.icebang.common.dto.PageResult;
+import site.icebang.common.exception.DuplicateDataException;
 import site.icebang.common.service.PageableService;
+import site.icebang.domain.schedule.mapper.ScheduleMapper;
+import site.icebang.domain.schedule.model.Schedule;
+import site.icebang.domain.schedule.service.QuartzScheduleService;
+import site.icebang.domain.workflow.dto.ScheduleCreateDto;
 import site.icebang.domain.workflow.dto.ScheduleDto;
 import site.icebang.domain.workflow.dto.WorkflowCardDto;
 import site.icebang.domain.workflow.dto.WorkflowCreateDto;
@@ -41,6 +49,8 @@
 public class WorkflowService implements PageableService<WorkflowCardDto> {
 
   private final WorkflowMapper workflowMapper;
+  private final ScheduleMapper scheduleMapper;
+  private final QuartzScheduleService quartzScheduleService;
 
   /**
    * 워크플로우 목록을 페이징 처리하여 조회합니다.
@@ -91,7 +101,16 @@ public WorkflowDetailCardDto getWorkflowDetail(BigInteger workflowId) {
     return workflow;
   }
 
-  /** 워크플로우 생성 */
+  /**
+   * 워크플로우 생성 (스케줄 포함 가능)
+   *
+   * <p>워크플로우와 스케줄을 하나의 트랜잭션으로 처리하여 원자성을 보장합니다. 스케줄이 포함된 경우 DB 저장 후 즉시 Quartz 스케줄러에 등록합니다.
+   *
+   * @param dto 워크플로우 생성 정보 (스케줄 선택사항)
+   * @param createdBy 생성자 ID
+   * @throws IllegalArgumentException 검증 실패 시
+   * @throws RuntimeException 생성 중 오류 발생 시
+   */
   @Transactional
   public void createWorkflow(WorkflowCreateDto dto, BigInteger createdBy) {
     // 1. 기본 검증
@@ -100,12 +119,18 @@ public void createWorkflow(WorkflowCreateDto dto, BigInteger createdBy) {
     // 2. 비즈니스 검증
     validateBusinessRules(dto);
 
-    // 3. 중복체크
+    // 3. 스케줄 검증 (있는 경우만)
+    if (dto.hasSchedules()) {
+      validateSchedules(dto.getSchedules());
+    }
+
+    // 4. 워크플로우 이름 중복 체크
     if (workflowMapper.existsByName(dto.getName())) {
-      throw new IllegalArgumentException("이미 존재하는 워크플로우 이름입니다 : " + dto.getName());
+      throw new IllegalArgumentException("이미 존재하는 워크플로우 이름입니다: " + dto.getName());
     }
 
-    // 4. 워크플로우 생성
+    // 5. 워크플로우 생성
+    Long workflowId = null;
     try {
       // JSON 설정 생성
       String defaultConfigJson = dto.genertateDefaultConfigJson();
@@ -121,12 +146,24 @@ public void createWorkflow(WorkflowCreateDto dto, BigInteger createdBy) {
         throw new RuntimeException("워크플로우 생성에 실패했습니다");
       }
 
-      log.info("워크플로우 생성 완료: {} (생성자: {})", dto.getName(), createdBy);
+      // 생성된 workflow ID 추출
+      Object generatedId = params.get("id");
+      workflowId =
+          (generatedId instanceof BigInteger)
+              ? ((BigInteger) generatedId).longValue()
+              : ((Number) generatedId).longValue();
+
+      log.info("워크플로우 생성 완료: {} (ID: {}, 생성자: {})", dto.getName(), workflowId, createdBy);
 
     } catch (Exception e) {
       log.error("워크플로우 생성 실패: {}", dto.getName(), e);
       throw new RuntimeException("워크플로우 생성 중 오류가 발생했습니다", e);
     }
+
+    // 6. 스케줄 등록 (있는 경우만)
+    if (dto.hasSchedules() && workflowId != null) {
+      registerSchedules(workflowId, dto.getSchedules(), createdBy.longValue());
+    }
   }
 
   /** 기본 입력값 검증 */
@@ -158,4 +195,117 @@ private void validateBusinessRules(WorkflowCreateDto dto) {
       }
     }
   }
+
+  /**
+   * 스케줄 목록 검증
+   *
+   * <p>크론 표현식 유효성 및 중복 검사를 수행합니다.
+   *
+   * @param schedules 검증할 스케줄 목록
+   * @throws IllegalArgumentException 유효하지 않은 크론식
+   * @throws DuplicateDataException 중복 크론식 발견
+   */
+  private void validateSchedules(List<ScheduleCreateDto> schedules) {
+    if (schedules == null || schedules.isEmpty()) {
+      return;
+    }
+
+    // 중복 크론식 검사 (같은 요청 내에서)
+    Set<String> cronExpressions = new HashSet<>();
+
+    for (ScheduleCreateDto schedule : schedules) {
+      String cron = schedule.getCronExpression();
+
+      // 1. 크론 표현식 유효성 검증 (Quartz 기준)
+      if (!isValidCronExpression(cron)) {
+        throw new IllegalArgumentException("유효하지 않은 크론 표현식입니다: " + cron);
+      }
+
+      // 2. 중복 크론식 검사
+      if (cronExpressions.contains(cron)) {
+        throw new DuplicateDataException("중복된 크론 표현식이 있습니다: " + cron);
+      }
+      cronExpressions.add(cron);
+    }
+  }
+
+  /**
+   * Quartz 크론 표현식 유효성 검증
+   *
+   * @param cronExpression 검증할 크론 표현식
+   * @return 유효하면 true
+   */
+  private boolean isValidCronExpression(String cronExpression) {
+    try {
+      new CronExpression(cronExpression);
+      return true;
+    } catch (Exception e) {
+      log.warn("유효하지 않은 크론 표현식: {}", cronExpression, e);
+      return false;
+    }
+  }
+
+  /**
+   * 스케줄 목록 등록 (DB 저장 + Quartz 등록)
+   *
+   * <p>트랜잭션 내에서 DB 저장을 수행하고, Quartz 등록은 실패해도 워크플로우는 유지되도록 예외를 로그로만 처리합니다.
+   *
+   * @param workflowId 워크플로우 ID
+   * @param scheduleCreateDtos 등록할 스케줄 목록
+   * @param userId 생성자 ID
+   */
+  private void registerSchedules(
+      Long workflowId, List<ScheduleCreateDto> scheduleCreateDtos, Long userId) {
+    if (scheduleCreateDtos == null || scheduleCreateDtos.isEmpty()) {
+      return;
+    }
+
+    log.info("스케줄 등록 시작: Workflow ID {} - {}개", workflowId, scheduleCreateDtos.size());
+
+    int successCount = 0;
+    int failCount = 0;
+
+    for (ScheduleCreateDto dto : scheduleCreateDtos) {
+      try {
+        // 1. DTO → Model 변환
+        Schedule schedule = dto.toEntity(workflowId, userId);
+
+        // 2. DB 중복 체크 (같은 워크플로우 + 같은 크론식)
+        if (scheduleMapper.existsByWorkflowIdAndCronExpression(
+            workflowId, schedule.getCronExpression())) {
+          throw new DuplicateDataException(
+              "이미 동일한 크론식의 스케줄이 존재합니다: " + schedule.getCronExpression());
+        }
+
+        // 3. DB 저장
+        int insertResult = scheduleMapper.insertSchedule(schedule);
+        if (insertResult != 1) {
+          log.error("스케줄 DB 저장 실패: Workflow ID {} - {}", workflowId, schedule.getCronExpression());
+          failCount++;
+          continue;
+        }
+
+        // 4. Quartz 등록 (실시간 반영)
+        quartzScheduleService.addOrUpdateSchedule(schedule);
+
+        log.info(
+            "스케줄 등록 완료: Workflow ID {} - {} ({})",
+            workflowId,
+            schedule.getCronExpression(),
+            schedule.getScheduleText());
+        successCount++;
+
+      } catch (DuplicateDataException e) {
+        log.warn("스케줄 중복으로 등록 건너뜀: Workflow ID {} - {}", workflowId, dto.getCronExpression());
+        failCount++;
+        // 중복은 경고만 하고 계속 진행
+      } catch (Exception e) {
+        log.error("스케줄 등록 실패: Workflow ID {} - {}", workflowId, dto.getCronExpression(), e);
+        failCount++;
+        // 스케줄 등록 실패해도 워크플로우는 유지
+      }
+    }
+
+    log.info("스케줄 등록 완료: Workflow ID {} - 성공 {}개, 실패 {}개", workflowId, successCount, failCount);
+  }
 }
diff --git a/apps/user-service/src/main/resources/log4j2-production.yml b/apps/user-service/src/main/resources/log4j2-production.yml
index ae8e9aba..79d920fc 100644
--- a/apps/user-service/src/main/resources/log4j2-production.yml
+++ b/apps/user-service/src/main/resources/log4j2-production.yml
@@ -1,6 +1,7 @@
 Configuration:
   status: INFO
   name: production
+  monitorInterval: 30
 
   properties:
     property:
diff --git a/apps/user-service/src/main/resources/mybatis/mapper/ScheduleMapper.xml b/apps/user-service/src/main/resources/mybatis/mapper/ScheduleMapper.xml
index 80d6ffae..e89c06c9 100644
--- a/apps/user-service/src/main/resources/mybatis/mapper/ScheduleMapper.xml
+++ b/apps/user-service/src/main/resources/mybatis/mapper/ScheduleMapper.xml
@@ -2,6 +2,7 @@
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 
 <mapper namespace="site.icebang.domain.schedule.mapper.ScheduleMapper">
+    <!-- ResultMap 정의 -->
     <resultMap id="ScheduleResultMap" type="site.icebang.domain.schedule.model.Schedule">
         <id property="id" column="id"/>
         <result property="workflowId" column="workflow_id"/>
@@ -17,7 +18,98 @@
         <result property="scheduleText" column="schedule_text"/>
     </resultMap>
 
+    <!-- 활성화된 모든 스케줄 조회 -->
     <select id="findAllActive" resultMap="ScheduleResultMap">
         SELECT * FROM schedule WHERE is_active = true
     </select>
+
+    <!-- 새로운 스케줄 등록 -->
+    <insert id="insertSchedule" parameterType="site.icebang.domain.schedule.model.Schedule"
+            useGeneratedKeys="true" keyProperty="id">
+        INSERT INTO schedule (
+            workflow_id,
+            cron_expression,
+            parameters,
+            is_active,
+            schedule_text,
+            created_at,
+            created_by,
+            updated_at,
+            updated_by
+        ) VALUES (
+                     #{workflowId},
+                     #{cronExpression},
+                     #{parameters},
+                     #{isActive},
+                     #{scheduleText},
+                     UTC_TIMESTAMP(),
+                     #{createdBy},
+                     UTC_TIMESTAMP(),
+                     #{updatedBy}
+                 )
+    </insert>
+
+    <!-- 특정 워크플로우의 모든 활성 스케줄 조회 -->
+    <select id="findAllByWorkflowId" resultMap="ScheduleResultMap">
+        SELECT *
+        FROM schedule
+        WHERE workflow_id = #{workflowId}
+          AND is_active = true
+        ORDER BY id
+    </select>
+
+    <!-- 워크플로우 + 크론식 중복 확인 -->
+    <select id="existsByWorkflowIdAndCronExpression" resultType="boolean">
+        SELECT COUNT(*) > 0
+        FROM schedule
+        WHERE workflow_id = #{workflowId}
+          AND cron_expression = #{cronExpression}
+          AND is_active = true
+    </select>
+
+    <!-- 워크플로우 + 크론식으로 스케줄 조회 -->
+    <select id="findByWorkflowIdAndCronExpression" resultMap="ScheduleResultMap">
+        SELECT *
+        FROM schedule
+        WHERE workflow_id = #{workflowId}
+          AND cron_expression = #{cronExpression}
+          AND is_active = true
+            LIMIT 1
+    </select>
+
+    <!-- 스케줄 활성화 상태 변경 -->
+    <update id="updateActiveStatus">
+        UPDATE schedule
+        SET is_active = #{isActive},
+            updated_at = UTC_TIMESTAMP()
+        WHERE id = #{id}
+    </update>
+
+    <!-- 스케줄 정보 수정 -->
+    <update id="updateSchedule" parameterType="site.icebang.domain.schedule.model.Schedule">
+        UPDATE schedule
+        SET cron_expression = #{cronExpression},
+            schedule_text = #{scheduleText},
+            parameters = #{parameters},
+            is_active = #{isActive},
+            updated_at = UTC_TIMESTAMP(),
+            updated_by = #{updatedBy}
+        WHERE id = #{id}
+    </update>
+
+    <!-- 스케줄 삭제 (비활성화) -->
+    <update id="deleteSchedule">
+        UPDATE schedule
+        SET is_active = false,
+            updated_at = UTC_TIMESTAMP()
+        WHERE id = #{id}
+    </update>
+
+    <!-- 워크플로우의 모든 스케줄 비활성화 -->
+    <update id="deactivateAllByWorkflowId">
+        UPDATE schedule
+        SET is_active = false,
+            updated_at = UTC_TIMESTAMP()
+        WHERE workflow_id = #{workflowId}
+    </update>
 </mapper>
\ No newline at end of file
diff --git a/apps/user-service/src/test/java/site/icebang/e2e/scenario/WorkflowCreateFlowE2eTest.java b/apps/user-service/src/test/java/site/icebang/e2e/scenario/WorkflowCreateFlowE2eTest.java
index 3d5ca4b8..08088a8c 100644
--- a/apps/user-service/src/test/java/site/icebang/e2e/scenario/WorkflowCreateFlowE2eTest.java
+++ b/apps/user-service/src/test/java/site/icebang/e2e/scenario/WorkflowCreateFlowE2eTest.java
@@ -3,7 +3,9 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 import java.time.Instant;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 import org.junit.jupiter.api.DisplayName;
@@ -296,4 +298,283 @@ void createWorkflow_utc_time_validation() throws Exception {
 
     logCompletion("UTC 시간 기반 워크플로우 생성 검증 완료");
   }
+
+  @Test
+  @DisplayName("워크플로우 생성 시 단일 스케줄 등록 성공")
+  void createWorkflow_withSingleSchedule_success() {
+    performUserLogin();
+
+    logStep(1, "스케줄이 포함된 워크플로우 생성");
+
+    // 워크플로우 + 스케줄 요청 데이터 구성
+    Map<String, Object> workflowRequest = new HashMap<>();
+    workflowRequest.put("name", "매일 오전 9시 자동 실행 워크플로우");
+    workflowRequest.put("description", "매일 오전 9시에 자동으로 실행되는 워크플로우");
+    workflowRequest.put("search_platform", "naver");
+    workflowRequest.put("posting_platform", "naver_blog");
+    workflowRequest.put("posting_account_id", "test_account");
+    workflowRequest.put("posting_account_password", "test_password");
+    workflowRequest.put("is_enabled", true);
+
+    // 스케줄 정보 추가
+    List<Map<String, Object>> schedules = new ArrayList<>();
+    Map<String, Object> schedule = new HashMap<>();
+    schedule.put("cronExpression", "0 0 9 * * ?"); // 매일 오전 9시
+    schedule.put("scheduleText", "매일 오전 9시");
+    schedule.put("isActive", true);
+    schedules.add(schedule);
+
+    workflowRequest.put("schedules", schedules);
+
+    HttpHeaders headers = new HttpHeaders();
+    headers.setContentType(MediaType.APPLICATION_JSON);
+
+    HttpEntity<Map<String, Object>> entity = new HttpEntity<>(workflowRequest, headers);
+
+    logStep(2, "워크플로우 생성 요청 전송");
+    ResponseEntity<Map> response =
+        restTemplate.postForEntity(getV0ApiUrl("/workflows"), entity, Map.class);
+
+    logStep(3, "응답 검증");
+    assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
+    assertThat((Boolean) response.getBody().get("success")).isTrue();
+
+    logSuccess("스케줄이 포함된 워크플로우 생성 성공");
+    logDebug("응답: " + response.getBody());
+
+    logCompletion("단일 스케줄 등록 테스트 완료");
+  }
+
+  @Test
+  @DisplayName("워크플로우 생성 시 다중 스케줄 등록 성공")
+  void createWorkflow_withMultipleSchedules_success() {
+    performUserLogin();
+
+    logStep(1, "다중 스케줄이 포함된 워크플로우 생성");
+
+    // 워크플로우 기본 정보
+    Map<String, Object> workflowRequest = new HashMap<>();
+    workflowRequest.put("name", "다중 스케줄 워크플로우");
+    workflowRequest.put("description", "여러 시간대에 실행되는 워크플로우");
+    workflowRequest.put("search_platform", "naver");
+    workflowRequest.put("posting_platform", "naver_blog");
+    workflowRequest.put("posting_account_id", "test_multi");
+    workflowRequest.put("posting_account_password", "test_pass123");
+    workflowRequest.put("is_enabled", true);
+
+    // 다중 스케줄 정보 추가
+    List<Map<String, Object>> schedules = new ArrayList<>();
+
+    // 스케줄 1: 매일 오전 9시
+    Map<String, Object> schedule1 = new HashMap<>();
+    schedule1.put("cronExpression", "0 0 9 * * ?");
+    schedule1.put("scheduleText", "매일 오전 9시");
+    schedule1.put("isActive", true);
+    schedules.add(schedule1);
+
+    // 스케줄 2: 매일 오후 6시
+    Map<String, Object> schedule2 = new HashMap<>();
+    schedule2.put("cronExpression", "0 0 18 * * ?");
+    schedule2.put("scheduleText", "매일 오후 6시");
+    schedule2.put("isActive", true);
+    schedules.add(schedule2);
+
+    // 스케줄 3: 평일 오후 2시
+    Map<String, Object> schedule3 = new HashMap<>();
+    schedule3.put("cronExpression", "0 0 14 ? * MON-FRI");
+    schedule3.put("scheduleText", "평일 오후 2시");
+    schedule3.put("isActive", true);
+    schedules.add(schedule3);
+
+    workflowRequest.put("schedules", schedules);
+
+    HttpHeaders headers = new HttpHeaders();
+    headers.setContentType(MediaType.APPLICATION_JSON);
+
+    HttpEntity<Map<String, Object>> entity = new HttpEntity<>(workflowRequest, headers);
+
+    logStep(2, "워크플로우 생성 요청 전송 (3개 스케줄 포함)");
+    ResponseEntity<Map> response =
+        restTemplate.postForEntity(getV0ApiUrl("/workflows"), entity, Map.class);
+
+    logStep(3, "응답 검증");
+    assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
+    assertThat((Boolean) response.getBody().get("success")).isTrue();
+
+    logSuccess("다중 스케줄이 포함된 워크플로우 생성 성공");
+    logDebug("응답: " + response.getBody());
+
+    logCompletion("다중 스케줄 등록 테스트 완료");
+  }
+
+  @Test
+  @DisplayName("유효하지 않은 크론 표현식으로 스케줄 등록 시 실패")
+  void createWorkflow_withInvalidCronExpression_shouldFail() {
+    performUserLogin();
+
+    logStep(1, "잘못된 크론 표현식으로 워크플로우 생성 시도");
+
+    Map<String, Object> workflowRequest = new HashMap<>();
+    workflowRequest.put("name", "잘못된 크론식 테스트");
+    workflowRequest.put("search_platform", "naver");
+    workflowRequest.put("is_enabled", true);
+
+    // 잘못된 크론 표현식
+    List<Map<String, Object>> schedules = new ArrayList<>();
+    Map<String, Object> schedule = new HashMap<>();
+    schedule.put("cronExpression", "INVALID CRON"); // 잘못된 형식
+    schedule.put("scheduleText", "잘못된 스케줄");
+    schedule.put("isActive", true);
+    schedules.add(schedule);
+
+    workflowRequest.put("schedules", schedules);
+
+    HttpHeaders headers = new HttpHeaders();
+    headers.setContentType(MediaType.APPLICATION_JSON);
+
+    HttpEntity<Map<String, Object>> entity = new HttpEntity<>(workflowRequest, headers);
+
+    logStep(2, "워크플로우 생성 요청 전송");
+    ResponseEntity<Map> response =
+        restTemplate.postForEntity(getV0ApiUrl("/workflows"), entity, Map.class);
+
+    logStep(3, "에러 응답 검증");
+    assertThat(response.getStatusCode())
+        .isIn(
+            HttpStatus.BAD_REQUEST,
+            HttpStatus.UNPROCESSABLE_ENTITY,
+            HttpStatus.INTERNAL_SERVER_ERROR);
+
+    logSuccess("유효하지 않은 크론 표현식 검증 확인");
+    logDebug("에러 응답: " + response.getBody());
+
+    logCompletion("크론 표현식 검증 테스트 완료");
+  }
+
+  @Test
+  @DisplayName("중복된 크론 표현식으로 스케줄 등록 시 실패")
+  void createWorkflow_withDuplicateCronExpression_shouldFail() {
+    performUserLogin();
+
+    logStep(1, "중복된 크론식을 가진 워크플로우 생성 시도");
+
+    Map<String, Object> workflowRequest = new HashMap<>();
+    workflowRequest.put("name", "중복 크론식 테스트");
+    workflowRequest.put("search_platform", "naver");
+    workflowRequest.put("is_enabled", true);
+
+    // 동일한 크론 표현식을 가진 스케줄 2개
+    List<Map<String, Object>> schedules = new ArrayList<>();
+
+    Map<String, Object> schedule1 = new HashMap<>();
+    schedule1.put("cronExpression", "0 0 9 * * ?"); // 매일 오전 9시
+    schedule1.put("scheduleText", "매일 오전 9시 - 첫번째");
+    schedule1.put("isActive", true);
+    schedules.add(schedule1);
+
+    Map<String, Object> schedule2 = new HashMap<>();
+    schedule2.put("cronExpression", "0 0 9 * * ?"); // 동일한 크론식
+    schedule2.put("scheduleText", "매일 오전 9시 - 두번째");
+    schedule2.put("isActive", true);
+    schedules.add(schedule2);
+
+    workflowRequest.put("schedules", schedules);
+
+    HttpHeaders headers = new HttpHeaders();
+    headers.setContentType(MediaType.APPLICATION_JSON);
+
+    HttpEntity<Map<String, Object>> entity = new HttpEntity<>(workflowRequest, headers);
+
+    logStep(2, "워크플로우 생성 요청 전송");
+    ResponseEntity<Map> response =
+        restTemplate.postForEntity(getV0ApiUrl("/workflows"), entity, Map.class);
+
+    logStep(3, "중복 크론식 에러 검증");
+    assertThat(response.getStatusCode())
+        .isIn(HttpStatus.BAD_REQUEST, HttpStatus.CONFLICT, HttpStatus.INTERNAL_SERVER_ERROR);
+
+    logSuccess("중복 크론 표현식 검증 확인");
+    logDebug("에러 응답: " + response.getBody());
+
+    logCompletion("중복 크론식 검증 테스트 완료");
+  }
+
+  @Test
+  @DisplayName("스케줄 없이 워크플로우 생성 후 정상 작동 확인")
+  void createWorkflow_withoutSchedule_success() {
+    performUserLogin();
+
+    logStep(1, "스케줄 없이 워크플로우 생성");
+
+    Map<String, Object> workflowRequest = new HashMap<>();
+    workflowRequest.put("name", "스케줄 없는 워크플로우");
+    workflowRequest.put("description", "수동 실행 전용 워크플로우");
+    workflowRequest.put("search_platform", "naver");
+    workflowRequest.put("posting_platform", "naver_blog");
+    workflowRequest.put("posting_account_id", "manual_test");
+    workflowRequest.put("posting_account_password", "manual_pass");
+    workflowRequest.put("is_enabled", true);
+    // schedules 필드 없음
+
+    HttpHeaders headers = new HttpHeaders();
+    headers.setContentType(MediaType.APPLICATION_JSON);
+
+    HttpEntity<Map<String, Object>> entity = new HttpEntity<>(workflowRequest, headers);
+
+    logStep(2, "워크플로우 생성 요청 전송");
+    ResponseEntity<Map> response =
+        restTemplate.postForEntity(getV0ApiUrl("/workflows"), entity, Map.class);
+
+    logStep(3, "응답 검증");
+    assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
+    assertThat((Boolean) response.getBody().get("success")).isTrue();
+
+    logSuccess("스케줄 없는 워크플로우 생성 성공");
+    logDebug("응답: " + response.getBody());
+
+    logCompletion("스케줄 선택사항 테스트 완료");
+  }
+
+  @Test
+  @DisplayName("비활성화 스케줄로 워크플로우 생성 시 Quartz 미등록 확인")
+  void createWorkflow_withInactiveSchedule_shouldNotRegisterToQuartz() {
+    performUserLogin();
+
+    logStep(1, "비활성화 스케줄로 워크플로우 생성");
+
+    Map<String, Object> workflowRequest = new HashMap<>();
+    workflowRequest.put("name", "비활성화 스케줄 테스트");
+    workflowRequest.put("description", "DB에는 저장되지만 Quartz에는 등록되지 않음");
+    workflowRequest.put("search_platform", "naver");
+    workflowRequest.put("is_enabled", true);
+
+    // 비활성화 스케줄
+    List<Map<String, Object>> schedules = new ArrayList<>();
+    Map<String, Object> schedule = new HashMap<>();
+    schedule.put("cronExpression", "0 0 10 * * ?");
+    schedule.put("scheduleText", "매일 오전 10시 (비활성)");
+    schedule.put("isActive", false); // 비활성화
+    schedules.add(schedule);
+
+    workflowRequest.put("schedules", schedules);
+
+    HttpHeaders headers = new HttpHeaders();
+    headers.setContentType(MediaType.APPLICATION_JSON);
+
+    HttpEntity<Map<String, Object>> entity = new HttpEntity<>(workflowRequest, headers);
+
+    logStep(2, "워크플로우 생성 요청 전송");
+    ResponseEntity<Map> response =
+        restTemplate.postForEntity(getV0ApiUrl("/workflows"), entity, Map.class);
+
+    logStep(3, "응답 검증 - DB 저장은 성공하지만 Quartz 미등록");
+    assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
+    assertThat((Boolean) response.getBody().get("success")).isTrue();
+
+    logSuccess("비활성화 스케줄로 워크플로우 생성 성공");
+    logDebug("응답: " + response.getBody());
+    logDebug("비활성화 스케줄은 DB에 저장되지만 Quartz에는 등록되지 않음");
+
+    logCompletion("비활성화 스케줄 테스트 완료");
+  }
 }
diff --git a/docker/production-fastapi/docker-compose.yml b/docker/production-fastapi/docker-compose.yml
index 76b0b85c..0f6e3a2b 100644
--- a/docker/production-fastapi/docker-compose.yml
+++ b/docker/production-fastapi/docker-compose.yml
@@ -11,6 +11,7 @@ services:
       - ~/app/blogger:/app/blogger
       - ~/app/models:/app/models
       - logs_volume:/logs
+      - ~/app/key:/app/key
     depends_on:
       - promtail
     env_file:
diff --git a/docker/production/docker-compose.yml b/docker/production/docker-compose.yml
index 6d9a3c10..35ecb706 100644
--- a/docker/production/docker-compose.yml
+++ b/docker/production/docker-compose.yml
@@ -32,6 +32,7 @@ services:
       - SPRING_PROFILES_ACTIVE=production
     volumes:
       - logs_volume:/logs
+      - ./config:/app/config:ro
 
   # Grafana Agent만으로 메트릭 수집 + 전송
   grafana-agent: