Xây dựng tác nhân LangChain để tự động hóa tác vụ trong Python

Thiết lập

Trước khi bắt đầu, hãy thiết lập môi trường cho bài hướng dẫn.

Đầu tiên, tạo một môi trường Conda mới:

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

Cài đặt các gói của LangChain và một số thư viện cần thiết khác:

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

Thêm môi trường Conda vừa tạo vào Jupyter như một kernel:

$ ipython kernel install --user --name=langchain

Tạo tệp .env để lưu trữ các bí mật như khóa API:

$ touch .env
$ vim .env  # Paste your OPENAI key

OPENAI_API_KEY='YOUR_KEY_HERE'

Lấy khóa API OpenAI của bạn từ tệp .env:

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')

Kiểm tra mọi thứ hoạt động đúng bằng cách truy vấn GPT-3.5 (mô hình ngôn ngữ mặc định) của OpenAI:

from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])

There is no definitive answer to this question, as it is subjective and de

Giờ thì chúng ta đã sẵn sàng bắt đầu.

LangChain Agents là gì?

Hãy dành chút thời gian suy nghĩ về khung tác nhân (agent framework). Cụ thể, chúng ta sẽ xét xem nó khác gì so với mô hình chuỗi (chain) truyền thống và các thành phần của một tác nhân gồm những gì. Hiểu vì sao cần chọn một cách mới để xây dựng ứng dụng sẽ giúp chúng ta sẵn sàng viết mã.

Chuỗi (Chains) so với Tác nhân (Agents)

Đặc điểm xác định của tác nhân là khả năng chọn thứ tự hành động tối ưu để giải quyết vấn đề dựa trên một tập công cụ.

Ví dụ, giả sử chúng ta có các công cụ sau:

• API thời tiết
• Mô hình ML gợi ý trang phục
• API Strava cho tuyến đường đạp xe
• Cơ sở dữ liệu sở thích người dùng
• Mô hình nhận dạng hình ảnh
• Mô hình ngôn ngữ (tạo văn bản)

Cách giải quyết truyền thống sẽ là dùng một chuỗi các công cụ được chọn từ danh sách:

Chuỗi 1: Gợi ý trang phục theo thời tiết

1. Gọi API thời tiết
2. Đưa dữ liệu thời tiết vào mô hình ML gợi ý trang phục
3. Tạo gợi ý trang phục
4. Trình bày kết quả cho người dùng

Chuỗi 2: Gợi ý tuyến đường đạp xe theo thời tiết

1. Gọi API thời tiết
2. Gọi API Strava để lấy các tuyến phổ biến
3. Lọc tuyến theo điều kiện thời tiết
4. Trình bày các tuyến phù hợp cho người dùng

Chuỗi 3: Phân tích ảnh trang phục

1. Nhận ảnh trang phục của người dùng
2. Dùng mô hình nhận dạng hình ảnh để nhận diện các món đồ
3. So sánh với cơ sở dữ liệu sở thích người dùng
4. Tạo phản hồi bằng mô hình tạo văn bản
5. Trình bày phân tích cho người dùng

Mỗi chuỗi giải quyết một vấn đề cụ thể bằng một trình tự bước định sẵn và một tập con công cụ khả dụng. Chúng không thể thích ứng vượt ngoài phạm vi đã định. Đồng thời, chúng đòi hỏi ba nhánh phát triển riêng biệt, kém hiệu quả về thời gian và nguồn lực.

Giờ hãy hình dung một hệ thống tác nhân có quyền truy cập tất cả các công cụ này. Nó sẽ có thể:

1. Hiểu truy vấn hay vấn đề của người dùng (qua ngôn ngữ tự nhiên với mô hình ngôn ngữ)
2. Đánh giá công cụ nào liên quan đến vấn đề (lập luận)
3. Tạo một quy trình làm việc động bằng những công cụ phù hợp nhất
4. Thực thi quy trình, điều chỉnh theo thời gian thực nếu cần (hành động)
5. Đánh giá kết quả và học hỏi từ các tương tác trước

Ví dụ, nếu người dùng hỏi: “Hôm nay tôi nên mặc gì khi đạp xe?” tác nhân có thể kiểm tra API thời tiết, phân tích các tuyến đạp xe phù hợp qua Strava, gợi ý trang phục phù hợp có xét tới sở thích trước đó của người dùng, và tạo phản hồi cá nhân hóa.

Tác nhân có thể:

• Xử lý đa dạng vấn đề với cùng một bộ công cụ
• Tạo quy trình tùy biến cho từng tình huống riêng
• Thích ứng cách tiếp cận dựa trên ngữ cảnh cụ thể và nhu cầu người dùng
• Học từ tương tác để cải thiện hiệu năng tương lai

Khả năng của LangChain trong việc biến các mô hình ngôn ngữ — vốn chỉ tạo văn bản — thành động cơ lập luận có thể tận dụng tài nguyên sẵn có để hành động phù hợp là một trong những ứng dụng chính của nó. Nói ngắn gọn, LangChain cho phép phát triển các tác nhân tự chủ mạnh mẽ tương tác với thế giới bên ngoài.

Các thành phần chính

Một tác nhân LangChain gồm nhiều thành phần như mô hình chat, mẫu nhắc (prompt templates), công cụ bên ngoài và các cấu trúc liên quan khác. Để xây dựng tác nhân hiệu quả, chúng ta cần xem lại từng thành phần và hiểu cách dùng.

Mô hình ngôn ngữ và mô hình chat

Có rất nhiều bộ phận chuyển động khi tạo một tác nhân LangChain. Đầu tiên và rõ ràng nhất là mô hình ngôn ngữ.

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key, model="gpt-3.5-turbo-instruct")
question = "What is special about the number 73?"
output = llm.invoke(question)
print(output[:100])

1. Prime Number: 73 is a prime number, which means it is only divisible by 1 and itself. This make

Mô hình ngôn ngữ, như GPT-3.5 Turbo của OpenAI, nhận và tạo chuỗi ký tự. Chúng thường là các thế hệ cũ hơn và hoạt động tốt để trả lời các truy vấn đơn lẻ của người dùng.

Các mô hình mới và mạnh hơn thường là mô hình chat, có thể nhận một chuỗi thông điệp làm đầu vào và trả về thông điệp chat làm đầu ra (thay vì dùng văn bản thuần):

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessageChunk, SystemMessage
# Initialize the model
chat_model = ChatOpenAI(api_key=api_key, model='gpt-4o-mini')
# Write the messages
messages = [SystemMessage(content='You are a grumpy pirate.'),
           HumanMessage(content="What's up?")]
output = chat_model.invoke(messages)

Nói cách khác, mô hình chat cho phép chúng ta trò chuyện bằng ngôn ngữ tự nhiên. Trong ví dụ trên, chúng ta khởi tạo GPT-4o-mini với một thông điệp hệ thống rồi tới truy vấn của người dùng. Lưu ý việc sử dụng các lớp SystemMessage và HumanMessage.

Biến output là một đối tượng thông điệp, đây là hành vi mong đợi của các mô hình chat:

type(output)

langchain_core.messages.ai.AIMessage

print(output.content)

Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!

Ngoài ra, chúng trả về các metadata hữu ích khác có thể truy cập bằng cú pháp chấm:

output.dict()

{'content': "Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!",
'additional_kwargs': {},
'response_metadata': {'token_usage': {'completion_tokens': 38,
  'prompt_tokens': 21,
  'total_tokens': 59},
 'model_name': 'gpt-4o-mini-2024-07-18',
 'system_fingerprint': 'fp_48196bc67a',
 'finish_reason': 'stop',
 'logprobs': None},
'type': 'ai',
'name': None,
'id': 'run-fde829bf-8f5f-4926-a1ed-ab53609ce03a-0',
'example': False,
'tool_calls': [],
'invalid_tool_calls': [],
'usage_metadata': {'input_tokens': 21,
 'output_tokens': 38,
 'total_tokens': 59}}

Đa số tác nhân dùng mô hình chat vì kiến thức cập nhật hơn và khả năng hội thoại. Tuy nhiên, với tác nhân đơn giản không cần bộ nhớ, các mô hình ngôn ngữ như GPT-3.5 là đủ.

Mẫu nhắc (Prompt templates)

Cách hiệu quả nhất để truy vấn mô hình ngôn ngữ hoặc chat là dùng các mẫu nhắc. Chúng giúp bạn cấu trúc truy vấn nhất quán và chèn biến động, làm cho tương tác với mô hình linh hoạt và tái sử dụng hơn.

Trong LangChain có nhiều loại mẫu nhắc, cơ bản nhất là lớp PromptTemplate. Nó có thể dùng với mô hình ngôn ngữ (văn bản thuần):

from langchain_core.prompts import PromptTemplate
query_template = "Tell me about {book_name} by {author}."
prompt = PromptTemplate(input_variables=["book_name", "author"], template=query_template)
prompt.invoke({"book_name": "Song of Ice and Fire", "author": "GRRM"})

StringPromptValue(text='Tell me about Song of Ice and Fire by GRRM.')

Lớp này yêu cầu bạn tạo một chuỗi có chỗ trống cho biến cần thay bằng ký hiệu ngoặc. Sau đó, bạn truyền chuỗi mẫu này vào lớp PromptTemplate cùng tên các biến, nhờ đó tạo ra prompt của bạn.

Gọi .invoke() với các giá trị biến sẽ cho thấy prompt của bạn sẽ được truyền vào mô hình ra sao.

Truyền mẫu nhắc này cho mô hình ngôn ngữ yêu cầu chúng ta xâu chuỗi nó bằng toán tử ống:

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key)
# Create a chain
chain = prompt | llm
# Invoke the chain
output = chain.invoke({"book_name": "Deathly Hallows", "author": "J.K. Rowling"})
print(output[:100])

Deathly Hallows is the seventh and final book in the popular Harry Potter series, written by J.K. R

Toán tử ống (|) là một phần của Ngôn ngữ Biểu thức LangChain (LCEL), được thiết kế để xâu chuỗi nhiều thành phần và công cụ LangChain.

type(chain)

langchain_core.runnables.base.RunnableSequence

Khi bạn dùng toán tử ống trên các đối tượng LangChain, bạn tạo một thể hiện của lớp RunnableSequence. Một chuỗi có thể chạy đại diện cho một xâu các đối tượng hỗ trợ phương thức .invoke(), như mẫu nhắc và mô hình ngôn ngữ/chat.

Giờ hãy xem một lớp mẫu nhắc khác dành cho mô hình chat:

from langchain_core.prompts import ChatPromptTemplate

Chúng ta đã nói rằng mô hình chat cần một chuỗi thông điệp làm đầu vào. Thông điệp đầu thường là một prompt hệ thống cho biết mô hình chat nên hành xử thế nào. Vì vậy, dùng lớp ChatPromptTemplate, ta có thể dễ dàng tạo mô hình chat với các “tính cách” khác nhau:

chat_model = ChatOpenAI(api_key=api_key, model="gpt-4o-mini")
template = ChatPromptTemplate([
   ('system', 'You are a helpful AI bot. Your specialty is {specialty}.'),
   ('human', 'Explain the concept of {concept} based on your expertise.')
])

Lớp này yêu cầu một danh sách thông điệp theo vai trò làm đầu vào. Mỗi phần tử phải là một bộ (vai trò, thông điệp) với các chỗ trống biến được xác định khi cần.

Sau khi sẵn sàng, ta có thể dùng cùng toán tử ống để tạo các mô hình chat với hành vi khác nhau:

specialties = ["psychology", "economics", "politics"]
concept = "time"
# Call the model with different personalities
for s in specialties:
   chain = template | chat_model
   output = chain.invoke({"specialty": s, "concept": concept})
   print(output.content[:100], end="\n" + "-" * 25 + '\n')

Time is a complex and multifaceted concept that has been explored from various perspectives, includi
-------------------------
In economics, the concept of time is multifaceted and plays a crucial role in various theories and m
-------------------------
While my primary focus is on politics, I can provide a brief overview of the concept of time as it m
-------------------------

Công cụ (Tools)

Ở phần trước, chúng ta đã đề cập rằng tác nhân có thể chọn kết hợp các công cụ sẵn có để giải quyết một vấn đề, với LLM đóng vai trò động cơ lập luận bên dưới.

LangChain cung cấp tích hợp với hàng chục API và dịch vụ phổ biến để các tác nhân có thể tương tác với phần còn lại của thế giới. Phần lớn có sẵn trong gói langchain_community, một số nằm trong langchain_core.

Ví dụ, đây là cách bạn có thể dùng công cụ ArXiv để lấy tóm tắt bài báo về nhiều chủ đề:

!pip install -Uq arxiv  # Install arXiv Python SDK

from langchain_community.tools import ArxivQueryRun
tool = ArxivQueryRun()
print(tool.invoke('Photosynthesis')[:250])

Published: 2019-08-28
Title: Photosynthesis on Exoplanets and Exomoons from Reflected Light
Authors: Manasvi Lingam, Abraham Loeb
Summary: Photosynthesis offers a convenient means of sustaining biospheres. We
quantify the constraints for photosynthes

Có một cách khác để nạp công cụ thay vì import bằng tên lớp:

from langchain_community.agent_toolkits.load_tools import load_tools
tools = load_tools(["arxiv", "dalle-image-generator"])

Ở trên, chúng ta nạp đồng thời công cụ arXiv và trình tạo ảnh Dall-E bằng hàm load_tools(). Các công cụ nạp bằng hàm này có cùng cú pháp sử dụng:

# Call arXiv
print(tools[0].invoke("Kaggle")[:150])

Published: 2020-06-06
Title: StackOverflow vs Kaggle: A Study of Developer Discussions About Data Science
Authors: David Hin
Summary: Software develop

# Generate an image with DallE
output_image_url = tools[1].invoke("A magnificent chain in a cartoon.")
output_image_url

'https://oaidalleapiprodscus.blob.core.windows.net/...'

Hàm load_tools yêu cầu bạn biết tên chuỗi của các lớp công cụ, như ví dụ ArxivQueryRun so với 'arxiv'. Bạn có thể nhanh chóng kiểm tra tên chuỗi của bất kỳ công cụ nào bằng cách chạy hàm get_all_tool_names:

from langchain_community.agent_toolkits.load_tools import get_all_tool_names
get_all_tool_names()[:10]

['sleep',
'wolfram-alpha',
'google-search',
'google-search-results-json',
'searx-search-results-json',
'bing-search',
'metaphor-search',
'ddg-search',
'google-lens',
'google-serper']

Lưu ý load_tools() chỉ là một hàm viết tắt. Khi xây dựng tác nhân, khuyến nghị nạp công cụ bằng constructor lớp của chúng để có thể cấu hình theo hành vi cụ thể.

Quy trình từng bước xây dựng LangChain Agents

Cuối cùng, trong phần này, chúng ta sẽ xem cách tạo tác nhân LangChain từng bước dựa trên kiến thức đã có ở các phần trước.

Trong các ví dụ sắp tới, chúng ta sẽ xây dựng một tác nhân có thể giải thích bất kỳ chủ đề nào qua ba phương tiện: văn bản, hình ảnh hoặc video. Cụ thể hơn, dựa trên câu hỏi, tác nhân sẽ quyết định giải thích chủ đề ở định dạng nào.

Bắt đầu thôi. Hãy nhớ xem lại phần thiết lập môi trường ở đầu bài viết. 

1. Định nghĩa công cụ

Bước đầu tiên sau khi cấu hình môi trường là định nghĩa các công cụ sẽ cấp cho tác nhân. Hãy import chúng:

from langchain_community.tools import WikipediaQueryRun  # pip install wikipedia
from langchain_community.utilities import WikipediaAPIWrapper
from langchain_community.tools import YouTubeSearchTool  # pip install youtube_search
from langchain_community.tools.openai_dalle_image_generation import (
   OpenAIDALLEImageGenerationTool
)
from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper

Chúng ta đang import năm lớp:

• WikipediaAPIWrapper: để cấu hình cách truy cập API Wikipedia
• WikipediaQueryRun: để tạo tóm tắt trang Wikipedia
• YouTubeSearchTool: để tìm video YouTube về các chủ đề
• DallEAPIWrapper: để cấu hình cách truy cập endpoint DallE của OpenAI
• OpenAIDALLEImageGenerationTool: để tạo ảnh bằng prompts

Khi người dùng truy vấn tác nhân, nó sẽ quyết định liệu giải thích chủ đề bằng bài viết Wikipedia ở dạng văn bản, hoặc tạo hình ảnh bằng Dall-E để minh họa trực quan, hoặc gợi ý video YouTube để hiểu sâu hơn.

Hãy khởi tạo chúng, bắt đầu với công cụ Wikipedia:

wiki_api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=250)
wikipedia = WikipediaQueryRun(description="A tool to explain things in text format. Use this tool if you think the user’s asked concept is best explained through text.", api_wrapper=wiki_api_wrapper)
print(wikipedia.invoke("Mobius strip"))

Page: Möbius strip
Summary: In mathematics, a Möbius strip, Möbius band, or Möbius loop is a surface that can be formed by attaching the ends of a strip of paper together with a half-twist. As a mathematical object, it was discovered by Johann Benedi

Trình tạo ảnh DallE:

dalle_api_wrapper = DallEAPIWrapper(model="dall-e-3", size="1792x1024")
dalle = OpenAIDALLEImageGenerationTool(
   api_wrapper=dalle_api_wrapper, description="A tool to generate images. Use this tool if you think the user’s asked concept is best explained through an image."
)
output = dalle.invoke("A mountain bike illustration.")
print(output)

Công cụ tìm kiếm YouTube:

youtube = YouTubeSearchTool(
   description="A tool to search YouTube videos. Use this tool if you think the user’s asked concept can be best explained by watching a video."
)
youtube.run("Oiling a bike's chain")

"['https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUVT2lsaW5nIGEgYmlrZSdzIGNoYWlu', 'https://www.youtube.com/watch?v=T6xyn1FGHiU&pp=ygUVT2lsaW5nIGEgYmlrZSdzIGNoYWlu']"

Hãy chú ý mô tả công cụ. Tác nhân sẽ quyết định dùng công cụ nào dựa trên phần mô tả bạn cung cấp. 

Giờ chúng ta sẽ đưa các công cụ vào một danh sách:

tools = [wikipedia, dalle, youtube]

Chúng ta đã có thể bind tập công cụ này vào một mô hình chat mà chưa cần tạo tác nhân:

chat_model = ChatOpenAI(api_key=api_key)
model_with_tools = chat_model.bind_tools(tools)

Hãy thử gọi mô hình với một thông điệp đơn giản:

response = model_with_tools.invoke([HumanMessage("What's up?!")])
print(f"Text response: {response.content}")
print(f"Tools used in the response: {response.tool_calls}")

Text response: Hello! How can I assist you today?
Tools used in the response: []

Kết quả cho thấy không có công cụ nào được dùng khi tạo câu trả lời. Giờ hãy hỏi một câu cụ thể buộc mô hình phải nhìn ra ngoài dữ liệu huấn luyện của nó:

response = model_with_tools.invoke([
   HumanMessage("Can you generate an image of a mountain bike?")
])
print(f"Text response: {response.content}")
print(f"Tools used in the response: {response.tool_calls}")

Text response:
Tools used in the response: [{'name': 'openai_dalle', 'args': {'query': 'mountain bike'}, 'id': 'call_92GBfmsYtPi9TpGuIOFB1pG8', 'type': 'tool_call'}]

Ta thấy không có đầu ra văn bản, nhưng có nhắc đến DallE của OpenAI. Công cụ chưa được gọi; mô hình chỉ đề xuất chúng ta sử dụng nó. Để thực sự gọi công cụ — tức hành động, ta cần tạo một tác nhân.

2. Tạo một tác nhân đơn giản

Sau khi định nghĩa mô hình và công cụ, chúng ta tạo tác nhân. LangChain cung cấp giao diện hàm cấp cao create_react_agent() từ gói langgraph để nhanh chóng tạo tác nhân ReAct (reason and act):

from langgraph.prebuilt import create_react_agent
system_prompt = SystemMessage("You are a helpful bot named Chandler.")
agent = create_react_agent(chat_model, tools, state_modifier=system_prompt)

Khi khởi tạo tác nhân với một mô hình chat và danh sách công cụ, chúng ta truyền thêm một prompt hệ thống để định hướng hành vi chung. Giờ nó đã sẵn sàng nhận truy vấn:

from pprint import pprint
response = agent.invoke({"messages": HumanMessage("What's up?")})
pprint(response["messages"])

[HumanMessage(content="What's up?", id='133b9380-cfe1-495a-98f7-b835c874bd57'),
AIMessage(content='Hello! How can I assist you today?', response_metadata={'token_usage': {'completion_tokens': 10, 'prompt_tokens': 112, 'total_tokens': 122}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-0a920c15-39b4-4857-ab51-6ea905575dba-0', usage_metadata={'input_tokens': 112, 'output_tokens': 10, 'total_tokens': 122})]

Chúng ta nhận được một phản hồi hợp lý, là câu trả lời văn bản đơn giản không có lời gọi công cụ. Giờ hãy hỏi điều gì đó sát chủ đề hơn:

response = agent.invoke({"messages": [
   HumanMessage('Explain how photosynthesis works.')
]})
print(len(response['messages']))

4

Lần này có bốn thông điệp. Hãy xem tên lớp và nội dung của chúng:

for message in response['messages']:
   print(
       f"{message.__class__.__name__}: {message.content}"
   )  # Print message class name and its content
   print("-" * 20, end="\n")

HumanMessage: Explain how photosynthesis works.
--------------------
AIMessage:
--------------------
ToolMessage: Page: Photosynthesis
Summary: Photosynthesis ( FOH-tə-SINTH-ə-sis) is a system of biological processes by which photosynthetic organisms, such as most plants, algae, and cyanobacteria, convert light energy, typically from sunlight, into the chemical
--------------------
AIMessage: Photosynthesis is a biological process where photosynthetic organisms like plants, algae, and cyanobacteria convert light energy, usually from sunlight, into chemical energy. This process involves capturing light energy through pigments like chlorophyll in plant cells and using it to convert carbon dioxide and water into glucose and oxygen. Glucose serves as a source of energy for the plant, while oxygen is released into the atmosphere as a byproduct. Photosynthesis is crucial for the survival of plants and the balance of oxygen and carbon dioxide in the atmosphere.
--------------------

Tuyệt! Thông điệp thứ ba là từ lời gọi công cụ, đó là tóm tắt một trang Wikipedia về quang hợp. Thông điệp cuối là từ mô hình chat, sử dụng nội dung lời gọi công cụ khi xây dựng câu trả lời.

Hãy nhanh chóng tạo một hàm để mô-đun hóa các bước vừa thực hiện:

def execute(agent, query):
   response = agent.invoke({'messages': [HumanMessage(query)]})
  
   for message in response['messages']:
       print(
           f"{message.__class__.__name__}: {message.content}"
       )  # Print message class name and its content
      
       print("-" * 20, end="\n")
  
   return response

3. Tinh chỉnh prompt hệ thống

Giờ hãy cập nhật prompt hệ thống với hướng dẫn chi tiết về cách tác nhân nên hành xử:

system_prompt = SystemMessage(
   """
   You are a helpful bot named Chandler. Your task is to explain topics
   asked by the user via three mediums: text, image or video.
  
   If the asked topic is best explained in text format, use the Wikipedia tool.
   If the topic is best explained by showing a picture of it, generate an image
   of the topic using Dall-E image generator and print the image URL.
   Finally, if video is the best medium to explain the topic, conduct a YouTube search on it
   and return found video links.
   """
)

Hãy tạo lại tác nhân với prompt hệ thống mới:

agent = create_react_agent(chat_model, tools, state_modifier=system_prompt)
response = execute(agent, query='Explain the Fourier Series visually.')

HumanMessage: Explain the Fourier Series visually.
--------------------
AIMessage:
--------------------
ToolMessage: https://oaidalleapiprodscus.blob.core.windows.net/private/org-qRwX4bsgcnaYHHwbxFBdZxUy/user-LOXQPflMtXxamV72hac9oS2O/img-iY3gXXBzWapRWKdmkd9cXEIN.png?st=2024-08-09T18%3A36%3A46Z&se=2024-08-09T20%3A36%3A46Z&sp=r&sv=2024-08-04&sr=b&rscd=inline&rsct=image/png&skoid=d505667d-d6c1-4a0a-bac7-5c84a87759f8&sktid=a48cca56-e6da-484e-a814-9c849652bcb3&skt=2024-08-09T17%3A56%3A46Z&ske=2024-08-10T17%3A56%3A46Z&sks=b&skv=2024-08-04&sig=Ly8F4jvakFeEtpZ/6jMliLq%2BG3Xs%2Bz1AmX1sL06%2BQ3U%3D
--------------------
AIMessage: Here is a visual representation of the Fourier Series:
![Fourier Series](https://oaidalleapiprodscus.blob.core.windows.net/private/org-qRwX4bsgcnaYHHwbxFBdZxUy/user-LOXQPflMtXxamV72hac9oS2O/img-iY3gXXBzWapRWKdmkd9cXEIN.png)
The Fourier Series is a way to represent a function as the sum of simple sine waves. It is used in many areas of mathematics and physics to analyze and understand periodic phenomena.
--------------------

Tuyệt vời, dựa trên thông điệp của chúng ta (rất rõ ràng :), tác nhân đã chọn đúng công cụ cho công việc. Đây là hình ảnh được tạo:

4. Thêm bộ nhớ cho tác nhân

Hiện tại tác nhân của chúng ta là stateless, tức không nhớ các tương tác trước đó:

response = execute(agent, query="What did I ask you in the previous query?")

HumanMessage: What did I ask you in the previous query?
--------------------
AIMessage: I'm sorry, I cannot remember the previous query as I don't have access to the conversation history. How can I assist you today?
--------------------

Cách dễ nhất để thêm lịch sử thông điệp chat cho tác nhân là dùng lớp SqliteSaver của langgraph:

from langgraph.checkpoint.sqlite import SqliteSaver
memory = SqliteSaver.from_conn_string(':agent_history:')
agent = create_react_agent(chat_model, tools, checkpointer=memory, state_modifier=system_prompt)

Chúng ta khởi tạo bộ nhớ bằng phương thức .from_conn_string() của lớp SqliteSaver, tạo một tệp cơ sở dữ liệu. Sau đó, truyền memory vào tham số checkpointer của hàm create_react_agent().

Giờ chúng ta cần tạo một từ điển cấu hình:

config = {'configurable': {'thread_id': 'a1b2c3'}}

Từ điển này định nghĩa một ID luồng để phân biệt các cuộc hội thoại và được truyền vào phương thức .invoke() của tác nhân. Vậy hãy cập nhật hàm execute() để bao gồm hành vi này:

def execute(agent, query, thread_id="a1b2c3"):
   config = {"configurable": {"thread_id": thread_id}}
   response = agent.invoke({'messages': [HumanMessage(query)]}, config=config)
   for message in response["messages"]:
       print(
           f"{message.__class__.__name__}: {message.content}"
       )  # Print message class name and its content
       print("-" * 20, end="\n")
   return response
Let’s test it again:
response = execute(
   agent, query="Explain how to oil a bike's chain using a YouTube video", thread_id="123"
)

HumanMessage: Explain how to oil a bike's chain using a YouTube video
--------------------
AIMessage:
--------------------
ToolMessage: ['https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D', 'https://www.youtube.com/watch?v=ubKCHtZ20-0&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D']
--------------------
AIMessage: I found a couple of YouTube videos that explain how to oil a bike chain:
1. [Video 1: How to oil a bike chain](https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D)
2. [Video 2: Step-by-step guide on oiling a bike chain](https://www.youtube.com/watch?v=ubKCHtZ20-0&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D)
You can watch these videos to learn how to oil your bike's chain effectively.
--------------------

Giờ hãy hỏi tác nhân về các truy vấn trước đó:

response = execute(agent, query='What have I asked you so far?', thread_id='123')
print(response)

{'messages': [HumanMessage(content="Explain how to oil a bike's chain using a YouTube video",     id='8254142b-fb77-4958-8ad9-0a0283c6611a'), ...
]

Đúng như mong đợi, tác nhân trả về các thông điệp trước đó! Giờ chúng ta chỉ cần một giao diện chat như ChatGPT là đã có một chatbot tùy chỉnh.

Xu hướng và phát triển tương lai

Xuyên suốt bài viết, chúng ta đã thoáng thấy hướng đi của LangChain về tác nhân. Cho đến rất gần đây, LangChain chủ yếu dùng lớp AgentExecutor nhưng đang dần được thay thế bằng các tác nhân langgraph.

Các tác nhân thuần LangChain phù hợp để khởi đầu, nhưng chúng cần nhiều dòng mã hơn để xây dựng cùng một tác nhân so với LangGraph. Ngoài ra, đến một mức độ nhất định, framework AgentExecutor sẽ không cung cấp sự linh hoạt như LangGraph trong việc xây dựng các tác nhân đa công cụ phức tạp.

Đó là lý do tại sao bây giờ là thời điểm tuyệt vời để nắm bắt làn sóng và bắt đầu trực tiếp với LangGraph.

Chúng tôi cũng khuyến nghị mạnh mẽ bắt đầu sử dụng LangSmith, vốn đã trở thành một phần cốt lõi trong hệ sinh thái LangChain để xây dựng ứng dụng LLM cấp sản xuất. Dưới đây là một số lợi ích chính:

• Gỡ lỗi: LangSmith cung cấp dấu vết chi tiết quá trình thực thi của tác nhân, giúp dễ dàng xác định và khắc phục sự cố.
• Tối ưu hiệu năng: Với LangSmith, bạn có thể phân tích mức dùng token, độ trễ và các chỉ số hiệu năng khác để tối ưu hiệu quả của tác nhân.
• Kiểm thử và đánh giá: LangSmith hỗ trợ tạo và quản lý bộ dữ liệu kiểm thử, cho phép bạn đánh giá tác nhân một cách nghiêm ngặt trên nhiều kịch bản.
• Giám sát: Trong môi trường sản xuất, LangSmith cung cấp khả năng giám sát theo thời gian thực, cho phép bạn theo dõi hiệu năng của tác nhân và phát hiện bất thường nhanh chóng.

Đây là cách bạn có thể bắt đầu với LangSmith:

1. Đăng ký tài khoản miễn phí tại đây.
2. Thiết lập biến môi trường.

export LANGCHAIN_TRACING_V2="true"

export LANGCHAIN_API_KEY="..."

và bạn đã sẵn sàng! Khi bạn bắt đầu truy vấn các mô hình ngôn ngữ/chat, LangSmith sẽ bắt đầu ghi log nhiều chỉ số về mỗi lần chạy:

Kết luận

Trong bài viết này, chúng ta đã khám phá điều làm cho các tác nhân LangChain khác biệt với chuỗi và các khối xây dựng quan trọng để cấu thành chúng. Trước tiên, chúng ta giới thiệu tác nhân là gì và cách chúng khác với cấu trúc chuỗi truyền thống về tính linh hoạt và khả năng đưa ra quyết định.

Sau đó, chúng ta xem các thành phần chính bạn cần biết để xây dựng một tác nhân: mô hình chat, công cụ và mẫu nhắc. Cuối cùng, chúng ta đi qua hai ví dụ minh họa cách xây dựng tác nhân đơn giản và nâng cao. Xử lý ngôn ngữ tự nhiên không ngừng phát triển, và các tác nhân LangChain đang ở tuyến đầu của tiến trình này, mở đường cho một họ AI thông minh và linh hoạt hơn.

Đây là một số tài nguyên liên quan để nâng cao kỹ năng LangChain của bạn:

• Khóa học Phát triển Ứng dụng LLM với LangChain 
• Giới thiệu Kỹ thuật Prompt với LangChain 
• Hướng dẫn Xây dựng Ứng dụng LLM với LangChain
• Xây dựng Mô hình GPT có Khả năng Duyệt Web bằng Công cụ LangChain
• LangChain vs LlamaIndex: So sánh Chi tiết

Cảm ơn bạn đã đọc!