AI로 자동화 만들기: API, 비용, 실패 처리
LLM API로 고객 문의 분류 자동화를 만들면서 실서비스에 필요한 것들을 익혀요. API 키를 안전하게 다루는 법, 돈을 쓰지 않고 가짜 서버로 코드를 시험하는 법, 응답의 멈춘 이유와 토큰 사용량 읽기, 모델과 캐시와 배치에 따라 비용이 몇 배씩 달라지는 계산, 다시 보내도 되는 오류와 안 되는 오류, 정해진 JSON 형식으로 답하게 하기, 중간에 멈춰도 처음부터 다시 하지 않는 체크포인트와 예산 한도까지 코드로 다뤄요.
LLM 트랙에서 모델이 어떻게 작동하는지 배웠다면, 이제 실제로 일을 시킬 차례예요. 이번 강의에서는 쇼핑몰에 들어오는 고객 문의를 자동으로 분류하고 한 줄로 요약하는 프로그램을 만들어요. 채팅 창에 문의를 하나씩 붙여 넣는 대신, 코드가 API로 모델에게 요청을 보내고 결과를 받아 정리해요.
채팅 창에서 몇 번 해 보는 것과 하루 1,000건을 자동으로 처리하는 것은 전혀 달라요. 1,000번 보내면 몇 번은 실패하고, 돈이 생각보다 많이 나가고, 중간에 멈추기도 해요. 이번 강의는 그런 일을 처음부터 설계에 넣는 법이 중심이에요. 예제는 Claude API와 파이썬 SDK로 쓰지만, 다른 회사의 API도 구조는 거의 같아요.
준비: API 키 다루기
API를 쓰려면 제공사 콘솔에서 API 키를 만들어요. 키는 내 계정으로 돈을 쓸 수 있는 비밀번호예요. 그래서 다루는 원칙이 분명해요.
- 코드에 직접 적지 않아요. 환경 변수에 넣고, 코드는 환경 변수에서 읽어요. 파이썬 SDK는
ANTHROPIC_API_KEY환경 변수를 알아서 읽어요. - 저장소에 올리지 않아요. 키를 적은
.env파일은.gitignore에 넣어요. 공개 저장소에 올라간 키는 몇 분 안에 자동 수집기에 털릴 수 있어요. 실수로 올렸다면 바로 콘솔에서 키를 폐기하고 새로 만들어요. 커밋을 지우는 것만으로는 부족해요. - 용도마다 따로 만들어요. 프로젝트마다 키를 나누면, 하나가 새어도 그것만 폐기하면 되고 어디서 돈이 나가는지도 보여요.
- 지출 한도를 걸어요. 콘솔에서 월 사용 한도를 정해 두면, 코드 실수로 반복 호출이 일어나도 피해가 한도에서 멈춰요.
pip install anthropic
export ANTHROPIC_API_KEY="sk-ant-..." # 윈도 PowerShell이라면 $env:ANTHROPIC_API_KEY="sk-ant-..."
돈을 쓰지 않고 시험하는 법: 가짜 서버
API 호출에는 돈이 들어요. 코드를 고칠 때마다 진짜로 보내면 시험 비용이 쌓이고, 일부러 오류를 일으켜 보기도 어려워요. 그래서 진짜 API처럼 생긴 응답을 돌려주는 가짜 서버를 만들어 시험하는 게 좋은 습관이에요. 이 강의의 코드도 이 가짜 서버로 돌아가서, 키가 없어도 모두 따라 할 수 있어요.
import json
import anthropic
import httpx2
calls = [] # 가짜 서버가 받은 요청 기록
FAIL_AT = {} # {몇 번째 요청: 돌려줄 오류 코드}
def fake_api(request):
body = json.loads(request.content)
calls.append(body)
n = len(calls)
if n in FAIL_AT: # 정해 둔 차례에는 일부러 실패해요
status = FAIL_AT[n]
kind = {429: "rate_limit_error", 400: "invalid_request_error"}.get(status, "api_error")
return httpx2.Response(status, json={"type": "error", "error": {"type": kind, "message": "가짜 오류"}})
question = body["messages"][-1]["content"]
if "[거절]" in question: # 모델이 답을 거절하는 경우를 흉내 내요
return httpx2.Response(200, json={
"id": f"msg_fake_{n}", "type": "message", "role": "assistant", "model": body["model"],
"content": [], "stop_reason": "refusal", "stop_sequence": None,
"stop_details": {"type": "refusal", "category": None, "explanation": "가짜 거절"},
"usage": {"input_tokens": 20, "output_tokens": 0},
})
label = next((k for k in ("배송", "환불", "상품", "계정") if k in question), "기타")
if "format" in body.get("output_config", {}): # JSON 형식을 요청받으면 JSON으로
answer = json.dumps({"category": label, "summary": question[:40]}, ensure_ascii=False)
else:
answer = label
prompt = (body.get("system") or "") + question
return httpx2.Response(200, json={
"id": f"msg_fake_{n}", "type": "message", "role": "assistant", "model": body["model"],
"content": [{"type": "text", "text": answer}],
"stop_reason": "end_turn", "stop_sequence": None,
"usage": {"input_tokens": len(prompt) // 2, "output_tokens": len(answer) // 2 + 5},
})
client = anthropic.Anthropic(
api_key="sk-fake-for-practice",
http_client=anthropic.DefaultHttpxClient(transport=httpx2.MockTransport(fake_api)),
)
# 진짜로 보낼 때는 이 한 줄이면 돼요: client = anthropic.Anthropic()
가짜 서버는 문의에 "배송" 같은 낱말이 있는지만 보고 대충 답해요. 모델의 실력을 흉내 내려는 게 아니라, 우리 코드가 응답과 오류를 제대로 다루는지 보려는 거예요. 토큰 수도 글자 수로 지어낸 가짜 숫자예요. 진짜 비용은 진짜 응답의 숫자로 계산해요.
첫 요청 보내기
response = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
output_config={"effort": "low"},
system="너는 쇼핑몰 고객 문의를 배송, 환불, 상품, 계정, 기타 중 하나로 분류해. 낱말 하나로만 답해.",
messages=[{"role": "user", "content": "주문한 지 일주일인데 배송이 아직 안 왔어요."}],
)
for block in response.content:
if block.type == "text":
print(block.text)
print(response.stop_reason, response.usage.input_tokens, response.usage.output_tokens)
배송
end_turn 40 6
(가짜 서버의 응답이에요.) 요청의 각 부분은 이런 뜻이에요.
model: 어떤 모델에게 보낼지예요.max_tokens: 답의 최대 길이예요. 이 모델은 답하기 전에 생각을 하는데, 생각에 쓴 토큰도 출력 토큰으로 계산되고 이 한도 안에 들어가요. 너무 작게 잡으면 답이 잘려요.output_config의effort: 얼마나 깊이 생각할지예요. 분류처럼 쉬운 일은low로 낮추면 빠르고 싸요. 어려운 일일수록 높여요.system: 모든 요청에 공통인 지시예요. 프롬프트 강의의 원칙이 그대로 적용돼요.messages: 대화 내용이에요. API는 기억이 없어서, 여러 턴 대화라면 매번 앞의 대화를 전부 다시 보내요.
응답에서는 세 가지를 꼭 확인해요.
content: 답의 내용이에요. 여러 블록의 목록이라,type이text인 블록에서 글을 꺼내요.stop_reason: 왜 멈췄는지예요.end_turn은 정상 완료,max_tokens는 한도에 걸려 잘림,refusal은 안전 문제로 거절,tool_use는 도구 호출 요청(에이전트 강의)이에요. 결과를 쓰기 전에 꼭 확인해요.usage: 입력과 출력 토큰 수예요. 비용 계산의 근거예요.
비용 계산하기
API 요금은 토큰 단위로 매겨요. 입력보다 출력이 몇 배 비싸고, 모델마다 가격이 크게 달라요. 하루 문의 1,000건을 처리한다고 하고 계산해 볼게요. 모든 요청에 공통인 지시와 예시가 3,000토큰, 문의 하나가 평균 200토큰, 답(생각 포함)이 평균 150토큰이라고 가정해요.
PRICES = { # 2026년 11월 기준, 100만 토큰당 달러 (입력, 출력)
"claude-opus-5-5": (4.00, 20.00),
"claude-sonnet-5-5": (2.00, 10.00),
"claude-haiku-5-5": (0.10, 0.50),
}
n, shared, own, out = 1000, 3000, 200, 150 # 건수, 공통 지시, 문의 하나, 답 하나 (토큰)
for model, (p_in, p_out) in PRICES.items():
cost = n * ((shared + own) * p_in + out * p_out) / 1e6
print(f"{model}: ${cost:.2f}")
p_in, p_out = PRICES["claude-opus-5-5"]
plain = n * ((shared + own) * p_in + out * p_out) / 1e6
first = (shared * p_in * 1.25 + own * p_in + out * p_out) / 1e6 # 첫 요청: 캐시에 쓰기 (1.25배)
rest = (n - 1) * (shared * 0.20 + own * p_in + out * p_out) / 1e6 # 나머지: 캐시에서 읽기
print(f"캐시: ${first + rest:.2f} ({1 - (first + rest) / plain:.0%} 절약)")
print(f"배치: ${plain * 0.5:.2f} (50% 할인)")
claude-opus-5-5: $15.80
claude-sonnet-5-5: $7.90
claude-haiku-5-5: $0.40
캐시: $4.41 (72% 절약)
배치: $7.90 (50% 할인)
가격은 바뀔 수 있으니 실제로 쓸 때는 공식 가격표를 확인하세요. 계산에서 세 가지를 배울 수 있어요.
- 모델 선택이 수십 배를 좌우해요. 같은 일에 0.40달러에서 15.80달러까지 차이가 나요. 다만 싼 모델이 이 일을 충분히 잘하는지는 평가 세트로 재 봐야 알아요(LLM 평가 강의). 비용만 보고 고르면 안 되고, 품질을 지키는 가장 싼 선택을 찾는 거예요.
- 공통 부분은 캐시로 줄여요. 모든 요청의 앞부분이 똑같다면, 한 번 계산한 결과를 저장해 두고 다시 쓰는 프롬프트 캐시를 켤 수 있어요. 이 모델은 캐시 읽기가 입력 가격의 20분의 1이라 72%가 줄었어요. 캐시는 앞부분이 글자 하나까지 같아야 맞고, 요청 사이 간격이 5분을 넘으면(기본 설정) 사라져요. 그래서 날짜나 요청 번호처럼 매번 바뀌는 내용은 공통 부분 뒤에 둬요.
- 기다릴 수 있으면 배치로 보내요. 누가 답을 기다리는 게 아니라면, 요청을 모아 한꺼번에 맡기는 배치 기능으로 절반 가격에 처리할 수 있어요. 대신 결과가 바로 오지 않고 몇 분에서 길게는 하루 안에 와요.
출력 토큰이 비싸다는 것도 기억해요. 답을 짧게 요청하고, 쉬운 일에는 생각의 깊이(effort)를 낮추는 것도 비용을 줄이는 방법이에요.
실패는 반드시 일어나요
하루 1,000번 요청하면 몇 번은 실패해요. 중요한 건 어떤 실패는 다시 보내면 되고, 어떤 실패는 다시 보내도 소용없다는 구분이에요.
| 상태 코드 | 뜻 | 다시 보내면? | 할 일 |
|---|---|---|---|
| 400 | 요청이 잘못됨 | 소용없어요 | 기록하고 건너뛰고, 코드를 고쳐요 |
| 401, 403 | 키가 틀렸거나 권한이 없음 | 소용없어요 | 전체를 멈추고 설정을 고쳐요 |
| 429 | 너무 자주 보냄(요청 한도) | 기다렸다 보내면 돼요 | 속도를 줄여요 |
| 500, 529 | 서버 쪽 문제, 과부하 | 기다렸다 보내면 돼요 | 잠시 뒤 다시 |
| 연결 오류, 시간 초과 | 네트워크 문제 | 대개 돼요 | 잠시 뒤 다시 |
다시 보낼 때는 점점 길게 기다려요(0.5초, 1초, 2초, 4초처럼). 서버가 힘들어서 실패했는데 모두가 곧바로 다시 보내면 더 힘들어지니까요. 여기에 무작위로 조금씩 다른 시간을 더해서, 동시에 실패한 요청들이 동시에 다시 몰리지 않게 해요. 다행히 SDK가 이걸 이미 해 줘요. 다시 보내도 되는 오류는 기본으로 두 번까지 알아서 다시 보내요. 가짜 서버로 확인해 볼게요.
start = len(calls)
FAIL_AT = {start + 1: 429} # 다음 요청 하나를 "너무 자주 보냄"으로 실패시켜요
response = client.messages.create(
model="claude-opus-5-5", max_tokens=1024, output_config={"effort": "low"},
messages=[{"role": "user", "content": "환불은 언제 되나요?"}],
)
print(response.content[0].text, "| 실제로 보낸 요청:", len(calls) - start)
start = len(calls)
FAIL_AT = {start + 1: 400} # 이번엔 "요청이 잘못됨"
try:
client.messages.create(model="claude-opus-5-5", max_tokens=1024,
messages=[{"role": "user", "content": "계정 비밀번호를 잊었어요"}])
except anthropic.BadRequestError as e:
print("오류", e.status_code, "| 실제로 보낸 요청:", len(calls) - start)
FAIL_AT = {}
환불 | 실제로 보낸 요청: 2
오류 400 | 실제로 보낸 요청: 1
429 오류는 SDK가 알아서 다시 보내서, 우리 코드는 실패를 눈치채지도 못하고 답을 받았어요. 400 오류는 다시 보내지 않고 바로 오류를 냈어요. 다시 보내 봐야 같은 결과니까요. 다시 보내는 횟수는 anthropic.Anthropic(max_retries=5)처럼 바꿀 수 있어요.
그런데 SDK가 다시 보내도 계속 실패하면 어떻게 할까요? 서버가 몇 분씩 멈추는 일도 있어요. 그럴 때는 그 건을 건너뛰고 나중에 다시 처리할 수 있게 설계해야 해요. 그게 아래의 체크포인트예요.
정해진 형식으로 답하게 하기
분류 결과를 프로그램이 쓰려면 답이 항상 같은 형식이어야 해요. "배송이에요!"나 "이건 배송 문제로 보여요" 같은 답은 프로그램이 다루기 어려워요. 그래서 JSON 스키마로 답의 모양을 정해 줘요. 이 기능(구조화 출력)을 쓰면 답이 스키마에 맞는 JSON으로 오도록 보장돼요. 분류는 enum으로 정해진 값 중에서만 고르게 해요.
import pathlib
CATEGORIES = ["배송", "환불", "상품", "계정", "기타"]
SCHEMA = {
"type": "object",
"properties": {
"category": {"type": "string", "enum": CATEGORIES},
"summary": {"type": "string", "description": "문의 내용을 30자 안으로 요약"},
},
"required": ["category", "summary"],
"additionalProperties": False,
}
SYSTEM = ("너는 쇼핑몰 고객 문의를 분류하고 요약하는 담당자야. "
"category는 배송, 환불, 상품, 계정, 기타 중 하나로 고르고, summary는 30자 안으로 써.")
PRICE_IN, PRICE_OUT = 4.00, 20.00 # claude-opus-5-5, 100만 토큰당 달러
def classify(text):
response = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
output_config={"effort": "low", "format": {"type": "json_schema", "schema": SCHEMA}},
system=SYSTEM,
messages=[{"role": "user", "content": text}],
)
cost = (response.usage.input_tokens * PRICE_IN + response.usage.output_tokens * PRICE_OUT) / 1e6
if response.stop_reason != "end_turn": # 거절(refusal)이나 잘림(max_tokens)
return None, cost, response.stop_reason
data = json.loads(next(b.text for b in response.content if b.type == "text"))
return data, cost, "ok"
print(classify("상품 색이 사진이랑 너무 달라요."))
({'category': '상품', 'summary': '상품 색이 사진이랑 너무 달라요.'}, 0.000812, 'ok')
형식은 보장돼도 내용이 맞는지는 따로 봐야 해요. "30자 안으로"라고 해도 더 길게 쓸 수 있고, 분류가 틀릴 수도 있어요. 그래서 간단한 규칙으로 검사하고, 걸리는 건 사람이 확인할 목록으로 보내요. 거절당한 문의도 마찬가지예요. 자동화는 모든 걸 기계가 처리하는 게 아니라, 기계가 확실한 것을 처리하고 애매한 것을 사람에게 넘기는 거예요.
끝까지 처리하기: 체크포인트와 예산
이제 문의 목록 전체를 처리해요. 세 가지 장치를 넣어요.
- 체크포인트: 한 건 처리할 때마다 결과를 파일에 한 줄씩 바로 써요. 중간에 멈추면 다음 실행 때 파일을 읽고 이미 처리한 건은 건너뛰어요. 처음부터 다시 하면 돈을 두 번 써요.
- 오류별 처리: 위의 표대로, 다시 해 볼 만한 실패는 기록하지 않고 넘어가서 다음 실행 때 다시 시도하고, 키 문제는 전체를 멈춰요.
- 예산 한도: 쓴 돈을 더해 가다가 한도에 닿으면 멈춰요.
def run(inquiries, out_path="results.jsonl", budget=1.00):
out = pathlib.Path(out_path)
done = set()
if out.exists(): # 이미 처리한 건 다시 보내지 않아요
done = {json.loads(line)["id"] for line in out.read_text(encoding="utf-8").splitlines()}
spent, sent_before = 0.0, len(calls)
with out.open("a", encoding="utf-8") as f:
for item in inquiries:
if item["id"] in done:
continue
if spent >= budget:
print(" 예산에 닿아 멈춰요")
break
try:
data, cost, status = classify(item["text"])
except anthropic.BadRequestError as e: # 요청이 잘못됨: 다시 보내도 같아요
data, cost, status = None, 0.0, f"요청 오류 {e.status_code}"
except (anthropic.AuthenticationError, anthropic.PermissionDeniedError):
raise # 키나 권한 문제: 전부 멈추고 사람이 고쳐요
except anthropic.RateLimitError:
print(f" {item['id']}번: 요청 한도에 걸림, 다음 실행 때 다시")
continue
except anthropic.APIStatusError as e:
if e.status_code < 500:
raise
print(f" {item['id']}번: 서버 오류 {e.status_code}, 다음 실행 때 다시")
continue # 기록하지 않았으니 다음 실행 때 다시 시도해요
except anthropic.APIConnectionError:
print(f" {item['id']}번: 연결 오류, 다음 실행 때 다시")
continue
spent += cost
if status == "ok" and len(data["summary"]) > 30:
status = "사람 확인: 요약이 김"
elif status == "refusal":
status = "사람 확인: 모델이 거절"
row = {"id": item["id"], "status": status, **(data or {})}
f.write(json.dumps(row, ensure_ascii=False) + "\n")
f.flush() # 바로 디스크에 써요
print(" ", row)
print(f" 이번 실행에서 보낸 요청 {len(calls) - sent_before}번, 쓴 돈 ${spent:.6f}")
가짜 서버에게 셋째 문의의 요청을 세 번 연속 실패하게 해서, SDK가 두 번 다시 보내도 결국 실패하는 상황을 만들어 볼게요.
inquiries = [
{"id": 1, "text": "주문한 지 일주일인데 배송이 아직 안 왔어요."},
{"id": 2, "text": "환불 신청했는데 언제 들어오나요?"},
{"id": 3, "text": "상품 색이 사진이랑 너무 달라요."},
{"id": 4, "text": "계정 비밀번호를 잊어버렸어요."},
{"id": 5, "text": "[거절] 거절되는 경우를 시험하는 문의예요."},
{"id": 6, "text": "주말에도 배송되나요? 다음 주 월요일이 생일이라 그 전에 꼭 받아야 하거든요."},
]
pathlib.Path("results.jsonl").unlink(missing_ok=True) # 연습이라 결과 파일을 지우고 시작해요
start = len(calls)
FAIL_AT = {start + 3: 500, start + 4: 500, start + 5: 500} # 셋째 문의: 세 번 연속 서버 오류
print("첫 실행")
run(inquiries)
FAIL_AT = {}
print("다시 실행")
run(inquiries)
첫 실행
{'id': 1, 'status': 'ok', 'category': '배송', 'summary': '주문한 지 일주일인데 배송이 아직 안 왔어요.'}
{'id': 2, 'status': 'ok', 'category': '환불', 'summary': '환불 신청했는데 언제 들어오나요?'}
3번: 서버 오류 500, 다음 실행 때 다시
{'id': 4, 'status': 'ok', 'category': '계정', 'summary': '계정 비밀번호를 잊어버렸어요.'}
{'id': 5, 'status': '사람 확인: 모델이 거절'}
{'id': 6, 'status': '사람 확인: 요약이 김', 'category': '배송', 'summary': '주말에도 배송되나요? 다음 주 월요일이 생일이라 그 전에 꼭 받아야 하거'}
이번 실행에서 보낸 요청 8번, 쓴 돈 $0.003672
다시 실행
{'id': 3, 'status': 'ok', 'category': '상품', 'summary': '상품 색이 사진이랑 너무 달라요.'}
이번 실행에서 보낸 요청 1번, 쓴 돈 $0.000812
첫 실행에서 요청이 8번 나갔어요. 문의 6건에 셋째 문의의 다시 보내기 2번이 더해졌어요. SDK가 두 번 다시 보내도 실패하자, 우리 코드는 셋째 문의를 기록하지 않고 넘어갔어요. 나머지는 멈추지 않고 처리했어요. 다시 실행하자 파일에 있는 다섯 건은 건너뛰고 셋째 문의 하나만 보냈어요. 중간에 프로그램이 통째로 꺼졌더라도 마찬가지예요. 거절된 문의와 요약이 긴 문의는 사람이 확인할 목록에 올랐어요.
참고로 Claude API에는 안전 분류기가 요청을 거절했을 때 다른 모델로 자동으로 넘겨 다시 시도하게 하는 옵션(베타 기능인 fallbacks)도 있어요. 거절이 잦은 분야라면 검토해 볼 만해요.
서비스로 돌릴 때 챙길 것
- 기록 남기기: 요청마다 요청 번호(응답의
_request_id), 토큰 수, 비용, 걸린 시간, 결과 상태를 남겨요. 문제가 생겼을 때 이 기록 없이는 원인을 찾기 어려워요. - 지켜보기: 오류 비율, 하루 비용, 사람 확인 비율이 갑자기 늘면 알림이 오게 해요. 사람 확인 비율이 늘었다면 문의 유형이 바뀌었을 수 있어요.
- 속도 조절: API에는 분당 요청 수와 토큰 수 한도가 있어요. 1,000건을 하나씩 보내면 오래 걸리니 몇 개씩 동시에 보내되(비동기 클라이언트), 동시에 보내는 수를 제한해서 429를 줄여요. 급하지 않다면 배치가 가장 싸고 편해요.
- 개인 정보: 꼭 필요하지 않은 개인 정보(전화번호, 주소, 카드 번호)는 보내기 전에 지우거나 가려요. API 제공사의 데이터 보관과 학습 활용 정책도 확인해요.
- 프롬프트와 모델도 코드처럼: 시스템 지시를 바꾸거나 모델을 바꾸기 전에 평가 세트로 전후를 비교하고, 어떤 버전으로 처리했는지 결과와 함께 기록해요.
- 사람의 자리: 애매한 건을 사람에게 넘기는 흐름이 있어야 오류가 고객에게 바로 가지 않아요. 사람이 고친 결과는 다음 평가 세트와 예시의 좋은 재료가 돼요.
실습
- 가짜 서버에서
FAIL_AT을{start + 1: 401}로 바꾸면run은 어떻게 되나요? 그렇게 설계한 이유는 무엇일까요? run의budget을 아주 작게(예:0.001) 잡고 실행해 보세요. 몇 건에서 멈추나요? 다시 실행하면 어떻게 되나요?- 비용 계산에서 공통 지시를 3,000토큰에서 500토큰으로 줄이면 캐시의 효과는 어떻게 되나요? 이 모델의 최소 캐시 길이(512토큰)도 고려해 보세요.
- 출력 토큰을 150에서 50으로 줄이면 Opus 5.5의 하루 비용은 얼마가 되나요?
classify의 결과에 "확신도"를 0에서 1 사이 숫자로 함께 받도록 스키마를 바꾸고, 확신도가 낮으면 사람 확인으로 보내도록run을 고쳐 보세요.
자주 하는 실수
- 키를 코드나 저장소에 넣기. 환경 변수로 읽고, 새면 바로 폐기해요.
stop_reason을 확인하지 않기. 잘리거나 거절된 답을 정상 결과로 저장하게 돼요.- 모든 오류를 똑같이 다시 보내기. 400을 다시 보내면 돈과 시간만 버려요.
- 결과를 마지막에 한꺼번에 저장하기. 중간에 멈추면 처음부터 다시 하며 돈을 두 번 써요.
- 가격표만 보고 모델 고르기. 평가 세트로 품질을 확인한 뒤 골라요.
- 매번 바뀌는 내용을 프롬프트 앞부분에 넣기. 캐시가 맞지 않아 비용이 줄지 않아요.
- 시험할 때마다 진짜 API 부르기. 가짜 서버로 흐름과 오류 처리를 먼저 확인해요.
점검 문제
- API 키를 코드에 직접 적으면 안 되는 이유와, 실수로 공개했을 때 할 일은?
stop_reason이max_tokens라면 무슨 뜻이고 어떻게 해야 하나요?- 429와 400 오류를 다르게 다뤄야 하는 이유는?
- 다시 보낼 때 기다리는 시간을 점점 늘리고 무작위성을 더하는 이유는?
- 프롬프트 캐시가 효과를 보려면 프롬프트를 어떻게 구성해야 하나요?
- 체크포인트가 없으면 생기는 문제는?
- 구조화 출력으로 형식을 보장받아도 검사가 필요한 이유는?
정답
- 키는 내 계정으로 돈을 쓸 수 있는 비밀번호라서, 코드가 공유되거나 저장소에 올라가면 누구나 쓸 수 있어요. 실수로 공개했다면 바로 콘솔에서 폐기하고 새 키를 만들어요.
- 답이 최대 길이에 걸려 잘렸다는 뜻이에요. 결과를 그대로 쓰지 말고
max_tokens를 늘리거나 답을 짧게 요청해서 다시 보내요. - 429는 잠시 기다리면 해결되는 일시적 문제지만, 400은 요청 자체가 잘못돼서 다시 보내도 같은 결과가 나오기 때문이에요.
- 서버가 힘들 때 모두가 곧바로, 동시에 다시 보내면 더 힘들어지기 때문이에요. 간격을 늘리고 흩어서 보내야 회복할 시간이 생겨요.
- 모든 요청에 공통인 부분(지시, 예시, 긴 문서)을 앞에 두고, 매번 바뀌는 내용은 뒤에 둬요. 앞부분이 글자 하나까지 같아야 캐시가 맞아요.
- 중간에 멈추면 이미 처리한 것까지 처음부터 다시 보내야 해서 돈과 시간이 두 번 들어요.
- 형식만 맞을 뿐 내용(분류가 맞는지, 요약 길이가 지켜졌는지)은 틀릴 수 있기 때문이에요.
다음 강의
이번에는 문의 목록이 이미 주어져 있었어요. 실제로는 데이터를 모으고, 정리하고, 정해진 시간마다 흘려보내는 일이 먼저예요. 다음 강의에서는 웹과 API에서 데이터를 수집하고, 정제하고, 저장하는 데이터 파이프라인을 만들어요.