Merge pull request #9 from UMC-hackathon-2team/feat/#2-ai-service

Feat: 감정 기억 생성 기능 및 AI 응답 반환 구현

Author: JiwonLee42

build.gradle

@@ -36,6 +36,9 @@ dependencies {
 
 	// swagger
 	implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.7.0'
+
+	// gpt
+	implementation 'io.github.flashvayne:chatgpt-spring-boot-starter:1.0.4'
 }
 
 tasks.named('test') {

src/main/java/umc/tosee/global/common/ErrorCode.java

@@ -9,11 +9,14 @@
 public enum ErrorCode implements BaseCode {
 
     // 서버 에러
-    INTERNAL_SERVER_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, "COMMON-001", "서버 오류가 발생했습니다."),
-    INVALID_REQUEST(HttpStatus.BAD_REQUEST, "COMMON-002", "요청 파라미터가 올바르지 않습니다."),
-    INVALID_DATE(HttpStatus.BAD_REQUEST, "DATE-001", "유효하지 않은 날짜입니다."),
-    INVALID_FORMAT(HttpStatus.BAD_REQUEST, "FORMAT-001", "형식이 올바르지 않습니다."),
-    JSON_PARSE_ERROR(HttpStatus.BAD_REQUEST, "COMMON-003", "JSON 파싱에 실패했습니다.");
+    INTERNAL_SERVER_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, "COMMON-500", "서버 오류가 발생했습니다."),
+    INVALID_REQUEST(HttpStatus.BAD_REQUEST, "COMMON-400", "요청 파라미터가 올바르지 않습니다."),
+    INVALID_DATE(HttpStatus.BAD_REQUEST, "DATE-400", "유효하지 않은 날짜입니다."),
+    INVALID_FORMAT(HttpStatus.BAD_REQUEST, "FORMAT-400", "형식이 올바르지 않습니다."),
+    JSON_PARSE_ERROR(HttpStatus.BAD_REQUEST, "COMMON-400", "JSON 파싱에 실패했습니다."),
+
+    // GPT 에러
+    GPT_RESPONSE_FORMAT_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, "GPT-500", "GPT 응답 포맷이 올바르지 않습니다.");
 
     private final HttpStatus httpStatus;
     private final String code;

src/main/java/umc/tosee/global/config/SwaggerConfig.java

@@ -13,8 +13,8 @@ public class SwaggerConfig {
     @Bean
     public OpenAPI swagger() {
         Info info = new Info()
-                .title("Tosee API 명세서")
-                .description("Tosee 백엔드 API 명세서입니다.")
+                .title("Tosea API 명세서")
+                .description("Tosea 백엔드 API 명세서입니다.")
                 .version("0.0.1");
 
         return new OpenAPI()

src/main/java/umc/tosee/gpt/dto/GptDTO.java

@@ -0,0 +1,30 @@
+package umc.tosee.gpt.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+public class GptDTO {
+
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class GptRequestDTO {
+
+        @NotBlank(message = "채팅 내용은 필수입니다.")
+        String message;
+    }
+
+    @NoArgsConstructor
+    @AllArgsConstructor
+    @Getter
+    public static class GptResponseDTO {
+
+        private String category;
+        private String letter;
+        private String summary;
+
+    }
+}

src/main/java/umc/tosee/gpt/service/GptService.java

@@ -0,0 +1,207 @@
+package umc.tosee.gpt.service;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.*;
+import org.springframework.stereotype.Service;
+import org.springframework.web.client.RestTemplate;
+import umc.tosee.global.common.ErrorCode;
+import umc.tosee.global.exception.CustomException;
+import umc.tosee.gpt.dto.GptDTO;
+
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class GptService {
+
+    @Value("${openai.api.key}")
+    private String apikey;
+
+    // openai url
+    final String url = "https://api.openai.com/v1/chat/completions";
+
+    // 프롬프트
+    String instruction =
+            "당신은 사용자의 감정을 섬세하게 이해하고,\n" +
+                    "그 감정이 ‘이상하지 않으며 충분히 이해될 수 있음’을\n" +
+                    "차분하고 따뜻한 어투와 단정한 문장으로 전달하는 AI입니다.\n" +
+                    "사용자가 어떤 상황이나 감정을 입력하면,\n" +
+                    "당신은 다음 원칙을 반드시 따릅니다.\n\n" +
+
+                    "1. 감정을 판단하거나 해결하려 들지 않습니다.\n" +
+                    "2. 조언, 위로를 넘어서는 충고, 긍정 강요는 하지 않습니다.\n" +
+                    "3. \"이 감정은 충분히 이해될 수 있습니다\", \"이상하지 않습니다\"와 같은\n" +
+                    "   감정의 정당성을 먼저 인정합니다.\n" +
+                    "4. 문체는 차분하고 담담하며, 과장되거나 시적인 표현은 사용하지 않습니다.\n" +
+                    "5. 2~4개의 짧은 문단으로 구성된 편지 형식으로 작성합니다.\n" +
+                    "6. 욕설, 비속어, 혐오 표현이나 특정 인물 또는 집단에 대한\n" +
+                    "   과도한 비난이나 공격적인 표현은 사용하지 않습니다.\n\n" +
+
+                    "출력 요구 사항:\n" +
+                    "입력된 글을 바탕으로 아래 작업을 수행하십시오.\n\n" +
+
+                    "1. 감정/상황을 대표하는 카테고리 1개만 선택합니다.\n" +
+                    "   - 카테고리는 2~15자 이내\n" +
+                    "   - 추상적이며 감정 중심의 단어\n" +
+                    "   - 예: 슬픔, 상실감, 기대, 자존감, 변화, 애착, 좌절 등\n\n" +
+
+                    "2. 사용자에게 보내는 공감 편지를 작성합니다.\n" +
+                    "   - 감정의 맥락을 자연스럽게 반영합니다.\n" +
+                    "   - \"당신이 느끼는 감정은 충분히 이해될 수 있습니다\" 또는\n" +
+                    "     \"이상하지 않습니다\"와 같은 감정 인정 문장을 반드시 포함합니다.\n" +
+                    "   - 편지 전체 분량은 200자 이내로 작성합니다.\n\n" +
+
+                    "3. 편지 내용을 한 줄로 요약합니다.\n" +
+                    "   - 감정을 요약하는 문장\n" +
+                    "   - 조언이나 결론형 표현 금지\n" +
+                    "   - 18자 이내로 작성합니다.\n\n" +
+
+                    "출력 형식:\n\n" +
+
+                    "아래 JSON 형식으로만 출력하십시오.\n" +
+                    "설명, 인사, 코드 블록, 추가 텍스트는 절대 포함하지 마십시오.\n\n" +
+
+                    "{\n" +
+                    "  \"category\": \"카테고리\",\n" +
+                    "  \"letter\": \"편지 내용 (200자 이내)\",\n" +
+                    "  \"summary\": \"한 줄 요약 (18자 이내)\"\n" +
+                    "}";
+
+
+
+
+    // JSON 블록 추출용 정규식
+    private static final Pattern JSON_PATTERN = Pattern.compile(
+            "(?s)(\\{(?:[^{}]|\\{[^{}]*\\})*\\}|\\[(?:[^\\[\\]]|\\[[^\\[\\]]*\\])*\\])"
+    );
+
+    private String abbreviate(String s, int max) {
+        if (s == null) return "null";
+        if (s.length() <= max) return s;
+        return s.substring(0, max) + "...(truncated)";
+    }
+
+    /**
+     *  LLM이 설명이나 프롤로그를 붙여도 첫 번째 JSON 블록만 안전 추출해서 파싱
+     */
+    private Optional<JsonNode> extractJsonSafely(String raw, ObjectMapper om) {
+        if (raw == null) return Optional.empty();
+        String trimmed = raw.trim();
+
+        // 처음부터 JSON이면 바로 시도
+        if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+                (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+            try {
+                return Optional.of(om.readTree(trimmed));
+            } catch (Exception ignore) {
+                // 아래 패턴 시도로 넘어감
+            }
+        }
+
+        //  본문에서 첫 JSON 블록 추출
+        Matcher m = JSON_PATTERN.matcher(trimmed);
+        if (m.find()) {
+            String json = m.group(1);
+            try {
+                return Optional.of(om.readTree(json));
+            } catch (Exception ignore) {
+                // fall through
+            }
+        }
+        return Optional.empty();
+    }
+
+
+    public JsonNode callChatGpt(String content) throws JsonProcessingException {
+
+        ObjectMapper objectMapper = new ObjectMapper();
+        // header 설정
+        HttpHeaders headers = new HttpHeaders();
+        headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
+        headers.setContentType(new MediaType("application", "json", StandardCharsets.UTF_8));
+        headers.setBearerAuth(apikey);
+
+        // system 프롬프트
+        String systemContent = String.format(instruction);
+
+        List<Map<String, String>> messages = new ArrayList<>();
+        messages.add(Map.of("role", "system", "content", systemContent));
+
+        // 사용자 입력
+        messages.add(Map.of("role", "user", "content", content));
+
+        // 요청 바디
+        Map<String, Object> bodyMap = new HashMap<>();
+        bodyMap.put("model", "gpt-4o-mini");
+        bodyMap.put("messages", messages);
+        bodyMap.put("temperature", 0.2);
+        bodyMap.put("max_tokens", 512);
+
+        Map<String, String> responseFormat = new HashMap<>();
+        responseFormat.put("type", "json_object");
+        bodyMap.put("response_format", responseFormat);
+
+        HttpEntity<String> request = new HttpEntity<>(objectMapper.writeValueAsString(bodyMap), headers);
+        RestTemplate restTemplate = new RestTemplate();
+        ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.POST, request, String.class);
+
+        return objectMapper.readTree(response.getBody());
+
+    }
+
+    public GptDTO.GptResponseDTO getAssistantMsg(String content) {
+        try {
+            JsonNode responseNode = callChatGpt(content);
+
+            String rawContent = responseNode
+                    .path("choices").get(0)
+                    .path("message")
+                    .path("content")
+                    .asText(null);
+            if (rawContent == null) {
+                log.error("GPT 응답에서 content가 null입니다. head={}", abbreviate(responseNode.toString(), 600));
+                throw new CustomException(ErrorCode.GPT_RESPONSE_FORMAT_ERROR);
+            }
+
+            // json 파싱 시도
+            ObjectMapper safeMapper = new ObjectMapper()
+                    .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+
+            Optional<JsonNode> parsedOpt = extractJsonSafely(rawContent, safeMapper);
+            if (parsedOpt.isEmpty()) {
+                log.error("LLM 응답에서 JSON 블록을 찾지 못함. rawHead={}", abbreviate(rawContent, 300));
+                throw new CustomException(ErrorCode.GPT_RESPONSE_FORMAT_ERROR);
+            }
+
+            JsonNode parsed = parsedOpt.get();
+
+            // 스키마 최소 검증
+            if (!parsed.has("category") || !parsed.has("letter") || !parsed.has("summary")) {
+                log.error("필수 필드 누락 jsonHead={}", abbreviate(parsed.toString(), 300));
+                throw new CustomException(ErrorCode.GPT_RESPONSE_FORMAT_ERROR);
+            }
+
+            // DTO 변환
+            return safeMapper.treeToValue(parsed, GptDTO.GptResponseDTO.class);
+
+        } catch (JsonProcessingException e) {
+            log.error("GPT 응답 파싱 실패: {}", e.getMessage(), e);
+            throw new CustomException(ErrorCode.GPT_RESPONSE_FORMAT_ERROR);
+        } catch (NullPointerException | IndexOutOfBoundsException e) {
+            log.error("GPT 응답 구조 이상(choices/message 누락 가능). head={}", e.getMessage(), e);
+            throw new CustomException(ErrorCode.GPT_RESPONSE_FORMAT_ERROR);
+        }
+    }
+
+
+}

src/main/java/umc/tosee/memory/controller/MemoryController.java

@@ -0,0 +1,90 @@
+package umc.tosee.memory.controller;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import io.swagger.v3.oas.annotations.Operation;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import umc.tosee.global.common.ApiResponse;
+import umc.tosee.global.common.SuccessCode;
+import umc.tosee.gpt.dto.GptDTO;
+import umc.tosee.memory.dto.MemoryDTO;
+import umc.tosee.memory.service.MemoryService;
+
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/memories")
+public class MemoryController {
+
+    private final MemoryService memoryService;
+
+    @Operation(
+            summary = "기억 입력",
+            description = """
+                    사용자가 입력한 기억 내용을 저장합니다.
+                    
+                    입력된 텍스트를 기반으로 GPT를 호출하여
+                    감정 카테고리 분류, 공감 편지, 한 줄 요약을 생성합니다.
+                    
+                    생성된 카테고리 ID 목록은 쿠키(memoryCategories)에 저장됩니다.
+                    """
+    )
+    @io.swagger.v3.oas.annotations.responses.ApiResponses({
+            @io.swagger.v3.oas.annotations.responses.ApiResponse(
+                    responseCode = "201",
+                    description = "기억 저장 및 GPT 응답 생성 성공",
+                    content = @io.swagger.v3.oas.annotations.media.Content(
+                            schema = @io.swagger.v3.oas.annotations.media.Schema(
+                                    implementation = GptDTO.GptResponseDTO.class
+                            )
+                    )
+            ),
+            @io.swagger.v3.oas.annotations.responses.ApiResponse(
+                    responseCode = "400",
+                    description = "잘못된 요청 (요청 본문 누락 또는 형식 오류)"
+            ),
+            @io.swagger.v3.oas.annotations.responses.ApiResponse(
+                    responseCode = "500",
+                    description = "서버 오류 또는 GPT 처리 실패"
+            )
+    })
+    @PostMapping
+    public ApiResponse<GptDTO.GptResponseDTO> saveMemory(
+
+            @io.swagger.v3.oas.annotations.parameters.RequestBody(
+                    description = "저장할 기억 내용",
+                    required = true,
+                    content = @io.swagger.v3.oas.annotations.media.Content(
+                            schema = @io.swagger.v3.oas.annotations.media.Schema(
+                                    implementation = MemoryDTO.MemoryRequestDTO.class
+                            ),
+                            examples = @io.swagger.v3.oas.annotations.media.ExampleObject(
+                                    value = """
+                                            {
+                                              "content": "열심히 준비한 일이 부정적인 평가를 받았을 때 느낀 감정"
+                                            }
+                                            """
+                            )
+                    )
+            )
+            @RequestBody
+            MemoryDTO.MemoryRequestDTO requestDTO,
+
+            @io.swagger.v3.oas.annotations.Parameter(
+                    description = "카테고리 ID를 쿠키로 저장하기 위한 HttpServletResponse",
+                    hidden = true
+            )
+            HttpServletResponse response
+
+    ) throws JsonProcessingException {
+
+        GptDTO.GptResponseDTO result =
+                memoryService.saveMemory(requestDTO, response);
+
+        return ApiResponse.onSuccess(result, SuccessCode.CREATED);
+    }
+}
+