Tác giả: Stephen Sanwo
Để xây dựng một ứng dụng full-stack hoạt động, có quá nhiều phần chuyển động cần suy nghĩ. Và bạn sẽ cần đưa ra nhiều quyết định quan trọng đối với thành công của ứng dụng.
Ví dụ, bạn sẽ dùng ngôn ngữ gì và triển khai trên nền tảng nào? Bạn sẽ triển khai phần mềm container hóa trên server, hay dùng serverless functions cho backend? Bạn có dự định dùng API bên thứ ba để xử lý các phần phức tạp như xác thực hoặc thanh toán? Dữ liệu lưu ở đâu?
Ngoài ra, bạn cũng cần suy nghĩ về giao diện người dùng, thiết kế và khả năng sử dụng của ứng dụng, và nhiều hơn nữa.
Đây là lý do tại sao các ứng dụng lớn phức tạp cần một đội ngũ phát triển đa chức năng cộng tác để xây dựng ứng dụng.
Một trong những cách tốt nhất để học cách phát triển ứng dụng full-stack là xây dựng các dự án bao quy trình phát triển end-to-end. Bạn sẽ trải qua thiết kế kiến trúc, phát triển dịch vụ API, phát triển giao diện người dùng, và cuối cùng triển khai ứng dụng.
Vì vậy, hướng dẫn này sẽ đưa bạn qua quy trình xây dựng một AI chatbot để giúp bạn học sâu các khái niệm này.
Một số chủ đề chúng ta sẽ bao gồm:
- Cách xây dựng API với Python, FastAPI, và WebSockets
- Cách xây dựng hệ thống real-time với Redis
- Cách xây dựng giao diện người dùng Chat với React
Lưu ý quan trọng: Đây là dự án phát triển phần mềm full-stack trung cấp đòi hỏi kiến thức cơ bản về Python và JavaScript.
Tôi đã chia cẩn thận dự án thành các phần để đảm bảo bạn có thể dễ dàng chọn giai đoạn quan trọng đối với bạn trong trường hợp bạn không muốn code toàn bộ ứng dụng.
Bạn có thể tải toàn bộ repository trên GitHub của tôi tại đây.
Mục lục
Phần 1
- Kiến trúc ứng dụng
- Cách thiết lập môi trường phát triển
Phần 2
- Cách xây dựng Chat Server với Python, FastAPI, và WebSockets
- Cách thiết lập môi trường Python
- Thiết lập FastAPI Server
- Cách thêm Routes cho API
- Cách tạo Chat Session Token với UUID
- Cách test API với Postman
- WebSockets và Connection Manager
- Dependency Injection trong FastAPI
Phần 3
- Cách xây dựng Hệ thống Real-Time với Redis
- Redis và Distributed Messaging Queues
- Cách kết nối Redis Cluster trong Python với Redis Client
- Cách làm việc với Redis Streams
- Cách mô hình hóa dữ liệu Chat
- Cách làm việc với Redis JSON
- Cách cập nhật Token Dependency
Phần 4
- Cách thêm trí tuệ cho Chatbot với AI Models
- Cách bắt đầu với Huggingface
- Cách tương tác với Language Model
- Cách mô phỏng Short-term Memory cho AI Model
- Stream Consumer và Real-time Data Pull từ Message Queue
- Cách cập nhật Chat Client với AI Response
- Refresh Token
- Cách test Chat với Multiple Clients trong Postman
Kiến trúc Ứng dụng
Phác thảo kiến trúc giải pháp cho bạn cái nhìn tổng quan cấp cao về ứng dụng, công cụ bạn định dùng, và cách các thành phần giao tiếp với nhau.
Tôi đã vẽ một kiến trúc đơn giản dưới đây sử dụng draw.io:
Kiến trúc chatbot fullstack
Hãy đi qua các phần khác nhau của kiến trúc chi tiết hơn:
Client/Giao diện người dùng
Chúng ta sẽ dùng React phiên bản 18 để xây dựng giao diện người dùng. Chat UI sẽ giao tiếp với backend qua WebSockets.
GPT-J-6B và Huggingface Inference API
GPT-J-6B là một mô hình ngôn ngữ generative được huấn luyện với 6 tỷ tham số (parameters) và hoạt động gần giống với GPT-3 của OpenAI trên một số tác vụ.
Tôi chọn GPT-J-6B vì nó là mô hình open-source và không yêu cầu token trả phí cho các trường hợp sử dụng đơn giản.
Huggingface cũng cung cấp cho chúng ta một API on-demand để kết nối với mô hình này hầu như miễn phí. Bạn có thể đọc thêm về GPT-J-6B và Hugging Face Inference API.
Redis
Khi chúng ta gửi prompts đến GPT, chúng ta cần một cách để lưu trữ prompts và dễ dàng truy xuất phản hồi. Chúng ta sẽ dùng Redis JSON để lưu trữ dữ liệu chat và Redis Streams để xử lý giao tiếp real-time với Huggingface inference API.
Redis là kho key-value in-memory cho phép lưu trữ và truy xuất dữ liệu kiểu JSON siêu nhanh. Cho hướng dẫn này, chúng ta sẽ dùng lưu trữ Redis miễn phí do Redis Enterprise cung cấp cho mục đích test.
WebSockets và Chat API
Để gửi tin nhắn giữa client và server real-time, chúng ta cần mở một kết nối socket. Điều này là vì kết nối HTTP sẽ không đủ để đảm bảo giao tiếp hai chiều real-time giữa client và server.
Chúng ta sẽ dùng FastAPI cho chat server, vì nó cung cấp server Python nhanh và hiện đại cho trường hợp của chúng ta. Xem tài liệu FastAPI để tìm hiểu thêm về WebSockets.
Cách thiết lập Môi trường Phát triển
Bạn có thể dùng OS mong muốn để xây dựng app này – tôi hiện đang dùng macOS và Visual Studio Code. Chỉ cần đảm bảo bạn đã cài Python và NodeJs.
Để thiết lập cấu trúc dự án, tạo thư mục tên fullstack-ai-chatbot. Sau đó tạo hai thư mục con trong dự án tên client và server. Thư mục server sẽ chứa code backend, client sẽ chứa code frontend.
Tiếp theo, trong thư mục dự án, khởi tạo Git repository tại gốc thư mục dự án dùng lệnh "git init". Sau đó tạo file .gitignore bằng "touch .gitignore":
git init
touch .gitignore
Trong phần tiếp theo, chúng ta sẽ xây dựng chat web server dùng FastAPI và Python.
Cách xây dựng Chat Server với Python, FastAPI và WebSockets
Trong phần này, chúng ta sẽ xây dựng chat server dùng FastAPI để giao tiếp với người dùng. Chúng ta sẽ dùng WebSockets để đảm bảo giao tiếp hai chiều giữa client và server để có thể gửi phản hồi cho người dùng real-time.
Cách thiết lập Môi trường Python
Để khởi động server, chúng ta cần thiết lập môi trường Python. Mở thư mục dự án trong VS Code, và mở terminal.
Từ gốc dự án, cd vào thư mục server và chạy python3.8 -m venv env. Điều này sẽ tạo một virtual environment cho dự án Python của chúng ta, tên là env. Để kích hoạt virtual environment, chạy source env/bin/activate
Tiếp theo, cài đặt một vài thư viện trong môi trường Python của bạn.
pip install fastapi uuid uvicorn gunicorn WebSockets python-dotenv aioredis
Tiếp theo tạo file môi trường bằng cách chạy touch .env trong terminal. Chúng ta sẽ định nghĩa biến môi trường ứng dụng và biến bí mật trong file .env.
Thêm biến môi trường app và đặt thành "development" như sau: export APP_ENV=development. Tiếp theo, chúng ta sẽ thiết lập development server với FastAPI server.
Thiết lập FastAPI Server
Tại gốc thư mục server, tạo file mới tên main.py sau đó dán mã dưới đây cho development server:
from fastapi import FastAPI, Request
import uvicorn
import os
from dotenv import load_dotenv
load_dotenv()
api = FastAPI()
@api.get("/test")
async def root():
return {"msg": "API is Online"}
if __name__ == "__main__":
if os.environ.get('APP_ENV') == "development":
uvicorn.run("main:api", host="0.0.0.0", port=3500, workers=4, reload=True)
else:
pass
Đầu tiên chúng ta import FastAPI và khởi tạo nó là api. Sau đó chúng ta import load_dotenv từ thư viện python-dotenv, và khởi tạo nó để load biến từ file .env.
Sau đó chúng ta tạo một test route đơn giản để test API. Test route sẽ trả về phản hồi JSON đơn giản cho biết API đang online.
Cuối cùng, chúng ta thiết lập development server bằng uvicorn.run và cung cấp các tham số cần thiết. API sẽ chạy trên cổng 3500.
Cuối cùng, chạy server trong terminal với python main.py. Khi bạn thấy Application startup complete trong terminal, truy cập URL https://localhost:3500/test trên trình duyệt, và bạn nên thấy trang web như sau:
Trang Test API
Cách thêm Routes cho API
Trong phần này, chúng ta sẽ thêm routes cho API. Tạo thư mục mới tên src. Đây là thư mục nơi tất cả mã API của chúng ta sẽ nằm.
Tạo thư mục con tên routes, cd vào thư mục, tạo file mới tên chat.py và thêm mã dưới đây:
import os
from fastapi import APIRouter, FastAPI, WebSocket, Request
chat = APIRouter()
# @route POST /token
# @desc Route tạo chat token
# @access Public
@chat.post("/token")
async def token_generator(request: Request):
return None
# @route POST /refresh_token
# @desc Route làm mới token
# @access Public
@chat.post("/refresh_token")
async def refresh_token(request: Request):
return None
# @route Websocket /chat
# @desc Socket cho chatbot
# @access Public
@chat.websocket("/chat")
async def websocket_endpoint(websocket: WebSocket = WebSocket):
return None
Chúng ta tạo ba endpoints:
/tokensẽ cấp cho người dùng một session token để truy cập phiên chat. Vì ứng dụng chat sẽ công khai, chúng ta không muốn lo về xác thực và chỉ giữ đơn giản – nhưng vẫn cần cách để nhận diện mỗi phiên người dùng duy nhất./refresh_tokensẽ lấy lịch sử phiên cho người dùng nếu kết nối bị mất, miễn là token vẫn hoạt động và chưa hết hạn./chatsẽ mở WebSocket để gửi tin nhắn giữa client và server.
Tiếp theo, kết nối chat route với API chính. Đầu tiên chúng ta cần import chat from src.chat trong file main.py. Sau đó chúng ta sẽ include router bằng cách gọi method include_router trên class FastAPI đã khởi tạo và truyền chat làm đối số.
Cập nhật mã api.py như dưới đây:
from fastapi import FastAPI, Request
import uvicorn
import os
from dotenv import load_dotenv
from routes.chat import chat
load_dotenv()
api = FastAPI()
api.include_router(chat)
@api.get("/test")
async def root():
return {"msg": "API is Online"}
if __name__ == "__main__":
if os.environ.get('APP_ENV') == "development":
uvicorn.run("main:api", host="0.0.0.0", port=3500, workers=4, reload=True)
else:
pass
Cách tạo Chat Session Token với UUID
Để tạo user token, chúng ta sẽ dùng uuid4 để tạo dynamic routes cho chat endpoint. Vì đây là endpoint công khai, chúng ta không cần đi sâu vào JWT và xác thực.
Nếu bạn chưa cài uuid ban đầu, chạy pip install uuid. Tiếp theo trong chat.py, import UUID, và cập nhật route /token với mã dưới đây:
from fastapi import APIRouter, FastAPI, WebSocket, Request, BackgroundTasks, HTTPException
import uuid
# @route POST /token
# @desc Route tạo chat token
# @access Public
@chat.post("/token")
async def token_generator(name: str, request: Request):
if name == "":
raise HTTPException(status_code=400, detail={
"loc": "name",
"msg": "Enter a valid name"
})
token = str(uuid.uuid4())
data = {"name": name, "token": token}
return data
Trong mã trên, client cung cấp tên của họ, bắt buộc. Chúng ta kiểm tra nhanh để đảm bảo trường name không rỗng, sau đó tạo token dùng uuid4.
Dữ liệu phiên là một dictionary đơn giản cho name và token. Cuối cùng chúng ta sẽ cần lưu trữ dữ liệu phiên này và đặt timeout, nhưng hiện tại chỉ trả về cho client.
Cách test API với Postman
Vì chúng ta sẽ test một WebSocket endpoint, chúng ta cần công cụ như Postman cho phép điều này (vì swagger docs mặc định của FastAPI không hỗ trợ WebSockets).
Trong Postman, tạo một collection cho môi trường dev và gửi POST request đến localhost:3500/token chỉ định name làm query parameter và truyền giá trị. Bạn nên nhận được phản hồi như dưới đây:
Token Generator Postman
WebSockets và Connection Manager
Trong thư mục gốc src, tạo thư mục mới tên socket và thêm file tên connection.py. Trong file này, chúng ta sẽ định nghĩa class kiểm soát kết nối đến WebSockets, và tất cả helper methods để connect và disconnect.
Trong connection.py thêm mã dưới đây:
from fastapi import WebSocket
from typing import List
class ConnectionManager:
def __init__(self):
self.active_connections: List[WebSocket] = []
async def connect(self, websocket: WebSocket):
await websocket.accept()
self.active_connections.append(websocket)
def disconnect(self, websocket: WebSocket):
self.active_connections.remove(websocket)
async def send_personal_message(self, message: str, websocket: WebSocket):
await websocket.send_text(message)
Class ConnectionManager được khởi tạo với thuộc tính active_connections là danh sách các kết nối đang hoạt động.
Sau đó method connect bất đồng bộ sẽ chấp nhận một WebSocket và thêm nó vào danh sách active connections, trong khi method disconnect sẽ xóa Websocket khỏi danh sách active connections.
Cuối cùng, method send_personal_message sẽ nhận một tin nhắn và Websocket chúng ta muốn gửi tin nhắn đến và gửi tin nhắn bất đồng bộ.
WebSockets là chủ đề rất rộng và chúng ta chỉ cào bề mặt ở đây. Tuy nhiên điều này đủ để tạo nhiều kết nối và xử lý tin nhắn đến các kết nối đó bất đồng bộ.
Bạn có thể đọc thêm về FastAPI Websockets và Socket Programming.
Để dùng ConnectionManager, import và khởi tạo nó trong src.routes.chat.py, và cập nhật route WebSocket /chat với mã dưới đây:
from ..socket.connection import ConnectionManager
manager = ConnectionManager()
@chat.websocket("/chat")
async def websocket_endpoint(websocket: WebSocket):
await manager.connect(websocket)
try:
while True:
data = await websocket.receive_text()
print(data)
await manager.send_personal_message(f"Response: Simulating response from the GPT service", websocket)
except WebSocketDisconnect:
manager.disconnect(websocket)
Trong hàm websocket_endpoint, nhận WebSocket, chúng ta thêm websocket mới vào connection manager và chạy vòng lặp while True để đảm bảo socket mở. Trừ khi socket bị disconnect.
Trong khi kết nối mở, chúng ta nhận bất kỳ tin nhắn nào client gửi bằng websocket.receive_test() và in ra terminal cho đến nay.
Sau đó gửi phản hồi hard-coded về client cho đến nay. Cuối cùng tin nhắn nhận từ clients sẽ được gửi đến AI Model, và phản hồi gửi về client sẽ là phản hồi từ AI Model.
Trong Postman, chúng ta có thể test endpoint này bằng cách tạo WebSocket request mới, và kết nối đến WebSocket endpoint localhost:3500/chat.
Khi bạn nhấn connect, pane Messages sẽ hiển thị API client đã kết nối đến URL, và một socket đang mở.
Để test, gửi tin nhắn "Hello Bot" đến chat server, và bạn nên nhận phản hồi test ngay lập tức "Response: Simulating response from the GPT service" như dưới đây:
Postman Chat Test
Dependency Injection trong FastAPI
Để phân biệt giữa hai phiên client khác nhau và giới hạn phiên chat, chúng ta sẽ dùng timed token, truyền làm query parameter đến kết nối WebSocket.
Trong thư mục socket, tạo file tên utils.py sau đó thêm mã dưới đây:
from fastapi import WebSocket, status, Query
from typing import Optional
async def get_token(
websocket: WebSocket,
token: Optional[str] = Query(None),
):
if token is None or token == "":
await websocket.close(code=status.WS_1008_POLICY_VIOLATION)
return token
Hàm get_token nhận WebSocket và token, sau đó kiểm tra nếu token là None hoặc null.
Nếu là trường hợp này, hàm trả về status policy violation và nếu có sẵn, hàm chỉ trả về token. Chúng ta sẽ mở rộng hàm này sau với validation token thêm.
Để consume hàm này, chúng ta inject nó vào route /chat. FastAPI cung cấp class Depends để dễ dàng inject dependencies, nên không cần tinker với decorators.
Cập nhật route /chat thành sau:
from ..socket.utils import get_token
@chat.websocket("/chat")
async def websocket_endpoint(websocket: WebSocket, token: str = Depends(get_token)):
await manager.connect(websocket)
try:
while True:
data = await websocket.receive_text()
print(data)
await manager.send_personal_message(f"Response: Simulating response from the GPT service", websocket)
except WebSocketDisconnect:
manager.disconnect(websocket)
Bây giờ khi bạn thử kết nối đến endpoint /chat trong Postman, bạn sẽ nhận lỗi 403. Cung cấp token làm query parameter và cho bất kỳ giá trị nào cho token, cho đến nay. Sau đó bạn nên kết nối được như trước, chỉ là giờ kết nối yêu cầu token.
Postman Chat Test with Token
Chúc mừng bạn đã đến đây! File chat.py của bạn giờ nên trông như sau:
import os
from fastapi import APIRouter, FastAPI, WebSocket, WebSocketDisconnect, Request, Depends, HTTPException
import uuid
from ..socket.connection import ConnectionManager
from ..socket.utils import get_token
chat = APIRouter()
manager = ConnectionManager()
# @route POST /token
# @desc Route tạo chat token
# @access Public
@chat.post("/token")
async def token_generator(name: str, request: Request):
token = str(uuid.uuid4())
if name == "":
raise HTTPException(status_code=400, detail={
"loc": "name",
"msg": "Enter a valid name"
})
data = {"name": name, "token": token}
return data
# @route POST /refresh_token
# @desc Route làm mới token
# @access Public
@chat.post("/refresh_token")
async def refresh_token(request: Request):
return None
# @route Websocket /chat
# @desc Socket cho chat bot
# @access Public
@chat.websocket("/chat")
async def websocket_endpoint(websocket: WebSocket, token: str = Depends(get_token)):
await manager.connect(websocket)
try:
while True:
data = await websocket.receive_text()
print(data)
await manager.send_personal_message(f"Response: Simulating response from the GPT service", websocket)
except WebSocketDisconnect:
manager.disconnect(websocket)
Trong phần tiếp theo của hướng dẫn này, chúng ta sẽ tập trung vào xử lý trạng thái ứng dụng và truyền dữ liệu giữa client và server.
Cách xây dựng Hệ thống Real-Time với Redis
Ứng dụng của chúng ta hiện tại không lưu trữ bất kỳ trạng thái nào, và không có cách để nhận diện người dùng hoặc lưu trữ và truy xuất dữ liệu chat. Chúng ta cũng đang trả về phản hồi hard-coded cho client trong các phiên chat.
Trong phần này của hướng dẫn, chúng ta sẽ bao gồm:
- Cách kết nối đến Redis Cluster trong Python và thiết lập Redis Client
- Cách lưu trữ và truy xuất dữ liệu với Redis JSON
- Cách thiết lập Redis Streams làm message queues giữa web server và worker environment
Redis và Distributed Messaging Queues
Redis là kho dữ liệu in-memory open source bạn có thể dùng như database, cache, message broker, và streaming engine. Nó hỗ trợ nhiều cấu trúc dữ liệu và là giải pháp hoàn hảo cho các ứng dụng phân tán với khả năng real-time.
Redis Enterprise Cloud là dịch vụ cloud fully managed do Redis cung cấp giúp chúng ta triển khai Redis clusters ở quy mô vô hạn mà không lo về infrastructure.
Chúng ta sẽ dùng instance Redis Enterprise Cloud miễn phí cho hướng dẫn này. Bạn có thể Bắt đầu với Redis Cloud miễn phí ở đây và làm theo Hướng dẫn này để thiết lập database Redis và Redis Insight, một GUI để tương tác với Redis.
Khi bạn đã thiết lập xong database Redis, tạo thư mục mới tại gốc dự án (bên ngoài thư mục server) tên worker.
Chúng ta sẽ tách biệt worker environment khỏi web server để khi client gửi tin nhắn đến WebSocket của chúng ta, web server không phải xử lý request đến dịch vụ bên thứ ba. Cũng như tài nguyên được giải phóng cho người dùng khác.
Giao tiếp background với inference API được xử lý bởi worker service này, thông qua Redis.
Requests từ tất cả clients kết nối được append vào message queue (producer), trong khi worker consume các tin nhắn, gửi request đến inference API, và append phản hồi vào response queue.
Khi API nhận được phản hồi, nó gửi lại cho client.
Trong chuyến đi giữa producer và consumer, client có thể gửi nhiều tin nhắn, và các tin nhắn này sẽ được xếp hàng và phản hồi theo thứ tự.
Lý tưởng nhất, chúng ta có thể chạy worker này trên một server hoàn toàn khác, trong môi trường riêng, nhưng hiện tại, chúng ta sẽ tạo môi trường Python riêng trên máy local.
Bạn có thể thắc mắc – tại sao cần worker? Hãy tưởng tượng kịch bản web server cũng tạo request đến dịch vụ bên thứ ba. Điều này có nghĩa là trong khi chờ phản hồi từ dịch vụ bên thứ ba trong kết nối socket, server bị block và tài nguyên bị chiếm dụng cho đến khi nhận được phản hồi từ API.
Bạn có thể thử bằng cách tạo random sleep time.sleep(10) trước khi gửi phản hồi hard-coded, và gửi tin nhắn mới. Sau đó thử kết nối với token khác trong phiên postman mới.
Bạn sẽ thấy phiên chat sẽ không kết nối cho đến khi random sleep timeout.
Mặc dù chúng ta có thể dùng kỹ thuật bất đồng bộ và worker pools trong server setup tập trung production hơn, điều đó cũng không đủ khi số lượng người dùng đồng thời tăng.
Cuối cùng, chúng ta muốn tránh chiếm dụng tài nguyên web server bằng cách dùng Redis để broker giao tiếp giữa chat API của chúng ta và API bên thứ ba.
Tiếp theo mở terminal mới, cd vào thư mục worker, và tạo và kích hoạt virtual environment Python mới giống như phần 1.
Tiếp theo, cài đặt các dependencies sau:
pip install aiohttp aioredis python-dotenv
Cách kết nối Redis Cluster trong Python với Redis Client
Chúng ta sẽ dùng client aioredis để kết nối với database Redis. Chúng ta cũng sẽ dùng thư viện requests để gửi request đến Huggingface inference API.
Tạo hai file .env, và main.py. Sau đó tạo thư mục tên src. Cũng tạo thư mục tên redis và thêm file mới tên config.py.
Trong file .env, thêm mã sau – và đảm bảo bạn cập nhật các trường với credentials cung cấp trong Redis Cluster của bạn.
export REDIS_URL=<REDIS URL PROVIDED IN REDIS CLOUD>
export REDIS_USER=<REDIS USER IN REDIS CLOUD>
export REDIS_PASSWORD=<DATABASE PASSWORD IN REDIS CLOUD>
export REDIS_HOST=<REDIS HOST IN REDIS CLOUD>
export REDIS_PORT=<REDIS PORT IN REDIS CLOUD>
Trong config.py thêm class Redis dưới đây:
import os
from dotenv import load_dotenv
import aioredis
load_dotenv()
class Redis():
def __init__(self):
"""initialize connection """
self.REDIS_URL = os.environ['REDIS_URL']
self.REDIS_PASSWORD = os.environ['REDIS_PASSWORD']
self.REDIS_USER = os.environ['REDIS_USER']
self.connection_url = f"redis://{self.REDIS_USER}:{self.REDIS_PASSWORD}@{self.REDIS_URL}"
async def create_connection(self):
self.connection = aioredis.from_url(
self.connection_url, db=0)
return self.connection
Chúng ta tạo một object Redis và khởi tạo các tham số cần thiết từ biến môi trường. Sau đó tạo method bất đồng bộ create_connection để tạo kết nối Redis và trả về connection pool từ method from_url của aioredis.
Tiếp theo, chúng ta test kết nối Redis trong main.py bằng cách chạy mã dưới đây. Điều này sẽ tạo connection pool Redis mới, đặt key đơn giản "key", và gán chuỗi "value" cho nó.
from src.redis.config import Redis
import asyncio
async def main():
redis = Redis()
redis = await redis.create_connection()
print(redis)
await redis.set("key", "value")
if __name__ == "__main__":
asyncio.run(main())
Bây giờ mở Redis Insight (nếu bạn làm theo hướng dẫn để tải và cài đặt) Bạn nên thấy giống như sau:
Redis Insight Test
Cách làm việc với Redis Streams
Bây giờ chúng ta đã thiết lập xong worker environment, chúng ta có thể tạo producer trên web server và consumer trên worker.
Đầu tiên, hãy tạo lại class Redis của chúng ta trên server. Trong server.src tạo thư mục tên redis và thêm hai file, config.py và producer.py.
Trong config.py, thêm mã dưới đây như chúng ta làm cho worker environment:
import os
from dotenv import load_dotenv
import aioredis
load_dotenv()
class Redis():
def __init__(self):
"""initialize connection """
self.REDIS_URL = os.environ['REDIS_URL']
self.REDIS_PASSWORD = os.environ['REDIS_PASSWORD']
self.REDIS_USER = os.environ['REDIS_USER']
self.connection_url = f"redis://{self.REDIS_USER}:{self.REDIS_PASSWORD}@{self.REDIS_URL}"
async def create_connection(self):
self.connection = aioredis.from_url(
self.connection_url, db=0)
return self.connection
Trong file .env, cũng thêm credentials Redis:
export REDIS_URL=<REDIS URL PROVIDED IN REDIS CLOUD>
export REDIS_USER=<REDIS USER IN REDIS CLOUD>
export REDIS_PASSWORD=<DATABASE PASSWORD IN REDIS CLOUD>
export REDIS_HOST=<REDIS HOST IN REDIS CLOUD>
export REDIS_PORT=<REDIS PORT IN REDIS CLOUD>
Cuối cùng, trong server.src.redis.producer.py thêm mã sau:
from .config import Redis
class Producer:
def __init__(self, redis_client):
self.redis_client = redis_client
async def add_to_stream(self, data: dict, stream_channel):
try:
msg_id = await self.redis_client.xadd(name=stream_channel, id="*", fields=data)
print(f"Message id {msg_id} added to {stream_channel} stream")
return msg_id
except Exception as e:
print(f"Error sending msg to stream => {e}")
Chúng ta tạo class Producer được khởi tạo với Redis client. Chúng ta dùng client này để thêm dữ liệu vào stream với method add_to_stream, nhận data và tên kênh Redis.
Lệnh Redis để thêm dữ liệu vào stream channel là xadd và nó có cả hàm high-level và low-level trong aioredis.
Tiếp theo, để chạy Producer mới tạo, cập nhật chat.py và WebSocket endpoint /chat như dưới đây. Lưu ý tên kênh cập nhật message_channel.
from ..redis.producer import Producer
from ..redis.config import Redis
chat = APIRouter()
manager = ConnectionManager()
redis = Redis()
@chat.websocket("/chat")
async def websocket_endpoint(websocket: WebSocket, token: str = Depends(get_token)):
await manager.connect(websocket)
redis_client = await redis.create_connection()
producer = Producer(redis_client)
try:
while True:
data = await websocket.receive_text()
print(data)
stream_data = {}
stream_data[token] = data
await producer.add_to_stream(stream_data, "message_channel")
await manager.send_personal_message(f"Response: Simulating response from the GPT service", websocket)
except WebSocketDisconnect:
manager.disconnect(websocket)
Tiếp theo, trong Postman, tạo kết nối và gửi bất kỳ số lượng tin nhắn nào nói Hello. Bạn nên thấy stream messages in ra terminal như dưới đây:
Terminal Channel Messages Test
Trong Redis Insight, bạn sẽ thấy message_channel mới được tạo và hàng đợi timestamped đầy tin nhắn gửi từ client. Hàng đợi timestamped này quan trọng để bảo toàn thứ tự tin nhắn.
Redis Insight Channel
Cách mô hình hóa dữ liệu Chat
Tiếp theo, chúng ta sẽ tạo model cho tin nhắn chat. Nhớ rằng chúng ta đang gửi dữ liệu text qua WebSockets, nhưng dữ liệu chat của chúng ta cần giữ nhiều thông tin hơn chỉ text. Chúng ta cần timestamp khi chat được gửi, tạo ID cho mỗi tin nhắn, và thu thập dữ liệu về phiên chat, sau đó lưu dữ liệu này ở định dạng JSON.
Chúng ta có thể lưu dữ liệu JSON này trong Redis để không mất lịch sử chat khi kết nối bị mất, vì WebSocket của chúng ta không lưu trữ state.
Trong server.src tạo thư mục mới tên schema. Sau đó tạo file tên chat.py trong server.src.schema thêm mã sau:
from datetime import datetime
from pydantic import BaseModel
from typing import List, Optional
import uuid
class Message(BaseModel):
id = uuid.uuid4()
msg: str
timestamp = str(datetime.now())
class Chat(BaseModel):
token: str
messages: List[Message]
name: str
session_start = str(datetime.now())
Chúng ta dùng class BaseModel của Pydantic để mô hình hóa dữ liệu chat. Class Chat sẽ giữ dữ liệu về một phiên Chat đơn lẻ. Nó sẽ lưu token, tên người dùng, và timestamp tự động tạo cho thời gian bắt đầu phiên chat dùng datetime.now().
Các tin nhắn gửi và nhận trong phiên chat này được lưu với class Message tạo chat id on the fly dùng uuid4. Dữ liệu duy nhất chúng ta cần cung cấp khi khởi tạo class Message này là text tin nhắn.
Cách làm việc với Redis JSON
Để dùng khả năng Redis JSON lưu trữ lịch sử chat của chúng ta, chúng ta cần cài đặt rejson do Redis labs cung cấp.
Trong terminal, cd vào server và cài rejson với pip install rejson. Sau đó cập nhật class Redis trong server.src.redis.config.py để bao gồm method create_rejson_connection:
import os
from dotenv import load_dotenv
import aioredis
from rejson import Client
load_dotenv()
class Redis():
def __init__(self):
"""initialize connection """
self.REDIS_URL = os.environ['REDIS_URL']
self.REDIS_PASSWORD = os.environ['REDIS_PASSWORD']
self.REDIS_USER = os.environ['REDIS_USER']
self.connection_url = f"redis://{self.REDIS_USER}:{self.REDIS_PASSWORD}@{self.REDIS_URL}"
self.REDIS_HOST = os.environ['REDIS_HOST']
self.REDIS_PORT = os.environ['REDIS_PORT']
async def create_connection(self):
self.connection = aioredis.from_url(
self.connection_url, db=0)
return self.connection
def create_rejson_connection(self):
self.redisJson = Client(host=self.REDIS_HOST, port=self.REDIS_PORT, decode_responses=True, username=self.REDIS_USER, password=self.REDIS_PASSWORD)
return self.redisJson
Chúng ta thêm method create_rejson_connection để kết nối đến Redis với client rejson Client. Điều này cho chúng ta các method để tạo và thao tác dữ liệu JSON trong Redis, không có sẵn với aioredis.
Tiếp theo, trong server.src.routes.chat.py chúng ta có thể cập nhật endpoint /token để tạo instance Chat mới và lưu dữ liệu phiên trong Redis JSON như sau:
@chat.post("/token")
async def token_generator(name: str, request: Request):
token = str(uuid.uuid4())
if name == "":
raise HTTPException(status_code=400, detail={
"loc": "name",
"msg": "Enter a valid name"
})
# Tạo phiên chat mới
json_client = redis.create_rejson_connection()
chat_session = Chat(
token=token,
messages=[],
name=name
)
# Lưu phiên chat trong redis JSON với token làm key
json_client.jsonset(str(token), Path.rootPath(), chat_session.dict())
# Đặt timeout cho dữ liệu redis
redis_client = await redis.create_connection()
await redis_client.expire(str(token), 3600)
return chat_session.dict()
LƯU Ý: Vì đây là demo app, tôi không muốn lưu dữ liệu chat trong Redis quá lâu. Vì vậy tôi thêm timeout 60 phút cho token dùng client aioredis (rejson không implement timeouts). Điều này có nghĩa là sau 60 phút, dữ liệu phiên chat sẽ bị mất.
Điều này cần thiết vì chúng ta không xác thực người dùng, và muốn xóa dữ liệu chat sau một khoảng thời gian định nghĩa. Bước này là tùy chọn, bạn không bắt buộc phải bao gồm nó.
Tiếp theo, trong Postman, khi bạn gửi POST request tạo token mới, bạn sẽ nhận phản hồi có cấu trúc như dưới đây. Bạn cũng có thể kiểm tra Redis Insight để thấy dữ liệu chat được lưu với token làm JSON key và dữ liệu làm value.
Token Generator Updated
Cách cập nhật Token Dependency
Bây giờ chúng ta có token được tạo và lưu, đây là thời điểm tốt để cập nhật dependency get_token trong WebSocket /chat của chúng ta. Chúng ta làm điều này để kiểm tra token hợp lệ trước khi bắt đầu phiên chat.
Trong server.src.socket.utils.py cập nhật hàm get_token để kiểm tra xem token có tồn tại trong instance Redis không. Nếu có thì trả về token, nghĩa là kết nối socket hợp lệ. Nếu không tồn tại, đóng kết nối.
Token được tạo bởi /token sẽ ngừng tồn tại sau 60 phút. Vì vậy chúng ta có thể có logic đơn giản trên frontend để redirect người dùng tạo token mới nếu lỗi phản hồi được tạo khi cố gắng bắt đầu chat.
from ..redis.config import Redis
async def get_token(
websocket: WebSocket,
token: Optional[str] = Query(None),
):
if token is None or token == "":
await websocket.close(code=status.WS_1008_POLICY_VIOLATION)
redis_client = await redis.create_connection()
isexists = await redis_client.exists(token)
if isexists == 1:
return token
else:
await websocket.close(code=status.WS_1008_POLICY_VIOLATION, reason="Session not authenticated or expired token")
Để test dependency, kết nối đến chat session với random token chúng ta đã dùng, và bạn nên nhận lỗi 403. (Lưu ý bạn phải xóa thủ công token trong Redis Insight.)
Sao chép token được tạo khi bạn gửi post request đến endpoint /token (hoặc tạo request mới) và dán nó làm giá trị cho token query parameter yêu cầu bởi WebSocket /chat. Sau đó kết nối. Bạn nên nhận kết nối thành công.
Chat Session with Token
Tổng hợp lại, chat.py của bạn nên trông như dưới đây.
import os
from fastapi import APIRouter, FastAPI, WebSocket, WebSocketDisconnect, Request, Depends
import uuid
from ..socket.connection import ConnectionManager
from ..socket.utils import get_token
import time
from ..redis.producer import Producer
from ..redis.config import Redis
from ..schema.chat import Chat
from rejson import Path
chat = APIRouter()
manager = ConnectionManager()
redis = Redis()
# @route POST /token
# @desc Route tạo chat token
# @access Public
@chat.post("/token")
async def token_generator(name: str, request: Request):
token = str(uuid.uuid4())
if name == "":
raise HTTPException(status_code=400, detail={
"loc": "name",
"msg": "Enter a valid name"
})
# Tạo phiên chat mới
json_client = redis.create_rejson_connection()
chat_session = Chat(
token=token,
messages=[],
name=name
)
print(chat_session.dict())
# Lưu phiên chat trong redis JSON với token làm key
json_client.jsonset(str(token), Path.rootPath(), chat_session.dict())
# Đặt timeout cho dữ liệu redis
redis_client = await redis.create_connection()
await redis_client.expire(str(token), 3600)
return chat_session.dict()
# @route POST /refresh_token
# @desc Route làm mới token
# @access Public
@chat.post("/refresh_token")
async def refresh_token(request: Request):
return None
# @route Websocket /chat
# @desc Socket cho chat bot
# @access Public
@chat.websocket("/chat")
async def websocket_endpoint(websocket: WebSocket, token: str = Depends(get_token)):
await manager.connect(websocket)
redis_client = await redis.create_connection()
producer = Producer(redis_client)
json_client = redis.create_rejson_connection()
consumer = StreamConsumer(redis_client)
try:
while True:
data = await websocket.receive_text()
stream_data = {}
stream_data[str(token)] = str(data)
await producer.add_to_stream(stream_data, "message_channel")
await manager.send_personal_message(f"Response: Simulating response from the GPT service", websocket)
except WebSocketDisconnect:
manager.disconnect(websocket)
Làm tốt lắm đã đến đây! Trong phần tiếp theo, chúng ta sẽ tập trung vào giao tiếp với AI model và xử lý truyền dữ liệu giữa client, server, worker, và external API.
Cách thêm Trí tuệ cho Chatbots với AI Models
Trong phần này, chúng ta sẽ tập trung vào xây dựng wrapper để giao tiếp với transformer model, gửi prompts từ người dùng đến API ở định dạng hội thoại, và nhận và biến đổi phản hồi cho ứng dụng chat của chúng ta.
Cách bắt đầu với Huggingface
Chúng ta sẽ không xây dựng hoặc triển khai bất kỳ language models nào trên Hugginface. Thay vào đó, chúng ta sẽ tập trung vào việc dùng accelerated inference API của Huggingface để kết nối với các mô hình pre-trained.
Mô hình chúng ta sẽ dùng là GPT-J-6B Model do EleutherAI cung cấp. Đây là mô hình ngôn ngữ generative được huấn luyện với 6 tỷ tham số.
Huggingface cung cấp cho chúng ta API on-demand giới hạn để kết nối với mô hình này hầu như miễn phí.
Để bắt đầu với Huggingface, Tạo tài khoản miễn phí. Trong settings, tạo access token mới. Đối với lên đến 30k tokens, Huggingface cung cấp truy cập inference API miễn phí.
Bạn có thể Theo dõi việc sử dụng API ở đây. Hãy chắc chắn giữ token này an toàn và không công khai nó.
Lưu ý: Chúng ta sẽ dùng kết nối HTTP để giao tiếp với API vì chúng ta dùng tài khoản miễn phí. Nhưng tài khoản PRO Huggingface hỗ trợ streaming với WebSockets xem parallelism và batch jobs.
Điều này có thể cải thiện đáng kể thời gian phản hồi giữa model và ứng dụng chat của chúng ta, và tôi hy vọng sẽ bao phủ phương pháp này trong bài viết tiếp theo.
Cách tương tác với Language Model
Đầu tiên, chúng ta thêm credentials kết nối Huggingface vào file .env trong thư mục worker của chúng ta.
export HUGGINFACE_INFERENCE_TOKEN=<HUGGINGFACE ACCESS TOKEN>
export MODEL_URL=https://api-inference.huggingface.co/models/EleutherAI/gpt-j-6B
Tiếp theo, trong worker.src tạo thư mục tên model sau đó thêm file gptj.py. Sau đó thêm class GPT dưới đây:
import os
from dotenv import load_dotenv
import requests
import json
load_dotenv()
class GPT:
def __init__(self):
self.url = os.environ.get('MODEL_URL')
self.headers = {
"Authorization": f"Bearer {os.environ.get('HUGGINFACE_INFERENCE_TOKEN')}"
}
self.payload = {
"inputs": "",
"parameters": {
"return_full_text": False,
"use_cache": True,
"max_new_tokens": 25
}
}
def query(self, input: str) -> list:
self.payload["inputs"] = input
data = json.dumps(self.payload)
response = requests.request(
"POST", self.url, headers=self.headers, data=data)
print(json.loads(response.content.decode("utf-8")))
return json.loads(response.content.decode("utf-8"))
if __name__ == "__main__":
GPT().query("Will artificial intelligence help humanity conquer the universe?")
Class GPT được khởi tạo với model url của Huggingface, header xác thực, và payload định nghĩa trước. Nhưng payload input là trường động được cung cấp bởi method query và cập nhật trước khi gửi request đến endpoint Huggingface.
Cuối cùng, chúng ta test bằng cách chạy method query trên instance của class GPT trực tiếp. Trong terminal, chạy python src/model/gptj.py, và bạn nên nhận phản hồi như sau (chỉ nhớ rằng phản hồi của bạn chắc chắn sẽ khác):
[{'generated_text': ' (AI) could solve all the problems on this planet? I am of the opinion that in the short term artificial intelligence is much better than human beings, but in the long and distant future human beings will surpass artificial intelligence.\n\nIn the distant'}]
Tiếp theo, chúng ta thêm một chút tinh chỉnh cho input để làm cho tương tác với model tự nhiên hơn bằng cách thay đổi định dạng input.
Cập nhật class GPT như sau:
class GPT:
def __init__(self):
self.url = os.environ.get('MODEL_URL')
self.headers = {
"Authorization": f"Bearer {os.environ.get('HUGGINFACE_INFERENCE_TOKEN')}"
}
self.payload = {
"inputs": "",
"parameters": {
"return_full_text": False,
"use_cache": False,
"max_new_tokens": 25
}
}
def query(self, input: str) -> list:
self.payload["inputs"] = f"Human: {input} Bot:"
data = json.dumps(self.payload)
response = requests.request(
"POST", self.url, headers=self.headers, data=data)
data = json.loads(response.content.decode("utf-8"))
text = data[0]['generated_text']
res = str(text.split("Human:")[0]).strip("\n").strip()
return res
if __name__ == "__main__":
GPT().query("Will artificial intelligence help humanity conquer the universe?")
Chúng ta cập nhật input với string literal f"Human: {input} Bot:". Input của human được đặt trong chuỗi và Bot cung cấp phản hồi. Định dạng input này biến GPT-J6B thành mô hình hội thoại. Các thay đổi khác bạn có thể nhận thấy bao gồm
- use_cache: bạn có thể đặt False nếu muốn model tạo phản hồi mới khi input giống nhau. Tôi khuyên để True trong production để tránh cạn kiệt free tokens nếu user spam bot với cùng tin nhắn. Dùng cache không thực sự load phản hồi mới từ model.
- return_full_text: là False, vì chúng ta không cần trả về input – chúng ta đã có nó. Khi nhận phản hồi, chúng ta strip "Bot:" và khoảng trắng đầu/cuối từ phản hồi và chỉ trả về text phản hồi.
Cách mô phỏng Short-term Memory cho AI Model
Đối với mỗi input mới chúng ta gửi đến model, không có cách nào model nhớ lịch sử hội thoại. Điều này quan trọng nếu chúng ta muốn giữ context trong hội thoại.
Nhưng nhớ rằng khi số tokens chúng ta gửi đến model tăng, xử lý tốn kém hơn, và thời gian phản hồi cũng lâu hơn.
Vì vậy chúng ta sẽ cần tìm cách truy xuất lịch sử ngắn hạn và gửi đến model. Chúng ta cũng cần tìm ra sweet spot - chúng ta muốn truy xuất và gửi bao nhiêu dữ liệu lịch sử đến model?
Để xử lý lịch sử chat, chúng ta cần quay lại JSON database. Chúng ta sẽ dùng token để lấy dữ liệu chat cuối cùng, và khi nhận được phản hồi, append phản hồi vào JSON database.
Cập nhật worker.src.redis.config.py để bao gồm method create_rejson_connection. Cũng cập nhật file .env với dữ liệu xác thực, và đảm bảo rejson đã cài đặt.
File worker.src.redis.config.py của bạn nên trông như sau:
import os
from dotenv import load_dotenv
import aioredis
from rejson import Client
load_dotenv()
class Redis():
def __init__(self):
"""initialize connection """
self.REDIS_URL = os.environ['REDIS_URL']
self.REDIS_PASSWORD = os.environ['REDIS_PASSWORD']
self.REDIS_USER = os.environ['REDIS_USER']
self.connection_url = f"redis://{self.REDIS_USER}:{self.REDIS_PASSWORD}@{self.REDIS_URL}"
self.REDIS_HOST = os.environ['REDIS_HOST']
self.REDIS_PORT = os.environ['REDIS_PORT']
async def create_connection(self):
self.connection = aioredis.from_url(
self.connection_url, db=0)
return self.connection
def create_rejson_connection(self):
self.redisJson = Client(host=self.REDIS_HOST, port=self.REDIS_PORT, decode_responses=True, username=self.REDIS_USER, password=self.REDIS_PASSWORD)
return self.redisJson
File .env của bạn nên trông như sau:
export REDIS_URL=<REDIS URL PROVIDED IN REDIS CLOUD>
export REDIS_USER=<REDIS USER IN REDIS CLOUD>
export REDIS_PASSWORD=<DATABASE PASSWORD IN REDIS CLOUD>
export REDIS_HOST=<REDIS HOST IN REDIS CLOUD>
export REDIS_PORT=<REDIS PORT IN REDIS CLOUD>
export HUGGINFACE_INFERENCE_TOKEN=<HUGGINGFACE ACCESS TOKEN>
export MODEL_URL=https://api-inference.huggingface.co/models/EleutherAI/gpt-j-6B
Tiếp theo, trong worker.src.redis tạo file mới tên cache.py và thêm mã dưới đây:
from .config import Redis
from rejson import Path
class Cache:
def __init__(self, json_client):
self.json_client = json_client
async def get_chat_history(self, token: str):
data = self.json_client.jsonget(
str(token), Path.rootPath())
return data
Cache được khởi tạo với rejson client, và method get_chat_history nhận token để lấy lịch sử chat cho token đó, từ Redis. Đảm bảo bạn import object Path từ rejson.
Tiếp theo, cập nhật worker.main.py với mã dưới đây:
from src.redis.config import Redis
import asyncio
from src.model.gptj import GPT
from src.redis.cache import Cache
redis = Redis()
async def main():
json_client = redis.create_rejson_connection()
data = await Cache(json_client).get_chat_history(token="18196e23-763b-4808-ae84-064348a0daff")
print(data)
if __name__ == "__main__":
asyncio.run(main())
Tôi đã hard-code một sample token được tạo từ test trước trong Postman. Nếu bạn không có token được tạo, chỉ việc gửi request mới đến /token và sao chép token, sau đó chạy python main.py trong terminal. Bạn nên thấy dữ liệu trong terminal như sau:
{'token': '18196e23-763b-4808-ae84-064348a0daff', 'messages': [], 'name': 'Stephen', 'session_start': '2022-07-16 13:20:01.092109'}
Tiếp theo, chúng ta cần thêm method add_message_to_cache vào class Cache thêm tin nhắn vào Redis cho token cụ thể.
async def add_message_to_cache(self, token: str, message_data: dict):
self.json_client.jsonarrappend(
str(token), Path('.messages'), message_data)
Method jsonarrappend do rejson cung cấp append tin nhắn mới vào mảng message.
Lưu ý để truy cập mảng message, chúng ta cần cung cấp .messages làm đối số cho Path. Nếu dữ liệu message của bạn có cấu trúc khác/lồng nhau, chỉ cần cung cấp đường dẫn đến mảng bạn muốn append dữ liệu mới.
Để test method này, cập nhật hàm main trong file main.py với mã dưới đây:
async def main():
json_client = redis.create_rejson_connection()
await Cache(json_client).add_message_to_cache(token="18196e23-763b-4808-ae84-064348a0daff", message_data={
"id": "1",
"msg": "Hello",
"timestamp": "2022-07-16 13:20:01.092109"
})
data = await Cache(json_client).get_chat_history(token="18196e23-763b-4808-ae84-064348a0daff")
print(data)
Chúng ta gửi tin nhắn hard-coded đến cache, và lấy lịch sử chat từ cache. Khi bạn chạy python main.py trong terminal trong thư mục worker, bạn nên nhận được thứ gì đó như sau in ra terminal, với tin nhắn được thêm vào mảng message.
{'token': '18196e23-763b-4808-ae84-064348a0daff', 'messages': [{'id': '1', 'msg': 'Hello', 'timestamp': '2022-07-16 13:20:01.092109'}], 'name': 'Stephen', 'session_start': '2022-07-16 13:20:01.092109'}
Cuối cùng, chúng ta cần cập nhật hàm main để gửi dữ liệu tin nhắn đến GPT model, và cập nhật input với 4 tin nhắn cuối được gửi giữa client và model.
Đầu tiên hãy cập nhật hàm add_message_to_cache với đối số mới "source" sẽ cho chúng ta biết tin nhắn là human hay bot. Chúng ta có thể dùng arg này để thêm tag "Human:" hoặc "Bot:" vào dữ liệu trước khi lưu vào cache.
Cập nhật method add_message_to_cache trong class Cache như sau:
async def add_message_to_cache(self, token: str, source: str, message_data: dict):
if source == "human":
message_data['msg'] = "Human: " + (message_data['msg'])
elif source == "bot":
message_data['msg'] = "Bot: " + (message_data['msg'])
self.json_client.jsonarrappend(
str(token), Path('.messages'), message_data)
Sau đó cập nhật hàm main trong main.py trong thư mục worker, và chạy python main.py để thấy kết quả mới trong database Redis.
async def main():
json_client = redis.create_rejson_connection()
await Cache(json_client).add_message_to_cache(token="18196e23-763b-4808-ae84-064348a0daff", source="human", message_data={
"id": "1",
"msg": "Hello",
"timestamp": "2022-07-16 13:20:01.092109"
})
data = await Cache(json_client).get_chat_history(token="18196e23-763b-4808-ae84-064348a0daff")
print(data)
Tiếp theo, chúng ta cần cập nhật hàm main để thêm tin nhắn mới vào cache, đọc 4 tin nhắn trước từ cache, và sau đó gọi API đến model dùng method query. Nó sẽ có payload gồm chuỗi composite của 4 tin nhắn cuối.
Bạn luôn có thể điều chỉnh số tin nhắn trong lịch sử bạn muốn trích xuất, nhưng tôi nghĩ 4 tin nhắn là con số khá tốt cho demo.
Trong worker.src, tạo thư mục mới schema. Sau đó tạo file mới tên chat.py và dán schema message của chúng ta vào chat.py như sau:
from datetime import datetime
from pydantic import BaseModel
from typing import List, Optional
import uuid
class Message(BaseModel):
id = str(uuid.uuid4())
msg: str
timestamp = str(datetime.now())
Tiếp theo, cập nhật file main.py như dưới đây:
async def main():
json_client = redis.create_rejson_connection()
await Cache(json_client).add_message_to_cache(token="18196e23-763b-4808-ae84-064348a0daff", source="human", message_data={
"id": "3",
"msg": "I would like to go to the moon to, would you take me?",
"timestamp": "2022-07-16 13:20:01.092109"
})
data = await Cache(json_client).get_chat_history(token="18196e23-763b-4808-ae84-064348a0daff")
print(data)
message_data = data['messages'][-4:]
input = ["" + i['msg'] for i in message_data]
input = " ".join(input)
res = GPT().query(input=input)
msg = Message(
msg=res
)
print(msg)
await Cache(json_client).add_message_to_cache(token="18196e23-763b-4808-ae84-064348a0daff", source="bot", message_data=msg.dict())
Trong mã trên, chúng ta thêm dữ liệu tin nhắn mới vào cache. Tin nhắn này cuối cùng sẽ đến từ message queue. Tiếp theo chúng ta lấy lịch sử chat từ cache, bây giờ sẽ bao gồm dữ liệu gần nhất chúng ta vừa thêm.
Lưu ý chúng ta dùng cùng token hard-coded để thêm vào cache và lấy từ cache, tạm thời chỉ để test.
Tiếp theo, chúng ta cắt bỏ dữ liệu cache và trích xuất chỉ 4 item cuối. Sau đó chúng ta gộp dữ liệu input bằng cách trích xuất msg trong list và join vào chuỗi rỗng.
Cuối cùng, chúng ta tạo instance Message mới cho phản hồi bot và thêm phản hồi vào cache chỉ định source là "bot"
Tiếp theo, chạy python main.py vài lần, thay đổi tin nhắn human và id theo ý muốn mỗi lần chạy. Bạn nên có đầy đủ conversation input và output với model.
Mở Redis Insight và bạn nên có thứ gì đó tương tự như dưới đây:
Conversational Chat
Stream Consumer và Real-time Data Pull từ Message Queue
Tiếp theo, chúng ta muốn tạo consumer và cập nhật worker.main.py để kết nối đến message queue. Chúng ta muốn nó pull token data real-time, vì hiện tại chúng ta hard-code tokens và message inputs.
Trong worker.src.redis tạo file mới tên stream.py. Thêm class StreamConsumer với mã dưới đây:
class StreamConsumer:
def __init__(self, redis_client):
self.redis_client = redis_client
async def consume_stream(self, count: int, block: int, stream_channel):
response = await self.redis_client.xread(
streams={stream_channel: '0-0'}, count=count, block=block)
return response
async def delete_message(self, stream_channel, message_id):
await self.redis_client.xdel(stream_channel, message_id)
Class StreamConsumer được khởi tạo với Redis client. Method consume_stream kéo tin nhắn mới từ queue từ message channel, dùng method xread do aioredis cung cấp.
Tiếp theo, cập nhật file worker.main.py với vòng lặp while để giữ kết nối đến message channel sống, như sau:
from src.redis.config import Redis
import asyncio
from src.model.gptj import GPT
from src.redis.cache import Cache
from src.redis.config import Redis
from src.redis.stream import StreamConsumer
import os
from src.schema.chat import Message
redis = Redis()
async def main():
json_client = redis.create_rejson_connection()
redis_client = await redis.create_connection()
consumer = StreamConsumer(redis_client)
cache = Cache(json_client)
print("Stream consumer started")
print("Stream waiting for new messages")
while True:
response = await consumer.consume_stream(stream_channel="message_channel", count=1, block=0)
if response:
for stream, messages in response:
# Lấy tin nhắn từ stream, trích xuất token, message data và message id
for message in messages:
message_id = message[0]
token = [k.decode('utf-8') for k, v in message[1].items()][0]
message = [v.decode('utf-8') for k, v in message[1].items()][0]
print(token)
# Tạo instance Message mới và thêm vào cache, chỉ định source là human
msg = Message(msg=message)
await cache.add_message_to_cache(token=token, source="human", message_data=msg.dict())
# Lấy lịch sử chat từ cache
data = await cache.get_chat_history(token=token)
# Làm sạch message input và gửi đến query
message_data = data['messages'][-4:]
input = ["" + i['msg'] for i in message_data]
input = " ".join(input)
res = GPT().query(input=input)
msg = Message(
msg=res
)
print(msg)
await cache.add_message_to_cache(token=token, source="bot", message_data=msg.dict())
# Xóa message khỏi queue sau khi đã xử lý
await consumer.delete_message(stream_channel="message_channel", message_id=message_id)
if __name__ == "__main__":
asyncio.run(main())
Đây là cập nhật khá lớn, hãy xem từng bước:
Chúng ta dùng vòng lặp while True để worker có thể online lắng nghe tin nhắn từ queue.
Tiếp theo, chúng ta await tin nhắn mới từ message_channel bằng cách gọi method consume_stream của chúng ta. Nếu có tin nhắn trong queue, chúng ta trích xuất message_id, token, và message. Sau đó tạo instance mới của class Message, thêm tin nhắn vào cache, và lấy 4 tin nhắn cuối. Đặt nó làm input cho method query của GPT model.
Khi nhận được phản hồi, chúng ta thêm phản hồi vào cache dùng method add_message_to_cache, sau đó xóa tin nhắn khỏi queue.
Cách cập nhật Chat Client với AI Response
Cho đến nay, chúng ta đang gửi tin nhắn chat từ client đến message_channel (được nhận bởi worker query AI model) để lấy phản hồi.
Tiếp theo, chúng ta cần gửi phản hồi này đến client. Miễn là kết nối socket vẫn mở, client nên có thể nhận phản hồi.
Nếu kết nối đóng, client luôn có thể lấy phản hồi từ lịch sử chat dùng endpoint refresh_token.
Trong worker.src.redis tạo file mới tên producer.py, và thêm class Producer tương tự như trên chat web server:
class Producer:
def __init__(self, redis_client):
self.redis_client = redis_client
async def add_to_stream(self, data: dict, stream_channel) -> bool:
msg_id = await self.redis_client.xadd(name=stream_channel, id="*", fields=data)
print(f"Message id {msg_id} added to {stream_channel} stream")
return msg_id
Tiếp theo, trong file main.py, cập nhật hàm main để khởi tạo producer, tạo stream data, và gửi phản hồi đến response_channel dùng method add_to_stream:
from src.redis.config import Redis
import asyncio
from src.model.gptj import GPT
from src.redis.cache import Cache
from src.redis.config import Redis
from src.redis.stream import StreamConsumer
import os
from src.schema.chat import Message
from src.redis.producer import Producer
redis = Redis()
async def main():
json_client = redis.create_rejson_connection()
redis_client = await redis.create_connection()
consumer = StreamConsumer(redis_client)
cache = Cache(json_client)
producer = Producer(redis_client)
print("Stream consumer started")
print("Stream waiting for new messages")
while True:
response = await consumer.consume_stream(stream_channel="message_channel", count=1, block=0)
if response:
for stream, messages in response:
# Lấy tin nhắn từ stream, trích xuất token, message data và message id
for message in messages:
message_id = message[0]
token = [k.decode('utf-8') for k, v in message[1].items()][0]
message = [v.decode('utf-8') for k, v in message[1].items()][0]
# Tạo instance Message mới và thêm vào cache, chỉ định source là human
msg = Message(msg=message)
await cache.add_message_to_cache(token=token, source="human", message_data=msg.dict())
# Lấy lịch sử chat từ cache
data = await cache.get_chat_history(token=token)
# Làm sạch message input và gửi đến query
message_data = data['messages'][-4:]
input = ["" + i['msg'] for i in message_data]
input = " ".join(input)
res = GPT().query(input=input)
msg = Message(
msg=res
)
stream_data = {}
stream_data[str(token)] = str(msg.dict())
await producer.add_to_stream(stream_data, "response_channel")
await cache.add_message_to_cache(token=token, source="bot", message_data=msg.dict())
# Xóa message khỏi queue sau khi đã xử lý
await consumer.delete_message(stream_channel="message_channel", message_id=message_id)
if __name__ == "__main__":
asyncio.run(main())
Tiếp theo, chúng ta cần cho client biết khi nhận phản hồi từ worker trong endpoint socket /chat. Chúng ta làm điều này bằng cách lắng nghe response stream. Chúng ta không cần vòng lặp while ở đây vì socket sẽ lắng nghe miễn là kết nối mở.
Lưu ý chúng ta cũng cần kiểm tra phản hồi dành cho client nào bằng cách thêm logic kiểm tra nếu token kết nối bằng token trong phản hồi. Sau đó xóa tin nhắn trong response queue sau khi đã đọc.
Trong server.src.redis tạo file mới tên stream.py và thêm class StreamConsumer như sau:
from .config import Redis
class StreamConsumer:
def __init__(self, redis_client):
self.redis_client = redis_client
async def consume_stream(self, count: int, block: int, stream_channel):
response = await self.redis_client.xread(
streams={stream_channel: '0-0'}, count=count, block=block)
return response
async def delete_message(self, stream_channel, message_id):
await self.redis_client.xdel(stream_channel, message_id)
Tiếp theo, cập nhật endpoint socket /chat như sau:
from ..redis.stream import StreamConsumer
@chat.websocket("/chat")
async def websocket_endpoint(websocket: WebSocket, token: str = Depends(get_token)):
await manager.connect(websocket)
redis_client = await redis.create_connection()
producer = Producer(redis_client)
json_client = redis.create_rejson_connection()
consumer = StreamConsumer(redis_client)
try:
while True:
data = await websocket.receive_text()
stream_data = {}
stream_data[str(token)] = str(data)
await producer.add_to_stream(stream_data, "message_channel")
response = await consumer.consume_stream(stream_channel="response_channel", block=0)
print(response)
for stream, messages in response:
for message in messages:
response_token = [k.decode('utf-8') for k, v in message[1].items()][0]
if token == response_token:
response_message = [v.decode('utf-8') for k, v in message[1].items()][0]
print(message[0].decode('utf-8'))
print(token)
print(response_token)
await manager.send_personal_message(response_message, websocket)
await consumer.delete_message(stream_channel="response_channel", message_id=message[0].decode('utf-8'))
except WebSocketDisconnect:
manager.disconnect(websocket)
Refresh Token
Cuối cùng, chúng ta cần cập nhật endpoint /refresh_token để lấy lịch sử chat từ database Redis dùng class Cache của chúng ta.
Trong server.src.redis, thêm file cache.py và thêm mã dưới đây:
from rejson import Path
class Cache:
def __init__(self, json_client):
self.json_client = json_client
async def get_chat_history(self, token: str):
data = self.json_client.jsonget(
str(token), Path.rootPath())
return data
Tiếp theo, trong server.src.routes.chat.py import class Cache và cập nhật endpoint /token thành dưới đây:
from ..redis.cache import Cache
@chat.get("/refresh_token")
async def refresh_token(request: Request, token: str):
json_client = redis.create_rejson_connection()
cache = Cache(json_client)
data = await cache.get_chat_history(token)
if data == None:
raise HTTPException(
status_code=400,
detail="Session expired or does not exist")
else:
return data
Bây giờ, khi chúng ta gửi GET request đến endpoint /refresh_token với bất kỳ token nào, endpoint sẽ lấy dữ liệu từ database Redis.
Nếu token chưa timeout, dữ liệu sẽ được gửi cho người dùng. Hoặc nó sẽ gửi phản hồi 400 nếu token không tìm thấy.
Cách test Chat với Multiple Clients trong Postman
Cuối cùng, chúng ta sẽ test hệ thống chat bằng cách tạo nhiều phiên chat trong Postman, kết nối nhiều clients trong Postman, và chat với bot trên các clients.
Cuối cùng, chúng ta sẽ thử lấy lịch sử chat cho các clients và hy vọng nhận được phản hồi phù hợp.
Tóm tắt
Hãy nhanh chóng tóm tắt những gì chúng ta đã đạt được với hệ thống chat của mình. Chat client tạo token cho mỗi phiên chat với client. Token này dùng để nhận diện mỗi client, và mỗi tin nhắn gửi bởi clients kết nối đến web server của chúng ta được xếp hàng trong kênh Redis (message_channel), được nhận diện bởi token.
Worker environment của chúng ta đọc từ kênh này. Nó không có manh mối ai là client (trừ là token duy nhất) và dùng tin nhắn trong queue để gửi request đến Huggingface inference API.
Khi nhận được phản hồi, phản hồi được thêm vào response channel và lịch sử chat được cập nhật. Client lắng nghe response_channel ngay lập tức gửi phản hồi đến client khi nhận phản hồi với token của nó.
Nếu socket vẫn mở, phản hồi này được gửi. Nếu socket đóng, chúng ta chắc chắn phản hồi được bảo toàn vì phản hồi được thêm vào lịch sử chat. Client có thể lấy lịch sử, ngay cả khi refresh trang hoặc mất kết nối.
Chúc mừng bạn đã đến đây! Bạn đã xây dựng được một hệ thống chat hoạt động.
Trong các bài viết tiếp theo, tôi sẽ tập trung vào xây dựng giao diện người dùng chat cho client, tạo unit và functional tests, fine-tuning worker environment cho thời gian phản hồi nhanh hơn với WebSockets và async requests, và cuối cùng triển khai ứng dụng chat trên AWS.
Bài viết này là một phần của series về xây dựng intelligent chatbots full-stack với công cụ như Python, React, Huggingface, Redis, v.v. Bạn có thể theo dõi toàn bộ series trên blog của tôi: blog.stephensanwo.dev - AI ChatBot Series**
Bạn có thể tải toàn bộ repository trên GitHub Repository của tôi
Tôi viết hướng dẫn này hợp tác với Redis. Cần giúp đỡ bắt đầu với Redis? Thử các tài nguyên sau:
- Thử Redis Cloud miễn phí
- Xem video về lợi ích Redis Cloud so với các provider Redis khác
- Redis Developer Hub - công cụ, hướng dẫn, và tutorials về Redis
- RedisInsight Desktop GUI
Học lập trình miễn phí. Chương trình mở của freeCodeCamp đã giúp hơn 40.000 người tìm được việc làm với tư cách là lập trình viên. Bắt đầu ngay hôm nay.