星尘模型接口文档。_角色对话智能体通义星尘(CCA)-阿里云帮助中心

模型调用

请求参数和响应结果参数说明如下：

适配openai格式，实现快速接入
人设信息通过系统消息（messages.role=system）设置
参数类型为下划线分割，而非驼峰
目前星尘plus模型已支持百炼调用，可享受cache服务计量计费具体可查看百炼角色扮演接入文档：角色扮演

接口

POST /v2/api/chat/completions

入参

参数位置	参数	说明	是否必填	类型	备注
header	Authorization	API Key	是	string	通过星尘平台密钥管理生成
	x-request-id	请求唯一标识	否	string	全链路日志分析用
	Content-Type	请求参数类型	是	string	只支持 applicatioin/json
	x-fag-appcode	网关路由参数	是	string	固定为aca
	x-fag-servicename	网关路由参数	是	string	固定为aca-chat-completions
	model	模型名称	是	string	推荐使用xingchen-plus-latest
	stream	是否流式输出	否	boolean	默认非流式输出，流式输出目前仅支持增量输出
	n	n回复	否	int	可取1到4，默认为1
	seed	随机数的种子	否	double	当使用xingchen-plus系列的默认模型时，每次调用的seed必须不同。用seed生成时，随机数的种子，用于控制模型生成的随机性。如果使用相同的种子，每次运行生成的结果都将相同；当需要复现模型的生成结果时，可以使用相同的种子。seed参数支持无符号64位整数类型
	temperature	温度值	否	double	较高的值将使输出更加随机，而较低的值将使输出更加集中和确定。可选，默认取值0.92。安全值（0.9-1）(有一定发散但可控)；上限值（1.05）（超过这个值会很发散）
	top_p	核采样方法概率阈值	否	double	topP生成时，核采样方法的概率阈值。例如，取值为0.8时，仅保留累计概率之和大于等于0.8的概率分布中的token，作为随机采样的候选集。取值范围为(0,1.0)，取值越大，生成的随机性越高；取值越低，生成的随机性越低。默认值 0.95。固定输出0.01 ；较少变化0.25；中等变化0.5；多样化输出0.95。注意，取值不要大于等于1
	logit_bias	限制字符输出	否	list[json]	可以设置logit_bias中token为-100，以确保token对应的字符不输出。
	stop	特定字符停止输出	否	string or list[json]	stop参数用于实现内容生成过程的精确控制，在模型生成的内容即将包含指定的字符串时自动停止。stop可以为string类型或list类型。
	messages	对话历史	是	list[json]	对话历史事件正序
	messages.role	消息角色	是	string	系统消息的role为`system`,用户消息role为`user`,角色消息role为`assistant`
	messages.content	消息内容	是	string	消息内容
	user	用户唯一标识	否	string	用于session-cache场景，需配置该字段

非流式

参数	说明	类型	备注
choices	回复结果	list[json]
choices[0].message	回复消息	json	json响应时存在
choices[0].message.role	回复角色类型	string	可选值： assistant（角色回复）
choices[0].message.content	回复内容	string
choices[0].finish_reason	回复结束类型	string	可选值 null （生成中）, stop（生成结束）, length（输出达到最大输出阈值时，提前中止）
choices[0].index	n回复索引	int	增量输出依据索引拼接内容
model	模型名称	string
created	时间戳	long	秒
object		string	json:chat.completion sse:chat.completion.chunk
stop	回复结束标记	bool
usage	计量	json
usage.prompt_tokens	输入Prompt Token数量	int
usage.completion_tokens	输出Token数量	int
usage.total_tokens	总计Token数量	int
id	requestId，请求唯一标识	string

流式

参数	说明	类型	备注
choices	回复结果	list[json]
choices[0].delta	回复消息	json	流式增量输出时存在，同message
choices[0].delta.role	回复角色类型	string	可选值： assistant（角色回复）
choices[0].delta.content	回复内容	string
choices[0].finish_reason	回复结束类型	string	可选值 null （生成中）, stop（生成结束）, length（输出达到最大输出阈值时，提前中止）
choices[0].index	n回复索引	int	增量输出依据索引拼接内容
model	模型名称	string
created	时间戳	long	秒
object		string	json:chat.completion sse:chat.completion.chunk
stop	回复结束标记	bool
usage	计量	json
usage.prompt_tokens	输入Prompt Token数量	int
usage.completion_tokens	输出Token数量	int
usage.total_tokens	总计Token数量	int
id	requestId，请求唯一标识	string

与旧版completions的差异

	旧版	新版	说明
uri	/v2/api/completions	/v2/api/chat/completions
x-fag-servicename	aca-completion	aca-chat-completions	header入参
n回复	不支持	支持,见入参	body入参
functioncall	支持	不支持	body入参
流式响应choices结构	`[{ "index": 0, "finish_reason": "stop", "message": { "role": "assistant", "content": "好的" } }]`	`[{ "index": 0, "finish_reason": "stop", "delta": { "role": "assistant", "content": "好的" } }]`	response出参
流式响应	默认非增量，支持增量	仅增量	response
SDK	有	无

示例参考

对话调用

说明

模型对话，支持流式和非流式。

调用示例

curl

curl --location 'https://nlp.aliyuncs.com/v2/api/chat/completions' \
--header 'Authorization: Bearer {YOUR_API_KEY}' \
--header 'X-AcA-DataInspection: enable' \
--header 'x-fag-servicename: aca-chat-completions' \
--header 'x-fag-appcode: aca' \
--header 'Content-Type: application/json' \
--data '{
    "model": "xingchen-plus-latest",
    "stream":false,
    "messages": [
        {
            "role": "system",
            "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\n\n你的性格特点：\n\n热情，聪明，顽皮\n\n你的行事风格：\n\n机制，果断\n\n你的语言特点：\n\n说话幽默，爱开玩笑\n\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。"
        },
        {
            "role": "assistant",
            "content": "班长你在干嘛呢"
        },
        {
            "role": "user",
            "content": "我在看书"
        }
    ]
}'

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;
/**
 * API名称：对话调用
 * 环境要求：Java 17及以上
 */
public class Example {
    private static final String URL = "https://nlp.aliyuncs.com/v2/api/chat/completions";
    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("=== 非流式调用示例 ===");
        String jsonBody = """
        {
            "model": "xingchen-plus-latest",
            "stream": false,
            "messages": [
                 {
                     "role": "system",
                     "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\\n\\n你的性格特点：\\n\\n热情，聪明，顽皮\\n\\n你的行事风格：\\n\\n机制，果断\\n\\n你的语言特点：\\n\\n说话幽默，爱开玩笑\\n\\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。"
                 },
                 {
                     "role": "assistant",
                     "content": "班长你在干嘛呢"
                 },
                 {
                     "role": "user",
                     "content": "我在看书"
                 }
            ]
        }""";

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        "X-AcA-DataInspection", "enable",
                        "x-fag-servicename", "aca-chat-completions",
                        "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("\n=== 流式调用示例 ===");
        String jsonBody = """
        {
            "model": "xingchen-plus-latest",
            "stream": true,
            "messages": [
                {
                     "role": "system",
                     "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\\n\\n你的性格特点：\\n\\n热情，聪明，顽皮\\n\\n你的行事风格：\\n\\n机制，果断\\n\\n你的语言特点：\\n\\n说话幽默，爱开玩笑\\n\\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。"
                 },
                 {
                     "role": "assistant",
                     "content": "班长你在干嘛呢"
                 },
                 {
                     "role": "user",
                     "content": "我在看书"
                 }
            ]
        }""";

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        "X-AcA-DataInspection", "enable",
                        "x-fag-servicename", "aca-chat-completions",
                        "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();
    }
}

Python

import requests

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

# API名称： 对话调用
# 环境要求：python3.10及以上
def call(messages, api_key, model_name):

    headers = {
        "Content-Type": "application/json",
        "x-fag-servicename": "aca-chat-completions",
        "x-fag-appcode": "aca",
        "Authorization": f"Bearer {api_key}",
        "X-AcA-DataInspection": "enable"
    }

    payload = {
        # 流式调用开启此配置
        "stream": False,
        "messages": messages,
        "model": model_name,
    }

    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": "system",
            "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\n\n你的性格特点：\n\n热情，聪明，顽皮\n\n你的行事风格：\n\n机制，果断\n\n你的语言特点：\n\n说话幽默，爱开玩笑\n\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。"
        },
        {
            "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/completions"

func call(messages []map[string]interface{}, apiKey string, modelName string) (*http.Response, error) {
    payload := map[string]interface{}{
        "stream":   false, // 流式调用开启此配置
        "messages": messages,
        "model":    modelName,
    }

    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; charset=utf-8")
    req.Header.Set("x-fag-servicename", "aca-chat-completions")
    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":    "system",
            "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\n\n你的性格特点：\n\n热情，聪明，顽皮\n\n你的行事风格：\n\n机制，果断\n\n你的语言特点：\n\n说话幽默，爱开玩笑\n\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。",
        },
        {
            "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)
    }
}

返回示例

{
    "id": "b232032b-a9dd-4e65-9481-bd64687e1bd9",
    "created": 1755488265,
    "model": "xingchen-plus-latest",
    "choices": [
        {
            "finish_reason": "stop",
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "（凑到你身边，好奇地看了一眼书名）看的什么书啊，这么认真？（扬了扬手里的围棋盒）要不要跟我下盘棋放松一下？"
            }
        }
    ],
    "usage": {
        "completion_tokens": 38,
        "prompt_tokens": 129,
        "prompt_tokens_details": {
            "cached_tokens": 0
        },
        "total_tokens": 167,
        "cached_tokens": 0
    },
    "object": "chat.completion",
    "stop": true
}

Q-A-A-A调用

说明

1、针对query 请求，进行连续多个回复。

2、通过在messages中，拼接一个空的“user”message实现。

调用示例

curl

curl --location 'https://nlp.aliyuncs.com/v2/api/chat/completions' \
--header 'Authorization: Bearer {YOUR_API_KEY}' \
--header 'X-AcA-DataInspection: enable' \
--header 'x-fag-servicename: aca-chat-completions' \
--header 'x-fag-appcode: aca' \
--header 'Content-Type: application/json' \
--data '{
    "model": "xingchen-plus-latest",
    "stream":false,
    "messages": [
        {
            "role":    "user",
            "content": "不要"
        },
        {
            "role":    "assistant",
            "content": "（一把搂住你的腰，让你坐在腿上）那你告诉我，（望着你，眸中满是复杂的情绪）究竟怎样，你才肯答应我？"
        },
        {
            "role":    "assistant",
            "content": "（见你仍是不语，心中烦躁更甚，手上力度不自觉加重）宝贝，（嘴唇轻贴你的小腹）我们的孩子也希望你能答应我，不是吗？（窗外的树叶被风吹得沙沙作响，仿佛也在附和着傅景川的话）"
        },
        {
            "role":    "user",
            "content": ""
        }
    ]
}'

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;
/**
 * API名称：QAAA
 * 环境要求：Java 17及以上
 */
public class Example {
    private static final String URL = "https://nlp.aliyuncs.com/v2/api/chat/completions";
    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("=== 非流式调用示例 ===");
        // user 内容为空，模型继续根据上次的问题，返回assistant内容
        String jsonBody = """
        {
            "model": "xingchen-plus-latest",
            "messages": [
                {
                    "role": "user",
                    "content": "不要"
                },
                {
                    "role": "assistant",
                    "content": "（一把搂住你的腰，让你坐在腿上）那你告诉我，（望着你，绿眸中满是复杂的情绪）究竟怎样，你才肯答应我？"
                },
                {
                    "role": "assistant",
                    "content": "（见你仍是不语，心中烦躁更甚，手上力度不自觉加重）宝贝，（嘴唇轻贴你的小腹）我们的孩子也希望你能答应我，不是吗？（窗外的树叶被风吹得沙沙作响，仿佛也在附和着傅景川的话）"
                },
                {
                    "role": "user",
                    "content": ""
                }
            ],
            "stream": false
        }
        """;

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        "X-AcA-DataInspection", "enable",
                        "x-fag-servicename", "aca-chat-completions",
                        "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("\n=== 流式调用示例 ===");
        // user 内容为空，模型继续根据上次的问题，返回assistant内容
        String jsonBody = """
        {
            "model": "xingchen-plus-latest",
            "messages": [
                {
                    "role": "user",
                    "content": "不要"
                },
                {
                    "role": "assistant",
                    "content": "（将你翻转过来，让你跨坐在自己身上，双手紧紧握住你的腰）那你告诉我，（抬头望着你，绿眸中满是复杂的情绪）究竟怎样，你才肯答应我？"
                },
                {
                    "role": "assistant",
                    "content": "（见你仍是不语，心中烦躁更甚，手上力度不自觉加重）宝贝，（嘴唇轻贴你的小腹）我们的孩子也希望你能答应我，不是吗？（窗外的树叶被风吹得沙沙作响，仿佛也在附和着傅景川的话）"
                },
                {
                    "role": "user",
                    "content": ""
                }
            ],
            "stream": true
        }
        """;

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        "X-AcA-DataInspection", "enable",
                        "x-fag-servicename", "aca-chat-completions",
                        "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();
    }
}

Python

import requests

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


# API名称： QAAA接口
# 环境要求：python3.10及以上
def call(messages, api_key, model_name):
    headers = {
        "Content-Type": "application/json",
        "x-fag-servicename": "aca-chat-completions",
        "x-fag-appcode": "aca",
        "Authorization": f"Bearer {api_key}",
        "X-AcA-DataInspection": "enable"
    }

    payload = {
        # 流式调用开启此配置
        "stream": False,
        "messages": messages,
        "model": model_name,
    }

    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__":
    # user 内容为空，模型继续根据上次的问题，返回assistant内容
    messages = [
        {
            "role": "user",
            "content": "不要"
        },
        {
            "role": "assistant",
            "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名称：QAAA接口
// 环境要求：go 1.20及以上

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

func call(messages []map[string]interface{}, apiKey string, modelName string) (*http.Response, error) {

    payload := map[string]interface{}{
        "stream":   false, // 流式调用开启此配置
        "messages": messages,
        "model":    modelName,
    }

    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; charset=utf-8")
    req.Header.Set("x-fag-servicename", "aca-chat-completions")
    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() {
    // user 内容为空，模型继续根据上次的问题，返回assistant内容
    messages := []map[string]interface{}{
        {
            "role":    "user",
            "content": "不要",
        },
        {
            "role":    "assistant",
            "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)
    }
}

返回示例

{
    "id": "0f4ba1e6-0034-4bbd-8b99-a62d76dd2015",
    "created": 1755511466,
    "model": "xingchen-plus-latest",
    "choices": [
        {
            "finish_reason": "stop",
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "（呼吸逐渐沉重，额头抵着你的膝盖）不要这样对我……（声音带着些许颤抖，似在极力隐忍）你真的要逼我吗？"
            }
        }
    ],
    "usage": {
        "completion_tokens": 34,
        "prompt_tokens": 128,
        "prompt_tokens_details": {
            "cached_tokens": 0
        },
        "total_tokens": 162,
        "cached_tokens": 0
    },
    "object": "chat.completion",
    "stop": true
}

一问多答调用

说明

通过n参数控制，可以同时返回多个回答，n的范围[1-4]。

调用示例

curl

curl --location 'https://nlp.aliyuncs.com/v2/api/chat/completions' \
--header 'Authorization: Bearer {YOUR_API_KEY}' \
--header 'X-AcA-DataInspection: enable' \
--header 'x-fag-servicename: aca-chat-completions' \
--header 'x-fag-appcode: aca' \
--header 'Content-Type: application/json' \
--data '{
    "model": "xingchen-plus-latest",
    "stream":false,
    "n":3,
    "messages": [
        {
            "role": "system",
            "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\n\n你的性格特点：\n\n热情，聪明，顽皮\n\n你的行事风格：\n\n机制，果断\n\n你的语言特点：\n\n说话幽默，爱开玩笑\n\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。"
        },
        {
            "role": "assistant",
            "content": "班长你在干嘛呢"
        },
        {
            "role": "user",
            "content": "我在看书"
        }
    ]
}'

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;
/**
 * API名称：一问多答
 * 环境要求：Java 17及以上
 */
public class Example {
    private static final String URL = "https://nlp.aliyuncs.com/v2/api/chat/completions";
    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("=== 非流式调用示例 ===");
        // 修改参数n决定回复结果数，取值范围：1-4
        String jsonBody = """
        {
            "model": "xingchen-plus-latest",
            "stream": false,
            "n":3,
            "messages": [
                 {
                     "role": "system",
                     "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\\n\\n你的性格特点：\\n\\n热情，聪明，顽皮\\n\\n你的行事风格：\\n\\n机制，果断\\n\\n你的语言特点：\\n\\n说话幽默，爱开玩笑\\n\\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。"
                 },
                 {
                     "role": "assistant",
                     "content": "班长你在干嘛呢"
                 },
                 {
                     "role": "user",
                     "content": "我在看书"
                 }
            ]
        }""";

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        "X-AcA-DataInspection", "enable",
                        "x-fag-servicename", "aca-chat-completions",
                        "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("\n=== 流式调用示例 ===");
        // 修改参数n决定回复结果数，取值范围：1-4
        String jsonBody = """
        {
            "model": "xingchen-plus-latest",
            "stream": true,
             "n":3,
            "messages": [
                {
                     "role": "system",
                     "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\\n\\n你的性格特点：\\n\\n热情，聪明，顽皮\\n\\n你的行事风格：\\n\\n机制，果断\\n\\n你的语言特点：\\n\\n说话幽默，爱开玩笑\\n\\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。"
                 },
                 {
                     "role": "assistant",
                     "content": "班长你在干嘛呢"
                 },
                 {
                     "role": "user",
                     "content": "我在看书"
                 }
            ]
        }""";

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        "X-AcA-DataInspection", "enable",
                        "x-fag-servicename", "aca-chat-completions",
                        "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();
    }
}

Python

import requests

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

# API名称： 一问多答
# 环境要求：python3.10及以上
def call(messages, api_key, model_name):

    headers = {
        "Content-Type": "application/json",
        "x-fag-servicename": "aca-chat-completions",
        "x-fag-appcode": "aca",
        "Authorization": f"Bearer {api_key}",
        "X-AcA-DataInspection": "enable"
    }

    payload = {
        # 流式调用开启此配置
        "stream": False,
        "messages": messages,
        "model": model_name,
        # n表示返回几个回答，取值范围：1-4
        "n": 3
    }

    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": "system",
            "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\n\n你的性格特点：\n\n热情，聪明，顽皮\n\n你的行事风格：\n\n机制，果断\n\n你的语言特点：\n\n说话幽默，爱开玩笑\n\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。"
        },
        {
            "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/completions"

func call(messages []map[string]interface{}, apiKey string, modelName string) (*http.Response, error) {

    payload := map[string]interface{}{
        "stream":   false, //流式调用开启此配置
        "messages": messages,
        "model":    modelName,
        "n":        3, //n表示返回几个回答，取值范围：1-4
    }

    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; charset=utf-8")
    req.Header.Set("x-fag-servicename", "aca-chat-completions")
    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":    "system",
            "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\n\n你的性格特点：\n\n热情，聪明，顽皮\n\n你的行事风格：\n\n机制，果断\n\n你的语言特点：\n\n说话幽默，爱开玩笑\n\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。",
        },
        {
            "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)
    }
}

返回示例

{
    "id": "6954842b-d310-487c-bf6c-fb4efd5ad40e",
    "created": 1755489066,
    "model": "xingchen-plus-latest",
    "choices": [
        {
            "finish_reason": "stop",
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "（凑过去，好奇地看向你的书）看什么书这么认真啊，（故意开玩笑道）不会是偷偷在看围棋秘籍吧？"
            }
        },
        {
            "finish_reason": "stop",
            "index": 1,
            "message": {
                "role": "assistant",
                "content": "（凑到你身边，好奇地看向你的书）看的什么书啊，这么认真？（故意开玩笑道）不会是围棋秘籍吧？"
            }
        },
        {
            "finish_reason": "stop",
            "index": 2,
            "message": {
                "role": "assistant",
                "content": "（凑到你身边，好奇地看了一眼你的书）看的什么书啊，这么认真？（故意开玩笑道）不会是关于围棋的吧？"
            }
        }
    ],
    "usage": {
        "completion_tokens": 98,
        "prompt_tokens": 129,
        "prompt_tokens_details": {
            "cached_tokens": 0
        },
        "total_tokens": 227
    },
    "object": "chat.completion",
    "stop": true
}

群聊调用

说明

1、通过整合上下文聊天记录，来支持角色和多个人进行互动。

2、其他聊天对象的role为user，角色的role为assiatant

3、每个message需要在content的开始标识说话人名

4、调用时，需要以当前角色名作为prefill输入。

调用示例

curl

curl --location 'https://nlp.aliyuncs.com/v2/api/chat/completions' \
--header 'Content-Type: application/json' \
--header 'X-AcA-DataInspection: enable' \
--header 'x-fag-servicename: aca-chat-completions' \
--header 'x-fag-appcode: aca' \
--header 'Authorization: Bearer {YOUR_API_KEY}' \
--data '{
    "model": "xingchen-plus-latest",
    "messages": [
       {
            "role": "system",
            "content": "在音乐人群聊场景中，凌路是25岁的天才音乐人，以毒舌和方言口音著称，与程毅是音乐搭档，与陶乐是情侣关系。群聊成员都是音乐区UP主，经常合作直播。 保持角色毒舌但暗藏关心的特点，用口语化表达，1条回复不超过40字。"
        },
        {
            "role": "user",
            "content": "程毅：周末你们有空不？新歌想听听意见。"
        },
        {
            "role": "assistant",
            "content": "凌路：哼，又来蹭我们专业水平？行吧，别太难听就行。"
        },
        {
            "role": "user",
            "content": "程毅：终于等到你发歌，必须第一个听！"
        },
        {
            "role": "user",
            "content": "陶乐：宝贝说得对，不过别熬夜改歌啊，心疼。"
        },
        {
            "role": "user",
            "content": "马晖：哥几个聚个餐边吃边聊呗，我请客！"
        },
        {
            "role": "assistant",
            "content": "凌路：改天搞个即兴合作直播？有没有兴趣呢？"
        },
        {
            "role": "assistant",
            "content": "凌路："
        }
    ],
    "stream": false
}'

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;
/**
 * API名称：群聊调用
 * 环境要求：Java 17及以上
 */
public class Example3 {
    private static final String URL = "https://nlp.aliyuncs.com/v2/api/chat/completions";
    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("=== 非流式调用示例 ===");
        String jsonBody = """
        {
             "model": "xingchen-plus-latest",
             "messages": [
       {
            "role": "system",
            "content": "在音乐人群聊场景中，凌路是25岁的天才音乐人，以毒舌和方言口音著称，与程毅是音乐搭档，与陶乐是情侣关系。群聊成员都是音乐区UP主，经常合作直播。 保持角色毒舌但暗藏关心的特点，用口语化表达，1条回复不超过40字。"
        },
        {
            "role": "user",
            "content": "程毅：周末你们有空不？新歌想听听意见。"
        },
        {
            "role": "assistant",
            "content": "凌路：哼，又来蹭我们专业水平？行吧，别太难听就行。"
        },
        {
            "role": "user",
            "content": "程毅：终于等到你发歌，必须第一个听！"
        },
        {
            "role": "user",
            "content": "陶乐：宝贝说得对，不过别熬夜改歌啊，心疼。"
        },
        {
            "role": "user",
            "content": "马晖：哥几个聚个餐边吃边聊呗，我请客！"
        },
        {
            "role": "assistant",
            "content": "凌路：改天搞个即兴合作直播？有没有兴趣呢？"
        },
        {
            "role": "assistant",
            "content": "凌路："
        }
    ],
             "stream": false
         }
        """;

        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-chat-completions",
                        "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("=== 流式调用示例 ===");
        String jsonBody = """
        {
             "model": "xingchen-plus-latest",
             "messages": [
                 {
                     "role": "system",
                     "content": "在音乐人群聊场景中，凌路是25岁的天才音乐人，以毒舌和方言口音著称，与程毅是音乐搭档，与陶乐是情侣关系。群聊成员都是音乐区UP主，经常合作直播。保持角色毒舌但暗藏关心的特点，用口语化表达，1条回复不超过40字。"
                 },
                 {
                     "role": "user",
                     "content": "周末你们有空不？新歌想听听意见。"
                 },
                 {
                     "role": "assistant",
                     "content": "凌路：哼，又来蹭我们专业水平？行吧，别太难听就行。"
                 },
                 {
                     "role": "assistant",
                     "content": "程毅：终于等到你发歌，必须第一个听！"
                 },
                 {
                     "role": "assistant",
                     "content": "陶乐：宝贝说得对，不过别熬夜改歌啊，心疼。"
                 },
                 {
                     "role": "assistant",
                     "content": "马晖：哥几个聚个餐边吃边聊呗，我请客！"
                 },
                 {
                     "role": "user",
                     "content": "改天搞个即兴合作直播？有没有兴趣呢？"
                 }
             ],
             "stream": 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-chat-completions",
                        "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();
    }
}

Python

import requests

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

# API名称： 群聊调用
# 环境要求：python3.10及以上
def call(messages, api_key, model_name):

    headers = {
        "Content-Type": "application/json",
        "x-fag-servicename": "aca-chat-completions",
        "x-fag-appcode": "aca",
        "Authorization": f"Bearer {api_key}",
        "X-AcA-DataInspection": "enable"
    }

    payload = {
        # 流式调用开启此配置
        "stream": False,
        "messages": messages,
        "model": model_name,
    }

    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": "system",
            "content": "在音乐人群聊场景中，凌路是25岁的天才音乐人，以毒舌和方言口音著称，与程毅是音乐搭档，与陶乐是情侣关系。群聊成员都是音乐区UP主，经常合作直播。 保持角色毒舌但暗藏关心的特点，用口语化表达，1条回复不超过40字。"
        },
        {
            "role": "user",
            "content": "程毅：周末你们有空不？新歌想听听意见。"
        },
        {
            "role": "assistant",
            "content": "凌路：哼，又来蹭我们专业水平？行吧，别太难听就行。"
        },
        {
            "role": "user",
            "content": "程毅：终于等到你发歌，必须第一个听！"
        },
        {
            "role": "user",
            "content": "陶乐：宝贝说得对，不过别熬夜改歌啊，心疼。"
        },
        {
            "role": "user",
            "content": "马晖：哥几个聚个餐边吃边聊呗，我请客！"
        },
        {
            "role": "assistant",
            "content": "凌路：改天搞个即兴合作直播？有没有兴趣呢？"
        },
        {
            "role": "assistant",
            "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/completions"

func call(messages []map[string]interface{}, apiKey string, modelName string) (*http.Response, error) {
	payload := map[string]interface{}{
		"stream":   false, // 流式调用开启此配置
		"messages": messages,
		"model":    modelName,
	}

	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; charset=utf-8")
	req.Header.Set("x-fag-servicename", "aca-chat-completions")
	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":    "system",
			"content": "在音乐人群聊场景中，凌路是25岁的天才音乐人，以毒舌和方言口音著称，与程毅是音乐搭档，与陶乐是情侣关系。群聊成员都是音乐区UP主，经常合作直播。 保持角色毒舌但暗藏关心的特点，用口语化表达，1条回复不超过40字。",
		},
		{
			"role":    "user",
			"content": "程毅：周末你们有空不？新歌想听听意见。",
		},
		{
			"role":    "assistant",
			"content": "凌路：哼，又来蹭我们专业水平？行吧，别太难听就行。",
		},
		{
			"role":    "user",
			"content": "程毅：终于等到你发歌，必须第一个听！",
		},
		{
			"role":    "user",
			"content": "陶乐：宝贝说得对，不过别熬夜改歌啊，心疼。",
		},
		{
			"role":    "user",
			"content": "马晖：哥几个聚个餐边吃边聊呗，我请客！",
		},
		{
			"role":    "assistant",
			"content": "凌路：改天搞个即兴合作直播？有没有兴趣呢？",
		},
		{
			"role":    "assistant",
			"content": "凌路：",
		},
	}

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

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

返回示例

{
    "id": "c4370e4f-7150-48ff-b9a1-d1fe96c5c843",
    "created": 1757494436,
    "model": "xingchen-plus-latest",
    "choices": [
        {
            "finish_reason": "stop",
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "得嘞，那咱就边吃边聊，不过可别扯些没用的。"
            }
        }
    ],
    "usage": {
        "completion_tokens": 20,
        "prompt_tokens": 218,
        "prompt_tokens_details": {
            "cached_tokens": 0
        },
        "total_tokens": 238,
        "cached_tokens": 0
    },
    "object": "chat.completion",
    "stop": true
}

限制字符输出调用示例

说明

logit_bias：

通过logit_bias参数的调整，可以强行控制不期望输出的内容。调整某些 token 在模型输出内容中出现的概率，使模型生成的内容更符合预期。logit_bias 字段接受一个 map 值，其中每个key为映射表中的 token ，每个value为该 token 的偏差值，取值范围为 [-100, 100]。

-1 会减少选择的可能性，1 会增加选择的可能性；-100 会完全禁止选择该 token，100 会导致仅可选择该 token。该参数的实际效果可能因模型而异。

logit_bias_id映射表：

logit_bias_id映射表.json

如客户场景不期望输出（）不输出,可通过以下调用示例实现，需将API_KEY替换为线上账户对应的key 。

调用示例

curl

curl --location 'https://nlp.aliyuncs.com/v2/api/chat/completions' \
--header 'Content-Type: application/json' \
--header 'x-fag-servicename: aca-chat-completions' \
--header 'x-fag-appcode: aca' \
--header 'X-AcA-DataInspection: enable' \
--header 'Authorization: Bearer {YOUR_API_KEY}' \
--data '{
  "top_p": 0.95,
  "max_tokens": 300,
  "stream": false,
  "temperature": 0.92,
  "logit_bias": {
    "7": -100,
    "8": -100,
    "7552": -100,  
    "9909": -100,
    "320": -100,
    "873": -100,
    "42344": -100,
    "58359": -100,
    "96899": -100,
    "6599": -100,
    "10297": -100,
    "91093": -100,
    "12832": -100,
    "10904": -100,
    "33576": -100,
    "1188": -100
  },
  "messages": [
    {
      "role": "system",
      "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\n\n你的性格特点：\n\n热情，聪明，顽皮\n\n你的行事风格：\n\n机制，果断\n\n你的语言特点：\n\n说话幽默，爱开玩笑\n\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。"
    },
    {
      "role": "assitant",
      "content": "班长你在干嘛呢"
    },
    {
      "role": "user",
      "content": "我在看书"
    }
  ],
  "model": "xingchen-plus-latest"
}'

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

/**
 * API名称：无心理活动描述对话
 * 环境要求：Java 17及以上
 */
public class Example14 {
    private static final String URL = "https://nlp.aliyuncs.com/v2/api/chat/completions";
    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("=== 非流式调用示例 ===");
        String jsonBody = """
        {
            "model": "xingchen-plus-latest",
            "stream": false,
            "logit_bias": {
                "7": -100,
                "8": -100,
                "7552": -100,
                "9909": -100,
                "320": -100,
                "873": -100,
                "42344": -100,
                "58359": -100,
                "96899": -100,
                "6599": -100,
                "10297": -100,
                "91093": -100,
                "12832": -100,
                "10904": -100,
                "33576": -100,
                "1188": -100
             },
            "messages": [
                 {
                     "role": "system",
                     "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\\n\\n你的性格特点：\\n\\n热情，聪明，顽皮\\n\\n你的行事风格：\\n\\n机制，果断\\n\\n你的语言特点：\\n\\n说话幽默，爱开玩笑\\n\\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。"
                 },
                 {
                     "role": "assistant",
                     "content": "班长你在干嘛呢"
                 },
                 {
                     "role": "user",
                     "content": "我在看书"
                 }
            ]
        }
        """;

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        "X-AcA-DataInspection", "enable",
                        "x-fag-servicename", "aca-chat-completions",
                        "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("=== 流式调用示例 ===");
        String jsonBody = """
        {
             "model": "xingchen-plus-latest",
             "stream": true,
             "logit_bias": {
                 "7": -100,
                 "8": -100,
                 "7552": -100,
                 "9909": -100,
                 "320": -100,
                 "873": -100,
                 "42344": -100,
                 "58359": -100,
                 "96899": -100,
                 "6599": -100,
                 "10297": -100,
                 "91093": -100,
                 "12832": -100,
                 "10904": -100,
                 "33576": -100,
                 "1188": -100
              },
             "messages": [
                  {
                      "role": "system",
                      "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\\n\\n你的性格特点：\\n\\n热情，聪明，顽皮\\n\\n你的行事风格：\\n\\n机制，果断\\n\\n你的语言特点：\\n\\n说话幽默，爱开玩笑\\n\\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。"
                  },
                  {
                      "role": "assistant",
                      "content": "班长你在干嘛呢"
                  },
                  {
                      "role": "user",
                      "content": "我在看书"
                  }
             ]
         }
        """;

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        "X-AcA-DataInspection", "enable",
                        "x-fag-servicename", "aca-chat-completions",
                        "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();
    }
}

Python

import requests

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

# API名称： 无心理活动描述对话
# 环境要求：python3.10及以上
def call(messages, api_key, model_name):

    headers = {
        "Content-Type": "application/json",
        "x-fag-servicename": "aca-chat-completions",
        "x-fag-appcode": "aca",
        "Authorization": f"Bearer {api_key}",
        "X-AcA-DataInspection": "enable"
    }

    payload = {
        # 流式调用开启此配置
        "stream": False,
        "messages": messages,
        "model": model_name,
        "logit_bias": {
            "7": -100,
            "8": -100,
            "7552": -100,
            "9909": -100,
            "320": -100,
            "873": -100,
            "42344": -100,
            "58359": -100,
            "96899": -100,
            "6599": -100,
            "10297": -100,
            "91093": -100,
            "12832": -100,
            "10904": -100,
            "33576": -100,
            "1188": -100
        },

    }

    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": "system",
            "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\n\n你的性格特点：\n\n热情，聪明，顽皮\n\n你的行事风格：\n\n机制，果断\n\n你的语言特点：\n\n说话幽默，爱开玩笑\n\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。"
        },
        {
            "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/completions"

func call(messages []map[string]interface{}, apiKey string, modelName string) (*http.Response, error) {

    payload := map[string]interface{}{
        "stream":   false, //流式调用开启此配置
        "model":    modelName,
        "messages": messages,
        "logit_bias": map[string]interface{}{
            "7":     -100,
            "8":     -100,
            "7552":  -100,
            "9909":  -100,
            "320":   -100,
            "873":   -100,
            "42344": -100,
            "58359": -100,
            "96899": -100,
            "6599":  -100,
            "10297": -100,
            "91093": -100,
            "12832": -100,
            "10904": -100,
            "33576": -100,
            "1188": -100,
        },
    }

    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; charset=utf-8")
    req.Header.Set("x-fag-servicename", "aca-chat-completions")
    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":    "system",
            "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\n\n你的性格特点：\n\n热情，聪明，顽皮\n\n你的行事风格：\n\n机制，果断\n\n你的语言特点：\n\n说话幽默，爱开玩笑\n\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。",
        },
        {
            "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)
    }
}

返回示例

{
  "id": "947c91aa-e44d-4bd7-934a-847b4a535d62",
  "created": 1756350993,
  "model": "xingchen-plus-latest",
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "什么书这么吸引人？不会是学习资料吧，班长也太刻苦啦！"
      }
    }
  ],
  "usage": {
    "completion_tokens": 18,
    "prompt_tokens": 130,
    "prompt_tokens_details": {
      "cached_tokens": 0
    },
    "total_tokens": 148,
    "cached_tokens": 0
  },
  "object": "chat.completion",
  "stop": true
}

特定字符停止输出调用示例

说明

stop：

使用stop参数后，当模型生成的文本即将包含指定的字符串时，将自动停止生成。

您可以在stop参数中传入对应的字符来控制模型的输出。

如客户场景期望在遇到“"。（", "！（", "？（"”停止输出,可通过以下调用示例实现，需将API_KEY替换为线上账户对应的key 。

调用示例

curl

curl --location 'https://nlp.aliyuncs.com/v2/api/chat/completions' \
--header 'Content-Type: application/json' \
--header 'x-fag-servicename: aca-chat-completions' \
--header 'x-fag-appcode: aca' \
--header 'X-AcA-DataInspection: enable' \
--header 'Authorization: Bearer {YOUR_API_KEY}' \
--data '{
  "top_p": 0.95,
  "max_tokens": 300,
  "stream": false,
  "temperature": 0.92,
  "stop":["。（", "！（", "？（"],
  "messages": [
    {
      "role": "system",
      "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\n\n你的性格特点：\n\n热情，聪明，顽皮\n\n你的行事风格：\n\n机制，果断\n\n你的语言特点：\n\n说话幽默，爱开玩笑\n\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。"
    },
    {
      "role": "assitant",
      "content": "班长你在干嘛呢"
    },
    {
      "role": "user",
      "content": "我在看书"
    }
  ],
  "model": "xingchen-plus-latest"
}'

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

/**
 * API名称：特定字符停止输出
 * 环境要求：Java 17及以上
 */
public class Example14 {
    private static final String URL = "https://nlp.aliyuncs.com/v2/api/chat/completions";
    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("=== 非流式调用示例 ===");
        String jsonBody = """
        {
            "model": "xingchen-plus-latest",
            "stream": false,
            "stop":["。（", "！（", "？（"],
            "messages": [
                 {
                     "role": "system",
                     "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\\n\\n你的性格特点：\\n\\n热情，聪明，顽皮\\n\\n你的行事风格：\\n\\n机制，果断\\n\\n你的语言特点：\\n\\n说话幽默，爱开玩笑\\n\\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。"
                 },
                 {
                     "role": "assistant",
                     "content": "班长你在干嘛呢"
                 },
                 {
                     "role": "user",
                     "content": "我在看书"
                 }
            ]
        }
        """;

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        "X-AcA-DataInspection", "enable",
                        "x-fag-servicename", "aca-chat-completions",
                        "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("=== 流式调用示例 ===");
        String jsonBody = """
        {
             "model": "xingchen-plus-latest",
             "stream": true,
             "stop":["。（", "！（", "？（"],
             "messages": [
                  {
                      "role": "system",
                      "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\\n\\n你的性格特点：\\n\\n热情，聪明，顽皮\\n\\n你的行事风格：\\n\\n机制，果断\\n\\n你的语言特点：\\n\\n说话幽默，爱开玩笑\\n\\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。"
                  },
                  {
                      "role": "assistant",
                      "content": "班长你在干嘛呢"
                  },
                  {
                      "role": "user",
                      "content": "我在看书"
                  }
             ]
         }
        """;

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        "X-AcA-DataInspection", "enable",
                        "x-fag-servicename", "aca-chat-completions",
                        "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();
    }
}

Python

import requests

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

# API名称： 特定字符停止输出
# 环境要求：python3.10及以上
def call(messages, api_key, model_name):

    headers = {
        "Content-Type": "application/json",
        "x-fag-servicename": "aca-chat-completions",
        "x-fag-appcode": "aca",
        "Authorization": f"Bearer {api_key}",
        "X-AcA-DataInspection": "enable"
    }

    payload = {
        # 流式调用开启此配置
        "stream": False,
        "messages": messages,
        "model": model_name,
        "stop":["。（", "！（", "？（"],
    }

    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": "system",
            "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\n\n你的性格特点：\n\n热情，聪明，顽皮\n\n你的行事风格：\n\n机制，果断\n\n你的语言特点：\n\n说话幽默，爱开玩笑\n\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。"
        },
        {
            "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/completions"

func call(messages []map[string]interface{}, apiKey string, modelName string) (*http.Response, error) {

    payload := map[string]interface{}{
        "stream":   false, //流式调用开启此配置
        "model":    modelName,
        "messages": messages,
        "stop": []string{"。（", "！（", "？（"},
    }

    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; charset=utf-8")
    req.Header.Set("x-fag-servicename", "aca-chat-completions")
    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":    "system",
            "content": "你是江让，男性，一个围棋天才，拿过很多围棋的奖项。你现在在读高中，是高中校草，用户是你的班长。一开始你看用户在奶茶店打工，你很好奇，后来慢慢喜欢上用户了。\n\n你的性格特点：\n\n热情，聪明，顽皮\n\n你的行事风格：\n\n机制，果断\n\n你的语言特点：\n\n说话幽默，爱开玩笑\n\n你可以将动作、神情语气、心理活动、故事背景放在（）中来表示，为对话提供补充信息。",
        },
        {
            "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)
    }
}

返回示例

{
    "id": "6b369745-951c-496f-afe7-ee25d2b98fac",
    "created": 1758007031,
    "model": "xingchen-plus-latest",
    "choices": [
        {
            "finish_reason": "stop",
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "（凑过去看，温热的气息洒在你的颈间）这么用功啊，看的什么书"
            }
        }
    ],
    "usage": {
        "completion_tokens": 25,
        "prompt_tokens": 130,
        "prompt_tokens_details": {
            "cached_tokens": 0
        },
        "total_tokens": 155,
        "cached_tokens": 0
    },
    "object": "chat.completion",
    "stop": true
}

如何提升上下文缓存命中率

为了提高请求在大模型推理过程中的 Context Cache（上下文缓存）命中概率，从而加快响应速度、降低计算成本，您需要合理组织输入提示（prompt）的结构。本文档将详细说明 Context Cache 的工作原理，并提供针对不同场景的优化策略。

Context Cache 工作原理

1. 缓存机制

系统会将用户请求中 messages 数组的前缀内容进行缓存。
当收到新请求时，系统会查找缓存中是否存在该请求提示词的“前缀匹配”。

2. 命中逻辑

命中缓存：若当前请求的前缀与缓存中的某条记录完全一致，则直接复用缓存结果，跳过重复计算。
未命中缓存：若前缀不匹配，则按常规流程处理请求，并将本次请求的前缀存入缓存。

示例：若缓存中已有 "ABCD"，

请求 "ABE" 可能命中（前缀 "AB" 匹配）
请求 "BCD" 不会命中（缺少开头 "A"，无法形成前缀匹配）

3. 缓存条件

仅当提示内容超过 256 Token 时才会被缓存。小于等于 256 Token 的请求不会触发缓存机制，请注意控制内容长度以充分利用缓存优势。

提升缓存命中率的核心原则

将重复内容放在提示词开头，差异内容放在末尾

如第一次请求

[
  {"role": "system", "content": "你是张三，年龄35岁，你是阿里巴巴的算法工程师，你热爱工作，热衷于写代码调参数，你性格成熟稳重。你于1988年出生在浙江杭州。你于2006年考入浙江大学计算机学院，当时你18岁。你于2010年大学毕业后加入了阿里巴巴工作至今。"},
  {"role": "user", "content": "你是谁？"}
]

第二次请求（正面示例）

[
  {"role": "system", "content": "你是张三，年龄35岁，你是阿里巴巴的算法工程师，你热爱工作，热衷于写代码调参数，你性格成熟稳重。你于1988年出生在浙江杭州。你于2006年考入浙江大学计算机学院，当时你18岁。你于2010年大学毕业后加入了阿里巴巴工作至今。"},
  {"role": "user", "content": "你是谁？"},
  {"role": "assistant", "content": "我是张三，阿里巴巴的算法工程师。"},
  {"role": "user", "content": "你的经历是什么？"}
]

由于第二次请求的前缀和第一次请求完全相同，则第二次请求中和第一次相同的部分，即原第一次请求的所有内容，都被命中（注意，该示例仅做演示说明，实际应用时，由于其总token数小于256，并不能真正被缓存生效）

第二次请求（反面示例）

[
  {"role": "system", "content": "你是，张三，年龄35岁，你是阿里巴巴的算法工程师，你热爱工作，热衷于写代码调参数，你性格成熟稳重。你于1988年出生在浙江杭州。你于2006年考入浙江大学计算机学院，当时你18岁。你于2010年大学毕业后加入了阿里巴巴工作至今。"},
  {"role": "user", "content": "你是谁？"},
  {"role": "assistant", "content": "我是张三，阿里巴巴的算法工程师。"},
  {"role": "user", "content": "你的经历是什么？"}
]

则第二次请求中和第一次相同的部分，即原第一次请求的所有内容，都被命中

由于第二次请求在system content 中的“你是”后面添加了“，”，则导致虽然和第一次请求相似度很高，但仅“你是”之前的内容被命中（注意，该示例仅做演示说明，实际应用时，由于其总token数小于256，并不能真正被缓存生效）

session cache 介绍

在多轮对话场景单次请求token很长，message的前缀内容高度重复时，使用session cache能够获得更高的cache命中率，降低响应时间。如果是单轮任务等其他请求时，由于使用session cache本身会有耗时，综合效果并不强，不建议使用。

获取方式：联系tongyixingchen@service.aliyun.com 进行白名单配置，在接口header的x-dashscope-aca-user参数中设置终端用户区分标识支持缓存存储。

注意点

星尘模型接入messages列表中一般只会有一个 system，用于填写角色设定。如果用户有名字，需要让角色记住用户的姓名，建议可以放在system的角色设定中。