feat: [ML-1118]: Init chatbot service for internal MCP usage (#11)

* feat: [ML-1118]: Init chatbot service for internal MCP usage

Author: David-Kreiner

client/chatbot.go

@@ -0,0 +1,43 @@
+package client
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/harness/harness-mcp/client/dto"
+)
+
+// There are no external paths for the chatbot-service
+const (
+	chatPath = "chat"
+)
+
+type ChatbotService struct {
+	Client *Client
+}
+
+func (c *ChatbotService) SendChatMessage(ctx context.Context, scope dto.Scope, request *dto.ChatRequest) (string, error) {
+	path := chatPath
+	params := make(map[string]string)
+	
+	// Only add non-empty scope parameters
+	if scope.AccountID != "" {
+		params["accountIdentifier"] = scope.AccountID
+	}
+	
+	if scope.OrgID != "" {
+		params["orgIdentifier"] = scope.OrgID
+	}
+	
+	if scope.ProjectID != "" {
+		params["projectIdentifier"] = scope.ProjectID
+	}
+
+	var response string
+	err := c.Client.Post(ctx, path, params, request, &response)
+	if err != nil {
+		return "", fmt.Errorf("failed to send message to chatbot: %w", err)
+	}
+
+	return response, nil
+}

client/dto/chatbot.go

@@ -0,0 +1,11 @@
+package dto
+
+type ChatHistoryItem struct {
+	Question string `json:"question"`
+	Answer   string `json:"answer"`
+}
+
+type ChatRequest struct {
+	Question    string           `json:"question"`
+	ChatHistory []ChatHistoryItem `json:"chat_history,omitempty"` 
+}

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

@@ -23,5 +23,7 @@ type Config struct {
 	PipelineSvcSecret  string
 	NgManagerBaseURL   string
 	NgManagerSecret    string
+	ChatbotBaseURL     string
+	ChatbotSecret      string
 	McpSvcSecret       string
 }

cmd/harness-mcp-server/main.go

@@ -137,6 +137,8 @@ var (
 				PipelineSvcSecret:  viper.GetString("pipeline_svc_secret"),
 				NgManagerBaseURL:   viper.GetString("ng_manager_base_url"),
 				NgManagerSecret:    viper.GetString("ng_manager_secret"),
+				ChatbotBaseURL:     viper.GetString("chatbot_base_url"),
+				ChatbotSecret:      viper.GetString("chatbot_secret"),
 				McpSvcSecret:       viper.GetString("mcp_svc_secret"),
 			}
 
@@ -174,6 +176,8 @@ func init() {
 	internalCmd.Flags().String("pipeline-svc-secret", "", "Secret for pipeline service")
 	internalCmd.Flags().String("ng-manager-base-url", "", "Base URL for NG manager")
 	internalCmd.Flags().String("ng-manager-secret", "", "Secret for NG manager")
+	internalCmd.Flags().String("chatbot-base-url", "", "Base URL for chatbot service")
+	internalCmd.Flags().String("chatbot-secret", "", "Secret for chatbot service")
 	internalCmd.Flags().String("mcp-svc-secret", "", "Secret for MCP service")
 
 	// Bind global flags to viper
@@ -194,6 +198,8 @@ func init() {
 	_ = viper.BindPFlag("pipeline_svc_secret", internalCmd.Flags().Lookup("pipeline-svc-secret"))
 	_ = viper.BindPFlag("ng_manager_base_url", internalCmd.Flags().Lookup("ng-manager-base-url"))
 	_ = viper.BindPFlag("ng_manager_secret", internalCmd.Flags().Lookup("ng-manager-secret"))
+	_ = viper.BindPFlag("chatbot_base_url", internalCmd.Flags().Lookup("chatbot-base-url"))
+	_ = viper.BindPFlag("chatbot_secret", internalCmd.Flags().Lookup("chatbot-secret"))
 	_ = viper.BindPFlag("mcp_svc_secret", internalCmd.Flags().Lookup("mcp-svc-secret"))
 
 	// Add subcommands

pkg/harness/chatbot.go

@@ -0,0 +1,64 @@
+package harness
+
+import (
+	"context"
+	"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"
+)
+
+func AskChatbotTool(config *config.Config, client *client.ChatbotService) (tool mcp.Tool, handler server.ToolHandlerFunc) {
+	return mcp.NewTool("ask_chatbot",
+			mcp.WithDescription("Ask a question about Harness products and documentation to the Harness Documentation Bot. The bot uses AI to retrieve and summarize relevant information from Harness documentation."),
+			mcp.WithString("question",
+				mcp.Required(),
+				mcp.Description("The question to ask the chatbot"),
+			),
+			mcp.WithArray("chat_history",
+				mcp.Description("Optional chat history for context"),
+			),
+			WithScope(config, false),
+		),
+		func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+			question, err := requiredParam[string](request, "question")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			scope, err := fetchScope(config, request, false)
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			var chatHistory []dto.ChatHistoryItem
+			chatHistoryRaw, err := OptionalParam[[]interface{}](request, "chat_history")
+			if err == nil && len(chatHistoryRaw) > 0 {
+				for _, historyItem := range chatHistoryRaw {
+					if historyItemMap, ok := historyItem.(map[string]interface{}); ok {
+						questionStr, _ := historyItemMap["question"].(string)
+						answerStr, _ := historyItemMap["answer"].(string)
+						chatHistory = append(chatHistory, dto.ChatHistoryItem{
+							Question: questionStr,
+							Answer:   answerStr,
+						})
+					}
+				}
+			}
+
+			chatRequest := &dto.ChatRequest{
+				Question:    question,
+				ChatHistory: chatHistory,
+			}
+
+			response, err := client.SendChatMessage(ctx, scope, chatRequest)
+			if err != nil {
+				return nil, fmt.Errorf("failed to send message to chatbot: %w", err)
+			}
+
+			return mcp.NewToolResultText(response), nil
+		}
+}

pkg/harness/tools.go

@@ -33,6 +33,11 @@ func InitToolsets(config *config.Config) (*toolsets.ToolsetGroup, error) {
 		return nil, err
 	}
 
+	// Register chatbot
+	if err := registerChatbot(config, tsg); err != nil {
+		return nil, err
+	}
+
 	// TODO: support internal mode for other endpoints as well eventually
 	if err := registerPullRequests(config, tsg); err != nil {
 		return nil, err
@@ -221,6 +226,36 @@ func registerRegistries(config *config.Config, tsg *toolsets.ToolsetGroup) error
 	return nil
 }
 
+// registerChatbot registers the chatbot toolset
+func registerChatbot(config *config.Config, tsg *toolsets.ToolsetGroup) error {
+	// Skip registration for external mode (no external service exposed)
+	if !config.Internal {
+		return nil
+	}
+
+	// Determine the base URL and secret for chatbot service
+	baseURL := config.ChatbotBaseURL
+	secret := config.ChatbotSecret
+	
+	// Create base client for chatbot
+	c, err := createClient(baseURL, config, secret)
+	if err != nil {
+		return err
+	}
+
+	chatbotClient := &client.ChatbotService{Client: c}
+
+	// Create the chatbot toolset
+	chatbot := toolsets.NewToolset("chatbot", "Harness Documentation Bot tools").
+		AddReadTools(
+			toolsets.NewServerTool(AskChatbotTool(config, chatbotClient)),
+		)
+
+	// Add toolset to the group
+	tsg.AddToolset(chatbot)
+	return nil
+}
+
 // registerLogs registers the logs toolset
 func registerLogs(config *config.Config, tsg *toolsets.ToolsetGroup) error {
 	// Determine the base URL and secret for logs