Trong lĩnh vực y tế, quy trình chẩn đoán là một chuỗi phức tạp đòi hỏi kiến thức chuyên môn cao. Với sự phát triển của AI, chúng ta có thể xây dựng hệ thống thông minh hỗ trợ bác sĩ chẩn đoán, nâng cao hiệu quả và độ chính xác. Bài viết này sẽ hướng dẫn chi tiết cách xây dựng Trợ lý Chẩn đoán Y tế Thông minh sử dụng LangGraph và DeepSeek, từ nguyên lý thiết kế đến triển khai mã nguồn. Dự án hoàn chỉnh: https://github.com/jiangnanboy/medical-diagnosis-assistant.
1. Triết lý cốt lõi: Vì sao chọn LangGraph?
Hệ thống AI truyền thống thường áp dụng quy trình tuyến tính (như cấu trúc chuỗi trong LangChain), nhưng quy trình chẩn đoán y tế không mang tính tuyến tính. Bác sĩ cần đánh giá ban đầu dựa trên thông tin bệnh nhân, quyết định liệu có cần xét nghiệm hay không, điều chỉnh chẩn đoán theo kết quả xét nghiệm, lập kế hoạch điều trị, thậm chí có thể cần đánh giá lại. Quy trình ra quyết định phức tạp này phù hợp hơn với cấu trúc đồ thị thay vì chuỗi đơn giản.
LangGraph được thiết kế riêng cho mục đích này, cho phép chúng ta:
- Định nghĩa trạng thái phức tạp: Duy trì tất cả thông tin trong quá trình chẩn đoán
- Thực hiện định tuyến điều kiện: Quyết định bước tiếp theo dựa trên kết quả trung gian
- Hỗ trợ vòng lặp và quay lại: Mô phỏng tình huống bác sĩ cần đánh giá lại
- Cung cấp điểm kiểm tra: Lưu trữ trạng thái trung gian để phục hồi và gỡ lỗi
Trợ lý chẩn đoán của chúng ta sẽ mô phỏng quy trình chẩn đoán thực tế của bác sĩ, từ đánh giá ban đầu đến báo cáo cuối cùng, mỗi bước là một nút trong đồ thị, các kết nối giữa nút đại diện cho các đường đi ra quyết định.
2. Kiến trúc hệ thống: Luồng công việc chẩn đoán thông minh
2.1 Định nghĩa trạng thái: Bộ nhớ hệ thống
Trong LangGraph, trạng thái là cấu trúc dữ liệu cốt lõi xuyên suốt luồng công việc. Chúng ta sử dụng TypedDict để định nghĩa TrangThaiChuanDoanYTe, chứa toàn bộ thông tin cần thiết trong quá trình chẩn đoán:
class TrangThaiChuanDoanYTe(TypedDict):
"""Cấu trúc trạng thái luồng chẩn đoán y tế"""
tin_nhan: Annotated[List, them_tin_nhan] # Lịch sử hội thoại
thong_tin_benh_nhan: Dict[str, Any] # Thông tin cơ bản bệnh nhân
trieu_chung: List[Dict[str, Any]] # Danh sách triệu chứng
dau_hieu_sinh_tuong: Dict[str, Any] # Dấu hiệu sinh tồn
ket_qua_xet_nghiem: List[Dict[str, Any]] # Kết quả xét nghiệm
chuan_doan_dau_tien: List[str] # Chẩn đoán ban đầu
phieu_xet_nghiem: List[str] # Phiếu xét nghiệm đề xuất
ke_hoach_dieu_tri: Dict[str, Any] # Kế hoạch điều trị
ke_hoach_theo_doi: Dict[str, Any] # Kế hoạch theo dõi
giai_doan_hien_tai: str # Giai đoạn hiện tại
muc_do_ngoai_binh_thuong: str # Mức độ ngoại biên thường
phe_duyet_bac_si: Dict[str, bool] # Trạng thái phê duyệt bác sĩ
dem_vong_lap: int # Bộ đếm vòng lặp
so_vong_lap_toi_da: int # Số vòng lặp tối đa
bao_cao_cuoi_cung: str # Báo cáo cuối cùng
loi: Optional[str] # Thông báo lỗi
ma_buoc: str # Mã bước
Cấu trúc trạng thái này giống như sổ bệnh án của bác sĩ, ghi nhận toàn bộ thông tin từ lúc bệnh nhân nhập viện đến khi chẩn đoán hoàn tất, mỗi nút có thể đọc và cập nhật thông tin này.
2.2 Thiết kế nút: Các bước chẩn đoán
Quy trình chẩn đoán được phân rã thành nhiều nút, mỗi nút đại diện cho một bước cụ thể:
- Nút đánh giá ban đầu (
danh_gia_ban_dau_node): Đánh giá mức độ khẩn cấp, nhận diện tình huống khẩn cấp tiềm năng - Nút ra quyết định xét nghiệm (
quyet_dinh_xet_nghiem_node): Quyết định chiến lược xét nghiệm dựa trên mức độ khẩn cấp - Nút cấp phiếu xét nghiệm (
cap_phoi_xet_nghiem_node): Tạo và thực hiện xét nghiệm - Nút phân tích chẩn đoán (
phan_tich_chuan_doan_node): Phân tích chẩn đoán dựa trên toàn bộ thông tin - Nút lập kế hoạch điều trị (
lap_ke_hoach_dieu_tri_node): Lập kế hoạch điều trị dựa trên kết quả chẩn đoán - Nút phê duyệt bác sĩ (
phe_duyet_bac_si_node): Mô phỏng quy trình phê duyệt của bác sĩ - Nút lập kế hoạch theo dõi (
lap_ke_hoach_theo_doi_node): Lập kế hoạch theo dõi bệnh nhân - Nút tạo báo cáo (
tao_bao_cao_cuoi_cung_node): Tạo báo cáo chẩn đoán cuối cùng
Chúng ta sẽ phân tích chi tiết một số nút quan trọng:
Nút đánh giá ban đầu
def danh_gia_ban_dau_node(state: TrangThaiChuanDoanYTe) -> Dict[str, Any]:
"""Bước 1: Đánh giá ban đầu và phân loại khẩn cấp"""
try:
thong_tin_benh_nhan = state["thong_tin_benh_nhan"]
trieu_chung = state["trieu_chung"]
dau_hieu_sinh_tuong = state["dau_hieu_sinh_tuong"]
prompt_danh_gia = f"""
Bạn là bác sĩ cấp cứu giàu kinh nghiệm. Vui lòng đánh giá ban đầu dựa trên:
Thông tin bệnh nhân:
{json.dumps(thong_tin_benh_nhan, ensure_ascii=False, indent=2)}
Triệu chứng:
{json.dumps(trieu_chung, ensure_ascii=False, indent=2)}
Dấu hiệu sinh tồn:
{json.dumps(dau_hieu_sinh_tuong, ensure_ascii=False, indent=2)}
Vui lòng thực hiện:
1. Đánh giá mức độ khẩn cấp (thấp/trung bình/cao/khẩn cấp)
2. Nhận diện các dấu hiệu khẩn cấp tiềm năng
3. Đề xuất các xét nghiệm cần thiết
4. Cung cấp ấn tượng ban đầu
Trả về định dạng JSON:
{{
"muc_do_khac_binh_thuong": "mức độ",
"dau_hieu_khac_binh_thuong": ["dấu hiệu 1", "dấu hiệu 2"],
"hanh_dong_khong_chu_y": ["hành động 1", "hành động 2"],
"phieu_xet_nghiem_de_xuat": ["xét nghiệm 1", "xét nghiệm 2"],
"an_tuong_ban_dau": "ấn tượng ban đầu"
}}
"""
response = llm.invoke([SystemMessage(content=prompt_danh_gia)])
# Phân tích phản hồi JSON
try:
response_text = response.content.strip()
if response_text.startswith("```json"):
response_text = response_text[7:-3]
ket_qua_danh_gia = json.loads(response_text)
muc_do = ket_qua_danh_gia.get("muc_do_khac_binh_thuong", "trung_binh")
phieu_xet_nghiem = ket_qua_danh_gia.get("phieu_xet_nghiem_de_xuat", [])
except json.JSONDecodeError:
muc_do = "trung_binh"
phieu_xet_nghiem = ["xét nghiệm máu", "kiểm tra nhiệt độ"]
# Dịch mức độ sang tiếng Việt
muc_do_map = {
"low": "thấp",
"medium": "trung bình",
"high": "cao",
"emergency": "khẩn cấp"
}
muc_do_vi = muc_do_map.get(muc_do, "trung bình")
return {
"muc_do_khac_binh_thuong": muc_do,
"phieu_xet_nghiem": phieu_xet_nghiem,
"giai_doan_hien_tai": "da_danh_gia",
"tin_nhan": [AIMessage(content=f"🏥 Đánh giá ban đầu hoàn tất, mức độ: {muc_do_vi}")]
}
except Exception as e:
return {
"loi": f"Lỗi đánh giá ban đầu: {str(e)}",
"giai_doan_hien_tai": "danh_gia_that_bai",
"tin_nhan": [AIMessage(content=f"❌ Đánh giá gặp vấn đề: {str(e)}")]
}
Nút này trước tiên trích xuất thông tin bệnh nhân, triệu chứng và dấu hiệu sinh tồn từ trạng thái, sau đó xây dựng prompt chi tiết gửi đến DeepSeek. Mô hình sẽ phân tích thông tin và trả về kết quả JSON bao gồm mức độ khẩn cấp và các xét nghiệm đề xuất. Nút xử lý kết quả, cập nhật trạng thái và trả về từ điển chứa thông tin mới.
Nút phân tích chẩn đoán
def phan_tich_chuan_doan_node(state: TrangThaiChuanDoanYTe) -> Dict[str, Any]:
"""Bước 4: Phân tích chẩn đoán"""
try:
thong_tin_benh_nhan = state["thong_tin_benh_nhan"]
trieu_chung = state["trieu_chung"]
dau_hieu_sinh_tuong = state["dau_hieu_sinh_tuong"]
ket_qua_xet_nghiem = state["ket_qua_xet_nghiem"]
prompt_chuan_doan = f"""
Bạn là bác sĩ chuyên khoa. Vui lòng phân tích chẩn đoán dựa trên:
Thông tin bệnh nhân:
{json.dumps(thong_tin_benh_nhan, ensure_ascii=False, indent=2)}
Triệu chứng:
{json.dumps(trieu_chung, ensure_ascii=False, indent=2)}
Dấu hiệu sinh tồn:
{json.dumps(dau_hieu_sinh_tuong, ensure_ascii=False, indent=2)}
Kết quả xét nghiệm:
{json.dumps(ket_qua_xet_nghiem, ensure_ascii=False, indent=2)}
Vui lòng cung cấp:
1. Chẩn đoán chính (có thể nhiều)
2. Chẩn đoán phân biệt
3. Cơ sở chẩn đoán
4. Đánh giá mức độ nghiêm trọng (nhẹ/trung bình/nặng)
5. Liệu có cần hội chẩn
Trả về định dạng JSON:
{{
"chuan_doan_chinh": ["chẩn đoán 1", "chẩn đoán 2"],
"chuan_doan_phan_biet": ["chẩn đoán phân biệt 1", "chẩn đoán phân biệt 2"],
"co_so_chuan_doan": "cơ sở chẩn đoán",
"muc_do_nang": "nhe/trung_binh/nang",
"can_hoi_chan": true/false,
"khoa_hoi_chan": "khoa hội chẩn"
}}
"""
response = llm.invoke([SystemMessage(content=prompt_chuan_doan)])
# Phân tích phản hồi JSON
try:
response_text = response.content.strip()
if response_text.startswith("```json"):
response_text = response_text[7:-3]
ket_qua = json.loads(response_text)
chuan_doan = ket_qua.get("chuan_doan_chinh", [])
can_hoi_chan = ket_qua.get("can_hoi_chan", False)
except json.JSONDecodeError:
chuan_doan = ["chưa xác định"]
can_hoi_chan = False
return {
"chuan_doan_dau_tien": chuan_doan,
"giai_doan_hien_tai": "da_chuan_doan",
"can_hoi_chan": can_hoi_chan,
"tin_nhan": [AIMessage(content=f"📋 Hoàn tất chẩn đoán: {', '.join(chuan_doan)}")]
}
except Exception as e:
return {
"loi": f"Lỗi chẩn đoán: {str(e)}",
"giai_doan_hien_tai": "chuan_doan_that_bai",
"tin_nhan": [AIMessage(content=f"❌ Quá trình chẩn đoán gặp vấn đề: {str(e)}")]
}
Nút này tổng hợp toàn bộ thông tin có sẵn (thông tin bệnh nhân, triệu chứng, dấu hiệu sinh tồn và kết quả xét nghiệm), yêu cầu DeepSeek phân tích chẩn đoán toàn diện. Kết quả trả về bao gồm chẩn đoán chính, chẩn đoán phân biệt, cơ sở chẩn đoán... sẽ được sử dụng để lập kế hoạch điều trị tiếp theo.
2.3 Thiết kế cạnh: Kết nối các đường dẫn ra quyết định
Trong LangGraph, cạnh định nghĩa mối liên hệ giữa các nút. Chúng ta sử dụng hai loại cạnh:
- Cạnh thông thường: Đại diện cho thứ tự quy trình cố định
- Cạnh điều kiện: Quyết định bước tiếp theo dựa trên trạng thái
Cạnh điều kiện là yếu tố then chốt để thực hiện ra quyết định thông minh. Ví dụ, sau đánh giá ban đầu, hệ thống cần quyết định bước tiếp theo dựa trên mức độ khẩn cấp:
def quyet_dinh_sau_danh_gia(state: TrangThaiChuanDoanYTe) -> Literal[
"quyet_dinh_xet_nghiem", "cap_phoi_xet_nghiem", "phan_tich_chuan_doan", "tao_bao_cao"]:
"""Quyết định đường dẫn sau đánh giá ban đầu"""
if state.get("loi") or "that_bai" in state.get("giai_doan_hien_tai", ""):
return "tao_bao_cao"
muc_do = state.get("muc_do_khac_binh_thuong", "")
if muc_do == "khac_binh_thuong":
return "cap_phoi_xet_nghiem" # Tình huống khẩn cấp trực tiếp xét nghiệm
return "quyet_dinh_xet_nghiem" # Các trường hợp khác quyết định chiến lược xét nghiệm
Hàm định tuyến này kiểm tra mức độ khẩn cấp trong trạng thái, nếu là "khẩn cấp" thì chuyển trực tiếp sang quy trình xét nghiệm; ngược lại, quyết định chiến lược xét nghiệm trước. Cơ chế định tuyến điều kiện này giúp hệ thống điều chỉnh linh hoạt theo tình huống, mô phỏng quy trình ra quyết định của bác sĩ thực tế.
3. Tích hợp luồng công việc: Xây dựng đồ thị chẩn đoán
Bây giờ, hãy xem cách tích hợp các nút và cạnh thành luồng công việc hoàn chỉnh:
def tao_truoc_li_chuan_doan_y_te():
"""Tạo luồng công việc chẩn đoán y tế"""
workflow = DoThiTrangThai(TrangThaiChuanDoanYTe)
# Thêm các nút
workflow.add_node("danh_gia_ban_dau", danh_gia_ban_dau_node)
workflow.add_node("quyet_dinh_xet_nghiem", quyet_dinh_xet_nghiem_node)
workflow.add_node("cap_phoi_xet_nghiem", cap_phoi_xet_nghiem_node)
workflow.add_node("phan_tich_chuan_doan", phan_tich_chuan_doan_node)
workflow.add_node("lap_ke_hoach_dieu_tri", lap_ke_hoach_dieu_tri_node)
workflow.add_node("phe_duyet_bac_si", phe_duyet_bac_si_node)
workflow.add_node("lap_ke_hoach_theo_doi", lap_ke_hoach_theo_doi_node)
workflow.add_node("tao_bao_cao_cuoi_cung", tao_bao_cao_cuoi_cung_node)
# Thiết lập luồng
workflow.add_edge(BAT_DAU, "danh_gia_ban_dau")
# Thêm cạnh điều kiện
workflow.add_conditional_edges(
"danh_gia_ban_dau",
quyet_dinh_sau_danh_gia,
{
"quyet_dinh_xet_nghiem": "quyet_dinh_xet_nghiem",
"cap_phoi_xet_nghiem": "cap_phoi_xet_nghiem",
"phan_tich_chuan_doan": "phan_tich_chuan_doan",
"tao_bao_cao": "tao_bao_cao"
}
)
workflow.add_conditional_edges(
"quyet_dinh_xet_nghiem",
quyet_dinh_sau_xet_nghiem,
{
"cap_phoi_xet_nghiem": "cap_phoi_xet_nghiem",
"phan_tich_chuan_doan": "phan_tich_chuan_doan"
}
)
workflow.add_edge("cap_phoi_xet_nghiem", "phan_tich_chuan_doan")
workflow.add_conditional_edges(
"phan_tich_chuan_doan",
quyet_dinh_sau_chuan_doan,
{
"lap_ke_hoach_dieu_tri": "lap_ke_hoach_dieu_tri",
"phe_duyet_bac_si": "phe_duyet_bac_si",
"lap_ke_hoach_theo_doi": "lap_ke_hoach_theo_doi"
}
)
workflow.add_edge("lap_ke_hoach_dieu_tri", "phe_duyet_bac_si")
workflow.add_conditional_edges(
"phe_duyet_bac_si",
quyet_dinh_sau_phe_duyet,
{
"lap_ke_hoach_theo_doi": "lap_ke_hoach_theo_doi",
"phan_tich_chuan_doan": "phan_tich_chuan_doan",
"lap_ke_hoach_dieu_tri": "lap_ke_hoach_dieu_tri"
}
)
workflow.add_edge("lap_ke_hoach_theo_doi", "tao_bao_cao_cuoi_cung")
workflow.add_edge("tao_bao_cao_cuoi_cung", KET_THUC)
# Biên dịch đồ thị
bo_nho = BoNhoTrong()
app = workflow.compile(checkpointer=bo_nho)
return app
Đoạn mã đầu tiên tạo đối tượng DoThiTrangThai, sau đó thêm tất cả các nút. Tiếp theo, định nghĩa mối liên kết giữa các nút bao gồm điểm bắt đầu và kết thúc. Đặc biệt đáng chú ý là việc sử dụng cạnh điều kiện, cho phép luồng công việc điều chỉnh đường đi dựa trên kết quả trung gian.
Cuối cùng, chúng ta sử dụng BoNhoTrong làm điểm kiểm tra và biên dịch đồ thị để thu được ứng dụng có thể thực thi. Điểm kiểm tra này cho phép lưu trữ và phục hồi trạng thái, rất hữu ích cho quy trình chẩn đoán kéo dài.
4. Sơ đồ luồng: Trực quan hóa công việc chẩn đoán thông minh
Để dễ hình dung luồng công việc chẩn đoán, dưới đây là sơ đồ tóm tắt:
Sơ đồ này thể hiện các điểm ra quyết định chính và đường đi trong luồng chẩn đoán. Bắt đầu từ đánh giá ban đầu, hệ thống quyết định liệu có cần xét nghiệm ngay lập tức dựa trên mức độ khẩn cấp. Sau khi hoàn tất xét nghiệm, phân tích chẩn đoán, sau đó dựa vào kết quả chẩn đoán để lập kế hoạch điều trị. Quy trình phê duyệt của bác sĩ có thể dẫn đến việc quay lại chẩn đoán hoặc điều chỉnh kế hoạch điều trị. Cuối cùng, lập kế hoạch theo dõi và tạo báo cáo cuối cùng.
5. Giao diện người dùng: Tương tác thông qua Streamlit
Để trợ lý chẩn đoán thông minh dễ sử dụng hơn, chúng ta xây dựng giao diện Web bằng Streamlit. Giao diện gồm các phần chính:
- Nhập thông tin bệnh nhân: Thu thập thông tin cơ bản, tiền sử bệnh, dị ứng ở thanh bên
- Mô tả triệu chứng: Cho phép người dùng thêm nhiều triệu chứng động, bao gồm tên triệu chứng, thời gian kéo dài, mức độ nghiêm trọng
- Dấu hiệu sinh tồn: Thu thập chỉ số huyết áp, nhịp tim, nhiệt độ
- Hiển thị quy trình chẩn đoán: Sử dụng thanh tiến độ và bảng mở rộng để hiển thị từng bước
- Kết quả hiển thị: Hiển thị rõ ràng chẩn đoán ban đầu, kế hoạch điều trị, kế hoạch theo dõi và báo cáo cuối cùng
# Nút chẩn đoán
st.markdown("---")
col_nut1, col_nut2, col_nut3 = st.columns([1, 2, 1])
with col_nut2:
nut_chuan_doan = st.button("🔍 Bắt đầu chẩn đoán thông minh", type="primary", use_container_width=True)
# Hiển thị kết quả chẩn đoán
if nut_chuan_doan:
# ... Chuẩn bị dữ liệu đầu vào ...
# Chạy quy trình chẩn đoán
with st.spinner("Đang thực hiện chẩn đoán, vui lòng chờ..."):
try:
# Sử dụng luồng để hiển thị tiến độ
ket_qua_luu_tru = chuan_doan_y_te(thong_tin_benh_nhan, danh_sach_trieu_chung, dau_hieu_sinh_tuong, stream=True)
# Hiển thị kết quả từng bước
buoc = 0
ket_qua_cuoi_cung = {}
with message_container:
for su_kien in ket_qua_luu_tru:
buoc += 1
tien_do = min(buoc / 8.0, 1.0)
thanh_tien_do.progress(tien_do)
for ten_nut, du_lieu_nut in su_kien.items():
if ten_nut != "__end__":
# Cập nhật trạng thái văn bản
ten_buoc_vi = ten_buoc.get(ten_nut, ten_nut)
status_text.markdown(f"**Bước hiện tại: {ten_buoc_vi}**")
# Hiển thị kết quả từng bước
with st.expander(f"Bước {buoc}: {ten_buoc_vi}", expanded=True):
for tin in du_lieu_nut.get("tin_nhan", []):
if isinstance(tin, AIMessage):
st.markdown(f'<p class="success-message">{tin.noi_dung}</p>',
unsafe_allow_html=True)
# Hiển thị báo cáo cuối cùng
# ... Hiển thị kết quả chẩn đoán ...
except Exception as e:
st.markdown(f'<p class="error-message">Lỗi trong quá trình chẩn đoán: {str(e)}</p>', unsafe_allow_html=True)
Đoạn mã này thể hiện cách sử dụng các thành phần giao diện của Streamlit để thu thập đầu vào người dùng và gọi luồng chẩn đoán. Đặc biệt đáng chú ý là việc sử dụng luồng (stream=True) để hiển thị tiến độ chẩn đoán theo thời gian thực, cải thiện trải nghiệm người dùng.
6. Tổng kết và hướng phát triển
Qua bài viết, chúng ta đã tìm hiểu cách xây dựng Trợ lý Chẩn đoán Y tế Thông minh bằng LangGraph và DeepSeek. Hệ thống này thể hiện sức mạnh của LangGraph trong việc xây dựng luồng công việc có trạng thái phức tạp, đặc biệt trong các trường hợp cần định tuyến điều kiện và quản lý trạng thái.
Trợ lý chẩn đoán của chúng ta có những đặc điểm sau:
- Thiết kế mô-đun: Mỗi bước chẩn đoán là một nút độc lập, dễ bảo trì và mở rộng
- Ra quyết định thông minh: Sử dụng cạnh điều kiện để định tuyến động dựa trên trạng thái
- Quản lý trạng thái: Tập trung quản lý toàn bộ thông tin trong quá trình chẩn đoán
- Dễ sử dụng: Cung cấp giao diện trực quan và phản hồi theo thời gian thực thông qua Streamlit
Trong tương lai, chúng ta có thể cải tiến hệ thống theo các hướng sau:
- Tích hợp dữ liệu thực tế: Kết nối với cơ sở dữ liệu y tế và thiết bị xét nghiệm thật
- Thêm nút chuyên khoa: Bổ sung các nút chẩn đoán chuyên sâu cho các chuyên khoa như tim mạch, thần kinh...
- Thực hiện kiểm tra thủ công: Thêm cơ chế kiểm tra của con người ở các bước ra quyết định quan trọng
- Tối ưu kỹ thuật prompt: Tinh chỉnh prompt để tăng độ chính xác chẩn đoán
- Hỗ trợ đa phương tiện: Thêm khả năng xử lý dữ liệu y tế đa phương tiện như hình ảnh, âm thanh...
LangGraph cung cấp khung mạnh mẽ để xây dựng ứng dụng AI phức tạp, trong khi các mô hình ngôn ngữ lớn như DeepSeek đóng vai trò cốt lõi thông minh. Kết hợp hai yếu tố này, chúng ta có thể tạo ra các hệ thống AI thông minh, hữu ích, mang lại thay đổi cho nhiều ngành nghề.