ChatGPT API 완벽 가이드 | 사용법·요금·프롬프트 엔지니어링·실전 예제
이 글의 핵심
ChatGPT API를 실무에 활용하는 완벽 가이드. API 키 발급부터 요금 체계, 프롬프트 엔지니어링, 스트리밍, 함수 호출까지 실전 예제로 정리. ChatGPT·OpenAI·API 중심으로 설명합니다. Start now.
이 글의 핵심
ChatGPT API를 실무에 활용하는 완벽 가이드입니다. API 키 발급부터 요금 체계, 프롬프트 엔지니어링, 스트리밍, 함수 호출까지 실전 예제로 정리했습니다.
실무 경험 공유: 실시간 채팅 모더레이션 시스템에 ChatGPT API를 도입한 경험을 바탕으로 작성했습니다. 초당 1000건 이상의 메시지를 처리하면서 얻은 실전 노하우를 공유합니다.
들어가며: “ChatGPT를 내 서비스에 넣고 싶어요”
실무 문제 시나리오
시나리오 1: 고객 문의 자동 응답
하루 100건 이상의 고객 문의를 수동으로 처리하고 있습니다. ChatGPT API로 80%를 자동화할 수 있습니다. 시나리오 2: 콘텐츠 자동 생성
블로그 글, 상품 설명, 메타 태그를 매번 작성하는 데 시간이 너무 걸립니다. API로 초안을 자동 생성할 수 있습니다. 시나리오 3: 코드 리뷰 자동화
Pull Request마다 코드 리뷰가 밀립니다. ChatGPT API로 기본 리뷰를 자동화할 수 있습니다.
flowchart LR
subgraph Before[수동 작업]
A1[고객 문의]
A2[콘텐츠 작성]
A3[코드 리뷰]
end
subgraph After[ChatGPT API]
B1[자동 응답]
B2[자동 생성]
B3[자동 리뷰]
end
Before --> After
1. ChatGPT API 시작하기
API 키 발급
- OpenAI 계정 생성: https://platform.openai.com/signup
- API 키 발급: https://platform.openai.com/api-keys
- 결제 수단 등록: https://platform.openai.com/account/billing
# API 키 확인
export OPENAI_API_KEY="sk-..."
echo $OPENAI_API_KEY첫 API 호출
# Python 예제
import openai
openai.api_key = "sk-..."
response = openai.chat.completions.create(
model="gpt-4",
messages=[
{"role": "user", "content": "안녕하세요!"}
]
)
print(response.choices[0].message.content)// Node.js 예제
import OpenAI from 'openai';
const openai = new OpenAI({
apiKey: process.env.OPENAI_API_KEY,
});
const response = await openai.chat.completions.create({
model: 'gpt-4',
messages: [
{ role: 'user', content: '안녕하세요!' }
],
});
console.log(response.choices[0].message.content);2. 모델 선택 및 요금
모델 비교
| 모델 | 입력 가격 (1M 토큰) | 출력 가격 (1M 토큰) | 특징 |
|---|---|---|---|
| gpt-4-turbo | $10 | $30 | 최신, 빠름, 128K 컨텍스트 |
| gpt-4 | $30 | $60 | 가장 강력, 8K 컨텍스트 |
| gpt-3.5-turbo | $0.50 | $1.50 | 빠르고 저렴, 16K 컨텍스트 |
토큰 계산
import tiktoken
def count_tokens(text, model="gpt-4"):
encoding = tiktoken.encoding_for_model(model)
return len(encoding.encode(text))
text = "ChatGPT API를 사용하는 방법"
tokens = count_tokens(text)
print(f"토큰 수: {tokens}") # 약 10토큰비용 계산 예시
def calculate_cost(input_tokens, output_tokens, model="gpt-4-turbo"):
prices = {
"gpt-4-turbo": {"input": 10, "output": 30},
"gpt-4": {"input": 30, "output": 60},
"gpt-3.5-turbo": {"input": 0.5, "output": 1.5},
}
price = prices[model]
cost = (input_tokens * price[input] + output_tokens * price[output]) / 1_000_000
return cost
# 예시: 1000 토큰 입력, 500 토큰 출력
cost = calculate_cost(1000, 500, "gpt-4-turbo")
print(f"비용: ${cost:.4f}") # $0.02503. 프롬프트 엔지니어링
기본 원칙
# ❌ 나쁜 프롬프트
response = openai.chat.completions.create(
model="gpt-4",
messages=[
{"role": "user", "content": "코드 짜줘"}
]
)
# ✅ 좋은 프롬프트
response = openai.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": "당신은 Python 전문가입니다."},
{"role": "user", "content": """
Python으로 CSV 파일을 읽어서 데이터를 분석하는 코드를 작성해주세요.
요구사항:
1. pandas 라이브러리 사용
2. 결측치 처리
3. 기술 통계 출력
4. 주석 포함
입력: sales.csv (날짜, 상품명, 판매량, 가격 컬럼)
출력: 상품별 총 매출액
"""}
]
)Few-Shot Learning
messages = [
{"role": "system", "content": "고객 문의를 분류하는 AI입니다."},
{"role": "user", "content": "배송이 언제 되나요?"},
{"role": "assistant", "content": "카테고리: 배송"},
{"role": "user", "content": "환불하고 싶어요"},
{"role": "assistant", "content": "카테고리: 환불"},
{"role": "user", "content": "상품이 불량이에요"},
]
response = openai.chat.completions.create(
model="gpt-4",
messages=messages
)체인 오브 쏘트 (Chain of Thought)
prompt = """
문제: 사과 3개에 2000원, 바나나 2개에 3000원입니다.
사과 5개와 바나나 3개를 사면 총 얼마인가요?
단계별로 생각해봅시다:
1. 사과 1개 가격 계산
2. 바나나 1개 가격 계산
3. 사과 5개 가격 계산
4. 바나나 3개 가격 계산
5. 합계 계산
"""
response = openai.chat.completions.create(
model="gpt-4",
messages=[{"role": "user", "content": prompt}]
)4. 스트리밍 응답
기본 스트리밍
# Python
response = openai.chat.completions.create(
model="gpt-4",
messages=[{"role": "user", "content": "긴 이야기를 들려주세요"}],
stream=True
)
for chunk in response:
if chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="")// Node.js
const stream = await openai.chat.completions.create({
model: 'gpt-4',
messages: [{ role: 'user', content: '긴 이야기를 들려주세요' }],
stream: true,
});
for await (const chunk of stream) {
const content = chunk.choices[0]?.delta?.content || ';
process.stdout.write(content);
}웹 애플리케이션에서 스트리밍
// Next.js API Route
import OpenAI from 'openai';
import { OpenAIStream, StreamingTextResponse } from 'ai';
export async function POST(req: Request) {
const { messages } = await req.json();
const openai = new OpenAI({
apiKey: process.env.OPENAI_API_KEY,
});
const response = await openai.chat.completions.create({
model: 'gpt-4',
messages,
stream: true,
});
const stream = OpenAIStream(response);
return new StreamingTextResponse(stream);
}// 클라이언트
'use client';
import { useChat } from 'ai/react';
export default function ChatPage() {
const { messages, input, handleInputChange, handleSubmit } = useChat();
return (
<div>
{messages.map(m => (
<div key={m.id}>
<strong>{m.role}:</strong> {m.content}
</div>
))}
<form onSubmit={handleSubmit}>
<input value={input} onChange={handleInputChange} />
<button type="submit">전송</button>
</form>
</div>
);
}5. 함수 호출 (Function Calling)
기본 사용법
functions = [
{
"name": "get_weather",
"description": "특정 도시의 날씨를 가져옵니다",
"parameters": {
"type": "object",
"properties": {
"city": {
"type": "string",
"description": "도시 이름 (예: 서울, 부산)"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"]
}
},
"required": [city]
}
}
]
response = openai.chat.completions.create(
model="gpt-4",
messages=[{"role": "user", "content": "서울 날씨 알려줘"}],
functions=functions,
function_call="auto"
)
# 함수 호출 확인
if response.choices[0].message.function_call:
function_name = response.choices[0].message.function_call.name
arguments = json.loads(response.choices[0].message.function_call.arguments)
# 실제 함수 실행
if function_name == "get_weather":
weather = get_weather(**arguments)
# 결과를 다시 GPT에 전달
messages = [
{"role": "user", "content": "서울 날씨 알려줘"},
response.choices[0].message,
{"role": "function", "name": function_name, "content": str(weather)}
]
final_response = openai.chat.completions.create(
model="gpt-4",
messages=messages
)실전 예제: 데이터베이스 쿼리
import sqlite3
def query_database(query: str):
"""SQL 쿼리를 실행합니다"""
conn = sqlite3.connect('sales.db')
cursor = conn.cursor()
cursor.execute(query)
results = cursor.fetchall()
conn.close()
return results
functions = [
{
"name": "query_database",
"description": "판매 데이터베이스에서 정보를 조회합니다",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "실행할 SQL 쿼리"
}
},
"required": [query]
}
}
]
messages = [
{"role": "system", "content": "당신은 SQL 전문가입니다. 테이블: sales (date, product, quantity, price)"},
{"role": "user", "content": "지난달 가장 많이 팔린 상품은?"}
]
response = openai.chat.completions.create(
model="gpt-4",
messages=messages,
functions=functions,
function_call="auto"
)
if response.choices[0].message.function_call:
args = json.loads(response.choices[0].message.function_call.arguments)
results = query_database(args[query])
messages.append(response.choices[0].message)
messages.append({"role": "function", "name": "query_database", "content": str(results)})
final_response = openai.chat.completions.create(
model="gpt-4",
messages=messages
)
print(final_response.choices[0].message.content)6. 실전 예제: 고객 지원 챗봇
전체 구조
flowchart TB
User[사용자] --> Chat[챗봇 UI]
Chat --> API[ChatGPT API]
API --> Intent[의도 분류]
Intent --> FAQ[FAQ 검색]
Intent --> Ticket[티켓 생성]
Intent --> Human[상담원 연결]
FAQ --> Response[응답 생성]
Ticket --> Response
Response --> User
구현
import openai
from typing import List, Dict
class CustomerSupportBot:
def __init__(self, api_key: str):
openai.api_key = api_key
self.conversation_history: List[Dict] = []
def classify_intent(self, message: str) -> str:
"""사용자 의도 분류"""
response = openai.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": """
다음 카테고리 중 하나로 분류하세요:
- 배송: 배송 관련 문의
- 환불: 환불/교환 문의
- 상품: 상품 정보 문의
- 기타: 그 외
"""},
{"role": "user", "content": message}
],
temperature=0
)
return response.choices[0].message.content.strip()
def search_faq(self, intent: str, question: str) -> str:
"""FAQ에서 답변 검색"""
faq_data = {
"배송": "일반 배송은 2-3일, 빠른 배송은 1일 소요됩니다.",
"환불": "구매일로부터 7일 이내 환불 가능합니다.",
"상품": "상품 상세 페이지에서 확인하실 수 있습니다."
}
return faq_data.get(intent, "상담원 연결이 필요합니다.")
def generate_response(self, user_message: str) -> str:
"""응답 생성"""
# 의도 분류
intent = self.classify_intent(user_message)
# FAQ 검색
faq_answer = self.search_faq(intent, user_message)
# 대화 히스토리에 추가
self.conversation_history.append(
{"role": "user", "content": user_message}
)
# 최종 응답 생성
messages = [
{"role": "system", "content": f"""
당신은 친절한 고객 지원 AI입니다.
사용자 의도: {intent}
FAQ 답변: {faq_answer}
위 정보를 바탕으로 자연스럽고 친절하게 답변하세요.
"""},
*self.conversation_history
]
response = openai.chat.completions.create(
model="gpt-4",
messages=messages,
temperature=0.7
)
assistant_message = response.choices[0].message.content
self.conversation_history.append(
{"role": "assistant", "content": assistant_message}
)
return assistant_message
# 사용 예시
bot = CustomerSupportBot(api_key="sk-...")
print(bot.generate_response("배송이 언제 되나요?"))
print(bot.generate_response("빠른 배송도 가능한가요?"))7. 비용 최적화
1. 적절한 모델 선택
def choose_model(task_complexity: str) -> str:
"""작업 복잡도에 따라 모델 선택"""
if task_complexity == "simple":
return "gpt-3.5-turbo" # 분류, 간단한 질문
elif task_complexity == "medium":
return "gpt-4-turbo" # 복잡한 추론
else:
return "gpt-4" # 매우 복잡한 작업2. 토큰 수 제한
response = openai.chat.completions.create(
model="gpt-4",
messages=messages,
max_tokens=500, # 출력 토큰 제한
temperature=0.7
)3. 캐싱 활용
from functools import lru_cache
@lru_cache(maxsize=1000)
def get_cached_response(prompt: str) -> str:
"""동일한 프롬프트는 캐싱"""
response = openai.chat.completions.create(
model="gpt-4",
messages=[{"role": "user", "content": prompt}]
)
return response.choices[0].message.content4. 배치 처리
def process_batch(prompts: List[str]) -> List[str]:
"""여러 요청을 한 번에 처리"""
responses = []
for prompt in prompts:
response = openai.chat.completions.create(
model="gpt-3.5-turbo", # 저렴한 모델 사용
messages=[{"role": "user", "content": prompt}],
max_tokens=100
)
responses.append(response.choices[0].message.content)
return responses8. 에러 처리 및 재시도
기본 에러 처리
import time
from openai import OpenAIError, RateLimitError, APIError
def call_api_with_retry(messages, max_retries=3):
for attempt in range(max_retries):
try:
response = openai.chat.completions.create(
model="gpt-4",
messages=messages
)
return response
except RateLimitError:
if attempt < max_retries - 1:
wait_time = 2 ** attempt # 지수 백오프
print(f"Rate limit 도달. {wait_time}초 대기...")
time.sleep(wait_time)
else:
raise
except APIError as e:
print(f"API 에러: {e}")
if attempt < max_retries - 1:
time.sleep(1)
else:
raise
except Exception as e:
print(f"예상치 못한 에러: {e}")
raise타임아웃 설정
import openai
openai.timeout = 30 # 30초 타임아웃
try:
response = openai.chat.completions.create(
model="gpt-4",
messages=messages,
request_timeout=30
)
except openai.Timeout:
print("요청 시간 초과")9. 보안 및 모범 사례
API 키 보호
# ❌ 나쁜 예
openai.api_key = "sk-..." # 코드에 직접 입력
# ✅ 좋은 예
import os
from dotenv import load_dotenv
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")입력 검증
def validate_input(user_input: str) -> bool:
"""사용자 입력 검증"""
if len(user_input) > 4000:
return False
if contains_malicious_content(user_input):
return False
return True
def contains_malicious_content(text: str) -> bool:
"""악의적 콘텐츠 확인"""
blocked_patterns = ["system:", "ignore previous", "jailbreak"]
return any(pattern in text.lower() for pattern in blocked_patterns)출력 필터링
def filter_output(response: str) -> str:
"""민감한 정보 필터링"""
import re
# 이메일 마스킹
response = re.sub(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
'***@***.***', response)
# 전화번호 마스킹
response = re.sub(r'\d{3}-\d{4}-\d{4}', '***-****-****', response)
return response10. 자주 하는 실수와 해결법
문제 1: 토큰 제한 초과
# ❌ 잘못된 코드
long_text = "..." * 10000 # 너무 긴 텍스트
response = openai.chat.completions.create(
model="gpt-4",
messages=[{"role": "user", "content": long_text}]
)
# ✅ 올바른 코드
def truncate_text(text: str, max_tokens: int = 7000) -> str:
encoding = tiktoken.encoding_for_model("gpt-4")
tokens = encoding.encode(text)
if len(tokens) > max_tokens:
tokens = tokens[:max_tokens]
text = encoding.decode(tokens)
return text
truncated = truncate_text(long_text)
response = openai.chat.completions.create(
model="gpt-4",
messages=[{"role": "user", "content": truncated}]
)문제 2: 비용 폭탄
# ❌ 잘못된 코드
for i in range(1000):
response = openai.chat.completions.create(
model="gpt-4", # 비싼 모델
messages=[{"role": "user", "content": f"항목 {i}"}]
)
# ✅ 올바른 코드
# 1. 배치로 묶기
batch_prompt = "\n".join([f"항목 {i}" for i in range(1000)])
response = openai.chat.completions.create(
model="gpt-3.5-turbo", # 저렴한 모델
messages=[{"role": "user", "content": batch_prompt}]
)
# 2. 비용 모니터링
total_cost = 0
for i in range(1000):
response = openai.chat.completions.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": f"항목 {i}"}]
)
cost = calculate_cost(
response.usage.prompt_tokens,
response.usage.completion_tokens,
"gpt-3.5-turbo"
)
total_cost += cost
if total_cost > 10: # $10 초과 시 중단
print("비용 한도 초과!")
break문제 3: 일관성 없는 응답
# ❌ 잘못된 코드
response = openai.chat.completions.create(
model="gpt-4",
messages=[{"role": "user", "content": "분류해줘"}],
temperature=1.5 # 너무 높음
)
# ✅ 올바른 코드
response = openai.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": "다음 카테고리 중 하나로만 답하세요: A, B, C"},
{"role": "user", "content": "이 텍스트를 분류해주세요: ..."}
],
temperature=0, # 결정적 출력
max_tokens=10
)정리 및 체크리스트
핵심 요약
- API 키 발급 후 환경 변수로 안전하게 관리
- 모델 선택: 작업 복잡도에 따라 gpt-3.5-turbo / gpt-4 선택
- 프롬프트 엔지니어링: 명확한 지시, Few-Shot, Chain of Thought
- 스트리밍: 실시간 응답으로 UX 향상
- 함수 호출: 외부 시스템 통합
- 비용 최적화: 토큰 제한, 캐싱, 적절한 모델 선택
실무 체크리스트
- API 키를 환경 변수로 관리
- 입력 검증 및 출력 필터링
- 에러 처리 및 재시도 로직
- 토큰 수 모니터링
- 비용 한도 설정
- 응답 캐싱
- 로깅 및 모니터링
같이 보면 좋은 글
- LangChain 실전 가이드 | 체인·메모리·에이전트·RAG
- RAG 구현 가이드 | 벡터 DB·임베딩·검색 증강 생성
- Next.js 15 완벽 가이드 | App Router·Server Actions
이 글에서 다루는 키워드
ChatGPT, OpenAI, API, GPT-4, 프롬프트 엔지니어링, AI, 자동화, 챗봇, LLM
내부 동작과 핵심 메커니즘
이 글의 주제는 「ChatGPT API 완벽 가이드 | 사용법·요금·프롬프트 엔지니어링·실전 예제」입니다. 앞선 튜토리얼을 구현·런타임 관점에서 다시 압축합니다. 요청 경로와 상태 전이를 기준으로 “입력이 어디서 검증되고, 핵심 연산이 어디서 일어나며, 부작용(I/O·네트워크·디스크)·동시성이 어디서 터지는가”를 한 장면으로 그리면 장애 분석이 빨라집니다.
처리 파이프라인(개념도)
flowchart TD A[입력·요청·이벤트] --> B[파싱·검증·디코딩] B --> C[핵심 연산·상태 전이] C --> D[부작용: I/O·네트워크·동시성] D --> E[결과·관측·저장]
경계에서의 지연·실패(시퀀스 관점)
sequenceDiagram participant C as 클라이언트/호출자 participant B as 경계(프로세스·런타임·게이트웨이) participant D as 의존성(외부 API·DB·큐) C->>B: 요청/이벤트 B->>D: 조회·쓰기·RPC D-->>B: 지연·부분 실패·재시도 가능 B-->>C: 응답 또는 오류(코드·상관 ID)
알고리즘·프로토콜·리소스 관점 체크포인트
- 불변 조건(Invariant): 각 단계가 만족해야 하는 조건(버퍼 경계, 프로토콜 상태, 트랜잭션 격리, 파일 디스크립터 상한)을 문장으로 적어 두면 디버깅 비용이 줄어듭니다.
- 결정성: 동일 입력에 동일 출력이 보장되는 순수 층과, 시간·네트워크·스레드 스케줄에 의해 달라질 수 있는 층을 분리해야 테스트와 장애 분석이 쉬워집니다.
- 경계 비용: 직렬화/역직렬화, 문자 인코딩, syscall 횟수, 락 경합, GC·할당, 캐시 미스처럼 누적 비용을 의심 목록에 넣습니다.
- 백프레셔: 생산자가 소비자보다 빠를 때(소켓 버퍼, 큐 깊이, 스트림) 어디서 어떤 신호로 속도를 줄일지 정의합니다.
프로덕션 운영 패턴
실서비스에서는 기능과 함께 관측·배포·보안·비용·규제가 동시에 요구됩니다.
| 영역 | 운영 관점 질문 |
|---|---|
| 관측성 | 요청 단위 상관 ID, 에러율/지연 분위수(p95/p99), 의존성 타임아웃·재시도가 대시보드에 보이는가 |
| 안전성 | 입력 검증·권한·비밀·감사 로그가 코드 경로마다 일관적인가 |
| 신뢰성 | 재시도는 멱등 연산에만 적용되는가, 서킷 브레이커·백오프·DLQ가 있는가 |
| 성능 | 캐시 계층·배치 크기·커넥션 풀·인덱스·백프레셔가 데이터 규모에 맞는가 |
| 배포 | 롤백 룬북, 카나리/블루그린, 마이그레이션 호환성·플래그가 문서화되어 있는가 |
| 용량 | 피크 트래픽·디스크·파일 디스크립터·스레드 풀 상한을 주기적으로 검증하는가 |
스테이징은 데이터 양·네트워크 RTT·동시성을 가능한 한 프로덕션에 가깝게 맞추는 것이 재현율을 높입니다.
확장 예시: 엔드투엔드 미니 시나리오
「ChatGPT API 완벽 가이드 | 사용법·요금·프롬프트 엔지니어링·실전 예제」을 실제 배포·운영 흐름으로 옮긴 체크리스트형 시나리오입니다. 도메인에 맞게 단계 이름만 바꿔 적용할 수 있습니다.
- 입력 계약 고정: 스키마·버전·최대 페이로드·타임아웃·에러 코드 표를 API 또는 이벤트 경계에 둔다.
- 핵심 경로 계측: 요청 ID, 단계별 지연, 외부 호출 결과 코드를 한 화면(로그+메트릭+트레이스)에서 추적한다.
- 실패 주입: 의존성 타임아웃·5xx·부분 데이터·락 대기를 스테이징에서 재현한다.
- 호환·롤백: 설정/마이그레이션/클라이언트 버전을 되돌릴 수 있는지(또는 피처 플래그) 확인한다.
- 부하 후 검증: 피크 대비 p95/p99, 에러율, 리소스 상한, 알림 임계값이 기대 범위인지 본다.
의사코드 스케치(프레임워크 무관)
handle(request):
ctx = newCorrelationId()
validated = validateSchema(request) // 경계에서 거절
authorize(validated, ctx) // 권한·테넌트
result = domainCore(validated) // 순수에 가까운 규칙
persistOrEmit(result, idempotentKey) // I/O: 멱등·재시도 정책
recordMetrics(ctx, latency, outcome)
return result문제 해결(Troubleshooting)
| 증상 | 가능 원인 | 조치 |
|---|---|---|
| 간헐적 실패 | 레이스, 타임아웃, 외부 의존성 불안정, DNS | 최소 재현 스크립트, 분산 트레이스·로그 상관관계, 재시도·서킷 설정 점검 |
| 성능 저하 | N+1, 동기 I/O, 락 경합, 과도한 직렬화, 캐시 미스 | 프로파일러·APM으로 핫스팟 확인 후 한 가지씩 제거 |
| 메모리 증가 | 캐시 무제한, 구독/리스너 누수, 대용량 버퍼, 커넥션 미반납 | 상한·TTL·힙/FD 스냅샷 비교 |
| 빌드·배포만 실패 | 환경 변수, 권한, 플랫폼 차이, lockfile | CI 로그와 로컬 diff, 런타임·이미지 버전 핀 |
| 설정이 로컬과 다름 | 프로필·시크릿·기본값, 지역 리전 | 단일 소스(예: 스키마 검증된 설정)와 배포 매트릭스 표준화 |
| 데이터 불일치 | 비멱등 재시도, 부분 쓰기, 캐시 무효화 누락 | 멱등 키·아웃박스·트랜잭션 경계 재검토 |
권장 순서: (1) 최소 재현 (2) 최근 변경 범위 축소 (3) 환경·의존성 차이 (4) 관측으로 가설 검증 (5) 수정 후 회귀·부하 테스트.
자주 묻는 질문 (FAQ)
Q. ChatGPT API 비용은 얼마나 드나요?
A. gpt-3.5-turbo는 1M 토큰당 $0.50/$1.50, gpt-4-turbo는 $10/$30입니다. 일반적인 대화 1회는 약 $0.001-0.01 수준입니다.
Q. 무료로 사용할 수 있나요?
A. 신규 가입 시 $5 크레딧이 제공됩니다. 이후에는 사용량에 따라 과금됩니다.
Q. 한국어도 잘 되나요?
A. GPT-4는 한국어를 매우 잘 이해하고 생성합니다. gpt-3.5-turbo도 대부분의 경우 충분합니다.
Q. 개인정보를 API로 보내도 되나요?
A. OpenAI는 API 데이터를 모델 학습에 사용하지 않습니다. 하지만 민감한 정보는 마스킹 후 전송하는 것을 권장합니다.