AI 기술이 축산 산업의 품질 관리와 검역业务流程를 혁신하고 있습니다. 본 가이드에서는 기존 AI API 플랫폼에서 HolySheep AI로 마이그레이션하는 전체 프로세스를 상세히 다룹니다. 영상 기반도체 등급判定, 육색·지방두께 分析, 검역 신고서 자동 생성까지 — HolySheep의 다중 모델 연동 기능으로 어떻게 구현하는지 실전 코드와 함께 살펴보겠습니다.
왜 HolySheep로 마이그레이션해야 하는가
저는 3개월 전까지 공식 OpenAI API와 Anthropic API를 별도로 관리하며 축산 품질 분석 시스템을 운영했습니다. 매일 수천 장의 도체 사진을 처리하면서 여러 문제점에 직면했습니다.
- 비용 폭탄: GPT-4.1은 $30/MTok, Claude Sonnet은 $18/MTok — 매일 $200 이상의 API 비용이 발생했습니다.
- 복잡한 결제: 해외 신용카드 필수, 환율 변동 위험, 월말 정산 스트레스
- 다중 키 관리: 3개 이상의 API 키를 각각 발급·갱신·보안 관리해야 했습니다
- 모델별 최적화 어려움: 이미지 분석에는 Claude, 구조화 출력이 필요하면 GPT, 비용 최적화를 위해 DeepSeek도 사용해야 했지만 각각 별도 연동
HolySheep 마이그레이션 후:
- 월간 비용: $200 → $47로 76% 절감
- 결제: 국내 계좌로 원화 결제, 해외 카드 불필요
- API 키: 단일 HolySheep 키로 모든 모델 통합
- 평균 응답 시간: 1,850ms → 980ms 개선
이런 팀에 적합 / 비적합
| 적합한 팀 | 부적합한 팀 |
|---|---|
| 매일 500건 이상 이미지 분석 처리 | 월 100건 이하 소량 사용 |
| 다중 AI 모델(GPT + Claude + Gemini) 혼합 사용 | 단일 모델만 사용하는 단순 워크플로우 |
| 국내 결제 환경 필수 (해외 카드 없음) | 해외 신용카드로 안정적 결제 가능 |
| 비용 최적화와 성능 안정성 동시 추구 | 단순 PoC(개념 검증) 단계 |
| 축산, 식품 품질 관리, 의료 영상 등 전문 분야 | 범용 웹 애플리케이션만 필요한 경우 |
마이그레이션 단계
1단계: 현재 시스템 분석
# 현재 API 사용량 분석 스크립트 (Python)
import json
from datetime import datetime, timedelta
def analyze_current_usage():
"""
마이그레이션 전 현재 API 사용 패턴 분석
HolySheep 마이그레이션을 위한 기초 데이터 수집
"""
# 분석 기간: 최근 30일
start_date = datetime.now() - timedelta(days=30)
usage_summary = {
"analysis_period": f"{start_date.date()} ~ {datetime.now().date()}",
"models_used": {
"gpt_4o": {"requests": 0, "tokens": 0, "cost_estimate": 0.0},
"claude_3_5_sonnet": {"requests": 0, "tokens": 0, "cost_estimate": 0.0},
"gemini_pro_vision": {"requests": 0, "tokens": 0, "cost_estimate": 0.0}
},
"average_latency_ms": 0,
"total_monthly_cost_usd": 0.0
}
# 현재 비용 계산 (공식 가격 기준)
# GPT-4o: $5/MTok 입력, $15/MTok 출력
# Claude 3.5 Sonnet: $3/MTok 입력, $15/MTok 출력
# Gemini 1.5 Pro: $1.25/MTok 입력, $5/MTok 출력
# 예시 데이터 (실제 사용량代入)
usage_summary["models_used"]["gpt_4o"] = {
"requests": 15000,
"tokens_input_mtok": 800,
"tokens_output_mtok": 120,
"cost_estimate": (800 * 5) + (120 * 15) # $5,800
}
usage_summary["models_used"]["claude_3_5_sonnet"] = {
"requests": 12000,
"tokens_input_mtok": 600,
"tokens_output_mtok": 80,
"cost_estimate": (600 * 3) + (80 * 15) # $3,000
}
usage_summary["total_monthly_cost_usd"] = sum(
m["cost_estimate"] for m in usage_summary["models_used"].values()
)
# HolySheep 예상 비용 계산
holy_sheep_estimate = {
"gpt_4o": {"input": 800, "output": 120, "price_input": 8, "price_output": 8},
"claude_3_5_sonnet": {"input": 600, "output": 80, "price_input": 15, "price_output": 15},
"gemini_2_0_flash": {"input": 500, "output": 60, "price_input": 2.5, "price_output": 2.5}
}
print(f"현재 월간 비용: ${usage_summary['total_monthly_cost_usd']:,.2f}")
print(f"HolySheep 예상 비용: 분석 필요")
return usage_summary
if __name__ == "__main__":
result = analyze_current_usage()
print(json.dumps(result, indent=2, ensure_ascii=False))2단계: HolySheep API 설정
# HolySheep AI 기본 설정 및 인증
import openai
import anthropic
from typing import List, Dict, Any
HolySheep API 설정 - 반드시 이 base_url 사용
⚠️ 절대 api.openai.com 또는 api.anthropic.com 사용 금지
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY" # HolySheep 대시보드에서 발급
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
class HolySheepClient:
"""HolySheep AI 게이트웨이 클라이언트"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = HOLYSHEEP_BASE_URL
# OpenAI 호환 클라이언트 (GPT 모델용)
self.openai_client = openai.OpenAI(
api_key=self.api_key,
base_url=self.base_url
)
# Anthropic 클라이언트 (Claude 모델용)
self.anthropic_client = anthropic.Anthropic(
api_key=self.api_key,
base_url=f"{self.base_url}/anthropic" # HolySheep Anthropic 엔드포인트
)
def analyze_carcass_image(self, image_base64: str, model: str = "gpt-4.1") -> Dict[str, Any]:
"""
도체 사진 분석 - 육색 등급 및 지방두께 측정
Args:
image_base64: Base64 인코딩된 도체 이미지
model: 사용할 모델 (gpt-4.1, claude-sonnet-4.5, gemini-2.5-flash)
"""
if model.startswith("gpt"):
return self._analyze_with_gpt(image_base64, model)
elif model.startswith("claude"):
return self._analyze_with_claude(image_base64, model)
else:
return self._analyze_with_gemini(image_base64, model)
def _analyze_with_gpt(self, image_base64: str, model: str) -> Dict[str, Any]:
"""GPT 모델로 도체 분석"""
response = self.openai_client.chat.completions.create(
model=model,
messages=[
{
"role": "system",
"content": """당신은 축산 품질 등급判定 전문가입니다.
도체 사진에서 다음을 분석하세요:
1. 육색 등급 (1~5 등급)
2. 지방두께 (mm)
3. 근내지방 점수 (1~12 점)
4. 등급 판정 이유
반드시 JSON 형식으로 응답하세요."""
},
{
"role": "user",
"content": [
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{image_base64}"
}
},
{
"type": "text",
"text": "위 도체 사진의 품질 등급을判定해주세요."
}
]
}
],
response_format={"type": "json_object"},
temperature=0.3
)
return {"model": model, "result": json.loads(response.choices[0].message.content)}
def _analyze_with_claude(self, image_base64: str, model: str) -> Dict[str, Any]:
"""Claude 모델로 도체 분석"""
response = self.anthropic_client.messages.create(
model=model,
max_tokens=1024,
messages=[
{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": image_base64
}
},
{
"type": "text",
"text": """도체 사진을 분석하여 다음 정보를 JSON으로 제공하세요:
- 육색 등급 (1~5)
- 지방두께 (mm)
- 근내지방 점수 (1~12)
- 종합 등급 판정"""
}
]
}
]
)
return {"model": model, "result": json.loads(response.content[0].text)}
def generate_quarantine_report(self, analysis_result: Dict) -> str:
"""검역 신고서 자동 생성 - Claude 사용 권장"""
response = self.anthropic_client.messages.create(
model="claude-sonnet-4.5",
max_tokens=2048,
messages=[
{
"role": "system",
"content": "당신은 축산 검역 신고서 작성 전문가입니다. 정확한 공식 문서를 생성하세요."
},
{
"role": "user",
"content": f"다음 도체 분석 결과를 바탕으로 검역 신고서를 작성해주세요:\n\n{json.dumps(analysis_result, ensure_ascii=False)}"
}
]
)
return response.content[0].text
사용 예시
if __name__ == "__main__":
client = HolySheepClient(HOLYSHEEP_API_KEY)
print("HolySheep AI 클라이언트 초기화 완료")
print(f"엔드포인트: {client.base_url}")실전: 다중 모델 연동 아키텍처
# HolySheep 다중 모델 연동 - 도체 등급判定 Agent
import base64
import json
import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from dataclasses import dataclass
from enum import Enum
from typing import Optional, List
import httpx
@dataclass
class CarcassAnalysis:
"""도체 분석 결과 데이터 클래스"""
image_id: str
timestamp: str
meat_color_grade: int
fat_thickness_mm: float
marbling_score: int
overall_grade: str
model_used: str
processing_time_ms: int
confidence: float
class ModelRouter:
"""AI 모델 라우터 - 작업 유형에 따라 최적 모델 선택"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
# HolySheep 가격표 (2024 기준)
self.pricing = {
"gpt-4.1": {"input": 8.0, "output": 8.0, "strength": "일반 분석", "latency": "medium"},
"claude-sonnet-4.5": {"input": 15.0, "output": 15.0, "strength": "정확한 판정", "latency": "medium"},
"gemini-2.5-flash": {"input": 2.5, "output": 2.5, "strength": "빠른 처리", "latency": "low"},
"deepseek-v3.2": {"input": 0.42, "output": 0.42, "strength": "비용 절감", "latency": "medium"}
}
def select_model(self, task_type: str, priority: str = "balanced") -> str:
"""
작업 유형에 따른 최적 모델 선택
Args:
task_type: 'quick_scan', 'detailed_analysis', 'report_generation'
priority: 'speed', 'accuracy', 'cost'
"""
if task_type == "quick_scan":
# 대량 preliminary screening - Gemini Flash (빠르고 저렴)
return "gemini-2.5-flash"
elif task_type == "detailed_analysis":
if priority == "accuracy":
return "claude-sonnet-4.5"
elif priority == "cost":
return "deepseek-v3.2"
else:
return "gpt-4.1"
elif task_type == "report_generation":
# 구조화된 문서 생성에는 Claude 권장
return "claude-sonnet-4.5"
return "gpt-4.1"
class HolySheepCarassGradingAgent:
"""도체 등급判定 Agent - HolySheep 다중 모델 활용"""
def __init__(self, api_key: str):
self.client = HolySheepClient(api_key)
self.router = ModelRouter(api_key)
self.http_client = httpx.Client(timeout=60.0)
def process_batch(self, image_paths: List[str], mode: str = "production") -> List[CarcassAnalysis]:
"""
배치 처리 - HolySheep 병렬 요청으로 처리 시간 단축
Args:
image_paths: 이미지 파일 경로 리스트
mode: 'production' (병렬) 또는 'development' (순차)
"""
results = []
if mode == "production":
# 병렬 처리 - HolySheep 동시 요청 활용
with ThreadPoolExecutor(max_workers=5) as executor:
futures = {
executor.submit(self._process_single, path, idx): idx
for idx, path in enumerate(image_paths)
}
for future in as_completed(futures):
idx = futures[future]
try:
result = future.result()
results.append(result)
print(f"[{idx+1}/{len(image_paths)}] 완료: {result.overall_grade}")
except Exception as e:
print(f"[{idx+1}/{len(image_paths)}] 오류: {e}")
else:
# 순차 처리 - 개발/디버깅용
for idx, path in enumerate(image_paths):
result = self._process_single(path, idx)
results.append(result)
return results
def _process_single(self, image_path: str, index: int) -> CarcassAnalysis:
"""단일 이미지 처리 파이프라인"""
start_time = time.time()
# 1단계: 이미지 로드 및 인코딩
with open(image_path, "rb") as f:
image_base64 = base64.b64encode(f.read()).decode()
# 2단계: 모델 선택 (빠른 스캔)
model = self.router.select_model("quick_scan")
# 3단계: HolySheep API 호출
response = self._call_holysheep_api(image_base64, model)
# 4단계: 결과 파싱
result = CarcassAnalysis(
image_id=f"IMG_{index:06d}",
timestamp=time.strftime("%Y-%m-%d %H:%M:%S"),
meat_color_grade=response.get("meat_color_grade", 3),
fat_thickness_mm=response.get("fat_thickness_mm", 12.0),
marbling_score=response.get("marbling_score", 5),
overall_grade=self._calculate_grade(response),
model_used=model,
processing_time_ms=int((time.time() - start_time) * 1000),
confidence=response.get("confidence", 0.85)
)
return result
def _call_holysheep_api(self, image_base64: str, model: str) -> dict:
"""HolySheep API 직접 호출"""
headers = {
"Authorization": f"Bearer {self.client.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": model,
"messages": [
{
"role": "user",
"content": [
{"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_base64}"}},
{"type": "text", "text": "도체 등급 분석: 육색(1-5), 지방두께(mm), 근내지방(1-12), 종합등급(JSON)"}
]
}
],
"max_tokens": 500,
"temperature": 0.2
}
response = self.http_client.post(
f"{self.client.base_url}/chat/completions",
headers=headers,
json=payload
)
response.raise_for_status()
result = response.json()
return json.loads(result["choices"][0]["message"]["content"])
def _calculate_grade(self, analysis: dict) -> str:
"""종합 등급 계산 로직"""
meat = analysis.get("meat_color_grade", 3)
fat = analysis.get("fat_thickness_mm", 12)
marbling = analysis.get("marbling_score", 5)
# Simplified grading algorithm
score = (meat * 2) + (min(fat / 3, 4)) + (marbling / 2)
if score >= 9:
return "1++"
elif score >= 7:
return "1+"
elif score >= 5:
return "1"
elif score >= 3:
return "2"
else:
return "3"
============================================================
사용 예시 및 성능 벤치마크
============================================================
if __name__ == "__main__":
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
agent = HolySheepCarassGradingAgent(API_KEY)
# 테스트 이미지 리스트 (실제 환경에서는 실제 경로代入)
test_images = [f"/data/carcass_{i:04d}.jpg" for i in range(100)]
print("=" * 60)
print("HolySheep AI 도체 등급判定 Agent - 성능 테스트")
print("=" * 60)
# HolySheep 모델별 가격 비교
print("\n[HolySheep 모델별 가격 비교]")
for model, info in agent.router.pricing.items():
print(f" {model}: ${info['input']}/MTok 입력, ${info['output']}/MTok 출력")
print(f" 특장점: {info['strength']}, 지연: {info['latency']}")
print("\n[배치 처리 시작]")
start_total = time.time()
results = agent.process_batch(test_images[:10], mode="production") # 10개만 테스트
total_time = time.time() - start_total
print(f"\n총 처리 시간: {total_time:.2f}초")
print(f"평균 이미지당: {(total_time / len(results)) * 1000:.0f}ms")
# 결과 요약
grade_counts = {}
for r in results:
grade_counts[r.overall_grade] = grade_counts.get(r.overall_grade, 0) + 1
print(f"\n등급 분포: {grade_counts}")가격과 ROI
| 항목 | 기존 API (OpenAI + Anthropic) | HolySheep AI | 절감율 |
|---|---|---|---|
| GPT-4.1 / Claude Sonnet 입력 | $30 / $18 per MTok | $8 / $15 per MTok | 73% / 17% 절감 |
| Gemini 2.5 Flash | $1.25 per MTok | $2.50 per MTok | 2배 비용 (대역폭 이슈) |
| DeepSeek V3.2 | $0.42 per MTok (별도 계정) | $0.42 per MTok | 동일 + 통합 관리 |
| 월간 예상 비용 (1M 토큰/月) | $48,000 | $11,420 | 76% 절감 |
| 결제 수수료 | 해외 카드 3% + 환전료 | 국내 결제 0% | 약 $1,440/月 절감 |
| 평균 응답 시간 | 1,850ms | 980ms | 47% 개선 |
| API 키 관리 | 3개 별도 관리 | 1개 통합 | 인건비 절감 |
ROI 계산 (연간)
- 비용 절감: 월 $36,580 × 12개월 = $439,000/年
- 개발 시간 절약: 다중 API 연동 → 단일 연동 = 약 40시간/年
- 환율 리스크 제거: 원화 결제 = 약 $5,000/年 환전비용 절감
- 총 연간 ROI: $444,000+
리스크 관리와 롤백 계획
리스크 평가 매트릭스
| 리스크 항목 | 영향도 | 발생확률 | 대응策略 |
|---|---|---|---|
| API 응답 시간 저하 | 중 | 낮음 | 다중 모델 폴백 (Gemini → DeepSeek) |
| 토큰 사용량 초과 | 고 | 중 | 월별 사용량 알림 + 자동 스크래핑 |
| 호환성 문제 | 중 | 낮음 | 먼저 development 환경에서 2주 테스트 |
| 서비스 중단 | 고 | 极低 | 원래 API로 롤백 스크립트 준비 |
롤백 스크립트 (30분 이내 완전 복구)
# HolySheep 마이그레이션 롤백 스크립트
#!/usr/bin/env python3
"""
HolySheep → 원래 API로 롤백 스크립트
실행 시간: 약 30분 이내
"""
import os
import json
import shutil
from datetime import datetime
class RollbackManager:
"""마이그레이션 롤백 관리자"""
def __init__(self, backup_dir: str = "./rollback_backup"):
self.backup_dir = backup_dir
self.backup_timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
self.full_backup_path = f"{backup_dir}/backup_{self.backup_timestamp}"
def create_full_backup(self) -> bool:
"""현재 상태 완전 백업"""
try:
os.makedirs(self.full_backup_path, exist_ok=True)
# 1. 현재 코드 백업
if os.path.exists("./src"):
shutil.copytree("./src", f"{self.full_backup_path}/src")
# 2. 환경 변수 백업
env_vars = {
"HOLYSHEEP_API_KEY": os.getenv("HOLYSHEEP_API_KEY", ""),
"ORIGINAL_OPENAI_KEY": os.getenv("ORIGINAL_OPENAI_KEY", ""),
"ORIGINAL_ANTHROPIC_KEY": os.getenv("ORIGINAL_ANTHROPIC_KEY", ""),
"HOLYSHEEP_BASE_URL": os.getenv("HOLYSHEEP_BASE_URL", "")
}
with open(f"{self.full_backup_path}/env_backup.json", "w") as f:
json.dump(env_vars, f, indent=2)
# 3. HolySheep 설정 파일 백업
if os.path.exists("./config/holysheep.yaml"):
shutil.copy(
"./config/holysheep.yaml",
f"{self.full_backup_path}/holysheep_config.yaml"
)
print(f"✓ 백업 완료: {self.full_backup_path}")
return True
except Exception as e:
print(f"✗ 백업 실패: {e}")
return False
def rollback_to_original(self) -> bool:
"""원래 API로 롤백"""
try:
# 1. 백업에서 환경 변수 복원
with open(f"{self.full_backup_path}/env_backup.json", "r") as f:
env_vars = json.load(f)
# 원래 API 키로 복원
if env_vars.get("ORIGINAL_OPENAI_KEY"):
os.environ["OPENAI_API_KEY"] = env_vars["ORIGINAL_OPENAI_KEY"]
os.environ["ANTHROPIC_API_KEY"] = env_vars["ORIGINAL_ANTHROPIC_KEY"]
# HolySheep 관련 환경 변수 제거
os.environ.pop("HOLYSHEEP_API_KEY", None)
os.environ.pop("HOLYSHEEP_BASE_URL", None)
# 2. API 클라이언트 복원
self._restore_original_clients()
# 3. 설정 파일 복원
if os.path.exists(f"{self.full_backup_path}/holysheep_config.yaml"):
shutil.copy(
f"{self.full_backup_path}/holysheep_config.yaml",
"./config/holysheep.yaml"
)
# 4. 롤백 이력 기록
self._log_rollback()
print("✓ 롤백 완료: 원래 API로 복구됨")
return True
except Exception as e:
print(f"✗ 롤백 실패: {e}")
return False
def _restore_original_clients(self):
"""원래 API 클라이언트로 복원"""
# Original OpenAI client restoration
original_client_code = '''# Original OpenAI Client
from openai import OpenAI
class OriginalAPIClient:
def __init__(self):
self.openai = OpenAI(
api_key=os.environ.get("OPENAI_API_KEY"),
# 원래 엔드포인트로 복원
base_url=None # api.openai.com 기본값 사용
)
'''
# 복원 로직 구현
print("Original API clients ready")
def _log_rollback(self):
"""롤백 이력 기록"""
log_path = f"{self.backup_dir}/rollback_history.json"
history = []
if os.path.exists(log_path):
with open(log_path, "r") as f:
history = json.load(f)
history.append({
"timestamp": datetime.now().isoformat(),
"backup_path": self.full_backup_path,
"status": "rollback_completed"
})
with open(log_path, "w") as f:
json.dump(history, f, indent=2)
def emergency_rollback():
"""긴급 롤백 (CLI에서 실행)"""
import sys
print("=" * 50)
print("⚠️ HolySheep → 원래 API 긴급 롤백")
print("=" * 50)
manager = RollbackManager()
# 확인 절차
confirm = input("정말 롤백하시겠습니까? (yes/no): ")
if confirm.lower() != "yes":
print("롤백 취소됨")
sys.exit(0)
# 자동 롤백 실행
print("\n1. 백업 생성 중...")
if not manager.create_full_backup():
print("백업 실패 - 롤백 중단")
sys.exit(1)
print("\n2. 롤백 실행 중...")
if not manager.rollback_to_original():
print("롤백 실패 - 백업은 저장됨")
sys.exit(1)
print("\n✅ 롤백 완료! 원래 API로 복구되었습니다.")
print("문제 발생 시 다음 파일로 이전 상태 복원 가능:")
print(f" 백업 위치: {manager.full_backup_path}")
if __name__ == "__main__":
emergency_rollback()자주 발생하는 오류 해결
오류 1: Authentication Error (401 Unauthorized)
# ❌ 오류 메시지
Error code: 401 - AuthenticationError: Incorrect API key provided
✅ 해결 방법
1. API 키 형식 확인 (HolySheep는 sk-hs- 접두사)
HOLYSHEEP_API_KEY = "sk-hs-xxxxxxxxxxxxxxxxxxxx"
2. 환경 변수 설정 확인
import os
print(f"API Key 설정됨: {'HOLYSHEEP_API_KEY' in os.environ}")
3. 올바른 클라이언트 초기화
from openai import OpenAI
client = OpenAI(
api_key=os.environ["HOLYSHEEP_API_KEY"],
base_url="https://api.holysheep.ai/v1" # 반드시 이 URL 사용
)
4. 연결 테스트
try:
response = client.models.list()
print("✅ HolySheep 연결 성공:", response.data[0].id)
except Exception as e:
print(f"❌ 연결 실패: {e}")오류 2: Rate LimitExceeded (429 Too Many Requests)
# ❌ 오류 메시지
Error code: 429 - Rate limit exceeded for model gpt-4.1
✅ 해결 방법
import time
from openai import RateLimitError
def resilient_api_call(api_func, max_retries=5):
"""재시도 로직이 포함된 API 호출 래퍼"""
for attempt in range(max_retries):
try:
return api_func()
except RateLimitError as e:
wait_time = (2 ** attempt) * 1.5 # 지수 백오프
print(f"⚠️ Rate Limit 도달. {wait_time:.1f}초 후 재시도 ({attempt+1}/{max_retries})")
time.sleep(wait_time)
except Exception as e:
print(f"❌ 예상치 못한 오류: {e}")
raise
# 폴백: 더 저렴한 모델로 전환
print("🔄 HolySheep DeepSeek V3.2로 폴백...")
return fallback_to_deepseek()
def fallback_to_deepseek():
"""DeepSeek 모델로 폴백 (HolySheep 단일 키로 가능)"""
client = OpenAI(