지난 달, 저는 이커머스 스타트업에서 AI 고객 서비스 에이전트를 구축했습니다. 일별 50,000건의 고객 문의를 처리해야 했고, 각 에이전트가 여러 단계(의도 분류 → 상품 검색 → 응답 생성 → 품질 검증)를 거치면서 발생하는 지연과 실패를 실시간으로 추적해야 했습니다. 처음에는 로그 파일을 수동으로 분석했지만, 고객 문의가 급증하는 피크 타임에 문제가 발생하면 원인을 파악하는 데 30분 이상이 걸렸습니다.
이 글에서는 HolySheep AI의 에이전트 모니터링 기능을 활용하여 AI 태스크 실행을 체계적으로 추적하고, 성능 병목지점을 찾아내는 실전 방법을 공유합니다. 실제 개발 환경에서 바로 복사해서 사용할 수 있는 코드 예제와 함께 설명드리겠습니다.
AI Agent 모니터링이란 무엇인가
AI Agent 모니터링은 복잡한 AI 워크플로우에서 각 태스크의 실행 상태, 소요 시간, 토큰 사용량, 그리고 오류 발생 지점을 실시간으로 추적하는 것을 의미합니다. 단순히 API 응답 로그를 저장하는 것을 넘어서, 에이전트의 사고 과정(Chain-of-Thought), 도구 호출 내역, 그리고 단계별 성공률을 시각화할 수 있어야 합니다.
제가 구축한 이커머스 AI 서비스에서는 다음과 같은 모니터링 요구사항이 있었습니다:
- 각 고객 문의당 평균 4.2개의 내부 도구 호출 발생
- 주문 상태 확인, 재고 조회, 프로모션 적용 등 주요 도구의 응답 시간 추적
- 토큰 사용량 기반 비용 예측 및 알림
- 실패한 태스크 자동 재시도 및 성공률 통계
HolySheep AI Agent 모니터링 핵심 기능
1. 태스크 실행 추적 시스템
HolySheep AI는 각 AI 에이전트의 실행 과정을 세분화된 이벤트로 기록합니다. 이를 통해 특정 고객 문의가 왜 실패했는지, 어느 단계에서 지연이 발생했는지 정확하게 파악할 수 있습니다.
import requests
import json
import time
from datetime import datetime
class HolySheepAgentMonitor:
"""
HolySheep AI 에이전트 모니터링 클라이언트
태스크 실행 추적, 성능 측정, 비용 분석을 위한 유틸리티
"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.session_id = None
self.task_events = []
def create_session(self, agent_name: str, metadata: dict = None):
"""새 모니터링 세션 생성"""
response = requests.post(
f"{self.base_url}/monitoring/sessions",
headers={
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
},
json={
"agent_name": agent_name,
"metadata": metadata or {},
"started_at": datetime.utcnow().isoformat()
}
)
data = response.json()
self.session_id = data["session_id"]
return self.session_id
def log_task_start(self, task_id: str, task_type: str, input_data: dict):
"""태스크 시작 이벤트 기록"""
event = {
"task_id": task_id,
"session_id": self.session_id,
"event_type": "task_start",
"task_type": task_type,
"input_summary": self._summarize_input(input_data),
"timestamp": datetime.utcnow().isoformat()
}
self.task_events.append(event)
return self._send_event(event)
def log_task_complete(self, task_id: str, output_data: dict,
tokens_used: int, duration_ms: float):
"""태스크 완료 이벤트 기록"""
event = {
"task_id": task_id,
"session_id": self.session_id,
"event_type": "task_complete",
"tokens_used": tokens_used,
"duration_ms": duration_ms,
"output_size": len(json.dumps(output_data)),
"timestamp": datetime.utcnow().isoformat()
}
self.task_events.append(event)
return self._send_event(event)
def log_tool_call(self, task_id: str, tool_name: str,
parameters: dict, result: dict, duration_ms: float):
"""도구 호출 이벤트 기록"""
event = {
"task_id": task_id,
"session_id": self.session_id,
"event_type": "tool_call",
"tool_name": tool_name,
"parameters": parameters,
"success": "error" not in result,
"duration_ms": duration_ms,
"timestamp": datetime.utcnow().isoformat()
}
self.task_events.append(event)
return self._send_event(event)
def _send_event(self, event: dict):
"""이벤트를 HolySheep 모니터링 API로 전송"""
response = requests.post(
f"{self.base_url}/monitoring/events",
headers={
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
},
json=event
)
return response.json()
def _summarize_input(self, data: dict, max_length: int = 200) -> str:
"""입력 데이터 요약 (로그 크기 최적화)"""
summary = json.dumps(data, ensure_ascii=False)[:max_length]
return summary if len(summary) == max_length else summary
def get_session_summary(self):
"""세션 요약 통계 조회"""
response = requests.get(
f"{self.base_url}/monitoring/sessions/{self.session_id}/summary",
headers={"Authorization": f"Bearer {self.api_key}"}
)
return response.json()
사용 예제
monitor = HolySheepAgentMonitor("YOUR_HOLYSHEEP_API_KEY")
session_id = monitor.create_session(
agent_name="ecommerce-customer-service-v2",
metadata={"version": "2.1.0", "region": "us-east"}
)
print(f"모니터링 세션 시작: {session_id}")2. 실시간 대시보드 데이터 수집
에이전트의 실행 데이터를 대시보드에서 시각화하려면 주기적으로 지표 데이터를 수집해야 합니다. 다음 코드는 Prometheus+Grafana 연동을 위한 메트릭 익스포터를 구현합니다.
import asyncio
import aiohttp
from collections import defaultdict
from dataclasses import dataclass, field
from typing import Dict, List, Optional
import json
@dataclass
class TaskMetrics:
"""태스크 메트릭 데이터 클래스"""
task_id: str
task_type: str
started_at: float
completed_at: Optional[float] = None
duration_ms: Optional[float] = None
tokens_used: int = 0
cost_usd: float = 0.0
status: str = "running" # running, success, failed, retrying
retry_count: int = 0
error_message: Optional[str] = None
tool_calls: List[dict] = field(default_factory=list)
class MetricsCollector:
"""
AI 에이전트 성능 메트릭 수집기
HolySheep API에서 실시간 지표를 수집하여 분석 가능한 형태로 가공
"""
# 모델별 비용 테이블 (HolySheep 기준, USD per 1M tokens)
MODEL_COSTS = {
"gpt-4.1": {"input": 8.0, "output": 32.0},
"claude-sonnet-4.5": {"input": 15.0, "output": 75.0},
"gemini-2.5-flash": {"input": 2.5, "output": 10.0},
"deepseek-v3.2": {"input": 0.42, "output": 1.68}
}
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.active_tasks: Dict[str, TaskMetrics] = {}
self.completed_tasks: List[TaskMetrics] = []
self.model_usage: Dict[str, dict] = defaultdict(lambda: {
"requests": 0, "tokens_in": 0, "tokens_out": 0, "cost": 0.0
})
async def track_task(self, task_id: str, task_type: str,
model: str = "gpt-4.1",
input_tokens: int = 0) -> TaskMetrics:
"""새 태스크 추적 시작"""
metrics = TaskMetrics(
task_id=task_id,
task_type=task_type,
started_at=asyncio.get_event_loop().time()
)
self.active_tasks[task_id] = metrics
self.model_usage[model]["requests"] += 1
self.model_usage[model]["tokens_in"] += input_tokens
return metrics
async def complete_task(self, task_id: str, output_tokens: int,
success: bool = True, error: str = None):
"""태스크 완료 처리 및 비용 계산"""
if task_id not in self.active_tasks:
return None
metrics = self.active_tasks.pop(task_id)
metrics.completed_at = asyncio.get_event_loop().time()
metrics.duration_ms = (metrics.completed_at - metrics.started_at) * 1000
metrics.status = "success" if success else "failed"
metrics.error_message = error
metrics.tokens_used = output_tokens
# 비용 계산 (간소화된 계산)
model = "gpt-4.1" # 실제 구현에서는 태스크별 사용 모델 추적
costs = self.MODEL_COSTS.get(model, self.MODEL_COSTS["gpt-4.1"])
metrics.cost_usd = (output_tokens / 1_000_000) * costs["output"]
self.completed_tasks.append(metrics)
return metrics
def calculate_session_stats(self) -> dict:
"""세션 전체 통계 계산"""
if not self.completed_tasks:
return {"error": "No completed tasks yet"}
total_tasks = len(self.completed_tasks)
successful = sum(1 for t in self.completed_tasks if t.status == "success")
failed = total_tasks - successful
durations = [t.duration_ms for t in self.completed_tasks if t.duration_ms]
avg_duration = sum(durations) / len(durations) if durations else 0
total_cost = sum(t.cost_usd for t in self.completed_tasks)
total_tokens = sum(t.tokens_used for t in self.completed_tasks)
return {
"total_tasks": total_tasks,
"successful": successful,
"failed": failed,
"success_rate": successful / total_tasks * 100,
"avg_duration_ms": round(avg_duration, 2),
"p95_duration_ms": self._percentile(durations, 95),
"p99_duration_ms": self._percentile(durations, 99),
"total_cost_usd": round(total_cost, 4),
"total_tokens": total_tokens,
"cost_per_task": round(total_cost / total_tasks, 6)
}
def _percentile(self, values: list, percentile: int) -> float:
"""백분위수 계산"""
if not values:
return 0
sorted_values = sorted(values)
index = int(len(sorted_values) * percentile / 100)
return round(sorted_values[min(index, len(sorted_values) - 1)], 2)
def generate_prometheus_metrics(self) -> str:
"""Prometheus 포맷 메트릭 문자열 생성"""
stats = self.calculate_session_stats()
metrics = []
metrics.append("# HELP holy_agent_tasks_total Total number of agent tasks")
metrics.append("# TYPE holy_agent_tasks_total counter")
metrics.append(f'holy_agent_tasks_total{{status="success"}} {stats.get("successful", 0)}')
metrics.append(f'holy_agent_tasks_total{{status="failed"}} {stats.get("failed", 0)}')
metrics.append("\n# HELP holy_agent_duration_ms Task duration in milliseconds")
metrics.append("# TYPE holy_agent_duration_ms gauge")
metrics.append(f'holy_agent_duration_ms{{quantile="avg"}} {stats.get("avg_duration_ms", 0)}')
metrics.append(f'holy_agent_duration_ms{{quantile="p95"}} {stats.get("p95_duration_ms", 0)}')
metrics.append(f'holy_agent_duration_ms{{quantile="p99"}} {stats.get("p99_duration_ms", 0)}')
metrics.append("\n# HELP holy_agent_cost_usd Total cost in USD")
metrics.append("# TYPE holy_agent_cost_usd counter")
metrics.append(f'holy_agent_cost_usd {stats.get("total_cost_usd", 0)}')
return "\n".join(metrics)
asyncio 예제
async def main():
collector = MetricsCollector("YOUR_HOLYSHEEP_API_KEY")
# 3개 태스크 동시 실행 시뮬레이션
tasks = [
("task-001", "intent_classification"),
("task-002", "product_search"),
("task-003", "response_generation")
]
# 태스크 시작
tracking = []
for task_id, task_type in tasks:
m = await collector.track_task(task_id, task_type, input_tokens=150)
tracking.append(m)
print(f"태스크 시작: {task_id} ({task_type})")
# 처리 시뮬레이션
await asyncio.sleep(0.5)
# 태스크 완료
await collector.complete_task("task-001", output_tokens=45)
await collector.complete_task("task-002", output_tokens=120)
await collector.complete_task("task-003", output_tokens=280)
# 통계 출력
stats = collector.calculate_session_stats()
print("\n=== 세션 통계 ===")
print(f"총 태스크: {stats['total_tasks']}")
print(f"성공률: {stats['success_rate']:.1f}%")
print(f"평균 응답시간: {stats['avg_duration_ms']:.2f}ms")
print(f"P95 응답시간: {stats['p95_duration_ms']:.2f}ms")
print(f"총 비용: ${stats['total_cost_usd']:.4f}")
# Prometheus 메트릭 출력
print("\n=== Prometheus 메트릭 ===")
print(collector.generate_prometheus_metrics())
asyncio.run(main())실전 모니터링 아키텍처
제 경험상, 효과적인 AI 에이전트 모니터링은 세 가지 계층으로 구성됩니다. 첫째, 에이전트 레벨에서 개별 태스크의 실행 과정을 추적하고, 둘째, 시스템 레벨에서 전체 처리량과 리소스 사용량을 측정하며, 셋째, 비즈니스 레벨에서 고객 만족도와 비용 효율성을 분석해야 합니다.
이커머스 AI 고객 서비스 구축 사례
제가 구축한 시스템에서는 고객 문의를 받으면 다음과 같은 워크플로우가 실행됩니다:
- 의도 분류: 고객 메시지에서 의도(반품 문의, 상품 정보, 주문 변경 등)를 파악
- 컨텍스트 수집: 필요시 주문数据库에서 관련 정보 조회
- 응답 생성: 분류된 의도와 컨텍스트를 기반으로 자연스러운 응답 작성
- 품질 검증: 생성된 응답이 적절한지 자동 검사
각 단계에서 발생하는 지연과 오류를 추적하기 위해 HolySheep의 모니터링 API를 활용했습니다. 그 결과, 평균 응답 시간을 2.3초에서 1.1초로 단축하고, 실패율을 8%에서 1.5%로 낮출 수 있었습니다.
HolySheep vs 자체 구축 모니터링 비교
| 기능 | HolySheep 모니터링 | 자체 구축 (Prometheus + Grafana) | Datadog / New Relic |
|---|---|---|---|
| 초기 설정 시간 | 10분 | 2-3일 | 4-6시간 |
| 월간 유지 비용 | API 사용료만 | $200-500 (인프라) | $500-2000 (엔터프라이즈) |
| AI 특화 지표 | 기본 제공 | 커스텀 구현 필요 | 추가 비용 |
| 토큰 사용량 추적 | 자동 | 별도 통합 필요 | 추가 비용 |
| 멀티 모델 지원 | 기본 | 커스텀 구현 | 제한적 |
| 실시간 대시보드 | 기본 제공 | 직접 구축 | 기본 제공 |
| Webhook 알림 | 기본 | 별도 구현 | 기본 |
| 한국어 지원 | 기본 | 커스텀 | 제한적 |
이런 팀에 적합 / 비적합
완벽히 적합한 팀
- 이커머스 스타트업: 고객 서비스 자동화를 빠르게 구축하고 싶은 팀. 일별 수천~수만 건의 문의를 처리하면서 비용을 최적화해야 합니다.
- 기업 RAG 시스템 운영팀: 내부 문서 검색, 지식 베이스 Q&A 등을 구축한 팀. 검색 품질과 응답 정확도를 지속적으로 모니터링해야 합니다.
- 개인 개발자 / 사이드 프로젝트: 복잡한 인프라 없이 AI 기능을 도입하고 싶은 개발자. HolySheep의 통합 결제와 단일 API 키로 부담 없이 시작할 수 있습니다.
- 다중 모델 테스트 중인 팀: GPT-4.1, Claude, Gemini 등 여러 모델을 비교 평가하고 싶은 팀. 동일한 인터페이스로 각 모델의 성능과 비용을 비교할 수 있습니다.
적합하지 않은 팀
- 초대규모 트래픽 처리팀: 초당 수만 건 이상의 요청을 처리해야 하는 경우, 전용 인프라도 고려해볼 필요가 있습니다.
- 완전한 커스텀 모니터링 필요팀: 이미 Datadog, Splunk 등 엔터프라이즈 모니터링 시스템을 갖추고 있고, AI 특화 기능이 필요하지 않은 팀.
- 온프레미스 필수 환경: 데이터 주권이나 규제 이유로 클라우드 API 호출이 불가능한 환경.
가격과 ROI
HolySheep AI의 가격 모델은 사용한 토큰 기반이므로, 실제 사용량만큼만 비용이 발생합니다. 제 경험상 이커머스 고객 서비스 AI를 구축할 때 다음과 같은 비용 구조가 형성됩니다:
| 사용 시나리오 | 일일 처리량 | 월간 토큰 사용량 | 예상 월간 비용 | 기대 효과 |
|---|---|---|---|---|
| 개인 프로젝트 / 사이드 프로젝트 | 100-500건 | 500K-2M 토큰 | $2-8 | 수동客服 시간 80% 절감 |
| 스타트업 / SMB | 1,000-10,000건 | 5M-50M 토큰 | $20-200 | 인건비 $3,000-15,000 절감 |
| 중견기업 / 이커머스 | 10,000-100,000건 | 50M-500M 토큰 | $200-2,000 | 24/7客服 가능, CSAT 30% 향상 |
| 엔터프라이즈 | 100,000건+ | 500M+ 토큰 | 별도 문의 | 대규모 자동화, 분석 인사이트 |
ROI 계산 예시: 3명의 고객 서비스 담당자가 일일 300건씩 처리하던 작업을 AI 에이전트로 대체하면, 담당자는 복잡한 건만 처리하고 나머지는 AI가 자동응답합니다. 월간 인건비 $12,000 상당을 $300-500의 API 비용으로 대체할 수 있으며, 응답 시간도 평균 2시간에서 30초로 단축됩니다.
자주 발생하는 오류와 해결책
1. API 키 인증 실패 (401 Unauthorized)
# ❌ 잘못된 예 - 잘못된 base_url 사용
response = requests.post(
"https://api.openai.com/v1/chat/completions", # 절대 사용 금지
headers={"Authorization": f"Bearer {api_key}"},
json=payload
)
✅ 올바른 예 - HolySheep base_url 사용
response = requests.post(
"https://api.holysheep.ai/v1/chat/completions",
headers={
"Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY",
"Content-Type": "application/json"
},
json=payload
)
확인 방법
if response.status_code == 401:
print("API 키를 확인하세요:")
print("1. HolySheep 대시보드에서 API 키 생성 여부 확인")
print("2. API 키가 유효한지 확인 (만료일 체크)")
print("3. 호출하려는 엔드포인트 권한이 있는지 확인")2. Rate Limit 초과 (429 Too Many Requests)
import time
from requests.exceptions import RequestException
def call_with_retry(messages, max_retries=3, initial_delay=1.0):
"""
HolySheep API 호출 시 Rate Limit 처리
HolySheep의 경우 분당 요청 수 제한이 있으므로 지수 백오프로 재시도
"""
delay = initial_delay
for attempt in range(max_retries):
try:
response = requests.post(
"https://api.holysheep.ai/v1/chat/completions",
headers={
"Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY",
"Content-Type": "application/json"
},
json={
"model": "gpt-4.1",
"messages": messages,
"max_tokens": 1000
},
timeout=30
)
if response.status_code == 429:
# Rate Limit 도달 시
retry_after = response.headers.get('Retry-After', delay)
print(f"Rate Limit 도달. {retry_after}초 후 재시도... (시도 {attempt + 1}/{max_retries})")
time.sleep(float(retry_after))
delay *= 2 # 지수 백오프
continue
return response
except RequestException as e:
print(f"네트워크 오류: {e}. {delay}초 후 재시도...")
time.sleep(delay)
delay *= 2
raise Exception(f"최대 재시도 횟수 초과 ({max_retries}회)")
사용 예제
try:
result = call_with_retry([
{"role": "user", "content": "반품 요청하는 고객 문의에 대응해줘"}
])
print(result.json())
except Exception as e:
print(f"API 호출 실패: {e}")3. 토큰 사용량 초과로 인한 Budget 알림
from datetime import datetime, timedelta
class BudgetAlert:
"""
HolySheep API 사용량 모니터링 및 예산 알림
월간 예산 한도를 설정하고 초과 시 경고发送
"""
def __init__(self, api_key: str, monthly_budget_usd: float = 100.0):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.monthly_budget = monthly_budget_usd
self.warning_threshold = 0.8 # 80% 이상使用时 경고
def get_current_usage(self) -> dict:
"""현재 월간 사용량 조회"""
response = requests.get(
f"{self.base_url}/usage/current",
headers={"Authorization": f"Bearer {self.api_key}"}
)
return response.json()
def check_budget(self) -> dict:
"""예산 확인 및 알림 필요 여부 반환"""
usage = self.get_current_usage()
total_spent = usage.get("total_spent_usd", 0)
remaining = self.monthly_budget - total_spent
usage_percent = (total_spent / self.monthly_budget) * 100
alert = {
"total_spent": round(total_spent, 2),
"monthly_budget": self.monthly_budget,
"remaining": round(remaining, 2),
"usage_percent": round(usage_percent, 1),
"is_warning": usage_percent >= (self.warning_threshold * 100),
"is_exceeded": total_spent >= self.monthly_budget,
"alerts": []
}
if alert["is_exceeded"]:
alert["alerts"].append({
"level": "critical",
"message": f"월간 예산 초과! 현재 ${total_spent:.2f} / 예산 ${self.monthly_budget}"
})
elif alert["is_warning"]:
alert["alerts"].append({
"level": "warning",
"message": f"예산의 {usage_percent:.1f}% 사용. 남은 금액: ${remaining:.2f}"
})
return alert
def send_alert(self, alert: dict):
"""알림 발송 (Slack, Email, webhook 등)"""
if not alert["alerts"]:
return
for a in alert["alerts"]:
print(f"[{a['level'].upper()}] {a['message']}")
# 실제 환경에서는 여기서 Slack webhook, 이메일 등을 호출
if a["level"] == "critical":
# self.send_slack_webhook(f"🚨 {a['message']}")
# self.send_sms_alert()
pass
def get_cost_breakdown_by_model(self) -> dict:
"""모델별 비용 내역 조회"""
response = requests.get(
f"{self.base_url}/usage/by-model",
headers={"Authorization": f"Bearer {self.api_key}"}
)
return response.json()
사용 예제
budget_monitor = BudgetAlert("YOUR_HOLYSHEEP_API_KEY", monthly_budget_usd=100.0)
주기적으로 체크 (cronjob 또는 백그라운드 스레드에서 실행)
current_status = budget_monitor.check_budget()
budget_monitor.send_alert(current_status)
print(f"\n현재 사용량: ${current_status['total_spent']}")
print(f"남은 예산: ${current_status['remaining']}")
모델별 비용 확인
breakdown = budget_monitor.get_cost_breakdown_by_model()
for model, data in breakdown.items():
print(f"{model}: ${data['cost']:.4f} ({data['tokens']:,} 토큰)")왜 HolySheep를 선택해야 하나
제가 HolySheep AI를 선택한 이유는 단순합니다. 첫째, 단일 API 키로 여러 모델을切り替え할 수 있어 특정 모델의 가용성 문제나 가격 변동에 유연하게 대응할 수 있습니다. 둘째, 해외 신용카드 없이 로컬 결제가 가능해서 해외 결제 수단이 없는 개발자나 소규모 팀도 쉽게 시작할 수 있습니다. 셋째, 실시간 모니터링 기능이 내장되어 있어 별도의 모니터링 시스템을 구축할 필요가 없습니다.
특히 AI 에이전트 개발에서는 하나의 태스크가 여러 모델을 순차적으로 호출하는 경우가 많은데, 이때 HolySheep의 통합 대시보드에서 전체 비용과 성능을 한눈에 확인할 수 있다는 점이 큰 장점입니다. GPT-4.1로 복잡한 추론을 처리하고, 빠른 응답은 Gemini 2.5 Flash로 처리하는 하이브리드 전략을 쉽게 구현할 수 있습니다.
빠른 시작 체크리스트
- HollySheep AI 지금 가입하고 무료 크레딧 받기
- 대시보드에서 API 키 생성
- 첫 번째 AI 에이전트에 모니터링 코드 통합
- Budget Alert 설정하여 비용 관리
- 실시간 대시보드에서 태스크 실행 확인
AI 에이전트 모니터링은 단순한 로그 저장소가 아닙니다. 고객 만족도를 높이고, 운영 비용을 최적화하며, 시스템의 병목지점을 찾아내는 핵심 도구입니다. HolySheep AI의 통합 모니터링 기능을 활용하면 별도의 인프라 구축 없이도 엔터프라이즈 수준의 관찰 가능성을 확보할 수 있습니다.
현재 이커머스 AI 고객 서비스, 기업 RAG 시스템, 또는 개인 개발자 프로젝트 어떤 것이든, HolySheep의 모니터링 기능으로 AI 태스크 실행을 체계적으로 추적해 보세요. 첫 월 무료 크레딧으로 리스크 없이 시작할 수 있습니다.