feat: [ML-1188]: add a tool to find similar templates querying on vector db (#43)

* update tool name, add to readme

* fix count float

* feat: [ML-1188]: add a tool to find similar templates querying on vector db

Author: hingerabhinav

README.md

@@ -138,6 +138,7 @@ Toolset Name: `logs`
 Toolset Name: `templates`
 
 - `list_templates`: List templates at a given scope
+- `intelligent_template_search`: Find the most relevant templates based on a natural language description.
 
 #### Internal Developer Portal Toolset
 

client/dto/intelligence.go

@@ -0,0 +1,24 @@
+package dto
+
+// SimilaritySearchRequest represents a request for similarity search
+type SimilaritySearchRequest struct {
+	AccountID    string `json:"account_identifier"`
+	OrgID        string `json:"org_identifier,omitempty"`
+	ProjectID    string `json:"project_identifier,omitempty"`
+	Description  string `json:"description"`
+	Count        int    `json:"count,omitempty"`
+	TemplateType string `json:"template_type,omitempty"`
+}
+
+// SimilaritySearchResult represents a single similarity search result
+type SimilaritySearchResult struct {
+	ID       string      `json:"id"`
+	Text     string      `json:"text"`
+	Score    float64     `json:"score"`
+	Metadata interface{} `json:"metadata,omitempty"`
+}
+
+// SimilaritySearchResponse represents the response from a similarity search
+type SimilaritySearchResponse struct {
+	Results []SimilaritySearchResult `json:"results"`
+}

client/intelligence.go

@@ -0,0 +1,64 @@
+package client
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/harness/harness-mcp/client/dto"
+)
+
+const (
+	// Base API paths
+	similaritySearchPath = "api/v1/template-search"
+)
+
+type IntelligenceService struct {
+	Client *Client
+}
+
+func (ts *IntelligenceService) buildPath(basePath string) string {
+	return basePath
+}
+
+// SimilaritySearch searches for similar templates based on the provided request
+func (ts *IntelligenceService) SimilaritySearch(ctx context.Context, request *dto.SimilaritySearchRequest) (*dto.SimilaritySearchResponse, error) {
+	endpoint := ts.buildPath(similaritySearchPath)
+
+	// Validate required parameters
+	if request.AccountID == "" {
+		return nil, fmt.Errorf("account_identifier is required")
+	}
+	if request.Description == "" {
+		return nil, fmt.Errorf("description is required")
+	}
+
+	// Create query parameters map for all request fields
+	params := make(map[string]string)
+	params["account_identifier"] = request.AccountID
+
+	if request.OrgID != "" {
+		params["org_identifier"] = request.OrgID
+	}
+	if request.ProjectID != "" {
+		params["project_identifier"] = request.ProjectID
+	}
+
+	// Always include description as it's required
+	params["description"] = request.Description
+
+	// Include optional parameters
+	if request.TemplateType != "" {
+		params["template_type"] = request.TemplateType
+	}
+	if request.Count > 0 {
+		params["count"] = fmt.Sprintf("%d", request.Count)
+	}
+
+	var result dto.SimilaritySearchResponse
+	err := ts.Client.Get(ctx, endpoint, params, map[string]string{}, &result)
+	if err != nil {
+		return nil, fmt.Errorf("failed to perform similarity search: %w", err)
+	}
+
+	return &result, nil
+}

cmd/harness-mcp-server/config/config.go

@@ -38,6 +38,8 @@ type Config struct {
 	ChaosManagerSvcSecret   string
 	TemplateSvcBaseURL      string
 	TemplateSvcSecret       string
+	IntelligenceSvcBaseURL  string
+	IntelligenceSvcSecret   string
 	CodeSvcBaseURL          string
 	CodeSvcSecret           string
 	LogSvcBaseURL           string

cmd/harness-mcp-server/main.go

@@ -152,6 +152,8 @@ var (
 				ChaosManagerSvcSecret:   viper.GetString("chaos_manager_svc_secret"),
 				TemplateSvcBaseURL:      viper.GetString("template_svc_base_url"),
 				TemplateSvcSecret:       viper.GetString("template_svc_secret"),
+				IntelligenceSvcBaseURL:  viper.GetString("intelligence_svc_base_url"),
+				IntelligenceSvcSecret:   viper.GetString("intelligence_svc_secret"),
 				CodeSvcBaseURL:          viper.GetString("code_svc_base_url"),
 				CodeSvcSecret:           viper.GetString("code_svc_secret"),
 				LogSvcBaseURL:           viper.GetString("log_svc_base_url"),
@@ -251,6 +253,8 @@ func init() {
 	_ = viper.BindPFlag("nextgen_ce_secret", internalCmd.Flags().Lookup("nextgen-ce-secret"))
 	_ = viper.BindPFlag("template_svc_base_url", internalCmd.Flags().Lookup("template-svc-base-url"))
 	_ = viper.BindPFlag("template_svc_secret", internalCmd.Flags().Lookup("template-svc-secret"))
+	_ = viper.BindPFlag("intelligence_svc_base_url", internalCmd.Flags().Lookup("intelligence-svc-base-url"))
+	_ = viper.BindPFlag("intelligence_svc_secret", internalCmd.Flags().Lookup("intelligence-svc-secret"))
 	_ = viper.BindPFlag("chaos_manager_svc_base_url", internalCmd.Flags().Lookup("chaos-manager-svc-base-url"))
 	_ = viper.BindPFlag("chaos_manager_svc_secret", internalCmd.Flags().Lookup("chaos-manager-svc-secret"))
 	_ = viper.BindPFlag("code_svc_base_url", internalCmd.Flags().Lookup("code-svc-base-url"))

pkg/harness/intelligence.go

@@ -0,0 +1,84 @@
+package harness
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/harness/harness-mcp/client"
+	"github.com/harness/harness-mcp/client/dto"
+	"github.com/harness/harness-mcp/cmd/harness-mcp-server/config"
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
+// FindSimilarTemplates creates a tool that allows finding similar templates based on provided description.
+func FindSimilarTemplates(config *config.Config, client *client.IntelligenceService) (tool mcp.Tool, handler server.ToolHandlerFunc) {
+	return mcp.NewTool("intelligent_template_search",
+			mcp.WithDescription("Finds the most relevant templates based on a natural language description. " +
+				"Searches across template identifiers, names, types, capabilities, and use cases to find the best matches. " +
+				"Returns templates ranked by similarity score with metadata including template IDs and organizational context. " +
+				"Ideal for discovering templates that fulfill specific requirements without knowing exact identifiers."),
+			mcp.WithString("description",
+				mcp.Required(),
+				mcp.Description("Description of the template to find similar templates"),
+			),
+			mcp.WithString("template_type",
+				mcp.Description("Type of templates to find similar templates (e.g., Step, Stage, Pipeline)"),
+			),
+			mcp.WithNumber("count",
+				mcp.Description("Maximum number of similar templates to return"),
+			),
+			WithScope(config, false),
+		),
+		func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+			// Get required description parameter
+			description, err := requiredParam[string](request, "description")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			// Fetch optional parameters
+			templateType, err := OptionalParam[string](request, "template_type")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			// Handle count parameter as float64 (JSON default) and convert to int
+			countFloat, err := OptionalParam[float64](request, "count")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			count := int(countFloat)
+
+			// Try to fetch scope parameters (account_id, org_id, project_id) if provided
+			scope, err := fetchScope(config, request, false)
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			// Create similarity search request
+			similarityRequest := &dto.SimilaritySearchRequest{
+				AccountID:    scope.AccountID,
+				OrgID:        scope.OrgID,
+				ProjectID:    scope.ProjectID,
+				Description:  description,
+				Count:        count,
+				TemplateType: templateType,
+			}
+
+			// Call the similarity search API
+			result, err := client.SimilaritySearch(ctx, similarityRequest)
+			if err != nil {
+				return nil, fmt.Errorf("failed to perform similarity search: %w", err)
+			}
+
+			// Marshal and return the result
+			r, err := json.Marshal(result)
+			if err != nil {
+				return nil, fmt.Errorf("failed to marshal similarity search response: %w", err)
+			}
+
+			return mcp.NewToolResultText(string(r)), nil
+		}
+}

pkg/harness/tools.go

@@ -98,6 +98,10 @@ func InitToolsets(config *config.Config) (*toolsets.ToolsetGroup, error) {
 		return nil, err
 	}
 
+	if err := registerIntelligence(config, tsg); err != nil {
+		return nil, err
+	}
+
 	if err := registerInternalDeveloperPortal(config, tsg); err != nil {
 		return nil, err
 	}
@@ -700,6 +704,33 @@ func registerTemplates(config *config.Config, tsg *toolsets.ToolsetGroup) error
 	return nil
 }
 
+// registerIntelligence registers the intelligence toolset
+func registerIntelligence(config *config.Config, tsg *toolsets.ToolsetGroup) error {
+	// Determine the base URL and secret for intelligence
+	baseURL := buildServiceURL(config, config.IntelligenceSvcBaseURL, config.BaseURL, "harness-intelligence")
+	secret := config.IntelligenceSvcSecret
+
+	// Create base client for intelligence service
+	c, err := createClient(baseURL, config, secret)
+	if err != nil {
+		return err
+	}
+
+	intelligenceClient := &client.IntelligenceService{
+		Client: c,
+	}
+
+	// Create the intelligence toolset
+	intelligence := toolsets.NewToolset("intelligence", "Harness Intelligence related tools").
+		AddReadTools(
+			toolsets.NewServerTool(FindSimilarTemplates(config, intelligenceClient)),
+		)
+
+	// Add toolset to the group
+	tsg.AddToolset(intelligence)
+	return nil
+}
+
 func registerInternalDeveloperPortal(config *config.Config, tsg *toolsets.ToolsetGroup) error {
 	// Determine the base URL and secret for IDP service
 	baseURL := buildServiceURL(config, config.IDPSvcBaseURL, config.BaseURL, "")