핵심 구현

// Low-level API 방식 - 복잡하고 반복적인 코드
ChatModel model = OllamaChatModel.builder().modelName("llama3").build();

List<ChatMessage> messages = new ArrayList<>();
messages.add(SystemMessage.from("당신은 도움이 되는 AI입니다"));
messages.add(UserMessage.from(userQuery));

// 메모리 관리, RAG, 응답 파싱 등을 모두 직접 구현해야 함
Response<AiMessage> response = model.generate(messages);
String answer = response.content().text();

// AiServices 방식 - 선언적이고 간결한 코드
interface Assistant {
    @SystemMessage("당신은 도움이 되는 AI입니다")
    String chat(@UserMessage String query);
}

Assistant assistant = AiServices.builder(Assistant.class)
        .chatModel(model)
        .chatMemory(memory)         // 메모리 자동 관리
        .contentRetriever(retriever) // RAG 자동 적용
        .build();

String answer = assistant.chat(userQuery);  // 깔끔한 비즈니스 로직

public interface RagChatbot {

    String RAG_SYSTEM_PROMPT = """
            당신은 지식 기반 질의응답 시스템입니다.
            사용자의 질문에 대해 제공된 문서 내용을 기반으로
            정확하고 도움이 되는 답변을 제공하세요.
            제공된 문서에 관련 정보가 없는 경우, 솔직하게 모른다고 답변하세요.
            답변은 한국어로 제공하세요.
            """;

    @SystemMessage(RAG_SYSTEM_PROMPT)
    Flux<String> streamChat(@UserMessage String query);

    @SystemMessage(RAG_SYSTEM_PROMPT)
    String chat(@UserMessage String query);
}

@Slf4j
@Component
public class ChatbotFactory {

    private final ContentRetriever contentRetriever;
    private final PersistentChatMemoryStore chatMemoryStore;
    private final OllamaStreamingChatModel defaultStreamingModel;

    @Value("${langchain4j.ollama.base-url}")
    private String ollamaBaseUrl;

    @Value("${chat.memory.max-messages:20}")
    private int maxMessages;

    public RagChatbot createRagChatbot(String modelName, String sessionId) {

        // 1. 모델 선택: 지정된 모델 또는 기본 모델 사용
        StreamingChatModel streamingModel = isDefaultModel(modelName)
                ? defaultStreamingModel
                : createStreamingModel(modelName);

        log.info("RAG 챗봇 생성 - 모델: {}, 세션: {}", modelName, sessionId);

        // 2. AiServices로 Reflection 기반 프록시 생성
        return AiServices.builder(RagChatbot.class)
                .streamingChatModel(streamingModel)
                .contentRetriever(contentRetriever)
                .chatMemory(createChatMemory(sessionId))
                .build();
    }

    private MessageWindowChatMemory createChatMemory(String sessionId) {
        return MessageWindowChatMemory.builder()
                .id(sessionId)
                .maxMessages(maxMessages)
                .chatMemoryStore(chatMemoryStore)
                .build();
    }

    private StreamingChatModel createStreamingModel(String modelName) {
        return OllamaStreamingChatModel.builder()
                .baseUrl(ollamaBaseUrl)
                .modelName(modelName)
                .temperature(0.4)
                .timeout(Duration.ofSeconds(60))
                .build();
    }
}

public interface ChatMemoryStore {

    // 저장된 메시지 조회 (LLM 호출 전에 히스토리 로드)
    List<ChatMessage> getMessages(Object memoryId);

    // 메시지 저장/갱신 (사용자 메시지, AI 응답 추가 시 호출)
    void updateMessages(Object memoryId, List<ChatMessage> messages);

    // 메시지 삭제 (ChatMemory.clear() 호출 시)
    void deleteMessages(Object memoryId);
}

@Slf4j
@Component
@RequiredArgsConstructor
public class PersistentChatMemoryStore implements ChatMemoryStore {

    private final ChatMemoryRepository chatMemoryRepository;

    @Override
    @Transactional(readOnly = true)
    public List<ChatMessage> getMessages(Object memoryId) {
        String sessionId = memoryId.toString();

        List<ChatMemoryEntity> entities = chatMemoryRepository
                .findBySessionIdOrderByCreatedAtAsc(sessionId);

        return entities.stream()
                .map(this::convertToLangChain4jMessage)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
    }

    @Override
    @Transactional
    public void updateMessages(Object memoryId, List<ChatMessage> messages) {
        String sessionId = memoryId.toString();

        // 1. 기존 메시지 전체 삭제 (교체 방식)
        chatMemoryRepository.deleteBySessionId(sessionId);

        // 2. 새 메시지 전체 저장
        for (ChatMessage message : messages) {
            ChatMemoryEntity entity = convertToEntity(sessionId, message);
            if (entity != null) {
                chatMemoryRepository.save(entity);
            }
        }
    }

    private ChatMessage convertToLangChain4jMessage(ChatMemoryEntity entity) {
        return switch (entity.getMessageType()) {
            case "USER" -> UserMessage.from(entity.getContent());
            case "ASSISTANT" -> AiMessage.from(entity.getContent());
            case "SYSTEM" -> SystemMessage.from(entity.getContent());
            default -> null;
        };
    }
}

-- chat_memory 테이블 (JPA 자동 생성)
CREATE TABLE chat_memory (
    id BIGSERIAL PRIMARY KEY,
    session_id VARCHAR(255) NOT NULL,
    message_type VARCHAR(50) NOT NULL,          -- USER, ASSISTANT, SYSTEM
    content TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT NOW()
);

CREATE INDEX idx_chat_memory_session ON chat_memory(session_id);

-- chat_sessions 테이블 (세션 메타데이터)
CREATE TABLE chat_sessions (
    session_id VARCHAR(255) PRIMARY KEY,
    title VARCHAR(255),
    created_at TIMESTAMP DEFAULT NOW(),
    last_message_at TIMESTAMP
);

-- document_embeddings 테이블 (PGVector 자동 생성)
CREATE TABLE document_embeddings (
    id UUID PRIMARY KEY,
    embedding vector(768),
    text TEXT,
    metadata JSONB
);