Trong thiết kế tương tác cho các AI Agent, Slash Command (lệnh gạch chéo) đóng vai trò là một thành phần giao diện người dùng tối giản nhưng mạnh mẽ. Xuất phát từ các công cụ cộng tác như Slack hay Discord, Slash Command cho phép người dùng kích hoạt các chức năng cụ thể bằng cách nhập một đoạn mã ngắn bắt đầu bằng ký tự /, thay vì phải mô tả yêu cầu bằng ngôn ngữ tự nhiên dài dòng hoặc thao tác qua nhiều tầng menu.

Ví dụ, trong một Agent hỗ trợ lập trình, lệnh /refactor có thể ngay lập tức tối ưu hóa mã nguồn, hoặc /debug để tìm lỗi. Việc này không chỉ tăng tốc độ làm việc mà còn đảm bảo tính chính xác cho các tác vụ quan trọng.

Cấu trúc cơ bản của một Slash Command

Về mặt kỹ thuật, Slash Command là một chuỗi văn bản được định nghĩa trước mà hệ thống Agent sẽ phân tích (parse) để thực thi logic tương ứng. Một lệnh tiêu chuẩn thường gồm ba phần:

• Tiền tố (Prefix): Ký tự / để phân biệt với văn bản thông thường.
• Tên lệnh (Command Name): Định danh duy nhất cho hành động, ví dụ: summarize, search.
• Tham số (Arguments): Các thông tin bổ trợ đi kèm sau tên lệnh, cách nhau bởi khoảng trắng.

Triển khai bộ phân tích lệnh cơ bản với Python

Để Agent nhận diện được lệnh, chúng ta cần xây dựng một bộ điều phối (Dispatcher). Dưới đây là cách triển khai đơn giản bằng Python:

class AgentCommandHandler:
    """Lớp xử lý và điều phối các Slash Command"""
    
    def __init__(self):
        # Lưu trữ các hàm xử lý lệnh dưới dạng dictionary
        self._actions = {}

    def bind_action(self, cmd: str, callback):
        """Đăng ký một lệnh mới vào hệ thống"""
        self._actions[cmd.lower()] = callback

    def run(self, raw_input: str) -> str:
        """Phân tích đầu vào và thực thi lệnh tương ứng"""
        if not raw_input.startswith('/'):
            return "Vui lòng bắt đầu lệnh bằng dấu '/'"

        # Tách tên lệnh và các tham số
        tokens = raw_input[1:].split(maxsplit=1)
        cmd_name = tokens[0].lower()
        payload = tokens[1] if len(tokens) > 1 else ""

        if cmd_name in self._actions:
            return self._actions[cmd_name](payload)
        return f"Lệnh '/{cmd_name}' không tồn tại. Thử lại với /help."

# Các hàm xử lý cụ thể
def info_action(data):
    return "Danh sách lệnh: /info, /say <nội dung>"

def say_action(data):
    return f"Agent phản hồi: {data}" if data else "Bạn chưa nhập nội dung."

# Khởi tạo và chạy thử
if __name__ == "__main__":
    handler = AgentCommandHandler()
    handler.bind_action("info", info_action)
    handler.bind_action("say", say_action)

    print(handler.run("/info"))
    print(handler.run("/say Chào buổi sáng"))

Nâng cao: Xử lý tham số phức tạp và kiểm soát lỗi

Trong các hệ thống thực tế, tham số thường chứa dấu cách (như tên thành phố "New York") hoặc yêu cầu kiểm tra số lượng tham số đầu vào. Chúng ta có thể sử dụng biểu thức chính quy (Regex) để xử lý các trường hợp này một cách chuyên nghiệp hơn.

import re
from typing import List, Callable

class AdvancedCommandManager:
    def __init__(self):
        self.registry = {}

    def register(self, name: str, func: Callable, expected_args: int = None):
        """Đăng ký lệnh với tùy chọn kiểm tra số lượng tham số"""
        self.registry[name] = {"func": func, "arg_count": expected_args}

    def _extract_params(self, text: str) -> List[str]:
        """Sử dụng Regex để hỗ trợ tham số nằm trong ngoặc kép"""
        # Regex tìm các cụm từ trong ngoặc kép hoặc các từ đơn cách nhau bởi khoảng trắng
        pattern = r'(?:"([^"]*)"|(\S+))'
        matches = re.findall(pattern, text)
        return [m[0] if m[0] else m[1] for m in matches]

    def execute_command(self, input_str: str):
        if not input_str.startswith('/'):
            return "Đầu vào không hợp lệ."

        parts = input_str[1:].split(maxsplit=1)
        name = parts[0].lower()
        raw_params = parts[1] if len(parts) > 1 else ""

        if name not in self.registry:
            return f"Không tìm thấy lệnh: /{name}"

        params = self._extract_params(raw_params)
        config = self.registry[name]

        # Kiểm tra tính hợp lệ của số lượng tham số
        if config["arg_count"] is not None and len(params) != config["arg_count"]:
            return f"Lỗi: Lệnh /{name} yêu cầu {config['arg_count']} tham số."

        try:
            return config["func"](params)
        except Exception as e:
            return f"Lỗi hệ thống khi thực thi: {str(e)}"

# Ví dụ hàm xử lý tra cứu thời tiết
def get_weather(args):
    city = args[0]
    date = args[1] if len(args) > 1 else "hôm nay"
    return f"Đang tra cứu thời tiết tại {city} cho ngày {date}..."

# Khởi tạo hệ thống nâng cao
manager = AdvancedCommandManager()
manager.register("weather", get_weather)

print(manager.execute_command('/weather "Ho Chi Minh" "Ngày mai"'))
print(manager.execute_command('/weather Hanoi'))

Các nguyên tắc vàng khi thiết kế Slash Command

Để tối ưu hóa trải nghiệm người dùng, khi xây dựng Slash Command cho AI Agent, bạn nên tuân thủ các quy tắc sau:

• Tính nhất quán: Đặt tên lệnh ngắn gọn, dễ nhớ (ví dụ: dùng /img thay vì /generate-image-from-text).
• Hệ thống trợ giúp: Luôn có lệnh /help để liệt kê tất cả khả năng mà Agent có thể thực hiện.
• Phản hồi tức thì: Nếu một lệnh tốn nhiều thời gian xử lý (như gọi API bên ngoài), hãy gửi một thông báo xác nhận ngay lập tức cho người dùng trước khi trả về kết quả cuối cùng.
• Xử lý lỗi thông minh: Thay vì chỉ báo lỗi, hãy gợi ý cú pháp đúng cho người dùng. Ví dụ: "Bạn thiếu tham số, hãy thử: /weather [tên_thành_phố]".

Việc triển khai Slash Command hiệu quả không chỉ giúp Agent chuyên nghiệp hơn mà còn tạo ra một cầu nối giao tiếp minh bạch giữa người dùng và trí tuệ nhân tạo, giảm thiểu sự mơ hồ vốn có của ngôn ngữ tự nhiên.