支持自定义模型

package nexus.io.maxkb.service.kb;

import java.util.ArrayList;
import java.util.List;
import com.jfinal.kit.Kv;
import nexus.io.db.activerecord.Db;
import nexus.io.db.activerecord.Row;

public class ModelCatalogService {

  public List<Kv> providers() {
    return providers(null);
  }

  /**
   * @param modelType 目录中登记的模型类型，可为空；为空时返回全部已启用平台
   */
  public List<Kv> providers(String modelType) {
    String sql = """
        select p.provider,p.name,p.icon from max_kb_model_provider p
        where p.enabled=true
          and (cast(? as text) is null
               or exists (select 1 from jsonb_array_elements(p.model_types) t where t->>'value'=?))
        order by p.sort_order,p.name
        """;
    List<Kv> result = new ArrayList<>();
    for (Row row : Db.find(sql, modelType, modelType)) {
      result.add(row.toKv());
    }
    return result;
  }
}

package nexus.io.maxkb.controller;

import com.alibaba.fastjson2.JSON;
import nexus.io.annotation.Get;
import nexus.io.annotation.Post;
import nexus.io.annotation.Put;
import nexus.io.annotation.RequestPath;
import nexus.io.jfinal.aop.Aop;
import nexus.io.maxkb.service.kb.ModelCatalogService;
import nexus.io.model.result.ResultVo;
import nexus.io.tio.boot.http.TioRequestContext;
import nexus.io.tio.http.common.HttpRequest;

@RequestPath("/api/provider")
public class ApiProviderController {
  private final ModelCatalogService catalog = Aop.get(ModelCatalogService.class);

  @Get("")
  public ResultVo index(String model_type) {
    return ResultVo.ok(catalog.providers(model_type));
  }

  @Get("/model_type_list")
  public ResultVo model_type_list(String provider) {
    return ResultVo.ok(catalog.types(provider));
  }

  @Get("/model_list")
  public ResultVo model_list(String provider, String model_type) {
    return ResultVo.ok(catalog.models(provider, model_type));
  }

  @Get("/model_form")
  public ResultVo model_form(String provider, String model_type, String model_name) {
    return ResultVo.ok(catalog.form(provider, "credential_form"));
  }

  @Post("/catalog/discover")
  public ResultVo discover(HttpRequest request) {
    return catalog.discover(TioRequestContext.getUserIdLong(), JSON.parseObject(request.getBodyString()));
  }

  @Put("/catalog")
  public ResultVo saveCatalog(HttpRequest request) {
    return catalog.saveCatalog(TioRequestContext.getUserIdLong(), JSON.parseObject(request.getBodyString()));
  }
}

package nexus.io.maxkb.service.kb;

import java.util.ArrayList;
import java.util.List;
import com.jfinal.kit.Kv;
import nexus.io.db.activerecord.Db;
import nexus.io.db.activerecord.Row;

public class ModelCatalogService {

  public List<Kv> models(String provider, String type) {
    String sql = """
        select model_id as name,description as desc,model_type
        from max_kb_model_catalog c
        where provider=? and model_type=? and enabled=true
          and exists(select 1 from max_kb_model_provider p where p.provider=c.provider and p.enabled=true)
        order by model_id
        """;
    List<Kv> result = new ArrayList<>();
    for (Row row : Db.find(sql, provider, type)) {
      result.add(row.toKv());
    }
    return result;
  }
}

package nexus.io.maxkb.service.kb;

import java.io.IOException;
import java.util.List;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import nexus.io.chat.UniChatClient;
import nexus.io.chat.UniChatMessage;
import nexus.io.chat.UniChatRequest;
import nexus.io.chat.UniChatResponse;
import nexus.io.maxkb.vo.CredentialVo;
import nexus.io.maxkb.vo.ModelVo;
import nexus.io.openai.client.OpenAiClient;
import okhttp3.Response;

public class MaxKbModelService {

  static void validateModel(ModelVo model) throws IOException {
    CredentialVo credential = model.getCredential();
    if ("EMBEDDING".equals(model.getModel_type())) {
      JSONObject input = new JSONObject();
      input.put("model", model.getModel_name());
      input.put("input", List.of("模型连接测试"));
      input.put("dimensions", 1024);
      try (Response response = OpenAiClient.embeddings(credential.getApi_base(), credential.getApi_key(), input.toJSONString())) {
        if (!response.isSuccessful() || response.body() == null) {
          throw new IllegalArgumentException("向量模型校验失败，HTTP " + response.code());
        }
        float[] vector = JSON.parseObject(response.body().string())
            .getJSONArray("data").getJSONObject(0).getObject("embedding", float[].class);
        if (vector == null || vector.length != 1024) {
          throw new IllegalArgumentException("当前知识库需要 1024 维向量，请选用支持 dimensions=1024 的模型");
        }
        for (float value : vector) {
          if (!Float.isFinite(value)) {
            throw new IllegalArgumentException("向量模型返回无效数据");
          }
        }
      }
    } else {
      UniChatRequest request = new UniChatRequest();
      request.setModel(model.getModel_name())
          .setApiPrefixUrl(credential.getApi_base())
          .setApiKey(credential.getApi_key())
          .setStream(false)
          .setMessages(List.of(new UniChatMessage("user", "Reply OK")));
      UniChatResponse response = UniChatClient.generate(request);
      if (response == null || response.getRawData() == null) {
        throw new IllegalArgumentException("模型未返回有效响应");
      }
    }
  }
}

package nexus.io.maxkb.service.kb;

import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.jfinal.kit.Kv;
import nexus.io.db.activerecord.Db;
import nexus.io.model.result.ResultVo;

public class ModelCatalogService {

  public ResultVo saveCatalog(Long userId, JSONObject input) {
    if (!admin(userId)) {
      return ResultVo.fail(403, "仅管理员可管理共享模型目录");
    }
    String provider = input.getString("provider");
    if (provider(provider) == null) {
      return ResultVo.fail(400, "供应商不存在或已停用");
    }
    JSONArray models = input.getJSONArray("models");
    if (models == null || models.size() > 5000) {
      return ResultVo.fail(400, "models 必须是最多 5000 项的数组");
    }
    for (int i = 0; i < models.size(); i++) {
      JSONObject model = models.getJSONObject(i);
      modelId(model.getString("name"));
      if (!List.of("LLM", "EMBEDDING").contains(model.getString("model_type"))) {
        return ResultVo.fail(400, "当前支持 LLM 和 EMBEDDING 类型");
      }
    }
    String upsert = """
        insert into max_kb_model_catalog(provider,model_type,model_id,description,source,enabled)
        values(?,?,?,?,?,?)
        on conflict(provider,model_type,model_id)
        do update set description=excluded.description,source=excluded.source,enabled=excluded.enabled,updated_at=now()
        """;
    Db.tx(() -> {
      for (int i = 0; i < models.size(); i++) {
        JSONObject model = models.getJSONObject(i);
        Db.update(upsert,
            provider, model.getString("model_type"), modelId(model.getString("name")), model.getString("desc"),
            "admin", !Boolean.FALSE.equals(model.getBoolean("enabled")));
      }
      return true;
    });
    return ResultVo.ok(Kv.by("updated", models.size()));
  }
}

package nexus.io.maxkb.service.kb;

import java.util.ArrayList;
import java.util.List;
import nexus.io.db.activerecord.Db;
import nexus.io.db.activerecord.Row;
import nexus.io.jfinal.aop.Aop;

public class MaxKbParagraphRetrieveService {

  public List<Row> searchRows(Long[] datasets, Float threshold, Integer limit, String question, String mode) {
    if (datasets == null || datasets.length == 0) {
      return List.of();
    }
    if (!"keywords".equals(mode)) {
      java.util.Map<Long, List<Long>> groups = new java.util.LinkedHashMap<>();
      String sql = """
          select id,coalesce(embedding_mode_id,1002) as model_id
          from max_kb_dataset
          where id=any(?) and deleted=0
          """;
      for (Row dataset : Db.find(sql, (Object) datasets)) {
        groups.computeIfAbsent(dataset.getLong("model_id"), key -> new ArrayList<>()).add(dataset.getLong("id"));
      }
      List<Row> all = new ArrayList<>();
      for (java.util.Map.Entry<Long, List<Long>> group : groups.entrySet()) {
        Long vectorId = Aop.get(KbEmbeddingService.class).getVectorIdForModel(question, group.getKey());
        all.addAll(searchGroup(group.getValue().toArray(new Long[0]), threshold, limit, question, mode, vectorId));
      }
      all.sort(java.util.Comparator.<Row>comparingDouble(row -> ((Number) row.get("similarity")).doubleValue()).reversed());
      return all;
    }
    return searchGroup(datasets, threshold, limit, question, mode, null);
  }
}