Tổng quan về quy trình Model I/O

Trong hệ sinh thái LangChain, việc tương tác với các mô hình ngôn ngữ được chuẩn hóa thông qua quy trình Model I/O. Quy trình này bao gồm ba giai đoạn chính:

• Định dạng (Format): Sử dụng Prompt Templates để xây dựng đầu vào linh hoạt.
• Dự đoán (Predict): Kết nối và gọi các mô hình ngôn ngữ (LLMs hoặc Chat Models) thông qua giao diện chung.
• Phân tích (Parse): Trích xuất và chuyển đổi phản hồi từ mô hình thành dữ liệu có cấu trúc.

1. Prompt Templates (Mẫu gợi ý)

Prompt Template giúp trừu tượng hóa các chuỗi văn bản, cho phép chèn các biến động vào mẫu có sẵn. Điều này cực kỳ hữu ích cho việc tái sử dụng logic gợi ý trong các tác vụ tự động hóa.

Mẫu gợi ý dạng chuỗi (String Prompt Template)

Đây là dạng cơ bản nhất, nhận vào các biến và trả về một chuỗi văn bản thuần túy.

from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate
import os
from dotenv import load_dotenv

load_dotenv()

# Khởi tạo instance cho mô hình
llm_service = ChatOpenAI(
    api_key=os.getenv("API_KEY"),
    base_url="https://api.example.com/v1",
    model='gpt-3.5-turbo'
)

# Thiết lập template
custom_prompt = PromptTemplate(
    input_variables=["topic"],
    template="Bạn là một chuyên gia về {topic}. Hãy giải thích khái niệm này một cách ngắn gọn."
)

# Tạo nội dung prompt thực tế
final_input = custom_prompt.format(topic="Hệ điều hành")

# Thực thi và lấy kết quả
response = llm_service.invoke(final_input)
print(response.content)

Mẫu gợi ý cho Chat (Chat Prompt Template)

Mô hình Chat yêu cầu đầu vào là danh sách các tin nhắn có vai trò cụ thể như System, Human, và AI.

from langchain_openai import ChatOpenAI
from langchain.prompts.chat import ChatPromptTemplate

# Định nghĩa cấu trúc hội thoại
chat_layout = ChatPromptTemplate.from_messages([
    ("system", "Bạn là một trợ lý ảo hỗ trợ lập trình viên ngôn ngữ {language}."),
    ("human", "Làm thế nào để tối ưu hóa đoạn code sau: {code}")
])

# Cấu hình Model
ai_model = ChatOpenAI(model="gpt-4")

# Kết hợp dữ liệu vào template
formatted_messages = chat_layout.format_messages(
    language="Python",
    code="[i for i in range(100) if i % 2 == 0]"
)

# Gọi model
output = ai_model.invoke(formatted_messages)
print(output.content)

Kỹ thuật Few-Shot Prompting

Phương pháp này cung cấp cho mô hình một vài ví dụ mẫu để nó hiểu ngữ cảnh và cách phản hồi mong muốn.

from langchain_core.prompts import PromptTemplate, FewShotPromptTemplate

# Danh sách các ví dụ minh họa
training_data = [
    {"query": "Nóng", "answer": "Lạnh"},
    {"query": "Nhanh", "answer": "Chậm"},
]

# Template cho từng ví dụ
item_template = "Từ gốc: {query}\nTừ trái nghĩa: {answer}"
item_prompt = PromptTemplate.from_template(item_template)

# Xây dựng FewShotPromptTemplate
few_shot_engine = FewShotPromptTemplate(
    examples=training_data,
    example_prompt=item_prompt,
    prefix="Hãy tìm từ trái nghĩa cho các từ dưới đây:",
    suffix="Từ gốc: {input}\nTừ trái nghĩa:",
    input_variables=["input"]
)

print(few_shot_engine.format(input="Cao"))

2. Các loại Model trong LangChain

LangChain phân loại các mô hình thành ba nhóm chính để tối ưu hóa mục đích sử dụng:

• LLMs (Large Language Models): Nhận văn bản và trả về văn bản (Text-in, Text-out).
• Chat Models: Được tinh chỉnh cho hội thoại, nhận danh sách tin nhắn và trả về tin nhắn AI.
• Embedding Models: Chuyển đổi văn bản thành các vector số thực (embeddings) phục vụ cho việc tìm kiếm ngữ nghĩa.

Sử dụng Embedding Model

Ví dụ về việc chuyển đổi văn bản thành vector để lưu trữ vào cơ sở dữ liệu vector.

from langchain_community.embeddings import DashScopeEmbeddings
import os

# Khởi tạo dịch vụ nhúng văn bản
embed_engine = DashScopeEmbeddings(
    dashscope_api_key=os.getenv("DASHSCOPE_API_KEY"),
    model='text-embedding-v1'
)

# Chuyển đổi danh sách tài liệu thành vector
doc_vectors = embed_engine.embed_documents(["Dữ liệu lớn", "Trí tuệ nhân tạo"])
print(f"Số lượng vector: {len(doc_vectors)}")

# Chuyển đổi một câu truy vấn
query_vector = embed_engine.embed_query("AI là gì?")
print(query_vector[:5]) # In 5 chiều đầu tiên

3. Output Parsers (Bộ phân tích đầu ra)

Để tích hợp kết quả từ AI vào các hệ thống phần mềm, chúng ta cần dữ liệu có cấu trúc như JSON hoặc List thay vì văn bản tự do.

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import JsonOutputParser
from pydantic import BaseModel, Field

# Định nghĩa cấu trúc dữ liệu mong muốn
class Smartphone(BaseModel):
    brand: str = Field(description="Hãng điện thoại")
    model: str = Field(description="Tên dòng máy")

# Khởi tạo Parser
json_parser = JsonOutputParser(pydantic_object=Smartphone)

# Tạo Prompt bao gồm hướng dẫn format của parser
prompt_node = ChatPromptTemplate.from_messages([
    ("system", "Bạn là một chuyên gia công nghệ. {format_instructions}"),
    ("user", "Hãy đề xuất một điện thoại tốt nhất của {company}")
])

# Truyền hướng dẫn định dạng vào prompt
prompt_with_format = prompt_node.partial(format_instructions=json_parser.get_format_instructions())

# Thiết lập chuỗi xử lý (Chain) bằng LCEL
llm = ChatOpenAI(model="gpt-3.5-turbo")
processing_chain = prompt_with_format | llm | json_parser

# Thực thi
result = processing_chain.invoke({"company": "Apple"})
print(type(result)) # Trả về <class 'dict'>
print(result)