CrazyAirhead

package com.example.demo.ai.llm.service;

import com.jfinal.kit.Kv;
import org.noear.solon.annotation.Component;
import org.noear.solon.annotation.Inject;
import org.noear.solon.flow.ChainContext;
import org.noear.solon.flow.FlowEngine;

/**
 * @author airhead
 */
@Component
public class LlmService {
  @Inject private FlowEngine flowEngine;

  public Kv flow(String prompt) {

    try {
      ChainContext chainContext = new ChainContext();
      chainContext.put("prompt", prompt);
      Kv kv = Kv.create();
      chainContext.put("result", kv);
      flowEngine.eval("c1", chainContext);

      return kv;
    } catch (Throwable e) {
      throw new RuntimeException(e);
    }
  }

  public Kv aiFlow(String prompt) {
    try {
      ChainContext chainContext = new ChainContext();
      chainContext.put("prompt", prompt);
      Kv kv = Kv.create();
      chainContext.put("result", kv);
      flowEngine.eval("ai-flow-01", chainContext);

      return kv;
    } catch (Throwable e) {
      throw new RuntimeException(e);
    }
  }
}

package com.example.demo.ai.llm.service;

import com.jfinal.kit.Kv;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

import org.dromara.hutool.core.regex.ReUtil;
import org.dromara.hutool.core.text.StrUtil;
import org.noear.solon.ai.chat.ChatConfig;
import org.noear.solon.ai.chat.ChatModel;
import org.noear.solon.ai.chat.ChatResponse;
import org.noear.solon.ai.chat.message.ChatMessage;
import org.noear.solon.annotation.Component;
import org.noear.solon.flow.ChainContext;
import org.noear.solon.flow.Node;
import org.noear.solon.flow.TaskComponent;

/**
 * @author airhead
 */
@Component("intentionTask")
public class IntentionTask implements TaskComponent {
  @Override
  public void run(ChainContext context, Node node) throws Throwable {
    Kv meta = Kv.create().set(node.meta());
    ChatConfig chatConfig = new ChatConfig();
    chatConfig.setModel(meta.getStr("model"));
    chatConfig.setProvider(meta.getStr("provider"));
    chatConfig.setApiUrl(meta.getStr("apiUrl"));
    chatConfig.setTimeout(Duration.ofSeconds(600));
    ChatModel chatModel = ChatModel.of(chatConfig).build();

    List<ChatMessage> chatMessageList = new ArrayList<>();
    ChatMessage system = ChatMessage.ofSystem(meta.getStr("system"));
    chatMessageList.add(system);

    Kv model = Kv.create().set(context.model());
    String inputKey = meta.getStr("input");
    ChatMessage userMessage = ChatMessage.ofUser(model.getStr(inputKey));
    chatMessageList.add(userMessage);
    ChatResponse response = chatModel.prompt(chatMessageList).call();
    String content = response.getMessage().getContent();

    // 去掉think的部分。
    String pattern = "<think>.*?</think>";
    Pattern p = Pattern.compile(pattern, Pattern.DOTALL);
    content = StrUtil.trim(ReUtil.replaceAll(content, p, ""));

    String outputKey = meta.getStr("output");
    context.put(outputKey, content);

    Kv result = context.get("result");
    result.set("data", content);
  }
}

package com.example.demo.ai.llm.service;

import com.jfinal.kit.Kv;
import java.util.ArrayList;
import java.util.List;
import org.noear.solon.ai.chat.ChatConfig;
import org.noear.solon.ai.chat.ChatModel;
import org.noear.solon.ai.chat.ChatResponse;
import org.noear.solon.ai.chat.message.ChatMessage;
import org.noear.solon.annotation.Component;
import org.noear.solon.flow.ChainContext;
import org.noear.solon.flow.Node;
import org.noear.solon.flow.TaskComponent;

/**
 * @author airhead
 */
@Component("suggestionTask")
public class SuggestionTask implements TaskComponent {
  @Override
  public void run(ChainContext context, Node node) throws Throwable {
    Kv meta = Kv.create().set(node.meta());
    ChatConfig chatConfig = new ChatConfig();
    chatConfig.setModel(meta.getStr("model"));
    chatConfig.setProvider(meta.getStr("provider"));
    chatConfig.setApiUrl(meta.getStr("apiUrl"));
    ChatModel chatModel = ChatModel.of(chatConfig).build();

    List<ChatMessage> chatMessageList = new ArrayList<>();
    ChatMessage system = ChatMessage.ofSystem(meta.getStr("system"));
    chatMessageList.add(system);

    Kv model = Kv.create().set(context.model());
    String inputKey = meta.getStr("input");
    ChatMessage userMessage = ChatMessage.ofUser(model.getStr(inputKey));
    chatMessageList.add(userMessage);
    ChatResponse response = chatModel.prompt(chatMessageList).call();
    String content = response.getMessage().getContent();

    String outputKey = meta.getStr("output");
    context.put(outputKey, content);

    Kv result = context.get("result");
    result.set("data", content);
  }
}

package com.example.demo.solon.controller;

import static org.junit.jupiter.api.Assertions.*;

import com.example.demo.solon.DemoCloudBreakerApp;
import java.util.concurrent.CountDownLatch;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.noear.solon.Utils;
import org.noear.solon.test.HttpTester;
import org.noear.solon.test.SolonTest;

@Slf4j
@SolonTest(DemoCloudBreakerApp.class)
public class DemoControllerTest extends HttpTester {
  @Test
  public void test() throws Exception {
    CountDownLatch count = new CountDownLatch(100);
    for (int i = 0; i < 100; i++) {
      log.info("get hello start. i:{}", i);
      int finalI = i;
      Utils.async(
          () -> {
            try {
              path("/hello").get();
            } catch (Exception e) {
              log.error("", e);
            }

            log.info("get hello end. i:{}", finalI);
            count.countDown();
          });
    }

    count.await();
  }
}

dependencies {
    implementation platform(project(":demo-parent"))

    implementation("org.noear:solon-web")
    implementation("org.noear:solon-ai")
    implementation("org.noear:solon-logging-logback")
    implementation("org.noear:solon-openapi2-knife4j")
    implementation("org.noear:solon-web-rx")
    implementation("org.noear:solon-web-sse")

    testImplementation("org.noear:solon-test")
}

package com.example.demo.ai.llm.config;

import org.noear.solon.ai.chat.ChatConfig;
import org.noear.solon.ai.chat.ChatModel;
import org.noear.solon.annotation.Bean;
import org.noear.solon.annotation.Configuration;
import org.noear.solon.annotation.Inject;

/**
 * @author airhead
 */
@Configuration
public class LlmConfig {
  @Bean
  public ChatModel build(@Inject("${demo.llm}") ChatConfig config) {
    return ChatModel.of(config).build();
  }
}

package com.example.demo.ai.llm.controller;

import com.example.demo.ai.llm.service.LlmService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import java.io.IOException;
import org.noear.solon.annotation.*;
import org.noear.solon.core.util.MimeType;
import reactor.core.publisher.Flux;

/**
 * @author airhead
 */
@Controller
@Mapping("/llm")
@Api("聊天")
public class LlmController {
  @Inject private LlmService service;

  @ApiOperation("chat")
  @Post
  @Mapping("chat")
  public String chat(String prompt) {
    return service.chat(prompt);
  }

  @Produces(MimeType.TEXT_EVENT_STREAM_UTF8_VALUE)
  @Mapping("stream")
  public Flux<String> stream(String prompt) throws IOException {
    return service.stream(prompt);
  }

  @ApiOperation("functionCall")
  @Post
  @Mapping("functionCall")
  public String functionCall(String prompt) {
    return service.functionCall(prompt);
  }
}

package com.example.demo.ai.llm.service;

import java.io.IOException;
import org.noear.solon.ai.chat.ChatModel;
import org.noear.solon.ai.chat.ChatResponse;
import org.noear.solon.annotation.Component;
import org.noear.solon.annotation.Inject;
import reactor.core.publisher.Flux;

/**
 * @author airhead
 */
@Component
public class LlmService {
  @Inject private ChatModel chatModel;

  public String chat(String prompt) {
    try {
      ChatResponse response = chatModel.prompt(prompt).call();

      return response.getMessage().getContent();
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

  public Flux<String> stream(String prompt) throws IOException {
    return Flux.from(chatModel.prompt(prompt).stream())
        .filter(ChatResponse::hasChoices)
        .map(resp -> resp.getMessage().getContent());
  }

  public String functionCall(String prompt) {
    try {
      ChatResponse response =
          chatModel.prompt(prompt).options(o -> o.functionAdd(new Tools())).call();

      return response.getMessage().getContent();
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }
}

package com.example.demo.solon.filter;

import io.vertx.core.buffer.Buffer;
import lombok.extern.slf4j.Slf4j;
import org.dromara.hutool.core.text.StrUtil;
import org.noear.solon.annotation.Component;
import org.noear.solon.cloud.gateway.exchange.ExContext;
import org.noear.solon.cloud.gateway.exchange.ExFilter;
import org.noear.solon.cloud.gateway.exchange.ExFilterChain;
import org.noear.solon.cloud.gateway.route.RouteFilterFactory;
import org.noear.solon.rx.Completable;

/**
 * @author airhead
 */
@Component
@Slf4j
public class AuthFilterFactory implements RouteFilterFactory {
  public static final String TOKEN = "token";
  public static final String EMPTY = "empty";

  @Override
  public String prefix() {
    return "Auth";
  }

  @Override
  public ExFilter create(String config) {
    if (TOKEN.equals(config)) {
      return new TokenFilter();
    } else {
      return new EmptyAuthFilter();
    }
  }

  /** 默认的空鉴权 */
  public static class EmptyAuthFilter implements ExFilter {
    public EmptyAuthFilter() {}

    @Override
    public Completable doFilter(ExContext ctx, ExFilterChain chain) {
      log.info("empty filter, do nothing");

      return chain.doFilter(ctx);
    }
  }

  /** token 鉴权 ，如果鉴权逻辑比较复杂的，用独立类 */
  public static class TokenFilter implements ExFilter {
    @Override
    public Completable doFilter(ExContext ctx, ExFilterChain chain) {
      String token = ctx.rawHeader("token");
      if (StrUtil.isBlank(token)) {
        ctx.newResponse().status(401);
        ctx.newResponse().body(Buffer.buffer("token is empty"));
        return Completable.complete();
      }

      return chain.doFilter(ctx);
    }
  }
}

 package com.example.demo.solon.controller;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.noear.solon.annotation.Controller;
import org.noear.solon.annotation.Mapping;
import org.noear.solon.annotation.Param;

/**
 * @author airhead
 */
@Api("Demo")
@Controller
@Mapping
public class DemoController {
  @ApiOperation("hello")
  @Mapping("/hello")
  public String hello(@Param(defaultValue = "world") String name) {
    return String.format("Hello %s!, By Service01", name);
  }
}

package com.example.demo.solon.controller;

import com.example.demo.solon.client.DemoClient;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import java.io.IOException;
import org.noear.nami.annotation.NamiClient;
import org.noear.solon.annotation.Controller;
import org.noear.solon.annotation.Mapping;
import org.noear.solon.annotation.Param;
import org.noear.solon.net.http.HttpUtils;

/**
 * @author airhead
 */
@Api("Demo")
@Controller
@Mapping
public class DemoController {
  @NamiClient private DemoClient demoClient;

  @ApiOperation("hello")
  @Mapping("/hello")
  public String hello(@Param(defaultValue = "world") String name) {
    try {
      return HttpUtils.http("demo-cloud-service01", "/hello").data("name", name).get();
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

  @ApiOperation("hello2")
  @Mapping("/hello2")
  public String hello2(@Param(defaultValue = "world") String name) {
    return demoClient.hello(name);
  }
}

package com.example.demo.solon.client;

import org.noear.nami.annotation.NamiClient;

/**
 * @author airhead
 */
@NamiClient(name = "demo-cloud-service01")
public interface DemoClient {
  String hello(String name);
}

package com.example.demo.solon.config;

import java.io.Serializable;
import lombok.Data;
import org.noear.solon.annotation.Configuration;
import org.noear.solon.annotation.Inject;

/**
 * @author airhead
 */
@Configuration
@Inject(value = "${app}", autoRefreshed = true)
@Data
public class AppConfig implements Serializable {
  private String appId;
  private String appKey;
}

@Api("配置管理")
@Controller
@Mapping("/config")
public class DemoController {
  @Inject private AppConfig appConfig;
 
 }

package com.example.demo.solon.config;

import java.io.Serializable;
import lombok.Data;
import org.noear.solon.annotation.Configuration;
import org.noear.solon.cloud.annotation.CloudConfig;

/**
 * 通过类获取dataId的配置，暂不支持的。
 *
 * @author airhead
 */
@Configuration
@CloudConfig(value = "demo-db", autoRefreshed = true)
@Data
public class DemoDbConfig implements Serializable {
  private String url;
  private String username;
  private String password;
}

@Api("配置管理")
@Controller
@Mapping("/config")
public class DemoController {
  /** 获取dataId的配置，获取不到值 */
  @Inject private DemoDbConfig demoDbConfig;
}

public class DemoController {
  /** 获取dataId的配置，获取不到值 */
  @Inject private DemoDbConfig demoDbConfig;

  @Inject private AppConfig appConfig;

  @CloudConfig(value = "demo-db", autoRefreshed = true)
  private Properties properties;

  @CloudConfig(value = "demo-db", autoRefreshed = true)
  private DemoDbConfig demoDbConfig2;
 
 }

package com.example.demo.solon.plugin;

import org.noear.solon.core.AppContext;
import org.noear.solon.core.Plugin;

/**
 * @author airhead
 */
public class DemoSolonPlugin implements Plugin {
  @Override
  public void start(AppContext context) throws Throwable {
    // 简单起见，直接扫描插件所在包，可以根据实际的需要进行定制化的加载
    context.beanScan(DemoSolonPlugin.class);
  }

  @Override
  public void prestop() throws Throwable {
    Plugin.super.prestop();
  }

  @Override
  public void stop() throws Throwable {
    // 移除http处理。在热插拔的插件中特别
    Solon.app().router().remove("/hello");
  }
}

package com.example.demo.solon.plugin.controller;

import org.noear.solon.annotation.Controller;
import org.noear.solon.annotation.Mapping;
import org.noear.solon.annotation.Param;

/**
 * @author airhead
 */
@Controller
public class DemoController {
  @Mapping("/hello")
  public String hello(@Param(defaultValue = "world") String name) {
    return String.format("Hello %s!", name);
  }
}

package com.example.demo.solon.controller;

import lombok.extern.slf4j.Slf4j;
import org.noear.solon.annotation.Controller;
import org.noear.solon.annotation.Mapping;
import org.noear.solon.hotplug.PluginManager;

/**
 * @author airhead
 */
@Controller
@Slf4j
public class PluginController {
  @Mapping("start")
  public String start() {
    PluginManager.start("demo");
    return "ok";
  }

  @Mapping("stop")
  public String stop() {
    PluginManager.stop("demo");
    return "ok";
  }
}

@SolonMain
public class App {
    public static void main(String[] args) {
        Solon.start(App.class, args, (app) -> {
            //应用初始化时机点
        });
    } 
}

@Configuration
public class DemoConfig {
    @Bean(name="db1", typed=true)
    public DataSource db1(@Inject("${demo.db1}") DataSource ds){ 
        return ds;
    }
    
    @Bean
    public void db1Test(@Db("db1") UserMapper mapper) { //这个注入，依赖“db1”的数据源
        return mapper.initUsers();
    }
}

@Component
public class DemoService{
    //注入值（带默认值：demoApi），并开启自动更新（注意：如果不是单例，请不要开启自动刷新）
    @Inject(value="${track.name:demoApi}", autoRefreshed=true)
    static String trackName; //v3.0 后支持静态字段注入//注入值（没有时，不覆盖字段初始值）
    
    @Inject("${track.url}")
    String trackUrl = "http://x.x.x/track";
    
    //注入配置集合
    @Inject("${track.db1}")
    Properties trackDbCfg;
    
    //注入Bean（根据对应的配置集合自动生成并注入）
    @Inject("${track.db1}")
    HikariDataSource trackDs;
}

@Inject("${user.config}")  
@Configuration
public class UserProperties{
    public String name;
    public List<String> tags;
    ...
}

@BindProps(prefix="user.config")  //或者用绑定属性注解。v3.0.7 后支持
@Configuration
public class UserProperties{
    public String name;
    public List<String> tags;
    ...
}

@Configuration
public class DemoConfig {
    @BindProps(prefix="user.config") //或者用绑定属性注解。v3.0.7 后支持
    @Bean
    public UserProperties userProperties(){
        return new UserProperties();
    }
}

@Configurationpublic class DemoConfig{
    //提示：@Bean 只能与 @Configuration 配合@Bean 
    public DataSource db1(@Inject("${track.db1}") HikariDataSource ds) {
        return ds;
    }
    
    @Beanpublic DataSourceWrap db1w(@Inject DataSource ds, @Inject("${wrap}") WrapConfig wc) {
        return new DataSourceWrap(ds, wc);
    }
    
    //也可以带条件处理@Bean@Condition(onProperty="${cache.enable} = true") //有 "cache.enable" 属性值，且等于truepublic CacheService cache(@Inject("${cache.config}") CacheServiceSupplier supper){
       return supper.get();
    }
}

@Componentpublic class DemoService{
    //注入值（带默认值：demoApi），并开启自动更新
    @Inject(value="${track.name:demoApi}", autoRefreshed=true)
    String trackName;
    
    //通过函数时时获取最新的（静态或动态，按需设定）
    public static String trackName2(){
        return Solon.cfg().get("track.name:demoApi");
    }
}