removed LLM

Signed-off-by: Tullio Sebastiani <tsebasti@redhat.com>

Author: tsebastiani

cmd/assist.go

@@ -18,108 +18,22 @@ import (
 func NewAssistCommand() *cobra.Command {
 	var command = &cobra.Command{
 		Use:   "assist",
-		Short: "Assist-AI related utilities",
-		Long: `Assist-AI related utilities for container runtime environments
+		Short: "AI-powered chaos engineering assistance",
+		Long: `AI-powered chaos engineering assistance for krknctl
 
 Available Commands:
-  check    Check GPU support in container runtime
   run      Run AI-powered chaos engineering assistance
 
-GPU Auto-Detection:
-  Lightspeed automatically detects your GPU type! No manual flags needed.
-  
-  Supported GPU Types:
-  • Apple Silicon (M1, M2, M3, M4 with Metal)
-  • NVIDIA GPUs (CUDA, GeForce, Quadro, Tesla)
-  
-  Future support planned:
-  • AMD GPUs (Radeon, FirePro, Instinct with ROCm)
-  • Intel GPUs (Arc, Iris, UHD Graphics)
+The assist service uses a lightweight AI model with FAISS vector search
+to provide intelligent command suggestions and documentation search.
 
 Examples:
-  krknctl assist check
-  krknctl assist run
-  krknctl assist run --no-gpu`,
+  krknctl assist run`,
 	}
 
-	// GPU auto-detection - no manual flags needed anymore!
-
-	// Add no-gpu flag for CPU-only mode
-	command.PersistentFlags().Bool("no-gpu", false, "Use CPU-only mode (no GPU acceleration)")
-
 	return command
 }
 
-// GPU auto-detection - no manual flag parsing needed anymore!
-
-func NewAssistCheckCommand(
-	providerFactory *factory.ProviderFactory,
-	scenarioOrchestrator *scenarioorchestrator.ScenarioOrchestrator,
-	config config.Config,
-) *cobra.Command {
-	var command = &cobra.Command{
-		Use:   "check",
-		Short: "Check GPU support in container runtime",
-		Long: `Check whether the container runtime (Podman or Docker) has GPU support available
-
-Lightspeed automatically tests all supported GPU types to detect your hardware.
-
-Examples:
-  krknctl assist check`,
-		Args: cobra.NoArgs,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			// Print container runtime info
-			(*scenarioOrchestrator).PrintContainerRuntime()
-
-			// Check if Docker is being used - Lightspeed only supports Podman
-			if (*scenarioOrchestrator).GetContainerRuntime() == orchestratormodels.Docker {
-				return fmt.Errorf("❌ Assist requires Podman container runtime. " +
-					"Docker is not supported for GPU acceleration")
-			}
-
-			// Get container runtime socket
-			socket, err := (*scenarioOrchestrator).GetContainerRuntimeSocket(nil)
-			if err != nil {
-				return fmt.Errorf("failed to get container runtime socket: %w", err)
-			}
-
-			// Connect to container runtime
-			ctx, err := (*scenarioOrchestrator).Connect(*socket)
-			if err != nil {
-				return fmt.Errorf("failed to connect to container runtime: %w", err)
-			}
-
-			// Get no-gpu flag
-			noGPU, _ := cmd.Flags().GetBool("no-gpu")
-
-			// Create platform GPU detector
-			detector := assist.NewPlatformGPUDetector(config)
-
-			// Auto-detect GPU acceleration
-			fmt.Println("\n🔍 Detecting GPU acceleration...")
-			gpuType := detector.DetectGPUAcceleration(ctx, noGPU)
-
-			// Get configuration
-			imageURI, _, deviceMounts, err := detector.AutoSelectAssistConfig(ctx, noGPU)
-			if err != nil {
-				return fmt.Errorf("failed to get assist configuration: %w", err)
-			}
-
-			// Format and print result
-			fmt.Printf("\n✅ GPU acceleration: %s\n", detector.GetGPUDescription(gpuType))
-			fmt.Printf("📦 Container image: %s\n", imageURI)
-			if len(deviceMounts) > 0 {
-				fmt.Printf("🔗 Device mounts: %v\n", deviceMounts)
-			} else {
-				fmt.Printf("🔗 Device mounts: none (CPU-only)\n")
-			}
-
-			return nil
-		},
-	}
-
-	return command
-}
 
 // buildAssistRegistryFromFlags builds assist registry configuration from command flags
 func buildAssistRegistryFromFlags(cmd *cobra.Command, config config.Config) (*models.RegistryV2, error) {
@@ -167,31 +81,24 @@ func NewAssistRunCommand(
 		Short: "Run AI-powered chaos engineering assistance",
 		Long: `Run AI-powered chaos engineering assistance with Retrieval-Augmented Generation (RAG)
 
-This command automatically detects your GPU and deploys a lightweight AI model that can answer 
-questions about krknctl usage, chaos engineering scenarios, and provide intelligent command 
-suggestions based on natural language.
+This command deploys a lightweight AI model that can answer questions about krknctl usage,
+chaos engineering scenarios, and provide intelligent command suggestions based on natural language.
 
 The system uses:
-- Automatic GPU detection (Apple Silicon, NVIDIA)
-- GPU-accelerated inference for fast responses
+- FAISS vector search for fast document retrieval
 - Live documentation indexing
-- Llama 3.2:1B model optimized for chaos engineering domain
+- Llama model optimized for chaos engineering domain
 
 Examples:
-  krknctl assist run          # Auto-detect GPU
-  krknctl assist run --no-gpu # Force CPU-only mode`,
+  krknctl assist run`,
 		Args: cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			// Get flags
-			noGPU, _ := cmd.Flags().GetBool("no-gpu")
-
 			// Print container runtime info
 			(*scenarioOrchestrator).PrintContainerRuntime()
 
-			// Check if Docker is being used - Lightspeed only supports Podman
+			// Check if Docker is being used - assist requires Podman
 			if (*scenarioOrchestrator).GetContainerRuntime() == orchestratormodels.Docker {
-				return fmt.Errorf("❌ assist requires Podman container runtime. " +
-					"Docker is not supported for GPU acceleration")
+				return fmt.Errorf("❌ assist requires Podman container runtime")
 			}
 
 			// Get container runtime socket
@@ -212,30 +119,19 @@ Examples:
 				return fmt.Errorf("failed to build assist registry configuration: %w", err)
 			}
 
-			// Step 1: Auto-detect GPU acceleration
-			fmt.Println("🔍 detecting GPU acceleration...")
-
-			// Create platform GPU detector
-			detector := assist.NewPlatformGPUDetector(config)
-			gpuType := detector.DetectGPUAcceleration(ctx, noGPU)
-
-			fmt.Printf("✅ GPU acceleration: %s\n", detector.GetGPUDescription(gpuType))
-
-			// Step 2: Deploy RAG model container
-			fmt.Println("\n🚀 deploying assist model...")
+			// Deploy RAG model container
+			fmt.Println("🚀 deploying assist model...")
 
 			// Create spinners for the operations
 			pullSpinner := NewSpinnerWithSuffix(" pulling RAG model image...")
 			thinkingSpinner := NewSpinnerWithSuffix(" thinking...", 37)
 
-			ragResult, err := assist.DeployAssistModelWithGPUType(ctx, gpuType, *scenarioOrchestrator, config, registry, detector, pullSpinner)
+			ragResult, err := assist.DeployAssistModel(ctx, *scenarioOrchestrator, config, registry, pullSpinner)
 			if err != nil {
-				// Handle GPU-related errors with helpful suggestions
-				enhancedErr := detector.HandleContainerError(err, gpuType)
-				return fmt.Errorf("failed to deploy RAG model: %w", enhancedErr)
+				return fmt.Errorf("failed to deploy RAG model: %w", err)
 			}
 
-			// Step 3: Health check
+			// Health check
 			fmt.Println("\n🩺 performing health check...")
 
 			healthOK, err := assist.PerformAssistHealthCheck(ragResult.ContainerID, ragResult.HostPort, *scenarioOrchestrator, ctx, config)
@@ -249,7 +145,7 @@ Examples:
 
 			fmt.Println("✅ assist service is ready!")
 
-			// Step 4: Start interactive prompt
+			// Start interactive prompt
 			fmt.Printf("\n🚂 starting interactive assist service on port %s...\n",
 				ragResult.HostPort)
 			fmt.Println("type your chaos engineering questions and get intelligent krknctl" +

cmd/assist_test.go

@@ -3,7 +3,6 @@ package cmd
 
 import (
 	"context"
-	"github.com/krkn-chaos/krknctl/pkg/assist"
 	"io"
 	"os"
 	"testing"
@@ -102,31 +101,8 @@ func TestNewAssistCommand(t *testing.T) {
 
 	assert.NotNil(t, cmd)
 	assert.Equal(t, "assist", cmd.Use)
-	assert.Contains(t, cmd.Short, "Assist-AI related utilities")
-	assert.Contains(t, cmd.Long, "Assist-AI related utilities")
-
-	// Test that GPU auto-detection is enabled (no manual GPU flags needed)
-	assert.NotNil(t, cmd.PersistentFlags().Lookup("no-gpu"))
-	// Manual GPU flags should not exist (using auto-detection now)
-	assert.Nil(t, cmd.PersistentFlags().Lookup("nvidia"))
-	assert.Nil(t, cmd.PersistentFlags().Lookup("apple-silicon"))
-	assert.Nil(t, cmd.PersistentFlags().Lookup("amd"))
-	assert.Nil(t, cmd.PersistentFlags().Lookup("intel"))
-}
-
-func TestNewAssistCheckCommand(t *testing.T) {
-	config := getTestConfig(t)
-	providerFactory := getTestProviderFactory(t)
-	orchestrator := getTestOrchestrator(t)
-
-	cmd := NewAssistCheckCommand(providerFactory, &orchestrator, config)
-
-	assert.NotNil(t, cmd)
-	assert.Equal(t, "check", cmd.Use)
-	assert.Contains(t, cmd.Short, "Check GPU support")
-	assert.Contains(t, cmd.Long, "Check whether the container runtime")
-	assert.NotNil(t, cmd.Args)
-	assert.NotNil(t, cmd.RunE)
+	assert.Contains(t, cmd.Short, "AI-powered chaos engineering")
+	assert.Contains(t, cmd.Long, "AI-powered chaos engineering")
 }
 
 func TestBuildAssistRegistryFromFlags_NoPrivateRegistry(t *testing.T) {
@@ -148,28 +124,6 @@ func TestBuildAssistRegistryFromFlags_NoPrivateRegistry(t *testing.T) {
 	assert.Nil(t, registry)
 }
 
-func TestGPUAutoDetection(t *testing.T) {
-	config := getTestConfig(t)
-	detector := assist.NewPlatformGPUDetector(config)
-
-	// Test GPU detection types
-	ctx := context.Background()
-
-	// Test with --no-gpu flag
-	gpuType := detector.DetectGPUAcceleration(ctx, true)
-	assert.Equal(t, assist.GPUAccelerationGeneric, gpuType)
-
-	// Test description generation
-	description := detector.GetGPUDescription(assist.GPUAccelerationAppleSilicon)
-	assert.Contains(t, description, "Apple Silicon")
-
-	description = detector.GetGPUDescription(assist.GPUAccelerationNVIDIA)
-	assert.Contains(t, description, "NVIDIA")
-
-	description = detector.GetGPUDescription(assist.GPUAccelerationGeneric)
-	assert.Contains(t, description, "CPU-only")
-}
-
 // Test command creation and basic structure
 func TestAssistCommands_Structure(t *testing.T) {
 	config := getTestConfig(t)
@@ -181,13 +135,13 @@ func TestAssistCommands_Structure(t *testing.T) {
 	assert.NotNil(t, assistCmd)
 	assert.Equal(t, "assist", assistCmd.Use)
 
-	// Test check command creation
-	checkCmd := NewAssistCheckCommand(providerFactory, &orchestrator, config)
-	assert.NotNil(t, checkCmd)
-	assert.Equal(t, "check", checkCmd.Use)
-	assert.NotNil(t, checkCmd.RunE)
+	// Test run command creation
+	runCmd := NewAssistRunCommand(providerFactory, &orchestrator, config)
+	assert.NotNil(t, runCmd)
+	assert.Equal(t, "run", runCmd.Use)
+	assert.NotNil(t, runCmd.RunE)
 
-	// Add check command to assist
-	assistCmd.AddCommand(checkCmd)
+	// Add run command to assist
+	assistCmd.AddCommand(runCmd)
 	assert.Equal(t, 1, len(assistCmd.Commands()))
 }

cmd/root.go

@@ -117,9 +117,7 @@ func Execute(providerFactory *factory.ProviderFactory, scenarioOrchestrator *sce
 
 	// assist subcommands
 	assistCmd := NewAssistCommand()
-	assistCheckCmd := NewAssistCheckCommand(providerFactory, scenarioOrchestrator, config)
 	assistRunCmd := NewAssistRunCommand(providerFactory, scenarioOrchestrator, config)
-	assistCmd.AddCommand(assistCheckCmd)
 	assistCmd.AddCommand(assistRunCmd)
 	rootCmd.AddCommand(assistCmd)