一文搭建智能问答聊天室（智能问答系统功能）

本文将详细介绍如何搭建一个智能聊天室，从基础的多人聊天功能到集成智能问答模型，逐步深入，轻松掌握整个过程。

#01 基础多人聊天室的搭建

1. 服务器端实现

服务器类的核心功能是监听客户端的连接请求，并为每个客户端创建一个线程来处理消息，并创建服务器端界面。

import wx
from socket import *
import  threading
from concurrent.futures import ThreadPoolExecutor
class Server(wx.Frame):
    def __init__(self):
        # 实例属性
        self.isOn = False  # 服务器的启动状态
        # 创建socket对象
        self.server_socket = socket()
        # 绑定ip和端口号
        self.server_socket.bind(('0.0.0.0',8999))
        # 监听
        self.server_socket.listen(5)
        # 保存所有的客户端
        self.client_thread_dict={}
        # 创建线程池
        self.pool = ThreadPoolExecutor(max_workers=10)
        # 界面布局
        # 调用父类的init方法
        wx.Frame.__init__(self,None,title='多人聊天室',pos=(0,50),size=(450,600))
        # 创建面板
        self.pl = wx.Panel(self)
        # 创建按钮
        # 启动服务器
        self.start_server_btn = wx.Button(self.pl,pos=(10,10),size=(200,40),label='启动服务器')
        # 保存聊天记录
        self.save_text_btn = wx.Button(self.pl, pos=(220, 10), size=(200, 40), label='保存聊天记录')
        # 创建聊天内容文本框
        self.text = wx.TextCtrl(self.pl, size=(400, 400), pos=(10, 60), style=wx.TE_READONLY | wx.TE_MULTILINE)
        # 给按钮绑定事件
        self.Bind(wx.EVT_BUTTON,self.start_server,self.start_server_btn)
        self.Bind(wx.EVT_BUTTON, self.save_text, self.save_text_btn)
    # 启动服务器
    def start_server(self,event):
        print('start server')
        if self.isOn==False:
            self.isOn=True
            # 创建线程
            main_thread = threading.Thread(target=self.main_thread_fun)
            # 设置为守护线程
            main_thread.daemon = True
            # 启动线程
            main_thread.start()
    def main_thread_fun(self):
        while self.isOn:
            client_socket,client_addr=self.server_socket.accept()
            print(client_addr)
            client_name = client_socket.recv(1024).decode('utf8')
            print(client_name)
            client_thread = ClientThead(client_socket,client_name,self)
            # 保存客户端
            self.client_thread_dict[client_name] = client_thread
            self.pool.submit(client_thread.run)
            self.send("【服务器通知】欢迎%s进入聊天室"%client_name)
    def send(self,text):
        self.text.AppendText(text+'\n')
        for client in self.client_thread_dict.values():
            if client.isOn:
                client.client_socket.send(text.encode('utf8'))
    # 保存聊天记录
    def save_text(self,event):
        print('save text')
        record = self.text.GetValue()
        with open('record.log',"a+",encoding='GBK') as f:
            f.write(record)
class ClientThead(threading.Thread):
    def __init__(self,socket,name,server):
        threading.Thread.__init__(self)
        self.client_socket = socket
        self.client_name = name
        self.server = server
        self.isOn = True
    def run(self):
        while self.isOn:
            text = self.client_socket.recv(1024).decode('utf8')
            if text =='断开连接':
                self.isOn = False
                self.server.send('【服务器消息】%s离开了聊天室'%self.client_name)
            else:
                self.server.send('【%s】%s'%(self.client_name,text))
        self.client_socket.close()
# 程序入口
if __name__=="__main__":
    # 创建应用程序对象
    app = wx.App()
    # 创建服务器窗口
    server = Server()
    # 显示服务器窗口
    server.Show()
    # 循环显示
    app.MainLoop()

2. 客户端实现

客户端类的核心功能是连接服务器，发送用户输入的消息，并接收服务器广播的消息,并创建客户端界面。

import wx
from socket import *
import threading
from faker import Faker #用于生成假数据的库
class Client(wx.Frame):
    # 构造方法
    def __init__(self):
        # 实例属性
        self.name =  Faker('zh_CN').name() # 客户端的名字
        self.isConnected = False  # 客户端是否连接服务器
        self.client_socket = None
        # 界面布局
        wx.Frame.__init__(self,None,title=self.name+"聊天室客户端",size=(450,660),pos=(100,50))
        # 创建面板
        self.pl = wx.Panel(self)
        # 创建按钮
        # 加入聊天室
        self.conn_btn = wx.Button(self.pl,label="加入聊天室",pos=(10,10),size=(200,40))
        # 离开聊天室
        self.dis_conn_btn = wx.Button(self.pl, label="离开聊天室", pos=(220, 10), size=(200, 40))
        # 清空按钮
        self.clear_btn = wx.Button(self.pl, label="清空", pos=(10, 580), size=(200, 40))
        # 发送按钮
        self.send_btn = wx.Button(self.pl, label="发送", pos=(220, 580), size=(200, 40))
        # 创建聊天内容文本框
        self.text = wx.TextCtrl(self.pl,size=(400,400),pos=(10,60),style=wx.TE_READONLY|wx.TE_MULTILINE)
        # 创建输入文本框
        self.input_text = wx.TextCtrl(self.pl,size=(400,100),pos=(10,470),style=wx.TE_MULTILINE)
        # 按钮的事件绑定
        self.Bind(wx.EVT_BUTTON,self.clear,self.clear_btn)
        self.Bind(wx.EVT_BUTTON, self.conn, self.conn_btn)
        self.Bind(wx.EVT_BUTTON, self.dis_conn, self.dis_conn_btn)
        self.Bind(wx.EVT_BUTTON, self.send, self.send_btn)
    # 点击 加入聊天室 按钮 触发
    def conn(self,event):
        print('conn方法')
        if self.isConnected==False:
            self.isConnected=True
            self.client_socket=socket()
            self.client_socket.connect(('127.0.0.1',8999))
            # 发送用户名
            self.client_socket.send(self.name.encode('utf8'))
            main_thread = threading.Thread(target=self.recv_data)
            main_thread.daemon=True
            main_thread.start()
    def recv_data(self):
        print(22222222222)
        while self.isConnected:
            print(111111111)
            text = self.client_socket.recv(1024).decode('utf8')
            print(text)
            self.text.AppendText(text+'\n')
    # 点击 离开聊天室 按钮 触发
    def dis_conn(self,event):
        print('dis_conn方法')
        self.client_socket.send('断开连接'.encode('utf8'))
        self.isConnected=False
    # 点击 清空 按钮 触发
    def clear(self, event):
        print('clear方法')
        self.input_text.Clear()
    # 点击 发送 按钮 触发
    def send(self, event):
        print('send方法')
        if self.isConnected:
            text = self.input_text.GetValue()
            if text !='':
                self.client_socket.send(text.encode('utf8'))
                self.input_text.Clear()
# 程序入口
if __name__ =='__main__':
    # 创建应用程序对象
    app = wx.App()
    # 创建客户端窗口
    client = Client()
    # 显示客户端窗口
    client.Show()
    # 一直循环显示
    app.MainLoop()

#02升级为智能问答聊天室

在基础的多人聊天室功能之上，可以进一步升级，使其具备智能问答的能力。这需要集成一个智能问答模型，例如Moonshot AI的 Kimi 大模型 。

调用Kimi 大模型 API 主要包括以下步骤：

1. 注册账号与获取 API Key

(1).访问 Moonshot AI 官方网站，注册或登录账号。 https://platform.moonshot.cn

(2).在平台的“账户总览”部分查看免费额度。

(3).点击“API Key 管理”并创建一个新的 API Key。创建完成后，请立即复制并保存 API Key，因为它只会显示一次。

2. 安装SDK并调用API

使用pip命令安装OpenAI SDK：

 pip install openai

使用 OpenAI 的 Python SDK 来调用 Kimi Chat API。以下是示例代码：

from openai import OpenAI
# 使用 OpenAI 的官方 SDK
client = OpenAI(
    api_key = "$MOONSHOT_API_KEY",# 需要替换为您在平台上创建的 API Key
    base_url = "https://api.moonshot.cn/v1",
)


def gpt(question):
    completion = client.chat.completions.create(
        model = "moonshot-v1-8k",
        messages = [
            {"role": "system", "content": "你是擅于交流的人工智能助手。"},
            {"role": "user", "content": question}
        ],
        temperature = 0.3,
    )
    content = completion.choices[0].message.content
    # print(content)
    return content
print(gpt('你好'))

3. 修改服务器端代码

在服务器端，仅需修改消息发送逻辑，使其能够调用Kimi大模型获取智能回答。

找到方法send(self,text),修改为如下代码即可。

    def send(self,text):
        self.text.AppendText(text+'\n')
        for client in self.client_thread_dict.values():
            if client.isOn:
                print(text)
                result = gpt(text)
                print(result)
                client.client_socket.send(result.encode('utf8'))
                self.text.AppendText(result + '\n')
                # client.client_socket.send(text.encode('utf8'))

快去试试吧！

通过上述步骤，已经成功搭建了一个从基础多人聊天到智能问答的聊天室。这个过程不仅涉及到了网络编程的基础知识，还引入了智能问答模型的集成。

希望本文的介绍能够帮助你快速掌握搭建智能聊天室的方法，并激发更多创新的想法。