AIGC: 关于ChatGPT中实现一个聊天机器人

规划一个聊天机器人

智能化完全于依托于GPT, 而产品化是我们需要考虑的事情
比如，如何去构建一个聊天机器人
聊天机器人它的处理逻辑其实非常的清晰
- 我们输入问题调用 GPT
- 然后，GPT 给我们生成回答就可以了
需要注意的是，聊天机器人不同于调用API进行一个简单的测试
我们和聊天机器人的对话，可能是多轮的一个对话
在这时候，我们去调用API的时候，就需要将我们多轮的问答都传递给GPT才行

新增一些实现类，结构如下

以下Java版代码来源于网络，可基于此逻辑，改造成其他编程语言
src
- main
  - java
    - com.xxx.gpt.client
      - util
        
        ChatContextHolder.java
      - ChatBotClient.java
      - ...
- test
  - java
    - com.xxx.gpt.client.test
      - FunctionCallTest.java
      - ...

ChatContextHolder.java

java 复制代码

package com.xxx.gpt.client.util;

import com.xxx.gpt.client.entity.Message;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ChatContextHolder {
    private static Map<String, List<Message>> context = new HashMap<>();

    public static List<Message> get(String id) {
        // TODO  限制轮数，或者限制token数量
        List<Message> messages = context.get(id);
        if (messages == null) {
            messages = new ArrayList<>();
            context.put(id, messages);
        }
        return messages;
    }

    public static void add(String id, String msg) {
        Message message = Message.builder().content(msg).build();
        add(id, message);
    }

    public static void add(String id, Message message) {
        List<Message> messages = context.get(id);
        if (messages == null) {
            messages = new ArrayList<>();
            context.put(id, messages);
        }
        messages.add(message);
    }

    public static void remove(String id) {
        context.remove(id);
    }
}

这里需要来添加一个类，就是我们GPT的上下文的类
我们创建一个类，用于保存我们和GPT聊天的相关的 message
- 实例化一个Map的对象, 里面的 key 是我们chat的一个id, 一个会话的id
- 然后，对应的这个key就会有它的一个消息的列表，也就是一个message的list
- 添加相关的方法
  - 比如说像get方法，根据我们的会话id，获取到所有的message
  - add方法，去对指定的会话id去添加message
  - remove方法, 去删除message
- 这是我们的上下文处理的类

ChatBotClient.java

java 复制代码

package com.xxx.gpt.client;

import com.xxx.gpt.client.entity.Message;
import com.xxx.gpt.client.listener.ConsoleStreamListener;
import com.xxx.gpt.client.util.ChatContextHolder;
import com.xxx.gpt.client.util.Proxys;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Proxy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.stream.Collectors;

@Slf4j

public class ChatBotClient {
    public static Proxy proxy = Proxy.NO_PROXY;
    public static void main(String[] args) {

        System.out.println("ChatGPT - Java command-line interface");
        System.out.println("Press enter twice to submit your question.");
        System.out.println();
        System.out.println("按两次回车以提交您的问题！！！");
        String chatUuid = UUID.randomUUID().toString();
        String key = "sk-adfas";
        proxy = Proxys.http("127.0.0.1", 7890);
        while (true) {
            String prompt = getInput("\nYou:\n");
            ChatGPTStreamClient chatGPT = ChatGPTStreamClient.builder()
                    .apiKey(key)
                    .proxy(proxy)
                    .build()
                    .init();
            System.out.println("AI: ");
            // 卡住
            CountDownLatch countDownLatch = new CountDownLatch(1);
            Message message = Message.of(prompt);
            ChatContextHolder.add(chatUuid, message);
            ConsoleStreamListener listener = new ConsoleStreamListener() {
                @Override
                public void onError(Throwable throwable, String response) {
                    throwable.printStackTrace();
                    countDownLatch.countDown();
                }
            };
            listener.setOnComplate(msg -> {
                ChatContextHolder.add(chatUuid, Message.ofAssistant(msg));
                countDownLatch.countDown();
            });
            chatGPT.streamChatCompletion(ChatContextHolder.get(chatUuid), listener);
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    @SneakyThrows
    public static String getInput(String prompt) {
        System.out.print(prompt);
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        List<String> lines = new ArrayList<>();
        String line;
        try {
            while ((line = reader.readLine()) != null && !line.isEmpty()) {
                lines.add(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return lines.stream().collect(Collectors.joining("\n"));
    }
}

它的实现其实也比较简单
- 第一步，需要等待用户输入，用户输入完成之后，调用GPT
  - 添加一下相关的我们的 API KEY 和 proxy
  - getInput 去接收用户输入
- 第二步，需要保存多轮会话
  - 我们是多轮会话，我们这里写一个循环在前面
  - chatUuid 是我们用于标识会话的id
- 第三步，为了效果更好，更加顺畅，采用流式的方式
  - 创建一个 StreamClient 去调用GPT的 API
  - 调用完成进行输出

测试

完成之后，可以测试一下
- 程序等待我们的输出，我们去询问一下: "你是谁?"
- 这里需要敲两次回车进行确认
调用之后，我们获取到了 GPT 它的返回的结果
- 然后，我们问: "请介绍一下ChatGPT"
- GPT生成了相关的答案
在这次问答当中，也能看到流式Client的一个效果
整体上和我们通过界面去访问GPT是没有什么区别的
假如说，我们现在再问: "这是我的第几个问题?"
- 理论上讲，这是我们本轮会话的第三个问题
- 由于我们没有在刚刚的调用里面, 去关联我们会话上下文的信息
- 这样，GPT会回答: "这是第3个问题"
将会话的上下文信息传递给 GPT, 就可以去结合这些上下文的信息，给予我们比较精确的一个答案
- 这是我们在构造一个聊天机器人的时候和前面测试所不一样的，需要我们注意的地方
- 但是在这里，其实就会有一个问题就是token的问题。
- GPT它的模型对于 token 是有限制的
如果我们一轮轮会话的叠加，最终我们的token, 一定会超过模型它本身的token
- 所以在上下文的管理类里面，我们这里是需要去进行处理
上述问题如何处理？
- 方案一就是保留最近一轮的会话轮数，比如只保留最近五轮
  - 对于历史的消息，不再保存，不再发送给GPT这样，可以达到小于指定token数量的目的
  - 但是当我们一轮的消息比较长的话，也有可能会超过token的阈值
- 方案二，就是在方案一的基础之上，我们不再以单纯会话的轮数去做一个迭代
  - 这里，根据计算后的token的数量，去进行判断
  - 如果小于模型的 max_token，我们就保留相关的这些会话
  - 如果大于，我们就要去做相关消息的一个删减
- 目前并未实现，可在上述 ChatContextHolder.java 类中进行实现