9.4. API로 앱 만들기¶

curl http://localhost:8000/v1/models

{
  "object": "list",
  "data": [
    {
      "id": "llama-3-8b",
      "object": "model",
      "created": 1704067200,
      "owned_by": "local"
    },
    {
      "id": "gpt-5.1",
      "object": "model",
      "created": 1704067200,
      "owned_by": "openai"
    }
  ]
}

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-3-8b",
    "messages": [
      {"role": "user", "content": "프랑스의 수도는 어디인가요?"}
    ]
  }'

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1704067200,
  "model": "llama-3-8b",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "프랑스의 수도는 파리입니다."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 15,
    "completion_tokens": 8,
    "total_tokens": 23
  }
}

pip install openai

from openai import OpenAI

def chatbot():
    client = OpenAI(
        base_url="http://localhost:8000/v1",
        api_key="not-needed"
    )

    messages = []
    print("챗봇이 시작되었습니다. 종료하려면 'quit'를 입력하세요.\n")

    while True:
        user_input = input("사용자: ")
        if user_input.lower() == 'quit':
            break

        messages.append({"role": "user", "content": user_input})

        response = client.chat.completions.create(
            model="llama-3-8b",
            messages=messages
        )

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

        print(f"봇: {assistant_message}\n")

if __name__ == "__main__":
    chatbot()

npm install openai

import express from 'express';
import OpenAI from 'openai';

const app = express();
app.use(express.json());

const client = new OpenAI({
  baseURL: 'http://localhost:8000/v1',
  apiKey: 'not-needed',
});

app.post('/api/chat', async (req, res) => {
  try {
    const { message, model = 'llama-3-8b' } = req.body;

    const response = await client.chat.completions.create({
      model,
      messages: [{ role: 'user', content: message }],
    });

    res.json({
      success: true,
      response: response.choices[0].message.content,
    });
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
    res.status(500).json({
      success: false,
      error: errorMessage,
    });
  }
});

app.listen(3000, () => {
  console.log('서버가 http://localhost:3000에서 실행 중입니다');
});

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-3-8b",
    "messages": [
      {"role": "user", "content": "안녕하세요!"}
    ],
    "temperature": 0.7,
    "max_tokens": 100
  }'

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-3-8b",
    "messages": [
      {"role": "user", "content": "이야기를 들려주세요"}
    ],
    "stream": true
  }' \
  --no-buffer

curl http://localhost:8000/v1/models

# 모델 응답만 가져오기
curl -s http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-3-8b",
    "messages": [{"role": "user", "content": "안녕"}]
  }' | jq -r '.choices[0].message.content'

# 사용 가능한 모든 모델 나열
curl -s http://localhost:8000/v1/models | jq '.data[].id'

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

def moderate_and_respond(user_message: str) -> str:
    # 1단계: 프라이버시를 위해 로컬에서 콘텐츠 확인
    moderation_prompt = f"""이 메시지의 정책 위반 여부를 분석하세요:

    메시지: {user_message}

    '안전함' 또는 '안전하지 않음'으로만 응답하세요."""

    moderation = client.chat.completions.create(
        model="llama-3-8b",  # 민감한 데이터에는 로컬 모델 사용
        messages=[{"role": "user", "content": moderation_prompt}]
    )

    if "안전하지 않음" in moderation.choices[0].message.content:
        return "해당 요청에 응답할 수 없습니다."

    # 2단계: 안전하면 클라우드 모델을 사용하여 고품질 응답 생성
    response = client.chat.completions.create(
        model="gpt-5.1",  # 더 나은 품질을 위해 클라우드 모델 사용
        messages=[{"role": "user", "content": user_message}]
    )

    return response.choices[0].message.content

# 사용
result = moderate_and_respond("양자 컴퓨팅에 대해 알려주세요")
print(result)

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

def smart_completion(prompt: str, complexity: str = "low") -> str:
    """
    복잡도에 따라 로컬 또는 클라우드 모델로 요청 라우팅
    """
    if complexity == "low":
        # 간단한 작업에는 무료 로컬 모델 사용
        model = "llama-3-8b"
    elif complexity == "medium":
        # 중간 복잡도에는 빠른 클라우드 모델 사용
        model = "gpt-5.1-mini"
    else:
        # 필요한 경우에만 강력한 클라우드 모델 사용
        model = "gpt-5.1"

    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}]
    )

    return response.choices[0].message.content

# 간단한 쿼리 - 로컬 모델 사용 (무료)
print(smart_completion("2+2는 얼마인가요?", complexity="low"))

# 복잡한 쿼리 - 클라우드 모델 사용 (유료)
print(smart_completion("양자 컴퓨팅이 암호학에 미치는 영향을 분석하세요", complexity="high"))

from openai import OpenAI
import httpx

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed",
    timeout=httpx.Timeout(10.0, connect=5.0)  # 총 10초, 연결 5초
)

def resilient_completion(prompt: str) -> str:
    """
    로컬 모델을 먼저 시도하고, 사용할 수 없으면 클라우드로 대체
    """
    models_to_try = [
        "llama-3-8b",      # 로컬 모델을 먼저 시도
        "gpt-5.1",         # 로컬 실패 시 클라우드로 대체
    ]

    for model in models_to_try:
        try:
            response = client.chat.completions.create(
                model=model,
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content
        except Exception as e:
            print(f"모델 {model} 실패: {e}")
            continue

    return "모든 모델을 사용할 수 없습니다. 나중에 다시 시도해주세요."

result = resilient_completion("신경망을 설명해주세요")
print(result)