ʲô£¿Ä㻹ûÓÐ×Ô¼ºµÄChatGPT£¿´î½¨ChatGPTʹÓÃDDDÁìÓò˼Ïë¶Ô½Ó¹«ÖںŽ»»¥

curl -fsSL https://jpom.top/docs/install.sh | bash -s Server jdk+mvn+node+default

# ÏÂÔز¢°²×°DockerËùÐèÒªµÄÈí¼þ°ü
sudo yum install -y yum-utils
# Ìí¼ÓDocker¹Ù·½µÄyum²Ö¿âµØÖ·
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# ÉèÖð¢ÀïÔƾµÏñµÄyum²Ö¿âµØÖ·
sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# ¸üÐÂyum»º´æ
sudo yum makecache fast
# °²×°Ð°æDocker
sudo yum install -y docker-ce docker-ce-cli containerd.io

curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

ĬÈÏ·¾¶£º/usr/java/xxxx

°æ±¾£º1.8

À´Ô´£ºhttps://mirrors.tuna.tsinghua.edu.cn/Adoptium/

curl -fsSL https://jpom.top/docs/install.sh | bash -s Server jdk+only-module+default

#gcc°²×°£¬nginxÔ´Âë±àÒëÐèÒª
yum install -y gcc-c++

#PCRE pcre-devel °²×°£¬nginx µÄ http Ä£¿éʹÓà pcre À´½âÎöÕýÔò±í´ïʽ
yum install -y pcre pcre-devel

#zlib°²×°£¬nginx ʹÓÃzlib¶Ôhttp°üµÄÄÚÈݽøÐÐgzip
yum install -y zlib zlib-devel

#OpenSSL °²×°£¬Ç¿´óµÄ°²È«Ì×½Ó×Ö²ãÃÜÂë¿â£¬nginx ²»½öÖ§³Ö http ЭÒ飬»¹Ö§³Ö https£¨¼´ÔÚsslЭÒéÉÏ´«Êähttp£©
yum install -y openssl openssl-devel

mkdir -p /usr/local/nginx && cd /usr/local/nginx
#ÏÂÔØ°æ±¾ºÅ¿É¸ù¾ÝÄ¿Ç°¹ÙÍø×îÐÂÎȶ¨°æ×ÔÐе÷Õû
wget -O nginx-1.20.2.tar.gz https://nginx.org/download/nginx-1.20.2.tar.gz

#¸ùĿ¼ʹÓÃlsÃüÁî¿ÉÒÔ¿´µ½ÏÂÔصÄnginxѹËõ°ü£¬È»ºó½âѹ
tar -zxvf nginx-1.20.2.tar.gz

#½âѹºó½øÈëĿ¼
cd nginx-1.20.2

#ʹÓÃĬÈÏÅäÖÃ
./configure

# ±àÒë°²×°
make
make install

# Æô¶¯nginx
cd /usr/local/nginx
./sbin/nginx

 "registry-mirrors": [
    "https://xv6jnj6e.mirror.aliyuncs.com"
]

{
  "bind": "0.0.0.0:8181",
  "tls": {
    "enabled": false,
    "cert_file": "",
    "key_file": ""
  },
  "timeout": 600,
  "proxy_url": "",
  "license_id": "·Ç³£ÖØÒª",
  "public_share": false,
  "site_password": "ÄãµÄÍøÒ³·ÃÎÊÃÜÂë",
  "setup_password": "¹ÜÀíÅäÖõÄÃÜÂë",
  "server_tokens": true,
  "proxy_api_prefix": "prox api ÇëÇóǰ׺",
  "isolated_conv_title": "*",
  "disable_signup": false,
  "auto_conv_arkose": false,
  "proxy_file_service": true,
  "custom_doh_host": "",
  "captcha": {
    "provider": "",
    "site_key": "",
    "site_secret": "",
    "site_login": false,
    "setup_login": false,
    "oai_username": false,
    "oai_password": false,
    "oai_signup": false
  },
  "whitelist": null
}

  "license_id": "Ç°ÃæµÄÐí¿ÉÖ¤",
  "site_password": "yangbuyiya123",
  "setup_password": "yangbuyiya123",
  "proxy_api_prefix": "yangbuyiya123",

{
  "token1": {
    // ÕâÀïÖ§³Ö¶àÖÖtoken»¹Ö§³ÖÕ˺ÅÃÜÂëÊÚȨ(ÍƼöÕ˺ÅÃÜÂë) ±ÈÈç "token": "ÄãµÄÕ˺Å&ÃÜÂë"
    "token": "access token / session token / refresh token / share token / username & password",
    "password": "12345"
  }
}

docker pull pengzhile/pandora-next

docker run -d --restart always --name PandoraNext --net=bridge \
            -p 8181:8181 \
            -v ./data:/data \
            -v ./sessions:/root/.cache/PandoraNext \
            pengzhile/pandora-next

curl http://·þÎñÆ÷IP:8181/yangbuyiya123/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
     "model": "gpt-3.5-turbo",
     "messages": [{"role": "user", "content": "Say this is a test!"}],
     "temperature": 0.7
   }'

curl http://·þÎñÆ÷IP:8181/yangbuyiya123/api/auth/login' \
    -H 'Content-Type: application/x-www-form-urlencoded' \
    -d 'username=user%40mail.com' \
    -d 'password=abc123'

curl 'http://127.0.0.1:8181/yangbuyi123/api/token/register' \
    -H 'Content-Type: application/x-www-form-urlencoded' \
    -d 'unique_name=abcdefg' \
    -d 'access_token=eyxxxx' \
    -d 'site_limit=https%3A%2F%2Fchat.oaifree.com' \
    -d 'expires_in=0' \
    -d 'show_conversations=false' \
    -d 'show_userinfo=false'

<!-- https://mvnrepository.com/artifact/com.squareup.okhttp3/okhttp -->
<dependency>
  <groupId>com.squareup.okhttp3</groupId>
  <artifactId>okhttp</artifactId>
  <version>4.12.0</version>
</dependency>
<dependency>
  <groupId>com.squareup.okhttp3</groupId>
  <artifactId>logging-interceptor</artifactId>
  <version>4.12.0</version>
</dependency>

/**
 * µ¥Ôª²âÊÔ
 */
@SpringBootTest
class Yby6PandoraChatGptApplicationTests {

    @Test
    void testApi() throws IOException {
        // ÈÕÖ¾ÅäÖÃ
        HttpLoggingInterceptor httpLoggingInterceptor = new HttpLoggingInterceptor();
        httpLoggingInterceptor.setLevel(HttpLoggingInterceptor.Level.HEADERS);

        // ½¨ÔìÇëokhttp¿Í»§¶Ë
        OkHttpClient client = new OkHttpClient().newBuilder()
        .addInterceptor(httpLoggingInterceptor)
        .build();
        MediaType mediaType = MediaType.parse("application/json");
        String req = "{\n" +
        "    \"model\": \"gpt-3.5-turbo\",\n" +
        "    \"messages\": [\n" +
        "        {\n" +
        "            \"role\": \"user\",\n" +
        "            \"content\": \"ÄãºÃѽ,ÎÒÊÇÑî²»Ò×ѽ\"\n" +
        "        }\n" +
        "    ],\n" +
        "    \"temperature\": 0.7,\n" +
        "    \"stream\": false\n" +
        "}";
        RequestBody body = RequestBody.create(req, mediaType);
        Request request = new Request.Builder()
        .url("http://IP:8181/ǰ׺/v1/chat/completions")
        .method("POST", body)
        .addHeader("Authorization", "Bearer FK token")
        .addHeader("Content-Type", "application/json")
        .addHeader("Accept", "*/*")
        .addHeader("Host", "IP:8181")
        .addHeader("Connection", "keep-alive")
        .build();
        Response response = client.newCall(request).execute();
        System.out.println(response.body().string());
    }

}

{
    "id": "chatcmpl-OtyWJeU0gQBFhfyA5XHHv37wRLyNx",
    "object": "chat.completion",
    "created": 1705425154,
    "model": "gpt-3.5-turbo",
    "usage": {
        "prompt_tokens": 0,
        "completion_tokens": 0,
        "total_tokens": 0
    },
    "choices": [
        {
            "message": {
                "role": "assistant",
                "content": "ÄãºÃÑî²»Ò×£¡ÓÐʲôÎÒ¿ÉÒÔ°ïÖúÄãµÄÂð£¿"
            },
            "finish_reason": "stop",
            "index": 0
        }
    ]
}

package com.yby6.yby6pandorachatgpt;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * ../
 *
 * @author Yang Shuai
 * Create By 2024/01/17
 */
@Data
public class ChatGPTResponse {

    /**
     * Éí·ÝÖ¤¼þ
     */
    @JsonProperty("id")
    private String id;
    /**
     * ¶ÔÏó
     */
    @JsonProperty("object")
    private String object;
    /**
     * ´´½¨
     */
    @JsonProperty("created")
    private Integer created;
    /**
     * Ä£ÐÍ
     */
    @JsonProperty("model")
    private String model;
    /**
     * tokenÓÃÁ¿
     */
    @JsonProperty("usage")
    private UsageDTO usage;

    /**
     * »Ø¸´ÐÅÏ¢
     */
    @JsonProperty("choices")
    private List<ChoicesDTO> choices;


    @NoArgsConstructor
    @Data
    public static class UsageDTO {
        @JsonProperty("prompt_tokens")
        private Integer promptTokens;
        @JsonProperty("completion_tokens")
        private Integer completionTokens;
        @JsonProperty("total_tokens")
        private Integer totalTokens;
    }

    @NoArgsConstructor
    @Data
    public static class ChoicesDTO {
        @JsonProperty("message")
        private MessageDTO message;
        @JsonProperty("finish_reason")
        private String finishReason;
        @JsonProperty("index")
        private Integer index;

        @NoArgsConstructor
        @Data
        public static class MessageDTO {
            @JsonProperty("role")
            private String role;
            @JsonProperty("content")
            private String content;
        }
    }
}

<!--    Ç¿´óµÄJava¹¤¾ß¿â -->
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.25</version>
</dependency>

# ΢ÐŹ«ÖÚºÅÅäÖÃÐÅÏ¢
wx:
  config:
    originalid: ÄãµÄԭʼID
    token: token

package com.yby6.yby6pandorachatgpt.infrastructure.util.wechat;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * ΢ÐÅÇ©Ãûutil
 *
 * @author Yang Shuai
 * Create By 2024/01/13
 */
public class WechatSignatureUtil {

    private static final Logger logger = LoggerFactory.getLogger(WechatSignatureUtil.class);


    /**
     * Ñé֤ǩÃû
     */
    public static boolean check(String token, String signature, String timestamp, String nonce) {
        String[] arr = new String[]{token, timestamp, nonce};
        // ½«token¡¢timestamp¡¢nonceÈý¸ö²ÎÊý½øÐÐ×ÖµäÐòÅÅÐò
        sort(arr);
        StringBuilder content = new StringBuilder();
        for (String s : arr) {
            content.append(s);
        }
        MessageDigest md;
        String tmpStr = null;
        try {
            md = MessageDigest.getInstance("SHA-1");
            // ½«Èý¸ö²ÎÊý×Ö·û´®Æ´½Ó³ÉÒ»¸ö×Ö·û´®½øÐÐsha1¼ÓÃÜ
            byte[] digest = md.digest(content.toString().getBytes());
            tmpStr = byteToStr(digest);
        } catch (NoSuchAlgorithmException e) {
            logger.error(e.getMessage());
        }
        // ½«sha1¼ÓÃܺóµÄ×Ö·û´®¿ÉÓësignature¶Ô±È£¬±êʶ¸ÃÇëÇóÀ´Ô´ÓÚ΢ÐÅ
        return tmpStr != null && tmpStr.equals(signature.toUpperCase());
    }

    /**
     * ½«×Ö½ÚÊý×éת»»ÎªÊ®Áù½øÖÆ×Ö·û´®
     */
    private static String byteToStr(byte[] byteArray) {
        StringBuilder strDigest = new StringBuilder();
        for (byte b : byteArray) {
            strDigest.append(byteToHexStr(b));
        }
        return strDigest.toString();
    }

    /**
     * ½«×Ö½Úת»»ÎªÊ®Áù½øÖÆ×Ö·û´®
     */
    private static String byteToHexStr(byte mByte) {
        char[] Digit = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
        char[] tempArr = new char[2];
        tempArr[0] = Digit[(mByte >>> 4) & 0X0F];
        tempArr[1] = Digit[mByte & 0X0F];
        return new String(tempArr);
    }

    /**
     * ½øÐÐ×ÖµäÅÅÐò
     */
    private static void sort(String[] str) {
        for (int i = 0; i < str.length - 1; i++) {
            for (int j = i + 1; j < str.length; j++) {
                if (str[j].compareTo(str[i]) < 0) {
                    String temp = str[i];
                    str[i] = str[j];
                    str[j] = temp;
                }
            }
        }
    }
}

# ΢ÐŹ«ÖÚºÅÅäÖÃÐÅÏ¢
wx:
config:
originalid: ԭʼID 
token: ·þÎñÆ÷ÅäÖÃÀïÃæµÄtoken ¸Õ¸ÕÉèÖõÄà»

package com.yby6.yby6pandorachatgpt.interfaces;

import com.yby6.yby6pandorachatgpt.infrastructure.util.wechat.WechatSignatureUtil;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author Yang Shuai
 * Create By 2024/1/18
 */
@RestController
@RequestMapping("/chat-api/wx/portal")
public class WechatController {

    private final Logger logger = LoggerFactory.getLogger(WechatController.class);

    // ·þÎñÆ÷ Token 
    @Value("${wx.config.token}")
    private String token;

    /**
     * ´¦Àí΢ÐÅ·þÎñÆ÷·¢À´µÄgetÇëÇ󣬽øÐÐÇ©ÃûµÄÑéÖ¤
     *
     * <p>
     * appid     ΢ÐŶËAppID
     * signature ΢ÐŶ˷¢À´µÄÇ©Ãû
     * timestamp ΢ÐŶ˷¢À´µÄʱ¼ä´Á
     * nonce     ΢ÐŶ˷¢À´µÄËæ»ú×Ö·û´®
     * echostr   ΢ÐŶ˷¢À´µÄÑéÖ¤×Ö·û´®
     */
    @GetMapping(produces = "text/plain;charset=utf-8")
    public String validate(
            @RequestParam(value = "signature", required = false) String signature,
            @RequestParam(value = "timestamp", required = false) String timestamp,
            @RequestParam(value = "nonce", required = false) String nonce,
            @RequestParam(value = "echostr", required = false) String echostr) {
        try {
            logger.info("΢ÐŹ«ÖÚºÅÑéÇ©ÐÅÏ¢{}¿ªÊ¼ [{}, {}, {}]", signature, timestamp, nonce, echostr);
            if (StringUtils.isAnyBlank(signature, timestamp, nonce, echostr)) {
                throw new IllegalArgumentException("ÇëÇó²ÎÊý·Ç·¨£¬ÇëºËʵ!");
            }
            boolean check = WechatSignatureUtil.check(token, signature, timestamp, nonce);
            logger.info("΢ÐŹ«ÖÚºÅÑéÇ©: {}", check);
            if (!check) {
                return null;
            }
            return echostr;
        } catch (Exception e) {
            logger.error("΢ÐŹ«ÖÚºÅÑéÇ©ÐÅÏ¢{}ʧ°Ü [{}, {}, {}]", signature, timestamp, nonce, echostr, e);
            return null;
        }
    }

}

/**
 * ´Ë´¦ÊÇ´¦Àí΢ÐÅ·þÎñÆ÷µÄÏûϢת·¢µÄ
 */
@PostMapping(produces = "application/xml; charset=UTF-8")
public String post(@RequestBody String requestBody) {

    logger.info("½ÓÊÕ²ÎÊý:{}", requestBody);

    return "ÕýÔÚ¿ª·¢ÖÐ....";
}

<!-- ¶Ô½Ó΢ÐŹ«Öںţ¬ÐèÒª½âÎöxml -->
<!-- https://mvnrepository.com/artifact/com.thoughtworks.xstream/xstream -->
<dependency>
    <groupId>com.thoughtworks.xstream</groupId>
    <artifactId>xstream</artifactId>
    <version>1.4.20</version>
</dependency>

package com.yby6.yby6pandorachatgpt.domain.wechat;

import com.thoughtworks.xstream.annotations.XStreamAlias;
import lombok.Getter;

/**
 * »Ø¸´ÏûÏ¢Îı¾ÊµÌå
 *
 * @author Yang Shuai
 * Create By 2024/01/18
 */
@Getter
public class MessageTextEntity {

    @XStreamAlias("MsgId")
    private String msgId;
    @XStreamAlias("ToUserName")
    private String toUserName;
    @XStreamAlias("FromUserName")
    private String fromUserName;
    @XStreamAlias("CreateTime")
    private String createTime;
    @XStreamAlias("MsgType")
    private String msgType;
    @XStreamAlias("Content")
    private String content;
    @XStreamAlias("Event")
    private String event;
    @XStreamAlias("EventKey")
    private String eventKey;

    public MessageTextEntity() {
    }

    public void setMsgId(String msgId) {
        this.msgId = msgId;
    }

    public void setToUserName(String toUserName) {
        this.toUserName = toUserName;
    }

    public void setFromUserName(String fromUserName) {
        this.fromUserName = fromUserName;
    }

    public void setCreateTime(String createTime) {
        this.createTime = createTime;
    }

    public void setMsgType(String msgType) {
        this.msgType = msgType;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public void setEvent(String event) {
        this.event = event;
    }

    public void setEventKey(String eventKey) {
        this.eventKey = eventKey;
    }
}

package com.yby6.yby6pandorachatgpt.infrastructure.util.wechat;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.core.util.QuickWriter;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import com.thoughtworks.xstream.io.xml.DomDriver;
import com.thoughtworks.xstream.io.xml.PrettyPrintWriter;
import com.thoughtworks.xstream.io.xml.XppDriver;
import org.apache.commons.lang3.StringUtils;

import java.io.Writer;

/**
 * XmlUtil
 *
 * @author yangbuyiya
 * Create By 2024/01/18
 */
public class XmlUtil {

    /**
     * xstreamÀ©Õ¹,beanתxml×Ô¶¯¼ÓÉÏ![CDATA[]]
     */
    public static XStream getMyXStream() {
        return new XStream(new XppDriver() {
            @Override
            public HierarchicalStreamWriter createWriter(Writer out) {
                return new PrettyPrintWriter(out) {
                    // ¶ÔËùÓÐxml½Úµã¶¼Ôö¼ÓCDATA±ê¼Ç
                    final boolean cdata = true;

                    @Override
                    public void startNode(String name, Class clazz) {
                        super.startNode(name, clazz);
                    }

                    @Override
                    protected void writeText(QuickWriter writer, String text) {
                        if (cdata && !StringUtils.isNumeric(text)) {
                            writer.write("<![CDATA[");
                            writer.write(text);
                            writer.write("]]>");
                        } else {
                            writer.write(text);
                        }
                    }
                };
            }
        });
    }

    /**
     * beanת³É΢ÐŵÄxmlÏûÏ¢¸ñʽ
     */
    public static String beanToXml(Object object) {
        XStream xStream = getMyXStream();
        xStream.alias("xml", object.getClass());
        xStream.processAnnotations(object.getClass());
        String xml = xStream.toXML(object);
        if (!StringUtils.isEmpty(xml)) {
            return xml;
        } else {
            return null;
        }
    }

    /**
     * xmlת³Ébean·ºÐÍ·½·¨
     */
    public static <T> T xmlToBean(String resultXml, Class clazz) {
        // XStream¶ÔÏóÉèÖÃĬÈÏ°²È«·À»¤£¬Í¬Ê±ÉèÖÃÔÊÐíµÄÀà
        XStream stream = new XStream(new DomDriver());
        XStream.setupDefaultSecurity(stream);
        stream.allowTypes(new Class[]{clazz});
        stream.processAnnotations(new Class[]{clazz});
        stream.setMode(XStream.NO_REFERENCES);
        stream.alias("xml", clazz);
        return (T) stream.fromXML(resultXml);
    }

}

logger.info("½ÓÊÕ²ÎÊý:{}", requestBody);
MessageTextEntity messageTextEntity = XmlUtil.xmlToBean(requestBody, MessageTextEntity.class);
logger.info("½âÎöXMLÊý¾Ý:{}", messageTextEntity);

@PostMapping(produces = "application/xml; charset=UTF-8")
public String post(@RequestBody String requestBody) {

    logger.info("½ÓÊÕ²ÎÊý:{}", requestBody);
    MessageTextEntity messageTextEntity = XmlUtil.xmlToBean(requestBody, MessageTextEntity.class);
    logger.info("½âÎöXMLÊý¾Ý:{}", messageTextEntity);

    // ×é×°Îı¾»Ø¸´
    MessageTextEntity res = new MessageTextEntity();
    // ½ÓÊÕ·½Õ˺ţ¨ÊÕµ½µÄOpenID£© ¾ÍÊǽӳöÀ´µÄ FromUserName Õâ¸öÊǽÓÊÕ·½µÄopenid
    res.setToUserName(messageTextEntity.getFromUserName());
    // 	¿ª·¢Õß΢ÐźŠ ¾ÍÊǽâÎö³öÀ´µÄ ToUserName Õâ¸öÊÇ¿ª·¢Õß΢ÐźÅ(ԭʼID)
    //  µ«ÊÇΪÁË°²È«,ÎÒÃÇʹÓÃÎÒÃÇ×Ô¼ºÅäÖÃÎļþµ±ÖеÄԭʼID
    res.setFromUserName(originalId);
    // ÏûÏ¢´´½¨Ê±¼ä £¨ÕûÐÍ£©
    res.setCreateTime(String.valueOf(System.currentTimeMillis() / 1000L));
    // ÏûÏ¢ÀàÐÍ£¬Îı¾Îªtext
    res.setMsgType("text");
    // »Ø¸´µÄÏûÏ¢ÄÚÈÝ£¨»»ÐУºÔÚcontentÖÐÄܹ»»»ÐУ¬Î¢ÐÅ¿Í»§¶Ë¾ÍÖ§³Ö»»ÐÐÏÔʾ£©
    res.setContent("¸ÉÂï¸ÉÂï!!!!");
    String result = XmlUtil.beanToXml(res);
    logger.info("½ÓÊÕ΢ÐŹ«ÖÚºÅÐÅÏ¢ÇëÇóÍê³É {}, openid:{}", result, messageTextEntity.getFromUserName());

    return result;
}

 OkHttpClient client = new OkHttpClient().newBuilder().build();

/**
 * OpenAI»á»°¹¤³§
 *
 * @author yangs
 * @date 2024/01/18
 */
public interface OpenAiSessionFactory {

    /**
     * ¿ªÆô»á»°
     *
     * @return {@link OpenAiSession}
     */
    OpenAiSession openSession();

}

package com.yby6.yby6pandorachatgpt.domain.chatgpt;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.*;
import lombok.extern.slf4j.Slf4j;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

/**
 * ½¨ÔìÕßģʽ ¹¹½¨ÇëÇóÐÅÏ¢
 * ÇëÇóÐÅÏ¢ÒÀÕÕ£»OpenAI¹ÙÍøAPI¹¹½¨²ÎÊý£»<a href="https://platform.openai.com/playground">...</a>
 *
 * @author yangs
 * @date 2024/01/18
 */
@Data
@Builder
@Slf4j
@JsonInclude(JsonInclude.Include.NON_NULL)
@NoArgsConstructor
@AllArgsConstructor
public class ChatGPTRequest implements Serializable {

    /**
     * ĬÈÏÄ£ÐÍ
     */
    private String model = Model.GPT_3_5_TURBO.getCode();
    /**
     * ÎÊÌâÃèÊö
     */
    private List<ChatGPTResponse.ChoicesDTO.MessageDTO> messages;
    /**
     * ¿ØÖÆζȡ¾Ëæ»úÐÔ¡¿£»0µ½2Ö®¼ä¡£½Ï¸ßµÄÖµ(Èç0.8)½«Ê¹Êä³ö¸ü¼ÓËæ»ú£¬¶ø½ÏµÍµÄÖµ(Èç0.2)½«Ê¹Êä³ö¸ü¼Ó¼¯ÖкÍÈ·¶¨
     */
    private double temperature = 0.2;
    /**
     * ¶àÑùÐÔ¿ØÖÆ£»Ê¹ÓÃζȲÉÑùµÄÌæ´ú·½·¨³ÆΪºËÐIJÉÑù£¬ÆäÖÐÄ£ÐÍ¿¼ÂǾßÓÐtop_p¸ÅÂÊÖÊÁ¿µÄÁîÅƵĽá¹û¡£Òò´Ë£¬0.1 Òâζ×ÅÖ»¿¼ÂÇ°üº¬Ç° 10% ¸ÅÂÊÖÊÁ¿µÄ´ú±Ò
     */
    @JsonProperty("top_p")
    private Double topP = 1d;
    /**
     * Ϊÿ¸öÌáʾÉú³ÉµÄÍê³É´ÎÊý
     */
    private Integer n = 1;
    /**
     * ÊÇ·ñΪÁ÷ʽÊä³ö£»¾ÍÊÇÒ»±ÄÒ»±ÄµÄ£¬³öÀ´½á¹û
     */
    private boolean stream = false;
    /**
     * Í£Ö¹Êä³ö±êʶ
     */
    private List<String> stop;
    /**
     * Êä³ö×Ö·û´®ÏÞÖÆ£»0 ~ 4096
     */
    @JsonProperty("max_tokens")
    private Integer maxTokens = 2048;
    /**
     * ƵÂʳͷ££»½µµÍÄ£ÐÍÖظ´Í¬Ò»ÐеĿÉÄÜÐÔ
     */
    @JsonProperty("frequency_penalty")
    private double frequencyPenalty = 0;
    /**
     * ´æÔڳͷ££»ÔöÇ¿Ä£ÐÍ̸ÂÛл°ÌâµÄ¿ÉÄÜÐÔ
     */
    @JsonProperty("presence_penalty")
    private double presencePenalty = 0;
    /**
     * Éú³É¶à¸öµ÷Óýá¹û£¬Ö»ÏÔʾ×î¼ÑµÄ¡£ÕâÑù»á¸ü¶àµÄÏûºÄÄãµÄ api token
     */
    @JsonProperty("logit_bias")
    private Map logitBias;
    /**
     * µ÷Óñêʶ£¬±ÜÃâÖظ´µ÷ÓÃ
     */
    private String user;

    @Getter
    @AllArgsConstructor
    public enum Model {
        /**
         * gpt-3.5-turbo
         */
        GPT_3_5_TURBO("gpt-3.5-turbo"),
        /**
         * GPT4.0
         */
        GPT_4("gpt-4"),
        /**
         * GPT4.0 ³¬³¤ÉÏÏÂÎÄ
         */
        GPT_4_32K("gpt-4-32k"),
        ;
        private final String code;
    }

}

package com.yby6.yby6pandorachatgpt.session;


import com.yby6.yby6pandorachatgpt.domain.chatgpt.ChatGPTRequest;
import com.yby6.yby6pandorachatgpt.domain.chatgpt.ChatGPTResponse;

/**
 * OpenAi »á»°½Ó¿Ú
 *
 * @author yangs
 * @date 2024/01/11
 */
public interface OpenAiSession {

    /**
     * ĬÈÏ GPT-3.5 ÎÊ´ðÄ£ÐÍ
     *
     * @param chatGPTRequest ÇëÇóÐÅÏ¢
     * @return ·µ»Ø½á¹û
     */
    ChatGPTResponse completions(ChatGPTRequest chatGPTRequest);

}

package com.yby6.yby6pandorachatgpt.infrastructure.interceptor;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.http.ContentType;
import cn.hutool.http.Header;
import okhttp3.HttpUrl;
import okhttp3.Interceptor;
import okhttp3.Request;
import okhttp3.Response;
import org.jetbrains.annotations.NotNull;

import java.io.IOException;

/**
 * ×Ô¶¨Òå OpenAI À¹½ØÆ÷
 *
 * @author yangs
 * @date 2024/01/18
 */
public class OpenAiInterceptor implements Interceptor {

    /**
     * OpenAi apiKey ÐèÒªÔÚ¹ÙÍøÉêÇë
     */
    private final String apiKey;

    public OpenAiInterceptor(String apiKey) {
        this.apiKey = apiKey;
    }

    /**
     * À¹½ØokhttpÇëÇó
     * @param chain Á´
     * @return ÊÇ·ñ¼ÌÐøÖ´ÐÐ
     */
    @NotNull
    @Override
    public Response intercept(Chain chain) throws IOException {
        return chain.proceed(this.auth(apiKey, chain.request()));
    }

    /**
     * ¹¹½¨ÈÏÖ¤ÇëÇó¶ÔÏó
     *
     * @param apiKey   apiÃÜÔ¿
     * @param original Æð³õ
     * @return {@link Request}
     */
    private Request auth(String apiKey, Request original) {
        HttpUrl.Builder builder = original.url().newBuilder();
        // ¹¹½¨ÐµÄÇëÇóµØÖ·
        HttpUrl url = builder.build();
        // ´´½¨ÇëÇó
        return original.newBuilder()
        .url(url.url())
        .header(Header.AUTHORIZATION.getValue(), "Bearer " + apiKey)
        .header(Header.CONTENT_TYPE.getValue(), ContentType.JSON.getValue())
        .method(original.method(), original.body())
        .build();
    }

}

<!--   http api ת Java ½Ó¿Ú     -->
<dependency>
    <groupId>com.squareup.retrofit2</groupId>
    <artifactId>retrofit</artifactId>
    <version>2.9.0</version>
</dependency>
<!--   ÐòÁл¯Óà     -->
<dependency>
  <groupId>com.squareup.retrofit2</groupId>
  <artifactId>converter-jackson</artifactId>
  <version>2.9.0</version>
</dependency>
<dependency>
  <groupId>com.squareup.retrofit2</groupId>
  <artifactId>adapter-rxjava2</artifactId>
  <version>2.9.0</version>
</dependency>

/**
 * ChatGPT ÇëÇó½Ó¿Ú API
 * ¹ÙÍø£º<a href="https://platform.openai.com/playground">...</a>
 *
 * @author Yang Shuai
 * Create By 2024/1/19
 */
public interface OpenAiService {

    /**
     * ĬÈÏ GPT-3.5 ÎÊ´ðÄ£ÐÍ
     *
     * @param chatGPTRequest ÇëÇóÐÅÏ¢
     * @return ·µ»Ø½á¹û
     */
    @POST("v1/chat/completions")
    Call<ChatGPTResponse> completions(@Body ChatGPTRequest chatGPTRequest);


}

/**
 * ¿ªÆô»á»°
 *
 * @return {@link OpenAiSession}
 */
@Override
public OpenAiSession openSession() {
    // 1. ÈÕÖ¾ÅäÖÃ
    HttpLoggingInterceptor httpLoggingInterceptor = new HttpLoggingInterceptor();
    httpLoggingInterceptor.setLevel(HttpLoggingInterceptor.Level.NONE);
    logger.info("OpenAi API Client Start");
    // 2. ¿ªÆô Http ¿Í»§¶Ë
    OkHttpClient okHttpClient = new OkHttpClient
    .Builder()
    .addInterceptor(httpLoggingInterceptor)
    .addInterceptor(new OpenAiInterceptor("ÄãµÄapi key"))
    .connectTimeout(450, TimeUnit.SECONDS)
    .writeTimeout(450, TimeUnit.SECONDS)
    .readTimeout(450, TimeUnit.SECONDS)
    .build();

    // 3. ´´½¨ API ·þÎñ
    final Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("IP") // ÄãµÄÅ˶àÀ­·ÃÎÊIP
    .client(okHttpClient)
    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
    .addConverterFactory(JacksonConverterFactory.create())
    .build();
    // ´´½¨¶ÔÓ¦ÇëÇó API
    final OpenAiService openAiService = retrofit.create(OpenAiService.class);

    // ´«µÝ¸øĬÈÏʵÏÖ½øÐд¥·¢ÇëÇóµ÷ÓÃ
    return new DefaultOpenAiSession(openAiService);
}

/**
 * ĬÈ쵀 OpenAI »á»°ÊµÏÖOpenAiSession
 *
 * @author Yang Shuai
 * Create By 2024/1/19
 */
@RequiredArgsConstructor
public class DefaultOpenAiSession implements OpenAiSession {

    private final OpenAiService openAiService;

    /**
     * ĬÈÏ GPT-3.5 ÎÊ´ðÄ£ÐÍ
     *
     * @param chatGPTRequest ÇëÇóÐÅÏ¢
     * @return ·µ»Ø½á¹û
     */
    @Override
    public ChatGPTResponse completions(ChatGPTRequest chatGPTRequest) throws IOException {
        return openAiService.completions(chatGPTRequest).execute().body();
    }
}

/**
 * @author Yang Shuai
 * {@code @create} 2024/1/16:17:48
 * {@code @desc} |
 **/
@Configuration
@RequiredArgsConstructor
public class initializeOpenAISession {
    private final Logger logger = LoggerFactory.getLogger(initializeOpenAISession.class);

    /**
     * ³õʼ»¯»á»°¹¤³§
     */
    @Bean("openAiSession")
    public OpenAiSession openAiSession() {
        logger.info("³õʼ»¯ÇëÇóÅäÖÃÎļþ");
        // 2. »á»°¹¤³§
        OpenAiSessionFactory factory = new DefaultOpenAiSessionFactory();
        // 3. ¿ªÆô»á»°
        logger.info("¿ªÆô»á»° openAiSession");
        return factory.openSession();
    }

}

@NoArgsConstructor
@Data
public static class MessageDTO {
    @JsonProperty("role")
    private String role;
    @JsonProperty("content")
    private String content;

    /**
     * ¹¹ÔìÆ÷ ¹¹½¨½ÇÉ«¡¢ÄÚÈÝ
     */
    private MessageDTO(MessageDTO.Builder builder) {
        this.role = builder.role;
        this.content = builder.content;
    }

    public static MessageDTO.Builder builder() {
        return new MessageDTO.Builder();
    }

    /**
     * ½¨ÔìÕßģʽ
     */
    public static final class Builder {

        private String role;
        private String content;

        public Builder() {
        }

        public MessageDTO.Builder role(Constants.Role role) {
            this.role = role.getCode();
            return this;
        }

        public MessageDTO.Builder content(String content) {
            this.content = content;
            return this;
        }


        public MessageDTO build() {
            return new MessageDTO(this);
        }
    }


}

/**
 * ¹«Óûù´¡ÓöÔÏó
 */
public class Constants {

    /**
     * ½ÇÉ«
     * ¹ÙÍøÖ§³ÖµÄÇëÇó½ÇÉ«ÀàÐÍ£»system¡¢user¡¢assistant
     * <a href="https://platform.openai.com/docs/guides/chat/introduction">...</a>
     */
    @Getter
    public enum Role {

        /**
         * ϵͳ
         */
        SYSTEM("system"),
        /**
         * ʹÓÃÕß
         */
        USER("user"),
        /**
         * ÖúÀí
         */
        ASSISTANT("assistant"),
        ;

        /**
         * ÃÜÂë
         */
        private final String code;

        /**
         * ½ÇÉ«
         *
         * @param code ÃÜÂë
         */
        Role(String code) {
            this.code = code;
        }

    }

}