Hướng dẫn AutoGPT: Tạo và Triển khai Tác Nhân AI Tự Trị Trên Máy Cục Bộ

AutoGPT Platform là một nền tảng cho phép bạn tạo, triển khai và quản lý các tác nhân AI chạy liên tục. Nền tảng sử dụng giao diện low-code để giúp tự động hóa hàng nghìn quy trình số, với các tác nhân hoạt động tự động ở hậu trường.

AutoGPT Platform có hai thành phần cốt lõi: AutoGPT Server — phần logic và hạ tầng chính, và AutoGPT Frontend — giao diện để xây dựng tác nhân, quản lý quy trình làm việc và thiết lập lịch chạy định kỳ. 

Nó được tích hợp sẵn với các nhà cung cấp LLM như OpenAI, Anthropic, Groq và Llama để có thể tự động hóa nhiều tác vụ như xử lý dữ liệu, tạo nội dung hoặc thậm chí các hoạt động mang tính giải trí. 

Trong hướng dẫn này, chúng tôi sẽ hướng dẫn các chuyên gia kỹ thuật cách thiết lập AutoGPT trên máy cục bộ và tạo tác nhân đầu tiên. Bạn có thể đọc hướng dẫn đầy đủ của chúng tôi về Tìm hiểu về Tác nhân AI để biết thêm, và khám phá các loại tác nhân AI khác nhau trong một bài viết riêng. 

AutoGPT là gì?

AutoGPT là một nền tảng/phần mềm AI cho phép người dùng tạo, triển khai và quản lý các tác nhân AI tự trị. Các tác nhân này có thể thực hiện nhiều nhiệm vụ với mức độ giám sát tối thiểu thông qua giao diện low-code được cài đặt trên máy của người dùng. 

Tại thời điểm viết bài, có một danh sách chờ mở cho phiên bản AutoGPT đám mây sắp ra mắt nếu bạn muốn tránh việc thiết lập cục bộ.

Các tính năng và khả năng chính của AutGPT gồm có:

• Quy trình low-code: Tạo quy trình làm việc mà không cần nhiều kiến thức lập trình.
• Vận hành tự động: Triển khai các tác nhân chạy liên tục, kích hoạt theo các trình kích hoạt cụ thể.
• Tự động hóa thông minh: Tự động hóa các quy trình lặp lại cho xử lý dữ liệu, tạo nội dung và các nhiệm vụ khác.
• Hệ thống dựa trên khối: Xây dựng tác nhân bằng các khối mô-đun đại diện cho các hành động và tích hợp khác nhau.
• Hỗ trợ nhiều LLM: Tương thích với OpenAI, Anthropic, Groq và Llama.
• Marketplace: Truy cập các tác nhân cấu hình sẵn cho những trường hợp sử dụng cụ thể.

Tổng quan kiến trúc AutoGPT

Nền tảng AutoGPT gồm hai thành phần chính:

1. Máy chủ AutoGPT:

• Logic cốt lõi cho tác nhân và tự động hóa
• Hạ tầng để đảm bảo hiệu năng ổn định
• Marketplace cho các tác nhân dựng sẵn

2. Giao diện AutoGPT:

• Trình xây dựng tác nhân để thiết kế và cấu hình
• Công cụ quản lý quy trình làm việc
• Điều khiển triển khai
• Chọn tác nhân sẵn sàng sử dụng
• Bảng điều khiển giám sát và phân tích

Backend của AutoGPT dùng Python với FastAPI làm web framework và PostgreSQL với Prisma ORM để lưu trữ dữ liệu. Hệ thống sử dụng websockets cho giao tiếp thời gian thực và có các trình quản lý thực thi, lập lịch và thông báo. 

Thiết kế này giúp tăng khả năng mở rộng và bảo trì khi nền tảng phát triển.

Frontend sử dụng Next.js 14 với TypeScript, các thành phần Radix và Tailwind CSS, trực quan hóa quy trình bằng xyflow. Điều này tạo ra giao diện low-code trực quan, nơi người dùng có thể xây dựng tác nhân AI mà không cần nhiều kiến thức lập trình.

Nền tảng bao gồm các dịch vụ chính sau:

• Trình quản lý cơ sở dữ liệu: Lưu cấu hình tác nhân và dữ liệu thực thi
• Trình quản lý thực thi: Chạy quy trình làm việc và quản lý trạng thái tác nhân
• Bộ lập lịch: Xử lý tự động theo thời gian và nhiệm vụ định kỳ
• Máy chủ Websocket: Cung cấp cập nhật theo thời gian thực
• REST API: Cung cấp quyền truy cập tính năng bằng lập trình
• Giao thức tác nhân: Chuẩn hóa giao tiếp với dịch vụ bên ngoài
• API tích hợp: Kết nối tới dịch vụ bên thứ ba và nhà cung cấp AI

AutoGPT năm 2025 so với các phiên bản cũ

Khi mới được giới thiệu vào khoảng năm 2023, AutoGPT bùng nổ về mức độ phổ biến và được xem là “sát thủ” mã nguồn mở của ChatGPT. Tất nhiên, đó chỉ là làn sóng thổi phồng do các influencer trên mạng xã hội dẫn dắt, vì bây giờ đã là 2025 và ChatGPT vẫn ở đây. Nhưng AutoGPT đã báo hiệu sự chuyển dịch trọng tâm của cộng đồng AI sang các tác nhân AI.

Những phiên bản đầu hứa hẹn các tác nhân hoàn toàn tự trị có thể được xây dựng tức thời từ một prompt duy nhất. Hệ thống sẽ có khả năng chia nhỏ prompt thành các nhiệm vụ có thể xử lý và ghép nối nhiều công cụ, phần mềm, API để hoàn thành công việc, đồng thời có cả bộ nhớ ngắn hạn và dài hạn được tăng cường nhờ vòng phản hồi tự phản tư. 

Tuy nhiên, trong quá trình phát triển, họ hẳn đã nhận ra những hạn chế của cách tiếp cận này do tính khó dự đoán vốn có của LLM trong môi trường sản xuất.

Ngày nay, AutoGPT không còn là nền tảng “prompt-to-agent” như vậy nữa mà là một thứ tốt hơn nhiều — một nền tảng low-code trao quyền kiểm soát cho người dùng trong cách xây dựng tác nhân. Bạn có thể thấy sự chuyển dịch này từ phiên bản gốc của AutoGPT sang nền tảng chúng ta có năm 2025 nếu đọc các bài viết từ 1–2 năm trước hoặc xem video YouTube. 

Những bài đó đưa ra hướng dẫn cài đặt và ví dụ quy trình làm việc hoàn toàn khác so với những gì tôi sắp hướng dẫn bạn.

Vậy nên, không dài dòng thêm nữa, hãy xem cách bạn có thể thiết lập nền tảng trên máy của mình.

Cài đặt và Cấu hình AutoGPT

Thiết lập AutoGPT cục bộ đòi hỏi cấu hình đúng môi trường phát triển và hiểu các công cụ container hóa — hãy xem khóa học của chúng tôi về Containerization and Virtualization với Docker và Kubernetes nếu bạn cần ôn lại. Phần này hướng dẫn toàn bộ quy trình từ yêu cầu tiên quyết đến lần chạy đầu tiên của nền tảng.

Yêu cầu tiên quyết và thiết lập môi trường

Trước khi cài đặt AutoGPT, hãy đảm bảo bạn có các thành phần sau:

1. Node.js & NPM

• Mac:
• brew install node
• Linux/WSL2:
• sudo apt update sudo apt install nodejs npm
• Xác minh cài đặt:
• node -v npm -v

2. Docker & Docker Compose

• Mac: Tải về và cài đặt Docker Desktop
• Linux (WSL2 đi kèm kernel Docker và vẫn cần cài đặt):
• sudo apt update sudo apt install docker.io docker-compose sudo systemctl enable --now docker
• Xác minh cài đặt:
• docker -v docker compose -v

3. Git

• Mac:
• brew install git
• Linux/WSL2:
• sudo apt update sudo apt install git

Nhân bản kho AutoGPT:

git clone https://github.com/Significant-Gravitas/AutoGPT.git

Các yêu cầu trên là cần thiết để chạy AutoGPT hiệu quả. Node.js và NPM cần cho ứng dụng frontend, cho phép bạn tương tác với AutoGPT qua giao diện thân thiện. 

Docker và Docker Compose tạo các container cách ly để đảm bảo hiệu năng nhất quán trên các hệ thống khác nhau và đơn giản hóa việc triển khai các dịch vụ backend. Git giúp bạn nhân bản kho mã và cập nhật các cải tiến mới nhất.

Sau bước này, bạn sẽ có thư mục AutoGPT trên máy, chứa mọi thứ để chạy ứng dụng. Phần còn lại là cấu hình.

Lưu trữ cục bộ với Docker 

Docker cung cấp môi trường cách ly, nhất quán để chạy AutoGPT, đảm bảo mọi phụ thuộc hoạt động đúng bất kể hệ điều hành của bạn.

1. Thiết lập dịch vụ backend

cd AutoGPT/autogpt_platform
cp .env.example .env
docker compose up -d --build

Tệp .env mới đi kèm các biến môi trường với giá trị mặc định hợp lý. Bạn không bắt buộc phải tự cấu hình tệp này nhưng sự hiện diện của nó là bắt buộc. Tệp sẽ được ứng dụng frontend sử dụng khi bạn cung cấp các khóa và bí mật trong quá trình tạo tác nhân tùy chỉnh.

Lệnh docker compose cuối có thể mất tới 15 phút tùy tốc độ Internet trong lần chạy đầu. Nó thiết lập các thành phần backend mà frontend sẽ kết nối tới.

2. Thiết lập ứng dụng frontend

cd frontend
cp .env.example .env
npm install
npm run dev

Các lệnh này thiết lập tệp môi trường cho frontend, cài đặt phụ thuộc bằng Node.js và khởi chạy giao diện.

3. Xác minh cài đặt

• Truy cập UI AutoGPT tại http://localhost:3000
• Các dịch vụ backend chạy trên cổng:
• WebSocket Server: 8001
• Execution API: 8006

Truy cập cổng 3000 sẽ hiển thị giao diện Marketplace, tại đó bạn cần tạo tài khoản và đăng nhập.

4. Tùy chỉnh khóa mã hóa của bạn (không bắt buộc nhưng nên làm)

# Generate a new key with Python
from cryptography.fernet import Fernet
Fernet.generate_key().decode()

# Or use the built-in CLI
poetry run cli gen-encrypt-key

Thay thế khóa hiện có trong autogpt_platform/backend/.env bằng khóa mới của bạn.

Lưu ý cho người dùng Windows: Khi dùng Docker trên Windows, hãy chọn WSL 2 thay vì Hyper-V trong quá trình cài đặt để tránh vấn đề tương thích với Supabase. Nếu bạn đã cài bằng Hyper-V, có thể chuyển sang WSL 2 trong cài đặt Docker Desktop.

Tổng quan Giao diện Người dùng AutoGPT

Trước khi tạo một tác nhân hoạt động, hãy làm quen với giao diện trình xây dựng của AutGPT.

Giao diện là một canvas trống lớn với bốn nút chính:

• Blocks
• Nút hoàn tác/làm lại
• Lưu

Nhấp “Blocks” sẽ mở menu các thành phần tái sử dụng tích hợp sẵn của AutoGPT được nhóm theo danh mục.

Các khối này cung cấp công cụ thiết yếu có thể áp dụng phổ quát trong nhiều kịch bản tác nhân. 

Ví dụ, bên dưới tôi đã tìm và thêm hai khối — ô nhập văn bản dài và bộ tạo văn bản AI. Hai thành phần này đủ để tôi tái tạo phiên bản cơ bản của giao diện ChatGPT:

Nhìn vào hình, bạn có thể thấy mỗi khối có các phần có thể thao tác khác nhau. Khối nhập có các trường cho tên khối và giá trị mặc định; trong khi bộ tạo văn bản có trường prompt, mô hình và biến prompt. 

Khối sau còn có trường nhập khóa API OpenAI một lần, bạn cần cung cấp trước khi chạy tác nhân (hãy làm ngay). Trường khóa API sẽ thay đổi dựa trên mô hình bạn chọn và AutoGPT hỗ trợ hầu hết nhà cung cấp lớn và nhỏ.

Bạn sẽ thấy cả hai khối đều có các đầu nối nhỏ (nhìn vào 3 và 5) cho phép bạn liên kết chúng:

Trong hình trên, tôi đặt tên (1) và giá trị mặc định (2) cho khối nhập, rồi nối kết quả văn bản (3) của nó vào trường prompt (4) của bộ tạo văn bản. Kết nối này tạo ra một quy trình tác nhân cơ bản, có thể thực thi sau khi lưu tác nhân (các bước 5–8).

Sau khi nhấp chạy, bạn sẽ thấy menu “Run settings” bật lên cho trường nhập:

Nhập prompt của bạn và chạy toàn bộ để nhận kết quả đầu tiên như dưới đây:

Bạn có thể nhận thấy phản hồi của mô hình khó đọc trong khối tạo văn bản lớn. Vì vậy AutoGPT có các khối cho đầu ra của tác nhân, mà tôi đang thêm bên dưới:

Lưu ý tôi đã nối trường phản hồi của bộ tạo văn bản với giá trị của khối đầu ra tác nhân. Thêm một khối đầu ra cũng cho phép bạn xem toàn bộ đầu ra tác nhân từ các khối khác nhau tại một nơi bằng bảng “Agent Outputs”:

Sau khi lưu, tác nhân của bạn sẽ được lưu vào thư viện. Hơn nữa, toàn bộ tác nhân này có thể được dùng như một khối trong các tác nhân khác bạn tạo. Cách tiếp cận mô-đun này mang lại một số lợi ích:

1. Tái sử dụng: Bạn có thể tái sử dụng chức năng phức tạp trên nhiều dự án mà không cần xây lại.
2. Khả năng hợp thành: Kết hợp các tác nhân khác nhau để tạo quy trình tinh vi hơn.
3. Dễ bảo trì: Khi bạn cập nhật tác nhân gốc, mọi phiên bản dùng nó như một khối sẽ được hưởng lợi từ cải tiến.
4. Trừu tượng hóa: Quy trình phức tạp có thể được gói gọn trong một khối, giúp quy trình chính gọn gàng và dễ hiểu hơn.
5. Hợp tác: Chia sẻ các khối tác nhân chuyên biệt với đồng đội hoặc cộng đồng để tăng tốc phát triển.

Cách xây dựng theo khối này giúp bạn tạo ra hệ thống AI ngày càng mạnh mẽ bằng cách xếp chồng các năng lực lên nhau.

Viết Khối Tùy Chỉnh trong AutoGPT bằng Python

Tổng quan cú pháp và quy trình chung

Sức mạnh của AutoGPT đến từ hệ thống khối mô-đun. Dù nền tảng đã có nhiều khối tích hợp hữu ích, bạn có thể mở rộng khả năng bằng cách tạo khối tùy chỉnh bằng Python. Tính năng này cho phép tích hợp với bất kỳ API, dịch vụ hoặc công cụ nào có thể truy cập bằng lập trình.

Tạo một khối tùy chỉnh gồm các bước thiết yếu sau:

1. Tạo tệp Python mới trong thư mục autogpt_platform/backend/backend/blocks với cách đặt tên snake_case
2. Định nghĩa lớp kế thừa từ lớp cơ sở Block
3. Tạo schema đầu vào và đầu ra bằng BlockSchema để định nghĩa cấu trúc dữ liệu
4. Cài đặt phương thức __init__ với ID duy nhất và dữ liệu kiểm thử
5. Viết phương thức run chứa logic cốt lõi của khối
6. Xử lý lỗi đúng cách để khối thất bại một cách an toàn
7. Kiểm thử khối bằng hạ tầng kiểm thử của nền tảng

Hãy phân tích chi tiết từng thành phần:

Cấu trúc lớp Block

Mọi khối đều phải kế thừa từ lớp cơ sở Block và định nghĩa schema đầu vào/đầu ra:

from backend.data.block import Block, BlockSchema, BlockOutput

class MyCustomBlock(Block):
   class Input(BlockSchema):
       # Define input fields with types
       field1: str
       field2: int
      
   class Output(BlockSchema):
       # Define output fields with types
       result: str
       error: str  # Always include an error field
      
   def __init__(self):
       super().__init__(
           id="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",  # Generate proper UUID
           input_schema=MyCustomBlock.Input,
           output_schema=MyCustomBlock.Output,
           test_input={"field1": "test", "field2": 42},
           test_output=("result", "expected output"),
           test_mock=None  # Only needed for external API calls
       )
      
   def run(self, input_data: Input, **kwargs) -> BlockOutput:
       try:
           # Your block logic here
           result = f"Processed {input_data.field1} and {input_data.field2}"
           yield "result", result
       except Exception as e:
           raise RuntimeError(f"Error in block: {str(e)}")

Thành phần quan trọng

1. Schema đầu vào/đầu ra: Định nghĩa cấu trúc dữ liệu bằng type hints
2. Tạo UUID: Sử dụng trình tạo UUID chuẩn (đừng tự bịa)
3. Dữ liệu kiểm thử: Cung cấp đầu vào kiểm thử thực tế và đầu ra kỳ vọng
4. Xử lý lỗi: Luôn xử lý lỗi đúng cách trong phương thức run
5. Xuất kết quả: Dùng yield để xuất kết quả từng mục

Ví dụ về khối tùy chỉnh

Hãy tạo một ví dụ chi tiết về khối tùy chỉnh thực hiện phân tích cảm xúc bằng OpenAI API. Ví dụ này minh họa cách tích hợp với dịch vụ AI bên ngoài và xử lý khóa API an toàn.

Hướng dẫn thiết lập khóa API OpenAI

Trước khi dùng khối này, bạn cần thiết lập khóa API OpenAI:

1. Cài đặt các gói cần thiết:

• pip install openai python-dotenv

2. Tạo tệp .env trong thư mục autogpt_platform/backend/blocks với khóa API OpenAI của bạn:

• OPENAI_API_KEY=your_api_key_here

Giờ hãy tạo khối:

Nhập phụ thuộc và thiết lập môi trường

Trước hết, xử lý import và thiết lập môi trường:

# autogpt_platform/backend/blocks/sentiment_analyzer.py
from backend.data.block import Block, BlockSchema, BlockOutput
from typing import Dict, Any, List
import os
from dotenv import load_dotenv
from openai import OpenAI
import json

# Load environment variables from .env file
load_dotenv()

Phần này import các thư viện cần thiết và nạp biến môi trường từ tệp .env. Hàm load_dotenv() đảm bảo khóa API có sẵn thông qua os.getenv().

Định nghĩa schema khối và khởi tạo

Tiếp theo, định nghĩa lớp khối với schema đầu vào và đầu ra:

class OpenAISentimentBlock(Block):
   """Block to analyze sentiment of text using OpenAI API"""
  
   class Input(BlockSchema):
       text: str  # Text to analyze
       model: str = "gpt-3.5-turbo"  # OpenAI model to use
       detailed_analysis: bool = False  # Whether to return detailed analysis
      
   class Output(BlockSchema):
       sentiment: str  # Positive, Negative, or Neutral
       confidence: float  # Confidence score of the prediction
       explanation: str  # Brief explanation of the sentiment
       detailed_analysis: Dict[str, Any]  # Optional detailed analysis
       error: str  # Error message if analysis fails

Schema đầu vào định nghĩa ba tham số:

• text: Nội dung cần phân tích (bắt buộc)
• model: Mô hình OpenAI sử dụng (mặc định "gpt-3.5-turbo")
• detailed_analysis: Có trả về chi tiết bổ sung hay không (mặc định False)

Schema đầu ra định nghĩa cấu trúc kết quả, bao gồm loại cảm xúc, điểm tin cậy, giải thích và phân tích chi tiết tùy chọn.

Khởi tạo khối với dữ liệu kiểm thử

Phương thức __init__ thiết lập khối với dữ liệu kiểm thử và khởi tạo client OpenAI:

def __init__(self):
   super().__init__(
       id="8f67d394-9f52-4352-a78b-175d5d1d7182",  # Generated UUID
       input_schema=OpenAISentimentBlock.Input,
       output_schema=OpenAISentimentBlock.Output,
       test_input={
           "text": "I really enjoyed this product, it exceeded my expectations!",
           "detailed_analysis": True
       },
       test_output=[
           ("sentiment", str),
           ("confidence", float),
           ("explanation", str),
           ("detailed_analysis", dict)
       ],
       test_mock={
           "_analyze_sentiment": lambda text, model, detailed: {
               "sentiment": "positive",
               "confidence": 0.92,
               "explanation": "The text expresses clear enjoyment and states that expectations were exceeded.",
               "detailed_analysis": {
                   "emotions": {
                       "joy": "high",
                       "satisfaction": "high",
                       "disappointment": "none"
                   },
                   "key_phrases": ["really enjoyed", "exceeded expectations"],
                   "tone": "enthusiastic"
               }
           }
       }
   )
   # Initialize OpenAI client
   api_key = os.getenv("OPENAI_API_KEY")
   if not api_key:
       raise RuntimeError("OpenAI API key not found. Please set OPENAI_API_KEY in .env file.")
   self.client = OpenAI(api_key=api_key)

Phương thức này:

• Thiết lập đầu vào kiểm thử thực tế và đầu ra kỳ vọng cho việc kiểm thử
• Cung cấp mô phỏng cho hàm phân tích cảm xúc để tránh gọi API khi kiểm thử
• Khởi tạo client OpenAI với khóa API từ biến môi trường
• Ném lỗi nếu thiếu khóa API

Cài đặt phương thức phân tích cảm xúc

Chức năng cốt lõi được cài đặt trong phương thức _analyze_sentiment:

@staticmethod
def _analyze_sentiment(self, text: str, model: str, detailed: bool) -> Dict[str, Any]:
   """Analyze sentiment using OpenAI API"""
   # Create prompt based on whether detailed analysis is requested
   if detailed:
       system_prompt = """
       You are a sentiment analysis expert. Analyze the following text and provide:
       1. The overall sentiment (positive, negative, or neutral)
       2. A confidence score from 0.0 to 1.0
       3. A brief explanation of your assessment
       4. A detailed analysis including:
          - Key emotions detected and their intensity
          - Key phrases that influenced your assessment
          - Overall tone of the text
      
       Format your response as a JSON object with the following structure:
       {
           "sentiment": "positive|negative|neutral",
           "confidence": 0.0-1.0,
           "explanation": "brief explanation",
           "detailed_analysis": {
               "emotions": {"emotion1": "intensity", "emotion2": "intensity"},
               "key_phrases": ["phrase1", "phrase2"],
               "tone": "description of tone"
           }
       }
       """
   else:
       system_prompt = """
       You are a sentiment analysis expert. Analyze the following text and provide:
       1. The overall sentiment (positive, negative, or neutral)
       2. A confidence score from 0.0 to 1.0
       3. A brief explanation of your assessment
      
       Format your response as a JSON object with the following structure:
       {
           "sentiment": "positive|negative|neutral",
           "confidence": 0.0-1.0,
           "explanation": "brief explanation"
       }
       """
  
   try:
       # Make API call using the latest OpenAI API syntax
       response = self.client.chat.completions.create(
           model=model,
           response_format={"type": "json_object"},
           messages=[
               {"role": "system", "content": system_prompt},
               {"role": "user", "content": text}
           ],
           temperature=0.2  # Low temperature for more consistent results
       )
      
       # Extract and parse JSON response
       content = response.choices[0].message.content
       result = json.loads(content)
      
       return result
      
   except Exception as e:
       raise RuntimeError(f"OpenAI API error: {str(e)}")

Phương thức này:

• Tạo system prompt khác nhau tùy theo có yêu cầu phân tích chi tiết hay không
• Sử dụng OpenAI API để tạo phân tích cảm xúc có cấu trúc
• Đặt nhiệt độ thấp (0,2) để có kết quả nhất quán hơn
• Phân tích phản hồi JSON và trả về
• Xử lý ngoại lệ có thể xảy ra khi gọi API

Cài đặt phương thức run

Cuối cùng, phương thức run liên kết mọi thứ lại với nhau:

def run(self, input_data: Input, **kwargs) -> BlockOutput:
   try:
       # Validate input
       if not input_data.text or not isinstance(input_data.text, str):
           raise ValueError("Text must be a non-empty string")
      
       # Process through OpenAI
       results = self._analyze_sentiment(
           input_data.text,
           input_data.model,
           input_data.detailed_analysis
       )
      
       # Yield the results
       yield "sentiment", results["sentiment"]
       yield "confidence", results["confidence"]
       yield "explanation", results["explanation"]
      
       # Only return detailed analysis if requested and available
       if input_data.detailed_analysis and "detailed_analysis" in results:
           yield "detailed_analysis", results["detailed_analysis"]
      
   except ValueError as e:
       raise RuntimeError(f"Input validation error: {str(e)}")
   except Exception as e:
       raise RuntimeError(f"Sentiment analysis failed: {str(e)}")

Phương thức này:

• Kiểm tra tính hợp lệ của văn bản đầu vào
• Gọi phương thức phân tích cảm xúc với tham số đầu vào
• Xuất kết quả lần lượt bằng từ khóa yield
• Chỉ xuất phân tích chi tiết nếu được yêu cầu và có sẵn
• Xử lý các loại lỗi khác nhau với thông báo phù hợp

Các khía cạnh then chốt của ví dụ

1. Tích hợp OpenAI API: Dùng cú pháp OpenAI API mới nhất với endpoint chat completions
2. Xử lý khóa API an toàn: Nạp khóa API từ biến môi trường bằng dotenv
3. Phân tích tùy chỉnh: Cung cấp phân tích cơ bản hoặc chi tiết theo sở thích người dùng
4. Đầu ra có cấu trúc: Trả về loại cảm xúc, điểm tin cậy, giải thích và phân tích chi tiết tùy chọn
5. Xử lý JSON: Xử lý phản hồi JSON có cấu trúc từ OpenAI
6. Chiến lược kiểm thử: Giả lập cuộc gọi OpenAI API để kiểm thử mà không tốn tín dụng API

Khối này minh họa cách tích hợp với các dịch vụ AI tối tân để nâng cao khả năng của tác nhân. Tích hợp OpenAI cho phép phân tích văn bản tinh vi mà khó có thể thực hiện bằng các phương pháp dựa trên luật đơn giản.

Khi viết khối của riêng bạn, luôn cân nhắc:

• Cách xử lý khóa API an toàn
• Cung cấp thông báo lỗi rõ ràng khi API thất bại
• Thiết kế đầu vào linh hoạt để khối có thể sử dụng theo nhiều cách
• Cấu trúc đầu ra để các khối hạ lưu dễ tiêu thụ

Để biết thêm chi tiết về cách tạo khối tùy chỉnh, bao gồm kiểu trường, xác thực, tích hợp webhook và thực hành tốt nhất, xem tài liệu chính thức về Khối AutoGPT.

Kết luận

AutoGPT cung cấp một nền tảng mạnh mẽ để tạo và triển khai các tác nhân AI tự trị thông qua giao diện trực quan dựa trên khối. Hướng dẫn này đã dẫn bạn đi qua toàn bộ quy trình — từ cài đặt và cấu hình cục bộ đến hiểu UI, tạo tác nhân cơ bản và mở rộng chức năng bằng các khối tùy chỉnh. 

Bằng cách tận dụng kiến trúc mô-đun của AutoGPT, các chuyên gia kỹ thuật có thể tự động hóa quy trình phức tạp mà không cần nhiều kiến thức mã hóa, đồng thời vẫn có sự linh hoạt để bổ sung khả năng tùy chỉnh khi cần.

Đối với những ai muốn tiếp tục phát triển từ nền tảng này và khám phá sâu hơn về tác nhân AI, tài liệu chính thức của AutoGPT cung cấp hướng dẫn toàn diện, trong khi DataCamp cung cấp các tài nguyên bổ trợ như Tìm hiểu về Tác nhân AI và Kiến thức Cơ bản về ChatGPT. 

Khóa học Giới thiệu về GPTs có thể giúp củng cố hiểu biết của bạn về các mô hình ngôn ngữ lớn, trong khi Xây dựng Chatbot RAG cho Tài liệu Kỹ thuật minh họa một ứng dụng thực tế khác của tác nhân AI. Khi tiếp tục thử nghiệm với tác nhân AI, bạn cũng có thể xem các công cụ mới như Mistral Agents API, Dify AI và Langflow.