Workflow API

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": "(Decides internally) This is the last time I will say this to you."
      },
      {
        "role": "assistant",
        "content": "(Looks up in surprise) Oh? What is it?"
      },
      {
        "role": "user",
        "content": "I want to exercise today. Tell me the benefits of exercising."
      }
    ],
    "botProfile": {
      "characterId": "aa7b98327d564d49a997ec67bfdaf68e"
    },
    "userProfile": {
      "userId": "123456",
      "basicInfo": "df"
    },
    "scenario": {
      "description": ""
    },
    "context": {
      "useChatHistory": true
    }
  }'

/**
 * API name: Workflow chat
 * Environment requirement: Java 17 or later
 */
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 {
        // Non-streaming call
        nonStreamingCall();

        // Streaming call
//        streamingCall();
    }

    private static void nonStreamingCall() throws Exception {
        System.out.println("=== Non-streaming call example ===");
        // Set characterId to the service assistant ID, not the role ID.
        String jsonBody = """
        {
         "messages": [
             {
                 "role": "user",
                 "content": "(Decides internally) This is the last time I will say this to you."
             },
             {
                 "role": "assistant",
                 "content": "(Looks up in surprise) Oh? What is it?"
             },
             {
                 "role": "user",
                 "content": "I want to exercise today. Tell me the benefits of exercising."
             }
         ],
         "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",
                        // Fixed servicename
                        "x-fag-servicename", "aca-flow-chat-send",
                        "x-fag-appcode", "aca",
                        "Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        // Synchronous call
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("Response data: " + responseBody);
    }

    private static void streamingCall() {
        System.out.println("=== Streaming call example ===");
        // Set characterId to the service assistant ID, not the role ID.
        String jsonBody = """
        {
         "messages": [
             {
                 "role": "user",
                 "content": "(Decides internally) This is the last time I will say this to you."
             },
             {
                 "role": "assistant",
                 "content": "(Looks up in surprise) Oh? What is it?"
             },
             {
                 "role": "user",
                 "content": "I want to exercise today. Tell me the benefits of exercising."
             }
         ],
         "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",
                        // Fixed servicename
                        "x-fag-servicename", "aca-flow-chat-send-sse",
                        "x-fag-appcode", "aca",
                        "Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        // Asynchronously process the SSE stream
        CompletableFuture<Void> future = client.sendAsync(request, HttpResponse.BodyHandlers.ofLines())
                .thenApply(HttpResponse::body)
                .thenAccept(stream -> {
                    stream.forEach(line -> {
                        System.out.println("Streaming response data: " + line);
                    });
                });

        // Keep the main thread waiting
        future.join();
    }
}

import requests

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

# API name: Workflow chat
# Environment requirement: Python 3.10 or later
def call(messages, api_key, model_name):
    headers = {
        "Content-Type": "application/json",
        "x-fag-servicename": "aca-flow-chat-send",
        # Enable this configuration for streaming calls
        # "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,
        # Set characterId to the service assistant ID, not the role ID.
        "botProfile": {
            "characterId": "aa7b98327d564d49a997ec67bfdaf68e"
        },
        "userProfile": {
            "userId": "123456",
            "basicInfo": "df"
        },
        "scenario": {
            "description": ""
        },
        "context": {
            "useChatHistory": True
        }
    }

    response = requests.post(URL, json=payload, headers=headers)
    # Print the raw response content line by line
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # Check the response status and throw an exception if an error occurs
    response.raise_for_status()
    return response


if __name__ == "__main__":
    messages = [
        {
            "role": "user",
            "content": "(Decides internally) This is the last time I will say this to you."
        },
        {
            "role": "assistant",
            "content": "(Looks up in surprise) Oh? What is it?"
        },
        {
            "role": "user",
            "content": "I want to exercise today. Tell me the benefits of exercising."
        }
    ]
    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"Request error: {e}")

package main

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

// API name: Workflow chat
// Environment requirement: Go 1.20 or later

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", // Set characterId to the service assistant ID, not the role 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") // Enable this configuration for streaming calls
    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
    }

    // Print the raw response content line by line
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("Request error, status code: %d", resp.StatusCode)
    }

    return resp, nil
}

func main() {
    messages := []map[string]interface{}{
        {
            "role":    "user",
            "content": "(Decides internally) This is the last time I will say this to you.",
        },
        {
            "role":    "assistant",
            "content": "(Looks up in surprise) Oh? What is it?",
        },
        {
            "role":    "user",
            "content": "I want to exercise today. Tell me the benefits of exercising.",
        },
    }

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

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