spring-ai 1.0.0 （3）交互增强：Advisor 顾问模块

核心组件

API 由非流式处理方案和和流式处理方案组成。

在1.0.0版本中，顾问链AdvisorChain相关接口已经弃用，可能是老版本的思想不太合伦理吧

可以使用下面的方式实现多个顾问按oder顺序访问模型

复制代码

    public ChatController(ChatClient.Builder chatClientBuilder) {
        MySimpleLoggerAdvisor advisor3=  new MySimpleLoggerAdvisor(3);
        MySimpleLoggerAdvisor advisor2= new MySimpleLoggerAdvisor(2);
        MySimpleLoggerAdvisor advisor1= new MySimpleLoggerAdvisor(1);
        this.chatClient = chatClientBuilder
                //此处执行顺序由order决定，并非添加顺序决定
                .defaultAdvisors(List.of(
                        advisor3,
                        advisor2,
                        advisor1)
                )
                .defaultSystem("You are a helpful assistant")
                .build();
    }

下图说明了顾问链和聊天模型之间的交互：

顾问advice之间的request和response 基于order 对称，比如三个女孩子按顺序123追你，你给出的答复顺序则应该是321

交互返回：

Spring AI 提供了两种类型的内存顾问程序来维护对话上下文：

顾问	存储机制	模板占位符
`PromptChatMemoryAdvisor`	内存中或自定义	`instructions`,`memory`
`VectorStoreChatMemoryAdvisor`	向量数据库	`instructions`,`long_term_memory`

下面是一个简单顾问的实现用于参考学习：

复制代码

package com.example.advisor;


import org.springframework.ai.chat.client.ChatClientRequest;
import org.springframework.ai.chat.client.ChatClientResponse;
import org.springframework.ai.chat.client.advisor.api.CallAdvisor;
import org.springframework.ai.chat.client.advisor.api.CallAdvisorChain;
import org.springframework.ai.chat.client.advisor.api.StreamAdvisor;
import org.springframework.ai.chat.client.advisor.api.StreamAdvisorChain;
import reactor.core.publisher.Flux;


public class MySimpleLoggerAdvisor implements CallAdvisor, StreamAdvisor {


    private Integer order;
    public MySimpleLoggerAdvisor() {
        super();
    }

    public MySimpleLoggerAdvisor(Integer preOrder) {
        order = preOrder;
    }


    public ChatClientResponse adviseCall(ChatClientRequest chatClientRequest, CallAdvisorChain callAdvisorChain) {
        System.out.println("BEFORE: {}" + chatClientRequest);
        System.out.println("do something　order  " + this.order);

        ChatClientResponse chatClientResponse = callAdvisorChain.nextCall(chatClientRequest);

        System.out.println("AFTER: {}" + chatClientResponse);

        System.out.println("was do something order  " + this.order);
        return chatClientResponse;
    }

    @Override
    public String getName() {
        return "MySimpleLoggerAdvisor";
    }

    @Override
    public int getOrder() {
        return this.order == null ? 0 : this.order;
    }


//	@Override
//	public AdvisedResponse aroundCall(AdvisedRequest advisedRequest, CallAroundAdvisorChain chain) {
//
//		logger.debug("BEFORE: {}", advisedRequest);
//
//		AdvisedResponse advisedResponse = chain.nextAroundCall(advisedRequest);
//
//		logger.debug("AFTER: {}", advisedResponse);
//
//		return advisedResponse;
//	}
//

    @Override
    public Flux<ChatClientResponse> adviseStream(ChatClientRequest chatClientRequest, StreamAdvisorChain streamAdvisorChain) {
        System.out.println("BEFORE: {}" + chatClientRequest);
        System.out.println("do something");

        Flux<ChatClientResponse> chatClientResponse = streamAdvisorChain.nextStream(chatClientRequest);

        System.out.println("AFTER: {}" + chatClientResponse);

        System.out.println("was do something");

        return chatClientResponse;
    }

//	@Override
//	public Flux<AdvisedResponse> aroundStream(AdvisedRequest advisedRequest, StreamAroundAdvisorChain chain) {
//
//		logger.debug("BEFORE: {}", advisedRequest);
//
//		Flux<AdvisedResponse> advisedResponses = chain.nextAroundStream(advisedRequest);
//
//        return new MessageAggregator().aggregateAdvisedResponse(advisedResponses,
//                    advisedResponse -> logger.debug("AFTER: {}", advisedResponse));
//	}
}

最后分析一下顾问模块的依赖关系：chatclient客户端是依赖于它的，他和chatclient客户端也同时依赖于spring-ai-模型，Core Advisor 框架在spring-ai-模型中得到定义和泛化