This is an automated email from the ASF dual-hosted git repository.

LinkinStars pushed a commit to branch dev
in repository https://gitbox.apache.org/repos/asf/answer.git


The following commit(s) were added to refs/heads/dev by this push:
     new 947a48b6 fix(ai): stop advertising semantic_search when no vector 
search plugin is enabled (#1597)
947a48b6 is described below

commit 947a48b6437783c6bb0ec013ed32ec2366779e0f
Author: LiuDag <[email protected]>
AuthorDate: Fri Aug 28 14:58:34 2026 +0800

    fix(ai): stop advertising semantic_search when no vector search plugin is 
enabled (#1597)
    
    Fixes #1532.
    
    ### Problem
    
    The `semantic_search` MCP tool was always advertised to the model, even
    when
    no VectorSearch plugin was enabled. The model could select it, the call
    reached `EmbeddingService.SearchSimilar`, and every such conversation
    logged
    `semantic search failed: semantic search is not available: no vector
    search
    plugin is enabled` — polluting logs and wasting a tool-call round trip
    on a
    capability that does not exist in the deployment.
    
    ### Fix
    
    - `EmbeddingService.Available()` reports whether a VectorSearch plugin
    is
      currently enabled.
    - `MCPController.SemanticSearchAvailable()` exposes that to the AI chat.
    - `getMCPTools()` omits the `semantic_search` tool when unavailable; all
      other MCP tools keep working exactly as before.
    - The default AI prompts (zh/en, and admin-custom prompts) drop the
    `semantic_search` instruction lines in the same situation, so the model
    is
      no longer nudged toward a missing capability.
    
    ### Testing
    
    - New unit tests: tool advertisement with/without the capability,
    prompt-line
    stripping, and prompt adaptation
    (`internal/controller/ai_tools_test.go`).
    - `go test ./internal/controller/` — all pass.
    
    Co-authored-by: LinkinStars <[email protected]>
---
 internal/controller/ai_controller.go            | 56 ++++++++++++---
 internal/controller/ai_tools_test.go            | 90 +++++++++++++++++++++++++
 internal/controller/mcp_controller.go           |  7 ++
 internal/service/embedding/embedding_service.go |  6 ++
 4 files changed, 149 insertions(+), 10 deletions(-)

diff --git a/internal/controller/ai_controller.go 
b/internal/controller/ai_controller.go
index 4c5c4cdd..c2fcc873 100644
--- a/internal/controller/ai_controller.go
+++ b/internal/controller/ai_controller.go
@@ -43,7 +43,6 @@ import (
        tagcommonser "github.com/apache/answer/internal/service/tag_common"
        usercommon "github.com/apache/answer/internal/service/user_common"
        "github.com/apache/answer/pkg/token"
-       "github.com/apache/answer/plugin"
        "github.com/gin-gonic/gin"
        "github.com/mark3labs/mcp-go/mcp"
        "github.com/sashabaranov/go-openai"
@@ -325,19 +324,45 @@ func (c *AIController) getPromptByLanguage(language 
i18n.Language, question stri
                return c.getDefaultPrompt(language, question)
        }
 
-       return fmt.Sprintf(promptTemplate, question)
+       return c.adaptPromptToCapabilities(fmt.Sprintf(promptTemplate, 
question))
 }
 
 // getDefaultPrompt prompt
 func (c *AIController) getDefaultPrompt(language i18n.Language, question 
string) string {
+       var prompt string
        switch language {
        case i18n.LanguageChinese:
-               return fmt.Sprintf(constant.DefaultAIPromptConfigZhCN, question)
+               prompt = fmt.Sprintf(constant.DefaultAIPromptConfigZhCN, 
question)
        case i18n.LanguageEnglish:
-               return fmt.Sprintf(constant.DefaultAIPromptConfigEnUS, question)
+               prompt = fmt.Sprintf(constant.DefaultAIPromptConfigEnUS, 
question)
        default:
-               return fmt.Sprintf(constant.DefaultAIPromptConfigEnUS, question)
+               prompt = fmt.Sprintf(constant.DefaultAIPromptConfigEnUS, 
question)
        }
+       return c.adaptPromptToCapabilities(prompt)
+}
+
+// adaptPromptToCapabilities removes instructions for tools the current
+// deployment cannot serve, so the model is never prompted to call a missing
+// capability.
+func (c *AIController) adaptPromptToCapabilities(prompt string) string {
+       if c.mcpController.SemanticSearchAvailable() {
+               return prompt
+       }
+       return stripSemanticSearchLine(prompt)
+}
+
+// stripSemanticSearchLine drops every prompt line that references the
+// semantic_search tool.
+func stripSemanticSearchLine(prompt string) string {
+       lines := strings.Split(prompt, "\n")
+       kept := make([]string, 0, len(lines))
+       for _, line := range lines {
+               if strings.Contains(line, semanticSearchToolName) {
+                       continue
+               }
+               kept = append(kept, line)
+       }
+       return strings.Join(kept, "\n")
 }
 
 // initializeConversationContext
@@ -700,12 +725,23 @@ func (c *AIController) sendErrorResponse(w 
http.ResponseWriter, id, model, error
        sendStreamData(w, errorResponse)
 }
 
-// getMCPTools
+// semanticSearchToolName is the MCP tool backed by the optional VectorSearch
+// plugin. It must not be advertised when no such plugin is enabled.
+const semanticSearchToolName = "semantic_search"
+
+// getMCPTools builds the tool list advertised to the model. The
+// semantic_search tool is omitted when no VectorSearch plugin is enabled,
+// otherwise the model can select a capability that always fails.
 func (c *AIController) getMCPTools() []openai.Tool {
-       openaiTools := make([]openai.Tool, 0)
-       vectorSearchEnabled := plugin.IsVectorSearchEnabled()
-       for _, mcpTool := range mcp_tools.MCPToolsList {
-               if mcpTool.Name == "semantic_search" && !vectorSearchEnabled {
+       return c.buildOpenAITools(mcp_tools.MCPToolsList, 
c.mcpController.SemanticSearchAvailable())
+}
+
+// buildOpenAITools converts MCP tools into OpenAI tool definitions, optionally
+// excluding the semantic_search tool.
+func (c *AIController) buildOpenAITools(tools []mcp.Tool, 
includeSemanticSearch bool) []openai.Tool {
+       openaiTools := make([]openai.Tool, 0, len(tools))
+       for _, mcpTool := range tools {
+               if !includeSemanticSearch && mcpTool.Name == 
semanticSearchToolName {
                        continue
                }
                openaiTool := c.convertMCPToolToOpenAI(mcpTool)
diff --git a/internal/controller/ai_tools_test.go 
b/internal/controller/ai_tools_test.go
new file mode 100644
index 00000000..363ca04b
--- /dev/null
+++ b/internal/controller/ai_tools_test.go
@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package controller
+
+import (
+       "strings"
+       "testing"
+
+       "github.com/apache/answer/internal/schema/mcp_tools"
+       "github.com/apache/answer/internal/service/embedding"
+)
+
+func toolNames(c *AIController, includeSemanticSearch bool) map[string]bool {
+       tools := c.buildOpenAITools(mcp_tools.MCPToolsList, 
includeSemanticSearch)
+       names := make(map[string]bool, len(tools))
+       for _, t := range tools {
+               names[t.Function.Name] = true
+       }
+       return names
+}
+
+func TestBuildOpenAIToolsIncludesSemanticSearch(t *testing.T) {
+       c := &AIController{}
+       names := toolNames(c, true)
+       if !names[semanticSearchToolName] {
+               t.Fatalf("semantic_search should be advertised when a vector 
search plugin is available: %v", names)
+       }
+       if len(names) != len(mcp_tools.MCPToolsList) {
+               t.Fatalf("expect %d tools, got %d", 
len(mcp_tools.MCPToolsList), len(names))
+       }
+}
+
+func TestBuildOpenAIToolsExcludesSemanticSearch(t *testing.T) {
+       c := &AIController{}
+       names := toolNames(c, false)
+       if names[semanticSearchToolName] {
+               t.Fatalf("semantic_search must not be advertised without a 
vector search plugin")
+       }
+       if len(names) != len(mcp_tools.MCPToolsList)-1 {
+               t.Fatalf("expect %d tools, got %d", 
len(mcp_tools.MCPToolsList)-1, len(names))
+       }
+       if !names["get_questions"] || !names["get_user"] {
+               t.Fatalf("other MCP tools must remain advertised: %v", names)
+       }
+}
+
+func TestStripSemanticSearchLine(t *testing.T) {
+       prompt := "You are an assistant.\n- get_questions: search questions\n- 
semantic_search: search by meaning\n- get_user: search users\n"
+       got := stripSemanticSearchLine(prompt)
+       if strings.Contains(got, "semantic_search") {
+               t.Fatalf("semantic_search line not stripped: %q", got)
+       }
+       if !strings.Contains(got, "get_questions") || !strings.Contains(got, 
"get_user") {
+               t.Fatalf("unrelated lines were dropped: %q", got)
+       }
+       if !strings.HasPrefix(got, "You are an assistant.\n") {
+               t.Fatalf("leading lines must be kept: %q", got)
+       }
+}
+
+func TestAdaptPromptToCapabilitiesStripsWhenUnavailable(t *testing.T) {
+       // In tests no VectorSearch plugin is registered, so semantic search is
+       // unavailable and the prompt must be adapted.
+       c := &AIController{mcpController: &MCPController{embeddingService: 
&embedding.EmbeddingService{}}}
+       prompt := "intro\n- semantic_search: search by meaning\noutro\n"
+       got := c.adaptPromptToCapabilities(prompt)
+       if strings.Contains(got, "semantic_search") {
+               t.Fatalf("expected semantic_search line removed: %q", got)
+       }
+       if !strings.Contains(got, "intro") || !strings.Contains(got, "outro") {
+               t.Fatalf("other content must be preserved: %q", got)
+       }
+}
diff --git a/internal/controller/mcp_controller.go 
b/internal/controller/mcp_controller.go
index e24c1a54..942117f4 100644
--- a/internal/controller/mcp_controller.go
+++ b/internal/controller/mcp_controller.go
@@ -488,3 +488,10 @@ func (c *MCPController) MCPSemanticSearchHandler() 
func(ctx context.Context, req
                return mcp.NewToolResultText(string(data)), nil
        }
 }
+
+// SemanticSearchAvailable reports whether a VectorSearch plugin is currently
+// enabled, so the AI chat can omit the semantic_search tool entirely instead
+// of letting the model call into a missing capability.
+func (c *MCPController) SemanticSearchAvailable() bool {
+       return c.embeddingService.Available()
+}
diff --git a/internal/service/embedding/embedding_service.go 
b/internal/service/embedding/embedding_service.go
index c69d60d8..62fccb42 100644
--- a/internal/service/embedding/embedding_service.go
+++ b/internal/service/embedding/embedding_service.go
@@ -35,6 +35,12 @@ func NewEmbeddingService() *EmbeddingService {
        return &EmbeddingService{}
 }
 
+// Available reports whether a VectorSearch plugin is currently enabled, so
+// callers can hide semantic search capabilities instead of failing at call 
time.
+func (s *EmbeddingService) Available() bool {
+       return plugin.IsVectorSearchEnabled()
+}
+
 // SearchSimilar delegates to the VectorSearch plugin.
 // Returns an error if no plugin is enabled.
 func (s *EmbeddingService) SearchSimilar(ctx context.Context, query string, 
topK int) ([]plugin.VectorSearchResult, error) {

Reply via email to