AWS Multi-Agent Orchestrator: Hướng dẫn kèm ví dụ

AWS Multi-Agent Orchestrator là gì?

AWS Multi-Agent Orchestrator là một framework linh hoạt, đi kèm nhiều công cụ, được thiết kế để quản lý các tác nhân AI và hỗ trợ hội thoại nhiều lượt phức tạp. Các thành phần dựng sẵn của nó cho phép phát triển và triển khai nhanh, giúp chúng ta tập trung vào ứng dụng mà không cần xây dựng lại các thành phần này từ đầu.

AWS Multi-Agent Orchestrator cung cấp các tính năng sau:

• Định tuyến thông minh: Xác định động tác nhân phù hợp nhất cho mỗi truy vấn.
• Phản hồi dạng streaming và không streaming: Hỗ trợ cả hai định dạng phản hồi của tác nhân.
• Quản lý ngữ cảnh: Quản lý tính mạch lạc và lịch sử trong hội thoại nhiều lượt.
• Khả năng mở rộng: Tạo tác nhân mới hoặc chỉnh sửa tác nhân hiện có.
• Triển khai linh hoạt: Hoạt động trên AWS Lambda, môi trường cục bộ và các nền tảng đám mây.

Framework được triển khai để hỗ trợ cả Python và TypeScript.

Tổng quan cách Multi-Agent Orchestrator vận hành. (Nguồn)

Trong sơ đồ trên, bộ phân loại xem xét các tác nhân hiện có, lời nhắc của người dùng và lịch sử hội thoại trước đó để chọn tác nhân tối ưu cho đầu vào của người dùng. Sau đó, tác nhân xử lý yêu cầu. Quy trình làm việc đơn giản nhưng hiệu quả.

Thiết lập AWS Multi-Agent Orchestrator

Để thiết lập nhanh môi trường, bạn có thể làm theo hướng dẫn trong tài liệu.

Trước hết, chúng ta tạo một thư mục mới và một môi trường Python mới để cài đặt các thư viện cần thiết.

mkdir test_multi_agent_orchestrator
cd test_multi_agent_orchestrator
python -m venv venv
source venv/bin/activate  # On Windows use venv\\Scripts\\activate

Khi môi trường ảo đã được kích hoạt, hãy cài đặt thư viện

pip install multi-agent-orchestrator

Tiếp theo, chúng ta cần cấu hình tài khoản AWS. Nếu bạn chưa có tài khoản AWS, hãy đăng ký miễn phí một tài khoản free tier. Sau khi đăng ký, tải AWS CLI.

AWS CLI cũng cần được cấu hình. Để biết hướng dẫn chi tiết, hãy làm theo Thiết lập AWS CLI, nhưng bạn có thể chọn cách đơn giản hơn bằng lệnh aws configure và cung cấp AWS access key ID và secret access key. Bạn có thể lấy các khóa này sau khi tạo người dùng mới trong bảng điều khiển.

Access key được cấp khi tạo người dùng mới.

Với các khóa trong tay, chạy aws configure và cung cấp khóa, chọn tên vùng (danh sách đầy đủ có tại đây) gần bạn nhất và đặt định dạng đầu ra mặc định là json.

Nếu CLI được cấu hình đúng, chạy lệnh aws sts get-caller-identity sẽ hiển thị AWS account ID, user ID và ARN của bạn.

Giờ AWS CLI đã sẵn sàng, chúng ta cần cấu hình AWS Bedrock để cấp quyền truy cập các LLM cần dùng. Amazon Bedrock là dịch vụ cho phép bạn thử nghiệm và gọi các mô hình nền tảng (chẳng hạn Llama 3.2 hoặc Claude 3.5 Sonnet) thông qua API. Multi-Agent Orchestrator sử dụng dịch vụ này để gọi hai mô hình theo mặc định:

1. Claude 3.5 Sonnet làm bộ phân loại
2. Claude 3 Haiku làm tác nhân

Dĩ nhiên, có thể thay đổi các mô hình này, nhưng trước mắt hãy tiếp tục với lựa chọn mặc định.

Để cấp quyền truy cập hai mô hình này, vào Amazon Bedrock > Model Access và chọn “Modify model access.” Chọn hai mô hình (và các mô hình khác nếu bạn muốn) và điền thông tin được yêu cầu. Phần này sẽ trông như sau:

Sau khi hoàn tất yêu cầu, các mô hình sẽ khả dụng trong 1–2 phút. Khi quyền truy cập được cấp cho các mô hình đã yêu cầu, bạn sẽ thấy “Access granted” phía trước chúng.

Lưu ý: Bạn có thể cần gán một policy cho người dùng đã tạo. Bạn có thể kiểm tra điều này nếu gặp vấn đề trong tiểu mục tiếp theo của bài viết (Kiểm tra thiết lập). Khi đó, hãy xem trang này. Tóm lại, bạn cần cấp cho người dùng đã định quyền AmazonBedrockFullAccess.

Kiểm tra thiết lập

Để kiểm tra các bước trước đã được thiết lập đúng hay chưa, hãy dùng đoạn mã này:

import uuid
import asyncio
import json
import sys
from typing import Optional, List, Dict, Any
from multi_agent_orchestrator.orchestrator import MultiAgentOrchestrator, OrchestratorConfig
from multi_agent_orchestrator.agents import (
    BedrockLLMAgent,
    BedrockLLMAgentOptions,
    AgentResponse,
    AgentCallbacks,
)
from multi_agent_orchestrator.types import ConversationMessage, ParticipantRole

orchestrator = MultiAgentOrchestrator(
    options=OrchestratorConfig(
        LOG_AGENT_CHAT=True,
        LOG_CLASSIFIER_CHAT=True,
        LOG_CLASSIFIER_RAW_OUTPUT=True,
        LOG_CLASSIFIER_OUTPUT=True,
        LOG_EXECUTION_TIMES=True,
        MAX_RETRIES=3,
        USE_DEFAULT_AGENT_IF_NONE_IDENTIFIED=True,
        MAX_MESSAGE_PAIRS_PER_AGENT=10,
    )
)


class BedrockLLMAgentCallbacks(AgentCallbacks):
    def on_llm_new_token(self, token: str) -> None:
        # handle response streaming here
        print(token, end="", flush=True)


tech_agent = BedrockLLMAgent(
    BedrockLLMAgentOptions(
        name="Tech Agent",
        streaming=True,
        description=(
            "Specializes in technology areas including software development, hardware, AI, "
            "cybersecurity, blockchain, cloud computing, emerging tech innovations, and pricing/costs "
            "related to technology products and services."
        ),
        model_id="anthropic.claude-3-sonnet-20240229-v1:0",
        callbacks=BedrockLLMAgentCallbacks(),
    )
)

orchestrator.add_agent(tech_agent)


async def handle_request(
    _orchestrator: MultiAgentOrchestrator, _user_input: str, _user_id: str, _session_id: str
):
    response: AgentResponse = await _orchestrator.route_request(
        _user_input, _user_id, _session_id
    )
    # Print metadata
    print("\nMetadata:")
    print(f"Selected Agent: {response.metadata.agent_name}")
    if response.streaming:
        print("Response:", response.output.content[0]["text"])
    else:
        print("Response:", response.output.content[0]["text"])


if __name__ == "__main__":
    USER_ID = "user123"
    SESSION_ID = str(uuid.uuid4())
    print("Welcome to the interactive Multi-Agent system. Type 'quit' to exit.")
    while True:
        # Get user input
        user_input = input("\nYou: ").strip()
        if user_input.lower() == "quit":
            print("Exiting the program. Goodbye!")
            sys.exit()
        # Run the async function
        asyncio.run(handle_request(orchestrator, user_input, USER_ID, SESSION_ID))

Nếu bạn có thể nhập prompt và nhận câu trả lời, mọi thứ đang hoạt động tốt.

Dự án demo với AWS Multi-Agent Orchestrator

Kho AWS Multi-Agent Orchestrator cung cấp một số dự án ví dụ bằng TypeScript và Python. Bây giờ chúng ta sẽ viết một ứng dụng Python giản lược gồm hai tác nhân: Python Developer Agent và ML Expert Agent.

Chúng ta cũng sẽ dùng Chainlit, một gói Python mã nguồn mở, để triển khai UI đơn giản cho ứng dụng. Đầu tiên, cài đặt các thư viện cần thiết:

chainlit==1.2.0
multi_agent_orchestrator==0.0.18

Chúng ta sẽ dùng đoạn mã dưới đây cho ứng dụng demo, nhưng trước hết hãy giải thích qua:

1. Bắt đầu bằng cách nhập các thư viện cần thiết.
2. Chúng ta dùng “anthropic.claude-3-haiku-20240307-v1:0” làm mô hình cho bộ phân loại. Bộ phân loại này sẽ chọn tác nhân nào để dùng khi có đầu vào mới từ người dùng.
3. Truyền bộ phân loại đã tạo vào MultiAgentOrchestrator và định nghĩa một số cấu hình.
4. Lớp BedrockLLMAgent được dùng để tạo các tác nhân. Cung cấp name và description cho mỗi tác nhân. Với một tác nhân, bạn có thể chọn bất kỳ mô hình nào có sẵn hoặc thậm chí dùng Ollama để chạy cục bộ. Đặt streaming=True và truyền ChainlitAgentCallbacks() làm callback sẽ giúp tác nhân trả về phản hồi dạng stream thay vì toàn bộ cùng lúc. Cuối cùng, thêm mỗi tác nhân vào orchestrator.
5. user_session được thiết lập và phần chính để xử lý tin nhắn của người dùng và tác nhân được định nghĩa.

### 1
import uuid
import chainlit as cl
from multi_agent_orchestrator.orchestrator import MultiAgentOrchestrator, OrchestratorConfig
from multi_agent_orchestrator.classifiers import BedrockClassifier, BedrockClassifierOptions
from multi_agent_orchestrator.agents import AgentResponse
from multi_agent_orchestrator.agents import BedrockLLMAgent, BedrockLLMAgentOptions, AgentCallbacks
from multi_agent_orchestrator.orchestrator import MultiAgentOrchestrator
from multi_agent_orchestrator.types import ConversationMessage
import asyncio
import chainlit as cl

class ChainlitAgentCallbacks(AgentCallbacks):
    def on_llm_new_token(self, token: str) -> None:
        asyncio.run(cl.user_session.get("current_msg").stream_token(token))

### 2
# Initialize the orchestrator & classifier
custom_bedrock_classifier = BedrockClassifier(BedrockClassifierOptions(
    model_id='anthropic.claude-3-haiku-20240307-v1:0',
    inference_config={
        'maxTokens': 500,
        'temperature': 0.7,
        'topP': 0.9
    }
))

### 3
orchestrator = MultiAgentOrchestrator(options=OrchestratorConfig(
        LOG_AGENT_CHAT=True,
        LOG_CLASSIFIER_CHAT=True,
        LOG_CLASSIFIER_RAW_OUTPUT=True,
        LOG_CLASSIFIER_OUTPUT=True,
        LOG_EXECUTION_TIMES=True,
        MAX_RETRIES=3,
        USE_DEFAULT_AGENT_IF_NONE_IDENTIFIED=False,
        MAX_MESSAGE_PAIRS_PER_AGENT=10,
    ),
    classifier=custom_bedrock_classifier
)

### 4
def create_python_dev():
    return BedrockLLMAgent(BedrockLLMAgentOptions(
        name="Python Developer Agent",
        streaming=True,
        description="Experienced Python developer specialized in writing, debugging, and evaluating only Python code.",
        model_id="anthropic.claude-3-sonnet-20240229-v1:0",
        callbacks=ChainlitAgentCallbacks()
    ))

def create_ml_expert():
    return BedrockLLMAgent(BedrockLLMAgentOptions(
        name="Machine Learning Expert",
        streaming=True,
        description="Expert in areas related to machine learning including deep learning, pytorch, tensorflow, scikit-learn, and large language models.",
        model_id="anthropic.claude-3-sonnet-20240229-v1:0",
        callbacks=ChainlitAgentCallbacks()
    ))

# Add agents to the orchestrator
orchestrator.add_agent(create_python_dev())
orchestrator.add_agent(create_ml_expert())

### 5
@cl.on_chat_start
async def start():
    cl.user_session.set("user_id", str(uuid.uuid4()))
    cl.user_session.set("session_id", str(uuid.uuid4()))
    cl.user_session.set("chat_history", [])

@cl.on_message
async def main(message: cl.Message):
    user_id = cl.user_session.get("user_id")
    session_id = cl.user_session.get("session_id")
    msg = cl.Message(content="")
    await msg.send()  # Send the message immediately to start streaming
    cl.user_session.set("current_msg", msg)
    response:AgentResponse = await orchestrator.route_request(message.content, user_id, session_id, {})
    # Handle non-streaming or problematic responses
    if isinstance(response, AgentResponse) and response.streaming is False:
        # Handle regular response
        if isinstance(response.output, str):
            await msg.stream_token(response.output)
        elif isinstance(response.output, ConversationMessage):
                await msg.stream_token(response.output.content[0].get('text'))
    await msg.update()

if __name__ == "__main__":
    cl.run()

Đã đến lúc chạy ứng dụng. Để làm điều này, trước tiên chạy chainlit run [app.py](<http://app.py/>) -w. Giờ bạn có thể thử ứng dụng trong thẻ mới được mở trên trình duyệt.

Như bạn thấy trong ảnh chụp màn hình, chúng ta đã có một UI để thử nghiệm ứng dụng và trò chuyện với các tác nhân.

Lưu ý rằng vì lời nhắc đầu tiên “Thủ đô của Pháp là gì?” không liên quan đến bất kỳ tác nhân nào của chúng ta, hệ thống sẽ không đưa ra câu trả lời. Điều này rất quan trọng để giữ cuộc trò chuyện đúng trọng tâm và tránh tiêu tốn tín dụng không cần thiết khi dùng các mô hình này. Tuy nhiên, khi được hỏi một câu liên quan, tác nhân Machine Learning Expert sẽ tham gia để đưa ra phản hồi nhờ vào định tuyến thông minh của Multi-Agent Orchestrator.

Kết luận

Trong bài viết này, chúng ta đã giới thiệu framework AWS Multi-Agent Orchestrator mới, làm nổi bật một số tính năng nổi bật của nó, phác thảo các bước thiết lập môi trường, khám phá các mô hình nền tảng do Amazon Bedrock cung cấp và triển khai một dự án demo.

Tại thời điểm viết bài, framework này còn thiếu tài liệu toàn diện và chi tiết. Để tận dụng các tính năng khác như bộ nhớ và công cụ, bạn cần đọc mã nguồn và xem các dự án ví dụ được cung cấp.

Theo dõi các framework AI tác nhân là lựa chọn khôn ngoan để bắt kịp lĩnh vực phát triển nhanh này. AWS Multi-Agent Orchestrator là một lựa chọn đầy hứa hẹn được xây dựng trên hạ tầng của các dịch vụ AWS, và đáng để dõi theo quá trình phát triển của nó.