핵심 API

public interface ChatModel extends Model<Prompt, ChatResponse>, StreamingChatModel {

    default String call(String message) {...}

    @Override
    ChatResponse call(Prompt prompt);
}

@RestController
@RequiredArgsConstructor
public class ChatController {

    private final OllamaChatModel chatModel;

    // 간단한 호출
    @GetMapping("/simple")
    public String simpleCall() {
        return chatModel.call("Tell me a joke");
    }
}

@GetMapping("/advanced")
public String advancedCall() {

    Prompt prompt = new Prompt(new UserMessage("Explain Spring Boot"));

    // 실제 애플리케이션에서는 Prompt를 받아 호출하는 것이 일반적
    ChatResponse response = chatModel.call(prompt);
    
    return response.getResult().getOutput().getContent();
}

@GetMapping("/stream")
public Flux<ChatResponse> streamCall() {

    Prompt prompt = new Prompt(new UserMessage("Tell me a story"));
    
    return chatModel.stream(prompt);
}

ChatResponse response = chatModel.call(
    new Prompt(
        "Tell me a joke about Spring",
        ChatOptions.builder()
            .withModel("gpt-4")
            .withTemperature(0.7)    // 창의성
            .withMaxTokens(100)      // 최대 길이
            .build()
    )
);

String content = response.getResult().getOutput().getContent();

@RestController
class MyController {
    private final ChatClient chatClient;

    public MyController(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }

    @GetMapping("/ai")
    String generation(String userInput) {
        return this.chatClient.prompt()
            .user(userInput)
            .call()
            .content();
    }
}

import org.springframework.ai.chat.ChatClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ChatClientConfig {

    @Bean
    public ChatClient openAiChatClient(OpenAiChatModel chatModel) {
        return ChatClient.create(chatModel);
    }

    @Bean
    public ChatClient anthropicChatClient(AnthropicChatModel chatModel) {
        return ChatClient.create(chatModel);
    }
}

@Configuration
public class ChatClientExample {

    @Bean
    CommandLineRunner cli(
            @Qualifier("openAiChatClient") ChatClient openAiChatClient,
            @Qualifier("anthropicChatClient") ChatClient anthropicChatClient) {

        return args -> {
            var scanner = new Scanner(System.in);
            ChatClient chat;

            String choice = scanner.nextLine().trim();

            if (choice.equals("1")) {
                chat = openAiChatClient;
                System.out.println("Using OpenAI model");
            } else {
                chat = anthropicChatClient;
                System.out.println("Using Anthropic model");
            }

            System.out.print("\nEnter your question: ");
            String input = scanner.nextLine();
            String response = chat.prompt(input).call().content();
            System.out.println("ASSISTANT: " + response);

            scanner.close();
        };
    }
}

public Flux<ChatResponse> streamRagResponse(String query, String model) {
    String sessionId = SessionContext.getCurrentSessionId();

    // 동적 모델 선택 지원
    ChatClientRequestSpec requestSpec = createRequestSpec(query, model);

    // RAG 어드바이저 동적 생성 (질문 압축 설정에 따라)
    Advisor ragAdvisor = EgovRagConfig.createRagAdvisor(
            sessionId, compressionTransformer,
            vectorStoreDocumentRetriever, enableQueryCompression);

    // ChatMemory + RAG Advisor 체인 적용
    return requestSpec
            .advisors(messageChatMemoryAdvisor, ragAdvisor)
            .advisors(a -> a.param(ChatMemory.CONVERSATION_ID, sessionId))
            .stream()
            .chatResponse();
}

@GetMapping("/ai/rag/stream")
public Flux<ChatResponse> streamRagResponse(
        @RequestParam(value = "message") String message,
        @RequestParam(value = "model", required = false) String model,
        @RequestParam(value = "sessionId", required = false) String sessionId) {

    // 세션 컨텍스트 설정 및 검증
    SessionContext.setCurrentSessionId(sessionId);

    return sessionAwareChatService.streamRagResponse(message, model)
            .doFinally(signalType -> SessionContext.clear());
}

function sendMessage(message, sessionId) {
    const eventSource = new EventSource(
        `/ai/rag/stream?message=${encodeURIComponent(message)}&sessionId=${sessionId}`
    );

    eventSource.onmessage = function(event) {
        const data = JSON.parse(event.data);
        if (data.result && data.result.output) {
            appendToChat(data.result.output.content);
        }
    };

    eventSource.onerror = function() {
        eventSource.close();
    };
}

// 템플릿 정의
PromptTemplate promptTemplate = new PromptTemplate(
    "Tell me a {adjective} joke about {topic}"
);

// 변수 바인딩
Prompt prompt = promptTemplate.create(
    Map.of("adjective", "funny", "topic", "programming")
);

// 실행
ChatResponse response = chatModel.call(prompt);

PromptTemplate promptTemplate = PromptTemplate.builder()
    .renderer(StTemplateRenderer.builder()
        .startDelimiterToken('<')
        .endDelimiterToken('>')
        .build())
    .template("""
        Tell me the names of 5 movies whose soundtrack was composed by <composer>.
        """)
    .build();

String prompt = promptTemplate.render(Map.of("composer", "John Williams"));

String userText = """
    Tell me about three famous pirates from the Golden Age of Piracy and why they did.
    Write at least a sentence for each pirate.
    """;

Message userMessage = new UserMessage(userText);

String systemText = """
  You are a helpful AI assistant that helps people find information.
  Your name is {name}
  You should reply to the user's request with your name and also in the style of a {voice}.
  """;

SystemPromptTemplate systemPromptTemplate = new SystemPromptTemplate(systemText);
Message systemMessage = systemPromptTemplate.createMessage(
    Map.of("name", "Claude", "voice", "pirate")
);

Prompt prompt = new Prompt(List.of(userMessage, systemMessage));
List<Generation> response = chatModel.call(prompt).getResults();

// 반환될 객체 정의
record ActorsFilms(String actor, List<String> movies) { }

// 응답을 ActorsFilms로 반환하도록 AI 모델에 요청
ActorsFilms actorsFilms = ChatClient.create(chatModel).prompt()
    .user(u -> u.text("Generate the filmography of 5 movies for {actor}.")
                .param("actor", "Tom Hanks"))
    .call()
    .entity(ActorsFilms.class);

// BeanOutputConverter 생성
BeanOutputConverter<ActorsFilms> beanOutputConverter =
    new BeanOutputConverter<>(ActorsFilms.class);

String format = beanOutputConverter.getFormat();
String actor = "Tom Hanks";

String template = """
    Generate the filmography of 5 movies for {actor}.
    {format}
    """;

// Prompt 생성 및 호출
Generation generation = chatModel.call(
    PromptTemplate.builder()
        .template(template)
        .variables(Map.of("actor", actor, "format", format))
        .build()
        .create()
).getResult();

// 응답을 객체로 변환
ActorsFilms actorsFilms = beanOutputConverter.convert(
    generation.getOutput().getText()
);

TransformersEmbeddingModel embeddingModel = new TransformersEmbeddingModel();

// (optional) tokenizer 리소스 설정
embeddingModel.setTokenizerResource(
    "classpath:/onnx/all-MiniLM-L6-v2/tokenizer.json"
);

// (optional) 모델 리소스 설정
embeddingModel.setModelResource(
    "classpath:/onnx/all-MiniLM-L6-v2/model.onnx"
);

// (optional) 캐시 디렉토리 설정
embeddingModel.setResourceCacheDirectory("/tmp/onnx-zoo");

// (optional) tokenizer 패딩 설정
embeddingModel.setTokenizerOptions(Map.of("padding", "true"));

embeddingModel.afterPropertiesSet();

// Embedding 수행
List<List<Double>> embeddings = embeddingModel.embed(
    List.of("Hello world", "World is big")
);