Ver3.5 AI 자동계약서 검증 서비스 구현 완전 정복

AI 자동계약서 검증 서비스 구현 완전 정복
계약서 리뷰에 AI를 붙이면 어떤 일이 벌어질까? 🔍✨
실전 구현부터 핵심 기술까지 낱낱이 파헤쳐봄 ㅋㅋ
🚀 들어가며 - 계약서, 진짜 읽는 사람 있음?
솔직히 말해보자. 계약서 받으면 진짜 처음부터 끝까지 다 읽는 사람... 얼마나 될까? 🤔
대부분은 "뭐 대충 괜찮겠지~" 하고 서명하거나, 아니면 변호사한테 맡기는데 그것도 비용이 만만치 않잖아.
근데 이제 AI가 이 판을 완전히 뒤집어놓고 있음 ㄹㅇ.
2024년 기준으로 LegalTech 시장은 전 세계적으로 약 300억 달러(한화 약 40조 원) 규모로 성장했고,
그 중에서도 AI 기반 계약서 분석·검증 솔루션이 가장 빠르게 성장하는 세그먼트야.
McKinsey 보고서에 따르면 법률 업무의 약 23%가 AI로 자동화 가능하다고 하는데,
그 중 계약서 검토가 가장 먼저, 가장 빠르게 자동화되고 있는 분야임.
반복적인 패턴이 존재하고, 이런 패턴 인식은 AI가 인간보다 훨씬 빠르고 정확함.
게다가 계약서 검토는 고도의 집중력이 필요한 작업인데,
인간은 피로해지면 실수하지만 AI는 100번째 계약서도 1번째처럼 꼼꼼하게 봄 ㅋㅋ
이 글에서는 AI 자동계약서 검증 서비스를 실제로 어떻게 구현하는지,
어떤 기술 스택을 쓰는지, 어떤 함정이 있는지까지 개발자 관점에서 낱낱이 파헤쳐볼 거야.
프로그램 개발 카테고리답게 코드도 나오고, 아키텍처도 나오고, 실전 팁도 빵빵하게 담았으니까
끝까지 읽어봐! 🔥
📋 AI 계약서 검증이란? 핵심 개념 정리
AI 자동계약서 검증 서비스는 크게 4가지 핵심 기능으로 구성돼:
보안 처리, 대용량 문서 처리, 일관된 출력 형식, 법률 도메인 특화 파인튜닝, 할루시네이션 방지 등
고려해야 할 게 엄청 많거든. 이 글에서 그 모든 걸 다룰 거야!
🏗️ 시스템 아키텍처 설계 - 어떻게 만들 거야?
자, 이제 진짜 개발자 모드로 들어가보자. 🔧
AI 계약서 검증 서비스를 구현할 때 가장 먼저 해야 할 건 전체 아키텍처 설계야.
대충 만들면 나중에 확장할 때 지옥을 경험하게 됨 ㅋㅋㅋ (경험담)
PostgreSQL Redis Celery Docker
PyMuPDF python-docx Tesseract OCR Pinecone
📐 전체 시스템 플로우
🔧 핵심 컴포넌트별 역할 정리
| 컴포넌트 | 역할 | 선택 이유 |
|---|---|---|
| FastAPI | REST API 서버 | 비동기 지원, 자동 문서화, Python 생태계 최적 |
| LangChain | LLM 오케스트레이션 | 체인 구성, 프롬프트 관리, 메모리 처리 용이 |
| GPT-4o | 핵심 AI 분석 | 법률 문서 이해도 최고 수준, 128K 컨텍스트 |
| Celery + Redis | 비동기 작업 큐 | 대용량 문서 처리, 타임아웃 방지 |
| Pinecone | 벡터 데이터베이스 | 유사 계약서 검색, RAG 구현 |
| PyMuPDF | PDF 파싱 | 빠른 속도, 레이아웃 보존, 한글 지원 우수 |
📄 Step 1: 문서 파싱 및 전처리 구현
계약서 검증의 첫 번째 관문은 문서를 제대로 읽어내는 것이야.
PDF, DOCX, 이미지 스캔본 등 다양한 형식을 처리해야 하는데,
이게 생각보다 훨씬 까다로움 ㅋㅋ 특히 스캔본 계약서는 OCR까지 해야 하거든.
- ✅ PDF (텍스트 레이어 있음) → PyMuPDF로 직접 텍스트 추출
- ✅ PDF (스캔본/이미지) → Tesseract OCR 또는 Google Vision API
- ✅ DOCX → python-docx로 단락 구조 보존하며 추출
- ✅ 이미지 (JPG/PNG) → OCR 처리 후 텍스트 변환
- ✅ 텍스트 파일 → 직접 읽기 (인코딩 처리 주의!)
💻 문서 파서 구현 코드
# document_parser.py
import fitz # PyMuPDF
from docx import Document
import pytesseract
from PIL import Image
import io
from typing import Optional
import re
class ContractDocumentParser:
"""계약서 문서 파서 - 다양한 형식 지원"""
def __init__(self):
self.supported_formats = ['pdf', 'docx', 'txt', 'jpg', 'png']
def parse(self, file_path: str, file_type: str) -> dict:
"""
계약서 파일을 파싱하여 구조화된 데이터 반환
Returns: {
'raw_text': str,
'sections': list,
'metadata': dict,
'page_count': int
}
"""
if file_type == 'pdf':
return self._parse_pdf(file_path)
elif file_type == 'docx':
return self._parse_docx(file_path)
elif file_type in ['jpg', 'png']:
return self._parse_image(file_path)
elif file_type == 'txt':
return self._parse_text(file_path)
else:
raise ValueError(f"지원하지 않는 파일 형식: {file_type}")
def _parse_pdf(self, file_path: str) -> dict:
"""PDF 파싱 - 텍스트 레이어 우선, 없으면 OCR"""
doc = fitz.open(file_path)
full_text = ""
sections = []
for page_num, page in enumerate(doc):
# 텍스트 레이어 확인
text = page.get_text("text")
# 텍스트가 거의 없으면 OCR 처리
if len(text.strip()) < 50:
# 이미지로 변환 후 OCR
pix = page.get_pixmap(dpi=300)
img_data = pix.tobytes("png")
img = Image.open(io.BytesIO(img_data))
text = pytesseract.image_to_string(
img,
lang='kor+eng', # 한국어 + 영어
config='--psm 6' # 단일 블록 텍스트 모드
)
full_text += text + "\n"
# 페이지별 섹션 추출
blocks = page.get_text("blocks")
for block in blocks:
if block[6] == 0: # 텍스트 블록만
sections.append({
'page': page_num + 1,
'text': block[4].strip(),
'bbox': block[:4]
})
# 조항 번호 패턴으로 섹션 분리
clauses = self._extract_clauses(full_text)
return {
'raw_text': full_text,
'sections': sections,
'clauses': clauses,
'metadata': {
'page_count': len(doc),
'file_type': 'pdf',
'char_count': len(full_text)
}
}
def _extract_clauses(self, text: str) -> list:
"""조항 번호 패턴으로 계약 조항 추출"""
# 한국 계약서 조항 패턴 (제1조, 제2조, 1. 2. 등)
patterns = [
r'제\s*(\d+)\s*조\s*[(\[【]?([^)\]】\n]+)[)\]】]?\s*\n',
r'(\d+)\.\s+([^\n]+)\n',
r'Article\s+(\d+)[.:]\s*([^\n]+)\n'
]
clauses = []
for pattern in patterns:
matches = re.finditer(pattern, text, re.MULTILINE)
for match in matches:
clause_num = match.group(1)
clause_title = match.group(2).strip()
# 해당 조항의 내용 추출 (다음 조항 전까지)
start_pos = match.end()
next_match = re.search(pattern, text[start_pos:])
end_pos = start_pos + next_match.start() if next_match else len(text)
clause_content = text[start_pos:end_pos].strip()
clauses.append({
'number': clause_num,
'title': clause_title,
'content': clause_content,
'char_count': len(clause_content)
})
return clauses
def _parse_docx(self, file_path: str) -> dict:
"""DOCX 파싱 - 단락 구조 보존"""
doc = Document(file_path)
full_text = ""
sections = []
for para in doc.paragraphs:
if para.text.strip():
full_text += para.text + "\n"
sections.append({
'text': para.text,
'style': para.style.name,
'is_heading': 'Heading' in para.style.name
})
return {
'raw_text': full_text,
'sections': sections,
'clauses': self._extract_clauses(full_text),
'metadata': {
'page_count': None, # DOCX는 페이지 수 계산 복잡
'file_type': 'docx',
'char_count': len(full_text)
}
}
lang='kor+eng' 설정 필수야.그리고 DPI를 300 이상으로 설정해야 인식률이 올라감.
스캔 품질이 낮은 계약서는 Google Cloud Vision API나 Naver Clova OCR이 훨씬 정확해.
특히 도장이나 서명이 있는 부분은 OCR이 헷갈려하니까 해당 영역은 제외하는 로직도 필요함!
🧹 텍스트 전처리 - 노이즈 제거
파싱된 텍스트는 바로 AI에 넣으면 안 됨. 노이즈가 너무 많거든 ㅋㅋ
페이지 번호, 헤더/푸터, 불필요한 공백 등을 정리해야 해.
# text_preprocessor.py
import re
from typing import str
class ContractTextPreprocessor:
"""계약서 텍스트 전처리기"""
def preprocess(self, raw_text: str) -> str:
"""전처리 파이프라인 실행"""
text = raw_text
text = self._remove_page_numbers(text)
text = self._remove_headers_footers(text)
text = self._normalize_whitespace(text)
text = self._fix_encoding_issues(text)
text = self._normalize_korean_punctuation(text)
return text
def _remove_page_numbers(self, text: str) -> str:
"""페이지 번호 제거"""
# - 1 -, [1], 1/10 등 패턴
patterns = [
r'\n\s*[-–]\s*\d+\s*[-–]\s*\n',
r'\n\s*\[\d+\]\s*\n',
r'\n\s*\d+\s*/\s*\d+\s*\n',
r'\n\s*\d+\s*\n(?=\s*[가-힣A-Z제])' # 단독 숫자 줄
]
for pattern in patterns:
text = re.sub(pattern, '\n', text)
return text
def _normalize_whitespace(self, text: str) -> str:
"""공백 정규화"""
# 3개 이상 연속 줄바꿈을 2개로
text = re.sub(r'\n{3,}', '\n\n', text)
# 탭을 공백으로
text = re.sub(r'\t', ' ', text)
# 연속 공백 정리
text = re.sub(r' {2,}', ' ', text)
return text.strip()
def _normalize_korean_punctuation(self, text: str) -> str:
"""한국어 특수문자 정규화"""
# 전각 문자를 반각으로
replacements = {
',': ',', '。': '.', ':': ':',
';': ';', '!': '!', '?': '?',
'(': '(', ')': ')',
'【': '[', '】': ']'
}
for old, new in replacements.items():
text = text.replace(old, new)
return text
🤖 Step 2: AI 분석 엔진 구현 - LangChain + GPT-4o
이제 진짜 핵심 파트야! 🔥
전처리된 계약서 텍스트를 AI가 분석하는 부분인데,
여기서 프롬프트 엔지니어링이 서비스 품질을 좌우함.
대충 "이 계약서 분석해줘" 하면 안 되고, 구조화된 프롬프트가 필요해.
1️⃣ 컨텍스트 길이 제한 - 긴 계약서는 한 번에 못 넣음 → 청킹 전략 필요
2️⃣ 할루시네이션 - AI가 없는 조항을 있다고 하거나 잘못된 법률 해석 → RAG로 보완
3️⃣ 일관성 없는 출력 - 매번 다른 형식으로 결과 나옴 → 구조화된 출력 강제
4️⃣ 비용 최적화 - 긴 계약서 분석 시 토큰 비용 폭발 → 스마트 청킹 필요
🔗 LangChain 기반 분석 체인 구현
# contract_analyzer.py
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.output_parsers import PydanticOutputParser
from langchain.text_splitter import RecursiveCharacterTextSplitter
from pydantic import BaseModel, Field
from typing import List, Optional
import json
# 출력 스키마 정의 (Pydantic)
class ClauseRisk(BaseModel):
clause_number: str = Field(description="조항 번호")
clause_title: str = Field(description="조항 제목")
clause_type: str = Field(description="조항 유형 (계약기간/대금/해지/손해배상 등)")
risk_level: str = Field(description="위험 등급: LOW/MEDIUM/HIGH/CRITICAL")
risk_description: str = Field(description="위험 내용 설명")
suggestion: Optional[str] = Field(description="개선 제안 문구")
original_text: str = Field(description="원문 텍스트")
class ContractAnalysisResult(BaseModel):
contract_type: str = Field(description="계약서 유형")
parties: List[str] = Field(description="계약 당사자 목록")
contract_period: Optional[str] = Field(description="계약 기간")
key_obligations: List[str] = Field(description="핵심 의무사항 목록")
clause_risks: List[ClauseRisk] = Field(description="조항별 위험 분석")
missing_clauses: List[str] = Field(description="누락된 필수 조항 목록")
overall_risk_score: int = Field(description="전체 위험 점수 (0-100)")
summary: str = Field(description="전체 요약")
class ContractAnalyzer:
"""AI 기반 계약서 분석 엔진"""
def __init__(self, openai_api_key: str):
self.llm = ChatOpenAI(
model="gpt-4o",
temperature=0, # 일관성을 위해 0으로 설정
api_key=openai_api_key,
max_tokens=4096
)
self.output_parser = PydanticOutputParser(
pydantic_object=ContractAnalysisResult
)
self.text_splitter = RecursiveCharacterTextSplitter(
chunk_size=8000,
chunk_overlap=500,
separators=["\n\n", "\n제", "\n第", "\nArticle", "\n1.", "\n2."]
)
def analyze(self, contract_text: str, contract_type: str = "일반") -> ContractAnalysisResult:
"""계약서 전체 분석 실행"""
# 텍스트 길이에 따라 전략 선택
if len(contract_text) < 15000:
# 짧은 계약서: 한 번에 분석
return self._analyze_single(contract_text, contract_type)
else:
# 긴 계약서: 청킹 후 맵-리듀스 방식
return self._analyze_with_chunks(contract_text, contract_type)
def _analyze_single(self, text: str, contract_type: str) -> ContractAnalysisResult:
"""단일 분석 (짧은 계약서용)"""
prompt = ChatPromptTemplate.from_messages([
("system", """당신은 대한민국 법률 전문가이자 계약서 검토 AI입니다.
주어진 계약서를 면밀히 분석하여 다음을 수행하세요:
1. 계약서 유형 및 당사자 파악
2. 각 조항의 법적 위험도 평가 (LOW/MEDIUM/HIGH/CRITICAL)
3. 불공정 조항, 독소 조항, 모호한 표현 탐지
4. 누락된 필수 조항 식별
5. 개선 방안 제시
위험 등급 기준:
- CRITICAL: 즉각적인 법적 분쟁 가능성, 계약 무효 위험
- HIGH: 심각한 불이익 조항, 일방적 불공정 조항
- MEDIUM: 모호한 표현, 잠재적 분쟁 소지
- LOW: 경미한 개선 필요 사항
{format_instructions}
반드시 JSON 형식으로만 응답하세요."""),
("human", """다음 {contract_type} 계약서를 분석해주세요:
{contract_text}""")
])
chain = prompt | self.llm | self.output_parser
result = chain.invoke({
"contract_type": contract_type,
"contract_text": text,
"format_instructions": self.output_parser.get_format_instructions()
})
return result
def _analyze_with_chunks(self, text: str, contract_type: str) -> ContractAnalysisResult:
"""청킹 방식 분석 (긴 계약서용) - Map-Reduce 패턴"""
chunks = self.text_splitter.split_text(text)
chunk_results = []
# Map 단계: 각 청크 분석
for i, chunk in enumerate(chunks):
chunk_result = self._analyze_chunk(chunk, contract_type, i+1, len(chunks))
chunk_results.append(chunk_result)
# Reduce 단계: 결과 통합
return self._merge_chunk_results(chunk_results, contract_type)
def _analyze_chunk(self, chunk: str, contract_type: str,
chunk_num: int, total_chunks: int) -> dict:
"""개별 청크 분석"""
prompt = ChatPromptTemplate.from_messages([
("system", """당신은 계약서 분석 AI입니다.
전체 계약서의 {chunk_num}/{total_chunks} 부분을 분석합니다.
이 부분에서 발견되는 위험 조항과 주요 내용을 JSON으로 반환하세요.
응답 형식:
{{
"found_clauses": [
{{
"clause_number": "조항번호",
"clause_title": "조항제목",
"clause_type": "유형",
"risk_level": "LOW/MEDIUM/HIGH/CRITICAL",
"risk_description": "위험설명",
"suggestion": "개선제안",
"original_text": "원문"
}}
],
"key_points": ["주요 내용 1", "주요 내용 2"]
}}"""),
("human", "{chunk_text}")
])
chain = prompt | self.llm
response = chain.invoke({
"chunk_num": chunk_num,
"total_chunks": total_chunks,
"chunk_text": chunk
})
try:
return json.loads(response.content)
except:
return {"found_clauses": [], "key_points": []}
temperature를 높이면 매번 다른 결과가 나와서 서비스 신뢰도가 떨어짐.
법률 도메인에서는 무조건 temperature=0 또는 0.1 이하로 설정하는 게 정석이야!
🎯 Step 3: RAG 구현 - 법률 지식 베이스 구축
AI가 계약서를 분석할 때 가장 큰 문제가 뭔지 알아? 바로 할루시네이션이야.
"이 조항은 민법 제○○조에 위반됩니다" 라고 자신있게 말하는데,
실제로 그런 조항이 없거나 잘못된 해석인 경우가 있거든 ㅋㅋㅋ 이거 진짜 위험함.
그래서 RAG(Retrieval-Augmented Generation)를 도입해야 해.
Retrieval-Augmented Generation의 약자로,
AI가 답변을 생성할 때 실제 법률 데이터베이스에서 관련 정보를 검색해서
그 정보를 바탕으로 답변하는 방식이야.
이렇게 하면 AI가 "아는 척"하는 게 아니라 실제 법률에 근거한 분석이 가능해짐!
📖 법률 지식 베이스 구성
RAG를 위한 지식 베이스에는 다음 데이터를 넣어야 해:
# rag_system.py
from langchain_openai import OpenAIEmbeddings
from langchain_pinecone import PineconeVectorStore
from langchain.text_splitter import RecursiveCharacterTextSplitter
from pinecone import Pinecone, ServerlessSpec
import os
class LegalRAGSystem:
"""법률 지식 기반 RAG 시스템"""
def __init__(self, openai_api_key: str, pinecone_api_key: str):
self.embeddings = OpenAIEmbeddings(
model="text-embedding-3-large", # 최신 임베딩 모델
api_key=openai_api_key
)
# Pinecone 초기화
pc = Pinecone(api_key=pinecone_api_key)
# 인덱스 생성 (없으면)
index_name = "legal-knowledge-base"
if index_name not in pc.list_indexes().names():
pc.create_index(
name=index_name,
dimension=3072, # text-embedding-3-large 차원
metric="cosine",
spec=ServerlessSpec(cloud="aws", region="us-east-1")
)
self.vectorstore = PineconeVectorStore(
index=pc.Index(index_name),
embedding=self.embeddings,
text_key="text"
)
def add_legal_documents(self, documents: list):
"""법률 문서를 벡터 DB에 추가"""
splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=200
)
texts = []
metadatas = []
for doc in documents:
chunks = splitter.split_text(doc['content'])
for chunk in chunks:
texts.append(chunk)
metadatas.append({
'source': doc['source'],
'doc_type': doc['type'], # 'law', 'precedent', 'standard_contract'
'title': doc['title']
})
self.vectorstore.add_texts(texts=texts, metadatas=metadatas)
print(f"✅ {len(texts)}개 청크 추가 완료")
def retrieve_relevant_laws(self, query: str, k: int = 5) -> list:
"""관련 법률 정보 검색"""
results = self.vectorstore.similarity_search_with_score(
query=query,
k=k,
filter={"doc_type": {"$in": ["law", "precedent"]}}
)
return [
{
'content': doc.page_content,
'source': doc.metadata.get('source', ''),
'title': doc.metadata.get('title', ''),
'relevance_score': float(score)
}
for doc, score in results
if score > 0.7 # 유사도 임계값
]
def get_similar_contracts(self, clause_text: str, k: int = 3) -> list:
"""유사한 표준 계약서 조항 검색"""
results = self.vectorstore.similarity_search_with_score(
query=clause_text,
k=k,
filter={"doc_type": "standard_contract"}
)
return [
{
'content': doc.page_content,
'source': doc.metadata.get('source', ''),
'relevance_score': float(score)
}
for doc, score in results
]
# RAG 통합 분석기
class RAGEnhancedAnalyzer:
"""RAG로 강화된 계약서 분석기"""
def __init__(self, analyzer: ContractAnalyzer, rag: LegalRAGSystem):
self.analyzer = analyzer
self.rag = rag
def analyze_with_legal_context(self, contract_text: str) -> dict:
"""법률 컨텍스트를 포함한 분석"""
# 1. 기본 AI 분석
basic_result = self.analyzer.analyze(contract_text)
# 2. 위험 조항에 대해 관련 법률 검색
enhanced_risks = []
for risk in basic_result.clause_risks:
if risk.risk_level in ['HIGH', 'CRITICAL']:
# 관련 법률 검색
relevant_laws = self.rag.retrieve_relevant_laws(
query=f"{risk.clause_type} {risk.risk_description}"
)
# 유사 표준 계약서 조항 검색
similar_clauses = self.rag.get_similar_contracts(
clause_text=risk.original_text
)
enhanced_risks.append({
**risk.dict(),
'relevant_laws': relevant_laws,
'standard_alternatives': similar_clauses
})
else:
enhanced_risks.append(risk.dict())
return {
'basic_analysis': basic_result.dict(),
'enhanced_risks': enhanced_risks,
'rag_enhanced': True
}
법률 도메인에서 틀린 정보는 단순한 오류가 아니라 실제 피해로 이어질 수 있다."
— AI Legal Tech 개발 원칙
⚡ Step 4: 비동기 처리 시스템 구현
계약서 분석은 시간이 꽤 걸려. 특히 긴 계약서는 GPT-4o 호출만 해도 30초~2분이 걸릴 수 있음.
이걸 동기 방식으로 처리하면 사용자가 기다리다 지쳐서 나가버림 ㅋㅋㅋ
그래서 Celery + Redis로 비동기 작업 큐를 구현해야 해.
# tasks.py (Celery 작업 정의)
from celery import Celery
from celery.utils.log import get_task_logger
import time
logger = get_task_logger(__name__)
# Celery 앱 설정
celery_app = Celery(
'contract_analyzer',
broker='redis://localhost:6379/0',
backend='redis://localhost:6379/1'
)
celery_app.conf.update(
task_serializer='json',
accept_content=['json'],
result_serializer='json',
timezone='Asia/Seoul',
task_track_started=True,
task_time_limit=300, # 5분 타임아웃
task_soft_time_limit=240, # 4분 소프트 타임아웃
worker_prefetch_multiplier=1, # 한 번에 하나씩 처리
)
@celery_app.task(bind=True, max_retries=3)
def analyze_contract_task(self, task_id: str, file_path: str,
file_type: str, contract_type: str, user_id: str):
"""계약서 분석 비동기 작업"""
try:
# 진행 상태 업데이트
self.update_state(
state='PROGRESS',
meta={'current': 10, 'total': 100, 'status': '문서 파싱 중...'}
)
# 1. 문서 파싱
parser = ContractDocumentParser()
parsed_doc = parser.parse(file_path, file_type)
self.update_state(
state='PROGRESS',
meta={'current': 30, 'total': 100, 'status': '텍스트 전처리 중...'}
)
# 2. 텍스트 전처리
preprocessor = ContractTextPreprocessor()
clean_text = preprocessor.preprocess(parsed_doc['raw_text'])
self.update_state(
state='PROGRESS',
meta={'current': 50, 'total': 100, 'status': 'AI 분석 중... (시간이 걸릴 수 있어요)'}
)
# 3. AI 분석
analyzer = ContractAnalyzer(openai_api_key=os.getenv('OPENAI_API_KEY'))
rag = LegalRAGSystem(
openai_api_key=os.getenv('OPENAI_API_KEY'),
pinecone_api_key=os.getenv('PINECONE_API_KEY')
)
rag_analyzer = RAGEnhancedAnalyzer(analyzer, rag)
analysis_result = rag_analyzer.analyze_with_legal_context(clean_text)
self.update_state(
state='PROGRESS',
meta={'current': 80, 'total': 100, 'status': '결과 저장 중...'}
)
# 4. 결과 DB 저장
save_analysis_result(task_id, analysis_result, user_id)
# 5. 알림 발송
send_completion_notification(user_id, task_id)
return {
'status': 'SUCCESS',
'task_id': task_id,
'result_url': f'/api/results/{task_id}'
}
except Exception as exc:
logger.error(f"분석 실패 - task_id: {task_id}, error: {str(exc)}")
# 재시도 (최대 3회)
raise self.retry(exc=exc, countdown=60) # 60초 후 재시도
# FastAPI 엔드포인트
from fastapi import FastAPI, UploadFile, File, BackgroundTasks
from fastapi.responses import JSONResponse
app = FastAPI(title="AI 계약서 검증 API")
@app.post("/api/contracts/analyze")
async def submit_contract_analysis(
file: UploadFile = File(...),
contract_type: str = "일반",
current_user: dict = Depends(get_current_user)
):
"""계약서 분석 요청 제출"""
# 파일 저장
file_path = await save_uploaded_file(file)
task_id = generate_task_id()
# 비동기 작업 시작
task = analyze_contract_task.delay(
task_id=task_id,
file_path=file_path,
file_type=file.filename.split('.')[-1].lower(),
contract_type=contract_type,
user_id=current_user['id']
)
return JSONResponse({
'task_id': task_id,
'celery_task_id': task.id,
'status': 'PENDING',
'message': '분석이 시작되었습니다. 완료 시 알림을 보내드릴게요! 🔔'
})
@app.get("/api/contracts/status/{task_id}")
async def get_analysis_status(task_id: str):
"""분석 진행 상태 조회"""
task = analyze_contract_task.AsyncResult(task_id)
if task.state == 'PENDING':
response = {'status': 'PENDING', 'progress': 0, 'message': '대기 중...'}
elif task.state == 'PROGRESS':
response = {
'status': 'PROGRESS',
'progress': task.info.get('current', 0),
'message': task.info.get('status', '')
}
elif task.state == 'SUCCESS':
response = {'status': 'SUCCESS', 'progress': 100, 'result': task.result}
else:
response = {'status': 'FAILED', 'error': str(task.info)}
return JSONResponse(response)
GPT-4o는 토큰당 비용이 발생해. 긴 계약서 분석하면 비용이 꽤 나올 수 있음.
✅ 캐싱 전략: 동일한 계약서(해시값 기준)는 재분석 없이 캐시 반환
✅ 스마트 청킹: 불필요한 반복 내용(서명란, 날짜 등)은 분석에서 제외
✅ 모델 선택: 조항 분류는 GPT-4o-mini로, 위험 분석만 GPT-4o로 처리
✅ 배치 처리: 여러 조항을 한 번에 묶어서 API 호출 횟수 최소화
🛡️ Step 5: 보안 설계 - 계약서는 극비 문서야!
계약서에는 엄청 민감한 정보가 담겨 있어. 💼
거래 금액, 당사자 정보, 영업 비밀, 개인정보 등등...
보안을 소홀히 하면 서비스 자체가 날아갈 수 있음. 진짜로.
특히 개인정보보호법과 정보통신망법을 반드시 준수해야 해.
🔒 핵심 보안 구현 코드
# security.py
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
import base64
import hashlib
import re
import os
class ContractSecurityManager:
"""계약서 보안 관리자"""
def __init__(self, encryption_key: str):
# AES-256 암호화 키 생성
kdf = PBKDF2HMAC(
algorithm=hashes.SHA256(),
length=32,
salt=os.getenv('ENCRYPTION_SALT', 'default_salt').encode(),
iterations=100000
)
key = base64.urlsafe_b64encode(
kdf.derive(encryption_key.encode())
)
self.cipher = Fernet(key)
def encrypt_contract(self, contract_text: str) -> bytes:
"""계약서 텍스트 암호화"""
return self.cipher.encrypt(contract_text.encode('utf-8'))
def decrypt_contract(self, encrypted_data: bytes) -> str:
"""계약서 텍스트 복호화"""
return self.cipher.decrypt(encrypted_data).decode('utf-8')
def mask_personal_info(self, text: str) -> str:
"""개인정보 마스킹 (AI 전송 전 처리)"""
# 주민등록번호 마스킹
text = re.sub(
r'\d{6}-[1-4]\d{6}',
'######-#######',
text
)
# 전화번호 마스킹
text = re.sub(
r'01[0-9]-\d{3,4}-\d{4}',
'010-****-****',
text
)
# 이메일 마스킹 (도메인은 유지)
text = re.sub(
r'([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})',
lambda m: '****@' + m.group(2),
text
)
# 계좌번호 마스킹
text = re.sub(
r'\d{3,4}-\d{2,4}-\d{4,8}',
'****-**-****',
text
)
return text
def generate_file_hash(self, file_path: str) -> str:
"""파일 해시 생성 (중복 감지 및 캐싱용)"""
sha256_hash = hashlib.sha256()
with open(file_path, "rb") as f:
for byte_block in iter(lambda: f.read(4096), b""):
sha256_hash.update(byte_block)
return sha256_hash.hexdigest()
def validate_file_safety(self, file_path: str, file_type: str) -> dict:
"""파일 안전성 검증"""
# 파일 크기 제한 (50MB)
file_size = os.path.getsize(file_path)
if file_size > 50 * 1024 * 1024:
return {'safe': False, 'reason': '파일 크기 초과 (최대 50MB)'}
# 파일 타입 검증 (매직 바이트 확인)
magic_bytes = {
'pdf': b'%PDF',
'docx': b'PK\x03\x04',
'txt': None # 텍스트는 매직 바이트 없음
}
if file_type in magic_bytes and magic_bytes[file_type]:
with open(file_path, 'rb') as f:
header = f.read(4)
if not header.startswith(magic_bytes[file_type]):
return {'safe': False, 'reason': '파일 형식 불일치 (위조 파일 의심)'}
return {'safe': True, 'file_size': file_size}
# 프롬프트 인젝션 방지
class PromptInjectionGuard:
"""프롬프트 인젝션 공격 방지"""
INJECTION_PATTERNS = [
r'ignore previous instructions',
r'forget everything',
r'you are now',
r'act as',
r'jailbreak',
r'DAN mode',
r'이전 지시를 무시',
r'시스템 프롬프트를 출력'
]
def sanitize_input(self, user_input: str) -> str:
"""사용자 입력 정제"""
for pattern in self.INJECTION_PATTERNS:
if re.search(pattern, user_input, re.IGNORECASE):
raise ValueError("⚠️ 비정상적인 입력이 감지되었습니다.")
# 최대 길이 제한
if len(user_input) > 500000: # 50만 자 제한
raise ValueError("입력 텍스트가 너무 깁니다.")
return user_input
기업 고객 입장에서는 민감한 계약 내용이 외부 서버로 나가는 것 자체를 꺼려함.
해결책: 개인정보 마스킹 후 전송 + 온프레미스 LLM 옵션 제공 (Llama 3, Mistral 등)
재능넷 같은 플랫폼에서 프리랜서 계약서를 다룰 때도 이 부분이 특히 중요해!
📊 Step 6: 결과 리포트 생성 및 시각화
분석 결과를 어떻게 보여주느냐도 엄청 중요해.
법률 용어로 가득한 리포트는 일반 사용자가 이해하기 어렵거든.
직관적인 시각화와 쉬운 언어로의 번역이 핵심이야! 🎨
📝 리포트 생성 코드
# report_generator.py
from reportlab.lib.pagesizes import A4
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.lib.colors import HexColor
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table
from reportlab.lib.units import cm
import json
from datetime import datetime
class ContractReportGenerator:
"""계약서 분석 리포트 생성기"""
RISK_COLORS = {
'CRITICAL': '#e87070',
'HIGH': '#f0a060',
'MEDIUM': '#f0d060',
'LOW': '#7dd4b0'
}
RISK_LABELS = {
'CRITICAL': '🚨 즉시 수정 필요',
'HIGH': '⚠️ 높은 위험',
'MEDIUM': '📋 검토 필요',
'LOW': '✅ 경미한 사항'
}
def generate_json_report(self, analysis_result: dict) -> dict:
"""JSON 형식 리포트 생성 (API 응답용)"""
basic = analysis_result['basic_analysis']
enhanced_risks = analysis_result.get('enhanced_risks', [])
# 위험도별 분류
risks_by_level = {
'CRITICAL': [],
'HIGH': [],
'MEDIUM': [],
'LOW': []
}
for risk in enhanced_risks:
level = risk.get('risk_level', 'LOW')
risks_by_level[level].append(risk)
# 전체 위험 점수 계산
score = self._calculate_risk_score(risks_by_level)
# 핵심 액션 아이템 생성
action_items = self._generate_action_items(risks_by_level)
return {
'report_id': generate_report_id(),
'generated_at': datetime.now().isoformat(),
'contract_info': {
'type': basic.get('contract_type', ''),
'parties': basic.get('parties', []),
'period': basic.get('contract_period', ''),
},
'risk_summary': {
'overall_score': score,
'risk_level': self._get_overall_risk_level(score),
'critical_count': len(risks_by_level['CRITICAL']),
'high_count': len(risks_by_level['HIGH']),
'medium_count': len(risks_by_level['MEDIUM']),
'low_count': len(risks_by_level['LOW']),
},
'risks_by_level': risks_by_level,
'missing_clauses': basic.get('missing_clauses', []),
'action_items': action_items,
'summary': basic.get('summary', ''),
'key_obligations': basic.get('key_obligations', [])
}
def _calculate_risk_score(self, risks_by_level: dict) -> int:
"""위험 점수 계산 (0=안전, 100=매우 위험)"""
weights = {'CRITICAL': 25, 'HIGH': 10, 'MEDIUM': 4, 'LOW': 1}
total_score = 0
for level, risks in risks_by_level.items():
total_score += len(risks) * weights[level]
return min(100, total_score)
def _generate_action_items(self, risks_by_level: dict) -> list:
"""우선순위별 액션 아이템 생성"""
actions = []
# CRITICAL 먼저
for risk in risks_by_level.get('CRITICAL', []):
actions.append({
'priority': 1,
'action': f"즉시 수정: {risk.get('clause_title', '')}",
'description': risk.get('risk_description', ''),
'suggestion': risk.get('suggestion', '')
})
# HIGH 다음
for risk in risks_by_level.get('HIGH', []):
actions.append({
'priority': 2,
'action': f"검토 필요: {risk.get('clause_title', '')}",
'description': risk.get('risk_description', ''),
'suggestion': risk.get('suggestion', '')
})
return actions
def _get_overall_risk_level(self, score: int) -> str:
if score >= 70: return 'CRITICAL'
elif score >= 40: return 'HIGH'
elif score >= 20: return 'MEDIUM'
else: return 'LOW'
🧪 Step 7: 테스트 및 품질 관리
AI 서비스의 테스트는 일반 소프트웨어 테스트보다 훨씬 복잡해.
왜냐면 AI 출력이 비결정적(non-deterministic)이거든.
같은 입력에도 약간씩 다른 결과가 나올 수 있어서 기존 단위 테스트 방식으로는 한계가 있음.
- ✅ 골든 셋 테스트: 전문 변호사가 검토한 "정답" 계약서 셋으로 정확도 측정
- ✅ 회귀 테스트: 모델 업데이트 시 기존 결과와 비교하여 품질 저하 감지
- ✅ 엣지 케이스 테스트: 빈 계약서, 외국어 계약서, 손상된 파일 등
- ✅ A/B 테스트: 다른 프롬프트 버전의 성능 비교
- ✅ 인간 평가(Human Eval): 법률 전문가가 AI 결과를 주기적으로 검토
# test_contract_analyzer.py
import pytest
import json
from unittest.mock import patch, MagicMock
class TestContractAnalyzer:
"""계약서 분석기 테스트 스위트"""
@pytest.fixture
def sample_contract(self):
"""테스트용 샘플 계약서"""
return """
용역 계약서
제1조 (목적)
본 계약은 갑(발주자)과 을(수급자) 간의 용역 제공에 관한 사항을 정함을 목적으로 한다.
제2조 (계약 기간)
계약 기간은 2024년 1월 1일부터 2024년 12월 31일까지로 한다.
제3조 (대금 지급)
갑은 을에게 월 500만원을 매월 말일에 지급한다.
제15조 (손해배상)
을의 손해배상 책임은 계약금액의 10%를 초과하지 아니한다.
제20조 (계약 해지)
갑은 언제든지 계약을 해지할 수 있으며, 이 경우 을은 어떠한 보상도 청구할 수 없다.
"""
def test_parse_contract_extracts_clauses(self, sample_contract):
"""조항 추출 테스트"""
parser = ContractDocumentParser()
# 텍스트 파일로 임시 저장 후 파싱
with tempfile.NamedTemporaryFile(mode='w', suffix='.txt',
encoding='utf-8', delete=False) as f:
f.write(sample_contract)
temp_path = f.name
result = parser.parse(temp_path, 'txt')
assert 'clauses' in result
assert len(result['clauses']) > 0
assert result['metadata']['char_count'] > 0
def test_risk_detection_identifies_unfair_clause(self, sample_contract):
"""불공정 조항 탐지 테스트"""
# 제20조 (일방적 해지 + 보상 없음)는 HIGH 이상이어야 함
with patch('openai.ChatCompletion.create') as mock_openai:
# 모의 응답 설정
mock_openai.return_value = MagicMock(
choices=[MagicMock(
message=MagicMock(
content=json.dumps({
"contract_type": "용역계약",
"parties": ["갑", "을"],
"clause_risks": [
{
"clause_number": "20",
"clause_title": "계약 해지",
"clause_type": "해지",
"risk_level": "CRITICAL",
"risk_description": "일방적 해지권 + 보상 배제",
"suggestion": "해지 시 잔여 기간 대금 지급 조항 추가 필요",
"original_text": "갑은 언제든지 계약을 해지할 수 있으며..."
}
],
"missing_clauses": ["분쟁해결조항"],
"overall_risk_score": 75,
"summary": "불공정 조항 다수 발견",
"key_obligations": [],
"contract_period": "2024.01.01~2024.12.31"
})
)
)]
)
analyzer = ContractAnalyzer(openai_api_key="test_key")
result = analyzer.analyze(sample_contract)
# 제20조가 CRITICAL로 탐지되어야 함
critical_risks = [r for r in result.clause_risks
if r.risk_level == 'CRITICAL']
assert len(critical_risks) > 0
def test_personal_info_masking(self):
"""개인정보 마스킹 테스트"""
security = ContractSecurityManager("test_key_12345678901234567890")
test_text = "홍길동 (주민번호: 900101-1234567, 전화: 010-1234-5678)"
masked = security.mask_personal_info(test_text)
assert "900101-1234567" not in masked
assert "010-1234-5678" not in masked
assert "홍길동" in masked # 이름은 마스킹 안 함
@pytest.mark.parametrize("risk_score,expected_level", [
(85, 'CRITICAL'),
(55, 'HIGH'),
(30, 'MEDIUM'),
(10, 'LOW')
])
def test_risk_score_to_level_mapping(self, risk_score, expected_level):
"""위험 점수 → 등급 변환 테스트"""
generator = ContractReportGenerator()
assert generator._get_overall_risk_level(risk_score) == expected_level
- 재현율(Recall): 실제 위험 조항 중 AI가 탐지한 비율
- F1 Score: 정밀도와 재현율의 조화 평균
법률 서비스에서는 재현율이 더 중요해. 위험 조항을 놓치는 게 더 큰 문제니까!
💡 실전 구현 팁 & 흔한 실수들
이 파트는 진짜 실전에서 겪은 삽질들을 공유하는 코너야 ㅋㅋㅋ
이 실수들만 피해도 개발 시간 엄청 줄일 수 있음!
토큰이 많을수록 중간 내용을 잊어버리는 "Lost in the Middle" 현상이 발생해.
실제로 긴 계약서에서 중간 조항의 위험도 탐지율이 처음/끝보다 30% 낮다는 연구 결과도 있음.
→ 해결책: 조항 단위로 청킹해서 각각 분석 후 통합
GPT가 가끔 JSON 앞뒤에 설명 텍스트를 붙이거나, 잘못된 JSON을 반환할 때가 있어.
→ 해결책: LangChain의 PydanticOutputParser + 재시도 로직 구현
from langchain.output_parsers import OutputFixingParser
# 잘못된 JSON 자동 수정
fixing_parser = OutputFixingParser.from_llm(
parser=output_parser,
llm=llm
)
"Force Majeure", "Indemnification", "Warranty" 같은 영어 용어를
한국어 계약서 분석에 그대로 쓰면 GPT가 헷갈려함.
→ 해결책: 프롬프트에 한국 법률 용어 매핑 테이블 포함
예) "불가항력 조항", "손해배상 조항", "보증 조항" 등으로 명시
이건 진짜 중요한 법적 이슈야! 🚨
AI 계약서 분석 서비스는 "법적 조언(Legal Advice)"이 아닌 "법적 정보(Legal Information)"를 제공해야 해.
실제 법적 조언은 변호사 자격이 있어야 하고, AI가 이를 대체한다고 표현하면 변호사법 위반 소지가 있음.
→ 해결책: 모든 결과에 "이 분석은 참고용이며, 중요한 계약은 법률 전문가와 상담하세요" 면책 조항 필수!
🚀 성능 최적화 팁
| 최적화 항목 | 방법 | 효과 |
|---|---|---|
| API 호출 최소화 | 배치 처리, 캐싱 | 비용 40-60% 절감 |
| 응답 속도 향상 | 스트리밍 응답 (SSE) | 체감 속도 3배 향상 |
| 모델 선택 최적화 | 단순 분류는 mini 모델 | 비용 80% 절감 |
| 임베딩 캐싱 | 동일 텍스트 임베딩 재사용 | RAG 속도 5배 향상 |
| 병렬 처리 | asyncio로 청크 동시 분석 | 분석 시간 60% 단축 |
# 스트리밍 응답 구현 (사용자 체감 속도 향상)
from fastapi.responses import StreamingResponse
import asyncio
@app.get("/api/contracts/{task_id}/stream")
async def stream_analysis_result(task_id: str):
"""분석 결과 스트리밍 반환"""
async def generate():
# 진행 상태를 SSE(Server-Sent Events)로 실시간 전송
yield f"data: {json.dumps({'status': 'PARSING', 'progress': 10})}\n\n"
await asyncio.sleep(0.1)
yield f"data: {json.dumps({'status': 'ANALYZING', 'progress': 50})}\n\n"
await asyncio.sleep(0.1)
# 실제 결과 스트리밍
result = await get_analysis_result(task_id)
for chunk in result['risks']:
yield f"data: {json.dumps({'type': 'risk', 'data': chunk})}\n\n"
await asyncio.sleep(0.05)
yield f"data: {json.dumps({'status': 'COMPLETE', 'progress': 100})}\n\n"
return StreamingResponse(
generate(),
media_type="text/event-stream",
headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"}
)
🌐 실제 서비스 사례 및 시장 현황
이론만 알면 뭐해, 실제로 이런 서비스들이 어떻게 돌아가고 있는지도 알아야지! 📊
국내에서도 AI 계약서 검증 서비스에 대한 수요가 빠르게 늘고 있어.
특히 스타트업, 프리랜서, 중소기업들이 변호사 비용 부담 없이
계약서를 검토받고 싶어하는 니즈가 엄청 크거든.
재능넷 같은 프리랜서 플랫폼에서도 계약서 관련 분쟁이 종종 발생하는데,
이런 AI 검증 서비스가 있으면 계약 전에 미리 리스크를 파악할 수 있어서 엄청 유용함!
의사에게 가기 전에 증상을 검색하는 것처럼, 계약서도 전문가 상담 전에 AI로 먼저 체크하는 시대가 왔어."
🔮 미래 발전 방향 - 다음 단계는?
현재 기술로도 충분히 유용한 서비스를 만들 수 있지만,
앞으로 더 발전할 방향도 알아두면 좋아! 🚀
GPT-4V 같은 비전 모델을 활용해서 계약서의 도장, 서명, 표, 그래프까지 분석.
"이 도장이 진짜인가?" 같은 위조 감지도 가능해질 거야.
계약 협상 중에 실시간으로 "이 조항은 수락하면 안 됩니다" 같은 알림을 주는 시스템.
화상회의 중에 계약서 내용을 실시간 분석하는 것도 가능해질 거야.
"NDA 계약서 만들어줘" → AI가 생성 → 즉시 자체 검증 → 완성본 제공.
생성과 검증이 하나의 파이프라인으로 통합되는 방향.
스마트 컨트랙트와 AI 검증을 결합해서 계약 이행 여부까지 자동으로 모니터링.
"계약 조건이 충족되면 자동으로 대금 지급" 같은 자동화가 가능해짐.
GPT-4o 같은 범용 모델 대신 한국 법률 데이터로만 학습한 전문 모델.
이미 Harvey AI(미국), 국내 법무법인들이 개발 중이야.
1. OpenAI API + LangChain으로 MVP 계약서 분석기 만들기 (1~2주)
2. 공정거래위원회 표준 계약서로 RAG 지식 베이스 구축 (1주)
3. FastAPI + Celery로 비동기 처리 시스템 구현 (1주)
4. 법률 전문가와 협업해서 프롬프트 최적화 (지속적)
5. 재능넷 같은 플랫폼과 연동해서 실제 계약서 데이터로 검증 (베타 테스트)
📌 핵심 정리 - 이것만 기억해!
AI 자동계약서 검증 서비스는 단순히 "GPT한테 계약서 보여주기"가 아니야.
문서 파싱 → 전처리 → AI 분석 → RAG 보강 → 비동기 처리 → 보안 → 리포트 생성까지
여러 기술이 유기적으로 연결된 복잡한 시스템이거든.
하지만 이 글에서 다룬 내용들을 하나씩 구현해나가면 충분히 만들 수 있어! 💪
특히 법률 도메인의 특수성을 항상 염두에 두는 게 중요해.
할루시네이션 방지, 면책 조항, 개인정보 보호, 법적 조언 vs 법적 정보 구분...
이런 것들을 소홀히 하면 기술적으로 훌륭한 서비스도 법적 리스크에 노출될 수 있거든.
재능넷에서 프리랜서로 활동하는 개발자라면 이런 AI 계약서 검증 서비스 구현 능력 자체가
엄청난 경쟁력이 될 수 있어. LegalTech는 지금 가장 핫한 AI 응용 분야 중 하나니까! 🔥
자, 이제 코드 에디터 열고 시작해봐! 처음엔 간단한 MVP부터,
그리고 점점 기능을 붙여나가면 돼. 화이팅! 🚀✨
관련 키워드
댓글 작성
이 글에 대한 여러분의 생각을 들려주세요
로그인이 필요합니다
댓글을 작성하려면 먼저 로그인해주세요.
댓글 0
지식인의 숲 - 지적 재산권 보호 고지
지적 재산권 보호 고지
- 저작권 및 소유권: 본 컨텐츠는 재능넷의 독점 AI 기술로 생성되었으며, 대한민국 저작권법 및 국제 저작권 협약에 의해 보호됩니다.
- AI 생성 컨텐츠의 법적 지위: 본 AI 생성 컨텐츠는 재능넷의 지적 창작물로 인정되며, 관련 법규에 따라 저작권 보호를 받습니다.
- 사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
- 데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
- AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.
아직 댓글이 없습니다.