ChatModel & ChatClient

package com.example.docsassistant;

import java.util.Map;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.SimpleLoggerAdvisor;
import org.springframework.ai.chat.prompt.ChatOptions;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
class ClientDefaults {

    @Bean
    ChatClient defaultsDemo(ChatClient.Builder builder, DocsTools docsTools) {
        return builder
                .defaultSystem("You are DocsAssistant. Answer as {tone} as you can.")
                .defaultUser(u -> u.text("{question}"))
                .defaultOptions(ChatOptions.builder().temperature(0.2).maxTokens(600))
                .defaultAdvisors(new SimpleLoggerAdvisor())
                .defaultTools(docsTools)
                .defaultToolContext(Map.of("tenant", "public"))
                .build();
    }

    String ask(ChatClient client, String question) {
        return client.prompt()
                .system(s -> s.param("tone", "concisely"))
                .user(u -> u.param("question", question))
                .call()
                .content();
    }

    ChatClient variant(ChatClient base) {
        return base.mutate().defaultSystem("You are DocsAssistant. Answer in Spanish.").build();
    }
}

package com.example.docsassistant;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;

@Service
class StreamPreview {

    private final ChatClient chatClient;

    StreamPreview(ChatClient docsChatClient) {
        this.chatClient = docsChatClient;
    }

    Flux<String> tokens(String question) {
        return this.chatClient.prompt().user(question).stream().content();
    }

    Flux<ChatResponse> chunks(String question) {
        return this.chatClient.prompt().user(question).stream().chatResponse();
    }
}

package com.example.docsassistant;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.metadata.Usage;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.stereotype.Service;

@Service
class UsageReporter {

    record Answer(String text, int promptTokens, int completionTokens, int totalTokens) { }

    private final ChatClient chatClient;

    UsageReporter(ChatClient docsChatClient) {
        this.chatClient = docsChatClient;
    }

    Answer askWithUsage(String question) {
        ChatResponse response = this.chatClient.prompt()
                .user(question)
                .call()
                .chatResponse();

        String text = response.getResult().getOutput().getText();
        Usage usage = response.getMetadata().getUsage();
        return new Answer(text,
                orZero(usage.getPromptTokens()),
                orZero(usage.getCompletionTokens()),
                orZero(usage.getTotalTokens()));
    }

    /** Cost in the provider's currency, given the price per million tokens for input and output. */
    static double cost(Answer answer, double inputPerMillion, double outputPerMillion) {
        return (answer.promptTokens() * inputPerMillion + answer.completionTokens() * outputPerMillion) / 1_000_000.0;
    }

    private static int orZero(Integer value) {
        return value == null ? 0 : value;
    }
}

package com.example.docsassistant;

import io.micrometer.observation.ObservationRegistry;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.ToolCallingAdvisor;
import org.springframework.ai.chat.client.advisor.observation.AdvisorObservationConvention;
import org.springframework.ai.chat.client.observation.ChatClientObservationConvention;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.model.chat.client.autoconfigure.ChatClientBuilderConfigurer;
import org.springframework.ai.ollama.OllamaChatModel;
import org.springframework.ai.ollama.api.OllamaChatOptions;
import org.springframework.ai.openai.OpenAiChatModel;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

@Configuration
class MultiChatClientConfig {

    private final ChatClientBuilderConfigurer configurer;
    private final ObjectProvider<ObservationRegistry> observationRegistry;
    private final ObjectProvider<ChatClientObservationConvention> chatClientConvention;
    private final ObjectProvider<AdvisorObservationConvention> advisorConvention;
    private final ObjectProvider<ToolCallingAdvisor.Builder<?>> toolCallingAdvisorBuilder;

    MultiChatClientConfig(ChatClientBuilderConfigurer configurer,
            ObjectProvider<ObservationRegistry> observationRegistry,
            ObjectProvider<ChatClientObservationConvention> chatClientConvention,
            ObjectProvider<AdvisorObservationConvention> advisorConvention,
            ObjectProvider<ToolCallingAdvisor.Builder<?>> toolCallingAdvisorBuilder) {
        this.configurer = configurer;
        this.observationRegistry = observationRegistry;
        this.chatClientConvention = chatClientConvention;
        this.advisorConvention = advisorConvention;
        this.toolCallingAdvisorBuilder = toolCallingAdvisorBuilder;
    }

    // Exactly one ChatModel must be primary for the auto-configured ChatClient.Builder to resolve.
    @Bean
    @Primary
    ChatModel primaryChatModel(OllamaChatModel model) {
        return model;
    }

    @Bean
    @Primary
    ChatClient localChatClient(OllamaChatModel model) {
        return build(model);
    }

    @Bean
    ChatClient hostedChatClient(OpenAiChatModel model) {
        return build(model);
    }

    // Same arguments the auto-configured builder uses, so observations and the tool-calling advisor are kept.
    private ChatClient build(ChatModel model) {
        ChatClient.Builder builder = ChatClient.builder(model,
                this.observationRegistry.getIfUnique(() -> ObservationRegistry.NOOP),
                this.chatClientConvention.getIfUnique(), this.advisorConvention.getIfUnique(),
                this.toolCallingAdvisorBuilder.getIfAvailable());
        return this.configurer.configure(builder).build();
    }

    // Same provider, another personality: the auto-configured builder is prototype-scoped.
    @Bean
    ChatClient terseChatClient(ChatClient.Builder builder) {
        return builder
                .defaultSystem("Answer in one sentence.")
                .defaultOptions(OllamaChatOptions.builder().temperature(0.0))
                .build();
    }
}