大模型Assistant API简述

2024-09-09 本文已影响0人梅西爱骑车

一、Assistant概念

Assistant，常被称作“智能体”或 Agent，是一款集成了大语言模型及多种工具的 AI 应用。它不仅能回答您的问题，还可以调用知识库、查询数据库/Excel、执行代码、生成图像、联网搜索，甚至调用您的业务API接口或本地函数。

Assistant 支持对话交互管理，能够保存历史消息记录，如果您想完善问题，也可以修改后再次请求回答。

二、运行机制

Assistant 接受用户输入，并由内置的大语言模型判断是否需要调用工具。

如果需要调用工具，大语言模型会选择合适的工具，工具返回结果和用户内容合并后再次输入到大语言模型，由大语言模型生成内容并输出。
如果无需调用工具，大语言模型将直接生成内容并输出。

Assistant 工作流

Assistant API

Assistant API 是一套用于构建 Assistant 的开发工具，旨在简化 Assistant 的创建与管理，帮助您方便地管理对话消息，以及调用工具。

三、核心组件

Assistant API 包含四个核心组件：

Assistant API 对象	功能
智能体（Assistant）	功能强大的 AI 对话助手，结合了大语言模型和多种高级工具。
线程（Thread）	用户和智能体之间的会话线程，用于管理历史会话记录。
消息（Message）	用户发送的消息，以及智能体回复的消息，以列表的形式保存在线程中。
运行（Run）	将线程中存储的上下文信息输入到智能体，以完成一次运行。

您可以使用 Assistant API 创建一个智能体应用的 Assistant。Assistant API 的主要组件与智能体应用控制台界面的大致对应关系如下：

Assistant各组件与页面对应关系

四、运行机制

Assistant API 采用线程（Thread）机制确保消息的有序执行，以此维护对话的时序连贯性。具体流程如下：

创建消息实例：用户通过Message.create()方法创建消息实例，该消息归属于特定的线程。这一步骤是初始化消息的基础，确保每条消息都能正确关联到上下文环境。
启动 Assistant 运行环境：利用Run.create()函数来初始化 Assistant 的执行环境。这为消息的处理提供了必要的运行时配置。
等待输出结果：调用wait()函数等待 Assistant 完成处理并返回结果。这一环节保证了程序在获取响应前保持同步，避免了数据乱序的风险。

Assistant API 内部实现了一个基于 Thread 的顺序消息队列，该队列自动依据消息的创建时间进行排序。这意味着 Assistant 将严格按照消息的时间顺序来接收和处理输入，从而产生与之对应的响应。

Assistant API 支持连续消息的无缝整合，不论是连续的用户查询还是智能体的连续反馈，都能在对话流程中平滑过渡。这种设计不仅增强了对话的自然流畅度，还显著提高了多轮交互的效率和体验。

完整的示例代码——Python：

import dashscope
from http import HTTPStatus
import json


def check_status(component, operation):
    if component.status_code == HTTPStatus.OK:
        print(f"{operation} 成功。")
        return True
    else:
        print(f"{operation} 失败。状态码：{component.status_code}，错误码：{component.code}，错误信息：{component.message}")
        return False


# 1. 创建绘画助手
painting_assistant = dashscope.Assistants.create(
    model='qwen-max',
    name='Art Maestro',
    description='用于绘画和艺术知识的AI助手',
    instructions='''提供绘画技巧、艺术史和创意指导的信息。
    使用工具进行研究和生成图像。''',
    tools=[
        {'type': 'quark_search', 'description': '用于研究艺术主题'},
        {'type': 'text_to_image', 'description': '用于创建视觉示例'}
    ]
)

if not check_status(painting_assistant, "助手创建"):
    exit()

# 2. 创建一个新线程
thread = dashscope.Threads.create()

if not check_status(thread, "线程创建"):
    exit()

# 3. 向线程发送消息
message = dashscope.Messages.create(thread.id, content='请帮我画一幅布偶猫的画。')

if not check_status(message, "消息创建"):
    exit()

# 4. 在线程上运行助手
run = dashscope.Runs.create(thread.id, assistant_id=painting_assistant.id)

if not check_status(run, "运行创建"):
    exit()

# 5. 等待运行完成
print("等待助手处理请求...")
run = dashscope.Runs.wait(run.id, thread_id=thread.id)

if check_status(run, "运行完成"):
    print(f"运行完成，状态：{run.status}")
else:
    print("运行未完成。")
    exit()

# 6. 检索并显示助手的响应
messages = dashscope.Messages.list(thread.id)

if check_status(messages, "消息检索"):
    if messages.data:
        # 显示最后一条消息的内容（助手的响应）
        last_message = messages.data[0]
        print("\n助手的回应：")
        print(json.dumps(last_message, ensure_ascii=False, default=lambda o: o.__dict__, sort_keys=True, indent=4))
    else:
        print("在线程中未找到消息。")
else:
    print("未能检索到助手的响应。")

# 提示: 这段代码创建了一个绘画助手，开始了一段关于如何绘制布偶猫的对话，
# 并展示了助手的回答。

完整的示例代码——Java:

package com.example;
import java.util.Arrays;

import com.alibaba.dashscope.assistants.Assistant;
import com.alibaba.dashscope.assistants.AssistantParam;
import com.alibaba.dashscope.assistants.Assistants;
import com.alibaba.dashscope.common.GeneralListParam;
import com.alibaba.dashscope.common.ListResult;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.InvalidateParameter;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.threads.AssistantThread;
import com.alibaba.dashscope.threads.ThreadParam;
import com.alibaba.dashscope.threads.Threads;
import com.alibaba.dashscope.threads.messages.Messages;
import com.alibaba.dashscope.threads.messages.TextMessageParam;
import com.alibaba.dashscope.threads.messages.ThreadMessage;
import com.alibaba.dashscope.threads.runs.Run;
import com.alibaba.dashscope.threads.runs.RunParam;
import com.alibaba.dashscope.threads.runs.Runs;
import com.alibaba.dashscope.tools.T2Image.Text2Image;
import com.alibaba.dashscope.tools.search.ToolQuarkSearch;

public class PaintingAssistant {
    private static boolean checkStatus(Object response, String operation) {
        if (response != null) {
            System.out.println(operation + " 成功。");
            return true;
        } else {
            System.out.println(operation + " 失败。");
            return false;
        }
    }

    public static void main(String[] args) {
        try {
            // 1. 创建绘画助手
            Assistants assistants = new Assistants();
            AssistantParam assistantParam = AssistantParam.builder()
                .model("qwen-max")
                .name("Art Maestro")
                .description("用于绘画和艺术知识的AI助手")
                .instructions("提供绘画技巧、艺术史和创意指导的信息。使用工具进行研究和生成图像。")
                .tools(Arrays.asList(ToolQuarkSearch.builder().build(),Text2Image.builder().build()))
                .build();
            
            Assistant paintingAssistant = assistants.create(assistantParam);
            if (!checkStatus(paintingAssistant, "助手创建")) {
                System.exit(1);
            }

            // 2. 创建一个新线程
            Threads threads = new Threads();
            AssistantThread thread = threads.create(ThreadParam.builder().build());
            if (!checkStatus(thread, "线程创建")) {
                System.exit(1);
            }

            // 3. 向线程发送消息
            Messages messages = new Messages();
            ThreadMessage message = messages.create(thread.getId(), 
                TextMessageParam.builder()
                    .role("user")
                    .content("请帮我画一幅布偶猫的画。")
                    .build());
            if (!checkStatus(message, "消息创建")) {
                System.exit(1);
            }

            // 4. 在线程上运行助手
            Runs runs = new Runs();
            RunParam runParam = RunParam.builder().assistantId(paintingAssistant.getId()).build();
            Run run = runs.create(thread.getId(), runParam);
            if (!checkStatus(run, "运行创建")) {
                System.exit(1);
            }

            // 5. 等待运行完成
            System.out.println("等待助手处理请求...");
            while (true) {
                if (run.getStatus().equals(Run.Status.COMPLETED) ||
                    run.getStatus().equals(Run.Status.FAILED) ||
                    run.getStatus().equals(Run.Status.CANCELLED) ||
                    run.getStatus().equals(Run.Status.REQUIRES_ACTION) ||
                    run.getStatus().equals(Run.Status.EXPIRED)) {
                    break;
                }
                Thread.sleep(1000);
                run = runs.retrieve(thread.getId(), run.getId());
            }

            if (checkStatus(run, "运行完成")) {
                System.out.println("运行完成，状态：" + run.getStatus());
            } else {
                System.out.println("运行未完成。");
                System.exit(1);
            }

            // 6. 检索并显示助手的响应
            ListResult<ThreadMessage> messagesList = messages.list(thread.getId(), GeneralListParam.builder().build());
            if (checkStatus(messagesList, "消息检索")) {
                if (!messagesList.getData().isEmpty()) {
                    // 显示最后一条消息（助手的响应）
                    ThreadMessage lastMessage = messagesList.getData().get(0);
                    System.out.println("\n助手的回应：");
                    System.out.println(lastMessage.getContent());
                } else {
                    System.out.println("在线程中未找到消息。");
                }
            } else {
                System.out.println("未能检索到助手的响应。");
            }

        } catch (ApiException | NoApiKeyException | InputRequiredException | InvalidateParameter | InterruptedException e) {
            e.printStackTrace();
        }
    }
}