AI 아키텍처 모듈화 설계
프로젝트: Devths AI 취업 도우미
작성일: 2026-01-13
버전: v1.6
마지막 업데이트: 2026-01-26
업데이트 기록
| 날짜 |
버전 |
변경 내용 |
작성자 |
| 2026-01-26 |
v1.6 |
백엔드 회의 후 API 5개 구조로 재정리, 모듈 구조 업데이트 |
AI 팀 |
| 2026-01-13 |
v1.0 |
모듈화 설계 완료 |
AI 팀 |
| 2026-01-10 |
v0.9 |
5개 API로 통합 반영 |
AI 팀 |
| 2026-01-08 |
v0.8 |
초기 아키텍처 설계 |
AI 팀 |
목차
아키텍처 설계
모듈화 효과
1. 전체 아키텍처 개요
시스템 구성도
┌─────────────────────────────────────────────────────────────────────────────┐
│ Frontend (Web) │
│ Next.js / React │
└─────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ Backend (Spring Boot) │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Auth API │ │ Resume API │ │ Interview │ │ Calendar │ │
│ │ │ │ │ │ API │ │ API │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ AI Server (FastAPI) │
│ │
│ ┌───────────────────────────────────────────────────────────────────────┐ │
│ │ 5개 API 엔드포인트 │ │
│ ├───────────────────────────────────────────────────────────────────────┤ │
│ │ 1. POST /ai/text/extract - OCR + 임베딩 + 분석 (비동기) │ │
│ │ 2. POST /ai/chat - 채팅 (general/interview/report) │ │
│ │ 3. POST /ai/calendar/parse - 캘린더 일정 파싱 (동기) │ │
│ │ 4. POST /ai/masking/draft - 개인정보 마스킹 (비동기) │ │
│ │ 5. GET /ai/task/{task_id} - 비동기 작업 상태 조회 │ │
│ └───────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Text │ │ Chat │ │ Calendar │ │ Masking │ │
│ │ Extract │ │ Module │ │ Module │ │ Module │ │
│ │ Module │ │ │ │ │ │ │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘
│
┌───────────────────────────┼───────────────────────────┐
▼ ▼ ▼
┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐
│ VectorDB │ │ Redis │ │ LLM │ │ Storage │
│(ChromaDB) │ │ (Context) │ │ (Gemini) │ │ (S3) │
└───────────┘ └───────────┘ └───────────┘ └───────────┘
API 엔드포인트 요약
| # |
Endpoint |
Method |
설명 |
처리방식 |
| 1 |
/ai/text/extract |
POST |
OCR + 임베딩 + 분석 리포트 (통합) |
비동기 |
| 2 |
/ai/chat |
POST |
채팅 (general/interview_question/interview_report) |
스트리밍 (SSE) |
| 3 |
/ai/calendar/parse |
POST |
캘린더 일정 파싱 |
동기 |
| 4 |
/ai/masking/draft |
POST |
게시판 첨부파일 마스킹 |
비동기 |
| 5 |
/ai/task/{task_id} |
GET |
비동기 작업 상태 조회 |
동기 |
데이터 저장소 역할 분담
| 저장소 |
용도 |
담당 |
| PostgreSQL |
사용자 정보, 채팅방 메타데이터, 면접 세션 |
Backend |
| MongoDB |
분석 결과, 채팅 메시지 영구 저장 |
Backend |
| ChromaDB |
임베딩 벡터 저장 (VectorDB) |
AI Server |
| Redis |
실시간 대화 컨텍스트, LLM 응답 캐시, 비동기 Task 상태 |
AI Server, Backend |
| S3 |
원본 파일, 마스킹된 이미지 |
Backend |
Redis 활용 상세
| 용도 |
Redis 키 패턴 |
TTL |
설명 |
| 채팅 컨텍스트 |
chat:{room_id} |
30분 |
최근 10개 메시지 (LangChain Memory) |
| LLM 응답 캐시 |
llm:{prompt_hash} |
1시간 |
동일 프롬프트 재사용 |
| 비동기 Task 상태 |
task:{task_id} |
30분 |
OCR/마스킹 처리 상태 |
| 사용자 세션 |
session:{user_id} |
1시간 |
사용자 선호도, 요약 정보 |
# LangChain Redis Memory 연동 예시
from langchain_community.chat_message_histories import RedisChatMessageHistory
from langchain.memory import ConversationBufferWindowMemory
history = RedisChatMessageHistory(
session_id=f"chat:{room_id}",
url="redis://redis:6379",
ttl=1800 # 30분
)
memory = ConversationBufferWindowMemory(
chat_memory=history,
k=10 # 최근 10개 메시지만 유지
)
설계 원칙
| 원칙 |
설명 |
| Decoupling |
Backend와 AI Server 분리로 독립적 배포 가능 |
| Single Responsibility |
각 모듈은 하나의 책임만 담당 |
| Scalability |
모듈별 독립적 스케일링 가능 (다중 사용자 대응) |
| Fault Isolation |
장애 격리로 시스템 전체 영향 최소화 |
다중 사용자 확장성 설계
┌─────────────────────────────────────────────────────────────────────────────┐
│ 다중 사용자 아키텍처 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ [사용자 A] [사용자 B] [사용자 C] ... [사용자 N] │
│ │ │ │ │ │
│ └───────────┴───────────┴───────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────┐ │
│ │ Load Balancer │ │
│ └───────┬───────┘ │
│ │ │
│ ┌───────────────┼───────────────┐ │
│ ▼ ▼ ▼ │
│ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │
│ │ AI Server #1 │ │ AI Server #2 │ │ AI Server #3 │ ← Stateless │
│ └───────────────┘ └───────────────┘ └───────────────┘ │
│ │ │ │ │
│ └───────────────┼───────────────┘ │
│ ▼ │
│ ┌───────────────┐ │
│ │ Redis │ ← 세션 공유 (Stateless 달성) │
│ └───────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
핵심: AI Server는 Stateless → Redis에서 세션 관리 → 수평 확장 가능
2. 계층 구조
2.1. 전체 시스템 계층 (요약)
| 계층 |
기술 스택 |
역할 |
| Presentation |
Next.js / React |
사용자 인터페이스 |
| Application |
Spring Boot |
비즈니스 로직, API Gateway |
| AI Service |
FastAPI (Python) |
AI 모델 추론, RAG, 에이전트 |
| Data |
MongoDB, ChromaDB, S3 |
데이터 저장소 |
2.2. AI Service Layer 상세
AI Server (FastAPI)
├── Langchain Core
│ ├── LLM 호출 래퍼
│ ├── Prompt Template 관리
│ ├── Output Parser
│ └── VectorDB 연동
│
├── Langgraph Workflows
│ ├── 면접 워크플로우
│ └── 에이전트 워크플로우
│
└── Modules (5개 API)
├── Text Extract Module (/ai/text/extract)
│ ├── OCR 처리 (Gemini VLM)
│ ├── 임베딩 생성 + VectorDB 저장
│ └── 분석 리포트 생성
│
├── Chat Module (/ai/chat)
│ ├── mode: general - 일반 대화 + RAG
│ ├── mode: interview_question - 면접 질문/꼬리질문 생성
│ └── mode: interview_report - 면접 평가 리포트 생성
│
├── Calendar Module (/ai/calendar/parse)
│ └── 채용공고 일정 추출
│
├── Masking Module (/ai/masking/draft)
│ └── 개인정보 좌표 추출 + 마스킹
│
└── Task Module (/ai/task/{task_id})
└── 비동기 작업 상태 조회
2.3. LangChain / LangGraph 사용 패턴
LangChain = 기본 프레임워크 (모든 API에서 사용)
LangGraph = 확장 라이브러리 (복잡한 워크플로우에만 사용)
| API |
LangChain |
LangGraph |
이유 |
/ai/text/extract |
✅ |
❌ |
VLM 호출 + 임베딩 + 단순 분석 |
/ai/chat (general) |
✅ |
✅ |
RAG + 에이전트 Tool Calling |
/ai/chat (interview_question) |
✅ |
✅ |
상태 기반 질문 생성 워크플로우 |
/ai/chat (interview_report) |
✅ |
❌ |
단순 LLM 평가 |
/ai/calendar/parse |
✅ |
❌ |
단순 LLM 파싱 |
/ai/masking/draft |
✅ |
❌ |
단순 VLM 호출 |
LangChain 사용 기능:
- LLM 호출 래퍼 (
ChatGoogleGenerativeAI)
- Prompt Template 관리
- RAG Chain (
RetrievalQA)
- Embedding (
GoogleGenerativeAIEmbeddings)
- Memory (
RedisChatMessageHistory)
LangGraph 사용 기능:
- 상태 기반 워크플로우 (
StateGraph)
- 조건부 분기 (
add_conditional_edges)
- 에이전트 실행 (
create_react_agent)
3. 모듈 상세
3.1. AI Server 모듈 구조
ai_server/
├── app/
│ ├── main.py # FastAPI 진입점
│ ├── config/
│ │ ├── settings.py # 환경 설정
│ │ └── llm_config.py # LLM 설정
│ │
│ ├── routers/ # API 라우터
│ │ ├── text_extract.py # POST /ai/text/extract
│ │ ├── chat.py # POST /ai/chat
│ │ ├── calendar.py # POST /ai/calendar/parse
│ │ ├── masking.py # POST /ai/masking/draft
│ │ └── task.py # GET /ai/task/{task_id}
│ │
│ ├── services/ # 비즈니스 로직
│ │ ├── text_extract_service.py
│ │ ├── chat_service.py
│ │ ├── calendar_service.py
│ │ ├── masking_service.py
│ │ └── task_service.py
│ │
│ ├── chains/ # LangChain Chains
│ │ ├── analyze_chain.py # 분석 RAG Chain
│ │ ├── interview_chain.py # 면접 Chain
│ │ └── chat_chain.py # 채팅 RAG Chain
│ │
│ ├── graphs/ # LangGraph Workflows
│ │ ├── interview_graph.py # 면접 워크플로우
│ │ └── agent_graph.py # 에이전트 워크플로우
│ │
│ ├── prompts/ # 프롬프트 템플릿
│ │ ├── analyze_prompts.py
│ │ ├── interview_prompts.py
│ │ ├── calendar_prompts.py
│ │ └── masking_prompts.py
│ │
│ ├── schemas/ # Pydantic 스키마
│ │ ├── text_extract.py # TextExtractRequest/Response
│ │ ├── chat.py # ChatRequest/Response
│ │ ├── calendar.py # CalendarParseRequest/Response
│ │ ├── masking.py # MaskingRequest/Response
│ │ └── task.py # TaskStatusResponse
│ │
│ └── utils/ # 유틸리티
│ ├── ocr_utils.py
│ ├── vectordb_utils.py
│ ├── redis_utils.py # Redis 연동 (컨텍스트, 캐시)
│ └── streaming_utils.py # SSE 스트리밍
│
├── tests/
│ └── ...
│
├── requirements.txt
└── Dockerfile
3.2. Pydantic 스키마 예시
# schemas/text_extract.py
from pydantic import BaseModel, Field
from typing import Optional, Literal
class DocumentInput(BaseModel):
file_id: Optional[int] = None
s3_key: Optional[str] = None
file_type: Optional[Literal["pdf", "image"]] = None
text: Optional[str] = None
class TextExtractRequest(BaseModel):
model: str = "gemini"
user_id: int
resume: DocumentInput
job_posting: DocumentInput
class TextExtractResponse(BaseModel):
task_id: str
status: str = "processing"
# schemas/chat.py
class ChatContext(BaseModel):
mode: Literal["general", "interview_question", "interview_report"] = "general"
resume_ocr: Optional[str] = None
job_posting: Optional[str] = None
interview_type: Optional[Literal["technical", "personality"]] = None
session_id: Optional[str] = None
question_count: Optional[int] = None
class ChatRequest(BaseModel):
model: str = "gemini"
room_id: str
user_id: int
message: Optional[str] = None
session_id: Optional[str] = None
context: Optional[ChatContext | list] = None
3.3. 모듈별 역할
| 모듈 |
Endpoint |
역할 |
의존성 |
| Text Extract |
/ai/text/extract |
OCR + 임베딩 + 분석 통합 처리 |
Gemini VLM, ChromaDB, LLM |
| Chat |
/ai/chat |
모든 LLM 응답 (일반대화/면접질문/면접리포트) |
LLM, RAG, LangGraph |
| Calendar |
/ai/calendar/parse |
채용공고에서 일정 정보 추출 |
LLM |
| Masking |
/ai/masking/draft |
이미지 개인정보 좌표 추출 |
VLM |
| Task |
/ai/task/{task_id} |
비동기 작업 상태 조회 |
Redis |
4. 통신 방식
4.1. API 통신 패턴
| 처리방식 |
아이콘 |
사용 API |
구현 방식 |
| 동기 |
⚡ |
/ai/calendar/parse, /ai/task/{task_id} |
일반 HTTP Response |
| 비동기 |
🔄 |
/ai/text/extract, /ai/masking/draft |
task_id 반환 → 폴링 |
| 스트리밍 |
📡 |
/ai/chat (모든 모드) |
SSE (Server-Sent Events) |
4.2. 스트리밍 응답 형식 (SSE)
Content-Type: text/event-stream
data: {"type": "chunk", "content": "분석 결과..."}
data: {"type": "chunk", "content": "를 확인했습니다."}
data: {"type": "complete", "data": {전체 JSON 응답}}
4.3. 비동기 처리 흐름
┌─────────┐ ┌─────────┐ ┌─────────┐
│ Backend │───▶│ AI │───▶│ Task │
│ │ │ Server │ │ Queue │
└─────────┘ └─────────┘ └─────────┘
│ │ │
│◀────────────┘ │
│ task_id 반환 │
│ │
│ 폴링 │
├────────────────────────────▶│
│◀────────────────────────────┤
│ processing / completed │
4.4. Chat API 모드별 동작
POST /ai/chat
│
├─ context.mode = "general"
│ └─ RAG 검색 → LLM 응답 → SSE 스트리밍
│
├─ context.mode = "interview_question"
│ └─ 이력서/채용공고 기반 질문 생성 → SSE 스트리밍
│
└─ context.mode = "interview_report" (context가 배열)
└─ Q&A 히스토리 기반 평가 리포트 → SSE 스트리밍
5. 데이터 흐름
5.1. 이력서 + 채용공고 분석 흐름
[Frontend] → [Backend] → [AI Server]
│ │ │
│ 파일 업로드 │ │
├────────────▶│ │
│ │ S3 저장 │
│ ├────────────▶│
│ │ │
│ │ POST /ai/text/extract
│ ├────────────▶│
│ │ │ (비동기)
│ │◀────────────┤ task_id 반환
│ │ │
│ │ 폴링 │
│ ├────────────▶│ GET /ai/task/{task_id}
│ │◀────────────┤ status: processing
│ │ │
│ │ 폴링 │
│ ├────────────▶│ GET /ai/task/{task_id}
│ │◀────────────┤ status: completed
│ │ │ + resume_ocr, job_posting_ocr
│ │ │ + resume_analysis, posting_analysis
│ 완료 응답 │ │
│◀────────────┤ │
5.2. 면접 모드 흐름
[Frontend] → [Backend] → [AI Server]
│ │ │
│ 면접 시작 │ │
├────────────▶│ │
│ │ POST /ai/chat (mode: interview_question)
│ ├────────────▶│
│ │◀────────────┤ 질문 (SSE)
│◀────────────┤ │
│ │ │
│ 답변 입력 │ │
├────────────▶│ │
│ │ Q&A 저장 (Backend RDB)
│ │ │
│ │ POST /ai/chat (mode: interview_question)
│ ├────────────▶│ question_count++
│ │◀────────────┤ 꼬리질문 (SSE)
│◀────────────┤ │
│ │ │
│ ... 반복 (최대 5개) ... │
│ │ │
│ 면접 종료 │ │
├────────────▶│ │
│ │ POST /ai/chat (mode: interview_report)
│ ├────────────▶│ context: [{question, answer}, ...]
│ │◀────────────┤ 리포트 (SSE)
│◀────────────┤ │
5.3. AI Server 관련 저장 위치
| 데이터 |
저장 위치 |
설명 |
| 임베딩 벡터 |
VectorDB (ChromaDB) |
이력서/채용공고/면접 피드백 벡터 |
| 대화 컨텍스트 |
Redis |
실시간 채팅 히스토리 (TTL: 30분) |
| LLM 응답 캐시 |
Redis |
동일 요청 캐싱 (히트율 ↑ 비용 ↓) |
| 비동기 Task 상태 |
Redis |
OCR, Masking 처리 상태 |
참고: 원본 파일, 추출 텍스트, 면접 Q&A 등은 Backend(MongoDB/S3)에서 관리
6. 확장성 고려사항
6.1. 수평적 확장
┌─────────────┐
│ Load │
│ Balancer │
└─────────────┘
│
┌─────────────────┼─────────────────┐
▼ ▼ ▼
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ AI Server │ │ AI Server │ │ AI Server │
│ Instance 1 │ │ Instance 2 │ │ Instance 3 │
└─────────────┘ └─────────────┘ └─────────────┘
│ │ │
└─────────────────┼─────────────────┘
▼
┌─────────────┐
│ VectorDB │
│ (Shared) │
└─────────────┘
6.2. 버전 관리
| 구분 |
현재 |
향후 확장 |
| API 버전 |
/ai/... |
/v1/ai/..., /v2/ai/... |
| 모델 버전 |
Gemini 1.5 |
모델 A/B 테스트 지원 |
| Prompt 버전 |
하드코딩 |
Prompt Template DB 관리 |
6.3. 장애 대응
| 장애 유형 |
대응 전략 |
| LLM API 장애 |
Fallback 모델 (OpenAI → Gemini) |
| VectorDB 장애 |
로컬 캐시 활용 |
| 타임아웃 |
재시도 + 지수 백오프 |
| Rate Limit |
큐잉 + 요청 제한 |
7. 모듈화 기대 효과
7.1. 개발/운영 측면 이점
| 측면 |
효과 |
상세 설명 |
| 독립 배포 |
배포 리스크 감소 |
Chat 모듈 변경 시 Masking 모듈 재배포 불필요 |
| 독립 스케일링 |
리소스 최적화 |
트래픽 많은 /ai/chat 모듈만 스케일 아웃 가능 |
| 병렬 개발 |
개발 속도 향상 |
분석 담당과 면접 담당이 동시에 개발 가능 |
| 장애 격리 |
안정성 향상 |
Text Extract 모듈 장애 시 다른 모듈 정상 동작 |
| 테스트 용이 |
품질 향상 |
각 모듈별 독립 유닛/통합 테스트 가능 |
| 코드 유지보수 |
유지보수성 향상 |
책임 분리로 코드 복잡도 감소 |
7.2. 모듈별 독립성 효과
┌─────────────────────────────────────────────────────────────────────────────┐
│ 모듈 독립성으로 인한 변경 영향 범위 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ [Before: 모놀리식] │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ ┌───────┬───────┬───────┬───────┬───────┐ │ │
│ │ │ OCR │Analyze│Interview│ Chat │Masking│ ← 전체가 하나의 덩어리 │ │
│ │ └───────┴───────┴───────┴───────┴───────┘ │ │
│ │ │ │
│ │ 문제: Chat 수정 시 → 전체 재배포 필요 │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
│ [After: 모듈화 (5개 API)] │
│ ┌───────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Text │ │ Chat │ │Calendar │ │ Masking │ │
│ │ Extract │ │ │ │ Parse │ │ Draft │ │
│ └───────────┘ └────┬────┘ └─────────┘ └─────────┘ │
│ │ │
│ ▼ │
│ Chat 모듈만 독립 배포 가능! │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
7.3. LLM/VLM 모델 교체 시 이점
| 상황 |
모놀리식 |
모듈화 |
| Chat 모듈에서 GPT-4 → Claude 교체 |
전체 서비스 영향 |
Chat 모듈만 수정 |
| Text Extract 모듈에서 Gemini Vision → PaddleOCR 교체 |
전체 테스트 필요 |
Text Extract 모듈만 테스트 |
| 면접 프롬프트 대폭 변경 |
다른 기능 사이드 이펙트 우려 |
Chat 모듈 내 interview 로직만 검증 |
8. 서비스 시나리오 부합 근거
8.1. 모듈 경계 설정 근거
서비스(AI 기반 취업 준비 플랫폼)의 핵심 기능별로 모듈을 분리:
┌─────────────────────────────────────────────────────────────────────────────┐
│ 서비스 시나리오 → API 매핑 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ [시나리오: 이력서 + 채용공고 분석] │
│ ├── 사용 API: POST /ai/text/extract │
│ └── 근거: OCR → 임베딩 → 분석이 하나의 파이프라인 │
│ │
│ [시나리오: 일반 대화 + RAG] │
│ ├── 사용 API: POST /ai/chat (mode: general) │
│ └── 근거: VectorDB 검색 + LLM 응답 생성 │
│ │
│ [시나리오: 모의 면접] │
│ ├── 사용 API: POST /ai/chat (mode: interview_question/interview_report) │
│ └── 근거: 세션 기반 상태 유지 + 질문/평가 워크플로우 │
│ │
│ [시나리오: 캘린더 일정 추출] │
│ ├── 사용 API: POST /ai/calendar/parse │
│ └── 근거: 채용공고에서 일정 파싱 (독립 기능) │
│ │
│ [시나리오: 게시판 마스킹] │
│ ├── 사용 API: POST /ai/masking/draft │
│ └── 근거: 다른 기능과 완전히 독립적인 단일 기능 │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
8.2. Backend ↔ AI Server API 매핑
| Backend 외부 API |
AI Server 내부 API |
설명 |
POST /api/chat/rooms |
없음 |
대화창 생성 (Backend만) |
POST /api/ai/chatrooms/{roomId}/analysis |
POST /ai/text/extract |
분석 요청 |
POST /api/ai/chatrooms/{roomId}/messages |
POST /ai/chat (general) |
일반 채팅 |
POST /api/ai/chatrooms/{roomId}/interview |
POST /ai/chat (interview_question) |
면접 질문 |
POST /api/ai/chatrooms/{roomId}/evaluation |
POST /ai/chat (interview_report) |
면접 평가 |
POST /api/ai/events/extraction |
POST /ai/calendar/parse |
일정 추출 |
POST /api/board/upload |
POST /ai/masking/draft |
마스킹 요청 |
8.3. 변경 요구사항 발생 시 영향 범위 분석
시나리오 1: 면접 질문 생성 로직 변경
변경 내용: 면접 질문 생성 시 RAG 검색 로직 개선
[모놀리식일 경우]
├── 전체 서비스 분석 필요
├── 분석/채팅 기능까지 영향 가능성
└── 전체 회귀 테스트 필요 (테스트 시간: 2시간+)
[모듈화된 현재 구조]
├── Chat 모듈의 interview_question 로직만 수정
├── 해당 모드 유닛/통합 테스트만 실행 (테스트 시간: 10분)
└── 다른 모듈 영향 없음
시나리오 2: 사용자 급증으로 채팅 트래픽 5배 증가
변경 내용: Chat 모듈 처리량 증가 필요
[모놀리식일 경우]
├── 전체 AI Server 인스턴스 5배 증가
├── 불필요한 Text Extract/Masking 리소스도 5배 증가
└── 인프라 비용 5배
[모듈화된 현재 구조]
├── Chat 모듈만 수평 확장 (5 인스턴스)
├── 다른 모듈은 기존 1 인스턴스 유지
└── 인프라 비용 최적화 (예상 2배 수준)
8.4. 모듈화 적용 전후 비교 요약
| 항목 |
Before (모놀리식) |
After (모듈화) |
| 배포 단위 |
전체 AI Server |
모듈별 독립 배포 |
| 변경 영향 범위 |
전체 |
해당 모듈만 |
| 스케일링 |
전체 스케일 |
모듈별 독립 스케일 |
| 장애 영향 |
전체 서비스 다운 |
해당 모듈만 영향 |
| 테스트 범위 |
전체 회귀 테스트 |
해당 모듈 테스트 |
| 개발 병렬화 |
충돌 발생 가능 |
독립 개발 가능 |
| 코드 복잡도 |
높음 |
낮음 (책임 분리) |
문서 작성: 2026-01-13
작성자: AI Team
버전: v1.6
마지막 업데이트: 2026-01-26