์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿš€ Python์œผ๋กœ ChatGPT API ์—ฐ๋™ํ•˜๊ธฐ: ์ดˆ๋ณด์ž๋„ ๋”ฐ๋ผํ•˜๋Š” ์™„๋ฒฝ ๊ฐ€์ด๋“œ

๐Ÿš€ Python์œผ๋กœ ChatGPT API ์—ฐ๋™ํ•˜๊ธฐ: ์ดˆ๋ณด์ž๋„ ๋”ฐ๋ผํ•˜๋Š” ์™„๋ฒฝ ๊ฐ€์ด๋“œ

AI ์ฑ—๋ด‡์„ ๋‚ด ํ”„๋กœ๊ทธ๋žจ์— ์ง์ ‘ ์—ฐ๊ฒฐํ•ด๋ณด์ž! ๐Ÿ’ฌโœจ

๐ŸŽฏ ChatGPT API, ์™œ ๋ฐฐ์›Œ์•ผ ํ• ๊นŒ?

์š”์ฆ˜ AI ๊ธฐ์ˆ ์ด ์ •๋ง ํ•ซํ•˜์ž–์•„? ํŠนํžˆ ChatGPT๋Š” ์šฐ๋ฆฌ ์ผ์ƒ์— ์™„์ „ํžˆ ๋…น์•„๋“ค์—ˆ์–ด. ๊ทผ๋ฐ ์›น์‚ฌ์ดํŠธ์— ์ ‘์†ํ•ด์„œ ๋Œ€ํ™”ํ•˜๋Š” ๊ฒƒ๋„ ์ข‹์ง€๋งŒ, ๋‚ด๊ฐ€ ๋งŒ๋“  ํ”„๋กœ๊ทธ๋žจ์— ์ง์ ‘ ChatGPT๋ฅผ ์—ฐ๊ฒฐํ•  ์ˆ˜ ์žˆ๋‹ค๋ฉด ์–ด๋–จ๊นŒ? ๐Ÿค”

์ƒ์ƒํ•ด๋ด. ์ž๋™์œผ๋กœ ๊ณ ๊ฐ ๋ฌธ์˜์— ๋‹ต๋ณ€ํ•˜๋Š” ์ฑ—๋ด‡, ๋ธ”๋กœ๊ทธ ๊ธ€์„ ์ž๋™์œผ๋กœ ์ž‘์„ฑํ•ด์ฃผ๋Š” ๋„๊ตฌ, ์‹ฌ์ง€์–ด ์ฝ”๋“œ ๋ฆฌ๋ทฐ๋ฅผ ํ•ด์ฃผ๋Š” ํ”„๋กœ๊ทธ๋žจ๊นŒ์ง€! ์ด ๋ชจ๋“  ๊ฒŒ ChatGPT API๋ฅผ ํ†ตํ•ด ๊ฐ€๋Šฅํ•ด. Python์œผ๋กœ API๋ฅผ ์—ฐ๋™ํ•˜๋ฉด ์ •๋ง ๋ฌด๊ถ๋ฌด์ง„ํ•œ ๊ฐ€๋Šฅ์„ฑ์ด ์—ด๋ฆฌ๋Š” ๊ฑฐ์ง€.

์ด ๊ธ€์—์„œ๋Š” ์™„์ „ ๊ธฐ์ดˆ๋ถ€ํ„ฐ ์‹ค์ „ ํ™œ์šฉ๊นŒ์ง€, ์นœ๊ตฌํ•œํ…Œ ์„ค๋ช…ํ•˜๋“ฏ์ด ์‰ฝ๊ฒŒ ์•Œ๋ ค์ค„๊ฒŒ. ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๊ฒฝํ—˜์ด ์กฐ๊ธˆ๋งŒ ์žˆ์–ด๋„ ์ถฉ๋ถ„ํžˆ ๋”ฐ๋ผ์˜ฌ ์ˆ˜ ์žˆ์œผ๋‹ˆ๊นŒ ๊ฑฑ์ • ๋งˆ! ๐Ÿ˜Š


๐Ÿ“š ์‹œ์ž‘ํ•˜๊ธฐ ์ „์— ์•Œ์•„์•ผ ํ•  ๊ฒƒ๋“ค

๐Ÿ”‘ OpenAI API ํ‚ค ๋ฐœ๊ธ‰๋ฐ›๊ธฐ

ChatGPT API๋ฅผ ์‚ฌ์šฉํ•˜๋ ค๋ฉด ๋จผ์ € OpenAI์—์„œ API ํ‚ค๋ฅผ ๋ฐœ๊ธ‰๋ฐ›์•„์•ผ ํ•ด. ์ด๊ฑด ๋งˆ์น˜ ์ง‘ ์—ด์‡  ๊ฐ™์€ ๊ฑฐ์•ผ. ์ด ํ‚ค๊ฐ€ ์žˆ์–ด์•ผ OpenAI ์„œ๋ฒ„์— ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ๊ฑฐ๋“ .

๋ฐœ๊ธ‰ ๊ณผ์ •์€ ์ด๋ ‡๊ฒŒ ์ง„ํ–‰๋ผ:
1. OpenAI ๊ณต์‹ ์›น์‚ฌ์ดํŠธ(platform.openai.com)์— ์ ‘์†
2. ํšŒ์›๊ฐ€์ž… ๋˜๋Š” ๋กœ๊ทธ์ธ
3. API Keys ๋ฉ”๋‰ด๋กœ ์ด๋™
4. "Create new secret key" ๋ฒ„ํŠผ ํด๋ฆญ
5. ์ƒ์„ฑ๋œ ํ‚ค๋ฅผ ์•ˆ์ „ํ•œ ๊ณณ์— ๋ณต์‚ฌํ•ด์„œ ๋ณด๊ด€

โš ๏ธ ์ค‘์š”! API ํ‚ค๋Š” ์ ˆ๋Œ€ ๊ณต๊ฐœ๋œ ๊ณณ์— ์˜ฌ๋ฆฌ๋ฉด ์•ˆ ๋ผ. GitHub ๊ฐ™์€ ๊ณณ์— ์‹ค์ˆ˜๋กœ ์˜ฌ๋ฆฌ๋ฉด ๋‹ค๋ฅธ ์‚ฌ๋žŒ์ด ๋„ˆ์˜ ํ‚ค๋กœ API๋ฅผ ์‚ฌ์šฉํ•ด์„œ ์š”๊ธˆ์ด ํญํƒ„์ฒ˜๋Ÿผ ๋‚˜์˜ฌ ์ˆ˜ ์žˆ์–ด!

๐Ÿ’ฐ ์š”๊ธˆ ์ฒด๊ณ„ ์ดํ•ดํ•˜๊ธฐ

ChatGPT API๋Š” ๋ฌด๋ฃŒ๊ฐ€ ์•„๋‹ˆ์•ผ. ์‚ฌ์šฉํ•œ ๋งŒํผ ๋ˆ์„ ๋‚ด๋Š” ์ข…๋Ÿ‰์ œ ๋ฐฉ์‹์ด์ง€. ํ•˜์ง€๋งŒ ๊ฑฑ์ • ๋งˆ! ํ…Œ์ŠคํŠธ ์šฉ๋„๋กœ๋Š” ์ •๋ง ์ €๋ ดํ•˜๊ฑฐ๋“ .

GPT-4o ๋ชจ๋ธ ๊ธฐ์ค€์œผ๋กœ:
โ€ข ์ž…๋ ฅ ํ† ํฐ(Input): 100๋งŒ ํ† ํฐ๋‹น ์•ฝ $2.50
โ€ข ์ถœ๋ ฅ ํ† ํฐ(Output): 100๋งŒ ํ† ํฐ๋‹น ์•ฝ $10.00

ํ† ํฐ์ด ๋ญ๋ƒ๊ณ ? ๊ฐ„๋‹จํžˆ ๋งํ•˜๋ฉด ๋‹จ์–ด ์กฐ๊ฐ์ด๋ผ๊ณ  ์ƒ๊ฐํ•˜๋ฉด ๋ผ. ์˜์–ด๋กœ "Hello, how are you?"๋Š” ๋Œ€๋žต 5๊ฐœ ํ† ํฐ ์ •๋„์•ผ. ํ•œ๊ธ€์€ ์กฐ๊ธˆ ๋” ๋งŽ์€ ํ† ํฐ์„ ์‚ฌ์šฉํ•˜๋Š” ํŽธ์ด๊ณ .

์‹ค์ œ๋กœ ๊ฐ„๋‹จํ•œ ์งˆ๋ฌธ ํ•˜๋‚˜ ๋‹ต๋ณ€ ๋ฐ›๋Š” ๋ฐ ๋ช‡ ์„ผํŠธ๋„ ์•ˆ ๋“ค์–ด. ์ฒ˜์Œ ์‹œ์ž‘ํ•  ๋•Œ๋Š” $5 ์ •๋„๋งŒ ์ถฉ์ „ํ•ด๋„ ์ถฉ๋ถ„ํžˆ ํ…Œ์ŠคํŠธํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿ’ต

๐Ÿ Python ํ™˜๊ฒฝ ์ค€๋น„

Python 3.7 ์ด์ƒ ๋ฒ„์ „์ด ์„ค์น˜๋˜์–ด ์žˆ์–ด์•ผ ํ•ด. ์š”์ฆ˜์€ ๋Œ€๋ถ€๋ถ„ 3.9๋‚˜ 3.10 ๋ฒ„์ „์„ ์“ฐ๋‹ˆ๊นŒ ๋ฌธ์ œ์—†์„ ๊ฑฐ์•ผ.

ํ„ฐ๋ฏธ๋„์ด๋‚˜ ๋ช…๋ น ํ”„๋กฌํ”„ํŠธ์—์„œ ํ™•์ธํ•ด๋ณด์ž:

python --version

๋˜๋Š”

python3 --version

๋ฒ„์ „์ด ์ž˜ ๋‚˜์˜ค๋ฉด ์ค€๋น„ ์™„๋ฃŒ! ๐ŸŽ‰


๐Ÿ› ๏ธ OpenAI ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ์„ค์น˜ํ•˜๊ธฐ

์ž, ์ด์ œ ๋ณธ๊ฒฉ์ ์œผ๋กœ ์‹œ์ž‘ํ•ด๋ณผ๊นŒ? ๋จผ์ € OpenAI์—์„œ ์ œ๊ณตํ•˜๋Š” ๊ณต์‹ Python ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์„ค์น˜ํ•ด์•ผ ํ•ด. ์ด ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๊ฐ€ ์žˆ์œผ๋ฉด API ํ˜ธ์ถœ์ด ์ •๋ง ๊ฐ„๋‹จํ•ด์ ธ.

ํ„ฐ๋ฏธ๋„์„ ์—ด๊ณ  ๋‹ค์Œ ๋ช…๋ น์–ด๋ฅผ ์ž…๋ ฅํ•ด:

pip install openai

๋งŒ์•ฝ pip ๋Œ€์‹  pip3๋ฅผ ์‚ฌ์šฉํ•ด์•ผ ํ•œ๋‹ค๋ฉด:

pip3 install openai
๐Ÿ’ก ํŒ: ๊ฐ€์ƒํ™˜๊ฒฝ(venv)์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฑธ ์ถ”์ฒœํ•ด! ํ”„๋กœ์ ํŠธ๋งˆ๋‹ค ๋…๋ฆฝ์ ์ธ ํ™˜๊ฒฝ์„ ๋งŒ๋“ค๋ฉด ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ๋ฒ„์ „ ์ถฉ๋Œ ๊ฐ™์€ ๋ฌธ์ œ๋ฅผ ํ”ผํ•  ์ˆ˜ ์žˆ๊ฑฐ๋“ . ํŠนํžˆ ์—ฌ๋Ÿฌ ํ”„๋กœ์ ํŠธ๋ฅผ ๋™์‹œ์— ์ง„ํ–‰ํ•œ๋‹ค๋ฉด ํ•„์ˆ˜์•ผ.

์„ค์น˜๊ฐ€ ์™„๋ฃŒ๋˜๋ฉด Python ์ธํ„ฐํ”„๋ฆฌํ„ฐ์—์„œ ํ™•์ธํ•ด๋ณผ ์ˆ˜ ์žˆ์–ด:

python
>>> import openai
>>> print(openai.__version__)

๋ฒ„์ „ ์ •๋ณด๊ฐ€ ๋‚˜์˜ค๋ฉด ์„ฑ๊ณต! ์ตœ์‹  ๋ฒ„์ „์€ 1.x ๋Œ€์ผ ๊ฑฐ์•ผ. ์ฐธ๊ณ ๋กœ OpenAI ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋Š” ๋ฒ„์ „ 1.0 ์ดํ›„๋กœ ์‚ฌ์šฉ๋ฒ•์ด ๋งŽ์ด ๋ฐ”๋€Œ์—ˆ์–ด. ์ด ๊ธ€์—์„œ๋Š” ์ตœ์‹  ๋ฒ„์ „ ๊ธฐ์ค€์œผ๋กœ ์„ค๋ช…ํ• ๊ฒŒ. ๐Ÿ“ฆ


๐ŸŽจ ์ฒซ ๋ฒˆ์งธ API ํ˜ธ์ถœ: Hello, ChatGPT!

๋“œ๋””์–ด ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•  ์‹œ๊ฐ„์ด์•ผ! ๊ฐ€์žฅ ๊ธฐ๋ณธ์ ์ธ ์˜ˆ์ œ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด๋ณด์ž. ์ƒˆ๋กœ์šด Python ํŒŒ์ผ์„ ๋งŒ๋“ค๊ณ  ๋‹ค์Œ ์ฝ”๋“œ๋ฅผ ์ž…๋ ฅํ•ด๋ด:

from openai import OpenAI

# API ํ‚ค ์„ค์ •
client = OpenAI(api_key="์—ฌ๊ธฐ์—_๋„ˆ์˜_API_ํ‚ค๋ฅผ_์ž…๋ ฅ")

# ChatGPT์—๊ฒŒ ์งˆ๋ฌธํ•˜๊ธฐ
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "user", "content": "์•ˆ๋…•! ๋„ˆ๋Š” ๋ˆ„๊ตฌ๋‹ˆ?"}
    ]
)

# ๋‹ต๋ณ€ ์ถœ๋ ฅ
print(response.choices[0].message.content)

์ฝ”๋“œ๋ฅผ ์‹คํ–‰ํ•˜๋ฉด ChatGPT๊ฐ€ ์ž๊ธฐ์†Œ๊ฐœ๋ฅผ ํ•ด์ค„ ๊ฑฐ์•ผ! ๐ŸŽ‰

์ฝ”๋“œ ์„ค๋ช…:

1. OpenAI ํด๋ผ์ด์–ธํŠธ ์ƒ์„ฑ
OpenAI(api_key="...")๋กœ ํด๋ผ์ด์–ธํŠธ ๊ฐ์ฒด๋ฅผ ๋งŒ๋“ค์–ด. ์ด๊ฒŒ API์™€ ํ†ต์‹ ํ•˜๋Š” ํ•ต์‹ฌ ๋„๊ตฌ์•ผ.

2. chat.completions.create() ๋ฉ”์„œ๋“œ
์ด๊ฒŒ ์‹ค์ œ๋กœ ChatGPT์™€ ๋Œ€ํ™”ํ•˜๋Š” ๋ถ€๋ถ„์ด์•ผ. ์—ฌ๋Ÿฌ ํŒŒ๋ผ๋ฏธํ„ฐ๋ฅผ ๋ฐ›๋Š”๋ฐ:
โ€ข model: ์‚ฌ์šฉํ•  ๋ชจ๋ธ ์ง€์ • (gpt-4o-mini, gpt-4o, gpt-4-turbo ๋“ฑ)
โ€ข messages: ๋Œ€ํ™” ๋‚ด์šฉ์„ ๋‹ด์€ ๋ฆฌ์ŠคํŠธ

3. messages ๊ตฌ์กฐ
๊ฐ ๋ฉ”์‹œ์ง€๋Š” ๋”•์…”๋„ˆ๋ฆฌ ํ˜•ํƒœ์•ผ:
โ€ข role: ๋ˆ„๊ฐ€ ๋งํ•˜๋Š”์ง€ (system, user, assistant)
โ€ข content: ์‹ค์ œ ๋ฉ”์‹œ์ง€ ๋‚ด์šฉ

4. ์‘๋‹ต ์ฒ˜๋ฆฌ
response.choices[0].message.content์— ChatGPT์˜ ๋‹ต๋ณ€์ด ๋“ค์–ด์žˆ์–ด.

๐Ÿ”’ ๋ณด์•ˆ ์ฃผ์˜์‚ฌํ•ญ: API ํ‚ค๋ฅผ ์ฝ”๋“œ์— ์ง์ ‘ ๋„ฃ๋Š” ๊ฑด ํ…Œ์ŠคํŠธ์šฉ์ผ ๋•Œ๋งŒ! ์‹ค์ œ ํ”„๋กœ์ ํŠธ์—์„œ๋Š” ํ™˜๊ฒฝ๋ณ€์ˆ˜๋‚˜ ์„ค์ • ํŒŒ์ผ์„ ์‚ฌ์šฉํ•ด์•ผ ํ•ด. ๋‚˜์ค‘์— ์ž์„ธํžˆ ์„ค๋ช…ํ• ๊ฒŒ.
Python Code ๐Ÿ ChatGPT API ๐Ÿค– API Request Response ๐Ÿ’ก API ์—ฐ๋™ ํ๋ฆ„๋„

๐Ÿ” API ํ‚ค ์•ˆ์ „ํ•˜๊ฒŒ ๊ด€๋ฆฌํ•˜๊ธฐ

์•„๊นŒ ๋งํ–ˆ๋“ฏ์ด API ํ‚ค๋ฅผ ์ฝ”๋“œ์— ์ง์ ‘ ๋„ฃ์œผ๋ฉด ์œ„ํ—˜ํ•ด. ํŠนํžˆ GitHub ๊ฐ™์€ ๊ณณ์— ์˜ฌ๋ฆด ๋•Œ ์‹ค์ˆ˜๋กœ ํ‚ค๊ฐ€ ๋…ธ์ถœ๋  ์ˆ˜ ์žˆ๊ฑฐ๋“ . ์•ˆ์ „ํ•˜๊ฒŒ ๊ด€๋ฆฌํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์•Œ์•„๋ณด์ž! ๐Ÿ›ก๏ธ

๋ฐฉ๋ฒ• 1: ํ™˜๊ฒฝ๋ณ€์ˆ˜ ์‚ฌ์šฉํ•˜๊ธฐ

๊ฐ€์žฅ ์ผ๋ฐ˜์ ์ด๊ณ  ์•ˆ์ „ํ•œ ๋ฐฉ๋ฒ•์ด์•ผ. ์šด์˜์ฒด์ œ์˜ ํ™˜๊ฒฝ๋ณ€์ˆ˜์— API ํ‚ค๋ฅผ ์ €์žฅํ•˜๋Š” ๊ฑฐ์ง€.

Windows์—์„œ:

set OPENAI_API_KEY=your_api_key_here

Mac/Linux์—์„œ:

export OPENAI_API_KEY=your_api_key_here

๊ทธ๋ฆฌ๊ณ  Python ์ฝ”๋“œ์—์„œ๋Š” ์ด๋ ‡๊ฒŒ ๋ถˆ๋Ÿฌ์™€:

import os
from openai import OpenAI

api_key = os.getenv("OPENAI_API_KEY")
client = OpenAI(api_key=api_key)

๋ฐฉ๋ฒ• 2: .env ํŒŒ์ผ ์‚ฌ์šฉํ•˜๊ธฐ

ํ”„๋กœ์ ํŠธ๋งˆ๋‹ค ๋‹ค๋ฅธ ํ‚ค๋ฅผ ์‚ฌ์šฉํ•˜๊ฑฐ๋‚˜, ํŒ€์›๋“ค๊ณผ ํ˜‘์—…ํ•  ๋•Œ ํŽธ๋ฆฌํ•œ ๋ฐฉ๋ฒ•์ด์•ผ.

๋จผ์ € python-dotenv ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์„ค์น˜:

pip install python-dotenv

ํ”„๋กœ์ ํŠธ ๋ฃจํŠธ์— .env ํŒŒ์ผ์„ ๋งŒ๋“ค์–ด:

OPENAI_API_KEY=your_api_key_here

Python ์ฝ”๋“œ์—์„œ ๋ถˆ๋Ÿฌ์˜ค๊ธฐ:

from dotenv import load_dotenv
import os
from openai import OpenAI

load_dotenv()  # .env ํŒŒ์ผ ๋กœ๋“œ
api_key = os.getenv("OPENAI_API_KEY")
client = OpenAI(api_key=api_key)
๐Ÿ’ก ์ค‘์š”! .env ํŒŒ์ผ์€ ๋ฐ˜๋“œ์‹œ .gitignore์— ์ถ”๊ฐ€ํ•ด์„œ Git์— ์˜ฌ๋ผ๊ฐ€์ง€ ์•Š๋„๋ก ํ•ด์•ผ ํ•ด!

๋ฐฉ๋ฒ• 3: ์„ค์ • ํŒŒ์ผ ์‚ฌ์šฉํ•˜๊ธฐ

์ข€ ๋” ๋ณต์žกํ•œ ์„ค์ •์ด ํ•„์š”ํ•  ๋•Œ๋Š” JSON์ด๋‚˜ YAML ํŒŒ์ผ์„ ์‚ฌ์šฉํ•  ์ˆ˜๋„ ์žˆ์–ด.

config.json ํŒŒ์ผ:

{
    "openai_api_key": "your_api_key_here",
    "model": "gpt-4o-mini",
    "temperature": 0.7
}

Python์—์„œ ์ฝ๊ธฐ:

import json
from openai import OpenAI

with open('config.json', 'r') as f:
    config = json.load(f)

client = OpenAI(api_key=config['openai_api_key'])

์ด ๋ฐฉ๋ฒ•๋„ config.json์„ .gitignore์— ์ถ”๊ฐ€ํ•˜๋Š” ๊ฑธ ์žŠ์ง€ ๋งˆ!


๐Ÿ’ฌ ๋Œ€ํ™” ๋งฅ๋ฝ ์œ ์ง€ํ•˜๊ธฐ

ChatGPT์˜ ์ง„์งœ ๊ฐ•๋ ฅํ•จ์€ ๋Œ€ํ™”์˜ ๋งฅ๋ฝ์„ ์ดํ•ดํ•œ๋‹ค๋Š” ๊ฑฐ์•ผ. ์ด์ „ ๋Œ€ํ™” ๋‚ด์šฉ์„ ๊ธฐ์–ตํ•˜๊ณ  ๊ทธ์— ๋งž์ถฐ ๋‹ต๋ณ€ํ•˜์ง€. ์ด๊ฑธ ๊ตฌํ˜„ํ•˜๋ ค๋ฉด messages ๋ฆฌ์ŠคํŠธ์— ๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ๋ฅผ ๊ณ„์† ์ถ”๊ฐ€ํ•ด์•ผ ํ•ด.

์‹ค์ œ ์ฑ„ํŒ… ์•ฑ์ฒ˜๋Ÿผ ์ž‘๋™ํ•˜๋Š” ์˜ˆ์ œ๋ฅผ ๋งŒ๋“ค์–ด๋ณผ๊นŒ?

from openai import OpenAI
import os

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# ๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ๋ฅผ ์ €์žฅํ•  ๋ฆฌ์ŠคํŠธ
conversation_history = []

def chat(user_message):
    """์‚ฌ์šฉ์ž ๋ฉ”์‹œ์ง€๋ฅผ ๋ฐ›์•„์„œ ChatGPT ์‘๋‹ต์„ ๋ฐ˜ํ™˜"""
    
    # ์‚ฌ์šฉ์ž ๋ฉ”์‹œ์ง€๋ฅผ ํžˆ์Šคํ† ๋ฆฌ์— ์ถ”๊ฐ€
    conversation_history.append({
        "role": "user",
        "content": user_message
    })
    
    # API ํ˜ธ์ถœ
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=conversation_history
    )
    
    # ์–ด์‹œ์Šคํ„ดํŠธ ์‘๋‹ต์„ ํžˆ์Šคํ† ๋ฆฌ์— ์ถ”๊ฐ€
    assistant_message = response.choices[0].message.content
    conversation_history.append({
        "role": "assistant",
        "content": assistant_message
    })
    
    return assistant_message

# ๋Œ€ํ™” ์‹œ์ž‘!
print("ChatGPT: ์•ˆ๋…•ํ•˜์„ธ์š”! ๋ฌด์—‡์„ ๋„์™€๋“œ๋ฆด๊นŒ์š”?")

while True:
    user_input = input("You: ")
    
    if user_input.lower() in ['์ข…๋ฃŒ', 'quit', 'exit']:
        print("ChatGPT: ๋Œ€ํ™”๋ฅผ ์ข…๋ฃŒํ•ฉ๋‹ˆ๋‹ค. ์ข‹์€ ํ•˜๋ฃจ ๋˜์„ธ์š”!")
        break
    
    response = chat(user_input)
    print(f"ChatGPT: {response}")

์ด ์ฝ”๋“œ์˜ ํ•ต์‹ฌ์€ conversation_history ๋ฆฌ์ŠคํŠธ์•ผ. ๋ชจ๋“  ๋Œ€ํ™” ๋‚ด์šฉ์ด ์—ฌ๊ธฐ์— ์Œ“์ด๋ฉด์„œ ChatGPT๊ฐ€ ๋งฅ๋ฝ์„ ์ดํ•ดํ•  ์ˆ˜ ์žˆ๊ฒŒ ๋˜๋Š” ๊ฑฐ์ง€.

์˜ˆ๋ฅผ ๋“ค์–ด ์ด๋Ÿฐ ๋Œ€ํ™”๊ฐ€ ๊ฐ€๋Šฅํ•ด:

You: ํŒŒ์ด์ฌ์œผ๋กœ ๋ฆฌ์ŠคํŠธ๋ฅผ ์ •๋ ฌํ•˜๋Š” ๋ฐฉ๋ฒ• ์•Œ๋ ค์ค˜
ChatGPT: [์ •๋ ฌ ๋ฐฉ๋ฒ• ์„ค๋ช…]
You: ๊ทธ๋Ÿผ ์—ญ์ˆœ์œผ๋กœ ์ •๋ ฌํ•˜๋ ค๋ฉด?
ChatGPT: [์—ญ์ˆœ ์ •๋ ฌ ๋ฐฉ๋ฒ• ์„ค๋ช…]

๋‘ ๋ฒˆ์งธ ์งˆ๋ฌธ์—์„œ "๊ทธ๋Ÿผ"์ด๋ผ๊ณ  ํ–ˆ์„ ๋•Œ, ChatGPT๋Š” ์ด์ „ ๋Œ€ํ™”๋ฅผ ๊ธฐ์–ตํ•˜๊ณ  ์žˆ์–ด์„œ ๋ฆฌ์ŠคํŠธ ์ •๋ ฌ์— ๋Œ€ํ•œ ์งˆ๋ฌธ์ž„์„ ์•Œ์•„์ฐจ๋ฆฌ๋Š” ๊ฑฐ์•ผ! ๐Ÿง 

โš ๏ธ ํ† ํฐ ์ œํ•œ ์ฃผ์˜! ๋Œ€ํ™”๊ฐ€ ๊ธธ์–ด์ง€๋ฉด ํ† ํฐ ์ˆ˜๊ฐ€ ๊ณ„์† ์ฆ๊ฐ€ํ•ด. ๋ชจ๋ธ๋งˆ๋‹ค ์ตœ๋Œ€ ํ† ํฐ ์ œํ•œ์ด ์žˆ์–ด์„œ(GPT-4o๋Š” 128K ํ† ํฐ), ๋„ˆ๋ฌด ๊ธด ๋Œ€ํ™”๋Š” ์˜ค๋ฅ˜๊ฐ€ ๋‚  ์ˆ˜ ์žˆ์–ด. ์ ์ ˆํžˆ ํžˆ์Šคํ† ๋ฆฌ๋ฅผ ๊ด€๋ฆฌํ•ด์•ผ ํ•ด!

๐ŸŽ›๏ธ ํŒŒ๋ผ๋ฏธํ„ฐ๋กœ ์‘๋‹ต ์กฐ์ ˆํ•˜๊ธฐ

ChatGPT API๋Š” ๋‹ค์–‘ํ•œ ํŒŒ๋ผ๋ฏธํ„ฐ๋ฅผ ์ œ๊ณตํ•ด์„œ ์‘๋‹ต ์Šคํƒ€์ผ์„ ์„ธ๋ฐ€ํ•˜๊ฒŒ ์กฐ์ ˆํ•  ์ˆ˜ ์žˆ์–ด. ๋งˆ์น˜ ๋ผ๋””์˜ค ๋‹ค์ด์–ผ์„ ๋Œ๋ฆฌ๋“ฏ์ด ๋ง์ด์•ผ! ๐Ÿ“ป

๐ŸŒก๏ธ temperature (์˜จ๋„)

๋ฒ”์œ„: 0.0 ~ 2.0 (๊ธฐ๋ณธ๊ฐ’: 1.0)

์ด๊ฒŒ ๊ฐ€์žฅ ์ค‘์š”ํ•œ ํŒŒ๋ผ๋ฏธํ„ฐ์•ผ! ์‘๋‹ต์˜ ์ฐฝ์˜์„ฑ๊ณผ ๋ฌด์ž‘์œ„์„ฑ์„ ์กฐ์ ˆํ•ด.

โ€ข ๋‚ฎ์€ ๊ฐ’ (0.0 ~ 0.3): ์ผ๊ด€๋˜๊ณ  ์˜ˆ์ธก ๊ฐ€๋Šฅํ•œ ๋‹ต๋ณ€. ์‚ฌ์‹ค ๊ธฐ๋ฐ˜ ์งˆ๋ฌธ์— ์ ํ•ฉ
โ€ข ์ค‘๊ฐ„ ๊ฐ’ (0.5 ~ 1.0): ๊ท ํ˜•์žกํžŒ ๋‹ต๋ณ€. ์ผ๋ฐ˜์ ์ธ ๋Œ€ํ™”์— ์ข‹์Œ
โ€ข ๋†’์€ ๊ฐ’ (1.5 ~ 2.0): ์ฐฝ์˜์ ์ด๊ณ  ๋‹ค์–‘ํ•œ ๋‹ต๋ณ€. ๋ธŒ๋ ˆ์ธ์Šคํ† ๋ฐ์ด๋‚˜ ์ฐฝ์ž‘์— ์œ ์šฉ

์˜ˆ์ œ:

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "ํŒŒ์ด์ฌ์ด๋ž€?"}],
    temperature=0.2  # ์ •ํ™•ํ•˜๊ณ  ์ผ๊ด€๋œ ๋‹ต๋ณ€
)

๐ŸŽฒ top_p (nucleus sampling)

๋ฒ”์œ„: 0.0 ~ 1.0 (๊ธฐ๋ณธ๊ฐ’: 1.0)

temperature์™€ ๋น„์Šทํ•˜์ง€๋งŒ ๋‹ค๋ฅธ ๋ฐฉ์‹์œผ๋กœ ์ž‘๋™ํ•ด. ๋ˆ„์  ํ™•๋ฅ ์ด top_p์— ๋„๋‹ฌํ•  ๋•Œ๊นŒ์ง€์˜ ํ† ํฐ๋งŒ ๊ณ ๋ คํ•˜๋Š” ๊ฑฐ์•ผ.

โ€ข ๋‚ฎ์€ ๊ฐ’ (0.1): ๊ฐ€์žฅ ํ™•๋ฅ  ๋†’์€ ๋‹จ์–ด๋“ค๋งŒ ์„ ํƒ
โ€ข ๋†’์€ ๊ฐ’ (0.9): ๋” ๋‹ค์–‘ํ•œ ๋‹จ์–ด ์„ ํƒ ๊ฐ€๋Šฅ

๐Ÿ’ก ๋ณดํ†ต temperature์™€ top_p ์ค‘ ํ•˜๋‚˜๋งŒ ์กฐ์ ˆํ•˜๋Š” ๊ฑธ ์ถ”์ฒœํ•ด. ๋‘˜ ๋‹ค ์กฐ์ ˆํ•˜๋ฉด ์˜ˆ์ธกํ•˜๊ธฐ ์–ด๋ ค์›Œ์ ธ!

๐Ÿ“ max_tokens (์ตœ๋Œ€ ํ† ํฐ ์ˆ˜)

์‘๋‹ต์˜ ์ตœ๋Œ€ ๊ธธ์ด๋ฅผ ์ œํ•œํ•ด. ๋น„์šฉ ๊ด€๋ฆฌ์—๋„ ์ค‘์š”ํ•˜๊ณ , ์งง์€ ๋‹ต๋ณ€์ด ํ•„์š”ํ•  ๋•Œ ์œ ์šฉํ•ด.

์˜ˆ์ œ:

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "AI๋ฅผ ํ•œ ๋ฌธ์žฅ์œผ๋กœ ์„ค๋ช…ํ•ด์ค˜"}],
    max_tokens=50  # ์งง์€ ๋‹ต๋ณ€ ๊ฐ•์ œ
)

๐ŸŽฏ presence_penalty & frequency_penalty

๋ฒ”์œ„: -2.0 ~ 2.0 (๊ธฐ๋ณธ๊ฐ’: 0)

presence_penalty: ์ƒˆ๋กœ์šด ์ฃผ์ œ๋กœ ์ „ํ™˜ํ•˜๋„๋ก ์œ ๋„
โ€ข ์–‘์ˆ˜ ๊ฐ’: ์ด๋ฏธ ์–ธ๊ธ‰๋œ ํ† ํฐ์„ ๋œ ์‚ฌ์šฉํ•˜๊ฒŒ ํ•จ
โ€ข ์Œ์ˆ˜ ๊ฐ’: ๊ฐ™์€ ์ฃผ์ œ๋ฅผ ๊ณ„์† ์ด์•ผ๊ธฐํ•˜๊ฒŒ ํ•จ

frequency_penalty: ๋ฐ˜๋ณต์„ ์ค„์ž„
โ€ข ์–‘์ˆ˜ ๊ฐ’: ์ž์ฃผ ๋‚˜์˜จ ๋‹จ์–ด๋ฅผ ๋œ ์‚ฌ์šฉ
โ€ข ์Œ์ˆ˜ ๊ฐ’: ๋ฐ˜๋ณต์„ ํ—ˆ์šฉ

์˜ˆ์ œ:

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "์ฐฝ์˜์ ์ธ ์ด์•ผ๊ธฐ๋ฅผ ์จ์ค˜"}],
    presence_penalty=0.6,  # ๋‹ค์–‘ํ•œ ์ฃผ์ œ
    frequency_penalty=0.5  # ๋ฐ˜๋ณต ์ค„์ด๊ธฐ
)

์ด๋Ÿฐ ํŒŒ๋ผ๋ฏธํ„ฐ๋“ค์„ ์กฐํ•ฉํ•˜๋ฉด ์ •๋ง ๋‹ค์–‘ํ•œ ์Šคํƒ€์ผ์˜ ์‘๋‹ต์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด. ํ”„๋กœ์ ํŠธ ์„ฑ๊ฒฉ์— ๋งž๊ฒŒ ์‹คํ—˜ํ•ด๋ณด๋Š” ๊ฒŒ ์ค‘์š”ํ•ด! ๐Ÿงช


๐ŸŽญ System Role๋กœ AI ์„ฑ๊ฒฉ ์ •ํ•˜๊ธฐ

messages ๋ฆฌ์ŠคํŠธ์—์„œ role์ด "system"์ธ ๋ฉ”์‹œ์ง€๋Š” ํŠน๋ณ„ํ•ด. ์ด๊ฑด ChatGPT์—๊ฒŒ ์–ด๋–ค ์—ญํ• ์„ ๋งก์„์ง€ ์ง€์‹œํ•˜๋Š” ๊ฑฐ์•ผ. ๋งˆ์น˜ ๋ฐฐ์šฐ์—๊ฒŒ ์บ๋ฆญํ„ฐ ์„ค์ •์„ ์•Œ๋ ค์ฃผ๋Š” ๊ฒƒ์ฒ˜๋Ÿผ!

system ๋ฉ”์‹œ์ง€๋Š” ๋Œ€ํ™” ์‹œ์ž‘ ๋ถ€๋ถ„์— ํ•œ ๋ฒˆ๋งŒ ๋„ฃ์œผ๋ฉด ๋ผ. ๊ทธ๋Ÿฌ๋ฉด ChatGPT๊ฐ€ ๊ทธ ์—ญํ• ์„ ๊ณ„์† ์œ ์ง€ํ•˜์ง€.

์˜ˆ์ œ 1: ์นœ์ ˆํ•œ Python ํŠœํ„ฐ

messages = [
    {
        "role": "system",
        "content": "๋‹น์‹ ์€ ์นœ์ ˆํ•˜๊ณ  ์ธ๋‚ด์‹ฌ ๋งŽ์€ Python ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์„ ์ƒ๋‹˜์ž…๋‹ˆ๋‹ค. ์ดˆ๋ณด์ž๋„ ์ดํ•ดํ•  ์ˆ˜ ์žˆ๋„๋ก ์‰ฝ๊ฒŒ ์„ค๋ช…ํ•˜๊ณ , ํ•ญ์ƒ ์˜ˆ์ œ ์ฝ”๋“œ๋ฅผ ํ•จ๊ป˜ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค."
    },
    {
        "role": "user",
        "content": "for ๋ฃจํ”„๊ฐ€ ๋ญ์˜ˆ์š”?"
    }
]

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

์˜ˆ์ œ 2: ์ „๋ฌธ ์ฝ”๋“œ ๋ฆฌ๋ทฐ์–ด

messages = [
    {
        "role": "system",
        "content": """๋‹น์‹ ์€ 10๋…„ ๊ฒฝ๋ ฅ์˜ ์‹œ๋‹ˆ์–ด ๊ฐœ๋ฐœ์ž์ž…๋‹ˆ๋‹ค. 
        ์ฝ”๋“œ๋ฅผ ๋ฆฌ๋ทฐํ•  ๋•Œ ๋‹ค์Œ์„ ์ค‘์ ์ ์œผ๋กœ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค:
        1. ์ฝ”๋“œ ๊ฐ€๋…์„ฑ
        2. ์„ฑ๋Šฅ ์ตœ์ ํ™” ๊ฐ€๋Šฅ์„ฑ
        3. ๋ณด์•ˆ ์ทจ์•ฝ์ 
        4. ๋ฒ ์ŠคํŠธ ํ”„๋ž™ํ‹ฐ์Šค ์ค€์ˆ˜ ์—ฌ๋ถ€
        
        ํ”ผ๋“œ๋ฐฑ์€ ๊ฑด์„ค์ ์ด๊ณ  ๊ตฌ์ฒด์ ์œผ๋กœ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค."""
    },
    {
        "role": "user",
        "content": "์ด ์ฝ”๋“œ๋ฅผ ๋ฆฌ๋ทฐํ•ด์ฃผ์„ธ์š”: [์ฝ”๋“œ ๋‚ด์šฉ]"
    }
]

์˜ˆ์ œ 3: JSON ์ถœ๋ ฅ ์ „๋ฌธ๊ฐ€

messages = [
    {
        "role": "system",
        "content": "๋‹น์‹ ์€ ํ•ญ์ƒ ์œ ํšจํ•œ JSON ํ˜•์‹์œผ๋กœ๋งŒ ์‘๋‹ตํ•ฉ๋‹ˆ๋‹ค. ์ถ”๊ฐ€ ์„ค๋ช… ์—†์ด ์ˆœ์ˆ˜ JSON๋งŒ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค."
    },
    {
        "role": "user",
        "content": "์‚ฌ๊ณผ, ๋ฐ”๋‚˜๋‚˜, ์˜ค๋ Œ์ง€์˜ ์˜์–‘ ์ •๋ณด๋ฅผ ์•Œ๋ ค์ค˜"
    }
]

์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ํ”„๋กœ๊ทธ๋žจ์—์„œ ํŒŒ์‹ฑํ•˜๊ธฐ ์‰ฌ์šด JSON ํ˜•ํƒœ๋กœ ๋‹ต๋ณ€์„ ๋ฐ›์„ ์ˆ˜ ์žˆ์–ด! ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌํ•  ๋•Œ ์—„์ฒญ ์œ ์šฉํ•˜์ง€. ๐Ÿ“Š

๐Ÿ’ก Pro Tip: system ๋ฉ”์‹œ์ง€๋Š” ๊ตฌ์ฒด์ ์ผ์ˆ˜๋ก ์ข‹์•„. "์นœ์ ˆํ•˜๊ฒŒ ๋‹ต๋ณ€ํ•ด์ค˜" ๋ณด๋‹ค๋Š” "์ดˆ๋“ฑํ•™์ƒ๋„ ์ดํ•ดํ•  ์ˆ˜ ์žˆ๋Š” ์‰ฌ์šด ๋‹จ์–ด๋กœ, ๋น„์œ ๋ฅผ ๋“ค์–ด๊ฐ€๋ฉฐ ์„ค๋ช…ํ•ด์ค˜"์ฒ˜๋Ÿผ ์ƒ์„ธํ•˜๊ฒŒ ์ž‘์„ฑํ•˜๋ฉด ํ›จ์”ฌ ์›ํ•˜๋Š” ๊ฒฐ๊ณผ๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ์–ด!

โšก ์ŠคํŠธ๋ฆฌ๋ฐ์œผ๋กœ ์‹ค์‹œ๊ฐ„ ์‘๋‹ต ๋ฐ›๊ธฐ

ChatGPT ์›น์‚ฌ์ดํŠธ์—์„œ ๋‹ต๋ณ€์ด ํ•œ ๊ธ€์ž์”ฉ ํƒ€์ดํ•‘๋˜๋Š” ๊ฑฐ ๋ดค์ง€? ๊ทธ๊ฒŒ ๋ฐ”๋กœ ์ŠคํŠธ๋ฆฌ๋ฐ์ด์•ผ! API์—์„œ๋„ ๋˜‘๊ฐ™์ด ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์–ด. ์‚ฌ์šฉ์ž ๊ฒฝํ—˜์ด ํ›จ์”ฌ ์ข‹์•„์ง€๊ฑฐ๋“ . โšก

์ผ๋ฐ˜ API ํ˜ธ์ถœ์€ ์ „์ฒด ์‘๋‹ต์ด ์™„์„ฑ๋  ๋•Œ๊นŒ์ง€ ๊ธฐ๋‹ค๋ ค์•ผ ํ•˜์ง€๋งŒ, ์ŠคํŠธ๋ฆฌ๋ฐ์€ ์ƒ์„ฑ๋˜๋Š” ์ฆ‰์‹œ ๋ฐ›์„ ์ˆ˜ ์žˆ์–ด. ๊ธด ๋‹ต๋ณ€์ผ ๋•Œ ํŠนํžˆ ์œ ์šฉํ•ด!

from openai import OpenAI
import os

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# stream=True ์˜ต์…˜ ์ถ”๊ฐ€!
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "user", "content": "์ธ๊ณต์ง€๋Šฅ์˜ ์—ญ์‚ฌ์— ๋Œ€ํ•ด ์ž์„ธํžˆ ์„ค๋ช…ํ•ด์ค˜"}
    ],
    stream=True  # ์ŠคํŠธ๋ฆฌ๋ฐ ํ™œ์„ฑํ™”
)

print("ChatGPT: ", end="")

# ์ŠคํŠธ๋ฆผ์—์„œ ์ฒญํฌ๋ฅผ ํ•˜๋‚˜์”ฉ ๋ฐ›์•„์„œ ์ถœ๋ ฅ
for chunk in response:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)

print()  # ์ค„๋ฐ”๊ฟˆ

์ฝ”๋“œ ์„ค๋ช…:

1. stream=True ํŒŒ๋ผ๋ฏธํ„ฐ๋ฅผ ์ถ”๊ฐ€ํ•˜๋ฉด ์ŠคํŠธ๋ฆฌ๋ฐ ๋ชจ๋“œ๊ฐ€ ํ™œ์„ฑํ™”๋ผ
2. ์‘๋‹ต ๊ฐ์ฒด๋ฅผ for ๋ฃจํ”„๋กœ ์ˆœํšŒํ•˜๋ฉด์„œ ์ฒญํฌ(chunk)๋ฅผ ํ•˜๋‚˜์”ฉ ๋ฐ›์•„
3. chunk.choices[0].delta.content์— ์ƒˆ๋กœ ์ƒ์„ฑ๋œ ํ…์ŠคํŠธ๊ฐ€ ๋“ค์–ด์žˆ์–ด
4. end=""์™€ flush=True๋กœ ์ฆ‰์‹œ ์ถœ๋ ฅ๋˜๊ฒŒ ํ•ด

์‹คํ–‰ํ•˜๋ฉด ChatGPT ์›น์‚ฌ์ดํŠธ์ฒ˜๋Ÿผ ๋‹ต๋ณ€์ด ์‹ค์‹œ๊ฐ„์œผ๋กœ ๋‚˜ํƒ€๋‚˜๋Š” ๊ฑธ ๋ณผ ์ˆ˜ ์žˆ์–ด! ๐Ÿ˜Š

์ŠคํŠธ๋ฆฌ๋ฐ + ๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ

์ŠคํŠธ๋ฆฌ๋ฐ๊ณผ ๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ๋ฅผ ํ•จ๊ป˜ ์‚ฌ์šฉํ•˜๋ ค๋ฉด ์ „์ฒด ์‘๋‹ต์„ ๋ชจ์•„์•ผ ํ•ด:

def chat_with_streaming(user_message, conversation_history):
    """์ŠคํŠธ๋ฆฌ๋ฐ์œผ๋กœ ๋Œ€ํ™”ํ•˜๋ฉด์„œ ํžˆ์Šคํ† ๋ฆฌ ๊ด€๋ฆฌ"""
    
    conversation_history.append({
        "role": "user",
        "content": user_message
    })
    
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=conversation_history,
        stream=True
    )
    
    full_response = ""
    print("ChatGPT: ", end="")
    
    for chunk in response:
        if chunk.choices[0].delta.content is not None:
            content = chunk.choices[0].delta.content
            print(content, end="", flush=True)
            full_response += content
    
    print()
    
    # ์™„์„ฑ๋œ ์‘๋‹ต์„ ํžˆ์Šคํ† ๋ฆฌ์— ์ถ”๊ฐ€
    conversation_history.append({
        "role": "assistant",
        "content": full_response
    })
    
    return full_response
๐Ÿ’ก ์–ธ์ œ ์ŠคํŠธ๋ฆฌ๋ฐ์„ ์‚ฌ์šฉํ• ๊นŒ? โ€ข ์›น ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์ด๋‚˜ ์ฑ—๋ด‡ UI๋ฅผ ๋งŒ๋“ค ๋•Œ
โ€ข ๊ธด ๋‹ต๋ณ€์ด ์˜ˆ์ƒ๋  ๋•Œ
โ€ข ์‚ฌ์šฉ์ž์—๊ฒŒ ์ฆ‰๊ฐ์ ์ธ ํ”ผ๋“œ๋ฐฑ์„ ์ฃผ๊ณ  ์‹ถ์„ ๋•Œ

๋ฐ˜๋Œ€๋กœ ๋ฐฑ๊ทธ๋ผ์šด๋“œ ์ž‘์—…์ด๋‚˜ ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ์—๋Š” ์ผ๋ฐ˜ ๋ชจ๋“œ๊ฐ€ ๋” ๊ฐ„๋‹จํ•ด!

๐Ÿ›ก๏ธ ์—๋Ÿฌ ์ฒ˜๋ฆฌ์™€ ์žฌ์‹œ๋„ ๋กœ์ง

API ํ˜ธ์ถœ์€ ํ•ญ์ƒ ์„ฑ๊ณตํ•œ๋‹ค๋Š” ๋ณด์žฅ์ด ์—†์–ด. ๋„คํŠธ์›Œํฌ ๋ฌธ์ œ, ์„œ๋ฒ„ ๊ณผ๋ถ€ํ•˜, ์ž˜๋ชป๋œ ์š”์ฒญ ๋“ฑ ๋‹ค์–‘ํ•œ ์ด์œ ๋กœ ์‹คํŒจํ•  ์ˆ˜ ์žˆ์ง€. ์•ˆ์ •์ ์ธ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์„ ๋งŒ๋“ค๋ ค๋ฉด ์—๋Ÿฌ ์ฒ˜๋ฆฌ๊ฐ€ ํ•„์ˆ˜์•ผ! ๐Ÿ›ก๏ธ

๊ธฐ๋ณธ ์—๋Ÿฌ ์ฒ˜๋ฆฌ

from openai import OpenAI, OpenAIError
import os

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

try:
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": "์•ˆ๋…•!"}]
    )
    print(response.choices[0].message.content)
    
except OpenAIError as e:
    print(f"OpenAI API ์—๋Ÿฌ ๋ฐœ์ƒ: {e}")
    
except Exception as e:
    print(f"์˜ˆ์ƒ์น˜ ๋ชปํ•œ ์—๋Ÿฌ: {e}")

๊ตฌ์ฒด์ ์ธ ์—๋Ÿฌ ํƒ€์ž… ์ฒ˜๋ฆฌ

OpenAI ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋Š” ๋‹ค์–‘ํ•œ ์—๋Ÿฌ ํƒ€์ž…์„ ์ œ๊ณตํ•ด:

from openai import (
    OpenAI,
    APIError,
    APIConnectionError,
    RateLimitError,
    AuthenticationError
)
import time

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def chat_with_error_handling(message):
    try:
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": message}]
        )
        return response.choices[0].message.content
        
    except AuthenticationError:
        print("โŒ API ํ‚ค๊ฐ€ ์œ ํšจํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค!")
        return None
        
    except RateLimitError:
        print("โณ ์š”์ฒญ ํ•œ๋„ ์ดˆ๊ณผ! ์ž ์‹œ ํ›„ ๋‹ค์‹œ ์‹œ๋„ํ•ฉ๋‹ˆ๋‹ค...")
        time.sleep(60)  # 1๋ถ„ ๋Œ€๊ธฐ
        return chat_with_error_handling(message)  # ์žฌ์‹œ๋„
        
    except APIConnectionError:
        print("๐ŸŒ ๋„คํŠธ์›Œํฌ ์—ฐ๊ฒฐ ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ–ˆ์Šต๋‹ˆ๋‹ค.")
        return None
        
    except APIError as e:
        print(f"โš ๏ธ API ์—๋Ÿฌ: {e}")
        return None

์žฌ์‹œ๋„ ๋กœ์ง ๊ตฌํ˜„ํ•˜๊ธฐ

์ผ์‹œ์ ์ธ ๋„คํŠธ์›Œํฌ ๋ฌธ์ œ๋‚˜ ์„œ๋ฒ„ ๊ณผ๋ถ€ํ•˜๋Š” ์žฌ์‹œ๋„ํ•˜๋ฉด ํ•ด๊ฒฐ๋˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ์•„. ์ง€์ˆ˜ ๋ฐฑ์˜คํ”„(exponential backoff) ์ „๋žต์„ ์‚ฌ์šฉํ•ด๋ณด์ž:

import time
from openai import OpenAI, APIError

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def chat_with_retry(message, max_retries=3):
    """์žฌ์‹œ๋„ ๋กœ์ง์ด ํฌํ•จ๋œ ์ฑ„ํŒ… ํ•จ์ˆ˜"""
    
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="gpt-4o-mini",
                messages=[{"role": "user", "content": message}]
            )
            return response.choices[0].message.content
            
        except APIError as e:
            if attempt < max_retries - 1:
                # ๋Œ€๊ธฐ ์‹œ๊ฐ„์„ ์ ์  ๋Š˜๋ฆผ (1์ดˆ, 2์ดˆ, 4์ดˆ...)
                wait_time = 2 ** attempt
                print(f"โณ ์—๋Ÿฌ ๋ฐœ์ƒ. {wait_time}์ดˆ ํ›„ ์žฌ์‹œ๋„... (์‹œ๋„ {attempt + 1}/{max_retries})")
                time.sleep(wait_time)
            else:
                print(f"โŒ {max_retries}๋ฒˆ ์‹œ๋„ ํ›„ ์‹คํŒจ: {e}")
                return None
    
    return None

# ์‚ฌ์šฉ ์˜ˆ์ œ
result = chat_with_retry("ํŒŒ์ด์ฌ์ด๋ž€?")
if result:
    print(result)
else:
    print("์‘๋‹ต์„ ๋ฐ›์ง€ ๋ชปํ–ˆ์Šต๋‹ˆ๋‹ค.")
โš ๏ธ ์ฃผ์˜์‚ฌํ•ญ: โ€ข ๋ฌดํ•œ ์žฌ์‹œ๋„๋Š” ํ”ผํ•ด์•ผ ํ•ด. ์ตœ๋Œ€ ์‹œ๋„ ํšŸ์ˆ˜๋ฅผ ์ •ํ•ด๋‘์ž
โ€ข Rate Limit ์—๋Ÿฌ๋Š” ์ถฉ๋ถ„ํžˆ ๊ธฐ๋‹ค๋ฆฐ ํ›„ ์žฌ์‹œ๋„ํ•ด์•ผ ํ•ด
โ€ข ์—๋Ÿฌ ๋กœ๊ทธ๋ฅผ ๋‚จ๊ฒจ์„œ ๋ฌธ์ œ ํŒŒ์•…์— ๋„์›€์ด ๋˜๊ฒŒ ํ•˜์ž

๐Ÿ’ฐ ๋น„์šฉ ์ตœ์ ํ™” ํŒ

API ์‚ฌ์šฉ๋ฃŒ๊ฐ€ ๊ฑฑ์ •๋˜์ง€? ๊ฑฑ์ • ๋งˆ! ๋˜‘๋˜‘ํ•˜๊ฒŒ ์‚ฌ์šฉํ•˜๋ฉด ๋น„์šฉ์„ ํฌ๊ฒŒ ์ค„์ผ ์ˆ˜ ์žˆ์–ด. ์‹ค์ œ๋กœ ๋งŽ์€ ๊ฐœ๋ฐœ์ž๋“ค์ด ์ด๋Ÿฐ ๋ฐฉ๋ฒ•๋“ค๋กœ ๋น„์šฉ์„ ์ ˆ๊ฐํ•˜๊ณ  ์žˆ๊ฑฐ๋“ . ๐Ÿ’ก

1. ์ ์ ˆํ•œ ๋ชจ๋ธ ์„ ํƒํ•˜๊ธฐ

๋ชจ๋ธ๋งˆ๋‹ค ๊ฐ€๊ฒฉ์ด ๋‹ฌ๋ผ. ํ•ญ์ƒ ์ตœ์‹  ๋ชจ๋ธ์„ ์“ธ ํ•„์š”๋Š” ์—†์–ด!

๋ชจ๋ธ๋ณ„ ํŠน์ง•:
โ€ข gpt-4o: ๊ฐ€์žฅ ๊ฐ•๋ ฅํ•˜์ง€๋งŒ ๋น„์Œˆ. ๋ณต์žกํ•œ ์ถ”๋ก ์ด ํ•„์š”ํ•  ๋•Œ
โ€ข gpt-4o-mini: ๊ฐ€์„ฑ๋น„ ์ตœ๊ณ ! ๋Œ€๋ถ€๋ถ„์˜ ์ž‘์—…์— ์ถฉ๋ถ„
โ€ข gpt-3.5-turbo: ์ €๋ ดํ•˜๊ณ  ๋น ๋ฆ„. ๊ฐ„๋‹จํ•œ ์ž‘์—…์— ์ ํ•ฉ

๐Ÿ’ก ํŒ: ํ”„๋กœํ† ํƒ€์ž…์€ gpt-4o-mini๋กœ ๊ฐœ๋ฐœํ•˜๊ณ , ์ •๋ง ํ•„์š”ํ•œ ๋ถ€๋ถ„๋งŒ gpt-4o๋ฅผ ์‚ฌ์šฉํ•˜์ž!

2. ํ† ํฐ ์‚ฌ์šฉ๋Ÿ‰ ๋ชจ๋‹ˆํ„ฐ๋ง

API ์‘๋‹ต์—๋Š” ์‚ฌ์šฉ๋œ ํ† ํฐ ์ •๋ณด๊ฐ€ ํฌํ•จ๋˜์–ด ์žˆ์–ด. ์ด๊ฑธ ์ถ”์ ํ•˜๋ฉด ๋น„์šฉ์„ ์˜ˆ์ธกํ•  ์ˆ˜ ์žˆ์ง€:

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "์•ˆ๋…•!"}]
)

# ํ† ํฐ ์‚ฌ์šฉ๋Ÿ‰ ํ™•์ธ
usage = response.usage
print(f"์ž…๋ ฅ ํ† ํฐ: {usage.prompt_tokens}")
print(f"์ถœ๋ ฅ ํ† ํฐ: {usage.completion_tokens}")
print(f"์ด ํ† ํฐ: {usage.total_tokens}")

# ๋Œ€๋žต์ ์ธ ๋น„์šฉ ๊ณ„์‚ฐ (gpt-4o-mini ๊ธฐ์ค€)
input_cost = (usage.prompt_tokens / 1_000_000) * 0.15
output_cost = (usage.completion_tokens / 1_000_000) * 0.60
total_cost = input_cost + output_cost
print(f"์˜ˆ์ƒ ๋น„์šฉ: ${total_cost:.6f}")

3. max_tokens๋กœ ์ถœ๋ ฅ ์ œํ•œ

๋ถˆํ•„์š”ํ•˜๊ฒŒ ๊ธด ๋‹ต๋ณ€์€ ๋น„์šฉ ๋‚ญ๋น„์•ผ. ํ•„์š”ํ•œ ๊ธธ์ด๋งŒํผ๋งŒ ๋ฐ›์ž:

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "AI๋ฅผ ํ•œ ๋ฌธ์žฅ์œผ๋กœ ์„ค๋ช…ํ•ด์ค˜"}],
    max_tokens=100  # ์งง์€ ๋‹ต๋ณ€์œผ๋กœ ์ œํ•œ
)

4. ๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ ๊ด€๋ฆฌ

๋Œ€ํ™”๊ฐ€ ๊ธธ์–ด์งˆ์ˆ˜๋ก ๋งค๋ฒˆ ์ „์ฒด ํžˆ์Šคํ† ๋ฆฌ๋ฅผ ๋ณด๋‚ด์•ผ ํ•ด์„œ ๋น„์šฉ์ด ์ฆ๊ฐ€ํ•ด. ์˜ค๋ž˜๋œ ๋ฉ”์‹œ์ง€๋Š” ์ œ๊ฑฐํ•˜์ž:

def manage_conversation_history(history, max_messages=10):
    """์ตœ๊ทผ ๋ฉ”์‹œ์ง€๋งŒ ์œ ์ง€"""
    if len(history) > max_messages:
        # system ๋ฉ”์‹œ์ง€๋Š” ์œ ์ง€ํ•˜๊ณ  ๋‚˜๋จธ์ง€๋งŒ ์ œํ•œ
        system_messages = [msg for msg in history if msg["role"] == "system"]
        other_messages = [msg for msg in history if msg["role"] != "system"]
        
        # ์ตœ๊ทผ ๋ฉ”์‹œ์ง€๋งŒ ์œ ์ง€
        recent_messages = other_messages[-(max_messages-len(system_messages)):]
        
        return system_messages + recent_messages
    
    return history

5. ์บ์‹ฑ ํ™œ์šฉํ•˜๊ธฐ

๊ฐ™์€ ์งˆ๋ฌธ์— ๋Œ€ํ•œ ๋‹ต๋ณ€์„ ์บ์‹ฑํ•˜๋ฉด API ํ˜ธ์ถœ์„ ์ค„์ผ ์ˆ˜ ์žˆ์–ด:

import hashlib
import json

# ๊ฐ„๋‹จํ•œ ๋ฉ”๋ชจ๋ฆฌ ์บ์‹œ
response_cache = {}

def get_cached_response(messages):
    """์บ์‹œ๋œ ์‘๋‹ต์ด ์žˆ์œผ๋ฉด ๋ฐ˜ํ™˜, ์—†์œผ๋ฉด API ํ˜ธ์ถœ"""
    
    # ๋ฉ”์‹œ์ง€๋ฅผ ํ•ด์‹œ๋กœ ๋ณ€ํ™˜ (์บ์‹œ ํ‚ค๋กœ ์‚ฌ์šฉ)
    cache_key = hashlib.md5(
        json.dumps(messages, sort_keys=True).encode()
    ).hexdigest()
    
    # ์บ์‹œ ํ™•์ธ
    if cache_key in response_cache:
        print("๐Ÿ’พ ์บ์‹œ์—์„œ ์‘๋‹ต ๋ฐ˜ํ™˜!")
        return response_cache[cache_key]
    
    # API ํ˜ธ์ถœ
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages
    )
    
    result = response.choices[0].message.content
    
    # ์บ์‹œ์— ์ €์žฅ
    response_cache[cache_key] = result
    
    return result
๐Ÿ’ก ๋น„์šฉ ์ ˆ๊ฐ ์ฒดํฌ๋ฆฌ์ŠคํŠธ: โœ… ์ž‘์—…์— ๋งž๋Š” ๊ฐ€์žฅ ์ €๋ ดํ•œ ๋ชจ๋ธ ์‚ฌ์šฉ
โœ… max_tokens๋กœ ์ถœ๋ ฅ ๊ธธ์ด ์ œํ•œ
โœ… ๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ ์ ์ ˆํžˆ ๊ด€๋ฆฌ
โœ… ์ž์ฃผ ์‚ฌ์šฉ๋˜๋Š” ์‘๋‹ต์€ ์บ์‹ฑ
โœ… ํ† ํฐ ์‚ฌ์šฉ๋Ÿ‰ ์ •๊ธฐ์ ์œผ๋กœ ๋ชจ๋‹ˆํ„ฐ๋ง
โœ… ๊ฐœ๋ฐœ ์ค‘์—๋Š” ํ…Œ์ŠคํŠธ ๊ณ„์ • ์‚ฌ์šฉ

๐Ÿš€ ์‹ค์ „ ํ”„๋กœ์ ํŠธ: ๊ฐ„๋‹จํ•œ ์ฑ—๋ด‡ ๋งŒ๋“ค๊ธฐ

์ง€๊ธˆ๊นŒ์ง€ ๋ฐฐ์šด ๋‚ด์šฉ์„ ๋ชจ๋‘ ํ™œ์šฉํ•ด์„œ ์‹ค์ œ๋กœ ์ž‘๋™ํ•˜๋Š” ์ฑ—๋ด‡์„ ๋งŒ๋“ค์–ด๋ณด์ž! ์ด ์ฑ—๋ด‡์€ ๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ, ์—๋Ÿฌ ์ฒ˜๋ฆฌ, ์ŠคํŠธ๋ฆฌ๋ฐ, ๋น„์šฉ ์ถ”์ ๊นŒ์ง€ ๋ชจ๋‘ ํฌํ•จํ•˜๊ณ  ์žˆ์–ด. ๐Ÿค–

from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import os
import time

# ํ™˜๊ฒฝ๋ณ€์ˆ˜ ๋กœ๋“œ
load_dotenv()

class ChatBot:
    """ChatGPT ๊ธฐ๋ฐ˜ ์ฑ—๋ด‡ ํด๋ž˜์Šค"""
    
    def __init__(self, model="gpt-4o-mini", system_message=None):
        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
        self.model = model
        self.conversation_history = []
        self.total_tokens_used = 0
        
        # ์‹œ์Šคํ…œ ๋ฉ”์‹œ์ง€ ์„ค์ •
        if system_message:
            self.conversation_history.append({
                "role": "system",
                "content": system_message
            })
    
    def chat(self, user_message, stream=True):
        """์‚ฌ์šฉ์ž ๋ฉ”์‹œ์ง€๋ฅผ ๋ฐ›์•„ ์‘๋‹ต ๋ฐ˜ํ™˜"""
        
        # ์‚ฌ์šฉ์ž ๋ฉ”์‹œ์ง€ ์ถ”๊ฐ€
        self.conversation_history.append({
            "role": "user",
            "content": user_message
        })
        
        try:
            if stream:
                return self._chat_with_streaming()
            else:
                return self._chat_normal()
                
        except OpenAIError as e:
            error_msg = f"์—๋Ÿฌ๊ฐ€ ๋ฐœ์ƒํ–ˆ์Šต๋‹ˆ๋‹ค: {e}"
            print(error_msg)
            return error_msg
    
    def _chat_normal(self):
        """์ผ๋ฐ˜ ๋ชจ๋“œ ์ฑ„ํŒ…"""
        response = self.client.chat.completions.create(
            model=self.model,
            messages=self.conversation_history
        )
        
        assistant_message = response.choices[0].message.content
        
        # ํžˆ์Šคํ† ๋ฆฌ์— ์ถ”๊ฐ€
        self.conversation_history.append({
            "role": "assistant",
            "content": assistant_message
        })
        
        # ํ† ํฐ ์‚ฌ์šฉ๋Ÿ‰ ์ถ”์ 
        self.total_tokens_used += response.usage.total_tokens
        
        return assistant_message
    
    def _chat_with_streaming(self):
        """์ŠคํŠธ๋ฆฌ๋ฐ ๋ชจ๋“œ ์ฑ„ํŒ…"""
        response = self.client.chat.completions.create(
            model=self.model,
            messages=self.conversation_history,
            stream=True
        )
        
        full_response = ""
        print("๐Ÿค– ChatBot: ", end="", flush=True)
        
        for chunk in response:
            if chunk.choices[0].delta.content is not None:
                content = chunk.choices[0].delta.content
                print(content, end="", flush=True)
                full_response += content
        
        print()  # ์ค„๋ฐ”๊ฟˆ
        
        # ํžˆ์Šคํ† ๋ฆฌ์— ์ถ”๊ฐ€
        self.conversation_history.append({
            "role": "assistant",
            "content": full_response
        })
        
        return full_response
    
    def clear_history(self):
        """๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ ์ดˆ๊ธฐํ™” (์‹œ์Šคํ…œ ๋ฉ”์‹œ์ง€๋Š” ์œ ์ง€)"""
        system_messages = [
            msg for msg in self.conversation_history 
            if msg["role"] == "system"
        ]
        self.conversation_history = system_messages
        print("๐Ÿ”„ ๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ๊ฐ€ ์ดˆ๊ธฐํ™”๋˜์—ˆ์Šต๋‹ˆ๋‹ค.")
    
    def get_stats(self):
        """ํ†ต๊ณ„ ์ •๋ณด ๋ฐ˜ํ™˜"""
        return {
            "total_messages": len(self.conversation_history),
            "total_tokens": self.total_tokens_used,
            "estimated_cost": self.total_tokens_used * 0.0000002  # ๋Œ€๋žต์ ์ธ ๋น„์šฉ
        }


# ์ฑ—๋ด‡ ์‚ฌ์šฉ ์˜ˆ์ œ
def main():
    # ์ฑ—๋ด‡ ์ดˆ๊ธฐํ™”
    bot = ChatBot(
        model="gpt-4o-mini",
        system_message="๋‹น์‹ ์€ ์นœ์ ˆํ•˜๊ณ  ์œ ๋จธ๋Ÿฌ์Šคํ•œ AI ์–ด์‹œ์Šคํ„ดํŠธ์ž…๋‹ˆ๋‹ค. ์ด๋ชจ์ง€๋ฅผ ์ ์ ˆํžˆ ์‚ฌ์šฉํ•˜๋ฉฐ ๋Œ€ํ™”ํ•ฉ๋‹ˆ๋‹ค."
    )
    
    print("=" * 50)
    print("๐ŸŽ‰ ChatGPT ์ฑ—๋ด‡์— ์˜ค์‹  ๊ฒƒ์„ ํ™˜์˜ํ•ฉ๋‹ˆ๋‹ค!")
    print("=" * 50)
    print("๋ช…๋ น์–ด:")
    print("  - '์ข…๋ฃŒ' ๋˜๋Š” 'quit': ํ”„๋กœ๊ทธ๋žจ ์ข…๋ฃŒ")
    print("  - '์ดˆ๊ธฐํ™”' ๋˜๋Š” 'clear': ๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ ์ดˆ๊ธฐํ™”")
    print("  - 'ํ†ต๊ณ„' ๋˜๋Š” 'stats': ์‚ฌ์šฉ ํ†ต๊ณ„ ํ™•์ธ")
    print("=" * 50)
    print()
    
    while True:
        # ์‚ฌ์šฉ์ž ์ž…๋ ฅ
        user_input = input("๐Ÿ‘ค You: ").strip()
        
        if not user_input:
            continue
        
        # ๋ช…๋ น์–ด ์ฒ˜๋ฆฌ
        if user_input.lower() in ['์ข…๋ฃŒ', 'quit', 'exit']:
            stats = bot.get_stats()
            print("\n๐Ÿ“Š ์ตœ์ข… ํ†ต๊ณ„:")
            print(f"  ์ด ๋ฉ”์‹œ์ง€: {stats['total_messages']}๊ฐœ")
            print(f"  ์ด ํ† ํฐ: {stats['total_tokens']}๊ฐœ")
            print(f"  ์˜ˆ์ƒ ๋น„์šฉ: ${stats['estimated_cost']:.6f}")
            print("\n๐Ÿ‘‹ ์ฑ—๋ด‡์„ ์ข…๋ฃŒํ•ฉ๋‹ˆ๋‹ค. ์ข‹์€ ํ•˜๋ฃจ ๋˜์„ธ์š”!")
            break
        
        elif user_input.lower() in ['์ดˆ๊ธฐํ™”', 'clear']:
            bot.clear_history()
            continue
        
        elif user_input.lower() in ['ํ†ต๊ณ„', 'stats']:
            stats = bot.get_stats()
            print(f"\n๐Ÿ“Š ํ˜„์žฌ ํ†ต๊ณ„:")
            print(f"  ์ด ๋ฉ”์‹œ์ง€: {stats['total_messages']}๊ฐœ")
            print(f"  ์ด ํ† ํฐ: {stats['total_tokens']}๊ฐœ")
            print(f"  ์˜ˆ์ƒ ๋น„์šฉ: ${stats['estimated_cost']:.6f}\n")
            continue
        
        # ์ผ๋ฐ˜ ๋Œ€ํ™”
        bot.chat(user_input, stream=True)
        print()


if __name__ == "__main__":
    main()

์ด ์ฑ—๋ด‡์€ ์‹ค์ œ๋กœ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ์ˆ˜์ค€์ด์•ผ! ์ฃผ์š” ๊ธฐ๋Šฅ๋“ค์„ ์‚ดํŽด๋ณด๋ฉด:

โœจ ์ฃผ์š” ๊ธฐ๋Šฅ:
โ€ข ํด๋ž˜์Šค ๊ธฐ๋ฐ˜ ๊ตฌ์กฐ๋กœ ์žฌ์‚ฌ์šฉ ๊ฐ€๋Šฅ
โ€ข ์ŠคํŠธ๋ฆฌ๋ฐ ๋ชจ๋“œ ์ง€์›
โ€ข ๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ ๊ด€๋ฆฌ
โ€ข ์—๋Ÿฌ ์ฒ˜๋ฆฌ
โ€ข ํ† ํฐ ์‚ฌ์šฉ๋Ÿ‰ ์ถ”์ 
โ€ข ๋ช…๋ น์–ด ์‹œ์Šคํ…œ (์ข…๋ฃŒ, ์ดˆ๊ธฐํ™”, ํ†ต๊ณ„)
โ€ข ์‹œ์Šคํ…œ ๋ฉ”์‹œ์ง€๋กœ ์„ฑ๊ฒฉ ์„ค์ • ๊ฐ€๋Šฅ

์ด ์ฝ”๋“œ๋ฅผ ๊ธฐ๋ฐ˜์œผ๋กœ ์›น ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜, Discord ๋ด‡, Slack ๋ด‡ ๋“ฑ ๋‹ค์–‘ํ•œ ํ”„๋กœ์ ํŠธ๋กœ ํ™•์žฅํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿš€

๐Ÿค– User Input AI Response Features โœ“ Streaming โœ“ Error Handling Optimization โœ“ Token Tracking โœ“ Cost Management Advanced โœ“ History Control โœ“ System Prompts Complete ChatBot Architecture

๐ŸŒ ์›น ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜๊ณผ ํ†ตํ•ฉํ•˜๊ธฐ

์ฑ—๋ด‡์„ ๋งŒ๋“ค์—ˆ์œผ๋‹ˆ ์ด์ œ ์›น์—์„œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•ด๋ณด์ž! Flask๋‚˜ FastAPI ๊ฐ™์€ ์›น ํ”„๋ ˆ์ž„์›Œํฌ์™€ ํ†ตํ•ฉํ•˜๋ฉด ๋ฉ‹์ง„ ์›น ์ฑ„ํŒ… ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด. ๐ŸŒŸ

Flask๋กœ ๊ฐ„๋‹จํ•œ API ์„œ๋ฒ„ ๋งŒ๋“ค๊ธฐ

๋จผ์ € Flask๋ฅผ ์„ค์น˜ํ•˜์ž:

pip install flask flask-cors

๊ทธ๋ฆฌ๊ณ  ๊ฐ„๋‹จํ•œ API ์„œ๋ฒ„๋ฅผ ๋งŒ๋“ค์–ด:

from flask import Flask, request, jsonify, Response
from flask_cors import CORS
from openai import OpenAI
import os
import json

app = Flask(__name__)
CORS(app)  # CORS ํ—ˆ์šฉ

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# ์„ธ์…˜๋ณ„ ๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ ์ €์žฅ (์‹ค์ œ๋กœ๋Š” ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์‚ฌ์šฉ ๊ถŒ์žฅ)
conversations = {}

@app.route('/chat', methods=['POST'])
def chat():
    """์ผ๋ฐ˜ ์ฑ„ํŒ… ์—”๋“œํฌ์ธํŠธ"""
    data = request.json
    user_message = data.get('message')
    session_id = data.get('session_id', 'default')
    
    if not user_message:
        return jsonify({'error': '๋ฉ”์‹œ์ง€๊ฐ€ ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค'}), 400
    
    # ์„ธ์…˜ ํžˆ์Šคํ† ๋ฆฌ ๊ฐ€์ ธ์˜ค๊ธฐ
    if session_id not in conversations:
        conversations[session_id] = []
    
    # ์‚ฌ์šฉ์ž ๋ฉ”์‹œ์ง€ ์ถ”๊ฐ€
    conversations[session_id].append({
        "role": "user",
        "content": user_message
    })
    
    try:
        # API ํ˜ธ์ถœ
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=conversations[session_id]
        )
        
        assistant_message = response.choices[0].message.content
        
        # ์–ด์‹œ์Šคํ„ดํŠธ ์‘๋‹ต ์ถ”๊ฐ€
        conversations[session_id].append({
            "role": "assistant",
            "content": assistant_message
        })
        
        return jsonify({
            'response': assistant_message,
            'tokens_used': response.usage.total_tokens
        })
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/chat/stream', methods=['POST'])
def chat_stream():
    """์ŠคํŠธ๋ฆฌ๋ฐ ์ฑ„ํŒ… ์—”๋“œํฌ์ธํŠธ"""
    data = request.json
    user_message = data.get('message')
    session_id = data.get('session_id', 'default')
    
    if session_id not in conversations:
        conversations[session_id] = []
    
    conversations[session_id].append({
        "role": "user",
        "content": user_message
    })
    
    def generate():
        try:
            response = client.chat.completions.create(
                model="gpt-4o-mini",
                messages=conversations[session_id],
                stream=True
            )
            
            full_response = ""
            for chunk in response:
                if chunk.choices[0].delta.content is not None:
                    content = chunk.choices[0].delta.content
                    full_response += content
                    # SSE ํ˜•์‹์œผ๋กœ ์ „์†ก
                    yield f"data: {json.dumps({'content': content})}\n\n"
            
            # ์™„์„ฑ๋œ ์‘๋‹ต์„ ํžˆ์Šคํ† ๋ฆฌ์— ์ถ”๊ฐ€
            conversations[session_id].append({
                "role": "assistant",
                "content": full_response
            })
            
        except Exception as e:
            yield f"data: {json.dumps({'error': str(e)})}\n\n"
    
    return Response(generate(), mimetype='text/event-stream')

@app.route('/clear/<session_id>', methods=['POST'])
def clear_conversation(session_id):
    """๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ ์ดˆ๊ธฐํ™”"""
    if session_id in conversations:
        conversations[session_id] = []
    return jsonify({'message': '๋Œ€ํ™”๊ฐ€ ์ดˆ๊ธฐํ™”๋˜์—ˆ์Šต๋‹ˆ๋‹ค'})

if __name__ == '__main__':
    app.run(debug=True, port=5000)

๊ฐ„๋‹จํ•œ HTML ํ”„๋ก ํŠธ์—”๋“œ

์ด์ œ ์ด API๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๊ฐ„๋‹จํ•œ ์›น ํŽ˜์ด์ง€๋ฅผ ๋งŒ๋“ค์–ด๋ณด์ž:

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>ChatGPT ์ฑ—๋ด‡</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            max-width: 800px;
            margin: 50px auto;
            padding: 20px;
        }
        #chat-container {
            border: 1px solid #ddd;
            height: 500px;
            overflow-y: auto;
            padding: 20px;
            margin-bottom: 20px;
            background: #f9f9f9;
        }
        .message {
            margin: 10px 0;
            padding: 10px;
            border-radius: 8px;
        }
        .user-message {
            background: #667eea;
            color: white;
            text-align: right;
        }
        .bot-message {
            background: white;
            border: 1px solid #ddd;
        }
        #input-container {
            display: flex;
            gap: 10px;
        }
        #message-input {
            flex: 1;
            padding: 10px;
            border: 1px solid #ddd;
            border-radius: 4px;
        }
        button {
            padding: 10px 20px;
            background: #667eea;
            color: white;
            border: none;
            border-radius: 4px;
            cursor: pointer;
        }
        button:hover {
            background: #5568d3;
        }
    </style>
</head>
<body>
    <h1>๐Ÿค– ChatGPT ์ฑ—๋ด‡</h1>
    <div id="chat-container"></div>
    <div id="input-container">
        <input type="text" id="message-input" placeholder="๋ฉ”์‹œ์ง€๋ฅผ ์ž…๋ ฅํ•˜์„ธ์š”...">
        <button onclick="sendMessage()">์ „์†ก</button>
        <button onclick="clearChat()">์ดˆ๊ธฐํ™”</button>
    </div>

    <script>
        const sessionId = 'user_' + Date.now();
        const chatContainer = document.getElementById('chat-container');
        const messageInput = document.getElementById('message-input');

        function addMessage(content, isUser) {
            const messageDiv = document.createElement('div');
            messageDiv.className = 'message ' + (isUser ? 'user-message' : 'bot-message');
            messageDiv.textContent = content;
            chatContainer.appendChild(messageDiv);
            chatContainer.scrollTop = chatContainer.scrollHeight;
        }

        async function sendMessage() {
            const message = messageInput.value.trim();
            if (!message) return;

            addMessage(message, true);
            messageInput.value = '';

            try {
                const response = await fetch('http://localhost:5000/chat', {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                    },
                    body: JSON.stringify({
                        message: message,
                        session_id: sessionId
                    })
                });

                const data = await response.json();
                addMessage(data.response, false);
            } catch (error) {
                addMessage('์—๋Ÿฌ๊ฐ€ ๋ฐœ์ƒํ–ˆ์Šต๋‹ˆ๋‹ค: ' + error.message, false);
            }
        }

        async function clearChat() {
            try {
                await fetch(`http://localhost:5000/clear/${sessionId}`, {
                    method: 'POST'
                });
                chatContainer.innerHTML = '';
                addMessage('๋Œ€ํ™”๊ฐ€ ์ดˆ๊ธฐํ™”๋˜์—ˆ์Šต๋‹ˆ๋‹ค.', false);
            } catch (error) {
                console.error('์ดˆ๊ธฐํ™” ์‹คํŒจ:', error);
            }
        }

        messageInput.addEventListener('keypress', (e) => {
            if (e.key === 'Enter') {
                sendMessage();
            }
        });
    </script>
</body>
</html>

์ด์ œ Flask ์„œ๋ฒ„๋ฅผ ์‹คํ–‰ํ•˜๊ณ  HTML ํŒŒ์ผ์„ ๋ธŒ๋ผ์šฐ์ €์—์„œ ์—ด๋ฉด ์ž‘๋™ํ•˜๋Š” ์›น ์ฑ—๋ด‡์„ ๋ณผ ์ˆ˜ ์žˆ์–ด! ๐ŸŽ‰

๐Ÿ’ก ์‹ค์ „ ํŒ: โ€ข ์‹ค์ œ ํ”„๋กœ๋•์…˜์—์„œ๋Š” ์„ธ์…˜ ๊ด€๋ฆฌ๋ฅผ Redis๋‚˜ ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค๋กœ ํ•ด์•ผ ํ•ด
โ€ข ์‚ฌ์šฉ์ž ์ธ์ฆ๊ณผ Rate Limiting์„ ์ถ”๊ฐ€ํ•˜์ž
โ€ข HTTPS๋ฅผ ์‚ฌ์šฉํ•ด์„œ ๋ณด์•ˆ์„ ๊ฐ•ํ™”ํ•˜์ž
โ€ข ์—๋Ÿฌ ๋กœ๊น…๊ณผ ๋ชจ๋‹ˆํ„ฐ๋ง์„ ์„ค์ •ํ•˜์ž

๐ŸŽ“ ๊ณ ๊ธ‰ ๊ธฐ๋Šฅ ํ™œ์šฉํ•˜๊ธฐ

๊ธฐ๋ณธ์ ์ธ ์‚ฌ์šฉ๋ฒ•์„ ๋„˜์–ด์„œ ChatGPT API์˜ ๊ณ ๊ธ‰ ๊ธฐ๋Šฅ๋“ค์„ ์•Œ์•„๋ณด์ž. ์ด๋Ÿฐ ๊ธฐ๋Šฅ๋“ค์„ ํ™œ์šฉํ•˜๋ฉด ํ›จ์”ฌ ๋” ๊ฐ•๋ ฅํ•œ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด! ๐Ÿ’ช

1. Function Calling (ํ•จ์ˆ˜ ํ˜ธ์ถœ)

ChatGPT๊ฐ€ ํŠน์ • ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•˜๋„๋ก ํ•  ์ˆ˜ ์žˆ์–ด. ์˜ˆ๋ฅผ ๋“ค์–ด ๋‚ ์”จ ์ •๋ณด๋ฅผ ๊ฐ€์ ธ์˜ค๊ฑฐ๋‚˜, ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค๋ฅผ ์กฐํšŒํ•˜๊ฑฐ๋‚˜, ์™ธ๋ถ€ API๋ฅผ ํ˜ธ์ถœํ•˜๋Š” ๋“ฑ์˜ ์ž‘์—…์ด ๊ฐ€๋Šฅํ•ด์ง€์ง€!

๋‚ ์”จ ์ •๋ณด๋ฅผ ๊ฐ€์ ธ์˜ค๋Š” ์˜ˆ์ œ:

import json

# ํ•จ์ˆ˜ ์ •์˜
def get_weather(location):
    """์‹ค์ œ๋กœ๋Š” ๋‚ ์”จ API๋ฅผ ํ˜ธ์ถœํ•˜์ง€๋งŒ, ์—ฌ๊ธฐ์„œ๋Š” ๋”๋ฏธ ๋ฐ์ดํ„ฐ ๋ฐ˜ํ™˜"""
    weather_data = {
        "์„œ์šธ": {"temperature": 15, "condition": "๋ง‘์Œ"},
        "๋ถ€์‚ฐ": {"temperature": 18, "condition": "ํ๋ฆผ"},
    }
    return weather_data.get(location, {"temperature": 20, "condition": "์•Œ ์ˆ˜ ์—†์Œ"})

# ChatGPT์—๊ฒŒ ํ•จ์ˆ˜ ์ •๋ณด ์ œ๊ณต
functions = [
    {
        "name": "get_weather",
        "description": "ํŠน์ • ์ง€์—ญ์˜ ํ˜„์žฌ ๋‚ ์”จ ์ •๋ณด๋ฅผ ๊ฐ€์ ธ์˜ต๋‹ˆ๋‹ค",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "๋‚ ์”จ๋ฅผ ํ™•์ธํ•  ๋„์‹œ ์ด๋ฆ„ (์˜ˆ: ์„œ์šธ, ๋ถ€์‚ฐ)"
                }
            },
            "required": ["location"]
        }
    }
]

# API ํ˜ธ์ถœ
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "์„œ์šธ ๋‚ ์”จ ์–ด๋•Œ?"}],
    functions=functions,
    function_call="auto"
)

message = response.choices[0].message

# ํ•จ์ˆ˜ ํ˜ธ์ถœ์ด ํ•„์š”ํ•œ์ง€ ํ™•์ธ
if message.function_call:
    function_name = message.function_call.name
    function_args = json.loads(message.function_call.arguments)
    
    # ํ•จ์ˆ˜ ์‹คํ–‰
    if function_name == "get_weather":
        weather = get_weather(function_args["location"])
        
        # ํ•จ์ˆ˜ ๊ฒฐ๊ณผ๋ฅผ ChatGPT์—๊ฒŒ ์ „๋‹ฌ
        second_response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "user", "content": "์„œ์šธ ๋‚ ์”จ ์–ด๋•Œ?"},
                message,
                {
                    "role": "function",
                    "name": function_name,
                    "content": json.dumps(weather)
                }
            ]
        )
        
        print(second_response.choices[0].message.content)
else:
    print(message.content)

์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ChatGPT๊ฐ€ ์ž์—ฐ์–ด ์งˆ๋ฌธ์„ ์ดํ•ดํ•˜๊ณ , ์ ์ ˆํ•œ ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•˜๊ณ , ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์ž์—ฐ์Šค๋Ÿฝ๊ฒŒ ๋‹ต๋ณ€์œผ๋กœ ๋งŒ๋“ค์–ด์ค˜! ๐ŸŽฏ

2. JSON Mode

ChatGPT๊ฐ€ ํ•ญ์ƒ ์œ ํšจํ•œ JSON ํ˜•์‹์œผ๋กœ ์‘๋‹ตํ•˜๋„๋ก ๊ฐ•์ œํ•  ์ˆ˜ ์žˆ์–ด. ๋ฐ์ดํ„ฐ ํŒŒ์‹ฑ์ด ํ•„์š”ํ•œ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์— ์™„๋ฒฝํ•ด!

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {
            "role": "system",
            "content": "๋‹น์‹ ์€ JSON ํ˜•์‹์œผ๋กœ๋งŒ ์‘๋‹ตํ•˜๋Š” ์–ด์‹œ์Šคํ„ดํŠธ์ž…๋‹ˆ๋‹ค."
        },
        {
            "role": "user",
            "content": "ํŒŒ์ด์ฌ์˜ ์ฃผ์š” ํŠน์ง• 3๊ฐ€์ง€๋ฅผ JSON ๋ฐฐ์—ด๋กœ ์•Œ๋ ค์ค˜"
        }
    ],
    response_format={"type": "json_object"}
)

# JSON ํŒŒ์‹ฑ
result = json.loads(response.choices[0].message.content)
print(result)

3. Vision (์ด๋ฏธ์ง€ ๋ถ„์„)

GPT-4o ๋ชจ๋ธ์€ ์ด๋ฏธ์ง€๋ฅผ ๋ถ„์„ํ•  ์ˆ˜ ์žˆ์–ด! ์ด๋ฏธ์ง€๋ฅผ base64๋กœ ์ธ์ฝ”๋”ฉํ•˜๊ฑฐ๋‚˜ URL๋กœ ์ œ๊ณตํ•˜๋ฉด ๋ผ.

import base64

# ์ด๋ฏธ์ง€๋ฅผ base64๋กœ ์ธ์ฝ”๋”ฉ
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

# ์ด๋ฏธ์ง€ ๋ถ„์„
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "์ด ์ด๋ฏธ์ง€์— ๋ฌด์—‡์ด ์žˆ๋‚˜์š”?"
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{encode_image('image.jpg')}"
                    }
                }
            ]
        }
    ]
)

print(response.choices[0].message.content)

์ด๋ฏธ์ง€ ์† ๊ฐ์ฒด ์ธ์‹, OCR, ์ด๋ฏธ์ง€ ์„ค๋ช… ์ƒ์„ฑ ๋“ฑ ๋‹ค์–‘ํ•œ ์šฉ๋„๋กœ ํ™œ์šฉํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿ“ธ

4. Embeddings (์ž„๋ฒ ๋”ฉ)

ํ…์ŠคํŠธ๋ฅผ ๋ฒกํ„ฐ๋กœ ๋ณ€ํ™˜ํ•ด์„œ ์˜๋ฏธ์  ์œ ์‚ฌ๋„๋ฅผ ๊ณ„์‚ฐํ•  ์ˆ˜ ์žˆ์–ด. ๊ฒ€์ƒ‰ ์—”์ง„, ์ถ”์ฒœ ์‹œ์Šคํ…œ, ๋ฌธ์„œ ๋ถ„๋ฅ˜ ๋“ฑ์— ํ™œ์šฉ๋ผ.

def get_embedding(text):
    """ํ…์ŠคํŠธ์˜ ์ž„๋ฒ ๋”ฉ ๋ฒกํ„ฐ ์ƒ์„ฑ"""
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return response.data[0].embedding

# ๋‘ ํ…์ŠคํŠธ์˜ ์œ ์‚ฌ๋„ ๊ณ„์‚ฐ
import numpy as np

text1 = "ํŒŒ์ด์ฌ์€ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด์ž…๋‹ˆ๋‹ค"
text2 = "Python is a programming language"
text3 = "๋‚˜๋Š” ์‚ฌ๊ณผ๋ฅผ ์ข‹์•„ํ•ฉ๋‹ˆ๋‹ค"

embedding1 = get_embedding(text1)
embedding2 = get_embedding(text2)
embedding3 = get_embedding(text3)

# ์ฝ”์‚ฌ์ธ ์œ ์‚ฌ๋„ ๊ณ„์‚ฐ
def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

print(f"text1 vs text2: {cosine_similarity(embedding1, embedding2):.4f}")
print(f"text1 vs text3: {cosine_similarity(embedding1, embedding3):.4f}")

text1๊ณผ text2๋Š” ๊ฐ™์€ ์˜๋ฏธ๋ผ์„œ ์œ ์‚ฌ๋„๊ฐ€ ๋†’๊ฒŒ ๋‚˜์˜ค๊ณ , text3๋Š” ๋‹ค๋ฅธ ์ฃผ์ œ๋ผ์„œ ๋‚ฎ๊ฒŒ ๋‚˜์˜ฌ ๊ฑฐ์•ผ!


๐Ÿ” ์‹ค์ „ ํ™œ์šฉ ์‚ฌ๋ก€

์ด๋ก ์€ ์ถฉ๋ถ„ํžˆ ๋ฐฐ์› ์œผ๋‹ˆ, ์‹ค์ œ๋กœ ์–ด๋–ป๊ฒŒ ํ™œ์šฉ๋˜๋Š”์ง€ ๊ตฌ์ฒด์ ์ธ ์‚ฌ๋ก€๋“ค์„ ์‚ดํŽด๋ณด์ž! ์ด๋Ÿฐ ํ”„๋กœ์ ํŠธ๋“ค์„ ๋งŒ๋“ค๋ฉด์„œ ํฌํŠธํด๋ฆฌ์˜ค๋„ ์Œ“์„ ์ˆ˜ ์žˆ์–ด. ๐Ÿ’ผ

๐Ÿ“ ์ž๋™ ๋ธ”๋กœ๊ทธ ๊ธ€ ์ž‘์„ฑ ๋„๊ตฌ

ํ‚ค์›Œ๋“œ๋งŒ ์ž…๋ ฅํ•˜๋ฉด SEO ์ตœ์ ํ™”๋œ ๋ธ”๋กœ๊ทธ ๊ธ€์„ ์ž๋™์œผ๋กœ ์ƒ์„ฑํ•ด์ฃผ๋Š” ๋„๊ตฌ:

def generate_blog_post(topic, keywords, tone="professional"):
    """๋ธ”๋กœ๊ทธ ๊ธ€ ์ž๋™ ์ƒ์„ฑ"""
    
    system_message = f"""๋‹น์‹ ์€ ์ „๋ฌธ ๋ธ”๋กœ๊ทธ ์ž‘๊ฐ€์ž…๋‹ˆ๋‹ค.
    ๋‹ค์Œ ์กฐ๊ฑด์„ ๋งŒ์กฑํ•˜๋Š” ๊ธ€์„ ์ž‘์„ฑํ•˜์„ธ์š”:
    - ํ†ค: {tone}
    - SEO ์ตœ์ ํ™”๋ฅผ ์œ„ํ•ด ํ‚ค์›Œ๋“œ๋ฅผ ์ž์—ฐ์Šค๋Ÿฝ๊ฒŒ ํฌํ•จ
    - ๊ตฌ์กฐ: ์„œ๋ก , ๋ณธ๋ก (3๊ฐœ ์„น์…˜), ๊ฒฐ๋ก 
    - ๊ฐ ์„น์…˜์— ์†Œ์ œ๋ชฉ ํฌํ•จ
    - ์•ฝ 1000๋‹จ์–ด ๋ถ„๋Ÿ‰
    """
    
    user_message = f"""์ฃผ์ œ: {topic}
    ํ‚ค์›Œ๋“œ: {', '.join(keywords)}
    
    ์œ„ ์ฃผ์ œ๋กœ ๋ธ”๋กœ๊ทธ ๊ธ€์„ ์ž‘์„ฑํ•ด์ฃผ์„ธ์š”."""
    
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": system_message},
            {"role": "user", "content": user_message}
        ],
        temperature=0.7
    )
    
    return response.choices[0].message.content

# ์‚ฌ์šฉ ์˜ˆ์ œ
blog_post = generate_blog_post(
    topic="Python ์›น ์Šคํฌ๋ž˜ํ•‘ ์ž…๋ฌธ",
    keywords=["BeautifulSoup", "requests", "์›น ํฌ๋กค๋ง", "๋ฐ์ดํ„ฐ ์ˆ˜์ง‘"],
    tone="์นœ๊ทผํ•˜๊ณ  ๊ต์œก์ ์ธ"
)
print(blog_post)

๐Ÿ’ฌ ๊ณ ๊ฐ ์ง€์› ์ฑ—๋ด‡

FAQ ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค์™€ ์—ฐ๋™๋œ ๊ณ ๊ฐ ์ง€์› ์ฑ—๋ด‡:

class CustomerSupportBot:
    def __init__(self, faq_data):
        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
        self.faq_data = faq_data
        
        # FAQ๋ฅผ ์‹œ์Šคํ…œ ๋ฉ”์‹œ์ง€์— ํฌํ•จ
        faq_text = "\n".join([
            f"Q: {item['question']}\nA: {item['answer']}"
            for item in faq_data
        ])
        
        self.system_message = f"""๋‹น์‹ ์€ ์นœ์ ˆํ•œ ๊ณ ๊ฐ ์ง€์› ๋‹ด๋‹น์ž์ž…๋‹ˆ๋‹ค.
        ๋‹ค์Œ FAQ ์ •๋ณด๋ฅผ ์ฐธ๊ณ ํ•˜์—ฌ ๋‹ต๋ณ€ํ•˜์„ธ์š”:
        
        {faq_text}
        
        FAQ์— ์—†๋Š” ๋‚ด์šฉ์ด๋ฉด ์ •์ค‘ํ•˜๊ฒŒ ์ƒ๋‹ด์› ์—ฐ๊ฒฐ์„ ์•ˆ๋‚ดํ•˜์„ธ์š”."""
    
    def answer(self, question):
        response = self.client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": self.system_message},
                {"role": "user", "content": question}
            ],
            temperature=0.3  # ์ผ๊ด€๋œ ๋‹ต๋ณ€์„ ์œ„ํ•ด ๋‚ฎ์€ temperature
        )
        return response.choices[0].message.content

# FAQ ๋ฐ์ดํ„ฐ
faq_data = [
    {
        "question": "๋ฐฐ์†ก์€ ์–ผ๋งˆ๋‚˜ ๊ฑธ๋ฆฌ๋‚˜์š”?",
        "answer": "์ผ๋ฐ˜ ๋ฐฐ์†ก์€ 2-3์ผ, ๋น ๋ฅธ ๋ฐฐ์†ก์€ 1์ผ ์†Œ์š”๋ฉ๋‹ˆ๋‹ค."
    },
    {
        "question": "๋ฐ˜ํ’ˆ์€ ์–ด๋–ป๊ฒŒ ํ•˜๋‚˜์š”?",
        "answer": "๊ตฌ๋งค ํ›„ 7์ผ ์ด๋‚ด ๋ฏธ์‚ฌ์šฉ ์ œํ’ˆ์— ํ•œํ•ด ๋ฐ˜ํ’ˆ ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค."
    }
]

bot = CustomerSupportBot(faq_data)
print(bot.answer("๋ฐฐ์†ก ๊ธฐ๊ฐ„์ด ๊ถ๊ธˆํ•ด์š”"))

๐Ÿ“Š ๋ฐ์ดํ„ฐ ๋ถ„์„ ์–ด์‹œ์Šคํ„ดํŠธ

์ž์—ฐ์–ด๋กœ ๋ฐ์ดํ„ฐ ๋ถ„์„ ์š”์ฒญ์„ ๋ฐ›์•„ pandas ์ฝ”๋“œ๋ฅผ ์ƒ์„ฑํ•˜๊ณ  ์‹คํ–‰:

import pandas as pd

class DataAnalysisAssistant:
    def __init__(self, dataframe):
        self.df = dataframe
        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
        
        # ๋ฐ์ดํ„ฐํ”„๋ ˆ์ž„ ์ •๋ณด
        df_info = f"""
        ์ปฌ๋Ÿผ: {list(dataframe.columns)}
        ํ–‰ ์ˆ˜: {len(dataframe)}
        ๋ฐ์ดํ„ฐ ํƒ€์ž…: {dataframe.dtypes.to_dict()}
        """
        
        self.system_message = f"""๋‹น์‹ ์€ ๋ฐ์ดํ„ฐ ๋ถ„์„ ์ „๋ฌธ๊ฐ€์ž…๋‹ˆ๋‹ค.
        ์‚ฌ์šฉ์ž์˜ ์š”์ฒญ์„ pandas ์ฝ”๋“œ๋กœ ๋ณ€ํ™˜ํ•˜์„ธ์š”.
        
        ํ˜„์žฌ ๋ฐ์ดํ„ฐํ”„๋ ˆ์ž„ ์ •๋ณด:
        {df_info}
        
        ์ฝ”๋“œ๋งŒ ์ถœ๋ ฅํ•˜๊ณ , ์„ค๋ช…์€ ์ฃผ์„์œผ๋กœ ์ž‘์„ฑํ•˜์„ธ์š”."""
    
    def analyze(self, request):
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": self.system_message},
                {"role": "user", "content": request}
            ],
            temperature=0.2
        )
        
        code = response.choices[0].message.content
        
        # ์ฝ”๋“œ ์‹คํ–‰ (์ฃผ์˜: ์‹ค์ œ ํ”„๋กœ๋•์…˜์—์„œ๋Š” ๋ณด์•ˆ ๊ฒ€์ฆ ํ•„์š”!)
        try:
            # ์•ˆ์ „ํ•œ ์‹คํ–‰ ํ™˜๊ฒฝ ์ œ๊ณต
            local_vars = {'df': self.df, 'pd': pd}
            exec(code, {}, local_vars)
            return local_vars.get('result', "๊ฒฐ๊ณผ๊ฐ€ ์—†์Šต๋‹ˆ๋‹ค")
        except Exception as e:
            return f"์‹คํ–‰ ์˜ค๋ฅ˜: {e}"

# ์‚ฌ์šฉ ์˜ˆ์ œ
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'salary': [50000, 60000, 70000]
})

assistant = DataAnalysisAssistant(df)
result = assistant.analyze("ํ‰๊ท  ๋‚˜์ด์™€ ๊ธ‰์—ฌ๋ฅผ ๊ณ„์‚ฐํ•ด์ค˜")
print(result)

๐ŸŽจ ์ฐฝ์ž‘ ๋„์šฐ๋ฏธ

์†Œ์„ค, ์‹œ๋‚˜๋ฆฌ์˜ค, ๊ด‘๊ณ  ์นดํ”ผ ๋“ฑ์„ ์ƒ์„ฑํ•˜๋Š” ์ฐฝ์ž‘ ๋„์šฐ๋ฏธ:

class CreativeWriter:
    def __init__(self):
        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    
    def generate_story(self, genre, characters, setting, plot_points):
        """๋‹จํŽธ ์†Œ์„ค ์ƒ์„ฑ"""
        prompt = f"""
        ์žฅ๋ฅด: {genre}
        ๋“ฑ์žฅ์ธ๋ฌผ: {', '.join(characters)}
        ๋ฐฐ๊ฒฝ: {setting}
        ์ฃผ์š” ํ”Œ๋กฏ: {', '.join(plot_points)}
        
        ์œ„ ์š”์†Œ๋“ค์„ ํ™œ์šฉํ•ด ํฅ๋ฏธ์ง„์ง„ํ•œ ๋‹จํŽธ ์†Œ์„ค์„ ์ž‘์„ฑํ•ด์ฃผ์„ธ์š”.
        """
        
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {
                    "role": "system",
                    "content": "๋‹น์‹ ์€ ๋ฒ ์ŠคํŠธ์…€๋Ÿฌ ์ž‘๊ฐ€์ž…๋‹ˆ๋‹ค. ์ƒ์ƒํ•œ ๋ฌ˜์‚ฌ์™€ ํฅ๋ฏธ๋กœ์šด ์ „๊ฐœ๋กœ ๋…์ž๋ฅผ ์‚ฌ๋กœ์žก๋Š” ์ด์•ผ๊ธฐ๋ฅผ ์”๋‹ˆ๋‹ค."
                },
                {"role": "user", "content": prompt}
            ],
            temperature=0.9  # ์ฐฝ์˜์„ฑ์„ ์œ„ํ•ด ๋†’์€ temperature
        )
        
        return response.choices[0].message.content
    
    def generate_ad_copy(self, product, target_audience, key_features):
        """๊ด‘๊ณ  ์นดํ”ผ ์ƒ์„ฑ"""
        prompt = f"""
        ์ œํ’ˆ: {product}
        ํƒ€๊ฒŸ: {target_audience}
        ์ฃผ์š” ํŠน์ง•: {', '.join(key_features)}
        
        ๋งค๋ ฅ์ ์ธ ๊ด‘๊ณ  ์นดํ”ผ๋ฅผ 3๊ฐ€์ง€ ๋ฒ„์ „์œผ๋กœ ์ž‘์„ฑํ•ด์ฃผ์„ธ์š”.
        ๊ฐ ๋ฒ„์ „์€ ๋‹ค๋ฅธ ํ†ค์œผ๋กœ ์ž‘์„ฑํ•˜์„ธ์š”.
        """
        
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {
                    "role": "system",
                    "content": "๋‹น์‹ ์€ ํฌ๋ฆฌ์—์ดํ‹ฐ๋ธŒ ๋””๋ ‰ํ„ฐ์ž…๋‹ˆ๋‹ค. ๊ฐ„๊ฒฐํ•˜๊ณ  ์ž„ํŒฉํŠธ ์žˆ๋Š” ์นดํ”ผ๋ฅผ ์ž‘์„ฑํ•ฉ๋‹ˆ๋‹ค."
                },
                {"role": "user", "content": prompt}
            ],
            temperature=0.8
        )
        
        return response.choices[0].message.content

# ์‚ฌ์šฉ ์˜ˆ์ œ
writer = CreativeWriter()

# ์†Œ์„ค ์ƒ์„ฑ
story = writer.generate_story(
    genre="SF ์Šค๋ฆด๋Ÿฌ",
    characters=["AI ์—ฐ๊ตฌ์› ์ง€์ˆ˜", "์˜๋ฌธ์˜ ํ•ด์ปค"],
    setting="2045๋…„ ์„œ์šธ",
    plot_points=["AI ๋ฐ˜๋ž€", "์ˆจ๊ฒจ์ง„ ์ง„์‹ค", "์˜ˆ์ƒ์น˜ ๋ชปํ•œ ๋ฐ˜์ „"]
)
print(story)

๐ŸŽฏ ์žฌ๋Šฅ๋„ท์—์„œ AI ๊ฐœ๋ฐœ ์žฌ๋Šฅ ๊ณต์œ ํ•˜๊ธฐ

์ด์ œ ChatGPT API๋ฅผ ์ž์œ ์ž์žฌ๋กœ ๋‹ค๋ฃฐ ์ˆ˜ ์žˆ๊ฒŒ ๋์–ด! ์ด๋Ÿฐ ๊ธฐ์ˆ ์„ ๊ฐ€์ง€๊ณ  ์žˆ๋‹ค๋ฉด ์žฌ๋Šฅ๋„ท์—์„œ ๋‹ค๋ฅธ ์‚ฌ๋žŒ๋“ค๊ณผ ์žฌ๋Šฅ์„ ๊ณต์œ ํ•ด๋ณด๋Š” ๊ฑด ์–ด๋•Œ? ๐ŸŒŸ

์žฌ๋Šฅ๋„ท์€ ๋‹ค์–‘ํ•œ ์žฌ๋Šฅ์„ ๊ฑฐ๋ž˜ํ•˜๋Š” ํ”Œ๋žซํผ์ด์•ผ. AI ๊ฐœ๋ฐœ ๋ถ„์•ผ์—์„œ ์ด๋Ÿฐ ์„œ๋น„์Šค๋“ค์„ ์ œ๊ณตํ•  ์ˆ˜ ์žˆ์–ด:

โ€ข ChatGPT API ์—ฐ๋™ ๊ฐœ๋ฐœ ๋Œ€ํ–‰
โ€ข ๋งž์ถคํ˜• ์ฑ—๋ด‡ ์ œ์ž‘
โ€ข AI ๊ธฐ๋ฐ˜ ์ž๋™ํ™” ๋„๊ตฌ ๊ฐœ๋ฐœ
โ€ข Python + AI ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๊ณผ์™ธ
โ€ข ๋ฐ์ดํ„ฐ ๋ถ„์„ ์ž๋™ํ™” ์†”๋ฃจ์…˜

ํŠนํžˆ ์š”์ฆ˜์€ AI ๊ธฐ์ˆ ์— ๋Œ€ํ•œ ์ˆ˜์š”๊ฐ€ ํญ๋ฐœ์ ์œผ๋กœ ์ฆ๊ฐ€ํ•˜๊ณ  ์žˆ์–ด์„œ, ์ด๋Ÿฐ ์žฌ๋Šฅ์„ ๊ฐ€์ง„ ์‚ฌ๋žŒ๋“ค์ด ์ •๋ง ๋งŽ์ด ํ•„์š”ํ•ด. ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์„ ํ†ตํ•ด ์ž์‹ ์˜ ๊ธฐ์ˆ ์„ ์ˆ˜์ตํ™”ํ•˜๊ณ , ๋™์‹œ์— ๋‹ค๋ฅธ ์‚ฌ๋žŒ๋“ค์—๊ฒŒ ๋„์›€์„ ์ค„ ์ˆ˜ ์žˆ์ง€! ๐Ÿ’ช

์‹ค์ œ๋กœ ๋งŽ์€ ๊ฐœ๋ฐœ์ž๋“ค์ด ์‚ฌ์ด๋“œ ํ”„๋กœ์ ํŠธ๋กœ AI ๊ด€๋ จ ์„œ๋น„์Šค๋ฅผ ์ œ๊ณตํ•˜๋ฉด์„œ ์ข‹์€ ์ˆ˜์ž…์„ ์˜ฌ๋ฆฌ๊ณ  ์žˆ์–ด. ๋„ˆ๋„ ์ด ๊ธ€์—์„œ ๋ฐฐ์šด ๋‚ด์šฉ์„ ๋ฐ”ํƒ•์œผ๋กœ ์ž์‹ ๋งŒ์˜ ์„œ๋น„์Šค๋ฅผ ๋งŒ๋“ค์–ด๋ณด๋Š” ๊ฑด ์–ด๋–จ๊นŒ?


โš ๏ธ ์ฃผ์˜์‚ฌํ•ญ๊ณผ ๋ฒ ์ŠคํŠธ ํ”„๋ž™ํ‹ฐ์Šค

๋งˆ์ง€๋ง‰์œผ๋กœ ChatGPT API๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ ๊ผญ ์•Œ์•„์•ผ ํ•  ์ฃผ์˜์‚ฌํ•ญ๋“ค์„ ์ •๋ฆฌํ•ด๋ณผ๊ฒŒ. ์ด๊ฑธ ์ง€ํ‚ค๋ฉด ์•ˆ์ „ํ•˜๊ณ  ํšจ์œจ์ ์œผ๋กœ API๋ฅผ ํ™œ์šฉํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿ›ก๏ธ

๐Ÿ”’ ๋ณด์•ˆ

1. API ํ‚ค ๊ด€๋ฆฌ
โ€ข ์ ˆ๋Œ€ ์ฝ”๋“œ์— ์ง์ ‘ ํ•˜๋“œ์ฝ”๋”ฉํ•˜์ง€ ๋ง ๊ฒƒ
โ€ข ํ™˜๊ฒฝ๋ณ€์ˆ˜๋‚˜ ๋น„๋ฐ€ ๊ด€๋ฆฌ ๋„๊ตฌ ์‚ฌ์šฉ
โ€ข GitHub ๋“ฑ์— ์‹ค์ˆ˜๋กœ ์˜ฌ๋ฆฌ์ง€ ์•Š๋„๋ก .gitignore ์„ค์ •
โ€ข ์ •๊ธฐ์ ์œผ๋กœ ํ‚ค๋ฅผ ๊ฐฑ์‹ 

2. ์‚ฌ์šฉ์ž ์ž…๋ ฅ ๊ฒ€์ฆ
โ€ข ์•…์˜์ ์ธ ํ”„๋กฌํ”„ํŠธ ์ธ์ ์…˜ ๋ฐฉ์ง€
โ€ข ์ž…๋ ฅ ๊ธธ์ด ์ œํ•œ
โ€ข ๋ฏผ๊ฐํ•œ ์ •๋ณด ํ•„ํ„ฐ๋ง

3. Rate Limiting
โ€ข ๊ณผ๋„ํ•œ API ํ˜ธ์ถœ ๋ฐฉ์ง€
โ€ข ์‚ฌ์šฉ์ž๋ณ„ ์š”์ฒญ ์ œํ•œ ์„ค์ •
โ€ข ๋น„์šฉ ํญํƒ„ ๋ฐฉ์ง€

๐Ÿ’ก ์„ฑ๋Šฅ ์ตœ์ ํ™”

1. ์ ์ ˆํ•œ ๋ชจ๋ธ ์„ ํƒ
โ€ข ์ž‘์—…์— ๋งž๋Š” ์ตœ์†Œ ์‚ฌ์–‘ ๋ชจ๋ธ ์‚ฌ์šฉ
โ€ข ๊ฐ„๋‹จํ•œ ์ž‘์—…์— GPT-4 ์‚ฌ์šฉ ์ž์ œ

2. ํ”„๋กฌํ”„ํŠธ ์ตœ์ ํ™”
โ€ข ๋ช…ํ™•ํ•˜๊ณ  ๊ตฌ์ฒด์ ์ธ ์ง€์‹œ
โ€ข ๋ถˆํ•„์š”ํ•œ ์ปจํ…์ŠคํŠธ ์ œ๊ฑฐ
โ€ข ์˜ˆ์ œ ํฌํ•จ์œผ๋กœ ์ •ํ™•๋„ ํ–ฅ์ƒ

3. ์บ์‹ฑ ํ™œ์šฉ
โ€ข ๋ฐ˜๋ณต๋˜๋Š” ์š”์ฒญ์€ ์บ์‹ฑ
โ€ข ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค๋‚˜ Redis ํ™œ์šฉ

4. ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ
โ€ข ์—ฌ๋Ÿฌ ์š”์ฒญ์„ ๋ฌถ์–ด์„œ ์ฒ˜๋ฆฌ
โ€ข ๋น„๋™๊ธฐ ์ฒ˜๋ฆฌ๋กœ ์„ฑ๋Šฅ ํ–ฅ์ƒ

๐Ÿ“Š ๋ชจ๋‹ˆํ„ฐ๋ง

1. ์‚ฌ์šฉ๋Ÿ‰ ์ถ”์ 
โ€ข ํ† ํฐ ์‚ฌ์šฉ๋Ÿ‰ ๋กœ๊น…
โ€ข ๋น„์šฉ ๋ชจ๋‹ˆํ„ฐ๋ง
โ€ข ์•Œ๋ฆผ ์„ค์ • (์˜ˆ์‚ฐ ์ดˆ๊ณผ ์‹œ)

2. ์—๋Ÿฌ ๋กœ๊น…
โ€ข ๋ชจ๋“  API ์—๋Ÿฌ ๊ธฐ๋ก
โ€ข ์—๋Ÿฌ ํŒจํ„ด ๋ถ„์„
โ€ข ์ž๋™ ์•Œ๋ฆผ ์‹œ์Šคํ…œ

3. ์„ฑ๋Šฅ ๋ฉ”ํŠธ๋ฆญ
โ€ข ์‘๋‹ต ์‹œ๊ฐ„ ์ธก์ •
โ€ข ์„ฑ๊ณต๋ฅ  ์ถ”์ 
โ€ข ์‚ฌ์šฉ์ž ๋งŒ์กฑ๋„ ์ˆ˜์ง‘

๐ŸŽฏ ์‚ฌ์šฉ์ž ๊ฒฝํ—˜

1. ์‘๋‹ต ์‹œ๊ฐ„ ๊ด€๋ฆฌ
โ€ข ์ŠคํŠธ๋ฆฌ๋ฐ์œผ๋กœ ์ฆ‰๊ฐ์ ์ธ ํ”ผ๋“œ๋ฐฑ
โ€ข ๋กœ๋”ฉ ์ธ๋””์ผ€์ดํ„ฐ ํ‘œ์‹œ
โ€ข ํƒ€์ž„์•„์›ƒ ์„ค์ •

2. ์—๋Ÿฌ ์ฒ˜๋ฆฌ
โ€ข ์‚ฌ์šฉ์ž ์นœํ™”์ ์ธ ์—๋Ÿฌ ๋ฉ”์‹œ์ง€
โ€ข ์žฌ์‹œ๋„ ์˜ต์…˜ ์ œ๊ณต
โ€ข ๋Œ€์ฒด ๋ฐฉ์•ˆ ์•ˆ๋‚ด

3. ํˆฌ๋ช…์„ฑ
โ€ข AI ์‚ฌ์šฉ ์‚ฌ์‹ค ๋ช…์‹œ
โ€ข ํ•œ๊ณ„์  ์„ค๋ช…
โ€ข ํ”ผ๋“œ๋ฐฑ ์ˆ˜์ง‘ ๋ฉ”์ปค๋‹ˆ์ฆ˜

โš ๏ธ ๋ฒ•์ /์œค๋ฆฌ์  ๊ณ ๋ ค์‚ฌํ•ญ: โ€ข OpenAI ์‚ฌ์šฉ ์ •์ฑ… ์ค€์ˆ˜
โ€ข ๊ฐœ์ธ์ •๋ณด ๋ณดํ˜ธ๋ฒ• ์ค€์ˆ˜
โ€ข ์ €์ž‘๊ถŒ ๋ฌธ์ œ ์ฃผ์˜
โ€ข AI ์ƒ์„ฑ ์ฝ˜ํ…์ธ  ๋ช…์‹œ
โ€ข ํŽธํ–ฅ์„ฑ๊ณผ ๊ณต์ •์„ฑ ๊ณ ๋ ค
โ€ข ์•…์šฉ ๋ฐฉ์ง€ ์กฐ์น˜

๐ŸŽ“ ๋” ๋ฐฐ์šฐ๊ณ  ์‹ถ๋‹ค๋ฉด

์ด ๊ธ€์—์„œ ChatGPT API์˜ ๊ธฐ์ดˆ๋ถ€ํ„ฐ ์‹ค์ „ ํ™œ์šฉ๊นŒ์ง€ ๋‹ค๋ค˜์ง€๋งŒ, AI ๋ถ„์•ผ๋Š” ์ •๋ง ๋น ๋ฅด๊ฒŒ ๋ฐœ์ „ํ•˜๊ณ  ์žˆ์–ด. ๊ณ„์† ํ•™์Šตํ•˜๊ณ  ์‹คํ—˜ํ•˜๋Š” ๊ฒŒ ์ค‘์š”ํ•ด! ๐Ÿ“š

๐Ÿ“– ์ถ”์ฒœ ํ•™์Šต ์ž๋ฃŒ

๊ณต์‹ ๋ฌธ์„œ:
โ€ข OpenAI API Documentation
โ€ข OpenAI Cookbook (์‹ค์ „ ์˜ˆ์ œ ๋ชจ์Œ)
โ€ข OpenAI Community Forum

์ถ”๊ฐ€ ํ•™์Šต ์ฃผ์ œ:
โ€ข LangChain: AI ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜ ํ”„๋ ˆ์ž„์›Œํฌ
โ€ข Vector Databases: ์ž„๋ฒ ๋”ฉ ์ €์žฅ ๋ฐ ๊ฒ€์ƒ‰
โ€ข Prompt Engineering: ํšจ๊ณผ์ ์ธ ํ”„๋กฌํ”„ํŠธ ์ž‘์„ฑ๋ฒ•
โ€ข Fine-tuning: ๋ชจ๋ธ ์ปค์Šคํ„ฐ๋งˆ์ด์ง•
โ€ข RAG (Retrieval-Augmented Generation): ๋ฌธ์„œ ๊ธฐ๋ฐ˜ QA ์‹œ์Šคํ…œ

์‹ค์Šต ํ”„๋กœ์ ํŠธ ์•„์ด๋””์–ด:
โ€ข ๊ฐœ์ธ ๋น„์„œ ์ฑ—๋ด‡
โ€ข ๋ฌธ์„œ ์š”์•ฝ ๋„๊ตฌ
โ€ข ์ฝ”๋“œ ๋ฆฌ๋ทฐ ์ž๋™ํ™”
โ€ข ์–ธ์–ด ํ•™์Šต ์•ฑ
โ€ข ๊ฐ์ • ๋ถ„์„ ๋„๊ตฌ
โ€ข ์ž๋™ ์ด๋ฉ”์ผ ์ž‘์„ฑ๊ธฐ

๐Ÿ’ก ํ•™์Šต ํŒ: โ€ข ์ž‘์€ ํ”„๋กœ์ ํŠธ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•˜์ž
โ€ข ์‹ค์ œ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๋Š” ๋ฐ ์ง‘์ค‘
โ€ข ์ปค๋ฎค๋‹ˆํ‹ฐ์— ์ฐธ์—ฌํ•ด์„œ ๊ฒฝํ—˜ ๊ณต์œ 
โ€ข ์ตœ์‹  ์—…๋ฐ์ดํŠธ ๊ณ„์† ํ™•์ธ
โ€ข ๋‹ค์–‘ํ•œ ํŒŒ๋ผ๋ฏธํ„ฐ๋กœ ์‹คํ—˜ํ•ด๋ณด๊ธฐ
โ€ข ์—๋Ÿฌ๋ฅผ ๋‘๋ ค์›Œํ•˜์ง€ ๋ง๊ณ  ๋””๋ฒ„๊น… ์—ฐ์Šต

๐ŸŽ‰ ๋งˆ๋ฌด๋ฆฌํ•˜๋ฉฐ

์™€! ์—ฌ๊ธฐ๊นŒ์ง€ ์ฝ์—ˆ๋‹ค๋ฉด ์ •๋ง ๋Œ€๋‹จํ•ด! ๐ŸŽŠ

์šฐ๋ฆฌ๋Š” ChatGPT API์˜ ๊ธฐ์ดˆ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด์„œ ์‹ค์ „ ํ”„๋กœ์ ํŠธ๊นŒ์ง€ ์ •๋ง ๋งŽ์€ ๋‚ด์šฉ์„ ๋‹ค๋ค˜์–ด. API ํ‚ค ๋ฐœ๊ธ‰๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด์„œ, ๊ธฐ๋ณธ์ ์ธ ์ฑ„ํŒ…, ๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ ๊ด€๋ฆฌ, ์ŠคํŠธ๋ฆฌ๋ฐ, ์—๋Ÿฌ ์ฒ˜๋ฆฌ, ๋น„์šฉ ์ตœ์ ํ™”, ์›น ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜ ํ†ตํ•ฉ, ๊ทธ๋ฆฌ๊ณ  ๊ณ ๊ธ‰ ๊ธฐ๋Šฅ๋“ค๊นŒ์ง€ ๋ง์ด์•ผ.

์ด์ œ ๋„ˆ๋Š” Python์œผ๋กœ ChatGPT API๋ฅผ ์ž์œ ์ž์žฌ๋กœ ๋‹ค๋ฃฐ ์ˆ˜ ์žˆ๋Š” ๋Šฅ๋ ฅ์„ ๊ฐ–์ท„์–ด! ์ด ๊ธฐ์ˆ ์€ ์ •๋ง ๊ฐ•๋ ฅํ•˜๊ณ , ์•ž์œผ๋กœ ๋”์šฑ ์ค‘์š”ํ•ด์งˆ ๊ฑฐ์•ผ. AI๋Š” ์ด์ œ ์„ ํƒ์ด ์•„๋‹ˆ๋ผ ํ•„์ˆ˜๊ฐ€ ๋˜์–ด๊ฐ€๊ณ  ์žˆ๊ฑฐ๋“ . ๐Ÿš€

๊ฐ€์žฅ ์ค‘์š”ํ•œ ๊ฑด ์ง์ ‘ ํ•ด๋ณด๋Š” ๊ฑฐ์•ผ! ์ด ๊ธ€์„ ์ฝ๋Š” ๊ฒƒ๋งŒ์œผ๋กœ๋Š” ๋ถ€์กฑํ•ด. ์‹ค์ œ๋กœ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•˜๊ณ , ์—๋Ÿฌ๋ฅผ ๋งŒ๋‚˜๊ณ , ํ•ด๊ฒฐํ•˜๋ฉด์„œ ์ง„์งœ ์‹ค๋ ฅ์ด ๋Š˜์–ด๋‚˜๋Š” ๊ฑฐ์ง€. ์ž‘์€ ํ”„๋กœ์ ํŠธ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด์„œ ์ ์  ๋ณต์žกํ•œ ๊ฑธ ๋งŒ๋“ค์–ด๋ด.

๊ทธ๋ฆฌ๊ณ  ํ˜น์‹œ AI ๊ฐœ๋ฐœ ๊ด€๋ จํ•ด์„œ ๋„์›€์ด ํ•„์š”ํ•˜๊ฑฐ๋‚˜, ์ž์‹ ์˜ ์žฌ๋Šฅ์„ ๊ณต์œ ํ•˜๊ณ  ์‹ถ๋‹ค๋ฉด ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์„ ํ™œ์šฉํ•ด๋ณด๋Š” ๊ฒƒ๋„ ์ข‹์€ ๋ฐฉ๋ฒ•์ด์•ผ. ๋ฐฐ์šฐ๋ฉด์„œ ๋™์‹œ์— ์ˆ˜์ต๋„ ์ฐฝ์ถœํ•  ์ˆ˜ ์žˆ์œผ๋‹ˆ๊นŒ!

AI ๊ธฐ์ˆ ์€ ๊ณ„์† ๋ฐœ์ „ํ•˜๊ณ  ์žˆ์–ด. ์˜ค๋Š˜ ๋ฐฐ์šด ๋‚ด์šฉ์ด ๋‚ด์ผ์ด๋ฉด ๋˜ ์—…๋ฐ์ดํŠธ๋  ์ˆ˜๋„ ์žˆ์ง€. ๊ทธ๋Ÿฌ๋‹ˆ๊นŒ ๊ณ„์† ํ•™์Šตํ•˜๊ณ , ์‹คํ—˜ํ•˜๊ณ , ์ปค๋ฎค๋‹ˆํ‹ฐ์™€ ์†Œํ†ตํ•˜๋ฉด์„œ ์„ฑ์žฅํ•ด๋‚˜๊ฐ€์ž! ๐Ÿ’ช

์งˆ๋ฌธ์ด๋‚˜ ๋ง‰ํžˆ๋Š” ๋ถ€๋ถ„์ด ์žˆ์œผ๋ฉด OpenAI ๊ณต์‹ ๋ฌธ์„œ๋ฅผ ์ฐธ๊ณ ํ•˜๊ฑฐ๋‚˜, ๊ฐœ๋ฐœ์ž ์ปค๋ฎค๋‹ˆํ‹ฐ์— ๋ฌผ์–ด๋ณด๋Š” ๊ฒƒ๋„ ์ข‹์•„. ํ˜ผ์ž ๊ณ ๋ฏผํ•˜์ง€ ๋ง๊ณ  ์ ๊ทน์ ์œผ๋กœ ๋„์›€์„ ๊ตฌํ•˜์ž!

์ž, ์ด์ œ ์ปดํ“จํ„ฐ ์•ž์— ์•‰์•„์„œ ์ง์ ‘ ์ฝ”๋”ฉ์„ ์‹œ์ž‘ํ•ด๋ณผ ์‹œ๊ฐ„์ด์•ผ! ๋„ˆ๋งŒ์˜ ๋ฉ‹์ง„ AI ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์„ ๋งŒ๋“ค์–ด๋ด. ํ™”์ดํŒ…! ๐Ÿ”ฅโœจ

๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.