OpenAI API 실전 가이드 — Python으로 GPT 앱 처음 만들기

1

pip install openai python-dotenv

1
2

# .env
OPENAI_API_KEY=sk-proj-...여기에_실제_키_입력...

1
2
3
4
5
6
7
8

# config.py
import os
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "system",
            "content": "당신은 친절한 Python 코딩 튜터입니다. 한국어로 답변합니다."
        },
        {
            "role": "user",
            "content": "리스트 컴프리헨션을 언제 쓰는 게 좋나요?"
        }
    ],
    max_tokens=500,
    temperature=0.7,
)

print(response.choices[0].message.content)
print(f"사용 토큰: {response.usage.total_tokens}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

def stream_response(user_message: str) -> None:
    """스트리밍으로 GPT 응답을 실시간 출력"""
    stream = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": user_message}],
        stream=True,
        max_tokens=1000,
    )

    for chunk in stream:
        if chunk.choices[0].delta.content is not None:
            print(chunk.choices[0].delta.content, end="", flush=True)
    print()  # 줄바꿈

stream_response("Python 데코레이터를 쉽게 설명해 주세요.")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from openai import OpenAI

app = FastAPI()
client = OpenAI()

@app.post("/chat")
async def chat_stream(message: str):
    def generate():
        stream = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": message}],
            stream=True,
        )
        for chunk in stream:
            if chunk.choices[0].delta.content:
                yield chunk.choices[0].delta.content

    return StreamingResponse(generate(), media_type="text/plain")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

import json
import requests

# 1. 도구 스키마 정의
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "특정 도시의 현재 날씨를 조회합니다.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "조회할 도시 이름 (예: Seoul, Tokyo)"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "온도 단위"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

# 2. 실제 함수 구현
def get_weather(city: str, unit: str = "celsius") -> dict:
    """날씨 API 호출 (예시)"""
    # 실제로는 OpenWeatherMap 같은 API 호출
    return {"city": city, "temperature": 22, "unit": unit, "condition": "맑음"}

# 3. Function Calling 흐름
def run_with_tools(user_message: str) -> str:
    messages = [{"role": "user", "content": user_message}]

    # 첫 번째 호출: GPT가 도구 사용 여부 결정
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=tools,
        tool_choice="auto",  # GPT가 자동으로 도구 선택
    )

    message = response.choices[0].message

    # 도구 호출이 필요한 경우
    if message.tool_calls:
        messages.append(message)  # GPT 응답 추가

        for tool_call in message.tool_calls:
            func_name = tool_call.function.name
            func_args = json.loads(tool_call.function.arguments)

            # 실제 함수 실행
            if func_name == "get_weather":
                result = get_weather(**func_args)

            # 도구 결과를 메시지에 추가
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(result, ensure_ascii=False)
            })

        # 두 번째 호출: 도구 결과를 포함해 최종 응답 생성
        final_response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
        )
        return final_response.choices[0].message.content

    return message.content

print(run_with_tools("서울 날씨 알려줘"))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class ChatSession:
    def __init__(self, system_prompt: str = "당신은 친절한 AI 어시스턴트입니다."):
        self.messages = [{"role": "system", "content": system_prompt}]
        self.client = OpenAI()

    def chat(self, user_input: str) -> str:
        self.messages.append({"role": "user", "content": user_input})

        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=self.messages,
            max_tokens=1000,
        )

        assistant_message = response.choices[0].message.content
        self.messages.append({"role": "assistant", "content": assistant_message})

        # 컨텍스트 관리: 최근 20개 메시지만 유지 (system 제외)
        if len(self.messages) > 21:
            self.messages = [self.messages[0]] + self.messages[-20:]

        return assistant_message

# 사용 예시
session = ChatSession("당신은 Python 전문가입니다.")
print(session.chat("리스트와 튜플의 차이는?"))
print(session.chat("그럼 어떤 상황에서 튜플을 써야 하나요?"))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import tiktoken

def count_tokens(text: str, model: str = "gpt-4o") -> int:
    """텍스트의 토큰 수를 사전 계산"""
    encoding = tiktoken.encoding_for_model(model)
    return len(encoding.encode(text))

# 비용 예측
def estimate_cost(input_text: str, output_tokens: int = 500) -> float:
    input_tokens = count_tokens(input_text)
    # gpt-4o 기준: 입력 $2.50/1M, 출력 $10/1M
    input_cost = (input_tokens / 1_000_000) * 2.50
    output_cost = (output_tokens / 1_000_000) * 10.00
    return input_cost + output_cost

text = "Python 비동기 프로그래밍에 대해 자세히 설명해 주세요."
print(f"예상 비용: ${estimate_cost(text):.6f}")

1
2
3
4
5
6
7
8

MODEL_TIERS = {
    "simple": "gpt-4o-mini",    # 분류, 추출, 단순 요약
    "standard": "gpt-4o",       # 일반적인 생성, 번역
    "complex": "gpt-4o",        # 복잡한 추론, 코드 생성
}

def get_model(complexity: str) -> str:
    return MODEL_TIERS.get(complexity, "gpt-4o-mini")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import hashlib
import json
from functools import lru_cache

@lru_cache(maxsize=1000)
def cached_completion(prompt: str, model: str = "gpt-4o-mini") -> str:
    """동일 프롬프트에 대한 API 호출 캐싱"""
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=200,
        temperature=0,  # 캐싱 시 temperature=0으로 결정론적 출력
    )
    return response.choices[0].message.content

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

from openai import RateLimitError, APIError, APIConnectionError
import time

def safe_completion(messages: list, retries: int = 3) -> str | None:
    """재시도 로직을 포함한 안전한 API 호출"""
    for attempt in range(retries):
        try:
            response = client.chat.completions.create(
                model="gpt-4o",
                messages=messages,
                max_tokens=1000,
            )
            return response.choices[0].message.content

        except RateLimitError:
            wait_time = 2 ** attempt  # 지수 백오프: 1s, 2s, 4s
            print(f"Rate limit 초과. {wait_time}초 후 재시도...")
            time.sleep(wait_time)

        except APIConnectionError:
            print("네트워크 연결 오류. 재시도 중...")
            time.sleep(1)

        except APIError as e:
            print(f"API 오류: {e.status_code} - {e.message}")
            break

    return None