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
new file mode 100644
index 00000000..29ce12b7
--- /dev/null
+++ b/apps/pre-processing-service/app/service/blog/blog_create_service.py
@@ -0,0 +1,345 @@
+import json
+import logging
+import os
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+
+from openai import OpenAI
+from dotenv import load_dotenv
+
+from app.model.schemas import RequestBlogCreate
+from app.errors.BlogPostingException import *
+
+# 환경변수 로드
+load_dotenv(".env.dev")
+
+
+class BlogContentService:
+    """RAG를 사용한 블로그 콘텐츠 생성 전용 서비스"""
+
+    def __init__(self):
+        # OpenAI API 키 설정
+        self.openai_api_key = os.getenv("OPENAI_API_KEY")
+        if not self.openai_api_key:
+            raise ValueError("OPENAI_API_KEY가 .env.dev 파일에 설정되지 않았습니다.")
+
+        # 인스턴스 레벨에서 클라이언트 생성
+        self.client = OpenAI(api_key=self.openai_api_key)
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
+
+    def generate_blog_content(self, request: RequestBlogCreate) -> Dict[str, Any]:
+        """
+        요청 데이터를 기반으로 블로그 콘텐츠 생성
+
+        Args:
+            request: RequestBlogCreate 객체
+
+        Returns:
+            Dict: {"title": str, "content": str, "tags": List[str]} 형태의 결과
+        """
+        try:
+            # 1. 콘텐츠 정보 정리
+            content_context = self._prepare_content_context(request)
+
+            # 2. 프롬프트 생성
+            prompt = self._create_content_prompt(content_context, request)
+
+            # 3. GPT를 통한 콘텐츠 생성
+            generated_content = self._generate_with_openai(prompt)
+
+            # 4. 콘텐츠 파싱 및 구조화
+            return self._parse_generated_content(generated_content, request)
+
+        except Exception as e:
+            self.logger.error(f"콘텐츠 생성 실패: {e}")
+            return self._create_fallback_content(request)
+
+    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']:,}원")
+
+            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"]
+                if isinstance(specs, dict):
+                    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개만
+                    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"
+            ):
+                url = request.product_info.get("url") or request.product_info.get(
+                    "product_url"
+                )
+                context_parts.append(f"- 구매 링크: {url}")
+
+        return "\n".join(context_parts) if context_parts else "키워드 기반 콘텐츠 생성"
+
+    def _create_content_prompt(self, context: str, request: RequestBlogCreate) -> str:
+        """콘텐츠 생성용 프롬프트 생성"""
+
+        # 기본 키워드가 없으면 상품 제목에서 추출
+        main_keyword = request.keyword
+        if (
+            not main_keyword
+            and request.product_info
+            and request.product_info.get("title")
+        ):
+            main_keyword = request.product_info["title"]
+
+        prompt = f"""
+다음 정보를 바탕으로 매력적인 블로그 포스트를 작성해주세요.
+
+정보:
+{context}
+
+작성 가이드라인:
+- 스타일: 친근하면서도 신뢰할 수 있는, 정보 제공 중심
+- 길이: 1200자 내외의 적당한 길이
+- 톤: 독자의 관심을 끄는 자연스러운 어조
+
+작성 요구사항:
+1. SEO 친화적이고 클릭하고 싶은 매력적인 제목
+2. 독자의 관심을 끄는 도입부
+3. 핵심 특징과 장점을 구체적으로 설명
+4. 실제 사용 시나리오나 활용 팁
+5. 구매 결정에 도움이 되는 정보
+
+⚠️ 주의:
+- 절대로 마지막에 'HTML 구조는…' 같은 자기 평가 문장을 추가하지 마세요.
+- 출력 시 ```나 ```html 같은 코드 블록 구문을 포함하지 마세요.
+- 오직 HTML 태그만 사용하여 구조화된 콘텐츠를 작성해주세요.
+(예: <h2>, <h3>, <p>, <ul>, <li> 등)
+"""
+
+        return prompt
+
+    def _generate_with_openai(self, prompt: str) -> str:
+        """OpenAI API를 통한 콘텐츠 생성"""
+        try:
+            response = self.client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "당신은 전문적인 블로그 콘텐츠 작성자입니다. 상품 리뷰와 정보성 콘텐츠를 매력적이고 SEO 친화적으로 작성합니다.",
+                    },
+                    {"role": "user", "content": prompt},
+                ],
+                temperature=0.7,
+                max_tokens=2000,
+            )
+
+            return response.choices[0].message.content
+
+        except Exception as e:
+            self.logger.error(f"OpenAI API 호출 실패: {e}")
+            raise
+
+    def _parse_generated_content(
+        self, content: str, request: RequestBlogCreate
+    ) -> Dict[str, Any]:
+        """생성된 콘텐츠를 파싱하여 구조화"""
+
+        # 제목 추출 (첫 번째 h1이나 강조된 줄)
+        lines = content.strip().split("\n")
+        title = "블로그 포스트"  # 기본값
+
+        for line in lines[:10]:  # 처음 10줄에서 제목 찾기
+            clean_line = (
+                line.strip()
+                .replace("#", "")
+                .replace("<h1>", "")
+                .replace("</h1>", "")
+                .replace("<h2>", "")
+                .replace("</h2>", "")
+            )
+            if clean_line and len(clean_line) > 5 and len(clean_line) < 100:
+                title = clean_line
+                break
+
+        # 키워드가 있으면 제목에 없을 경우 기본 제목 생성
+        if request.keyword and request.keyword not in title:
+            if request.product_info and request.product_info.get("title"):
+                title = (
+                    f"{request.product_info['title']} - {request.keyword} 완벽 가이드"
+                )
+            else:
+                title = f"{request.keyword} - 완벽 가이드"
+
+        # 태그 생성
+        tags = self._generate_tags(request)
+
+        return {"title": title, "content": content, "tags": tags}
+
+    def _generate_tags(self, request: RequestBlogCreate) -> List[str]:
+        """요청 정보 기반 태그 생성"""
+        tags = []
+
+        # 키워드 추가
+        if request.keyword:
+            tags.append(request.keyword)
+
+        # 상품 정보에서 태그 추출
+        if request.product_info:
+            # 상품명에서 키워드 추출
+            if request.product_info.get("title"):
+                title = request.product_info["title"].lower()
+
+                # 일반적인 제품 카테고리 태그
+                if any(word in title for word in ["iphone", "아이폰", "phone"]):
+                    tags.extend(["아이폰", "스마트폰"])
+                if any(word in title for word in ["필름", "보호", "강화"]):
+                    tags.extend(["보호필름", "강화필름"])
+                if any(word in title for word in ["케이스", "커버"]):
+                    tags.extend(["폰케이스", "액세서리"])
+                if any(word in title for word in ["노트북", "laptop"]):
+                    tags.extend(["노트북", "컴퓨터"])
+                if any(word in title for word in ["마우스", "키보드"]):
+                    tags.extend(["컴퓨터용품", "PC액세서리"])
+
+            # 재료/사양 정보에서 태그 생성
+            if request.product_info.get("material_info"):
+                material_info = request.product_info["material_info"]
+                if isinstance(material_info, dict):
+                    for key, value in material_info.items():
+                        if value and len(str(value).strip()) <= 20:
+                            clean_value = str(value).strip()
+                            if clean_value not in tags:
+                                tags.append(clean_value)
+
+        # 기본 태그 추가
+        if not tags:
+            tags = ["상품정보", "리뷰"]
+
+        # 중복 제거 및 개수 제한
+        unique_tags = []
+        for tag in tags:
+            if tag not in unique_tags and len(unique_tags) < 10:
+                unique_tags.append(tag)
+
+        return unique_tags
+
+    def _create_fallback_content(self, request: RequestBlogCreate) -> Dict[str, Any]:
+        """콘텐츠 생성 실패 시 대안 콘텐츠 생성"""
+
+        if request.product_info and request.product_info.get("title"):
+            title = f"{request.product_info['title']} - 상품 정보 및 구매 가이드"
+            product_name = request.product_info["title"]
+        elif request.keyword:
+            title = f"{request.keyword} - 완벽 가이드"
+            product_name = request.keyword
+        else:
+            title = "상품 정보 및 구매 가이드"
+            product_name = "상품"
+
+        content = f"""
+<h1>{title}</h1>
+
+<h2>상품 소개</h2>
+<p>{product_name}에 대한 상세한 정보를 소개합니다.</p>
+
+<h2>주요 특징</h2>
+<ul>
+<li>고품질의 제품으로 신뢰할 수 있는 브랜드입니다</li>
+<li>합리적인 가격으로 가성비가 뛰어납니다</li>
+<li>사용자 친화적인 디자인과 기능을 제공합니다</li>
+</ul>
+"""
+
+        if request.product_info:
+            if request.product_info.get("price"):
+                content += f"<h2>가격 정보</h2>\n<p>판매가: <strong>{request.product_info['price']:,}원</strong></p>\n"
+
+            if request.product_info.get("material_info"):
+                content += "<h2>상품 사양</h2>\n<ul>\n"
+                for key, value in request.product_info["material_info"].items():
+                    content += f"<li><strong>{key}:</strong> {value}</li>\n"
+                content += "</ul>\n"
+
+        content += """
+<h2>구매 안내</h2>
+<p>신중한 검토를 통해 만족스러운 구매 결정을 내리시기 바랍니다.</p>
+"""
+
+        return {
+            "title": title,
+            "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/product_blog_posting_service.py b/apps/pre-processing-service/app/service/product_blog_posting_service.py
deleted file mode 100644
index 129c4666..00000000
--- a/apps/pre-processing-service/app/service/product_blog_posting_service.py
+++ /dev/null
@@ -1,387 +0,0 @@
-import json
-import logging
-import os
-from datetime import datetime
-from typing import Dict, List, Optional, Any
-from dataclasses import dataclass
-from enum import Enum
-
-from openai import OpenAI
-from dotenv import load_dotenv
-
-from app.service.blog.blogger_blog_post_adapter import BloggerBlogPostAdapter
-from app.errors.BlogPostingException import *
-
-# 환경변수 로드
-load_dotenv(".env.dev")
-
-client = OpenAI()
-
-
-class PostingStatus(Enum):
-    PENDING = "pending"
-    PROCESSING = "processing"
-    SUCCESS = "success"
-    FAILED = "failed"
-    RETRY = "retry"
-
-
-@dataclass
-class ProductData:
-    """크롤링된 상품 데이터 모델"""
-
-    tag: str
-    product_url: str
-    title: str
-    price: int
-    rating: float
-    options: List[Dict[str, Any]]
-    material_info: Dict[str, str]
-    product_images: List[str]
-    crawled_at: str
-
-    @classmethod
-    def from_dict(cls, data: Dict) -> "ProductData":
-        """딕셔너리에서 ProductData 객체 생성"""
-        product_detail = data.get("product_detail", {})
-        return cls(
-            tag=data.get("tag", ""),
-            product_url=product_detail.get("url", ""),
-            title=product_detail.get("title", ""),
-            price=product_detail.get("price", 0),
-            rating=product_detail.get("rating", 0.0),
-            options=product_detail.get("options", []),
-            material_info=product_detail.get("material_info", {}),
-            product_images=product_detail.get("product_images", []),
-            crawled_at=data.get("crawled_at", ""),
-        )
-
-
-@dataclass
-class BlogPostContent:
-    """생성된 블로그 포스트 콘텐츠"""
-
-    title: str
-    content: str
-    tags: List[str]
-
-
-@dataclass
-class BlogContentRequest:
-    """블로그 콘텐츠 생성 요청"""
-
-    content_style: str = "informative"  # "informative", "promotional", "review"
-    target_keywords: List[str] = None
-    include_pricing: bool = True
-    include_specifications: bool = True
-    content_length: str = "medium"  # "short", "medium", "long"
-
-
-class ProductContentGenerator:
-    """GPT를 활용한 상품 블로그 콘텐츠 생성"""
-
-    def __init__(self):
-        # 환경변수에서 OpenAI API 키 로드
-        self.openai_api_key = os.getenv("OPENAI_API_KEY")
-        if not self.openai_api_key:
-            raise ValueError("OPENAI_API_KEY가 .env.dev 파일에 설정되지 않았습니다.")
-
-        client.api_key = self.openai_api_key
-
-    def generate_blog_content(
-        self, product_data: ProductData, request: BlogContentRequest
-    ) -> BlogPostContent:
-        """상품 데이터를 기반으로 블로그 콘텐츠 생성"""
-
-        # 1. 상품 정보 정리
-        product_info = self._format_product_info(product_data, request)
-
-        # 2. 프롬프트 생성
-        prompt = self._create_blog_prompt(product_info, request)
-
-        # 3. GPT를 통한 콘텐츠 생성
-        try:
-
-            response = client.chat.completions.create(
-                model="gpt-4o-mini",
-                messages=[
-                    {
-                        "role": "system",
-                        "content": "당신은 전문적인 블로그 콘텐츠 작성자입니다. 상품 리뷰와 정보성 콘텐츠를 매력적이고 SEO 친화적으로 작성합니다.",
-                    },
-                    {"role": "user", "content": prompt},
-                ],
-                temperature=0.7,
-                max_tokens=2000,
-            )
-
-            generated_content = response.choices[0].message.content
-
-            # 4. 콘텐츠 파싱 및 구조화
-            return self._parse_generated_content(
-                generated_content, product_data, request
-            )
-
-        except Exception as e:
-            logging.error(f"콘텐츠 생성 실패: {e}")
-            return self._create_fallback_content(product_data, request)
-
-    def _format_product_info(
-        self, product_data: ProductData, request: BlogContentRequest
-    ) -> str:
-        """상품 정보를 텍스트로 포맷팅"""
-        info_parts = [
-            f"상품명: {product_data.title}",
-        ]
-
-        # 가격 정보 추가
-        if request.include_pricing and product_data.price:
-            info_parts.append(f"가격: {product_data.price:,}원")
-
-        # 평점 정보 추가
-        if product_data.rating:
-            info_parts.append(f"평점: {product_data.rating}/5.0")
-
-        # 사양 정보 추가
-        if request.include_specifications and product_data.material_info:
-            info_parts.append("\n상품 사양:")
-            for key, value in product_data.material_info.items():
-                info_parts.append(f"- {key}: {value}")
-
-        # 옵션 정보 추가
-        if product_data.options:
-            info_parts.append(f"\n구매 옵션 ({len(product_data.options)}개):")
-            for i, option in enumerate(product_data.options[:5], 1):  # 처음 5개만
-                info_parts.append(f"{i}. {option.get('name', 'N/A')}")
-
-        # 구매 링크
-        if product_data.product_url:
-            info_parts.append(f"\n구매 링크: {product_data.product_url}")
-
-        return "\n".join(info_parts)
-
-    def _create_blog_prompt(
-        self, product_info: str, request: BlogContentRequest
-    ) -> str:
-        """블로그 작성용 프롬프트 생성"""
-
-        # 스타일별 가이드라인
-        style_guidelines = {
-            "informative": "객관적이고 상세한 정보 제공 중심으로, 독자가 제품을 이해할 수 있도록 전문적으로 작성",
-            "promotional": "제품의 장점과 매력을 강조하며, 구매 의욕을 자극할 수 있도록 매력적으로 작성",
-            "review": "실제 사용 경험을 바탕으로 한 솔직한 평가와 추천 중심으로 작성",
-        }
-
-        # 길이별 가이드라인
-        length_guidelines = {
-            "short": "800자 내외의 간결한 내용",
-            "medium": "1200자 내외의 적당한 길이",
-            "long": "1500자 이상의 상세한 내용",
-        }
-
-        style_guide = style_guidelines.get(
-            request.content_style, style_guidelines["informative"]
-        )
-        length_guide = length_guidelines.get(
-            request.content_length, length_guidelines["medium"]
-        )
-
-        # 키워드 정보
-        keywords_text = ""
-        if request.target_keywords:
-            keywords_text = f"\n포함할 키워드: {', '.join(request.target_keywords)}"
-
-        prompt = f"""
-다음 상품 정보를 바탕으로 매력적인 블로그 포스트를 작성해주세요.
-
-상품 정보:
-{product_info}
-
-작성 가이드라인:
-- 스타일: {style_guide}
-- 길이: {length_guide}
-- 톤: 친근하면서도 신뢰할 수 있는, 정보 제공 중심{keywords_text}
-
-작성 요구사항:
-1. SEO 친화적이고 클릭하고 싶은 매력적인 제목
-2. 독자의 관심을 끄는 도입부
-3. 상품의 핵심 특징과 장점을 구체적으로 설명
-4. 실제 사용 시나리오나 활용 팁
-5. 구매 결정에 도움이 되는 정보
-
-⚠️ 주의:
-- 절대로 마지막에 '이 HTML 구조는…' 같은 자기 평가 문장을 추가하지 마세요.
-- 출력 시 ```나 ```html 같은 코드 블록 구문을 포함하지 마세요.
-- 오직 HTML 태그만 사용하여 구조화된 콘텐츠를 작성해주세요.
-(예: <h2>, <h3>, <p>, <ul>, <li> 등)
-"""
-
-        return prompt
-
-    def _parse_generated_content(
-        self, content: str, product_data: ProductData, request: BlogContentRequest
-    ) -> BlogPostContent:
-        """생성된 콘텐츠를 파싱하여 구조화"""
-
-        # 제목 추출 (첫 번째 h1이나 강조된 줄)
-        lines = content.strip().split("\n")
-        title = product_data.title  # 기본값
-
-        for line in lines[:10]:  # 처음 10줄에서 제목 찾기
-            clean_line = (
-                line.strip().replace("#", "").replace("<h1>", "").replace("</h1>", "")
-            )
-            if (
-                clean_line
-                and len(clean_line) > 5
-                and ("제목" in line or "<h1>" in line or line.startswith("#"))
-            ):
-                title = clean_line
-                break
-            elif clean_line and len(clean_line) > 10 and len(clean_line) < 100:
-                # 적당한 길이의 첫 번째 줄을 제목으로
-                title = clean_line
-                break
-
-        # 태그 생성
-        tags = self._generate_tags_from_product(product_data, request)
-
-        return BlogPostContent(title=title, content=content, tags=tags)
-
-    def _generate_tags_from_product(
-        self, product_data: ProductData, request: BlogContentRequest
-    ) -> List[str]:
-        """상품 정보 기반 태그 생성"""
-        tags = []
-
-        # 사용자 지정 키워드가 있으면 우선 추가
-        if request.target_keywords:
-            tags.extend(request.target_keywords[:5])
-
-        # 기본 태그 추가
-        if product_data.tag:
-            tags.append(product_data.tag)
-
-        # 제품 타입 추론해서 태그 추가
-        title_lower = product_data.title.lower()
-        if any(word in title_lower for word in ["iphone", "아이폰", "phone"]):
-            tags.extend(["아이폰", "스마트폰"])
-        if any(word in title_lower for word in ["필름", "보호", "강화"]):
-            tags.extend(["보호필름", "강화필름"])
-        if any(word in title_lower for word in ["케이스", "커버"]):
-            tags.extend(["폰케이스", "액세서리"])
-
-        # 재료 정보에서 태그 생성
-        if product_data.material_info:
-            for key, value in product_data.material_info.items():
-                if value and len(value.strip()) <= 20:  # 너무 긴 값은 제외
-                    clean_value = value.strip()
-                    if clean_value not in tags:
-                        tags.append(clean_value)
-
-        # 중복 제거 및 개수 제한
-        unique_tags = []
-        for tag in tags:
-            if tag not in unique_tags and len(unique_tags) < 10:
-                unique_tags.append(tag)
-
-        return unique_tags
-
-    def _create_fallback_content(
-        self, product_data: ProductData, request: BlogContentRequest
-    ) -> BlogPostContent:
-        """콘텐츠 생성 실패 시 대안 콘텐츠 생성"""
-        title = f"{product_data.title} - 상품 정보 및 구매 가이드"
-
-        content = f"""
-<h1>{product_data.title}</h1>
-
-<h2>상품 소개</h2>
-<p>{product_data.title}에 대한 상세한 정보를 소개합니다.</p>
-
-<h2>가격 정보</h2>
-<p>판매가: <strong>{product_data.price:,}원</strong></p>
-"""
-
-        if product_data.material_info:
-            content += "<h2>상품 사양</h2>\n<ul>\n"
-            for key, value in product_data.material_info.items():
-                content += f"<li><strong>{key}:</strong> {value}</li>\n"
-            content += "</ul>\n"
-
-        if product_data.options:
-            content += f"<h2>구매 옵션 ({len(product_data.options)}가지)</h2>\n<ul>\n"
-            for option in product_data.options[:5]:
-                content += f"<li>{option.get('name', 'N/A')}</li>\n"
-            content += "</ul>\n"
-
-        content += f"""
-<h2>구매 안내</h2>
-<p>상품 구매는 <a href="{product_data.product_url}" target="_blank">여기</a>에서 가능합니다.</p>
-"""
-
-        return BlogPostContent(
-            title=title,
-            content=content,
-            tags=[product_data.tag] if product_data.tag else ["상품정보"],
-        )
-
-
-class ProductBlogPostingService:
-    """상품 데이터를 Blogger에 포스팅하는 메인 서비스"""
-
-    def __init__(self):
-        self.content_generator = ProductContentGenerator()
-        self.blogger_service = BloggerBlogPostAdapter()
-
-    def post_product_to_blogger(
-        self, product_data: ProductData, request: BlogContentRequest
-    ) -> dict:
-        """상품 데이터를 Blogger에 포스팅"""
-        try:
-            # 1. GPT를 통한 콘텐츠 생성
-            blog_content = self.content_generator.generate_blog_content(
-                product_data, request
-            )
-
-            # 2. Blogger에 포스팅
-            self.blogger_service.post_content(
-                title=blog_content.title,
-                content=blog_content.content,
-                tags=blog_content.tags,
-            )
-
-            # 3. 성공 결과 반환
-            return {
-                "status": "success",
-                "platform": "blogger",
-                "title": blog_content.title,
-                "tags": blog_content.tags,
-                "posted_at": datetime.now().isoformat(),
-                "product_tag": product_data.tag,
-            }
-
-        except Exception as e:
-            logging.error(f"Blogger 포스팅 실패: {e}")
-            # ProductData 객체 기준으로 처리
-            return {
-                "status": "failed",
-                "error": str(e),
-                "platform": "blogger",
-                "attempted_at": datetime.now().isoformat(),
-                "product_tag": getattr(product_data, "tag", "unknown"),
-            }
-
-    # def batch_post_products(self, products_data: List[Dict], request: BlogContentRequest) -> List[Dict[str, Any]]:
-    #     """여러 상품을 일괄 포스팅"""
-    #     results = []
-    #
-    #     for product_data in products_data:
-    #         result = self.post_product_to_blogger(product_data, request)
-    #         results.append(result)
-    #
-    #         # API 호출 제한을 고려한 딜레이
-    #         import time
-    #         time.sleep(3)  # 3초 대기
-    #
-    #     return results
diff --git a/apps/pre-processing-service/app/test/test_blog_create_service.py b/apps/pre-processing-service/app/test/test_blog_create_service.py
new file mode 100644
index 00000000..d32e4e9e
--- /dev/null
+++ b/apps/pre-processing-service/app/test/test_blog_create_service.py
@@ -0,0 +1,83 @@
+import unittest
+from unittest.mock import patch, MagicMock
+
+from app.service.blog.blog_create_service import BlogContentService
+from app.model.schemas import RequestBlogCreate
+
+
+class TestBlogContentGeneration(unittest.TestCase):
+    """블로그 콘텐츠 생성 핵심 로직 테스트"""
+
+    @patch.dict("os.environ", {"OPENAI_API_KEY": "test-key"})
+    @patch("app.service.blog.blog_create_service.OpenAI")
+    def setUp(self, mock_openai_class):
+        """테스트 설정 - OpenAI Mock 적용"""
+        # Mock OpenAI 클라이언트 설정
+        self.mock_client = MagicMock()
+        mock_openai_class.return_value = self.mock_client
+
+        # 서비스 인스턴스 생성
+        self.service = BlogContentService()
+
+    def test_generate_blog_content_success(self):
+        """정상적인 콘텐츠 생성 테스트"""
+        # Mock 응답 설정
+        mock_choice = MagicMock()
+        mock_choice.message.content = """<h1>아이폰 15 케이스 완벽 가이드</h1>
+<h2>제품 소개</h2>
+<p>이 케이스는 뛰어난 보호 성능을 제공합니다.</p>"""
+
+        mock_response = MagicMock()
+        mock_response.choices = [mock_choice]
+
+        self.mock_client.chat.completions.create.return_value = mock_response
+
+        # 테스트 요청
+        request = RequestBlogCreate(
+            keyword="아이폰 케이스",
+            product_info={"title": "아이폰 15 투명 케이스", "price": 25000},
+        )
+
+        # 실행
+        result = self.service.generate_blog_content(request)
+
+        # 검증
+        self.assertIn("title", result)
+        self.assertIn("content", result)
+        self.assertIn("tags", result)
+        # 실제 파싱 로직에 따른 제목 검증 (키워드가 제목에 포함되지 않아 기본 제목 생성됨)
+        self.assertEqual(
+            result["title"], "아이폰 15 투명 케이스 - 아이폰 케이스 완벽 가이드"
+        )
+        self.assertIn("<h1>", result["content"])
+        self.assertIn("아이폰 케이스", result["tags"])
+
+    def test_generate_blog_content_api_failure(self):
+        """API 실패 시 폴백 콘텐츠 생성 테스트"""
+        # API 실패 시뮬레이션
+        self.mock_client.chat.completions.create.side_effect = Exception("API Error")
+
+        request = RequestBlogCreate(keyword="테스트 키워드")
+
+        # 실행
+        result = self.service.generate_blog_content(request)
+
+        # 폴백 콘텐츠 검증
+        self.assertIn("title", result)
+        self.assertIn("content", result)
+        self.assertIn("tags", result)
+        self.assertEqual(result["title"], "테스트 키워드 - 완벽 가이드")
+
+    def test_generate_blog_content_minimal_input(self):
+        """최소한의 입력으로 콘텐츠 생성 테스트"""
+        # API 실패 시뮬레이션
+        self.mock_client.chat.completions.create.side_effect = Exception("API Error")
+
+        request = RequestBlogCreate()
+
+        result = self.service.generate_blog_content(request)
+
+        # 기본 콘텐츠 생성 확인
+        self.assertEqual(result["title"], "상품 정보 및 구매 가이드")
+        self.assertIn("<h1>", result["content"])
+        self.assertEqual(result["tags"], ["상품정보", "리뷰"])
diff --git a/apps/pre-processing-service/app/test/test_product_blog_posting_service.py b/apps/pre-processing-service/app/test/test_product_blog_posting_service.py
deleted file mode 100644
index c5b1efde..00000000
--- a/apps/pre-processing-service/app/test/test_product_blog_posting_service.py
+++ /dev/null
@@ -1,87 +0,0 @@
-import pytest
-from app.service.product_blog_posting_service import (
-    ProductBlogPostingService,
-    BlogContentRequest,
-    ProductData,
-)
-
-# 샘플 데이터
-sample_product_data = {
-    "tag": "test001",
-    "product_url": "https://ssadagu.kr/shop/view.php?platform=1688&num_iid=902500949447",
-    "status": "success",
-    "product_detail": {
-        "url": "https://ssadagu.kr/shop/view.php?platform=1688&num_iid=902500949447",
-        "title": "코닝 적용 가능한 애플 13 강화 필름 iphone16/15promax 휴대 전화 필름 애플 11 안티-peep 및 먼지없는 빈",
-        "price": 430,
-        "rating": 5.0,
-        "options": [
-            {"name": "먼지 없는 창고 2차 필름 [코닝글라스 방폭丨초투명]", "stock": 0},
-            {
-                "name": "먼지 없는 창고 2차 필름 [코닝글라스 방폭丨훔쳐보기 방지]",
-                "stock": 0,
-            },
-        ],
-        "material_info": {
-            "상표": "다른",
-            "재료": "강화 유리",
-            "필름 종류": "전막",
-            "크기": "애플 16프로맥스( 6.9inch )",
-            "적용 모델": "iPhone13 Pro Max",
-        },
-        "product_images": [],
-    },
-    "crawled_at": "2025-09-16 11:49:24",
-}
-
-
-@pytest.fixture
-def blog_service():
-    return ProductBlogPostingService()
-
-
-def test_generate_blog_content(blog_service):
-    """GPT를 통한 블로그 콘텐츠 생성 테스트"""
-    request = BlogContentRequest(
-        content_style="informative",
-        target_keywords=["아이폰", "강화필름", "보호필름", "스마트폰액세서리"],
-        include_pricing=True,
-        content_length="medium",
-    )
-
-    product_obj = ProductData.from_dict(sample_product_data)
-
-    # 순수 콘텐츠 생성만 테스트
-    blog_content = blog_service.content_generator.generate_blog_content(
-        product_obj, request
-    )
-
-    assert blog_content.title
-    assert "<h2>" in blog_content.content
-    assert len(blog_content.tags) > 0
-
-
-def test_post_product_to_blogger(blog_service, monkeypatch):
-    """Blogger 포스팅 테스트 (실제 API 호출을 막고 mock)"""
-
-    class MockBloggerAdapter:
-        def post_content(self, title, content, tags):
-            return {"mock": True}
-
-    monkeypatch.setattr(blog_service, "blogger_service", MockBloggerAdapter())
-
-    request = BlogContentRequest(
-        content_style="informative",
-        target_keywords=["아이폰", "강화필름", "보호필름", "스마트폰액세서리"],
-        include_pricing=True,
-        content_length="medium",
-    )
-
-    product_obj = ProductData.from_dict(sample_product_data)
-
-    result = blog_service.post_product_to_blogger(product_obj, request)
-
-    assert result["status"] == "success"
-    assert result["platform"] == "blogger"
-    assert "title" in result
-    assert "tags" in result
diff --git a/apps/pre-processing-service/app/utils/llm_extractor.py b/apps/pre-processing-service/app/utils/llm_extractor.py
index 4263a270..3fb200a5 100644
--- a/apps/pre-processing-service/app/utils/llm_extractor.py
+++ b/apps/pre-processing-service/app/utils/llm_extractor.py
@@ -4,6 +4,7 @@
 
 load_dotenv()
 
+
 class LLMExtractor:
 
     def __init__(self, model="gpt-4o"):