Việc xử lý hồ sơ bồi thường bảo hiểm là một trong những công việc tốn thời gian và công sức nhất trong ngành tài chính — bảo hiểm. Mỗi ngày, các công ty bảo hiểm tiếp nhận hàng trăm đơn yêu cầu bồi thường với đủ loại tài liệu đính kèm: hóa đơn bệnh viện, ảnh chụp hiện trường tai nạn, hợp đồng bảo hiểm, biên bản tổn thất, và vô số các loại giấy tờ khác. Trong bài viết này, tôi sẽ chia sẻ cách tôi đã xây dựng một hệ thống tự động hóa quy trình kiểm tra tài liệu bồi thường bảo hiểm sử dụng HolySheep AI — từ nhận diện hình ảnh, tóm tắt văn bản dài, đến luồng xác nhận thủ công, và cuối cùng là so sánh chi phí với các giải pháp khác trên thị trường.
Mục Lục
- Giới Thiệu Về Bài Toán
- Kịch Bản Thực Tế Tôi Đã Xây Dựng
- Bước 1: Quét Hình Ảnh Tài Liệu
- Bước 2: Tóm Tắt Văn Bản Dài Bằng AI
- Bước 3: Luồng Xử Lý Tự Động Và Thủ Công
- So Sánh Chi Phí API
- Lỗi Thường Gặp Và Cách Khắc Phục
- Kết Luận
Tại Sao Việc Kiểm Tra Tài Liệu Bảo Hiểm Lại Quan Trọng?
Theo thống kê của một công ty bảo hiểm lớn tại Việt Nam mà tôi đã tư vấn, trung bình mỗi hồ sơ bồi thường mất khoảng 3-5 ngày làm việc để xử lý hoàn tất. Nguyên nhân chính? Nhân viên phải đọc hàng chục trang tài liệu, kiểm tra từng hóa đơn, đối chiếu thông tin, và đưa ra quyết định phê duyệt. Với hơn 500 hồ sơ mỗi ngày, đội ngũ 20 người gần như làm việc hết công suất mà vẫn không thể đáp ứng kỳ vọng của khách hàng.
Bài toán đặt ra là: làm sao giảm thời gian xử lý xuống còn vài giờ thay vì vài ngày, đồng thời vẫn đảm bảo độ chính xác cao trong việc phát hiện tài liệu giả mạo hoặc thông tin không nhất quán?
Kịch Bản Thực Tế Tôi Đã Xây Dựng Cho Khách Hàng
Tôi đã triển khai một hệ thống end-to-end cho công ty bảo hiểm với kiến trúc như sau:
- Đầu vào: Hình ảnh hóa đơn, biên bản, chứng từ (upload qua web hoặc API)
- Xử lý OCR: Trích xuất văn bản từ hình ảnh
- Tóm tắt AI: Chuyển đổi văn bản dài thành các điểm chính
- Kiểm tra tự động: So khớp thông tin với cơ sở dữ liệu
- Human-in-the-loop: Chuyển các trường hợp phức tạp cho nhân viên
- Đầu ra: Báo cáo tổng hợp gửi về cho bộ phận bồi thường
Bước 1: Quét Và Nhận Diện Hình Ảnh Tài Liệu
Đầu tiên, chúng ta cần chuyển đổi hình ảnh tài liệu (hóa đơn, ảnh chụp, biên bản) thành văn bản có thể xử lý được. Trong thực tế, tôi đã sử dụng nhiều phương pháp và phát hiện rằng HolySheep AI cung cấp khả năng nhận diện hình ảnh vượt trội với chi phí cực thấp.
API Nhận Diện Hình Ảnh Với HolySheep
Dưới đây là code mẫu tôi đã sử dụng để xử lý hình ảnh hóa đơn bảo hiểm:
import base64
import requests
import json
Đọc file ảnh và mã hóa base64
def encode_image(image_path):
with open(image_path, "rb") as image_file:
return base64.b64encode(image_file.read()).decode('utf-8')
Gửi ảnh hóa đơn để nhận diện
def extract_text_from_receipt(image_path, api_key):
base_url = "https://api.holysheep.ai/v1"
# Mã hóa ảnh
image_base64 = encode_image(image_path)
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
payload = {
"model": "gpt-4o",
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Đây là hình ảnh hóa đơn bồi thường bảo hiểm. Hãy trích xuất các thông tin sau: tên bệnh viện/nhà cung cấp, ngày tháng, số tiền, danh sách các dịch vụ, và mã hồ sơ. Trả về JSON."
},
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{image_base64}"
}
}
]
}
],
"max_tokens": 2000,
"temperature": 0.1
}
response = requests.post(
f"{base_url}/chat/completions",
headers=headers,
json=payload
)
if response.status_code == 200:
result = response.json()
content = result['choices'][0]['message']['content']
return json.loads(content)
else:
raise Exception(f"Lỗi API: {response.status_code} - {response.text}")
Sử dụng
api_key = "YOUR_HOLYSHEEP_API_KEY"
result = extract_text_from_receipt("hoa_don_benh_vien.jpg", api_key)
print(f"Tên nhà cung cấp: {result.get('ten_nha_cung_cap')}")
print(f"Số tiền: {result.get('so_tien')}")
print(f"Ngày: {result.get('ngay_thang')}")Xử Lý Nhiều Hình Ảnh Cùng Lúc
Trong thực tế, một hồ sơ bồi thường thường có nhiều hình ảnh đính kèm. Tôi đã viết hàm xử lý batch để tăng hiệu suất:
import asyncio
import aiohttp
import base64
import json
from datetime import datetime
class InsuranceDocumentProcessor:
def __init__(self, api_key):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def encode_image_sync(self, image_path):
"""Mã hóa ảnh thành base64 - phiên bản đồng bộ"""
with open(image_path, "rb") as image_file:
return base64.b64encode(image_file.read()).decode('utf-8')
async def process_single_image(self, session, image_path, document_id):
"""Xử lý một ảnh duy nhất"""
image_base64 = self.encode_image_sync(image_path)
payload = {
"model": "gpt-4o",
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Trích xuất thông tin từ tài liệu bảo hiểm này. Trả về JSON với các trường: loai_tai_lieu, noi_dung_chinh, so_tien (nếu có), ngay_thang (nếu có), ghi_chu."
},
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{image_base64}"
}
}
]
}
],
"max_tokens": 1500,
"temperature": 0.1
}
async with session.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json=payload
) as response:
result = await response.json()
if response.status == 200:
content = result['choices'][0]['message']['content']
return {
"document_id": document_id,
"status": "success",
"data": json.loads(content),
"timestamp": datetime.now().isoformat()
}
else:
return {
"document_id": document_id,
"status": "error",
"error": result.get('error', {}).get('message', 'Unknown error'),
"timestamp": datetime.now().isoformat()
}
async def process_claim_batch(self, image_paths):
"""
Xử lý nhiều ảnh cùng lúc cho một hồ sơ bồi thường.
Ví dụ: 5 hình ảnh cùng lúc thay vì tuần tự.
"""
async with aiohttp.ClientSession() as session:
tasks = [
self.process_single_image(session, path, f"doc_{i}")
for i, path in enumerate(image_paths)
]
results = await asyncio.gather(*tasks)
return results
Sử dụng
processor = InsuranceDocumentProcessor("YOUR_HOLYSHEEP_API_KEY")
images = [
"hoa_don_1.jpg",
"hoa_don_2.jpg",
"anh_chup_hien_truong.jpg",
"bien_ban_ton_that.jpg",
"chung_tu_khac.jpg"
]
results = await processor.process_claim_batch(images)
for r in results:
print(f"{r['document_id']}: {r['status']}")Bước 2: Tóm Tắt Văn Bản Dài Với AI
Sau khi trích xuất văn bản từ hình ảnh, bước tiếp theo là tóm tắt nội dung để nhân viên bồi thường có thể nắm bắt nhanh thông tin quan trọng. Đây là nơi HolySheep AI thực sự tỏa sáng — với khả năng xử lý văn bản dài lên đến hàng chục nghìn ký tự trong một lần gọi.
Tóm Tắt Hồ Sơ Bồi Thường
import requests
import json
from datetime import datetime
class InsuranceSummarizer:
def __init__(self, api_key):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
def summarize_claim_document(self, full_text, claim_type="general"):
"""
Tóm tắt toàn bộ hồ sơ bồi thường.
Args:
full_text: Văn bản đầy đủ từ tất cả tài liệu
claim_type: Loại bồi thường (sức khỏe, xe cộ, tài sản)
"""
system_prompt = """Bạn là chuyên gia kiểm tra hồ sơ bồi thường bảo hiểm với 15 năm kinh nghiệm.
Nhiệm vụ của bạn:
1. Tóm tắt ngắn gọn các điểm chính của hồ sơ
2. Liệt kê các khoản tiền yêu cầu bồi thường
3. Đánh dấu các điểm cần lưu ý hoặc nghi vấn
4. Đề xuất mức độ phê duyệt (tự động/chờ xác nhận thêm/từ chối)
5. Ghi chú các tài liệu còn thiếu (nếu có)
Luôn trả về JSON theo format quy định."""
user_prompt = f"""Hãy phân tích và tóm tắt hồ sơ bồi thường sau:
{full_text}
Trả về JSON:
{{
"tom_tat_chinh": "Tóm tắt 2-3 câu về nội dung",
"cac_khoan_chinh": ["Danh sách các khoản tiền yêu cầu"],
"diem_can_luu_y": ["Các điểm cần kiểm tra kỹ"],
"muc_do_phe_duyet": "auto|pending|reject",
"ly_do_phe_duyet": "Giải thích ngắn gọn",
"tai_lieu_thieu": ["Danh sách tài liệu còn thiếu"]
}}"""
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": "gpt-4o", # Model mạnh cho task phân tích phức tạp
"messages": [
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
"max_tokens": 3000,
"temperature": 0.3
}
start_time = datetime.now()
response = requests.post(
f"{self.base_url}/chat/completions",
headers=headers,
json=payload
)
latency = (datetime.now() - start_time).total_seconds() * 1000
if response.status_code == 200:
result = response.json()
content = result['choices'][0]['message']['content']
return {
"success": True,
"summary": json.loads(content),
"latency_ms": latency,
"tokens_used": result.get('usage', {}).get('total_tokens', 0)
}
else:
return {
"success": False,
"error": response.text,
"latency_ms": latency
}
Ví dụ sử dụng
summarizer = InsuranceSummarizer("YOUR_HOLYSHEEP_API_KEY")
Văn bản mẫu từ nhiều tài liệu đã trích xuất
sample_text = """
HÓA ĐƠN VIỆN PHÍ
Bệnh viện Quốc tế Hòa Hảo
Ngày: 15/03/2026
Mã hồ sơ: BN-2026-04589
STT | Dịch vụ | Số tiền
1 | Khám tổng quát | 350,000
2 | Xét nghiệm máu | 450,000
3 | Siêu âm bụng | 600,000
4 | Thuốc theo đơn (7 ngày) | 280,000
---
Tổng cộng: 1,680,000 VND
Thanh toán: Bảo hiểm y tế + Bảo hiểm tự nguyện
BIÊN BẢN TAI NẠN
Ngày: 14/03/2026
Địa điểm: Ngã tư Điện Biên Phủ - Nguyễn Văn Linh
Mô tả: Ông Nguyễn Văn A đi xe máy bị ngã do đường trơn
Thương tích: Chấn thương nhẹ, được sơ cứu tại chỗ
"""
result = summarizer.summarize_claim_document(sample_text, "sức khỏe")
if result['success']:
print(f"Độ trễ: {result['latency_ms']:.0f}ms")
print(f"Tóm tắt: {result['summary']['tom_tat_chinh']}")
print(f"Mức độ phê duyệt: {result['summary']['muc_do_phe_duyet']}")
print(f"Khoản tiền: {result['summary']['cac_khoan_chinh']}")Xử Lý Văn Bản Dài Với Chunking
Đối với các hồ sơ rất dài (hàng trăm trang), tôi khuyến nghị sử dụng kỹ thuật chunking để đảm bảo không bị cắt ngữn nội dung:
import textwrap
import requests
class LongTextProcessor:
"""Xử lý văn bản dài bằng cách chia nhỏ thành các phần"""
def __init__(self, api_key):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.max_chars_per_chunk = 8000 # An toàn cho context window
def chunk_text(self, text):
"""Chia văn bản thành các phần nhỏ hơn"""
chunks = []
current_pos = 0
chunk_num = 1
while current_pos < len(text):
# Tìm vị trí cắt tối ưu (không cắt giữa dòng)
if current_pos + self.max_chars_per_chunk >= len(text):
chunk = text[current_pos:]
else:
# Cắt tại vị trí xuống dòng gần nhất
end_pos = current_pos + self.max_chars_per_chunk
last_newline = text.rfind('\n', current_pos, end_pos)
if last_newline > current_pos:
end_pos = last_newline
chunk = text[current_pos:end_pos]
chunks.append({
"chunk_id": f"chunk_{chunk_num}",
"content": chunk.strip(),
"start": current_pos,
"end": current_pos + len(chunk)
})
current_pos = current_pos + len(chunk)
chunk_num += 1
return chunks
def summarize_long_document(self, full_text, claim_id):
"""
Tóm tắt tài liệu dài bằng cách xử lý từng phần
và tổng hợp kết quả.
"""
chunks = self.chunk_text(full_text)
print(f"Tài liệu dài {len(full_text)} ký tự, chia thành {len(chunks)} phần")
all_summaries = []
for i, chunk in enumerate(chunks):
print(f"Đang xử lý phần {i+1}/{len(chunks)}...")
# Xử lý từng phần với HolySheep
response = self._summarize_chunk(chunk['content'], claim_id, i+1, len(chunks))
if response['success']:
all_summaries.append({
"chunk_id": chunk['chunk_id'],
"summary": response['summary'],
"key_points": response['key_points']
})
# Tổng hợp các bản tóm tắt
final_summary = self._aggregate_summaries(all_summaries, claim_id)
return final_summary
def _summarize_chunk(self, text, claim_id, part_num, total_parts):
"""Tóm tắt một phần của tài liệu"""
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": "gpt-4o-mini", # Dùng model nhẹ hơn cho tiết kiệm chi phí
"messages": [
{
"role": "user",
"content": f"""Đây là phần {part_num}/{total_parts} của hồ sơ bồi thường {claim_id}.
Tóm tắt phần này, trích xuất:
1. Các thông tin quan trọng (số tiền, ngày tháng, tên)
2. Các điểm bất thường hoặc cần lưu ý
3. Tóm tắt 2-3 câu nội dung chính
Trả về format:
SUMMARY: [tóm tắt]
POINTS: [danh sách điểm quan trọng]"""
},
{
"role": "user",
"content": text
}
],
"max_tokens": 1000,
"temperature": 0.2
}
response = requests.post(
f"{self.base_url}/chat/completions",
headers=headers,
json=payload
)
if response.status_code == 200:
result = response.json()
content = result['choices'][0]['message']['content']
# Parse kết quả
lines = content.split('\n')
summary = ""
key_points = []
for line in lines:
if line.startswith('SUMMARY:'):
summary = line.replace('SUMMARY:', '').strip()
elif line.startswith('POINTS:'):
key_points = [p.strip() for p in line.replace('POINTS:', '').split(',')]
return {
"success": True,
"summary": summary,
"key_points": key_points
}
else:
return {"success": False, "error": response.text}
def _aggregate_summaries(self, summaries, claim_id):
"""Tổng hợp các bản tóm tắt thành một báo cáo cuối cùng"""
combined_content = "\n\n".join([
f"[{s['chunk_id']}]: {s['summary']}\n- " + "\n- ".join(s['key_points'])
for s in summaries
])
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": "gpt-4o",
"messages": [
{
"role": "user",
"content": f"""Dựa trên các tóm tắt sau của hồ sơ {claim_id}, hãy tạo báo cáo tổng hợp cuối cùng:
{combined_content}
Tạo báo cáo JSON với:
- tom_tat_toan_bo: Tóm tắt toàn bộ hồ sơ
- cac_khoan_yeu_cau: Danh sách các khoản tiền
- diem_nghi_van: Các điểm cần xác minh thêm
- de_xuat_xu_ly: Đề xuất phê duyệt hay từ chối
"""
}
],
"max_tokens": 2000,
"temperature": 0.2
}
response = requests.post(
f"{self.base_url}/chat/completions",
headers=headers,
json=payload
)
if response.status_code == 200:
result = response.json()
return {
"success": True,
"report": result['choices'][0]['message']['content'],
"chunks_processed": len(summaries)
}
return {"success": False}
Sử dụng
processor = LongTextProcessor("YOUR_HOLYSHEEP_API_KEY")
Đọc file PDF/dài
with open("ho_so_boi_thuong dai.txt", "r", encoding="utf-8") as f:
full_document = f.read()
result = processor.summarize_long_document(full_document, "BH-2026-00123")
if result['success']:
print(f"Đã xử lý {result['chunks_processed']} phần")
print(result['report'])Bước 3: Luồng Xử Lý Tự Động Và Thủ Công (Human-in-the-Loop)
Không phải mọi hồ sơ đều có thể xử lý tự động hoàn toàn. Với những trường hợp phức tạp, hệ thống cần chuyển sang nhân viên thủ công. Tôi đã thiết kế một luồng xử lý hybrid để tối ưu cả hiệu suất lẫn độ chính xác.
Luồng Xử Lý Hybrid
from enum import Enum
from dataclasses import dataclass
from typing import Optional, List
from datetime import datetime
class ApprovalLevel(Enum):
AUTO_APPROVED = "auto_approved"
MANUAL_REVIEW = "manual_review"
SENIOR_REVIEW = "senior_review"
REJECTED = "rejected"
@dataclass
class ClaimResult:
claim_id: str
level: ApprovalLevel
summary: str
extracted_data: dict
flagged_issues: List[str]
confidence_score: float
assigned_to: Optional[str] = None
processing_time_ms: int = 0
class HybridApprovalWorkflow:
"""
Luồng xử lý hybrid: tự động cho hồ sơ đơn giản,
chuyển thủ công cho hồ sơ phức tạp.
"""
# Ngưỡng quyết định tự động
AUTO_THRESHOLD = 0.85 # Độ chính xác >= 85% -> tự động duyệt
MANUAL_THRESHOLD = 0.60 # >= 60% -> chờ nhân viên
# Dưới 60% -> từ chối hoặc yêu cầu bổ sung
def __init__(self, api_key, db_connection=None):
self.api_key = api_key
self.db = db_connection # Kết nối database để lưu trữ
self.base_url = "https://api.holysheep.ai/v1"
def process_claim(self, claim_data: dict) -> ClaimResult:
"""
Xử lý một hồ sơ bồi thường.
Args:
claim_data: Dict chứa thông tin hồ sơ và hình ảnh
"""
start_time = datetime.now()
claim_id = claim_data.get('claim_id', 'UNKNOWN')
try:
# Bước 1: Phân tích tài liệu bằng AI
ai_analysis = self._analyze_with_ai(claim_data)
# Bước 2: Kiểm tra các điều kiện tự động
validation = self._validate_claim(ai_analysis, claim_data)
# Bước 3: Quyết định mức độ phê duyệt
result = self._determine_approval_level(
ai_analysis,
validation,
claim_id
)
# Bước 4: Xử lý theo luồng phù hợp
if result.level == ApprovalLevel.AUTO_APPROVED:
result = self._auto_approve(result)
elif result.level == ApprovalLevel.MANUAL_REVIEW:
result = self._route_to_agent(result)
elif result.level == ApprovalLevel.SENIOR_REVIEW:
result = self._route_to_senior(result)
result.processing_time_ms = int(
(datetime.now() - start_time).total_seconds() * 1000
)
# Lưu vào database
self._save_result(result)
return result
except Exception as e:
return ClaimResult(
claim_id=claim_id,
level=ApprovalLevel.MANUAL_REVIEW,
summary=f"Lỗi xử lý: {str(e)}",
extracted_data={},
flagged_issues=[str(e)],
confidence_score=0.0
)
def _analyze_with_ai(self, claim_data):
"""Gọi HolySheep AI để phân tích hồ sơ"""
import requests
import json
# Xây dựng prompt chi tiết
prompt = f"""Phân tích hồ sơ bồi thường số {claim_data.get('claim_id')}
Thông tin khách hàng: {claim_data.get('customer_info', {})}
Loại bảo hiểm: {claim_data.get('insurance_type')}
Số tiền yêu cầu: {claim_data.get('claim_amount')} VND
Tài liệu đính k