基于coze+百度智能云+Pyside6开发的语音聊天客服

1.项目介绍

2.项目创新点

3.智能体设计

4.项目功能流程图

5.QT界面设计

5.1.1 用户列表界面设计

5.1.2 页面分析

• 用’toolBox’组件实现下拉分类列表
• 用‘PushButton’组件绑定点击事件：实现点击联系人与之聊天功能

5.2.1 聊天页设计

5.2.2 页面分析

• 用’PushButton‘组件绑定事件：实现语音录入功能
• 用’PushButton‘组件绑定事件：切换字体功能
• 用’PushButton‘组件绑定事件：历史记录功能
• 用’PushButton‘组件绑定事件：关闭界面功能
• 用’PushButton‘组件绑定事件：发送功能
• 用’TextEdit’组件实现输入文件
• 用’TextBrowser‘组件实现双方聊天内容的展示

5.3.1历史记录页面设计

5.3.2 页面分析

主要记录用户与客服之间的聊天消息

6.重要功能代码实现

6.1 用户界面实现类

class Userlist_Window(QMainWindow, Ui_UserWindow):
    def __init__(self):
        super().__init__()
        # 禁止最大化按钮（只显示最小化按钮和关闭按钮）
        self.setWindowFlags(QtCore.Qt.WindowMinimizeButtonHint | QtCore.Qt.WindowCloseButtonHint)
        # 禁止拉伸窗口大小
        self.setFixedSize(250, 355)
        self.setupUi(self)
        self.pushButton_12.clicked.connect(self.open_new_window)
        self.chat_window = Chat_Window()

    def open_new_window(self):
        self.chat_window.show()

6.2 聊天界面实现类

class Chat_Window(QMainWindow, Ui_ChatWindow):
    def __init__(self):
        super().__init__()
        self.setupUi(self)
        self.setWindowFlags(QtCore.Qt.WindowMinimizeButtonHint | QtCore.Qt.WindowCloseButtonHint)
        # 禁止拉伸窗口大小
        self.setFixedSize(572, 519)

        # 鼠标悬浮按钮时，显示按钮的提示语
        self.pushButton_27.setToolTip("字体")
        self.pushButton_24.setToolTip("查看历史记录")
        self.pushButton_25.setToolTip("发送")
        self.pushButton_23.setToolTip("关闭")

        # 获取当前时间
        self.current_time = datetime.now().strftime("%H:%M:%S")
        self.db = create_db_and_table()

        # 创建历史记录窗口
        self.history_window = History_Window()

        self.pushButton_23.clicked.connect(self.close_window)

        # 设置推送按钮的样式，包括背景色、文字色、字体大小和边框圆角
        self.pushButton_26.setStyleSheet(u"background-color: rgb(85, 170, 0);\n"
                                         "color: rgb(255, 255, 255);\n"
                                         "font-size:20px;\n"
                                         "border-radius:5px")

        # 设置字体按钮的点击事件，实现点击按钮后选择字体的功能
        self.pushButton_27.clicked.connect(self.font_change)
        # 设置历史记录按钮的点击事件，实现点击按钮后显示历史记录的功能
        self.pushButton_24.clicked.connect(self.show_history_window)

        # 将推送按钮的点击事件连接到send方法，实现点击按钮后发送信息的功能
        self.pushButton_25.clicked.connect(self.send)

        # 连接推送按钮的按下和释放事件到相应的录音开始和停止方法
        self.recording_status = False  # 录音状态，默认为False
        self.pushButton_26.pressed.connect(self.start_recording)
        self.pushButton_26.released.connect(self.stop_recording)

        # 初始化录音状态为False,表示未开始录音
        self.recording = False  # 录音状态，默认为False
        # 创建线程锁，用于同步访问录音数据帧
        self.frames_lock = threading.Lock()
        # 初始化录音数据帧列表
        self.frames = []
        # 设置音频块大小
        self.CHUNK = 1024
        # 设置音频格式为16位整数
        self.FORMAT = paInt16
        # 设置音频通道数为单声道
        self.CHANNELS = 1
        # 设置音频采样率为16000Hz
        self.RATE = 16000
        # 创建PyAudio对象，用于音频流的录入和播放
        self.audio = PyAudio()

    def start_recording(self):
        if not self.recording:
            self.recording = True

            with self.frames_lock:
                self.frames.clear()

            self.pushButton_26.setText("录音中...")
            self.pushButton_26.setStyleSheet(u"background-color: rgb(255, 0, 0);\n"
                                             "color: rgb(255, 255, 255);\n"
                                             "font-size:20px;\n"
                                             "border-radius:5px")

            print("录音中...")  # 打印录音开始的消息
            # 开始录音线程
            self.record_audio_thread = threading.Thread(target=self.record_audio)
            self.record_audio_thread.start()

    def record_audio(self):
        """
        录音方法。尝试打开音频流并开始录音，直到停止录音或发生异常。
        :return:
        """
        try:
            # 打开音频流，用于录制声音
            # 格式、通道数、采样率和缓冲区大小根据类的相应属性进行设置
            # input=True表示这是一个输入流（录音）
            stream = self.audio.open(format=self.FORMAT, channels=self.CHANNELS, rate=self.RATE,
                                     input=True, frames_per_buffer=self.CHUNK)

            # 循环录制音频数据，直到录制停止
            while self.recording:
                # 读取缓冲区大小的音频数据
                data = stream.read(self.CHUNK)
                # 在线程安全的情况下，将读取的音频数据追加到帧列表中
                with self.frames_lock:
                    self.frames.append(data)

            # 停止音频流并关闭它
            stream.stop_stream()
            stream.close()
        except Exception as e:
            # 捕获并打印录制过程中发生的任何异常
            print(f"Error during recording: {e}")

    def save_audio(self):
        try:
            # 尝试打开音频文件，准备写入
            filename = 'medium/user.wav'
            wf = wave.open(filename, 'wb')

            # 设置音频文件的参数，包括声道数、采样率和采样宽度
            wf.setnchannels(self.CHANNELS)
            wf.setframerate(self.RATE)
            wf.setsampwidth(self.audio.get_sample_size(self.FORMAT))

            # 在frames锁的保护下，将录音数据写入音频文件
            with self.frames_lock:
                wf.writeframes(b''.join(self.frames))

            # 关闭文件，释放资源
            wf.close()

            # 打印保存文件成功的消息，并返回True表示成功
            print(f"录音文件已保存为{filename}")
            return True
        except Exception as e:
            # 捕获异常，打印错误信息，并返回False表示失败
            print(f"Error saving audio file: {e}")
            return False

    def stop_recording(self):

        if self.recording:
            self.recording = False

            self.pushButton_26.setText("按住话筒说话")
            self.pushButton_26.setStyleSheet(u"background-color: rgb(85, 170, 0);\n"
                                             "color: rgb(255, 255, 255);\n"
                                             "font-size:20px;\n"
                                             "border-radius:5px")

            # 打印停止录音的消息，用于日志记录
            print("停止录音...")

            # 确保录音线程结束
            self.record_audio_thread.join()

            # 尝试保存录音文件
            success = self.save_audio()
            if success:
                print("录音文件保存成功！")
                self.speech_recognition()

            else:
                print("录音文件保存失败")

    def speech_recognition(self):
        # 实例化百度语音识别对象
        voice = BaiduVoice()

        # 调用语音识别方法，传入用户语音文件，返回识别结果
        recognition_result = voice.recognize_speech('medium/user.wav')

        # 打印用户语音的识别结果
        print("用户:", recognition_result)

        # 如果识别成功（即识别结果不为空）
        if recognition_result:
            # 发送用户消息
            self.send_user_message(recognition_result)

            # 使用多线程异步插入数据到数据库，避免阻塞主线程
            threading.Thread(target=insert_data, args=('用户', recognition_result)).start()

            # 调用Coze API，传入识别结果（此处未展示具体实现，假设是一个与Coze平台交互的函数）
            self.coze_api(recognition_result)


        else:
            # 如果识别失败，打印错误信息
            print('识别失败')

    def coze_api(self, kword):
        # 调用cozeapi接口，进行用户查询
        print("调用cozeapi接口")
        chat_response = chat(kword)

        # 打印coze机器人回复的内容
        print("客服:", chat_response)

        # 调用自身的方法receive_bot_response处理chat_response
        self.receive_bot_response(chat_response)

        # 创建并启动一个线程，负责对机器人的回复进行语音合成
        threading.Thread(target=self.speech_synthesis, args=(chat_response,)).start()
        # 将机器人的回复插入数据库
        insert_data('客服', chat_response)

    def speech_synthesis(self, kword):
        # 实例化百度语音合成对象
        voice = BaiduVoice()

        # 合成指定文本为语音文件
        # 将文本kword合成语音，并保存到'medium/bot.mp3'文件中
        voice.synthesize_text(kword, 'medium/bot.mp3')
        # print('已合成的文本:', kword)

        # 初始化Pygame模块，为播放音频做准备
        pygame.init()
        # 加载合成的语音文件
        pygame.mixer.music.load('medium/bot.mp3')
        # 播放语音
        pygame.mixer.music.play()
        # 等待音频播放完毕
        while pygame.mixer.music.get_busy():
            pygame.time.Clock().tick(10)

        # 关闭Pygame音频模块
        pygame.quit()

    def send_user_message(self, content):
        self.textEdit.clear()
        self.textBrowser.append(f"<p style='color:blue;'>{self.current_time} 用户: {content}</p>")

    def receive_bot_response(self, response):
        self.textBrowser.append(f"<p style='color:red;'>{self.current_time} 机器人: {response}</p>")
        # 设置滚动条位置
        self.textBrowser.verticalScrollBar().setValue(self.textBrowser.verticalScrollBar().maximum())

    def send(self):

        send_content = self.textEdit.toPlainText()
        # 判断用户输入的是否为空
        if send_content:
            # insert_data("用户", send_content)
            print("用户:", send_content)
            self.send_user_message(send_content)
            threading.Thread(target=insert_data, args=('用户', send_content)).start()  # 开启一个子进程，执行插入数据库操作

            try:
                chat_response = self.coze_api_input(send_content)
            except Exception as e:
                chat_response = f"发生错误：{str(e)}"

            self.receive_bot_response(chat_response)
            # 在新线程中执行语音合成, 避免阻塞主线程(即在textBroswer上的文本显示顺序)
            threading.Thread(target=self.speech_synthesis, args=(chat_response,)).start()

    # 再写一个带返回值的coze_api()方法
    def coze_api_input(self, send_content):
        print("调用cozeapi接口")
        chat_response = chat(send_content)
        insert_data('客服', chat_response)

        print("客服:", chat_response)

        return chat_response

    # 显示历史记录
    def show_history_window(self):
        self.history_window.show()

    # 设置字体
    def font_change(self):
        """
        该函数使用QFontDialog.getFont()打开字体选择对话框。
        若用户确认选择，返回值包含一个表示成功的布尔值和一个QFont对象。
        若选择被确认，则将所选字体应用于textEdit和textBrowser控件。
        :return:
        """

        result = QFontDialog.getFont()
        ok = result[0]
        font = result[1]
        if ok:
            self.textEdit.setFont(font)
            self.textBrowser.setFont(font)

    # 关闭窗口
    def close_window(self):
        self.close()

6.3 历史记录页面实现类

class History_Window(QMainWindow, Ui_HistoryWindow):
    def __init__(self):
        super().__init__()
        self.setupUi(self)
        self.setFixedSize(508, 450)

    def load_history(self):
        self.textBrowser.setText(query_data())

    def show(self):
        self.load_history()  # 加载最新历史记录
        super().show()

6.4 数据库设计类

import datetime
import sqlite3


def create_db_and_table():
    conn = sqlite3.connect('history_dialogue.db')
    cursor = conn.cursor()
    cursor.execute('''CREATE TABLE IF NOT EXISTS history(
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
            speaker TEXT NOT NULL,
            message TEXT NOT NULL,
            timestamp TEXT NOT NULL
    )''')
    conn.commit()
    conn.close()

def insert_data(speaker, message):
    current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    conn = sqlite3.connect('history_dialogue.db')
    cursor = conn.cursor()
    cursor.execute('INSERT INTO history(speaker, message,timestamp) VALUES(?, ?,?)', (speaker, message,current_time))
    conn.commit()
    conn.close()


def query_data():
    conn = sqlite3.connect('history_dialogue.db')
    cursor = conn.cursor()
    cursor.execute('SELECT speaker,message,timestamp FROM history')
    data = cursor.fetchall()
    info_text = '\n'.join([f"{speaker}:{message}-{timestamp}"for speaker,message,timestamp in data])
    conn.close()
    return info_text

def clear_data():
    conn = sqlite3.connect('history_dialogue.db')
    cursor = conn.cursor()
    cursor.execute('DELETE FROM history')
    conn.commit()
    conn.close()



if __name__ == '__main__':
     clear_data()

百度智能云-语音识别、语音合成模块

class BaiduVoice:
    def __init__(self, app_id=APP_ID, api_key=API_KEY, secret_key=SECRET_KEY):
        self.client = AipSpeech(app_id, api_key, secret_key)

    def recognize_speech(self, audio_file_path, language='zh'):
        try:
            with open(audio_file_path, 'rb') as f:
                audio_data = f.read()
        except IOError as e:
            print(f"文件读取错误: {e}")
            return None

        dev_pid = 1537 if language == 'zh' else 1737

        result = self.client.asr(audio_data, 'wav', 16000, {'dev_pid': dev_pid})

        return result.get('result')[0] if result and 'result' in result else None

    def synthesize_text(self, text, output_file_path, language='zh', per="106"):
        """
        合成文本为语音文件。
        参数:
        - text: 需要合成的文本内容。
        - output_file_path: 保存合成语音文件的路径。
        - language: 语言选项，默认为'zh'表示中文，否则为'en'表示英文。
        返回值:
        - 合成成功返回True，失败返回False。
        """
        # 根据文本内容和语言选项，调用语音合成接口，返回合成的语音数据或错误信息字典
        result = self.client.synthesis(text, 'zh' if language == 'zh' else 'en', per)

        # 检查合成结果是否为错误信息，如果是，则打印错误信息并返回False
        if isinstance(result, dict):
            print(f"合成失败: {result}")
            return False

        # 尝试将合成的语音数据写入到指定的文件路径
        try:
            with open(output_file_path, 'wb') as f:
                f.write(result)
        # 如果发生IOError异常，打印错误信息并返回False
        except IOError as e:
            print(f"文件写入错误: {e}")
            return False

        # 如果以上步骤都成功，返回True表示语音合成成功
        return True

运行图片

未来优化

该项目未来计划扩展为支持多用户实时聊天功能，并通过TCP网络编程技术构建一个类似“飞秋”的聊天室应用。