[Developer] #569 plain text vector Top-K probe

src/main/java/com/cloudhandson/vpdbackoffice/domain/vector/VectorQueryEmbedding.java

@@ -0,0 +1,9 @@
+package com.cloudhandson.vpdbackoffice.domain.vector;
+
+public record VectorQueryEmbedding(
+    String query,
+    String embeddingMode,
+    String embeddingModel,
+    String requestBody
+) {
+}

src/main/java/com/cloudhandson/vpdbackoffice/service/VectorKnowledgeService.java

@@ -8,6 +8,7 @@ import com.cloudhandson.vpdbackoffice.domain.vector.VectorChunk;
 import com.cloudhandson.vpdbackoffice.domain.vector.VectorIngestCommand;
 import com.cloudhandson.vpdbackoffice.domain.vector.VectorIngestResult;
 import com.cloudhandson.vpdbackoffice.domain.vector.VectorKnowledgeSummary;
+import com.cloudhandson.vpdbackoffice.domain.vector.VectorQueryEmbedding;
 import com.cloudhandson.vpdbackoffice.domain.vector.VectorSearchResult;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import java.util.ArrayList;
@@ -73,6 +74,16 @@ public class VectorKnowledgeService {
     return embeddingClient.embeddingConfigured();
   }
 
+  public VectorQueryEmbedding vectorizeQuery(String query, String embeddingMode) {
+    String normalizedQuery = required(query, "검색 질문");
+    String mode = normalizeMode(embeddingMode);
+    return new VectorQueryEmbedding(
+        normalizedQuery,
+        mode,
+        embeddingModel(mode),
+        "{\"embedding\":" + json(embed(normalizedQuery, mode)) + "}");
+  }
+
   @Transactional
   public VectorIngestResult ingest(VectorIngestCommand command) {
     String documentId = requiredDocumentId(command.documentId());
@@ -112,19 +123,19 @@ public class VectorKnowledgeService {
   }
 
   public VectorSearchResult search(long userId, String query, int limit, String embeddingMode) {
-    String normalizedQuery = required(query, "검색 질문");
     ProtectedObject vectorObject = protectedObjectService.findEnabled().stream()
         .filter(object -> VECTOR_OBJECT.equalsIgnoreCase(object.objectName()))
         .findFirst()
         .orElseThrow(() -> new AppException(
             "CB_VECTOR_SEARCH_DOCUMENTS 보호 객체가 없습니다. 28_agent_ords_vector_tag_vpd_setup.sql을 먼저 실행하세요."));
-    String mode = normalizeMode(embeddingMode);
-    String requestBody = "{\"embedding\":" + json(embed(normalizedQuery, mode)) + "}";
+    VectorQueryEmbedding vectorQuery = vectorizeQuery(query, embeddingMode);
     IssuedToken temporary = tokenService.issueTemporaryToken(userId, "지식 검색 검증 세션");
     try {
       ProbeResult probe = ordsProbeService.runProbe(new ProbeCommand(
-          temporary.keyId(), vectorObject.objectId(), temporary.plainToken(), normalizeLimit(limit), requestBody));
-      return new VectorSearchResult(normalizedQuery, mode, embeddingModel(mode), probe);
+          temporary.keyId(), vectorObject.objectId(), temporary.plainToken(), normalizeLimit(limit),
+          vectorQuery.requestBody()));
+      return new VectorSearchResult(
+          vectorQuery.query(), vectorQuery.embeddingMode(), vectorQuery.embeddingModel(), probe);
     } finally {
       tokenService.revokeToken(temporary.keyId(), "temporary vector search completed");
     }

src/main/java/com/cloudhandson/vpdbackoffice/web/ProbeController.java

@@ -2,9 +2,12 @@ package com.cloudhandson.vpdbackoffice.web;
 
 import com.cloudhandson.vpdbackoffice.domain.probe.ProbeCommand;
 import com.cloudhandson.vpdbackoffice.domain.protectedobject.ProtectedObject;
+import com.cloudhandson.vpdbackoffice.domain.vector.VectorQueryEmbedding;
+import com.cloudhandson.vpdbackoffice.service.AppException;
 import com.cloudhandson.vpdbackoffice.service.BearerTokenService;
 import com.cloudhandson.vpdbackoffice.service.OrdsProbeService;
 import com.cloudhandson.vpdbackoffice.service.ProtectedObjectService;
+import com.cloudhandson.vpdbackoffice.service.VectorKnowledgeService;
 import com.cloudhandson.vpdbackoffice.service.VpdPolicyService;
 import com.cloudhandson.vpdbackoffice.mapper.UserMapper;
 import java.util.Comparator;
@@ -25,19 +28,22 @@ public class ProbeController {
   private final BearerTokenService tokenService;
   private final VpdPolicyService vpdPolicyService;
   private final UserMapper userMapper;
+  private final VectorKnowledgeService vectorKnowledgeService;
 
   public ProbeController(
       OrdsProbeService probeService,
       ProtectedObjectService protectedObjectService,
       BearerTokenService tokenService,
       VpdPolicyService vpdPolicyService,
-      UserMapper userMapper
+      UserMapper userMapper,
+      VectorKnowledgeService vectorKnowledgeService
   ) {
     this.probeService = probeService;
     this.protectedObjectService = protectedObjectService;
     this.tokenService = tokenService;
     this.vpdPolicyService = vpdPolicyService;
     this.userMapper = userMapper;
+    this.vectorKnowledgeService = vectorKnowledgeService;
   }
 
   @GetMapping("/probe")
@@ -53,6 +59,7 @@ public class ProbeController {
     model.addAttribute("objects", objects);
     model.addAttribute("defaultObjectKeys", defaultObjectKeys);
     model.addAttribute("users", userMapper.findAll());
+    model.addAttribute("aiEmbeddingConfigured", vectorKnowledgeService.aiEmbeddingConfigured());
     return "probe";
   }
 
@@ -63,9 +70,17 @@ public class ProbeController {
       @RequestParam(required = false) Long tempUserId,
       @RequestParam(defaultValue = "50") int limit,
       @RequestParam(required = false) String requestBody,
+      @RequestParam(defaultValue = "DEMO") String embeddingMode,
       Model model
   ) {
     String normalizedToken = bearerToken == null ? "" : bearerToken.trim();
+    ProtectedObject selectedObject = protectedObjectService.findEnabled().stream()
+        .filter(object -> object.objectId() == objectId)
+        .findFirst()
+        .orElse(null);
+    boolean vectorSearch = selectedObject != null
+        && VectorKnowledgeService.VECTOR_OBJECT.equalsIgnoreCase(selectedObject.objectName());
+    model.addAttribute("vectorSearch", vectorSearch);
     Long temporaryKeyId = null;
     if (tempUserId != null) {
       var issued = tokenService.issueTemporaryToken(tempUserId, "ORDS 검증 임시 실행");
@@ -73,18 +88,24 @@ public class ProbeController {
       temporaryKeyId = issued.keyId();
     }
     try {
+      if (vectorSearch) {
+        VectorQueryEmbedding vectorQuery = vectorKnowledgeService.vectorizeQuery(requestBody, embeddingMode);
+        requestBody = vectorQuery.requestBody();
+        model.addAttribute("vectorQuery", vectorQuery.query());
+        model.addAttribute("vectorEmbeddingMode", vectorQuery.embeddingMode());
+        model.addAttribute("vectorEmbeddingModel", vectorQuery.embeddingModel());
+      }
       model.addAttribute("result", probeService.runProbe(
           new ProbeCommand(temporaryKeyId, objectId, normalizedToken, limit, requestBody)));
       model.addAttribute("tokenContext", tokenService.findTokenContextByPlainToken(normalizedToken));
+    } catch (AppException exception) {
+      model.addAttribute("errorMessage", exception.getMessage());
     } finally {
       if (temporaryKeyId != null) {
         tokenService.revokeToken(temporaryKeyId, "temporary probe completed");
       }
     }
-    model.addAttribute("selectedObject", protectedObjectService.findEnabled().stream()
-        .filter(object -> object.objectId() == objectId)
-        .findFirst()
-        .orElse(null));
+    model.addAttribute("selectedObject", selectedObject);
     return "fragments/probe-result :: result";
   }
 

src/main/resources/static/js/app.js

@@ -503,17 +503,25 @@ function initProbeObjectDescription() {
 
 function initProbeVectorInput() {
   const select = document.querySelector('select[name="objectId"]');
-  const block = document.querySelector('[data-vector-probe-input]');
-  const input = block?.querySelector('textarea[name="requestBody"]');
-  if (!select || !block || !input) {
+  const blocks = document.querySelectorAll('[data-vector-probe-input]');
+  const input = document.querySelector('[data-vector-probe-input] textarea[name="requestBody"]');
+  const controls = document.querySelectorAll('[data-vector-probe-input] textarea, [data-vector-probe-input] select, [data-vector-probe-input] input');
+  if (!select || !blocks.length || !input) {
     return;
   }
   const update = () => {
     const option = selectedOption(select);
     const isVectorSearch = option?.dataset.vectorSearch === 'true';
-    block.hidden = !isVectorSearch;
-    input.disabled = !isVectorSearch;
+    blocks.forEach(block => {
+      block.hidden = !isVectorSearch;
+    });
+    controls.forEach(control => {
+      control.disabled = !isVectorSearch;
+    });
     input.required = isVectorSearch;
+    if (!isVectorSearch) {
+      input.value = '';
+    }
   };
   select.addEventListener('change', update);
   update();

src/main/resources/templates/fragments/probe-result.html

@@ -2,6 +2,8 @@
 <html lang="ko" xmlns:th="http://www.thymeleaf.org">
 <body>
 <div th:fragment="result" class="probe-result-flow">
+  <div class="alert alert-danger" th:if="${errorMessage}" th:text="${errorMessage}"></div>
+  <th:block th:if="${result}">
   <div class="section-heading">
     <div>
       <span class="architecture-kicker">검증 결론</span>
@@ -58,7 +60,43 @@
       </div>
     </div>
 
-    <div class="table-responsive mt-3" th:if="${!#lists.isEmpty(result.rows())}">
+    <div class="vector-result-panel mt-3"
+         th:if="${vectorSearch and !#lists.isEmpty(result.rows())}">
+      <div class="section-heading compact-heading">
+        <div>
+          <h3>벡터 검색 Top-K</h3>
+          <p class="section-subtitle">거리(SCORE)가 낮은 순서로 VPD를 통과한 검색 단위를 반환했습니다.</p>
+        </div>
+        <span class="badge text-bg-light" th:text="${'K=' + result.rowCount()}">K=0</span>
+      </div>
+      <p class="form-hint" th:text="${'검색어: ' + vectorQuery + ' · 임베딩: ' + vectorEmbeddingMode + ' · 모델: ' + vectorEmbeddingModel}">검색 정보</p>
+      <div class="table-responsive mt-3">
+        <table class="table table-sm align-middle">
+          <thead>
+          <tr>
+            <th>검색 단위 ID</th>
+            <th>자료 ID</th>
+            <th>제목</th>
+            <th>기술 태그</th>
+            <th>벡터 거리 (SCORE)</th>
+            <th>본문</th>
+          </tr>
+          </thead>
+          <tbody>
+          <tr th:each="row : ${result.rows()}">
+            <td th:text="${row['CHUNK_ID'] ?: row['chunk_id']}">28001</td>
+            <td th:text="${row['DOCUMENT_ID'] ?: row['document_id']}">knowledge-001</td>
+            <td th:text="${row['TITLE'] ?: row['title']}">제목</td>
+            <td><code th:text="${row['TECH_TAG'] ?: row['tech_tag']}">ORDS</code></td>
+            <td th:text="${row['SCORE'] ?: row['score']}">0.01</td>
+            <td class="matrix-list" th:text="${row['CHUNK_TEXT'] ?: row['chunk_text']}">본문</td>
+          </tr>
+          </tbody>
+        </table>
+      </div>
+    </div>
+
+    <div class="table-responsive mt-3" th:if="${!vectorSearch and !#lists.isEmpty(result.rows())}">
       <table class="table table-sm table-striped align-middle">
         <thead><tr><th th:each="column : ${result.columns()}" th:text="${column}">column</th></tr></thead>
         <tbody>
@@ -120,6 +158,7 @@
       <section class="probe-exchange"><h3>Response Body</h3><pre th:text="${result.responseBody()} ?: ''"></pre></section>
     </div>
   </details>
+  </th:block>
 </div>
 </body>
 </html>

src/main/resources/templates/probe.html

@@ -67,10 +67,18 @@
           <span class="form-hint">권한 판정에는 영향을 주지 않고 화면에 가져올 최대 행만 제한합니다.</span>
         </label>
         <label class="span-2 vector-probe-input" data-vector-probe-input hidden>
-          벡터 검색 요청 본문 (JSON)
-          <textarea class="form-control" name="requestBody" rows="3" disabled
-                    placeholder='{"embedding":[0.10,0.20,0.30,0.40]}'></textarea>
-          <span class="form-hint">벡터 검색 객체를 선택했을 때만 필요합니다. 검색어를 외부 임베딩 모델로 바꾼 배열을 넣습니다.</span>
+          벡터 검색어 (평문)
+          <textarea class="form-control" name="requestBody" rows="3" required disabled
+                    placeholder="예: Oracle VPD에서 ORDS 권한을 적용하는 방법"></textarea>
+          <span class="form-hint">검색어를 평문으로 입력하면 백오피스가 같은 임베딩 방식으로 벡터화해 전용 ORDS Handler에 전달합니다.</span>
+        </label>
+        <label class="vector-probe-input" data-vector-probe-input hidden>
+          임베딩 방식
+          <select class="form-select" name="embeddingMode" disabled>
+            <option value="DEMO">로컬 임베딩(개발용)</option>
+            <option value="AI" th:disabled="${!aiEmbeddingConfigured}">AI 임베딩</option>
+          </select>
+          <span class="form-hint">자료 등록 때 사용한 방식·차원과 맞춰야 합니다. AI 설정이 없으면 로컬 임베딩을 사용하세요.</span>
         </label>
         <button class="btn rw-btn-primary probe-submit" type="submit">3. 권한 결과 확인</button>
     </form>

src/test/java/com/cloudhandson/vpdbackoffice/service/VectorKnowledgeServiceTest.java

@@ -0,0 +1,55 @@
+package com.cloudhandson.vpdbackoffice.service;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.mock;
+
+import com.cloudhandson.vpdbackoffice.domain.vector.VectorQueryEmbedding;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.Test;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+class VectorKnowledgeServiceTest {
+
+  @Test
+  void vectorizesPlainTextWithTheLocalEmbeddingAndBuildsOrdsBody() {
+    OpenAiCompatibleClient embeddingClient = mock(OpenAiCompatibleClient.class);
+    VectorKnowledgeService service = service(embeddingClient);
+
+    VectorQueryEmbedding result = service.vectorizeQuery("  Oracle VPD에서 ORDS 권한 확인  ", "demo");
+
+    assertThat(result.query()).isEqualTo("Oracle VPD에서 ORDS 권한 확인");
+    assertThat(result.embeddingMode()).isEqualTo("DEMO");
+    assertThat(result.embeddingModel()).isEqualTo("로컬 임베딩(개발용)");
+    assertThat(result.requestBody()).startsWith("{\"embedding\":[").contains("]}");
+  }
+
+  @Test
+  void rejectsAiModeWhenEmbeddingConfigurationIsMissing() {
+    OpenAiCompatibleClient embeddingClient = mock(OpenAiCompatibleClient.class);
+    VectorKnowledgeService service = service(embeddingClient);
+
+    assertThatThrownBy(() -> service.vectorizeQuery("검색어", "AI"))
+        .isInstanceOf(AppException.class)
+        .hasMessageContaining("AI 임베딩이 설정되지 않았습니다");
+  }
+
+  @Test
+  void rejectsBlankPlainTextBeforeCallingOrds() {
+    VectorKnowledgeService service = service(mock(OpenAiCompatibleClient.class));
+
+    assertThatThrownBy(() -> service.vectorizeQuery("  ", "DEMO"))
+        .isInstanceOf(AppException.class)
+        .hasMessageContaining("검색 질문");
+  }
+
+  private VectorKnowledgeService service(OpenAiCompatibleClient embeddingClient) {
+    return new VectorKnowledgeService(
+        mock(JdbcTemplate.class),
+        new ObjectMapper(),
+        embeddingClient,
+        mock(ProtectedObjectService.class),
+        mock(BearerTokenService.class),
+        mock(OrdsProbeService.class));
+  }
+}

src/test/java/com/cloudhandson/vpdbackoffice/web/GuidedFlowTemplateTest.java

@@ -28,10 +28,15 @@ class GuidedFlowTemplateTest {
     assertThat(probe)
         .contains("name=\"bearerToken\"")
         .contains("검증 세션 사용자")
+        .contains("벡터 검색어 (평문)")
+        .contains("임베딩 방식")
+        .doesNotContain("벡터 검색 요청 본문 (JSON)")
         .doesNotContain("name=\"tokenKeyId\"");
     assertThat(result)
         .contains("적용된 사용자와 권한")
         .contains("토큰 적용 후 SQL")
+        .contains("벡터 검색 Top-K")
+        .contains("벡터 거리 (SCORE)")
         .contains("vpd_predicate")
         .contains("다음에 할 일")
         .contains("<details")