feat: MCP server integrations — connect Atmos to external MCP servers

cmd/ai/ask.go

@@ -1,6 +1,7 @@
 package ai
 
 import (
+	"bytes"
 	"context"
 	_ "embed"
 	"fmt"
@@ -13,6 +14,7 @@ import (
 	errUtils "github.com/cloudposse/atmos/errors"
 	"github.com/cloudposse/atmos/pkg/ai"
 	"github.com/cloudposse/atmos/pkg/ai/executor"
+	"github.com/cloudposse/atmos/pkg/ai/formatter"
 	"github.com/cloudposse/atmos/pkg/ai/tools"
 	cfg "github.com/cloudposse/atmos/pkg/config"
 	"github.com/cloudposse/atmos/pkg/flags"
@@ -45,6 +47,7 @@ var askCmd = &cobra.Command{
 		excludePatterns := v.GetStringSlice("exclude")
 		noAutoContext := v.GetBool("no-auto-context")
 		noTools := v.GetBool("no-tools")
+		mcpServers := v.GetStringSlice("mcp")
 
 		// Initialize configuration.
 		configAndStacksInfo := schema.ConfigAndStacksInfo{}
@@ -92,15 +95,19 @@ var askCmd = &cobra.Command{
 			}
 		}
 
-		// Create read-only tool executor (if tools are enabled).
-		// The ask command uses only in-process, read-only tools (no subprocess execution).
+		// Create tool executor (if tools are enabled).
 		var toolExecutor *tools.Executor
 		if !noTools && atmosConfig.AI.Tools.Enabled {
-			_, toolExecutor, err = initializeAIReadOnlyTools(&atmosConfig)
-			if err != nil {
-				log.Warn("Failed to initialize tools", "error", err)
+			toolsResult, toolsErr := initializeAIToolsAndExecutor(&atmosConfig, mcpServers, question)
+			if toolsErr != nil {
+				log.Warn("Failed to initialize tools", "error", toolsErr)
 				// Continue without tools rather than failing.
-				toolExecutor = nil
+			}
+			if toolsResult != nil {
+				toolExecutor = toolsResult.Executor
+				if toolsResult.MCPMgr != nil {
+					defer toolsResult.MCPMgr.StopAll() //nolint:errcheck // Best-effort MCP server cleanup.
+				}
 			}
 		}
 
@@ -129,8 +136,13 @@ var askCmd = &cobra.Command{
 			return errUtils.ErrAIExecutionFailed
 		}
 
-		// Render response as Markdown for rich terminal output.
-		utils.PrintfMarkdown("%s", result.Response)
+		// Render response with tool execution details as Markdown.
+		var buf bytes.Buffer
+		mdFormatter := formatter.NewFormatter(formatter.FormatMarkdown)
+		if err := mdFormatter.Format(&buf, result); err != nil {
+			return fmt.Errorf("failed to format response: %w", err)
+		}
+		utils.PrintfMarkdown("%s", buf.String())
 
 		return nil
 	},
@@ -143,10 +155,12 @@ func init() {
 		flags.WithStringSliceFlag("exclude", "", nil, "Add glob patterns to exclude from context (can be repeated)"),
 		flags.WithBoolFlag("no-auto-context", "", false, "Disable automatic context discovery"),
 		flags.WithBoolFlag("no-tools", "", false, "Disable tool execution"),
+		flags.WithStringSliceFlag("mcp", "", nil, "MCP servers to use (comma-separated, skips auto-routing)"),
 		flags.WithEnvVars("include", "ATMOS_AI_INCLUDE"),
 		flags.WithEnvVars("exclude", "ATMOS_AI_EXCLUDE"),
 		flags.WithEnvVars("no-auto-context", "ATMOS_AI_NO_AUTO_CONTEXT"),
 		flags.WithEnvVars("no-tools", "ATMOS_AI_NO_TOOLS"),
+		flags.WithEnvVars("mcp", "ATMOS_AI_MCP"),
 	)
 
 	// Register flags on the command.

cmd/ai/ask_test.go

@@ -558,8 +558,8 @@ func TestAskCommand_FlagCount(t *testing.T) {
 			count++
 		}
 	})
-	// Expected: include, exclude, no-auto-context, no-tools = 4 flags.
-	assert.Equal(t, 4, count, "ask command should have exactly 4 custom flags")
+	// Expected: include, exclude, no-auto-context, no-tools, mcp = 5 flags.
+	assert.Equal(t, 5, count, "ask command should have exactly 5 custom flags")
 }
 
 func TestAskCommand_AIEnabledButClientCreationFails(t *testing.T) {
@@ -2235,9 +2235,9 @@ ai:
 	})
 }
 
-// TestAskCommand_StandardParserIntegration tests that the ask command uses StandardParser
+// TestAskCommand_StandardParserServer tests that the ask command uses StandardParser
 // with proper Viper binding for flag precedence (CLI > ENV > defaults).
-func TestAskCommand_StandardParserIntegration(t *testing.T) {
+func TestAskCommand_StandardParserServer(t *testing.T) {
 	t.Run("askParser is initialized", func(t *testing.T) {
 		require.NotNil(t, askParser, "askParser should be initialized by init()")
 	})

cmd/ai/chat.go

@@ -58,6 +58,8 @@ var chatCmd = &cobra.Command{
 			return err
 		}
 
+		mcpServers := v.GetStringSlice("mcp")
+
 		// Initialize configuration.
 		configAndStacksInfo := schema.ConfigAndStacksInfo{}
 		atmosConfig, err := cfg.InitCliConfig(configAndStacksInfo, true)
@@ -128,9 +130,15 @@ var chatCmd = &cobra.Command{
 		// Initialize tool registry and executor if tools are enabled.
 		var executor *tools.Executor
 		if atmosConfig.AI.Tools.Enabled {
-			_, executor, err = initializeAIToolsAndExecutor(&atmosConfig)
-			if err != nil {
-				log.Warnf("Failed to initialize AI tools: %v", err)
+			toolsResult, toolsErr := initializeAIToolsAndExecutor(&atmosConfig, mcpServers, "")
+			if toolsErr != nil {
+				log.Warnf("Failed to initialize AI tools: %v", toolsErr)
+			}
+			if toolsResult != nil {
+				executor = toolsResult.Executor
+				if toolsResult.MCPMgr != nil {
+					defer toolsResult.MCPMgr.StopAll() //nolint:errcheck // Best-effort MCP server cleanup.
+				}
 			}
 		}
 
@@ -179,7 +187,9 @@ func init() {
 	// Create parser with chat-specific flags using functional options.
 	chatParser = flags.NewStandardParser(
 		flags.WithStringFlag("session", "", "", "Resume or create a named session"),
+		flags.WithStringSliceFlag("mcp", "", nil, "MCP servers to use (comma-separated, skips auto-routing)"),
 		flags.WithEnvVars("session", "ATMOS_AI_SESSION"),
+		flags.WithEnvVars("mcp", "ATMOS_AI_MCP"),
 	)
 
 	// Register flags on the command.

cmd/ai/chat_test.go

@@ -2170,9 +2170,9 @@ func TestChatCmd_RunE_OllamaToolsInitWarn(t *testing.T) {
 	assert.Contains(t, err.Error(), "chat session failed")
 }
 
-// TestChatCommand_StandardParserIntegration tests that the chat command uses StandardParser
+// TestChatCommand_StandardParserServer tests that the chat command uses StandardParser
 // with proper Viper binding for flag precedence (CLI > ENV > defaults).
-func TestChatCommand_StandardParserIntegration(t *testing.T) {
+func TestChatCommand_StandardParserServer(t *testing.T) {
 	t.Run("chatParser is initialized", func(t *testing.T) {
 		require.NotNil(t, chatParser, "chatParser should be initialized by init()")
 	})

cmd/ai/exec.go

@@ -52,6 +52,7 @@ var execCmd = &cobra.Command{
 		includePatterns := v.GetStringSlice("include")
 		excludePatterns := v.GetStringSlice("exclude")
 		noAutoContext := v.GetBool("no-auto-context")
+		mcpServers := v.GetStringSlice("mcp")
 
 		// Initialize configuration.
 		configAndStacksInfo := schema.ConfigAndStacksInfo{}
@@ -104,11 +105,15 @@ var execCmd = &cobra.Command{
 		var toolExecutor *tools.Executor
 		if !noTools && atmosConfig.AI.Tools.Enabled {
 			// Use shared initialization function.
-			_, toolExecutor, err = initializeAIToolsAndExecutor(&atmosConfig)
-			if err != nil {
-				log.Warn("Failed to initialize tools", "error", err)
-				// Continue without tools rather than failing.
-				toolExecutor = nil
+			toolsResult, toolsErr := initializeAIToolsAndExecutor(&atmosConfig, mcpServers, prompt)
+			if toolsErr != nil {
+				log.Warn("Failed to initialize tools", "error", toolsErr)
+			}
+			if toolsResult != nil {
+				toolExecutor = toolsResult.Executor
+				if toolsResult.MCPMgr != nil {
+					defer toolsResult.MCPMgr.StopAll() //nolint:errcheck // Best-effort MCP server cleanup.
+				}
 			}
 		}
 
@@ -235,6 +240,7 @@ func init() {
 		flags.WithStringFlag("format", "f", "text", "Output format: text, json, markdown"),
 		flags.WithStringFlag("output", "o", "", "Output file (default: stdout)"),
 		flags.WithBoolFlag("no-tools", "", false, "Disable tool execution"),
+		flags.WithStringSliceFlag("mcp", "", nil, "MCP servers to use (comma-separated, skips auto-routing)"),
 		flags.WithBoolFlag("context", "", false, "Include stack context in prompt"),
 		flags.WithStringFlag("provider", "p", "", "Override AI provider (anthropic, openai, gemini, etc.)"),
 		flags.WithStringFlag("session", "s", "", "Session ID for conversation context"),
@@ -244,6 +250,7 @@ func init() {
 		flags.WithEnvVars("format", "ATMOS_AI_FORMAT"),
 		flags.WithEnvVars("output", "ATMOS_AI_OUTPUT"),
 		flags.WithEnvVars("no-tools", "ATMOS_AI_NO_TOOLS"),
+		flags.WithEnvVars("mcp", "ATMOS_AI_MCP"),
 		flags.WithEnvVars("context", "ATMOS_AI_CONTEXT"),
 		flags.WithEnvVars("provider", "ATMOS_AI_PROVIDER"),
 		flags.WithEnvVars("session", "ATMOS_AI_SESSION"),

cmd/ai/exec_test.go

@@ -775,8 +775,8 @@ func TestExecCommand_ErrorMessages(t *testing.T) {
 	})
 }
 
-// TestExecCommand_IntegrationStyle tests the overall flow in a more integration-style manner.
-func TestExecCommand_IntegrationStyle(t *testing.T) {
+// TestExecCommand_ServerStyle tests the overall flow in a more server-style manner.
+func TestExecCommand_ServerStyle(t *testing.T) {
 	t.Run("full flag setup works", func(t *testing.T) {
 		// Create a copy of the command for isolated testing.
 		testCmd := &cobra.Command{
@@ -1493,8 +1493,8 @@ ai:
 	return tmpDir
 }
 
-// TestFormatterIntegration tests actual formatter usage with ExecutionResult.
-func TestFormatterIntegration(t *testing.T) {
+// TestFormatterServer tests actual formatter usage with ExecutionResult.
+func TestFormatterServer(t *testing.T) {
 	t.Run("text formatter writes response", func(t *testing.T) {
 		result := &formatter.ExecutionResult{
 			Success:  true,
@@ -1899,7 +1899,7 @@ func TestExecCommand_TimeoutConfiguration(t *testing.T) {
 	t.Run("custom timeout from config", func(t *testing.T) {
 		// Test that timeout_seconds config is read at lines 143-146.
 		extraConfig := `
-    timeout_seconds: 300
+    timeout_seconds: 120
 `
 		tmpDir := createValidAtmosConfig(t, true, extraConfig)
 
@@ -3313,9 +3313,9 @@ func TestGetPrompt_WithMockStdin(t *testing.T) {
 	})
 }
 
-// TestExecCommand_StandardParserIntegration tests that the exec command uses StandardParser
+// TestExecCommand_StandardParserServer tests that the exec command uses StandardParser
 // with proper Viper binding for flag precedence (CLI > ENV > defaults).
-func TestExecCommand_StandardParserIntegration(t *testing.T) {
+func TestExecCommand_StandardParserServer(t *testing.T) {
 	t.Run("execParser is initialized", func(t *testing.T) {
 		require.NotNil(t, execParser, "execParser should be initialized by init()")
 	})