工作流接口

curl --location "https://nlp.aliyuncs.com/v2/api/chat/send" \
  -H "Authorization: Bearer {YOUR_API_KEY}" \
  -H "X-AcA-DataInspection: enable" \
  -H "X-AcA-SSE: enable" \
  -H "x-fag-servicename: aca-flow-chat-send-sse" \
  -H "x-fag-appcode: aca" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {
        "role": "user",
        "content": "（心中暗自决定）这是我最后一次对你说这样的话了。"
      },
      {
        "role": "assistant",
        "content": "（惊讶地抬头）哦？是什么话呢？"
      },
      {
        "role": "user",
        "content": "今天我想去运动，告诉我运动的好处"
      }
    ],
    "botProfile": {
      "characterId": "aa7b98327d564d49a997ec67bfdaf68e"
    },
    "userProfile": {
      "userId": "123456",
      "basicInfo": "df"
    },
    "scenario": {
      "description": ""
    },
    "context": {
      "useChatHistory": true
    }
  }'

/**
 * API名称：工作流对话
 * 环境要求：Java 17及以上
 */
public class Example {
    private static final String URL = "https://nlp.aliyuncs.com/v2/api/chat/send";
    private static final String API_KEY = "Bearer {YOUR_API_KEY}";

    public static void main(String[] args) throws Exception {
        // 非流式调用
        nonStreamingCall();

        // 流式调用
//        streamingCall();
    }

    private static void nonStreamingCall() throws Exception {
        System.out.println("=== 非流式调用示例 ===");
        // characterId 填写服务助手id，不是角色id
        String jsonBody = """
        {
         "messages": [
             {
                 "role": "user",
                 "content": "（心中暗自决定）这是我最后一次对你说这样的话了。"
             },
             {
                 "role": "assistant",
                 "content": "（惊讶地抬头）哦？是什么话呢？"
             },
             {
                 "role": "user",
                 "content": "今天我想去运动，告诉我运动的好处"
             }
         ],
         "botProfile": {
             "characterId": "aa7b98327d564d49a997ec67bfdaf68e"
         },
         "userProfile": {
             "userId": "123456",
             "basicInfo": "df"
             },
         "scenario": {
              "description": ""
          },
          "context": {
              "useChatHistory": true
          }
        }
        """;

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        "X-AcA-DataInspection", "enable",
                        // 固定servicename
                        "x-fag-servicename", "aca-flow-chat-send",
                        "x-fag-appcode", "aca",
                        "Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        // 同步调用
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("响应数据: " + responseBody);
    }

    private static void streamingCall() {
        System.out.println("=== 流式调用示例 ===");
        // characterId 填写服务助手id，不是角色id
        String jsonBody = """
        {
         "messages": [
             {
                 "role": "user",
                 "content": "（心中暗自决定）这是我最后一次对你说这样的话了。"
             },
             {
                 "role": "assistant",
                 "content": "（惊讶地抬头）哦？是什么话呢？"
             },
             {
                 "role": "user",
                 "content": "今天我想去运动，告诉我运动的好处"
             }
         ],
         "botProfile": {
             "characterId": "aa7b98327d564d49a997ec67bfdaf68e"
         },
         "userProfile": {
             "userId": "123456",
             "basicInfo": "df"
             },
         "scenario": {
              "description": ""
          },
          "context": {
              "useChatHistory": true
          }
        }
        """;

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        "X-AcA-DataInspection", "enable",
                        "X-AcA-SSE", "enable",
                        // 固定servicename
                        "x-fag-servicename", "aca-flow-chat-send-sse",
                        "x-fag-appcode", "aca",
                        "Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        // 异步处理 SSE 流
        CompletableFuture<Void> future = client.sendAsync(request, HttpResponse.BodyHandlers.ofLines())
                .thenApply(HttpResponse::body)
                .thenAccept(stream -> {
                    stream.forEach(line -> {
                        System.out.println("流式响应数据: " + line);
                    });
                });

        // 保持主线程等待
        future.join();
    }
}

import requests

URL = "https://nlp.aliyuncs.com/v2/api/chat/send"

# API名称：工作流对话
# 环境要求：python3.10及以上
def call(messages, api_key, model_name):
    headers = {
        "Content-Type": "application/json",
        "x-fag-servicename": "aca-flow-chat-send",
        # 流式调用开启此配置
        # "x-fag-servicename": "aca-flow-chat-send-sse",
        "x-fag-appcode": "aca",
        "Authorization": f"Bearer {api_key}",
        "X-AcA-DataInspection": "enable"
    }

    payload = {
        "messages": messages,
        "model": model_name,
        # characterId 填写服务助手id，不是角色id
        "botProfile": {
            "characterId": "aa7b98327d564d49a997ec67bfdaf68e"
        },
        "userProfile": {
            "userId": "123456",
            "basicInfo": "df"
        },
        "scenario": {
            "description": ""
        },
        "context": {
            "useChatHistory": True
        }
    }

    response = requests.post(URL, json=payload, headers=headers)
    # 逐行打印原始响应内容
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # 检查响应状态，如有错误则抛出异常
    response.raise_for_status()
    return response


if __name__ == "__main__":
    messages = [
        {
            "role": "user",
            "content": "（心中暗自决定）这是我最后一次对你说这样的话了。"
        },
        {
            "role": "assistant",
            "content": "（惊讶地抬头）哦？是什么话呢？"
        },
        {
            "role": "user",
            "content": "今天我想去运动，告诉我运动的好处"
        }
    ]
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        response = call(messages, api_key, model_name)
    except requests.HTTPError as e:
        print(f"请求出错: {e}")

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

// API名称：工作流对话
// 环境要求：go 1.20及以上

const URL = "https://nlp.aliyuncs.com/v2/api/chat/send"

func call(messages []map[string]interface{}, apiKey string, modelName string) (*http.Response, error) {
    payload := map[string]interface{}{
        "messages": messages,
        "model":    modelName,
        "botProfile": map[string]interface{}{
            "characterId": "aa7b98327d564d49a997ec67bfdaf68e", // characterId 填写服务助手id，不是角色id
        },
        "userProfile": map[string]interface{}{
            "userId":    "123456",
            "basicInfo": "df",
        },
        "scenario": map[string]interface{}{
            "description": "",
        },
        "context": map[string]interface{}{
            "useChatHistory": true,
        },
    }

    payloadBytes, err := json.Marshal(payload)
    if err != nil {
        return nil, err
    }

    req, err := http.NewRequest("POST", URL, bytes.NewBuffer(payloadBytes))
    if err != nil {
        return nil, err
    }

    req.Header.Set("Content-Type", "application/json")
    // req.Header.Set("x-fag-servicename", "aca-flow-chat-send-sse") // 流式调用开启此配置
    req.Header.Set("x-fag-servicename", "aca-flow-chat-send")
    req.Header.Set("x-fag-appcode", "aca")
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("X-AcA-DataInspection", "enable")
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }

    // 逐行打印原始响应内容
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("请求出错，状态码：%d", resp.StatusCode)
    }

    return resp, nil
}

func main() {
    messages := []map[string]interface{}{
        {
            "role":    "user",
            "content": "（心中暗自决定）这是我最后一次对你说这样的话了。",
        },
        {
            "role":    "assistant",
            "content": "（惊讶地抬头）哦？是什么话呢？",
        },
        {
            "role":    "user",
            "content": "今天我想去运动，告诉我运动的好处",
        },
    }

    apiKey := "YOUR_API_KEY"
    modelName := "xingchen-plus-latest"

    _, err := call(messages, apiKey, modelName)
    if err != nil {
        fmt.Printf("请求出错: %v\n", err)
    }
}