from openai import OpenAI

# 클라이언트 초기화
client = OpenAI()  # OPENAI_API_KEY 환경 변수에서 자동 로드

# 기본 호출
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {
            "role": "system",
            "content": "당신은 친절한 한국어 AI 어시스턴트입니다."
        },
        {
            "role": "user",
            "content": "자연어 처리가 무엇인지 한 문장으로 설명해 주세요."
        }
    ],
    temperature=0.7,  # 생성 다양성 (0.0 ~ 2.0)
    max_tokens=200,   # 최대 출력 토큰 수
)

# 응답 추출
answer = response.choices[0].message.content
print(answer)

# 토큰 사용량 확인
usage = response.usage
print(f"입력 토큰: {usage.prompt_tokens}")
print(f"출력 토큰: {usage.completion_tokens}")
print(f"총 토큰: {usage.total_tokens}")

from openai import OpenAI

client = OpenAI()

# 대화 히스토리 관리
conversation = [
    {"role": "system", "content": "당신은 NLP 전문가입니다. 간결하게 답변합니다."}
]

def chat(user_message: str) -> str:
    """사용자 메시지를 추가하고 응답을 받아 히스토리에 저장합니다."""
    conversation.append({"role": "user", "content": user_message})

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

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

# 대화 진행
print(chat("Transformer의 핵심 메커니즘은 무엇인가요?"))
print(chat("그것이 RNN보다 나은 점은 무엇인가요?"))  # 이전 문맥을 기억합니다
print(chat("구체적인 예시를 들어주세요."))

import anthropic

# 클라이언트 초기화
client = anthropic.Anthropic()  # ANTHROPIC_API_KEY 환경 변수에서 자동 로드

# 기본 호출
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="당신은 친절한 한국어 AI 어시스턴트입니다.",  # system은 별도 파라미터
    messages=[
        {
            "role": "user",
            "content": "BERT와 GPT의 핵심 차이를 표로 정리해 주세요."
        }
    ],
)

# 응답 추출
answer = response.content[0].text
print(answer)

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

from huggingface_hub import InferenceClient

# 클라이언트 초기화
client = InferenceClient(token=os.getenv("HF_TOKEN"))

# 텍스트 생성 (오픈소스 모델 활용)
response = client.text_generation(
    prompt="자연어 처리(NLP)란",
    model="meta-llama/Llama-3.1-8B-Instruct",
    max_new_tokens=200,
    temperature=0.7,
)
print(response)

# Chat Completion 스타일 호출
response = client.chat_completion(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[
        {"role": "system", "content": "당신은 유용한 AI 어시스턴트입니다."},
        {"role": "user", "content": "트랜스포머의 핵심 구성요소를 설명해 주세요."},
    ],
    max_tokens=500,
)
print(response.choices[0].message.content)

from openai import OpenAI

client = OpenAI()

# 스트리밍 호출 (stream=True)
stream = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "user", "content": "Transformer 아키텍처를 상세하게 설명해 주세요."}
    ],
    stream=True,  # 스트리밍 활성화
)

# 토큰 단위로 출력
full_response = ""
for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        token = chunk.choices[0].delta.content
        print(token, end="", flush=True)
        full_response += token

print()  # 줄바꿈
print(f"\n전체 응답 길이: {len(full_response)}자")

import anthropic

client = anthropic.Anthropic()

# 스트리밍 호출
with client.messages.stream(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Self-Attention의 동작 과정을 단계별로 설명해 주세요."}
    ],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

print()

# 최종 메시지에서 토큰 사용량 확인
final_message = stream.get_final_message()
print(f"입력 토큰: {final_message.usage.input_tokens}")
print(f"출력 토큰: {final_message.usage.output_tokens}")

import asyncio
from openai import AsyncOpenAI

async def stream_response():
    """비동기 스트리밍으로 응답을 받습니다."""
    client = AsyncOpenAI()

    stream = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "user", "content": "NLP의 주요 태스크를 나열해 주세요."}
        ],
        stream=True,
    )

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

# 실행
asyncio.run(stream_response())

import time
from openai import OpenAI, RateLimitError, APITimeoutError, APIConnectionError

client = OpenAI(timeout=30.0)  # 타임아웃 30초 설정

def call_with_retry(
    messages: list,
    model: str = "gpt-4o-mini",
    max_retries: int = 3,
    base_delay: float = 1.0,
) -> str:
    """지수 백오프(Exponential Backoff)로 API 호출을 재시도합니다."""
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages,
                temperature=0.7,
            )
            return response.choices[0].message.content

        except RateLimitError as e:
            # 429: 요청 속도 제한 초과
            delay = base_delay * (2 ** attempt)
            print(f"[Rate Limit] {delay}초 후 재시도 ({attempt + 1}/{max_retries})")
            time.sleep(delay)

        except APITimeoutError:
            # 408: 요청 시간 초과
            delay = base_delay * (2 ** attempt)
            print(f"[Timeout] {delay}초 후 재시도 ({attempt + 1}/{max_retries})")
            time.sleep(delay)

        except APIConnectionError:
            # 네트워크 연결 오류
            delay = base_delay * (2 ** attempt)
            print(f"[Connection Error] {delay}초 후 재시도 ({attempt + 1}/{max_retries})")
            time.sleep(delay)

        except Exception as e:
            # 기타 에러 (400 Bad Request, 401 Unauthorized 등)
            print(f"[Error] 재시도 불가: {e}")
            raise

    raise Exception(f"최대 재시도 횟수({max_retries})를 초과했습니다.")

# 사용 예시
result = call_with_retry(
    messages=[{"role": "user", "content": "NLP란 무엇인가요?"}]
)
print(result)