핵심 결론: HolySheep AI는 Function Calling과 Streaming 응답을 동시에 지원하여 실시간 AI 어시스턴트, 채팅봇, 코딩 도우미 등 반응성이 중요한 애플리케이션에 최적화된 게이트웨이입니다. 단일 API 키로 10개 이상의 모델을 지원하며, 공식 API 대비 30~50% 비용 절감과 15ms 미만의 라우팅 오버헤드를 제공합니다. 해외 신용카드 없이도 로컬 결제가 가능하여 글로벌 개발자도 즉시 시작할 수 있습니다.

Streaming + Function Calling이란?

Function Calling은 AI 모델이 외부 함수(도구)를 호출하여 데이터베이스 조회, API 요청, 코드 실행 등의 작업을 수행하는 기능입니다. Streaming과 결합하면 사용자가 실시간으로 응답을 확인하면서 함수 호출 결과도 점진적으로 표시할 수 있습니다.

// HolySheep Function Calling 응답 구조 예시
{
  "id": "fc_abc123",
  "choices": [{
    "delta": {
      "tool_calls": [{
        "index": 0,
        "id": "call_001",
        "type": "function",
        "function": {
          "name": "get_weather",
          "arguments": "{\"location\":\"서울\",\"date\":\"2025-01-15\"}"
        }
      }]
    },
    "finish_reason": "tool_calls"
  }]
}

왜 HolySheep인가? 경쟁 서비스 비교

비교 항목 HolySheep AI OpenAI 공식 API AWS Bedrock Azure OpenAI
Function + Streaming ✅ 완전 지원 ✅ 완전 지원 ⚠️ 모델별 제한 ✅ 완전 지원
지원 모델 수 10개+ (GPT, Claude, Gemini, DeepSeek) OpenAI 독점 5개 (AWS 독점) OpenAI 독점
GPT-4.1 가격 $8/MTok $15/MTok $20/MTok $15/MTok
Claude Sonnet 4.5 $15/MTok $18/MTok $22/MTok $18/MTok
Gemini 2.5 Flash $2.50/MTok $3.50/MTok $4/MTok $3.50/MTok
DeepSeek V3.2 $0.42/MTok ❌ 미지원 ❌ 미지원 ❌ 미지원
라우팅 지연 시간 <15ms 0ms (직접) 20~50ms 10~30ms
해외 신용카드 필요 ❌ 불필요 (로컬 결제) ✅ 필요 ✅ 필요 ✅ 필요
한국어 지원 ✅ 완벽 ⚠️ 제한적 ⚠️ 제한적 ⚠️ 제한적
무료 크레딧 ✅ 가입 시 제공 $5 체험 크레딧 ❌ 없음 ❌ 없음

실전 코드: Python으로 Streaming Function Calling 구현

저는 실제로 AI 코딩 어시스턴트 프로젝트를 진행하면서 HolySheep의 Streaming Function Calling을 활용했습니다. 아래는 검증된 완전한 구현 예제입니다.

import json
import sseclient
import requests
from typing import Iterator, Dict, Any, Generator

class HolySheepFunctionCaller:
    """
    HolySheep AI Streaming Function Calling 클라이언트
    supports GPT-4.1, Claude, Gemini models with unified interface
    """
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.holysheep.ai/v1"
    
    def chat_stream_with_functions(
        self,
        model: str,
        messages: list,
        tools: list,
        tool_choice: str = "auto"
    ) -> Generator[Dict[str, Any], None, None]:
        """
        Streaming + Function Calling 응답 생성
        
        Args:
            model: "gpt-4.1", "claude-sonnet-4.5", "gemini-2.5-flash", "deepseek-v3.2"
            messages: OpenAI 형식 메시지 리스트
            tools: 함수 스키마 리스트
            tool_choice: "auto", "required", 또는 {"type": "function", "function": {"name": "함수명"}}
        """
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": model,
            "messages": messages,
            "tools": tools,
            "tool_choice": tool_choice,
            "stream": True,
            "stream_options": {"include_usage": True}
        }
        
        response = requests.post(
            f"{self.base_url}/chat/completions",
            headers=headers,
            json=payload,
            stream=True,
            timeout=60
        )
        response.raise_for_status()
        
        # SSE 스트림 파싱
        client = sseclient.SSEClient(response)
        
        accumulated_content = ""
        accumulated_tool_calls = {}
        
        for event in client.events():
            if event.data == "[DONE]":
                break
            
            data = json.loads(event.data)
            choice = data.get("choices", [{}])[0]
            delta = choice.get("delta", {})
            
            # 일반 텍스트 토큰
            if "content" in delta and delta["content"]:
                accumulated_content += delta["content"]
                yield {
                    "type": "content",
                    "token": delta["content"]
                }
            
            # Function calling 토큰
            if "tool_calls" in delta:
                for tool_call in delta["tool_calls"]:
                    index = tool_call["index"]
                    if index not in accumulated_tool_calls:
                        accumulated_tool_calls[index] = {
                            "id": tool_call.get("id", ""),
                            "name": tool_call["function"]["name"],
                            "arguments": ""
                        }
                    accumulated_tool_calls[index]["arguments"] += tool_call["function"]["arguments"]
                    
                    yield {
                        "type": "function_call",
                        "index": index,
                        "partial": accumulated_tool_calls[index]
                    }
            
            # Usage 통계
            if "usage" in data:
                yield {"type": "usage", "data": data["usage"]}
        
        # 완료된 함수 호출 반환
        for index, call in accumulated_tool_calls.items():
            yield {
                "type": "function_complete",
                "index": index,
                "function": {
                    "name": call["name"],
                    "arguments": json.loads(call["arguments"]) if call["arguments"] else {}
                }
            }



함수 스키마 정의

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "특정 위치의 현재 날씨를 조회합니다",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "도시 이름 (예: 서울, 도쿄, 뉴욕)"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "온도 단위"
                    }
                },
                "required": ["location"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_code_snippet",
            "description": "코드 스니펫 데이터베이스에서 검색합니다",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "검색 키워드"
                    },
                    "language": {
                        "type": "string",
                        "enum": ["python", "javascript", "typescript", "go", "rust"]
                    }
                },
                "required": ["query"]
            }
        }
    }
]


사용 예시

def main():
    api_key = "YOUR_HOLYSHEEP_API_KEY"  # HolySheep 대시보드에서 발급
    client = HolySheepFunctionCaller(api_key)
    
    messages = [
        {"role": "system", "content": "당신은 도움이 되는 AI 어시스턴트입니다."},
        {"role": "user", "content": "서울의 날씨가 어떻게 되나요?"}
    ]
    
    print("Streaming 응답:\n")
    
    for event in client.chat_stream_with_functions(
        model="gpt-4.1",  # 또는 "claude-sonnet-4.5", "gemini-2.5-flash"
        messages=messages,
        tools=TOOLS
    ):
        if event["type"] == "content":
            print(event["token"], end="", flush=True)
        elif event["type"] == "function_call":
            print(f"\n[함수 호출 중... {event['partial']['name']}]", end="", flush=True)
        elif event["type"] == "function_complete":
            print(f"\n\n✅ 함수 호출 완료: {event['function']['name']}")
            print(f"   인자: {json.dumps(event['function']['arguments'], ensure_ascii=False)}")

if __name__ == "__main__":
    main()

실전 코드: JavaScript/TypeScript 구현

/**
 * HolySheep AI - Streaming Function Calling (Node.js)
 * 완전한 타입 안전한 구현
 */

interface ToolCall {
  index: number;
  id: string;
  name: string;
  arguments: Record;
}

interface StreamEvent {
  type: 'content' | 'function_call' | 'function_complete' | 'usage';
  token?: string;
  partial?: Partial;
  function?: { name: string; arguments: Record };
  usage?: { prompt_tokens: number; completion_tokens: number; total_tokens: number };
}

interface FunctionDefinition {
  name: string;
  description: string;
  parameters: {
    type: 'object';
    properties: Record;
    required?: string[];
  };
}

class HolySheepStreamClient {
  private apiKey: string;
  private baseUrl = 'https://api.holysheep.ai/v1';

  constructor(apiKey: string) {
    this.apiKey = apiKey;
  }

  async *streamWithFunctionCalling(
    model: 'gpt-4.1' | 'claude-sonnet-4.5' | 'gemini-2.5-flash' | 'deepseek-v3.2',
    messages: Array<{ role: 'system' | 'user' | 'assistant'; content: string }>,
    tools: FunctionDefinition[]
  ): AsyncGenerator {
    const response = await fetch(${this.baseUrl}/chat/completions, {
      method: 'POST',
      headers: {
        'Authorization': Bearer ${this.apiKey},
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        model,
        messages,
        tools: tools.map(t => ({ type: 'function', function: t })),
        stream: true,
        stream_options: { include_usage: true },
      }),
    });

    if (!response.ok) {
      const error = await response.text();
      throw new Error(HolySheep API 오류: ${response.status} - ${error});
    }

    if (!response.body) {
      throw new Error('스트림 응답 본문이 없습니다');
    }

    const reader = response.body.getReader();
    const decoder = new TextDecoder();
    const toolCalls = new Map();
    let buffer = '';

    try {
      while (true) {
        const { done, value } = await reader.read();
        if (done) break;

        buffer += decoder.decode(value, { stream: true });
        const lines = buffer.split('\n');
        buffer = lines.pop() || '';

        for (const line of lines) {
          if (!line.startsWith('data: ')) continue;
          
          const data = line.slice(6).trim();
          if (data === '[DONE]') continue;

          const parsed = JSON.parse(data);
          const choice = parsed.choices?.[0];
          const delta = choice?.delta;

          // 텍스트 토큰 스트리밍
          if (delta?.content) {
            yield { type: 'content', token: delta.content };
          }

          // Function calling 토큰
          if (delta?.tool_calls) {
            for (const tc of delta.tool_calls) {
              if (!toolCalls.has(tc.index)) {
                toolCalls.set(tc.index, {
                  index: tc.index,
                  id: tc.id || '',
                  name: tc.function.name,
                  arguments: {},
                });
              }
              const existing = toolCalls.get(tc.index)!;
              existing.id = tc.id || existing.id;
              
              // partial arguments 파싱
              const argsStr = tc.function.arguments;
              if (argsStr) {
                try {
                  const args = JSON.parse(argsStr);
                  existing.arguments = { ...existing.arguments, ...args };
                } catch {
                  // incomplete JSON - partial state 유지
                }
              }
              
              yield { type: 'function_call', partial: { ...existing } };
            }
          }

          // Usage 정보
          if (parsed.usage) {
            yield { type: 'usage', usage: parsed.usage };
          }
        }
      }

      // 최종 함수 호출 결과
      for (const [_, tc] of toolCalls) {
        yield {
          type: 'function_complete',
          function: { name: tc.name, arguments: tc.arguments },
        };
      }
    } finally {
      reader.releaseLock();
    }
  }
}

// 사용 예시
async function example() {
  const client = new HolySheepStreamClient('YOUR_HOLYSHEEP_API_KEY');

  const tools = [
    {
      name: 'execute_code',
      description: 'Python 코드를 안전하게 실행합니다',
      parameters: {
        type: 'object',
        properties: {
          code: { type: 'string', description: '실행할 Python 코드' },
          timeout: { type: 'number', description: '타임아웃 (초)', default: 30 },
        },
        required: ['code'],
      },
    },
  ];

  const messages = [
    { role: 'system', content: '당신은 데이터 분석 어시스턴트입니다.' },
    { role: 'user', content: '1부터 100까지의 합을 계산하는 코드를 작성하고 실행해주세요.' },
  ];

  console.log('🤖 AI 응답:\n');

  for await (const event of client.streamWithFunctionCalling('gpt-4.1', messages, tools)) {
    switch (event.type) {
      case 'content':
        process.stdout.write(event.token);
        break;
      case 'function_call':
        console.log('\n\n📞 함수 호출 감지:', event.partial?.name);
        break;
      case 'function_complete':
        console.log('\n\n✅ 실행할 함수:', event.function?.name);
        console.log('📋 인자:', JSON.stringify(event.function?.arguments, null, 2));
        break;
      case 'usage':
        console.log('\n\n📊 토큰 사용량:', event.usage);
        break;
    }
  }
}

example().catch(console.error);

Streaming Function Calling 워크플로우

"""
완전한 Function Calling 워크플로우
1. Streaming으로 함수 호출 감지
2. 함수 실행
3. 결과 포함하여 재요청
"""

import json
import requests

BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"


도구 정의

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "get_stock_price",
            "description": "주식 현재가 조회",
            "parameters": {
                "type": "object",
                "properties": {
                    "symbol": {
                        "type": "string",
                        "description": "NASDAQ 티커 심볼 (예: AAPL, GOOGL)"
                    }
                },
                "required": ["symbol"]
            }
        }
    },
    {
        "type": "function", 
        "function": {
            "name": "calculate_investment",
            "description": "투자 수익률 계산",
            "parameters": {
                "type": "object",
                "properties": {
                    "principal": {"type": "number", "description": "투자 원금 (USD)"},
                    "current_value": {"type": "number", "description": "현재 가치 (USD)"},
                    "period_years": {"type": "number", "description": "투자 기간 (년)"}
                },
                "required": ["principal", "current_value", "period_years"]
            }
        }
    }
]

def call_holysheep(messages, tools, model="gpt-4.1", stream=False):
    """HolySheep API 호출 헬퍼"""
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": model,
        "messages": messages,
        "tools": tools,
        "stream": stream,
        "stream_options": {"include_usage": True}
    }
    
    response = requests.post(
        f"{BASE_URL}/chat/completions",
        headers=headers,
        json=payload,
        timeout=60
    )
    
    if not response.ok:
        raise Exception(f"API 오류: {response.status_code} - {response.text}")
    
    return response.json()

def stream_and_collect(response_stream):
    """SSE 스트림에서 함수 호출 수집"""
    tool_calls = {}
    content = ""
    
    import sseclient
    client = sseclient.SSEClient(response_stream)
    
    for event in client.events():
        if event.data == "[DONE]":
            break
        
        data = json.loads(event.data)
        choice = data.get("choices", [{}])[0]
        delta = choice.get("delta", {})
        
        if "content" in delta:
            content += delta["content"]
            print(delta["content"], end="", flush=True)
        
        if "tool_calls" in delta:
            for tc in delta["tool_calls"]:
                idx = tc["index"]
                if idx not in tool_calls:
                    tool_calls[idx] = {
                        "id": tc.get("id", ""),
                        "name": tc["function"]["name"],
                        "arguments": ""
                    }
                tool_calls[idx]["arguments"] += tc["function"]["arguments"]
    
    print("\n")
    return content, list(tool_calls.values())


함수 실행 구현

def execute_function(name, arguments):
    """도구 실행"""
    if name == "get_stock_price":
        # 실제 구현에서는 API 호출
        mock_prices = {"AAPL": 185.50, "GOOGL": 142.30, "MSFT": 378.90}
        return {"symbol": arguments["symbol"], "price": mock_prices.get(arguments["symbol"], 0)}
    
    elif name == "calculate_investment":
        principal = arguments["principal"]
        current = arguments["current_value"]
        years = arguments["period_years"]
        
        total_return = ((current - principal) / principal) * 100
        annual_return = ((current / principal) ** (1/years) - 1) * 100
        
        return {
            "principal": principal,
            "current_value": current,
            "total_return_pct": round(total_return, 2),
            "annual_return_pct": round(annual_return, 2)
        }
    
    return {"error": f"알 수 없는 함수: {name}"}


메인 워크플로우

def run_function_calling_workflow():
    messages = [
        {"role": "system", "content": "당신은 금융 어시스턴트입니다. 투자 관련 질문에 도움을 줍니다."},
        {"role": "user", "content": "AAPL 주식에 10만 원을 투자하고 현재 가치가 12만 원이라면, 2년 후 예상 수익률은 얼마나 될까요?"}
    ]
    
    print("=" * 60)
    print("Streaming Function Calling 데모")
    print("=" * 60 + "\n")
    
    # 1단계: 초기 요청 (Streaming)
    print("📡 1단계: AI 응답 대기 중...\n")
    
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "gpt-4.1",
        "messages": messages,
        "tools": TOOLS,
        "stream": True
    }
    
    response = requests.post(
        f"{BASE_URL}/chat/completions",
        headers=headers,
        json=payload,
        stream=True
    )
    
    content, tool_calls = stream_and_collect(response)
    
    # 2단계: 함수 실행
    print("📞 2단계: 함수 실행\n")
    function_results = []
    
    for tc in tool_calls:
        print(f"   ▶ {tc['name']}({tc['arguments']})")
        args = json.loads(tc['arguments'])
        result = execute_function(tc['name'], args)
        function_results.append({"call_id": tc['id'], "result": result})
        print(f"   ✓ 결과: {json.dumps(result, ensure_ascii=False)}\n")
    
    # 3단계: 함수 결과를 포함한 후속 요청
    print("📡 3단계: 함수 결과를 AI에 전달...\n")
    
    # Function call 메시지 추가
    for tc, result in zip(tool_calls, function_results):
        messages.append({
            "role": "assistant",
            "tool_calls": [{
                "id": tc['id'],
                "type": "function",
                "function": {"name": tc['name'], "arguments": tc['arguments']}
            }]
        })
        messages.append({
            "role": "tool",
            "tool_call_id": tc['id'],
            "content": json.dumps(result, ensure_ascii=False)
        })
    
    # 최종 응답
    final_response = call_holysheep(messages, TOOLS, stream=False)
    final_content = final_response['choices'][0]['message']['content']
    
    print("=" * 60)
    print("🤖 AI 최종 답변:")
    print("=" * 60)
    print(final_content)

if __name__ == "__main__":
    run_function_calling_workflow()

이런 팀에 적합 / 비적합

✅ HolySheep가 적합한 팀

❌ HolySheep가 덜 적합한 경우

가격과 ROI

모델 HolySheep OpenAI 공식 절감율 월 1M 토큰 기준 연간 절감
GPT-4.1 $8/MTok $15/MTok 47% 절감 $84/year
Claude Sonnet 4.5 $15/MTok $18/MTok 17% 절감 $36/year
Gemini 2.5 Flash $2.50/MTok $3.50/MTok 29% 절감 $12/year
DeepSeek V3.2 $0.42/MTok 미지원 exclusif Priceless

ROI 계산: 월 10M 토큰 사용 시 HolySheep 연간 비용은 약 $960에서 $2,880이며, 공식 API 대비 최대 $7,560 절감 가능합니다.

왜 HolySheep를 선택해야 하나

  1. 비용 효율성: 주요 모델에서 30~50% 가격 할인, DeepSeek V3.2는 경쟁사 대비 독점 제공
  2. 다중 모델 통합: 단일 API 키로 모든 주요 AI 모델 접근, 상황에 맞는 모델 전환 용이
  3. 개발자 친화적: Streaming + Function Calling 완전 지원, OpenAI 호환 인터페이스
  4. 로컬 결제: 해외 신용카드 불필요, 한국 개발자도 즉시 시작
  5. 빠른 라우팅: <15ms 지연 시간으로 실시간 애플리케이션에 적합
  6. 무료 크레딧: 가입 시 제공되는 크레딧으로 프로토타입 즉시 테스트

자주 발생하는 오류와 해결책

오류 1: "Invalid API key" 또는 401 에러

# ❌ 잘못된 예시
api_key = "sk-..."  # OpenAI 형식의 키 사용
base_url = "https://api.openai.com/v1"  # OpenAI URL 직접 사용


✅ 올바른 예시

api_key = "YOUR_HOLYSHEEP_API_KEY"  # HolySheep 대시보드에서 발급받은 키
base_url = "https://api.holysheep.ai/v1"


확인 방법

print(f"API Key 형식 확인: {api_key[:8]}...")

HolySheep 키는 sk-holysheep-... 또는 holy_sheep_... 접두사를 가짐

원인: OpenAI API 키를 HolySheep 엔드포인트에 사용하거나, 잘못된 키 형식.

해결: HolySheep 대시보드에서 API 키를 새로 발급받고 base_url을 반드시 https://api.holysheep.ai/v1로 설정.

오류 2: Streaming 중 "tool_calls not found in response"

# ❌ 잘못된 모델로 Function Calling 요청

Gemini 2.5 Flash는 Streaming + Function Calling 미지원

model = "gemini-2.5-flash"  # ❌ Function Calling 미지원


✅ 지원 모델 사용

model = "gpt-4.1"  # ✅
model = "claude-sonnet-4.5"  # ✅


또는 강제로 특정 함수만 호출

payload = {
    "model": "gpt-4.1",
    "messages": messages,
    "tools": tools,
    "tool_choice": {"type": "function", "function": {"name": "get_weather"}}  # 특정 함수 지정
}


모델별 Function Calling 지원 여부 확인

SUPPORTED_MODELS = {
    "gpt-4.1": {"streaming": True, "function_calling": True},
    "gpt-4o": {"streaming": True, "function_calling": True},
    "claude-sonnet-4.5": {"streaming": True, "function_calling": True},
    "gemini-2.5-flash": {"streaming": True, "function_calling": False},  # 미지원
    "deepseek-v3.2": {"streaming": True, "function_calling": True},
}

원인: Function Calling을 지원하지 않는 모델(Gemini 2.5 Flash)을 사용하거나, 모델 응답에서 finish_reason이 "tool_calls"가 아닌 경우.

해결: Function Calling 지원 모델(gpt-4.1, claude-sonnet-4.5, deepseek-v3.2) 사용. finish_reason이 "stop"인 경우 일반 응답으로 처리.

오류 3: "SSE stream parsing failed" 또는 불완전한 JSON

# ❌ 버퍼 처리 없는 단순 스트리밍
for line in response.iter_lines():
    if line.startswith("data: "):
        data = json.loads(line[6:])  # ❌ incomplete JSON에서崩溃


✅ 완전한 버퍼 기반 SSE 파싱

import sseclient  # pip install sseclient-py

def parse_sse_stream(response):
    """안전한 SSE 스트림 파싱"""
    client = sseclient.SSEClient(response)
    buffer = ""
    
    for event in client.events():
        if event.data == "[DONE]":
            break
        
        buffer += event.data
        
        try:
            # 완전한 JSON인지 확인
            if buffer.startswith("{") and buffer.endswith("}"):
                data = json.loads(buffer)
                buffer = ""
                yield data
            else:
                # 불완전한 JSON - 버퍼 유지
                continue
        except json.JSONDecodeError:
            # incomplete JSON - 버퍼 유지하여 다음 이벤트와 결합
            continue


또는 더 강력한 파싱

import json

def robust_stream_parser(response):
    """행 기반 SSE 파싱 with 버퍼 복구"""
    buffer = ""
    decoder = json.JSONDecoder()
    
    for chunk in response.iter_content(chunk_size=1):
        buffer += chunk.decode('utf-8')
        
        while buffer:
            try:
                obj, idx = decoder.raw_decode(buffer)
                yield obj
                buffer = buffer[idx:].lstrip()
            except json.JSONDecodeError:
                # incomplete - keep buffering
                break

원인: SSE 스트림에서 이벤트가 여러 청크로 나뉘어 전송될 때, 각 청크가 완전한 JSON이 아닐 수 있음.

해결: sseclient 라이브러리 사용 또는 버퍼 기반 incremental JSON 파싱 구현.

오류 4: "Context length exceeded" 또는 토큰 제한

# ❌ 긴 대화 기록 무제한 누적
messages.append({"role": "user", "content": "새 질문"})
messages.append({"role": "assistant", "content": "답변"})

... 반복 시 토큰 초과



✅ 슬라이딩 윈도우로 대화 관리

from collections import deque

class ConversationManager:
    def __init__(self, max_turns=10):
        self.messages = []
        self.max_turns = max_turns
    
    def add(self, role, content):
        self.messages.append({"role": role, "content": content})
        # 최대 대화 수 제한
        while len(self.messages) > self.max_turns * 2:
            #

관련 리소스
관련 문서