계약서 심사 과정에서 수십 페이지에 달하는 문서를 수동으로 분석하는 것은 법무팀에게 상당한 시간과 비용을 소모시킵니다. 특히나 다국어 계약이나 복잡한 금융 상품 문서의 경우, 조항 하나라도 누락되면 치명적인 리스크로 이어질 수 있습니다.
본 튜토리얼에서는 HolySheep AI의 Function Calling 기능을 활용하여 계약서 분석을 자동화하는 실전 워크플로우를 구축하겠습니다. 로펌, 기업 법무팀,Compliance 부서 어디에나 적용 가능한 구조화된 솔루션을 단계별로 설명드리겠습니다.
HolySheep AI vs 공식 API vs 타 게이트웨이 비교
먼저 HolySheep AI가 경쟁 솔루션과 어떻게 다른지 핵심 항목을 비교해보겠습니다.
| 비교 항목 | HolySheep AI | 공식 OpenAI API | 타 API 게이트웨이 |
|---|---|---|---|
| base_url | https://api.holysheep.ai/v1 |
https://api.openai.com/v1 |
다양함 (불안정) |
| Local 결제 지원 | ✅ 해외 신용카드 불필요 | ❌ 해외 카드 필수 | 다름 |
| GPT-4.1 가격 | $8.00/MTok | $8.00/MTok | $9-12/MTok |
| Claude Sonnet 4.5 | $15.00/MTok | $15.00/MTok | $16-20/MTok |
| Gemini 2.5 Flash | $2.50/MTok | $2.50/MTok | $3-5/MTok |
| DeepSeek V3.2 | $0.42/MTok | 지원 안함 | 제한적 |
| Function Calling | ✅ 완벽 지원 | ✅ 지원 | 일부만 지원 |
| 가입 시 무료 크레딧 | ✅ 제공 | ❌ 없음 | 다름 |
| 단일 키 다중 모델 | ✅ 지원 | ❌ 단일 모델 | 제한적 |
| 한국어 기술 지원 | ✅ 한국어 지원 | ❌ 영어만 | 다름 |
HolySheep AI는 지금 가입하여 무료 크레딧으로 즉시 Function Calling을 체험해볼 수 있습니다. 특히 해외 신용카드 없이 로컬 결제가 가능하여 한국 법무팀의 접근성이 뛰어납니다.
이런 팀에 적합 / 비적합
✅ HolySheep AI가 적합한 팀
- 로펌 및 법률 컨설팅 firm: 다수의 계약서를 빠르게 분석해야 하는 중대형 로펌
- 기업 법무팀: 계약심사 업무가 과중하고 자동화가 필요한 팀
- Compliance 부서: 규제 준수를 위한 계약서 리스크 분석이 필요한 조직
- 금융권 법무팀: 복잡한 금융 상품 계약서를 검토해야 하는 업무
- 중소기업 법무 담당: 전담 법무팀 없이 계약 관리를 진행하는 조직
- 해외 계약 관리가 필요한 수출입 기업: 다국어 계약서 처리가 필요한 팀
❌ HolySheep AI가 비적합한 경우
- 극소형 팀: 월 10건 미만의 계약서만 처리하는 경우 수동 검토가 더 효율적
- 오프라인 환경만 허용: 클라우드 API 사용이 금지된 보안 정책이 있는 조직
- 완전 무료 솔루션 필요: 상업적 사용을 위한 지속적인 비용 감당 필요
Function Calling이란 무엇인가?
Function Calling은 AI 모델이 사용자가 정의한 함수를 호출하여 구조화된 데이터를 반환하는 기능입니다. 단순 텍스트 응답이 아닌 정형화된 JSON 형태로 결과를 받을 수 있어, 계약서 분석 결과 langsung 데이터베이스에 저장하거나 특정 포맷으로 출력하는 것이 가능합니다.
예를 들어, 계약서 텍스트에서 "중대한 의무 위반 시 해지 조항"을 찾아내는传统적 방법은 정규식이 필요했지만, Function Calling을 사용하면 자연어로 요구사항을 정의하고 구조화된 결과를 받을 수 있습니다.
사전 준비: HolySheep AI 설정
계약서 분석 워크플로우를 구축하기 전, HolySheep AI API 키를 발급받고 환경을 설정하겠습니다.
# 1. HolySheep AI SDK 설치 (OpenAI 호환 라이브러리 사용)
pip install openai python-dotenv
2. 프로젝트 디렉토리 생성
mkdir contract-analysis
cd contract-analysis
3. 환경변수 파일 생성
cat > .env << 'EOF'
HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY
EOF
4. API 키 확인 (발급 후 HolySheep 대시보드에서 확인)
echo "API Key 설정 완료: $HOLYSHEEP_API_KEY"# HolySheep AI 연결 테스트
from openai import OpenAI
import os
from dotenv import load_dotenv
load_dotenv()
HolySheep AI API 설정 — 반드시 이 base_url 사용
client = OpenAI(
api_key=os.getenv("HOLYSHEEP_API_KEY"),
base_url="https://api.holysheep.ai/v1"
)
연결 테스트
response = client.chat.completions.create(
model="gpt-4.1",
messages=[{"role": "user", "content": "안녕하세요, HolySheep AI 연결 테스트입니다."}]
)
print(f"✅ 연결 성공: {response.choices[0].message.content}")
print(f"사용된 모델: {response.model}")
print(f"토큰 사용량: {response.usage.total_tokens}")계약서 조항 추출 시스템 구축
이제 Function Calling을 활용하여 계약서에서 주요 조항을 추출하는 시스템을 구축하겠습니다.
import json
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()
client = OpenAI(
api_key=os.getenv("HOLYSHEEP_API_KEY"),
base_url="https://api.holysheep.ai/v1"
)
Function Calling을 위한 함수 정의
functions = [
{
"name": "extract_contract_clauses",
"description": "계약서에서 주요 조항을 구조화하여 추출합니다",
"parameters": {
"type": "object",
"properties": {
"clauses": {
"type": "array",
"description": "추출된 조항 목록",
"items": {
"type": "object",
"properties": {
"clause_number": {"type": "string", "description": "조항 번호"},
"clause_title": {"type": "string", "description": "조항 제목"},
"clause_type": {
"type": "string",
"enum": ["당사자", "기간", "대금", "해지", "손해배상", "비밀유지", "양도제한", "관할법원", "기타"],
"description": "조항 유형"
},
"summary": {"type": "string", "description": "조항 요약"},
"key_points": {
"type": "array",
"description": "핵심 포인트",
"items": {"type": "string"}
}
},
"required": ["clause_number", "clause_title", "clause_type", "summary"]
}
},
"contract_type": {"type": "string", "description": "계약서 유형"},
"total_clauses": {"type": "integer", "description": "총 조항 수"}
},
"required": ["clauses", "contract_type", "total_clauses"]
}
}
]
def analyze_contract(contract_text: str, contract_type: str = "일반 계약서") -> dict:
"""계약서를 분석하여 조항을 추출합니다"""
response = client.chat.completions.create(
model="gpt-4.1",
messages=[
{
"role": "system",
"content": "당신은 전문 법률 계약서 분석 AI입니다. 계약서를 внимательно 분석하여 주요 조항을 구조화하여 추출하세요. 모든 조항은 한국어로 정리해주세요."
},
{
"role": "user",
"content": f"다음 계약서를 분석하여 주요 조항을 추출해주세요:\n\n{contract_text}"
}
],
functions=functions,
function_call={"name": "extract_contract_clauses"}
)
# Function Calling 결과 파싱
result = json.loads(response.choices[0].message.function_call.arguments)
result["contract_type"] = contract_type
result["analysis_metadata"] = {
"model": response.model,
"tokens_used": response.usage.total_tokens,
"finish_reason": response.choices[0].finish_reason
}
return result
샘플 계약서 분석
sample_contract = """
제1조 (당사자)
①甲方: 한국전자 주식회사 (이하 "갑"이라 함)
②을: 글로벌소프트웨어 유한책임회사 (이하 "을"이라 함)
제5조 (대금 및 지급조건)
①本合同의 총 대금은 금 5억원(VAT 별도)으로 한다.
②甲方은 계약금 1억원(총 대금의 20%)을 계약 체결일로부터 7일 이내에 납부한다.
③잔금 4억원은 납품 완료 후 검사 합격 통보일로부터 30일 이내에 지급한다.
제8조 (계약 해지)
①갑은 을에게 30일 전 서면 통보로 본 계약을 해지할 수 있다.
②을의 중대한 의무 위반 시 갑은 즉시 계약을 해지할 수 있다.
③갑의 귀책사유로 계약을 해지할 경우, 을은 이행部分에 대한 대금을 청구할 수 있다.
"""
result = analyze_contract(sample_contract, "솔루션 공급 계약서")
print("=" * 60)
print(f"계약서 유형: {result['contract_type']}")
print(f"총 조항 수: {result['total_clauses']}")
print(f"토큰 사용량: {result['analysis_metadata']['tokens_used']}")
print("=" * 60)
for clause in result["clauses"]:
print(f"\n[{clause['clause_number']}] {clause['clause_title']} ({clause['clause_type']})")
print(f" 요약: {clause['summary']}")
if clause.get('key_points'):
print(f" 핵심포인트:")
for point in clause['key_points']:
print(f" • {point}")위험점标注 및 리스크 분석 시스템
추출된 조항을 기반으로 계약서의 잠재적 위험포인트를 자동으로 식별하고 분류하는 시스템을 구축하겠습니다.
from enum import Enum
from typing import List, Optional
from pydantic import BaseModel, Field
class RiskLevel(str, Enum):
HIGH = "HIGH" # 고위험 — 즉시 검토 필요
MEDIUM = "MEDIUM" # 중위험 — 주의 필요
LOW = "LOW" # 저위험 — 표준 조항
class RiskCategory(str, Enum):
FINANCIAL = "FINANCIAL" # 재무적 리스크
LEGAL = "LEGAL" # 법적 리스크
OPERATIONAL = "OPERATIONAL" # 운영 리스크
REPUTATION = "REPUTATION" # 평판 리스크
SECURITY = "SECURITY" # 보안 리스크
class RiskAnnotation(BaseModel):
clause_reference: str = Field(description="관련 조항 참조")
risk_title: str = Field(description="위험점 제목")
risk_level: RiskLevel = Field(description="위험 수준")
risk_category: RiskCategory = Field(description="위험 카테고리")
description: str = Field(description="위험 상세 설명")
recommendation: str = Field(description="권장 조치사항")
severity_score: int = Field(ge=1, le=10, description="심각도 점수 (1-10)")
class RiskAnalysisResult(BaseModel):
total_risks_identified: int
high_risk_count: int
medium_risk_count: int
low_risk_count: int
overall_risk_assessment: str = Field(description="전체 리스크 평가")
annotated_risks: List[RiskAnnotation]
risk_mitigation_suggestions: List[str]
def analyze_risks(clauses_data: dict) -> RiskAnalysisResult:
"""계약서 조항 데이터를 기반으로 위험점을 분석합니다"""
# Function Calling용 Pydantic 스키마를 OpenAI 함수 정의로 변환
functions = [
{
"name": "annotate_contract_risks",
"description": "계약서의 위험포인트를 분석하고标注합니다",
"parameters": {
"type": "object",
"properties": {
"total_risks_identified": {"type": "integer", "description": "식별된 총 위험 수"},
"high_risk_count": {"type": "integer", "description": "고위험 수"},
"medium_risk_count": {"type": "integer", "description": "중위험 수"},
"low_risk_count": {"type": "integer", "description": "저위험 수"},
"overall_risk_assessment": {"type": "string", "description": "전체 리스크 평가"},
"annotated_risks": {
"type": "array",
"items": {
"type": "object",
"properties": {
"clause_reference": {"type": "string"},
"risk_title": {"type": "string"},
"risk_level": {"type": "string", "enum": ["HIGH", "MEDIUM", "LOW"]},
"risk_category": {"type": "string", "enum": ["FINANCIAL", "LEGAL", "OPERATIONAL", "REPUTATION", "SECURITY"]},
"description": {"type": "string"},
"recommendation": {"type": "string"},
"severity_score": {"type": "integer", "minimum": 1, "maximum": 10}
},
"required": ["clause_reference", "risk_title", "risk_level", "risk_category", "description", "recommendation", "severity_score"]
}
},
"risk_mitigation_suggestions": {"type": "array", "items": {"type": "string"}}
},
"required": ["total_risks_identified", "high_risk_count", "medium_risk_count", "low_risk_count", "overall_risk_assessment", "annotated_risks", "risk_mitigation_suggestions"]
}
}
]
# 추출된 조항 정보를 문자열로 변환
clauses_summary = "\n".join([
f"[{c['clause_number']}] {c['clause_title']}: {c['summary']}"
for c in clauses_data.get("clauses", [])
])
response = client.chat.completions.create(
model="gpt-4.1",
messages=[
{
"role": "system",
"content": "당신은 전문 법무 리스크 분석가입니다. 계약서 조항을 바탕으로 잠재적 위험포인트를 식별하고 상세하게 분석해주세요. 모든 분석 결과는 한국어로 작성해주세요."
},
{
"role": "user",
"content": f"다음 계약서 조항에 대한 리스크 분석을 수행해주세요:\n\n{clauses_summary}"
}
],
functions=functions,
function_call={"name": "annotate_contract_risks"}
)
result = json.loads(response.choices[0].message.function_call.arguments)
return RiskAnalysisResult(**result)
이전 단계에서 추출한 조항数据进行 위험 분석
risk_result = analyze_risks(result)
print("=" * 70)
print("⚠️ 계약서 리스크 분석 결과")
print("=" * 70)
print(f"📊 전체 리스크 평가: {risk_result.overall_risk_assessment}")
print(f"🔴 고위험: {risk_result.high_risk_count}건")
print(f"🟡 중위험: {risk_result.medium_risk_count}건")
print(f"🟢 저위험: {risk_result.low_risk_count}건")
print("=" * 70)
for risk in risk_result.annotated_risks:
risk_emoji = {"HIGH": "🔴", "MEDIUM": "🟡", "LOW": "🟢"}[risk.risk_level]
print(f"\n{risk_emoji} [{risk.risk_level}] {risk.risk_title}")
print(f" 조항: {risk.clause_reference}")
print(f" 카테고리: {risk.risk_category}")
print(f" 설명: {risk.description}")
print(f" 심각도: {risk.severity_score}/10")
print(f" 💡 권장사항: {risk.recommendation}")
print("\n" + "=" * 70)
print("📋 리스크 완화 제안:")
for i, suggestion in enumerate(risk_result.risk_mitigation_suggestions, 1):
print(f" {i}. {suggestion}")구조화된 계약서 심사 보고서 생성
추출된 조항과 위험점 분석을 종합하여 구조화된 심사 보고서를 생성하는 워크플로우입니다.
from datetime import datetime
from typing import Dict, List
class ContractReviewReport:
def __init__(self, contract_info: dict, clauses_data: dict, risk_data: RiskAnalysisResult):
self.generated_at = datetime.now().isoformat()
self.contract_info = contract_info
self.clauses_data = clauses_data
self.risk_data = risk_data
def generate_report(self) -> Dict:
"""구조화된 심사 보고서를 생성합니다"""
report = {
"report_metadata": {
"generated_at": self.generated_at,
"report_version": "1.0",
"analysis_engine": "HolySheep AI Function Calling"
},
"contract_summary": {
"contract_type": self.contract_info.get("contract_type", "미분류"),
"total_clauses": self.clauses_data.get("total_clauses", 0),
"clauses_by_type": self._count_clauses_by_type()
},
"risk_summary": {
"total_risks": self.risk_data.total_risks_identified,
"risk_breakdown": {
"HIGH": self.risk_data.high_risk_count,
"MEDIUM": self.risk_data.medium_risk_count,
"LOW": self.risk_data.low_risk_count
},
"overall_assessment": self.risk_data.overall_risk_assessment
},
"detailed_analysis": {
"clauses": self.clauses_data.get("clauses", []),
"risks": [risk.model_dump() for risk in self.risk_data.annotated_risks],
"mitigation_suggestions": self.risk_data.risk_mitigation_suggestions
},
"approval_status": self._determine_approval_status()
}
return report
def _count_clauses_by_type(self) -> Dict[str, int]:
"""조항 유형별 카운트"""
counts = {}
for clause in self.clauses_data.get("clauses", []):
clause_type = clause.get("clause_type", "기타")
counts[clause_type] = counts.get(clause_type, 0) + 1
return counts
def _determine_approval_status(self) -> Dict:
"""심사 승인 상태 결정"""
high_risks = self.risk_data.high_risk_count
medium_risks = self.risk_data.medium_risk_count
if high_risks > 3:
status = "REJECTED"
reason = f"고위험 {high_risks}건이 포함되어 있어 반려 처리"
elif high_risks > 0:
status = "CONDITIONAL_APPROVAL"
reason = f"고위험 {high_risks}건에 대한 조치 후 재심사 필요"
elif medium_risks > 5:
status = "REVIEW_REQUIRED"
reason = "중위험 조항이 다수 포함되어 법무팀 전체 검토 필요"
else:
status = "APPROVED"
reason = "심사 완료 — 승인 가능"
return {
"status": status,
"reason": reason,
"action_items": self._generate_action_items()
}
def _generate_action_items(self) -> List[Dict]:
"""조치 항목 생성"""
action_items = []
for risk in self.risk_data.annotated_risks:
if risk.risk_level in ["HIGH", "MEDIUM"]:
action_items.append({
"priority": risk.risk_level,
"task": f"{risk.clause_reference} 조항 위험 해소",
"description": risk.recommendation,
"due_days": 3 if risk.risk_level == "HIGH" else 7
})
return action_items
def export_to_json(self, filename: str = "contract_review_report.json"):
"""보고서를 JSON 파일로 내보내기"""
report = self.generate_report()
with open(filename, 'w', encoding='utf-8') as f:
json.dump(report, f, ensure_ascii=False, indent=2)
print(f"✅ 보고서가 {filename}에 저장되었습니다.")
return report
전체 워크플로우 실행
def run_full_review_workflow(contract_text: str, contract_type: str) -> Dict:
"""계약서 분석에서 보고서 생성까지 전체 워크플로우 실행"""
print("📋 계약서 분석 워크플로우 시작")
print("=" * 60)
# Step 1: 조항 추출
print("\n[Step 1/3] 계약서 조항 추출 중...")
clauses_result = analyze_contract(contract_text, contract_type)
print(f" ✅ {clauses_result['total_clauses']}개 조항 추출 완료")
# Step 2: 위험점 분석
print("\n[Step 2/3] 위험점 분석 중...")
risk_result = analyze_risks(clauses_result)
print(f" ✅ {risk_result.total_risks_identified}개 위험점 식별 완료")
# Step 3: 보고서 생성
print("\n[Step 3/3] 심사 보고서 생성 중...")
report_generator = ContractReviewReport(
contract_info={"type": contract_type},
clauses_data=clauses_result,
risk_data=risk_result
)
final_report = report_generator.export_to_json()
print("\n" + "=" * 60)
print("🎉 전체 워크플로우 완료!")
print(f" 승인 상태: {final_report['approval_status']['status']}")
return final_report
샘플 계약서로 전체 워크플로우 실행
final_report = run_full_review_workflow(sample_contract, "솔루션 공급 계약서")실전 적용: batch processing 다중 계약서 처리
실무에서는 여러 계약서를 한번에 처리해야 하는 경우가 많습니다. 배치 처리 시스템을 구축하겠습니다.
import asyncio
from typing import List, Dict
from concurrent.futures import ThreadPoolExecutor
class BatchContractProcessor:
def __init__(self, max_workers: int = 3):
self.max_workers = max_workers
self.results = []
def process_multiple_contracts(self, contracts: List[Dict]) -> List[Dict]:
"""여러 계약서를 순차적으로 처리"""
print(f"📦 총 {len(contracts)}개 계약서 처리 시작")
print("=" * 60)
all_reports = []
for i, contract in enumerate(contracts, 1):
print(f"\n[{i}/{len(contracts)}] {contract['name']} 처리 중...")
try:
report = run_full_review_workflow(
contract_text=contract['text'],
contract_type=contract['type']
)
report['contract_name'] = contract['name']
all_reports.append(report)
print(f" ✅ 완료 — 상태: {report['approval_status']['status']}")
except Exception as e:
print(f" ❌ 오류 발생: {str(e)}")
all_reports.append({
'contract_name': contract['name'],
'status': 'ERROR',
'error': str(e)
})
return all_reports
def generate_batch_summary(self, reports: List[Dict]) -> Dict:
"""배치 처리 결과 요약 생성"""
total = len(reports)
approved = sum(1 for r in reports if r.get('approval_status', {}).get('status') == 'APPROVED')
conditional = sum(1 for r in reports if r.get('approval_status', {}).get('status') == 'CONDITIONAL_APPROVAL')
rejected = sum(1 for r in reports if r.get('approval_status', {}).get('status') == 'REJECTED')
errors = sum(1 for r in reports if r.get('status') == 'ERROR')
return {
"total_contracts": total,
"approved": approved,
"conditional_approval": conditional,
"rejected": rejected,
"errors": errors,
"approval_rate": f"{(approved/total)*100:.1f}%" if total > 0 else "0%"
}
샘플 다중 계약서 데이터
sample_contracts = [
{
"name": "클라우드 서비스 공급 계약서_A사",
"type": "IT 서비스 계약",
"text": """
제1조 (당사자) 갑: 한국전자, 을: A클라우드
제5조 (대금) 총 3억원, 분할 지급
제8조 (손해배상) 최대 계약금액의 200% 한도
제12조 (해지) 90일 전 통보로 해지 가능
"""
},
{
"name": "소프트웨어 라이선스 계약서_B사",
"type": "라이선스 계약",
"text": """
제1조 (당사자) 갑: 한국전자, 을: B소프트웨어
제5조 (대금) 연간 사용료 5천만원
제8조 (손해배상) 제한 없음
제15조 (양도제한) 사전 서면 동의 없이 양도 불가
"""
},
{
"name": "유지보수 계약서_C사",
"type": "유지보수 계약",
"text": """
제1조 (당사자) 갑: 한국전자, 을: C정보통신
제5조 (대금) 월 500만원
제8조 (손해배상) 제한 조항 없음, 무제한 책임
제20조 (관할법원) 서울중앙지방법원
"""
}
]
배치 처리 실행
processor = BatchContractProcessor()
batch_results = processor.process_multiple_contracts(sample_contracts)
summary = processor.generate_batch_summary(batch_results)
print("\n" + "=" * 60)
print("📊 배치 처리 결과 요약")
print("=" * 60)
print(f"전체 계약서: {summary['total_contracts']}건")
print(f"✅ 승인: {summary['approved']}건")
print(f"⚠️ 조건부 승인: {summary['conditional_approval']}건")
print(f"❌ 반려: {summary['rejected']}건")
print(f"🔶 오류: {summary['errors']}건")
print(f"📈 승인률: {summary['approval_rate']}")
전체 결과 JSON 저장
with open("batch_review_results.json", 'w', encoding='utf-8') as f:
json.dump({
"summary": summary,
"details": batch_results
}, f, ensure_ascii=False, indent=2)
print("\n✅ 전체 결과가 batch_review_results.json에 저장되었습니다.")가격과 ROI
HolySheep AI를 사용한 계약서 분석의 비용 효율성을 실제 수치로 분석해보겠습니다.
| 분석 항목 | 수동 심사 (인건비) | HolySheep AI 활용 |
|---|---|---|
| 계약서 1건당 소요 시간 | 약 2-4시간 | 약 30초-1분 |
| 월간 50건 처리 비용 | 약 150-200만원 (인건비) | 약 $2-5 (API 비용) |
| 사용 모델 | - | GPT-4.1 또는 Claude Sonnet 4.5 |
| 1건당 API 비용 (GPT-4.1) | - | 약 $0.05-0.15 (계약서 길이에 따라) |
| DeepSeek V3.2 사용 시 | - | 약 $0.01-0.03 (90% 절감) |
| 위험점 놓침 확률 | 인간 실수율 5-15% | AI 일관된 분석으로 감소 |
| 구조화된 출력 | 수동 정리 필요 | JSON 형식으로 즉시 저장 |
연간 예상 비용 절감:
- 월 50건 계약서 × 12개월 = 年 600건
- 수동 심사 비용 (시간당 3만원 × 평균 3시간 × 600건) = 약 5,400만원
- HolySheep AI API 비용 (평균 $0.10/건 × 600건) = 약 $60 (약 8만원)
- 연간 절감액: 약 5,300만원
저렴한 비용으로 계약서 분석 자동화를 구현하면서도 HolySheep AI의 무료 크레딧으로 먼저 체험해보실 수 있습니다.
자주 발생하는 오류와 해결책
오류 1: Function Calling 응답 파싱 실패
# ❌ 잘못된 접근: function_call.arguments가 문자열이 아닌 경우
response = client.chat.completions.create(...)
result = json.loads(response.choices[0].message.function_call.arguments)
KeyError: function_call not found
✅ 올바른 접근: function_call 존재 여부 확인
response = client.chat.completions.create(
model="gpt-4.1",
messages=[...],
functions=functions,
function_call={"name": "extract_contract_clauses"}
)
응답에서 function_call 확인
message = response.choices[0].message
if message.function_call:
# arguments가 이미 dict인 경우도 있음
if isinstance(message.function_call.arguments, str):
result = json.loads(message.function_call.arguments)
else:
result = message.function_call.arguments
else:
# Function Calling이 호출되지 않은 경우 (모델이 일반 응답 선택)
print("⚠️ Function이 호출되지 않음. 프롬프트 또는 함수 정의를 확인하세요.")
# 일반 응답 사용
result = {"text": message.content}오류 2: 토큰 제한 초과로 인한 긴 계약서 처리 실패
# ❌ 잘못된 접근: 긴 계약서를 한 번에 전달
full_contract = load_full_contract("huge_contract.pdf") # 수만 토큰
response = client.chat