OpenAI API 총정리

# Python SDK 설치
pip install openai

# Node.js SDK 설치
npm install openai

# Linux / Mac
export OPENAI_API_KEY="sk-proj-여러분의키..."

# Windows (PowerShell)
$env:OPENAI_API_KEY = "sk-proj-여러분의키..."

# .env 파일에 저장 (권장)
echo 'OPENAI_API_KEY=sk-proj-여러분의키...' >> .env

from openai import OpenAI

client = OpenAI()  # 환경 변수에서 자동으로 API 키를 읽음

response = client.responses.create(
    model="gpt-4.1",
    input="안녕하세요! OpenAI API를 처음 사용합니다."
)

print(response.output_text)

response = client.responses.create(
    model="gpt-5.4",
    reasoning={"effort": "high"},  # 복잡한 작업에 적합
    input="다음 코드의 버그를 찾아서 수정해 주세요: ..."
)

from openai import OpenAI
client = OpenAI()

response = client.responses.create(
    model="gpt-4.1",
    input="대한민국의 수도는 어디인가요?"
)

print(response.output_text)
# → "대한민국의 수도는 서울특별시입니다."

response = client.responses.create(
    model="gpt-4.1",
    instructions="당신은 친절한 한국어 요리 전문가입니다. "
                 "모든 답변은 존댓말로, 300자 이내로 작성하세요.",
    input="김치찌개 만드는 법을 알려주세요."
)

print(response.output_text)

# 첫 번째 대화
resp1 = client.responses.create(
    model="gpt-4.1",
    input="파이썬에서 리스트와 튜플의 차이가 뭐야?"
)
print(resp1.output_text)

# 두 번째 대화 — 이전 맥락을 이어감
resp2 = client.responses.create(
    model="gpt-4.1",
    previous_response_id=resp1.id,
    input="그럼 언제 튜플을 써야 해?"
)
print(resp2.output_text)  # 이전 대화 맥락을 기억하고 답변

response = client.responses.create(
    model="gpt-4.1",
    input=[
        {"role": "user", "content": "서울에서 부산까지 거리가 얼마야?"},
        {"role": "assistant", "content": "서울에서 부산까지는 약 325km입니다."},
        {"role": "user", "content": "KTX로 얼마나 걸려?"}
    ]
)
print(response.output_text)

from openai import OpenAI
client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {
            "role": "system",
            "content": "당신은 도움이 되는 한국어 어시스턴트입니다."
        },
        {
            "role": "user",
            "content": "JWT 토큰이 뭔지 쉽게 설명해 줘."
        }
    ],
    temperature=0.7,
    max_tokens=500
)

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

# tiktoken 라이브러리로 토큰 수 계산
import tiktoken

enc = tiktoken.encoding_for_model("gpt-4.1")
text = "안녕하세요, OpenAI API를 배우고 있습니다!"
tokens = enc.encode(text)

print(f"텍스트: {text}")
print(f"토큰 수: {len(tokens)}")
print(f"토큰 목록: {tokens}")

response = client.responses.create(
    model="gpt-4.1",
    input="파이썬 데코레이터를 설명해 주세요."
)

# 토큰 사용량 확인
print(f"입력 토큰: {response.usage.input_tokens}")
print(f"출력 토큰: {response.usage.output_tokens}")
print(f"전체 토큰: {response.usage.total_tokens}")

from openai import OpenAI
import json

client = OpenAI()

# 1단계: 도구 정의
tools = [
    {
        "type": "function",
        "name": "get_weather",
        "description": "주어진 도시의 현재 날씨를 가져옵니다.",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "도시 이름 (예: Seoul, Tokyo)"
                },
                "units": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "온도 단위"
                }
            },
            "required": ["city", "units"],
            "additionalProperties": False
        },
        "strict": True
    }
]

# 실제 함수 구현 (보통은 외부 API 호출)
def get_weather(city, units="celsius"):
    # 여기서는 예시를 위해 하드코딩
    return json.dumps({
        "city": city,
        "temperature": 22,
        "units": units,
        "condition": "맑음"
    })

# 2단계: 모델에 프롬프트 + 도구 전달
input_list = [
    {"role": "user", "content": "서울 날씨가 어때?"}
]

response = client.responses.create(
    model="gpt-4.1",
    tools=tools,
    input=input_list,
)

# 3단계: 모델의 도구 호출 처리
input_list += response.output

for item in response.output:
    if item.type == "function_call":
        args = json.loads(item.arguments)
        result = get_weather(**args)
        
        # 4단계: 함수 결과를 모델에 반환
        input_list.append({
            "type": "function_call_output",
            "call_id": item.call_id,
            "output": result
        })

# 5단계: 최종 응답 받기
final = client.responses.create(
    model="gpt-4.1",
    tools=tools,
    input=input_list,
)

print(final.output_text)
# → "서울의 현재 날씨는 맑음이며, 기온은 22°C입니다."

response = client.responses.create(
    model="gpt-4.1",
    input="대한민국의 주요 도시 3개를 알려주세요.",
    text={
        "format": {
            "type": "json_schema",
            "name": "cities_response",
            "schema": {
                "type": "object",
                "properties": {
                    "cities": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {"type": "string"},
                                "population": {"type": "integer"},
                                "description": {"type": "string"}
                            },
                            "required": ["name", "population", "description"],
                            "additionalProperties": False
                        }
                    }
                },
                "required": ["cities"],
                "additionalProperties": False
            },
            "strict": True
        }
    }
)

import json
data = json.loads(response.output_text)
for city in data["cities"]:
    print(f"{city['name']} (인구: {city['population']:,}명)")

from pydantic import BaseModel

class City(BaseModel):
    name: str
    population: int
    description: str

class CitiesResponse(BaseModel):
    cities: list[City]

response = client.responses.parse(
    model="gpt-4.1",
    input="대한민국의 주요 도시 3개를 알려주세요.",
    text_format=CitiesResponse,
)

# response.output_parsed는 CitiesResponse 객체
for city in response.output_parsed.cities:
    print(f"{city.name}: {city.description}")

# URL로 이미지 전달
response = client.responses.create(
    model="gpt-4.1",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "이 이미지에 무엇이 보이나요?"},
                {
                    "type": "input_image",
                    "image_url": "https://example.com/photo.jpg"
                }
            ]
        }
    ]
)
print(response.output_text)

result = client.images.generate(
    model="gpt-image-2",
    prompt="파란 하늘 아래 벚꽃이 만개한 한국의 전통 한옥 마을",
    n=1,
    size="1024x1024"
)

# 생성된 이미지 URL 또는 base64 데이터 접근
print(result.data[0].url)

stream = client.responses.create(
    model="gpt-4.1",
    input="파이썬의 GIL에 대해 설명해 주세요.",
    stream=True
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

print()  # 줄바꿈

stream = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "REST API란?"}],
    stream=True
)

for chunk in stream:
    content = chunk.choices[0].delta.content
    if content:
        print(content, end="", flush=True)

response = client.responses.create(
    model="gpt-5.4",
    tools=[{"type": "web_search"}],
    input="오늘 주요 뉴스를 요약해 주세요."
)

print(response.output_text)
# → 웹 검색 결과를 기반으로 최신 뉴스 요약을 생성

response = client.responses.create(
    model="gpt-5.4",
    tools=[{
        "type": "code_interpreter",
        "container": {"type": "auto"}
    }],
    input="1부터 100까지의 피보나치 수열에서 짝수인 것만 합산해 주세요."
)

print(response.output_text)
# → 모델이 Python 코드를 작성·실행하여 정확한 결과를 반환

response = client.embeddings.create(
    model="text-embedding-3-small",
    input="OpenAI API는 강력한 AI 기능을 제공합니다."
)

vector = response.data[0].embedding
print(f"벡터 차원: {len(vector)}")
print(f"처음 5개 값: {vector[:5]}")

import numpy as np

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# 문서 임베딩
docs = [
    "파이썬은 배우기 쉬운 프로그래밍 언어입니다.",
    "김치찌개는 한국의 대표적인 음식입니다.",
    "자바스크립트는 웹 개발에 필수적입니다.",
    "된장찌개는 한국인의 소울 푸드입니다."
]

doc_embeddings = client.embeddings.create(
    model="text-embedding-3-small",
    input=docs
).data

# 검색 쿼리 임베딩
query = "한국 전통 음식"
query_emb = client.embeddings.create(
    model="text-embedding-3-small",
    input=query
).data[0].embedding

# 유사도 계산 및 정렬
results = []
for i, doc_emb in enumerate(doc_embeddings):
    sim = cosine_similarity(query_emb, doc_emb.embedding)
    results.append((sim, docs[i]))

results.sort(reverse=True)
for sim, doc in results:
    print(f"[{sim:.4f}] {doc}")

from tenacity import retry, wait_random_exponential, stop_after_attempt

@retry(
    wait=wait_random_exponential(min=1, max=60),
    stop=stop_after_attempt(6)
)
def call_api(prompt):
    return client.responses.create(
        model="gpt-4.1",
        input=prompt
    )

response = call_api("안녕하세요?")

from agents import Agent, Runner, function_tool

@function_tool
def search_database(query: str) -> str:
    """데이터베이스에서 정보를 검색합니다."""
    # 실제 DB 쿼리 로직
    return f"'{query}'에 대한 검색 결과: ..."

@function_tool
def send_email(to: str, subject: str, body: str) -> str:
    """이메일을 발송합니다."""
    return f"{to}에게 이메일을 발송했습니다."

# 에이전트 정의
agent = Agent(
    name="비즈니스 어시스턴트",
    instructions="당신은 비즈니스 업무를 돕는 어시스턴트입니다. "
                 "필요한 정보는 DB에서 검색하고, "
                 "보고가 필요하면 이메일로 발송하세요.",
    tools=[search_database, send_email],
    model="gpt-5.4"
)

# 에이전트 실행
result = Runner.run_sync(
    agent,
    "이번 달 매출 현황을 조회해서 manager@company.com에 보고해 줘."
)
print(result.final_output)

from pydantic import BaseModel

class DocumentSummary(BaseModel):
    title: str
    summary: str
    keywords: list[str]
    key_points: list[str]

def summarize_document(text: str) -> DocumentSummary:
    response = client.responses.parse(
        model="gpt-4.1",
        instructions="주어진 문서를 분석하여 한국어로 요약하세요. "
                     "핵심 포인트는 3~5개로 정리하세요.",
        input=text,
        text_format=DocumentSummary,
    )
    return response.output_parsed

# 사용 예시
long_text = """여기에 긴 문서 내용을 넣습니다..."""
result = summarize_document(long_text)
print(f"제목: {result.title}")
print(f"요약: {result.summary}")
print(f"키워드: {', '.join(result.keywords)}")
for point in result.key_points:
    print(f"  • {point}")

import json

# 도구 정의
tools = [
    {
        "type": "function",
        "name": "check_order_status",
        "description": "주문번호로 배송 상태를 조회합니다.",
        "parameters": {
            "type": "object",
            "properties": {
                "order_id": {
                    "type": "string",
                    "description": "주문번호 (예: ORD-12345)"
                }
            },
            "required": ["order_id"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "request_refund",
        "description": "환불을 요청합니다.",
        "parameters": {
            "type": "object",
            "properties": {
                "order_id": {"type": "string"},
                "reason": {"type": "string"}
            },
            "required": ["order_id", "reason"],
            "additionalProperties": False
        },
        "strict": True
    }
]

# 함수 구현 (실제로는 DB/API 호출)
def check_order_status(order_id):
    return json.dumps({
        "order_id": order_id,
        "status": "배송중",
        "carrier": "CJ대한통운",
        "estimated_delivery": "2026-05-01"
    })

def request_refund(order_id, reason):
    return json.dumps({
        "success": True,
        "refund_id": "REF-99887",
        "message": "환불 요청이 접수되었습니다. 3영업일 내 처리됩니다."
    })

system_prompt = """당신은 '해피몰'의 고객 상담 AI입니다.
- 항상 친절하고 정중하게 응대하세요.
- 주문 조회, 환불 요청 등 도구를 활용하세요.
- 해결할 수 없는 문제는 상담원 연결을 안내하세요."""

# 대화 루프
prev_id = None
while True:
    user_input = input("\n고객: ")
    if user_input.lower() in ['quit', '종료']:
        break
    
    kwargs = {
        "model": "gpt-4.1",
        "instructions": system_prompt,
        "tools": tools,
        "input": user_input,
    }
    if prev_id:
        kwargs["previous_response_id"] = prev_id
    
    response = client.responses.create(**kwargs)
    
    # Function Call 처리
    needs_followup = False
    for item in response.output:
        if item.type == "function_call":
            needs_followup = True
            args = json.loads(item.arguments)
            
            if item.name == "check_order_status":
                result = check_order_status(**args)
            elif item.name == "request_refund":
                result = request_refund(**args)
            else:
                result = json.dumps({"error": "Unknown function"})
            
            # 도구 결과를 돌려보내기
            response = client.responses.create(
                model="gpt-4.1",
                instructions=system_prompt,
                tools=tools,
                previous_response_id=response.id,
                input=[{
                    "type": "function_call_output",
                    "call_id": item.call_id,
                    "output": result
                }]
            )
    
    prev_id = response.id
    print(f"\n상담AI: {response.output_text}")

response = client.responses.create(
    model="gpt-5.4",
    instructions="당신은 리서치 어시스턴트입니다. "
                 "웹 검색을 통해 최신 정보를 수집하고 "
                 "출처와 함께 한국어로 보고서를 작성하세요.",
    tools=[{"type": "web_search"}],
    input="2026년 AI 산업의 주요 트렌드를 조사해 주세요."
)

print(response.output_text)

# =============================================
# OpenAI API 치트시트 — 핵심 패턴 정리
# =============================================
from openai import OpenAI
client = OpenAI()  # OPENAI_API_KEY 환경 변수 자동 사용

# ── 1. 기본 텍스트 생성 (Responses API) ──
response = client.responses.create(
    model="gpt-4.1",
    input="질문 또는 프롬프트"
)
print(response.output_text)

# ── 2. 시스템 프롬프트 + 멀티턴 ──
resp1 = client.responses.create(
    model="gpt-4.1",
    instructions="시스템 프롬프트 (역할, 규칙 등)",
    input="사용자 메시지"
)
resp2 = client.responses.create(
    model="gpt-4.1",
    previous_response_id=resp1.id,
    input="후속 질문"
)

# ── 3. Chat Completions API (레거시) ──
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "system", "content": "시스템 프롬프트"},
        {"role": "user",   "content": "사용자 메시지"}
    ],
    temperature=0.7,
    max_tokens=1000
)
print(response.choices[0].message.content)

# ── 4. 스트리밍 ──
stream = client.responses.create(
    model="gpt-4.1",
    input="긴 답변이 필요한 질문",
    stream=True
)
for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="")

# ── 5. Structured Outputs ──
from pydantic import BaseModel
class MySchema(BaseModel):
    field1: str
    field2: int

resp = client.responses.parse(
    model="gpt-4.1",
    input="...",
    text_format=MySchema
)
parsed = resp.output_parsed  # MySchema 인스턴스

# ── 6. Function Calling ──
tools = [{
    "type": "function",
    "name": "my_function",
    "description": "함수 설명",
    "parameters": {
        "type": "object",
        "properties": {
            "param1": {"type": "string", "description": "설명"}
        },
        "required": ["param1"],
        "additionalProperties": False
    },
    "strict": True
}]
resp = client.responses.create(
    model="gpt-4.1",
    tools=tools,
    input="..."
)
# resp.output에서 function_call 아이템 처리

# ── 7. 내장 도구 ──
# 웹 검색
client.responses.create(
    model="gpt-5.4",
    tools=[{"type": "web_search"}],
    input="최신 뉴스 검색"
)

# ── 8. 이미지 입력 (Vision) ──
client.responses.create(
    model="gpt-4.1",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": "이 이미지를 설명해줘"},
            {"type": "input_image", "image_url": "https://..."}
        ]
    }]
)

# ── 9. 이미지 생성 ──
client.images.generate(
    model="gpt-image-2",
    prompt="이미지 설명",
    n=1,
    size="1024x1024"
)

# ── 10. Embeddings ──
client.embeddings.create(
    model="text-embedding-3-small",
    input="텍스트"
)

# ── 11. 추론 강도 조절 (GPT-5 시리즈) ──
client.responses.create(
    model="gpt-5.4",
    reasoning={"effort": "high"},  # low | medium | high | xhigh
    input="복잡한 문제..."
)

curl https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-4.1",
    "input": "안녕하세요, curl로 API를 호출합니다!"
  }'