java Springboot使用扣子Coze实现实时音频对话智能客服功能_Java

一、背景

因公司业务需求，需要使用智能客服实时接听顾客电话。

现在已经完成的操作是，智能体已接入系统进行对练，所以本文章不写对联相关的功能。只有coze对接～

扣子提供了试用realtime websocket，点击右上角setting配置好智能体token之后就可以试用了

注意：只有扣子专业版支持实时音视频，所以需要开通专业版，开发测试阶段可以先充值1元买1000资源点对接测试，注意超额会单独收费哦，

二、准备工作

1、发布智能体为ai服务

a.登陆扣子平台注册账号

扣子

扣子是新一代 ai 大模型智能体开发平台。整合了插件、长短期记忆、工作流、卡片等丰富能力，扣子能帮你低门槛、快速搭建个性化或具备商业价值的智能体，并发布到豆包、飞书等各个平台。

https://www.coze.cn/home

b. 在左侧导航栏中选择工作空间，并在页面顶部空间列表中选择个人空间或团队空间

c. 在项目开发页面，新建智能体

d.创建智能体完成之后，点击右上角的发布，在发布页面，选择api选项，然后点击发布

c.获取智能体id,后续开发要用

点开工作空间->项目开发->你的智能体，点进新建的智能体，链接地址后的数字则为智能体id

2、获取访问令牌

因公司业务需要经过对比我们选用了jwt方式，开发测试阶段也可以选择个人访问令牌

a.在扣子api页面，进入授权-> oauth应用页面->创建新应用，注意客户端类型为服务端应用

b.保存后进行下一步授权，将自动生成的公钥复制保存好，自动下载的私钥也要存储好，后续接口认证会用到！

3、安装java sdk，参考扣子官网

扣子

https://www.coze.cn/open/docs/developer_guides/java_installation

三、实践开发

1、添加maven依赖

 <dependency>
            <groupid>com.coze</groupid>
            <artifactid>coze-api</artifactid>
            <version>0.3.0</version>
</dependency>
<!-- 以下非必须！！！！我把私钥文件放到resources下了，所以打包需要加上这个类型->
<build>
      <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.pem</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

2、获取token

@slf4j
@component
public class cozeoauth {
    /**
     * jwt鉴权token
     */
    public string getjwttoken() {
        string token = "";
        try {
            // 获取私钥文件
            string jwtoauthprivatekeyfilepath = "这里是你的私钥文件地址";
            classloader classloader = this.getclass().getclassloader();
            java.net.url resourceurl = classloader.getresource(jwtoauthprivatekeyfilepath);
            if (resourceurl == null) {
                log.info("私钥资源文件未找到，{}", jwtoauthprivatekeyfilepath);
                return token;
            }
            string jwtoauthprivatekey = new string(
                    files.readallbytes(paths.get(resourceurl.touri())), standardcharsets.utf_8);
            jwtoauthclient oauth = new jwtoauthclient.jwtoauthbuilder()
                    .clientid("这里是你之前创建的oauth应用id")
                    .privatekey(jwtoauthprivatekey)
                    .publickey("这里是你的公钥")
                    .baseurl(com.coze.openapi.service.config.consts.coze_cn_base_url)
                    .build();
            // 获取token
            oauthtoken resp = oauth.getaccesstoken();
            system.out.println(resp);
            if (objects.nonnull(resp)) {
                token = resp.getaccesstoken();
            }
        } catch (exception e) {
            log.error("获取coze jwt token异常！", e);
        }
        log.info("获取coze jwt token：{}", token);
        return token;
    }
}

3、创建新类继承websocketschatcallbackhandler，接收扣子服务端返回消息并做业务处理

@slf4j
public class mywebsocketschatcallbackhandler extends websocketschatcallbackhandler {
    public void onchatcreated(websocketschatclient client, chatcreatedevent event) {
        log.info("扣子服务端返回，对话连接成功,{}", json.tojsonstring(event));
    }
    public void onchatupdated(websocketschatclient client, chatupdatedevent event) {
        log.info("扣子服务端返回，对话配置成功,{}", json.tojsonstring(event));
    }
    public void onconversationchatcreated(websocketschatclient client, conversationchatcreatedevent event) {
        log.info("扣子服务端返回，对话开始,{}", json.tojsonstring(event));
    }
    public void onconversationchatinprogress(websocketschatclient client, conversationchatinprogressevent event) {
        log.info("扣子服务端返回，对话正在处理,{}", json.tojsonstring(event));
    }
    public void onconversationmessagedelta(websocketschatclient client, conversationmessagedeltaevent event) {
        log.info("扣子服务端返回，增量消息,{}", json.tojsonstring(event));
    }
    public void onconversationaudiodelta(websocketschatclient client, conversationaudiodeltaevent event) {
        log.info("扣子服务端返回，增量语音,{}", json.tojsonstring(event));
       // todo 处理实际业务，比如返回给用户的语音
    }
    public void onconversationmessagecompleted(websocketschatclient client, conversationmessagecompletedevent event) {
        log.info("扣子服务端返回，消息完成,{}", json.tojsonstring(event));
    }
    public void onconversationaudiocompleted(websocketschatclient client, conversationaudiocompletedevent event) {
        log.info("扣子服务端返回，语音回复完成,{}", json.tojsonstring(event));
    }
    public void onconversationchatcompleted(websocketschatclient client, conversationchatcompletedevent event) {
        log.info("扣子服务端返回，对话完成,{}", json.tojsonstring(event));
    }
    public void onconversationchatfailed(websocketschatclient client, conversationchatfailedevent event) {
        log.info("扣子服务端返回，对话失败,{}", json.tojsonstring(event));
    }
    public void oninputaudiobuffercompleted(websocketschatclient client, inputaudiobuffercompletedevent event) {
        log.info("扣子服务端返回，流式提交的音频完成,{}", json.tojsonstring(event));
    }
    public void oninputaudiobuffercleared(websocketschatclient client, inputaudiobufferclearedevent event) {
        log.info("扣子服务端返回，清除缓冲区音频成功,{}", json.tojsonstring(event));
    }
    public void onconversationcleared(websocketschatclient client, conversationclearedevent event) {
        log.info("扣子服务端返回，上下文清除完成,{}", json.tojsonstring(event));
    }
    public void onconversationchatcanceled(websocketschatclient client, conversationchatcanceledevent event) {
        log.info("扣子服务端返回，智能体输出中断,{}", json.tojsonstring(event));
    }
    public void onconversationaudiotranscriptupdate(websocketschatclient client, conversationaudiotranscriptupdateevent event) {
        log.info("扣子服务端返回，用户语音识别字幕,{}", json.tojsonstring(event));
    }
    public void onconversationaudiotranscriptcompleted(websocketschatclient client, conversationaudiotranscriptcompletedevent event) {
        log.info("扣子服务端返回，用户语音识别完成,{}", json.tojsonstring(event));
    }
    public void onconversationchatrequiresaction(websocketschatclient client, conversationchatrequiresactionevent event) {
        log.info("扣子服务端返回，端插件请求,{}", json.tojsonstring(event));
    }
    public void oninputaudiobufferspeechstarted(websocketschatclient client, inputaudiobufferspeechstartedevent event) {
        log.info("扣子服务端返回，用户开始说话,{}", json.tojsonstring(event));
    }
    public void oninputaudiobufferspeechstopped(websocketschatclient client, inputaudiobufferspeechstoppedevent event) {
        log.info("扣子服务端返回，用户结束说话,{}", json.tojsonstring(event));
    }
    public void onclosing(websocketschatclient client, int code, string reason) {
        log.info("扣子服务端返回，onclosing,code：{}，reason：{}",code, reason);
    }
    public void onclosed(websocketschatclient client, int code, string reason) {
        log.info("扣子服务端返回，onclosed,code:{},reason：{}", code,reason);
    }
    public void onerror(websocketschatclient client, errorevent event) {
        log.info("扣子服务端返回，onerror,event：{}", json.tojsonstring(event));
    }
    public void onfailure(websocketschatclient client, throwable t) {
        log.info("扣子服务端返回，onfailure,event：{}", json.tojsonstring(t));
    }
    public void onclientexception(websocketschatclient client, throwable t) {
        log.info("扣子服务端返回，onfailure,event：{}", json.tojsonstring(t.getmessage()));
    }
}

4、创建工具类

抽取跟业务无关的代码到该类中

@slf4j
@component
public class websocketutils {
    @resource
    private cozeoauth cozeoauth;
    /**
     * 更新对话配置 请求参数
     */
    public chatupdateeventdata initchatupdateeventdata() {
        // 对话配置
        chatconfig chatconfig = new chatconfig();
        chatconfig.setautosavehistory(true);
        // 输入音频格式
        inputaudio inputaudio = new inputaudio("pcm", "g711a", 8000, 1, 16);
       pcmconfig pcmconfig = new pcmconfig(100,8000);
        // 输出音频格式
        outputaudio outputaudio = new outputaudio("pcm", pcmconfig, null, null, null);
        // 转检测配置
        // server_vad 模式下，vad 检测到语音之前要包含的音频量，单位为 ms。默认为 600ms。
        // server_vad 模式下，检测语音停止的静音持续时间，单位为 ms。默认为 500ms
        turndetection turndetection = new turndetection("server_vad", 300, 500);
        return cchatupdateeventdata.builder()
                .inputaudio(inputaudio)
                .outputaudio(outputaudio)
                .chatconfig(chatconfig)
                .turndetection(turndetection)
                .build();
    }
    public cozeapi getcozeapi(){
        return new cozeapi.builder()
                .baseurl(consts.coze_cn_base_url)
                .auth(new tokenauth(cozeoauth.getjwttoken()))
                .readtimeout(10000)
                .build();
    }
}

5、使用websocket双向流式对话

我们用到了第三方的用户进线传输，直接sip协议拿包，将包传输给扣子，之后再将扣子的增量语音返回给第三方就行。所以选择了websocket的方式

        byte[] buffer = new byte[1500];
        cozeapi cozeapi = websocketutils.getcozeapi();
        websocketschatclient websocketschatclient = cozeapi.websockets()
                .chat()
                .create(new websocketschatcreatereq("这里是你的智能体id", new mywebsocketschatcallbackhandler()));
        // 更新对话配置               
        websocketschatclient.chatupdate(websocketutils.initchatupdateeventdata());
        // 此处可以根据实际业务接收语音流
        byte[] audiodata = 
        files.readallbytes(paths.get("/音频.pcm"));
        // 流式上传音频片段
        websocketschatclient.inputaudiobufferappend(audiodata);

四、踩过的的坑

1、sdk版本会落后服务端功能

扣子提供的sdk跟接口文档中描述的功能有部分差异，比如更新对话接口的入参limit_config，在sdk中是没有的。

遇到这种情况则需要自己封装参数，比如继承某个sdk的类，然后在子类中写自己需要但是sdk没有的参数。

2、自动打断功能配置

想要实现自动打断功能，需要使用server_vad模式，并且需要配置输出音频的限制limit_config，限制每次服务端返回的包，否则会等服务端返回完成之后才能打断。

3、工作流模式服务端响应较慢

实际应用场景中会需要给智能体传配置好的参数，目前智能通过工作流的方式记住上下文，但是该模式服务端响应在3s左右，具体还在排查问题

到此这篇关于java springboot使用扣子coze实现实时音频对话智能客服功能的文章就介绍到这了,更多相关springboot音频对话智能客服内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

java Springboot使用扣子Coze实现实时音频对话智能客服功能

2025年07月23日 • Java •我要评论