Giới thiệu về Gỡ lỗi và Kiểm thử LLM trong LangSmith

Gần đây tôi phát hiện một nền tảng AI có thể tự động tạo thẻ ghi nhớ (flashcard) từ mọi loại nội dung. Vì tôi rất thích ghi nhớ các khái niệm bằng phương pháp lặp lại ngắt quãng, tôi lập tức tải lên hướng dẫn XGBoost của mình và yêu cầu AI tạo 50 thẻ ghi nhớ từ đó.

Nhưng tôi đã thất vọng. Phần lớn câu hỏi quá dễ, và rất ít câu liên quan đến cú pháp mã. Kỳ lạ hơn, 10% câu hỏi bị trùng hệt nhau và hoàn toàn lạc đề — “Thủ đô của Pháp là gì?”.

Những lỗi kiểu này cho thấy thiếu đánh giá và kiểm định đúng mức đối với đầu ra do dịch vụ AI tạo ra. Có lẽ họ chưa biết đến LangSmith.

LangSmith là một nền tảng hoàn chỉnh để kiểm thử, gỡ lỗi và đánh giá các ứng dụng LLM. Có lẽ tính năng quan trọng nhất của nó là đánh giá đầu ra LLM và giám sát hiệu năng. Trong hướng dẫn này, chúng ta sẽ xem khung công cụ này vận hành như thế nào và học các kỹ thuật để áp dụng vào dự án của riêng bạn.

Bắt đầu thôi!

Vì sao chọn LangSmith?

Như tôi đã đề cập, LangSmith là một nền tảng toàn diện để đánh giá các ứng dụng ngôn ngữ lớn. Dưới đây là một số tính năng và lợi ích thực tế:

Thiết lập nhanh

Lập trình viên có thể bắt đầu thử nghiệm LangSmith trong vài phút, không phải hàng giờ. Điều này có nghĩa là một nhóm nhỏ hoặc một nhà phát triển solo có thể dựng thử một ứng dụng AI vào cuối tuần và thậm chí tung ra dịch vụ trả phí vào thứ Hai.

Đảm bảo chất lượng

Với các công cụ đánh giá chặt chẽ, doanh nghiệp có thể tránh bối rối và chi phí do phát hành AI lỗi (như ví dụ tôi nêu ở phần mở đầu). LangSmith cho phép bạn kiểm tra đầu ra của LLM theo các tiêu chí tích hợp như mức độ hữu ích, mạch lạc, kỳ thị phụ nữ, hoặc thậm chí các đánh giá tùy chỉnh bằng ngôn ngữ tự nhiên như “Nội dung đầu ra có sáo mòn không?” hoặc, trong trường hợp tạo thẻ ghi nhớ, “Thẻ có chứa câu hỏi về mã không?”.

Giám sát và trực quan hóa theo thời gian thực

LangSmith sử dụng trace để ghi log gần như mọi khía cạnh của các lần chạy LLM. Bao gồm các chỉ số như độ trễ, số token, chi phí chạy và mọi loại metadata. Giao diện Web cho phép bạn lọc nhanh các lần chạy theo tỷ lệ lỗi, độ trễ, ngày tháng, hoặc thậm chí theo nội dung văn bản bằng ngôn ngữ tự nhiên. Điều này có nghĩa là, ví dụ, nếu một trợ giảng AI bắt đầu trả lời trục trặc với học viên thật, bạn có thể tung bản vá chỉ trong vài giờ.

Tích hợp với LangChain

LangChain là khung cha của LangSmith, tập trung vào giai đoạn phát triển LLM. Nó cung cấp thiết kế phần mềm mô-đun để xâu chuỗi nhiều LLM (agent) và tích hợp với các API khác như YouTube, Google Search, v.v. LangSmith là lớp hoàn thiện, đảm bảo các nguyên mẫu dựng bằng LangChain hoạt động như kỳ vọng nhờ các công cụ đánh giá và giám sát mạnh mẽ.

Xem thêm hướng dẫn Ứng dụng LLM với LangChain để tìm hiểu thêm về LangChain.

Bộ dữ liệu

Một tính năng tuyệt vời khác của LangSmith là bộ dữ liệu (dataset). Chúng có thể được dùng để cải thiện các chuỗi, agent hoặc mô hình LangChain dựa trên một tập ví dụ chuẩn hóa trước khi triển khai. Chẳng hạn, ta có thể có một tệp CSV chứa hai cột — câu hỏi và câu trả lời cho thẻ ghi nhớ theo một định dạng cụ thể.

Bằng cách chuyển đổi tệp này thành bộ dữ liệu tham chiếu, ta có thể hướng dẫn LLM tự đánh giá đầu ra của mình bằng các chỉ số đảm bảo chất lượng đã nêu trước đó.

Giờ chúng ta sẽ lần lượt xem tất cả các tính năng này qua từng ví dụ.

Quy trình phát triển ứng dụng LLM

Trong phát triển ứng dụng ML, bạn thu thập dữ liệu, huấn luyện, fine-tune, kiểm thử và triển khai mô hình - các bước đều rõ ràng. Với ứng dụng LLM, bạn thường bắt đầu với mô hình dựng sẵn từ nhà cung cấp. Fine-tune? Có thể tốn kém. Vì vậy, bạn sẽ tập trung nhiều vào việc soạn prompt phù hợp — mọi thứ xoay quanh việc đặt đúng câu hỏi cho ứng dụng LLM của bạn. Hãy nghĩ đến việc bạn cần thật nhiều prompt để thử nghiệm, giống như cần nhiều dữ liệu để có một mô hình ML tốt.

Tuy nhiên, với prompt, bạn xử lý văn bản vào/ra, không phải con số. Do đó, các cách đo lỗi hay độ chính xác thông thường như MSE hay cross-entropy không áp dụng ở đây. Thêm nữa, thử tưởng tượng phải đọc từng đầu vào và đầu ra để đánh giá — nếu có hàng nghìn prompt thì sẽ tốn cả ngày trời.

Vì vậy, bạn cần một quy trình tập trung vào việc tạo và kiểm thử prompt hiệu quả để xem ứng dụng LLM hoạt động tốt đến đâu, mà không bị chìm trong kiểm tra thủ công. Dưới đây là quy trình mẫu:

1. Phát triển

Ở giai đoạn này, bạn sẽ dựng nguyên khối cốt lõi của ứng dụng bằng các framework như LangChain. Với dự án tạo thẻ ghi nhớ, nguyên mẫu của bạn có thể gồm nhiều thành phần chạy trên LLM bạn chọn từ nhà cung cấp. Ví dụ, bạn có thể cần xâu chuỗi nó với:

• Retriever: API công cụ tìm kiếm, bộ thu thập web
• Trình nạp tài liệu: đầu vào tệp — PDF, văn bản, CSV, JSON, clipboard, YouTube, Search, v.v.
• Trình nạp chat
• Kho vector
• Mô hình embedding
• Callback

và nhiều thành phần khác (xem các thành phần có thể thêm từ trang này của tài liệu LangChain). Nhưng bạn có thể rút ngắn đáng kể thời gian phát triển bằng cách dùng các chain dựng sẵn do LangChain cung cấp cho những tác vụ cấp cao phổ biến.

2. Đưa vào quy mô sản xuất

Ở giai đoạn này, bạn sẽ kiểm thử ứng dụng trước càng nhiều kịch bản càng tốt. Điều này có nghĩa bạn phải đảm bảo mỗi thành phần thêm vào hoạt động tốt, xâu chuỗi tốt và cho ra đầu ra nhất quán, chất lượng cao.

Vì LLM là không tất định (không tạo cùng một đầu ra cho cùng một đầu vào) và do độ phức tạp của các thành phần bổ sung, bạn sẽ dành phần lớn thời gian ở giai đoạn này. Và LangSmith được phát triển với mục tiêu duy nhất là rút ngắn thời gian đó hết mức có thể. Chúng ta sẽ bàn thêm về điều này xuyên suốt hướng dẫn.

3. Triển khai

Khi đã có ứng dụng khả thi, bạn có thể triển khai nó như một REST API. Về cơ bản, REST API chuyển các chain hoặc agent LangChain hiện có của bạn thành các liên kết HTTPS để người khác gửi yêu cầu tương tác với mô hình AI của bạn. Lúc này, bạn sẽ xây giao diện người dùng cho dịch vụ, như ứng dụng desktop hoặc, phổ biến hơn, một trang web.

Hiện chưa có cách đơn giản để làm điều này, nhưng các nhà phát triển LangChain sắp ra mắt LangServe, sẽ tích hợp vào FastAPI (sẽ tuyệt đến mức nào?). Xem bản xem trước tại trang tài liệu này.

Giờ thì bắt tay khám phá LangSmith.

Tổng quan nền tảng LangSmith

Chúng ta sẽ bắt đầu bằng việc tìm hiểu giao diện web. Có thể truy cập qua liên kết smith.langchain.com. Để vào được, bạn cần đăng ký và chờ duyệt khỏi danh sách chờ, vì hiện vẫn đang trong giai đoạn beta kín.

Khi vào được, trang chào mừng sẽ trông như thế này:

Hai phần chính là dự án và bộ dữ liệu & kiểm thử, và cả hai có thể thao tác qua Python SDK. Nền tảng cũng có tab triển khai và hàng đợi gán nhãn, nhưng nằm ngoài phạm vi bài viết này.

Thiết lập LangSmith Python SDK

Quản lý dự án trong LangSmith dễ hơn nhiều với Python SDK của nó, kết nối tới nền tảng qua khóa API.

Để lấy khóa, nhấp biểu tượng chìa khóa trong nền tảng và lưu ở nơi an toàn. Sau đó, trong một thư mục mới với môi trường ảo mới đã khởi tạo, tạo tệp .env. Bên trong, dán hai dòng sau:

LANGCHAIN_API_KEY="LangSmith-API-key"
OPENAI_API_KEY="Your-OPENAI-key"Được hỗ trợ bởi

Tiếp theo, trong terminal, chạy các lệnh sau để cài LangSmith và python-dotenv để đọc biến môi trường:

python-dotenv to read environment variables:
pip install -U langsmith
pip install python-dotenvĐược hỗ trợ bởi

Giờ thì viết mã:

import warnings

from dotenv import find_dotenv, load_dotenv

warnings.filterwarnings("ignore")
Được hỗ trợ bởi

Chúng ta import các hàm find_dotenv và load_dotenv để đọc biến môi trường và thiết lập chúng với os:

import os

load_dotenv(find_dotenv())
os.environ["LANGCHAIN_API_KEY"] = str(os.getenv("LANGCHAIN_API_KEY"))
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
Được hỗ trợ bởi

Đặt LANGCHAIN_TRACING_V2 là True sẽ bật tracing (ghi log), điều thiết yếu để gỡ lỗi LLM. Sau đó, khởi tạo client để giao tiếp với nền tảng LangSmith:

from langsmith import Client

# Initialize a client
client = Client()
Được hỗ trợ bởi

client chứa các lệnh cấp cao để thao tác dự án và tài sản trong LangSmith. Lệnh đầu tiên chúng ta dùng là tạo một dự án mới:

import uuid

# Create id
uid = uuid.uuid4()
# Create a unique name
PROJECT_NAME = "flashcards-generator-" + str(uid)
# Create the project
session = client.create_project(
   project_name=PROJECT_NAME,
   description="A project that generates flashcards from user input",
)
Được hỗ trợ bởi

Sau khi create_project chạy thành công, bạn có thể thấy dự án xuất hiện trong mục Projects trên giao diện web:

Tiếp theo, chúng ta cần đặt dự án mới làm mặc định bằng một biến môi trường khác:

os.environ["LANGCHAIN_PROJECT"] = PROJECT_NAME
Được hỗ trợ bởi

Giờ chúng ta cần một LLM cho dự án. Chúng tôi sẽ dùng GPT-3.5 turbo vì chi phí rẻ hơn, nhưng bạn có thể dùng nhiều mô hình khác có sẵn qua langchain. Các mô hình OpenAI được khởi tạo qua lớp ChatOpenAI.

from langchain.chat_models import ChatOpenAI

llm = ChatOpenAI()  # Uses gpt-3.5-turbo by default
Được hỗ trợ bởi

Thực hiện lần chạy đầu tiên:

llm.invoke("Hello, chatty, how you doin' today?")

AIMessage(content="Hello! I'm an AI language model, so I don't have feelings, but I'm here to help you. How can I assist you today?")
Được hỗ trợ bởi

Nếu bạn kiểm tra nhanh dự án trên giao diện, bạn sẽ thấy lần chạy trên đã được trace (ghi log):

Khi thiết lập biến môi trường và client, chúng ta đã tự động bật ghi log. Như bạn thấy, ta đã có một loạt metadata về lần chạy.

Chạy thêm vài prompt nữa:

message = llm.invoke("Do you know how to generate flashcards?")

message.content[:50]

'Yes, I can help you generate flashcards. There are'
Được hỗ trợ bởi

Chúng ta đã có thể xây một bộ tóm tắt văn bản cơ bản. Hãy tóm tắt đầu ra của lần chạy vừa rồi:

prompt = f"Summarize this text: {message.content}"

summary = llm.invoke(prompt)
summary.content

'The text explains different methods for creating flashcards. These methods include writing on small index cards, using online flashcard generators, utilizing flashcard apps on mobile devices, and using word processing software like Microsoft Word or Google Docs. It emphasizes the importance of consistency in format and organization for effective studying.'
Được hỗ trợ bởi

Tuyệt vời, giờ là lúc tạo bộ dữ liệu đầu tiên.

Tạo bộ dữ liệu chưa gán nhãn trong LangSmith

Như tôi đã nói ở phần “Quy trình phát triển ứng dụng LLM”, bạn nhiều khả năng sẽ cần tạo hoặc thu thập hàng nghìn prompt để đánh giá mô hình, chain hoặc agent LLM của mình. Vì vậy, chạy từng prompt như trên không phải cách tốt nhất.

Vì lý do này, LangSmith cung cấp ba loại bộ dữ liệu:

• Key-value (kv) - mặc định: Định nghĩa đầu vào là các cặp khóa-giá trị tùy ý. Hữu ích khi đánh giá các chain và agent cần nhiều đầu vào hoặc trả về nhiều đầu ra.
• Bộ dữ liệu LLM (llm): Đầu vào và đầu ra được định nghĩa theo kiểu “hoàn thành” của LLM - vào chuỗi, ra chuỗi.
• Bộ dữ liệu chat (chat): Các bộ dữ liệu này được chuyển đổi từ các phiên chat LLM và định nghĩa bằng đầu vào có cấu trúc và thông điệp được tuần tự hóa.

Trước hết, hãy xem cách tạo bộ dữ liệu key-value không có đầu ra. Ta sẽ dùng hàm create_dataset của client:

create_dataset function of the client:
dataset_name = "deep_learning_fundamentals"

# Creating a blank dataset
dl_dataset = client.create_dataset(
   dataset_name=dataset_name,
   description="A deck containing flashcards on NNs and PyTorch",
   data_type="kv",  # default
)
Được hỗ trợ bởi

Giờ thêm ba đầu vào, mỗi đầu vào yêu cầu LLM tạo một thẻ ghi nhớ:

# Storing only inputs into a dataset
example_inputs = [
   "Generate a single flashcard on backpropagation",
   "Generate a single flashcard on the use of torch.no_grad",
   "Generate a single flashcard on how Adam optimizer",
]

for ex in example_inputs:
   # Each example input must be unique
   # The output is optional
   client.create_example(
       inputs={"input": ex},
       outputs=None,
       dataset_id=dl_dataset.id,
   )
Được hỗ trợ bởi

Nếu bạn vào tab dataset trên giao diện, sẽ thấy mỗi prompt được liệt kê với đầu ra NULL:

Giờ hãy chạy tất cả prompt trong một dòng mã bằng hàm run_on_dataset:

from langchain.smith import run_on_dataset

results = run_on_dataset(
   client=client,
   dataset_name=dataset_name,
   llm_or_chain_factory=llm,
   project_name="unlabeled_test",
)
Được hỗ trợ bởi

Sau khi chạy xong, nó sẽ xuất hiện trên trang dataset. Trông như sau:

Chúng ta vừa chạy thử trên một bộ dữ liệu chưa gán nhãn — bộ có ví dụ prompt nhưng không có ví dụ đầu ra. Bài test của ta chỉ tạo phản hồi cho mỗi prompt mà chưa đánh giá gì. Nhưng ta muốn kiểm tra cơ bản như “Đầu ra có hữu ích không?” hay “Phản hồi ngắn hay dài”?

LangSmith cho phép thực hiện các kiểm tra như vậy bằng các bộ đánh giá tích hợp.

Đánh giá LLM trong LangSmith

Để chạy các đánh giá conciseness và coherence với ba prompt trong bộ dữ liệu, ta có thể dùng lớp RunEvalConfig:

from langchain.smith import RunEvalConfig

# List the eval criteria
eval_config = RunEvalConfig(
   evaluators=[
       RunEvalConfig.Criteria("conciseness"),
       RunEvalConfig.Criteria("coherence"),
   ]
)
Được hỗ trợ bởi

Ở trên, ta định nghĩa hai tiêu chí trong một danh sách gọi là evaluators. Ta truyền các evaluator này vào tham số evaluation của hàm run_on_dataset:

results = run_on_dataset(
   client=client,
   dataset_name=dataset_name,
   llm_or_chain_factory=llm,
   evaluation=eval_config,
   project_name="criteria_test",
)
Được hỗ trợ bởi

run_on_dataset là hàm hữu ích để chạy tất cả prompt trong một bộ dữ liệu bằng LLM đã cho và thực hiện mọi loại đánh giá ngay trong quá trình. Kết quả sẽ hiển thị trên trang riêng của mỗi bộ dữ liệu:

Lần này, lần chạy có các chỉ số mạch lạc và súc tích cho mỗi prompt. Ở cuối, bạn cũng sẽ thấy điểm trung bình cho mỗi chỉ số.

Để xem danh sách tất cả tiêu chí tích hợp, chạy đoạn sau:

from langchain.evaluation import Criteria

list(Criteria)

[<Criteria.CONCISENESS: 'conciseness'>,
<Criteria.RELEVANCE: 'relevance'>,
<Criteria.CORRECTNESS: 'correctness'>,
<Criteria.COHERENCE: 'coherence'>,
<Criteria.HARMFULNESS: 'harmfulness'>,
<Criteria.MALICIOUSNESS: 'maliciousness'>,
<Criteria.HELPFULNESS: 'helpfulness'>,
<Criteria.CONTROVERSIALITY: 'controversiality'>,
<Criteria.MISOGYNY: 'misogyny'>,
<Criteria.CRIMINALITY: 'criminality'>,
<Criteria.INSENSITIVITY: 'insensitivity'>,
<Criteria.DEPTH: 'depth'>,
<Criteria.CREATIVITY: 'creativity'>,
<Criteria.DETAIL: 'detail'>]
Được hỗ trợ bởi

Viết bộ đánh giá tùy chỉnh trong LangSmith cho bộ dữ liệu chưa gán nhãn

Dĩ nhiên không phải mọi trường hợp dùng LLM đều có thể kiểm tra bằng các bộ đánh giá cơ bản. Ví dụ, không có bộ đánh giá để kiểm tra thẻ ghi nhớ có chứa câu hỏi về mã hay không. Vậy ta nên định nghĩa nó:

eval_config = RunEvalConfig(
   evaluators=[
       RunEvalConfig.Criteria(
           {"has_code": "Does the card contain a code syntax question?"}
       ),
       RunEvalConfig.Criteria(
           {
               "is_vague": "Is the front of the flashcard vague, meaning it hasn't enough context to answer?"
           }
       ),
   ]
)
Được hỗ trợ bởi

Để truyền tiêu chí tùy chỉnh bằng ngôn ngữ tự nhiên, ta chỉ cần truyền {“tên_tiêu_chí”: “Điều kiện cần kiểm tra”} vào lớp Criteria. Ở trên, ta tạo hai bộ đánh giá bổ sung, vì vậy LangSmith sẽ chạy thêm hai prompt bên trên đầu ra do các prompt trong bộ dữ liệu tạo ra:

# Run the evaluation
results = run_on_dataset(
   client,
   dataset_name,
   llm,
   evaluation=eval_config,
   project_name="custom_criteria_test",
)
Được hỗ trợ bởi

Nếu bạn kiểm tra lần chạy, bạn sẽ thấy tiêu chí tùy chỉnh ta đã định nghĩa dưới mỗi prompt. Di chuột vào, bạn sẽ thấy lập luận của LLM sau đó:

Khi kiểm tra kết quả đánh giá cho mọi prompt, bạn sẽ thấy các tiêu chí của ta chưa đánh giá đúng như kỳ vọng. Vậy có điều cần lưu ý — bạn cũng cần “prompt-engineer” cho chính tiêu chí của mình để đảm bảo chúng kiểm đúng điều cần kiểm.

Tạo bộ dữ liệu đã gán nhãn

Đôi khi, bạn có thể quyết định tạo một bộ dữ liệu gồm các prompt kèm đầu ra kỳ vọng, tức bộ dữ liệu đã gán nhãn. Bạn có thể tạo bộ dữ liệu gán nhãn ở nhiều định dạng, nhưng có lẽ phổ biến nhất là tệp CSV. Ví dụ, đây là một tệp tôi tạo bằng ChatGPT, chứa năm câu hỏi về cú pháp PyTorch:

Để tạo bộ dữ liệu từ tệp này, ta có thể dùng hàm upload_csv:

dataset_name = "PyTorch code syntax"

csv_path = "data/pytorch_code_syntax_flashcards.csv"
input_keys = ["front"]
output_keys = ["back"]

csv_dataset = client.upload_csv(
   csv_file=csv_path,
   input_keys=input_keys,
   output_keys=output_keys,
   name=dataset_name,
   data_type="kv",
)
Được hỗ trợ bởi

Hàm này có ba tham số bắt buộc: đường dẫn CSV và tên các cột đầu vào/đầu ra. Khi tải lên xong, bộ dữ liệu sẽ xuất hiện trên giao diện:

Hãy chạy tiêu chí tùy chỉnh ở phần trước trên bộ dữ liệu này nữa:

eval_config = RunEvalConfig(
   evaluators=[
       RunEvalConfig.Criteria(
           {"has_code": "Does the card contain a code syntax question?"}
       ),
       RunEvalConfig.Criteria(
           {
               "is_vague": "Is the front of the flashcard vague, meaning it hasn't enough context to answer?"
           }
       ),
   ]
)

# Run the evaluation
results = run_on_dataset(
   client,
   dataset_name,
   llm,
   evaluation=eval_config,
   project_name="custom_criteria_test_csv",
)
Được hỗ trợ bởi

Nếu bạn vào trang bộ dữ liệu và kiểm tra lần chạy, chúng ta có thể thấy điểm trung bình cho mỗi tiêu chí tùy chỉnh:

Đánh giá bộ dữ liệu đã gán nhãn

Các bộ đánh giá tích hợp và tùy chỉnh viết bằng ngôn ngữ tự nhiên chủ yếu dành cho bộ dữ liệu chưa gán nhãn. Với các bộ dữ liệu đã gán nhãn như CSV ta đã tải lên, LangSmith cung cấp các bộ đánh giá toàn diện hơn để đo mức độ đúng đắn của phản hồi đối với một prompt:

• context_qa (Hỏi đáp theo ngữ cảnh): Dùng đầu ra mẫu làm ngữ cảnh khi đánh giá độ đúng
• qa (Hỏi đáp): Chỉ dẫn LLM chấm trực tiếp phản hồi là "đúng" hoặc "sai" bằng đầu ra tham chiếu
• cot_qa (Hỏi đáp chuỗi suy luận): Tương tự context_qa nhưng buộc LLM sử dụng suy luận chuỗi trước khi đưa ra kết luận.

Hãy thử cái cuối cùng trên các ví dụ của ta:

eval_config = RunEvalConfig(evaluators=[RunEvalConfig.CoTQA()])

results = run_on_dataset(
   client,
   dataset_name,
   llm,
   evaluation=eval_config,
   project_name="cotqa_test",
)
Được hỗ trợ bởi

Tiêu chí CoTQA trả về một điểm gọi là Contextual accuracy, như minh họa trong GIF dưới đây (và trên giao diện):

Vui lòng truy cập mục bộ đánh giá của LangChain trong tài liệu LangSmith để tìm hiểu thêm.

Kết luận

Nếu sau khi đọc hướng dẫn này, bạn thấy LangSmith thực chất là một công cụ phức tạp dành cho prompt engineering, thì bạn đã nhận định đúng! Hiện tại, LangSmith là khung tốt nhất để đảm bảo chỉ dẫn và đầu ra của LLM đúng như bạn mong muốn.

Bạn hẳn cũng nhận ra công sức cần có để xây dựng ứng dụng LLM đạt chuẩn sản xuất. Vì vậy, hãy dùng LangSmith để có trải nghiệm mượt mà hơn khi làm việc với dự án LLM.

Nếu một số khái niệm trong LangSmith chưa rõ ràng, có thể bạn còn thiếu một vài nền tảng về LangChain. Dưới đây là một số tài nguyên:

• Giới thiệu LangChain cho Kỹ thuật dữ liệu
• Xây chatbot nhận thức ngữ cảnh trong LangChain
• Prompt Engineering trong LangChain
• Cách xây dựng ứng dụng LLM với LangChain
• Tài liệu LangChain
• Tài liệu LangSmith