最近OpenAI开放了函数功能，这个功能可太有意思了，相当于开放了自定义的插件。以前就想用ChatGPT实现自己的知识库，但是按照原有的使用对话分词–> Lucene搜索–> GPT总结，有个缺陷是很难使用聊天的方式进行搜索，因为聊天有很多无效的词。

现在，有了这个功能感觉更方便来实现了。先用函数来分析是用户表达的搜索意愿是什么，然后根据搜索意愿去搜索引擎中查找，最后使用GPT总结，可以更精准的实现个人知识库总结。

由于是边写代码边发文章，所以会分成几天来发，正好假期在家没什么事。

在最后一天把代码开源。

创建项目

start.spring.io/

项目使用JDK17、Maven、SpringBoot3.0.6。

<?xml version="1.0" encoding="UTF-8"?>  
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">  
    <modelVersion>4.0.0</modelVersion>  
    <parent>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-parent</artifactId>  
        <version>3.0.6</version>  
        <relativePath/> <!-- lookup parent from repository -->  
    </parent>  
    <groupId>com.lgf</groupId>  
    <artifactId>warehouse</artifactId>  
    <version>0.0.1-SNAPSHOT</version>  
    <name>warehouse</name>  
    <description>ChatGPT+Lucene</description>  
    <properties>  
        <java.version>17</java.version>  
        <jda.version>5.0.0-beta.9</jda.version>  
        <dataurl.version>2.0.0</dataurl.version>  
        <retrofit2.version>2.9.0</retrofit2.version>  
    </properties>  
    <dependencies>  
        <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter</artifactId>  
        </dependency>  


        <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-test</artifactId>  
            <scope>test</scope>  
        </dependency>  

        <dependency>  
            <groupId>org.projectlombok</groupId>  
            <artifactId>lombok</artifactId>  
        </dependency>  
        <dependency>  
            <groupId>cn.hutool</groupId>  
            <artifactId>hutool-all</artifactId>  
            <version>5.8.16</version>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.poi</groupId>  
            <artifactId>poi-ooxml</artifactId>  
            <version>4.1.2</version>  
        </dependency>  
        <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-web</artifactId>  
        </dependency>  
        <!-- swagger -->  
        <dependency>  
            <groupId>org.springdoc</groupId>  
            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>  
            <version>2.0.2</version>  
        </dependency>  

        <dependency>  
            <groupId>org.springdoc</groupId>  
            <artifactId>springdoc-openapi-starter-webmvc-api</artifactId>  
            <version>2.0.2</version>  
        </dependency>  



        <!-- ChatGPT支持 -->  
        <dependency>  
            <groupId>com.squareup.okhttp3</groupId>  
            <artifactId>okhttp-sse</artifactId>  
            <version>3.14.9</version>  
        </dependency>  
        <dependency>  
            <groupId>com.squareup.okhttp3</groupId>  
            <artifactId>logging-interceptor</artifactId>  
            <version>3.14.9</version>  
        </dependency>  

        <dependency>  
            <groupId>org.jetbrains</groupId>  
            <artifactId>annotations</artifactId>  
            <version>RELEASE</version>  
            <scope>compile</scope>  
        </dependency>  
        <dependency>  
            <groupId>com.knuddels</groupId>  
            <artifactId>jtokkit</artifactId>  
            <version>0.5.0</version>  
        </dependency>  

        <dependency>  
            <groupId>com.squareup.retrofit2</groupId>  
            <artifactId>retrofit</artifactId>  
            <version>${retrofit2.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>com.squareup.retrofit2</groupId>  
            <artifactId>converter-jackson</artifactId>  
            <version>${retrofit2.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>com.squareup.retrofit2</groupId>  
            <artifactId>adapter-rxjava2</artifactId>  
            <version>${retrofit2.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>junit</groupId>  
            <artifactId>junit</artifactId>  
            <version>4.12</version>  
        <scope>test</scope>  
        </dependency>  
    </dependencies>  

    <build>  
        <plugins>  
            <plugin>  
                <groupId>org.springframework.boot</groupId>  
                <artifactId>spring-boot-maven-plugin</artifactId>  
            </plugin>  
        </plugins>  
    </build>  
  
</project>

PS: 掘金的编辑器真不好用，复制进来代码的缩进都没了，还得一点一点调整，真麻烦啊！！！

项目对OpenAI的API操作使用了开源项目github.com/Grt1228/cha… 的包，可以直接使用Maven引用，或者直接使用代码。由于准备在后期修改一些代码，我选择了复制代码。

项目结构说明

在modules中分为ai、lucence、Serve，ai：准备接入OpenAI、Midjourney、SD，其他的以后再说；Lucence：搜索引擎，内嵌到服务中；Serve：对外提供的服务入口；

在ai.openai中包括config、controller、functions、service、utils，除了functions，其他的都在我以前的AIGC-FLOW项目中写过，这次对OpenAI的操作很多也是从AIGC-FLOW项目中复制了出来，之后的Midjourney和SD的操作也会从里面复制代码。

functions是接下来定义函数的包，包含：

package com.lgf.warehouse.modules.ai.openai.functions;  


  


import cn.hutool.json.JSONObject;  
import com.lgf.warehouse.core.chatgpt.entity.chat.Functions;  
import com.lgf.warehouse.core.chatgpt.entity.chat.Parameters;  
  
import java.lang.reflect.Method;  
import java.lang.reflect.Parameter;  
import java.util.ArrayList;  
import java.util.Arrays;  
import java.util.List;  
  

/**  

* 方法服务抽象类  
*/  

public abstract class AbsFunctionService {  

    public abstract List<Functions> getFunctions();  
    public abstract String getFunctionName();


    protected Functions getFunctions(Class cla, String methodName) throws NoSuchMethodException {  
        Method method = cla.getMethod(methodName);  
        FunctionAnnotation methodFun = method.getAnnotation(FunctionAnnotation.class);  
        String description = "";  
        if (methodFun != null) {  
            description = methodFun.describe();  
        }  

        Parameter[] params = method.getParameters();  
        Parameters parameters = this.getParameters(params);  


        Functions functions = Functions.builder()  
            .name(methodName)  
            .description(description)  
            .parameters(parameters)  
            .build();  
        return functions;  
    }  

    /**  
    * 获取参数  
    *  
    * @param parameters  
    * @return  
    */  
    private Parameters getParameters(Parameter[] parameters) {  
        JSONObject params = new JSONObject();  
        List<String> requireds=new ArrayList<>();  
        for (Parameter parameter : parameters) {  
            FunctionAnnotation paramFun = parameter.getAnnotation(FunctionAnnotation.class);  

            JSONObject param = new JSONObject();  
            String type = this.convertParameterToJsonSchemaType(parameter);  
            param.putOpt("type", type);  


            if (paramFun != null) {  
                if(paramFun.required()){  
                    requireds.add(parameter.getName());  
                }  
                if(paramFun.enums().length>0) {  
                    param.putOpt("enum", Arrays.asList(paramFun.enums()));  
                }  
                param.putOpt("description", paramFun.describe());  
            }  
            params.putOpt(parameter.getName(), param);  
        }  
        Parameters result=Parameters.builder()  
            .type("object")  
            .properties(params)  
            .required(requireds)  
            .build();  

        return result;  
    }  

    public String convertParameterToJsonSchemaType(Parameter parameter) {  
        String parameterTypeName = parameter.getType().getSimpleName().toLowerCase();  
        String jsonSchemaType = null;  
        switch (parameterTypeName) {  
            case "string":  
                jsonSchemaType = "string";  
                break;  
            case "boolean":  
                jsonSchemaType = "boolean";  
                break;  
            case "byte":  
            case "short":  
            case "int":  
            case "long":  
            case "float":  
            case "double":  
                jsonSchemaType = "number";  
                break;  
            default:  
                if (parameterTypeName.endsWith("[]")) {  
                    jsonSchemaType = "array";  
                } else {  
                    jsonSchemaType = "object";  
                }  
        }  
        return jsonSchemaType;  
    }  
}

OpenAI API中Parameters定义参数需要按照JSON Schema标准定义，所以使用convertParameterToJsonSchemaType方法将JAVA中的类型转换为符合标准定义的参数类型。

package com.lgf.warehouse.modules.ai.openai.functions;  


  


import java.lang.annotation.ElementType;  
import java.lang.annotation.Retention;  
import java.lang.annotation.RetentionPolicy;  
import java.lang.annotation.Target;  
import java.util.Map;  
  

/**  
* GPT函数的注释  
*/  
@Retention(RetentionPolicy.RUNTIME)  
@Target({ElementType.METHOD,ElementType.PARAMETER})  
public @interface FunctionAnnotation {  

    /**  
    * 描述  
    * @return  
    */  
    public String describe() default "";  

    /**  
    * 枚举数据  
    * @return  
    */  
    public String[] enums() default {};  


    /**  
    * 是否必须  
    * @return  
    */  
    public boolean required() default false;  
}

通过注解的方式，为方法和参数写说明，定义枚举和是否必须。

package com.lgf.warehouse.modules.ai.openai.functions;  


  


import com.lgf.warehouse.core.chatgpt.entity.chat.Functions;  
import com.lgf.warehouse.modules.ai.openai.functions.weather.service.WeatherApiService;  
import jakarta.annotation.PostConstruct;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;  
  

import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
  

/**  

* 方法生产工厂  
*/  

@Service  
public class FunctionFactory {  
    @Autowired  
    private WeatherApiService weatherApiService;  


    // 函数定义集合  
    private Map<String,AbsFunctionService> functionBeanMap;  

    private List<Functions> functions;  

    /**  
    * 注册服务到FunctionFactory  
    */  
    @PostConstruct()  
    public void register(){  
        this.functionBeanMap=new HashMap<>();  
        this.functions=this.weatherApiService.getFunctions();  
        //注册天气服务  
        this.registerFunction(this.weatherApiService);  
    }  

    private void registerFunction(AbsFunctionService functionService){  
        this.functionBeanMap.put(functionService.getFunctionName(),functionService);  
        this.functions.addAll(functionService.getFunctions());  
    }  

    //TODO 定义公共的返回值  
    public Object execute(String functionName,Map<String,Object> params){  
        String[] sp=functionName.split("_");  
        if(sp.length!=2){  
        throw new RuntimeException("方法名称不正确");  
        }  
        String beanName=sp[0];  
        AbsFunctionService functionService=this.functionBeanMap.get(beanName);  
        if(functionService==null){  
        throw new RuntimeException("没有找到对应的方法");  
        }  
        //TODO 执行Bean中的方法  
        return functionService.execute(params);  
    }  


    /**  
    * 获取方法集合  
    * @return  
    */  
    public List<Functions> getFunctions(){  
        return this.functions;  
    }  


}

今天刚开始，写的比较少，留下几个TODO，明天继续。