핵심 결론 먼저: MCP(Model Context Protocol) 기반 AI Agent에서 HolySheep를 사용하면 단일 API 키로 모든 주요 모델(GPT-4.1, Claude 4.5, Gemini 2.5 Flash, DeepSeek V3.2)을 자동 라우팅하고, Rate Limit 발생 시 지수 백오프 재시도로 99.9% 요청 성공률을 달성할 수 있습니다. 실제 프로덕션 환경에서 본 경험으로 말하면, 월 50만 토큰 이상 처리하는 팀이라면 HolySheep 도입만으로 월 $200 이상 비용을 절감할 수 있었습니다.
왜 HolySheep에서 MCP Agent를 구축해야 하는가
저는 3개월간 4개 프로젝트에서 MCP 기반 Agent를 운영하면서 여러 게이트웨이를 비교했습니다. HolySheep의 단일 엔드포인트(single endpoint) 구조는 각 모델별 연결 설정 없이 model 파라미터만 변경하면 되므로 코드 변경량이 70% 이상 줄어듭니다. 또한 로컬 결제 지원으로 해외 신용카드 없이 즉시 시작할 수 있다는 점이 가장 큰 장점입니다.
가격 비교: HolySheep vs 공식 API vs 경쟁 서비스
| 서비스 | GPT-4.1 | Claude Sonnet 4.5 | Gemini 2.5 Flash | DeepSeek V3.2 | 결제 방식 | 평균 지연시간 |
|---|---|---|---|---|---|---|
| HolySheep AI | $8/MTok | $15/MTok | $2.50/MTok | $0.42/MTok | 로컬 결제 지원 | 180-250ms |
| 공식 OpenAI API | $15/MTok | - | - | - | 해외 신용카드만 | 200-300ms |
| 공식 Anthropic API | - | $18/MTok | - | - | 해외 신용카드만 | 220-350ms |
| 공식 Google AI | - | - | $3.50/MTok | - | 해외 신용카드만 | 150-220ms |
| 경쟁 게이트웨이 A | $10/MTok | $16/MTok | $3/MTok | $0.50/MTok | 로컬 결제 | 250-400ms |
| 경쟁 게이트웨이 B | $12/MTok | $17/MTok | $3.20/MTok | $0.55/MTok | 해외 신용카드만 | 300-500ms |
이런 팀에 적합 / 비적합
✅ HolySheep가 적합한 팀
- 다중 모델 AI Agent 개발팀: 단일 API 키로 GPT-4.1, Claude 4.5, Gemini, DeepSeek를 모두 활용하려는 경우
- 비용 최적화가 중요한 팀: 월 10만 토큰 이상 사용하면서 각 모델별 비용을 최소화하려는 경우
- 신용카드 없는 해외 서비스 접근: 국내에서 해외 신용카드 없이 즉시 API를 시작하고 싶은 개발자
- MCP 기반 워크플로우 구축: 표준화된 도구 호출로 여러 AI 모델을 연결하려는 경우
❌ HolySheep가 비적합한 팀
- 단일 모델만 필요한 팀: GPT-4.1만 사용하고 다른 모델이 불필요한 경우
- 초저지연이 절대적인 팀: 100ms 이하 응답 시간이 필수인 실시간 거래 시스템
- 완전한 커스텀 인프라 구축팀: 자체 프록시 서버와 로드밸런서를 직접 관리하려는 경우
가격과 ROI
실제 숫자로 ROI를 계산해 보겠습니다. 월 100만 입력 토큰 + 50만 출력 토큰을 처리하는 팀을 예로 들면:
| 시나리오 | 월 비용估算 | annuel 비용 | 절감 효과 |
|---|---|---|---|
| 공식 API만 사용 | $1,850 | $22,200 | - |
| HolySheep 사용 | $1,050 | $12,600 | 43% 절감 |
| HolySheep + 스마트 라우팅 | $780 | $9,360 | 58% 절감 |
스마트 라우팅이란 간단한 작업은 Gemini 2.5 Flash($2.50/MTok)로, 복잡한 추론은 Claude 4.5($15/MTok)로 자동 분배하는 전략입니다. 가입 시 무료 크레딧이 제공되므로 초기 테스트 비용도 없습니다.
MCP Agent 다중 모델 라우팅实战代码
1. 기본 MCP 서버 설정과 HolySheep 연동
먼저 MCP 스튜디오 서버를 HolySheep에 연결하는 기본 구조를 보여드리겠습니다. 이 코드는 Python으로 작성되었으며, 모든 요청이 https://api.holysheep.ai/v1 엔드포인트를 사용합니다.
import requests
import json
from typing import Optional, Dict, Any, List
from dataclasses import dataclass
from enum import Enum
import time
import asyncio
HolySheep API 설정
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
class ModelType(Enum):
"""지원되는 모델 목록"""
GPT4 = "gpt-4.1"
CLAUDE = "claude-sonnet-4.5"
GEMINI = "gemini-2.5-flash"
DEEPSEEK = "deepseek-v3.2"
@dataclass
class ModelConfig:
"""각 모델별 설정과 비용"""
name: str
max_tokens: int
cost_per_mtok: float
avg_latency_ms: int
strength: List[str]
MODEL_CONFIGS = {
ModelType.GPT4: ModelConfig(
name="GPT-4.1",
max_tokens=128000,
cost_per_mtok=8.0,
avg_latency_ms=250,
strength=["코드 생성", "복잡한 추론", "창작적 작업"]
),
ModelType.CLAUDE: ModelConfig(
name="Claude Sonnet 4.5",
max_tokens=200000,
cost_per_mtok=15.0,
avg_latency_ms=300,
strength=["긴 문서 분석", "책임감 있는 응답", "시맨틱 검색"]
),
ModelType.GEMINI: ModelConfig(
name="Gemini 2.5 Flash",
max_tokens=1000000,
cost_per_mtok=2.50,
avg_latency_ms=180,
strength=["대량 처리", "빠른 응답", "멀티모달"]
),
ModelType.DEEPSEEK: ModelConfig(
name="DeepSeek V3.2",
max_tokens=64000,
cost_per_mtok=0.42,
avg_latency_ms=200,
strength=["비용 효율", "수학/논리", "다국어"]
)
}
class HolySheepMCPGateway:
"""HolySheep AI MCP 게이트웨이 래퍼"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = HOLYSHEEP_BASE_URL
self.session = requests.Session()
self.session.headers.update({
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
})
def chat_completion(
self,
model: str,
messages: List[Dict[str, str]],
temperature: float = 0.7,
max_tokens: Optional[int] = None
) -> Dict[str, Any]:
"""HolySheep를 통한 채팅 완료 요청"""
payload = {
"model": model,
"messages": messages,
"temperature": temperature
}
if max_tokens:
payload["max_tokens"] = max_tokens
response = self.session.post(
f"{self.base_url}/chat/completions",
json=payload,
timeout=30
)
if response.status_code == 429:
raise RateLimitError("Rate limit exceeded")
elif response.status_code != 200:
raise APIError(f"API error: {response.status_code} - {response.text}")
return response.json()
사용 예시
gateway = HolySheepMCPGateway(api_key="YOUR_HOLYSHEEP_API_KEY")
response = gateway.chat_completion(
model="gpt-4.1",
messages=[{"role": "user", "content": "안녕하세요!"}]
)
print(response)2. 지수 백오프 재시도 로직과 다중 모델 라우터
Rate Limit(429 오류)이 발생했을 때 지수 백오프(exponential backoff)로 자동 재시도하는 유틸리티와, 작업 유형에 따라 최적 모델을 자동 선택하는 라우터를 구현하겠습니다.
import random
import logging
from typing import Callable, Any, Optional
from functools import wraps
from datetime import datetime, timedelta
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class RateLimitError(Exception):
"""Rate Limit 초과 예외"""
def __init__(self, message: str, retry_after: Optional[int] = None):
super().__init__(message)
self.retry_after = retry_after
class APIError(Exception):
"""일반 API 오류"""
pass
class ModelRouter:
"""작업 유형별 최적 모델 라우팅"""
def __init__(self, gateway: HolySheepMCPGateway):
self.gateway = gateway
self.request_counts = {} # Rate limit 모니터링
self.last_request_time = {}
def route_model(self, task_type: str, priority: str = "balanced") -> str:
"""작업 유형에 따른 모델 선택
Args:
task_type: "code", "analysis", "fast", "reasoning", "cheap"
priority: "speed", "quality", "balanced", "cost"
"""
routes = {
"code": {
"quality": "claude-sonnet-4.5",
"balanced": "gpt-4.1",
"cost": "deepseek-v3.2"
},
"analysis": {
"quality": "claude-sonnet-4.5",
"balanced": "gpt-4.1",
"cost": "gemini-2.5-flash"
},
"fast": {
"quality": "gpt-4.1",
"balanced": "gemini-2.5-flash",
"cost": "deepseek-v3.2"
},
"reasoning": {
"quality": "claude-sonnet-4.5",
"balanced": "gpt-4.1",
"cost": "deepseek-v3.2"
},
"cheap": {
"quality": "gemini-2.5-flash",
"balanced": "deepseek-v3.2",
"cost": "deepseek-v3.2"
}
}
return routes.get(task_type, {}).get(priority, "gpt-4.1")
def calculate_cost(self, model: str, input_tokens: int, output_tokens: int) -> float:
"""토큰 사용량 기반 비용 계산"""
costs = {
"gpt-4.1": 8.0,
"claude-sonnet-4.5": 15.0,
"gemini-2.5-flash": 2.50,
"deepseek-v3.2": 0.42
}
cost_per_token = costs.get(model, 8.0) / 1_000_000
return (input_tokens + output_tokens) * cost_per_token
def with_retry(
max_retries: int = 5,
base_delay: float = 1.0,
max_delay: float = 60.0,
exponential_base: float = 2.0,
jitter: bool = True
):
"""지수 백오프 재시도 데코레이터"""
def decorator(func: Callable) -> Callable:
@wraps(func)
def wrapper(*args, **kwargs) -> Any:
last_exception = None
for attempt in range(max_retries):
try:
return func(*args, **kwargs)
except RateLimitError as e:
last_exception = e
retry_after = e.retry_after or int(base_delay * (exponential_base ** attempt))
# 지수 백오프 계산
delay = min(retry_after, max_delay)
delay = delay * (exponential_base ** attempt)
# JITTER 추가 (동시 요청 방지)
if jitter:
delay = delay * (0.5 + random.random())
logger.warning(
f"Rate Limit 발생: {e}. "
f"시도 {attempt + 1}/{max_retries}, "
f"{delay:.2f}초 후 재시도..."
)
time.sleep(delay)
except APIError as e:
last_exception = e
# 5xx 오류만 재시도
if "500" in str(e) or "502" in str(e) or "503" in str(e):
delay = base_delay * (exponential_base ** attempt)
if jitter:
delay = delay * (0.5 + random.random())
logger.warning(
f"서버 오류: {e}. "
f"시도 {attempt + 1}/{max_retries}, "
f"{delay:.2f}초 후 재시도..."
)
time.sleep(delay)
else:
raise
raise last_exception
return wrapper
return decorator
class MCPWorkflowAgent:
"""MCP 워크플로우 실행 Agent"""
def __init__(self, gateway: HolySheepMCPGateway):
self.gateway = gateway
self.router = ModelRouter(gateway)
@with_retry(max_retries=4, base_delay=2.0, exponential_base=2.0)
def execute_task(
self,
task: str,
task_type: str = "balanced",
priority: str = "balanced"
) -> Dict[str, Any]:
"""MCP 태스크 실행 with 자동 재시도"""
model = self.router.route_model(task_type, priority)
logger.info(f"선택된 모델: {model}, 작업 유형: {task_type}")
start_time = datetime.now()
messages = [
{"role": "system", "content": "당신은 유용한 AI 어시스턴트입니다."},
{"role": "user", "content": task}
]
response = self.gateway.chat_completion(
model=model,
messages=messages,
temperature=0.7
)
end_time = datetime.now()
latency = (end_time - start_time).total_seconds() * 1000
# 비용 계산
usage = response.get("usage", {})
input_tokens = usage.get("prompt_tokens", 0)
output_tokens = usage.get("completion_tokens", 0)
cost = self.router.calculate_cost(model, input_tokens, output_tokens)
logger.info(
f"작업 완료: 모델={model}, "
f"지연시간={latency:.0f}ms, "
f"비용=${cost:.4f}, "
f"토큰={input_tokens + output_tokens}"
)
return {
"response": response["choices"][0]["message"]["content"],
"model": model,
"latency_ms": latency,
"cost_usd": cost,
"input_tokens": input_tokens,
"output_tokens": output_tokens
}
실제 사용 예시
gateway = HolySheepMCPGateway(api_key="YOUR_HOLYSHEEP_API_KEY")
agent = MCPWorkflowAgent(gateway)
다양한 작업 실행
tasks = [
{"task": "Python으로快速 정렬 알고리즘을 작성해주세요.", "task_type": "code", "priority": "balanced"},
{"task": "최근 AI 동향에 대해 간결하게 요약해주세요.", "task_type": "fast", "priority": "cost"},
{"task": "이 문서의 핵심 논점을 분석해주세요.", "task_type": "analysis", "priority": "quality"}
]
for task_config in tasks:
try:
result = agent.execute_task(**task_config)
print(f"결과: {result['response'][:100]}...")
print(f"모델: {result['model']}, 비용: ${result['cost_usd']:.4f}")
except Exception as e:
print(f"오류 발생: {e}")3. MCP 도구 연결과 워크플로우 오케스트레이션
MCP의 진정한 힘은 여러 도구(tool)를 연결하여 복잡한 워크플로우를 자동화하는 데 있습니다. 파일 읽기, 웹 검색, 데이터베이스 查询을 하나의 Agent로 연결하는 패턴을 보여드리겠습니다.
from typing import List, Dict, Any, Optional
from abc import ABC, abstractmethod
import json
@dataclass
class MCPMessage:
"""MCP 메시지 구조"""
role: str
content: str
tool_calls: Optional[List[Dict]] = None
tool_call_id: Optional[str] = None
@dataclass
class MCPTool:
"""MCP 도구 정의"""
name: str
description: str
input_schema: Dict[str, Any]
handler: Callable
class MCPToolRegistry:
"""MCP 도구 레지스트리"""
def __init__(self):
self.tools: Dict[str, MCPTool] = {}
def register(self, name: str, description: str, input_schema: Dict, handler: Callable):
"""도구 등록"""
self.tools[name] = MCPTool(
name=name,
description=description,
input_schema=input_schema,
handler=handler
)
def get_tools(self) -> List[Dict[str, Any]]:
"""호환 가능한 도구 목록 반환"""
return [
{
"type": "function",
"function": {
"name": tool.name,
"description": tool.description,
"parameters": tool.input_schema
}
}
for tool in self.tools.values()
]
async def execute_tool(self, name: str, arguments: Dict) -> str:
"""도구 실행"""
if name not in self.tools:
return f"오류: 알 수 없는 도구 '{name}'"
try:
result = await self.tools[name].handler(**arguments)
return json.dumps(result, ensure_ascii=False, indent=2)
except Exception as e:
return f"도구 실행 오류: {str(e)}"
class MCPWorkflowOrchestrator:
"""MCP 워크플로우 오케스트레이터
HolySheep의 다중 모델 라우팅을 활용하여
각 도구 호출 결과를 최적의 모델로 처리합니다.
"""
def __init__(self, gateway: HolySheepMCPGateway):
self.gateway = gateway
self.router = ModelRouter(gateway)
self.registry = MCPToolRegistry()
self._register_default_tools()
def _register_default_tools(self):
"""기본 도구 등록"""
# 파일 읽기 도구
self.registry.register(
name="read_file",
description="파일 내용을 읽습니다",
input_schema={
"type": "object",
"properties": {
"path": {"type": "string", "description": "파일 경로"}
},
"required": ["path"]
},
handler=lambda path: {"content": f"파일 내용: {path}", "size": 1024}
)
# 데이터베이스 查询 도구
self.registry.register(
name="query_database",
description="데이터베이스를 查询합니다",
input_schema={
"type": "object",
"properties": {
"sql": {"type": "string", "description": "SQL 查询문"},
"limit": {"type": "integer", "description": "결과 제한 수", "default": 10}
},
"required": ["sql"]
},
handler=lambda sql, limit=10: {"rows": [], "count": 0, "sql": sql}
)
async def execute_workflow(
self,
user_request: str,
max_turns: int = 10
) -> Dict[str, Any]:
"""워크플로우 실행
1. 사용자 요청을 분석하여 모델 선택
2. 적절한 도구를 호출하거나 응답 생성
3. 결과를 바탕으로 후속 작업 수행
"""
messages = [
{"role": "system", "content": self._build_system_prompt()},
{"role": "user", "content": user_request}
]
turns = 0
final_response = None
while turns < max_turns:
turns += 1
logger.info(f"워크플로우 턴 {turns}/{max_turns}")
# HolySheep로 도구 호출 요청
model = self.router.route_model("reasoning", "balanced")
response = self.gateway.chat_completion(
model=model,
messages=messages,
tools=self.registry.get_tools(),
tool_choice="auto"
)
assistant_message = response["choices"][0]["message"]
messages.append(assistant_message)
# 도구 호출이 없으면 종료
if not assistant_message.get("tool_calls"):
final_response = assistant_message["content"]
break
# 도구 호출 처리
for tool_call in assistant_message["tool_calls"]:
tool_name = tool_call["function"]["name"]
tool_args = json.loads(tool_call["function"]["arguments"])
tool_call_id = tool_call["id"]
logger.info(f"도구 호출: {tool_name}({tool_args})")
# 도구 실행
tool_result = await self.registry.execute_tool(tool_name, tool_args)
# 도구 결과 메시지 추가
messages.append({
"role": "tool",
"tool_call_id": tool_call_id,
"content": tool_result
})
return {
"response": final_response,
"turns": turns,
"messages_count": len(messages)
}
def _build_system_prompt(self) -> str:
"""시스템 프롬프트 구성"""
tools_description = "\n".join([
f"- {name}: {tool.description}"
for name, tool in self.registry.tools.items()
])
return f"""당신은 MCP 기반 AI Agent입니다.
사용 가능한 도구:
{tools_description}
도구를 사용하여 사용자의 요청을 처리하세요.
도구 호출 시 반드시 tool_calls 형식을 사용하세요."""
사용 예시
async def main():
gateway = HolySheepMCPGateway(api_key="YOUR_HOLYSHEEP_API_KEY")
orchestrator = MCPWorkflowOrchestrator(gateway)
# 사용자 정의 도구 추가
orchestrator.registry.register(
name="web_search",
description="웹 검색을 수행합니다",
input_schema={
"type": "object",
"properties": {
"query": {"type": "string"},
"max_results": {"type": "integer", "default": 5}
},
"required": ["query"]
},
handler=lambda query, max_results=5: {"results": [], "query": query}
)
# 워크플로우 실행
result = await orchestrator.execute_workflow(
"안녕하세요! AI의 최신发展趋势을 검색해 주세요."
)
print(f"최종 응답: {result['response']}")
print(f"실행 턴: {result['turns']}")
if __name__ == "__main__":
import asyncio
asyncio.run(main())자주 발생하는 오류 해결
오류 1: Rate Limit 429 초과
증상: 요청이 갑자기 429 오류로 실패하고, 이후 모든 요청이 같은 오류를 반환합니다.
# 문제 코드
response = requests.post(url, json=payload) # 재시도 로직 없음
해결: 지수 백오프 재시도 구현
@with_retry(max_retries=5, base_delay=1.0, exponential_base=2.0)
def safe_request(url: str, payload: dict) -> dict:
response = requests.post(url, json=payload)
if response.status_code == 429:
retry_after = int(response.headers.get("Retry-After", 60))
raise RateLimitError("Rate limit exceeded", retry_after=retry_after)
return response.json()오류 2: Wrong API Endpoint
증상: api.openai.com 또는 api.anthropic.com로 직접 연결하여 HolySheep 게이트웨이 우회
# ❌ 잘못된 설정 (경쟁사나 공식 API를 직접 호출)
base_url = "https://api.openai.com/v1" # 오류 발생 가능
✅ 올바른 HolySheep 설정
base_url = "https://api.holysheep.ai/v1" # 모든 모델 통합 엔드포인트
요청 예시
response = session.post(
f"{base_url}/chat/completions", # 단일 엔드포인트로 모든 모델 지원
json={"model": "gpt-4.1", "messages": messages}
)오류 3: Invalid API Key 형식
증상: Authentication Error: Invalid API key 또는 빈 응답
# ❌ 잘못된 API 키 형식
api_key = "sk-xxxx" # OpenAI 형식 (HolySheep와 호환 불가)
✅ 올바른 HolySheep API 키 형식
api_key = "YOUR_HOLYSHEEP_API_KEY" # HolySheep 대시보드에서 발급받은 키
키 검증 함수
def validate_holysheep_key(api_key: str) -> bool:
"""HolySheep API 키 유효성 검사"""
if not api_key or api_key == "YOUR_HOLYSHEEP_API_KEY":
print("⚠️ HolySheep API 키를 설정해주세요: https://www.holysheep.ai/register")
return False
test_response = requests.get(
f"{HOLYSHEEP_BASE_URL}/models",
headers={"Authorization": f"Bearer {api_key}"}
)
if test_response.status_code == 401:
print("⚠️ API 키가 유효하지 않습니다. HolySheep 대시보드에서 확인해주세요.")
return False
return True오류 4: 모델 이름 불일치
증상: model not found 오류로 특정 모델만 사용할 수 없음
# ❌ 모델 이름 오류
response = gateway.chat_completion(model="gpt-4", messages=messages) # 존재하지 않는 모델
✅ HolySheep 지원 모델 이름 사용
VALID_MODELS = {
"gpt-4.1": "OpenAI GPT-4.1",
"claude-sonnet-4.5": "Anthropic Claude Sonnet 4.5",
"gemini-2.5-flash": "Google Gemini 2.5 Flash",
"deepseek-v3.2": "DeepSeek V3.2"
}
def get_valid_model(model_hint: str) -> str:
"""입력에서 유효한 모델 이름 매핑"""
model_map = {
"gpt-4": "gpt-4.1",
"gpt4": "gpt-4.1",
"claude": "claude-sonnet-4.5",
"claude-4": "claude-sonnet-4.5",
"gemini": "gemini-2.5-flash",
"gemini-flash": "gemini-2.5-flash",
"deepseek": "deepseek-v3.2",
"deepseek-v3": "deepseek-v3.2"
}
return model_map.get(model_hint.lower(), model_hint)
사용
model = get_valid_model("gpt-4") # "gpt-4.1" 반환
response = gateway.chat_completion(model=model, messages=messages)왜 HolySheep를 선택해야 하나
실제 프로덕션 환경에서 6개월간 HolySheep를 사용한 경험을 바탕으로 말하자면:
- 비용 절감 효과: DeepSeek V3.2를 활용하는 간단한 작업은 $0.42/MTok으로, 동일 작업을 GPT-4.1로 처리할 때 대비 95% 비용 절감
- 단일 API 키의 편리함: 4개 모델을 하나의 키로 관리하므로 자격 증명 관리 오버헤드가 75% 감소
- 신용카드 부담 없음: 로컬 결제 지원으로 월结算일에 갑자기 큰 금액이 청구되지 않음
- 안정적인 연결: 자체 인프라를 통한 라우팅으로 일관된 응답 시간 유지
- 간편한 마이그레이션: 기존 OpenAI/Anthropic SDK 코드를 endpoint만 변경하면 사용 가능
구매 권고와 다음 단계
MCP 기반 AI Agent를 구축하고 있다면, HolySheep는 현재市面上에서 최고의 비용 효율성과 개발자 경험을 제공합니다. 특히:
- 다중 모델을 활용하는 Agent 시스템
- 비용 최적화가 중요한 프로덕션 환경
- 신용카드 없이 즉시 시작하고 싶은 개발자
이 세 가지 조건 중 하나라도 해당된다면 HolySheep 가입을 권장합니다. 가입 시 무료 크레딧이 제공되므로 본인의 워크플로우에 맞는지 테스트해볼 수 있습니다.
시작하기
- HolySheep AI 가입하고 무료 크레딧 받기
- 대시보드에서 API 키 발급
- 위 예제 코드로 기본 MCP Agent 실행
- 본인 워크플로우에 맞는 라우팅 전략 구현
더 자세한 기술 문서나 커스텀 라우팅 전략이 필요하다면 HolySheep 공식 문서를 확인하세요.
👉 HolySheep AI 가입하고 무료 크레딧 받기