diff --git a/internal/cli/admin_parser.go b/internal/cli/admin_parser.go
index eced62cc91..f0a7b66f50 100644
--- a/internal/cli/admin_parser.go
+++ b/internal/cli/admin_parser.go
@@ -385,9 +385,9 @@ func (p *Parser) parseAdminShowCommands() (*Command, error) {
 	case TokenModel:
 		return p.parseAdminShowModel()
 	case TokenAdmin:
-		return p.parseUserShowAdmin()
+		return p.parseAdminShowAdminServer()
 	case TokenAPI:
-		return p.parseUserShowAPI()
+		return p.parseAdminShowAPI()
 	case TokenUsers:
 		return p.parseAdminShowUsersCommands()
 	case TokenData:
@@ -823,6 +823,55 @@ func (p *Parser) parseAdminShowModel() (*Command, error) {
 	return cmd, nil
 }
 
+// SHOW ADMIN SERVER;
+func (p *Parser) parseAdminShowAdminServer() (*Command, error) {
+	p.nextToken() // consume ADMIN
+
+	var cmd *Command
+	switch p.curToken.Type {
+	case TokenServer:
+		p.nextToken()
+		cmd = NewCommand("admin_show_admin_server")
+	default:
+		return nil, fmt.Errorf("expected SERVER after ADMIN")
+	}
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+	return cmd, nil
+}
+
+// SHOW API SERVER <server_name>
+func (p *Parser) parseAdminShowAPI() (*Command, error) {
+	p.nextToken() // consume API
+
+	var cmd *Command
+	switch p.curToken.Type {
+	case TokenServer:
+		p.nextToken()
+		cmd = NewCommand("admin_show_api_server")
+
+		serverName, err := p.parseQuotedString()
+		if err != nil {
+			return nil, fmt.Errorf("expected API server name: %w", err)
+		}
+		cmd.Params["api_server_name"] = serverName
+		p.nextToken()
+
+	default:
+		return nil, fmt.Errorf("expected SERVER after API")
+	}
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	return cmd, nil
+}
+
 func (p *Parser) parseCommonShowPoolModel() (*Command, error) {
 	p.nextToken() // consume POOL
 	if p.curToken.Type == TokenProvider {
@@ -2281,12 +2330,36 @@ func (p *Parser) parseAdminSaveCommand() (*Command, error) {
 	p.nextToken() // consume SAVE
 	switch p.curToken.Type {
 	case TokenConfig:
-		return p.parseSaveConfig()
+		return p.parseAdminSaveConfig()
 	default:
 		return nil, fmt.Errorf("unknown ADD target: %s", p.curToken.Value)
 	}
 }
 
+func (p *Parser) parseAdminSaveConfig() (*Command, error) {
+	p.nextToken() // consume CONFIG
+
+	if p.curToken.Type != TokenAs {
+		return nil, fmt.Errorf("expected AS after CONFIG")
+	}
+	p.nextToken() // consume AS
+
+	path, err := p.parseQuotedString()
+	if err != nil {
+		return nil, err
+	}
+
+	cmd := NewCommand("admin_save_config_command")
+	cmd.Params["path"] = path
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	return cmd, nil
+}
+
 func (p *Parser) parseAdminUseCommand() (*Command, error) {
 	p.nextToken() // consume USE
 	switch p.curToken.Type {
diff --git a/internal/cli/cli_http.go b/internal/cli/cli_http.go
index 8c28a8be93..dc256ad586 100644
--- a/internal/cli/cli_http.go
+++ b/internal/cli/cli_http.go
@@ -257,11 +257,10 @@ func (c *CLI) ExecuteAdminCommand(cmd *Command) (ResponseIf, error) {
 		return c.CommonEnableOrDisableModel(cmd, "enable")
 	case "admin_disable_model":
 		return c.CommonEnableOrDisableModel(cmd, "disable")
-		// TODO: Implement other commands
-	case "show_admin_server":
-		return c.ShowAdminServer(cmd)
-	case "show_api_server":
-		return c.ShowAPIServer(cmd)
+	case "admin_show_admin_server":
+		return c.CommonShowAdminServerCommand(cmd)
+	case "admin_show_api_server":
+		return c.CommonShowAPIServerCommand(cmd)
 	case "admin_show_log_level":
 		return c.AdminShowLogLevelCommand(cmd)
 	case "admin_list_api_servers":
@@ -274,8 +273,8 @@ func (c *CLI) ExecuteAdminCommand(cmd *Command) (ResponseIf, error) {
 		return nil, fmt.Errorf("cannot add admin server in admin mode")
 	case "delete_admin_server":
 		return nil, fmt.Errorf("cannot delete admin server in admin mode")
-	case "save_config_command":
-		return c.SaveServerConfig(cmd)
+	case "admin_save_config_command":
+		return c.CommonSaveServerConfigCommand(cmd)
 	case "admin_use_api_server":
 		return c.CommonUseAPIServerCommand(cmd)
 	case "admin_use_admin_server":
@@ -322,6 +321,16 @@ func (c *CLI) ExecuteUserCommand(cmd *Command) (ResponseIf, error) {
 		return nil, nil
 	case "api_create_api_key":
 		return c.APICreateAPIKeyCommand(cmd)
+	case "api_create_dataset":
+		return c.APICreateDatasetCommand(cmd)
+	case "api_create_agent":
+		return c.APICreateAgentCommand(cmd)
+	case "api_create_chat":
+		return c.APICreateChatCommand(cmd)
+	case "api_create_search":
+		return c.APICreateSearchCommand(cmd)
+	case "api_create_memory":
+		return c.APICreateMemoryCommand(cmd)
 	case "api_list_api_keys":
 		return c.APIListAPIKeysCommand(cmd)
 	case "api_delete_api_key":
@@ -348,6 +357,8 @@ func (c *CLI) ExecuteUserCommand(cmd *Command) (ResponseIf, error) {
 		return c.CommonShowProviderInstanceCommand(cmd)
 	case "api_show_provider_instance_balance":
 		return c.CommonShowProviderInstanceBalanceCommand(cmd)
+	case "api_show_provider_instance_task":
+		return c.APIShowProviderInstanceTaskCommand(cmd)
 	case "api_show_provider_model":
 		return c.CommonShowProviderModelCommand(cmd)
 	case "list_provider_models":
@@ -370,8 +381,8 @@ func (c *CLI) ExecuteUserCommand(cmd *Command) (ResponseIf, error) {
 	case "delete_provider":
 		return c.DeleteProvider(cmd)
 	// Provider instance commands
-	case "create_provider_instance":
-		return c.CreateProviderInstance(cmd)
+	case "api_create_provider_instance":
+		return c.APICreateProviderInstanceCommand(cmd)
 	case "api_list_provider_instances":
 		return c.CommonListProviderInstances(cmd)
 	case "alter_provider_instance":
@@ -411,11 +422,11 @@ func (c *CLI) ExecuteUserCommand(cmd *Command) (ResponseIf, error) {
 		return c.CommonCheckProviderConnection(cmd)
 	case "check_provider_with_key":
 		return c.CommonCheckProviderWithKey(cmd)
-	case "use_model":
-		return c.UseModel(cmd)
-	case "use_api_server":
+	case "api_use_model":
+		return c.APIUseModelCommand(cmd)
+	case "api_use_api_server":
 		return c.CommonUseAPIServerCommand(cmd)
-	case "use_admin_server":
+	case "api_use_admin_server":
 		return c.CommonUseAdminServerCommand(cmd)
 	case "set_default_model":
 		return c.SetDefaultModel(cmd)
@@ -423,8 +434,6 @@ func (c *CLI) ExecuteUserCommand(cmd *Command) (ResponseIf, error) {
 		return c.ResetDefaultModel(cmd)
 	case "api_list_default_models":
 		return c.ListDefaultModels(cmd)
-	case "show_task_user_command":
-		return c.ShowTaskUserCommand(cmd)
 	case "create_chunk_store":
 		return c.CreateChunkStore(cmd)
 	case "drop_chunk_store":
@@ -464,10 +473,10 @@ func (c *CLI) ExecuteUserCommand(cmd *Command) (ResponseIf, error) {
 	// TODO: Implement other commands
 	case "user_parse_local_file_command":
 		return c.UserParseLocalFile(cmd)
-	case "show_admin_server":
-		return c.ShowAdminServer(cmd)
-	case "show_api_server":
-		return c.ShowAPIServer(cmd)
+	case "api_show_admin_server":
+		return c.CommonShowAdminServerCommand(cmd)
+	case "api_show_api_server":
+		return c.CommonShowAPIServerCommand(cmd)
 	case "api_show_log_level":
 		return c.APIShowLogLevelCommand(cmd)
 	case "api_list_api_servers":
@@ -486,8 +495,8 @@ func (c *CLI) ExecuteUserCommand(cmd *Command) (ResponseIf, error) {
 		return c.DeleteAdminServer(cmd)
 	case "user_chunk_command":
 		return c.ChunkCommand(cmd)
-	case "save_config_command":
-		return c.SaveServerConfig(cmd)
+	case "api_save_config_command":
+		return c.CommonSaveServerConfigCommand(cmd)
 	case "file_system_command":
 		return c.ExecuteFilesystemCommand(cmd)
 	default:
diff --git a/internal/cli/common_command.go b/internal/cli/common_command.go
index ab18672f77..bcf9ce3fb1 100644
--- a/internal/cli/common_command.go
+++ b/internal/cli/common_command.go
@@ -1101,11 +1101,11 @@ func (c *CLI) CommonShowCurrentCommand(cmd *Command) (ResponseIf, error) {
 	return result, nil
 }
 
-func (c *CLI) ShowAdminServer(cmd *Command) (ResponseIf, error) {
+func (c *CLI) CommonShowAdminServerCommand(cmd *Command) (ResponseIf, error) {
 	return c.GetAdminServerInfo()
 }
 
-func (c *CLI) ShowAPIServer(cmd *Command) (ResponseIf, error) {
+func (c *CLI) CommonShowAPIServerCommand(cmd *Command) (ResponseIf, error) {
 	apiServerName, ok := cmd.Params["api_server_name"].(string)
 	if !ok {
 		return nil, fmt.Errorf("api_server_name not provided")
@@ -1302,7 +1302,7 @@ func (c *CLI) DeleteAdminServer(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
-func (c *CLI) SaveServerConfig(cmd *Command) (ResponseIf, error) {
+func (c *CLI) CommonSaveServerConfigCommand(cmd *Command) (ResponseIf, error) {
 
 	switch c.Config.CLIMode {
 	case AdminMode:
diff --git a/internal/cli/lexer.go b/internal/cli/lexer.go
index c95784d689..eb86169699 100644
--- a/internal/cli/lexer.go
+++ b/internal/cli/lexer.go
@@ -361,6 +361,10 @@ func (l *Lexer) lookupIdent(ident string) Token {
 		return Token{Type: TokenGet, Value: ident}
 	case "SEARCH":
 		return Token{Type: TokenSearch, Value: ident}
+	case "AGENT":
+		return Token{Type: TokenAgent, Value: ident}
+	case "MEMORY":
+		return Token{Type: TokenMemory, Value: ident}
 	case "RETRIEVE":
 		return Token{Type: TokenRetrieve, Value: ident}
 	case "CURRENT":
diff --git a/internal/cli/parser.go b/internal/cli/parser.go
index 1061a7a252..7a3b4120e2 100644
--- a/internal/cli/parser.go
+++ b/internal/cli/parser.go
@@ -153,9 +153,9 @@ func (p *Parser) parseUserCommand() (*Command, error) {
 	case TokenShow:
 		return p.parseAPIShowCommands()
 	case TokenCreate:
-		return p.parseCreateCommand()
+		return p.parseAPICreateCommands()
 	case TokenDrop:
-		return p.parseDropCommand()
+		return p.parseAPIDropCommands()
 	case TokenAdd:
 		return p.parseAddCommand()
 	case TokenDelete:
@@ -206,11 +206,10 @@ func (p *Parser) parseUserCommand() (*Command, error) {
 		return p.parseUserStartIngestion()
 	case TokenStop:
 		return p.parseUserStopIngestion()
-
 	case TokenSave:
-		return p.parseUserSaveCommand()
+		return p.parseAPISaveCommand()
 	case TokenUse:
-		return p.parseUseCommand()
+		return p.parseAPIUseCommands()
 	case TokenUpdate:
 		return p.parseUpdateCommand()
 	case TokenRemove:
diff --git a/internal/cli/types.go b/internal/cli/types.go
index e9e504f2b3..e2d8bc79d0 100644
--- a/internal/cli/types.go
+++ b/internal/cli/types.go
@@ -101,6 +101,8 @@ const (
 	TokenParser
 	TokenPipeline
 	TokenSearch
+	TokenAgent
+	TokenMemory
 	TokenRetrieve
 	TokenCurrent
 	TokenFingerprint
diff --git a/internal/cli/user_command.go b/internal/cli/user_command.go
index 4a4174f144..7b48824263 100644
--- a/internal/cli/user_command.go
+++ b/internal/cli/user_command.go
@@ -957,6 +957,12 @@ func (c *CLI) APICreateAPIKeyCommand(cmd *Command) (ResponseIf, error) {
 	}
 
 	httpClient := c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer]
+
+	// Determine auth kind based on whether API key is being used
+	if httpClient.LoginToken == nil && !c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].useAPIKey {
+		return nil, fmt.Errorf("no authorization")
+	}
+
 	resp, err := httpClient.Request("POST", "/system/keys", "web", nil, nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create key: %w", err)
@@ -982,6 +988,191 @@ func (c *CLI) APICreateAPIKeyCommand(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
+func (c *CLI) APICreateDatasetCommand(cmd *Command) (ResponseIf, error) {
+	if c.Config.CLIMode != APIMode {
+		return nil, fmt.Errorf("this command is only allowed in USER mode")
+	}
+
+	httpClient := c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer]
+
+	// Determine auth kind based on whether API key is being used
+	if httpClient.LoginToken == nil && !c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].useAPIKey {
+		return nil, fmt.Errorf("no authorization")
+	}
+
+	resp, err := httpClient.Request("POST", "/datasets", "web", nil, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create dataset: %w", err)
+	}
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("failed to create dataset: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
+	}
+
+	var createResult CommonDataResponse
+	if err = json.Unmarshal(resp.Body, &createResult); err != nil {
+		return nil, fmt.Errorf("create dataset failed: invalid JSON (%w)", err)
+	}
+
+	if createResult.Code != 0 {
+		return nil, fmt.Errorf("error code: %d, message: %s", createResult.Code, createResult.Message)
+	}
+
+	var result SimpleResponse
+	result.Code = 0
+	result.Message = "Dataset created successfully"
+	result.Duration = resp.Duration
+	return &result, nil
+}
+
+func (c *CLI) APICreateAgentCommand(cmd *Command) (ResponseIf, error) {
+	if c.Config.CLIMode != APIMode {
+		return nil, fmt.Errorf("this command is only allowed in USER mode")
+	}
+
+	httpClient := c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer]
+
+	// Determine auth kind based on whether API key is being used
+	if httpClient.LoginToken == nil && !c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].useAPIKey {
+		return nil, fmt.Errorf("no authorization")
+	}
+
+	resp, err := httpClient.Request("POST", "/agents", "web", nil, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create agent: %w", err)
+	}
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("failed to create agent: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
+	}
+
+	var createResult CommonDataResponse
+	if err = json.Unmarshal(resp.Body, &createResult); err != nil {
+		return nil, fmt.Errorf("create agent failed: invalid JSON (%w)", err)
+	}
+
+	if createResult.Code != 0 {
+		return nil, fmt.Errorf("%s", createResult.Message)
+	}
+
+	var result SimpleResponse
+	result.Code = 0
+	result.Message = "Agent created successfully"
+	result.Duration = resp.Duration
+	return &result, nil
+}
+
+func (c *CLI) APICreateChatCommand(cmd *Command) (ResponseIf, error) {
+	if c.Config.CLIMode != APIMode {
+		return nil, fmt.Errorf("this command is only allowed in USER mode")
+	}
+
+	httpClient := c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer]
+
+	// Determine auth kind based on whether API key is being used
+	if httpClient.LoginToken == nil && !c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].useAPIKey {
+		return nil, fmt.Errorf("no authorization")
+	}
+
+	resp, err := httpClient.Request("POST", "/chats", "web", nil, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create chat: %w", err)
+	}
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("failed to create chat: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
+	}
+
+	var createResult CommonDataResponse
+	if err = json.Unmarshal(resp.Body, &createResult); err != nil {
+		return nil, fmt.Errorf("create chat failed: invalid JSON (%w)", err)
+	}
+
+	if createResult.Code != 0 {
+		return nil, fmt.Errorf("%s", createResult.Message)
+	}
+
+	var result SimpleResponse
+	result.Code = 0
+	result.Message = "Chat created successfully"
+	result.Duration = resp.Duration
+	return &result, nil
+}
+
+func (c *CLI) APICreateSearchCommand(cmd *Command) (ResponseIf, error) {
+	if c.Config.CLIMode != APIMode {
+		return nil, fmt.Errorf("this command is only allowed in USER mode")
+	}
+
+	httpClient := c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer]
+
+	// Determine auth kind based on whether API key is being used
+	if httpClient.LoginToken == nil && !c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].useAPIKey {
+		return nil, fmt.Errorf("no authorization")
+	}
+
+	resp, err := httpClient.Request("POST", "/searches", "web", nil, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create search: %w", err)
+	}
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("failed to create search: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
+	}
+
+	var createResult CommonDataResponse
+	if err = json.Unmarshal(resp.Body, &createResult); err != nil {
+		return nil, fmt.Errorf("create search failed: invalid JSON (%w)", err)
+	}
+
+	if createResult.Code != 0 {
+		return nil, fmt.Errorf("%s", createResult.Message)
+	}
+
+	var result SimpleResponse
+	result.Code = 0
+	result.Message = "Search created successfully"
+	result.Duration = resp.Duration
+	return &result, nil
+}
+
+func (c *CLI) APICreateMemoryCommand(cmd *Command) (ResponseIf, error) {
+	if c.Config.CLIMode != APIMode {
+		return nil, fmt.Errorf("this command is only allowed in USER mode")
+	}
+
+	httpClient := c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer]
+
+	// Determine auth kind based on whether API key is being used
+	if httpClient.LoginToken == nil && !c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].useAPIKey {
+		return nil, fmt.Errorf("no authorization")
+	}
+
+	resp, err := httpClient.Request("POST", "/memories", "web", nil, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create memory: %w", err)
+	}
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("failed to create memory: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
+	}
+
+	var createResult CommonDataResponse
+	if err = json.Unmarshal(resp.Body, &createResult); err != nil {
+		return nil, fmt.Errorf("create memory failed: invalid JSON (%w)", err)
+	}
+
+	if createResult.Code != 0 {
+		return nil, fmt.Errorf("%s", createResult.Message)
+	}
+
+	var result SimpleResponse
+	result.Code = 0
+	result.Message = "Memory created successfully"
+	result.Duration = resp.Duration
+	return &result, nil
+}
+
 // APIListAPIKeysCommand lists all API keys for the current user
 func (c *CLI) APIListAPIKeysCommand(cmd *Command) (ResponseIf, error) {
 	if c.Config.CLIMode != APIMode {
@@ -1485,6 +1676,11 @@ func (c *CLI) DeleteProvider(cmd *Command) (ResponseIf, error) {
 		return nil, fmt.Errorf("this command is only allowed in USER mode")
 	}
 
+	httpClient := c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer]
+	if httpClient.APIKey == nil && httpClient.LoginToken == nil {
+		return nil, fmt.Errorf("API key not set. Please login first")
+	}
+
 	providerName, ok := cmd.Params["provider_name"].(string)
 	if !ok {
 		return nil, fmt.Errorf("provider name not provided")
@@ -1497,7 +1693,7 @@ func (c *CLI) DeleteProvider(cmd *Command) (ResponseIf, error) {
 		"llm_factory": providerName,
 	}
 
-	resp, err := c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].Request("DELETE", url, "web", nil, payload)
+	resp, err := httpClient.Request("DELETE", url, "web", nil, payload)
 	if err != nil {
 		return nil, fmt.Errorf("failed to delete provider: %w", err)
 	}
@@ -1519,13 +1715,18 @@ func (c *CLI) DeleteProvider(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
-// CreateProviderInstance creates a new provider instance
+// APICreateProviderInstanceCommand creates a new provider instance
 // CREATE PROVIDER <name> INSTANCE <instance_name> KEY <api_key> URL <base_url> REGION <region>
-func (c *CLI) CreateProviderInstance(cmd *Command) (ResponseIf, error) {
+func (c *CLI) APICreateProviderInstanceCommand(cmd *Command) (ResponseIf, error) {
 	if c.Config.CLIMode != APIMode {
 		return nil, fmt.Errorf("this command is only allowed in USER mode")
 	}
 
+	httpClient := c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer]
+	if httpClient.APIKey == nil && httpClient.LoginToken == nil {
+		return nil, fmt.Errorf("API key not set. Please login first")
+	}
+
 	providerName, ok := cmd.Params["provider_name"].(string)
 	if !ok {
 		return nil, fmt.Errorf("provider name not provided")
@@ -1560,7 +1761,7 @@ func (c *CLI) CreateProviderInstance(cmd *Command) (ResponseIf, error) {
 		"region":        region,
 	}
 
-	resp, err := c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].Request("POST", url, "web", nil, payload)
+	resp, err := httpClient.Request("POST", url, "web", nil, payload)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create provider instance: %w", err)
 	}
@@ -2715,8 +2916,11 @@ func (c *CLI) APIListModelInstanceTasksCommand(cmd *Command) (ResponseIf, error)
 	return &result, nil
 }
 
-func (c *CLI) ShowTaskUserCommand(cmd *Command) (ResponseIf, error) {
-	if c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].APIKey == nil && c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].LoginToken == nil {
+// APIShowProviderInstanceTaskCommand shows the details of a task
+func (c *CLI) APIShowProviderInstanceTaskCommand(cmd *Command) (ResponseIf, error) {
+
+	httpClient := c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer]
+	if httpClient.APIKey == nil && httpClient.LoginToken == nil {
 		return nil, fmt.Errorf("API key not set. Please login first")
 	}
 
@@ -2724,18 +2928,14 @@ func (c *CLI) ShowTaskUserCommand(cmd *Command) (ResponseIf, error) {
 		return nil, fmt.Errorf("this command is only allowed in USER mode")
 	}
 
-	var providerName, instanceName string
+	providerName, ok := cmd.Params["provider_name"].(string)
+	if !ok {
+		return nil, fmt.Errorf("no provider name")
+	}
 
-	// Check if composite_instance_name is provided in command
-	if compositeModelName, ok := cmd.Params["composite_instance_name"].(string); ok && compositeModelName != "" {
-		names := strings.Split(compositeModelName, "@")
-		if len(names) != 2 {
-			return nil, fmt.Errorf("model name must be in format 'instance@provider'")
-		}
-		providerName = names[1]
-		instanceName = names[0]
-	} else {
-		return nil, fmt.Errorf("no provider name or instance name")
+	instanceName, ok := cmd.Params["instance_name"].(string)
+	if !ok {
+		return nil, fmt.Errorf("no instance name")
 	}
 
 	taskID, ok := cmd.Params["task_id"].(string)
@@ -2745,7 +2945,7 @@ func (c *CLI) ShowTaskUserCommand(cmd *Command) (ResponseIf, error) {
 
 	url := fmt.Sprintf("/providers/%s/instances/%s/tasks/%s", providerName, instanceName, taskID)
 
-	resp, err := c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].Request("GET", url, "web", nil, nil)
+	resp, err := httpClient.Request("GET", url, "web", nil, nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get task: %w", err)
 	}
@@ -2763,8 +2963,8 @@ func (c *CLI) ShowTaskUserCommand(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
-// UseModel sets the current model for chat
-func (c *CLI) UseModel(cmd *Command) (ResponseIf, error) {
+// APIUseModelCommand sets the current model for chat
+func (c *CLI) APIUseModelCommand(cmd *Command) (ResponseIf, error) {
 	if c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].APIKey == nil && c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].LoginToken == nil {
 		return nil, fmt.Errorf("API key not set. Please login first")
 	}
diff --git a/internal/cli/user_parser.go b/internal/cli/user_parser.go
index db7dd6fd13..478895b65e 100644
--- a/internal/cli/user_parser.go
+++ b/internal/cli/user_parser.go
@@ -480,38 +480,6 @@ func (p *Parser) parseAPIListAvailableProviders() (*Command, error) {
 	return NewCommand("api_list_available_providers"), nil
 }
 
-func (p *Parser) parseShowQuotedStringCommand() (*Command, error) {
-	str, err := p.parseQuotedString()
-	if err != nil {
-		return nil, err
-	}
-	p.nextToken() // consume str
-	switch p.curToken.Type {
-	case TokenTask:
-		p.nextToken() // consume TASK
-
-		var taskID string
-		taskID, err = p.parseQuotedString()
-		if err != nil {
-			return nil, fmt.Errorf("expected string: %w", err)
-		}
-		p.nextToken()
-
-		cmd := NewCommand("show_task_user_command")
-		cmd.Params["task_id"] = taskID
-		cmd.Params["composite_instance_name"] = str
-		p.nextToken()
-
-		// Semicolon is optional
-		if p.curToken.Type == TokenSemicolon {
-			p.nextToken()
-		}
-		return cmd, nil
-	default:
-		return nil, fmt.Errorf("unknown command: %s", str)
-	}
-}
-
 func (p *Parser) parseAPIShowCommands() (*Command, error) {
 	p.nextToken() // consume SHOW
 	switch p.curToken.Type {
@@ -527,14 +495,10 @@ func (p *Parser) parseAPIShowCommands() (*Command, error) {
 		return p.parseAPIShowProviderCommands()
 	case TokenModel:
 		return p.parseAPIShowModel()
-	case TokenTask:
-		return p.parseShowTask()
-	case TokenQuotedString:
-		return p.parseShowQuotedStringCommand()
 	case TokenAdmin:
-		return p.parseUserShowAdmin()
+		return p.parseAPIShowAdmin()
 	case TokenAPI:
-		return p.parseUserShowAPI()
+		return p.parseAPIShowAPI()
 	case TokenLog:
 		return p.parseAPIShowLogCommands()
 	default:
@@ -590,7 +554,7 @@ func (p *Parser) parseAPIShowVariable() (*Command, error) {
 	return cmd, nil
 }
 
-// SHOW MODEL 'model_name'
+// SHOW MODEL 'model_name';
 func (p *Parser) parseAPIShowModel() (*Command, error) {
 	p.nextToken() // consume MODEL
 
@@ -608,9 +572,10 @@ func (p *Parser) parseAPIShowModel() (*Command, error) {
 	return cmd, nil
 }
 
-// SHOW PROVIDER <name>
-// SHOW PROVIDER <name> INSTANCE <instance_name>
-// SHOW PROVIDER <name> INSTANCE <instance_name> BALANCE
+// SHOW PROVIDER <name>;
+// SHOW PROVIDER <name> INSTANCE <instance_name>;
+// SHOW PROVIDER <name> INSTANCE <instance_name> BALANCE;
+// SHOW PROVIDER <name> INSTANCE <instance_name> TASK <task_id>;
 // SHOW PROVIDER 'provider_name' MODEL 'model_name';
 func (p *Parser) parseAPIShowProviderCommands() (*Command, error) {
 	p.nextToken() // consume PROVIDER
@@ -638,7 +603,7 @@ func (p *Parser) parseAPIShowProviderCommands() (*Command, error) {
 	return cmd, nil
 }
 
-// SHOW PROVIDER <name> INSTANCE <instance_name>
+// SHOW PROVIDER <name> INSTANCE <instance_name>;
 func (p *Parser) parseAPIShowProviderInstance(providerName string) (*Command, error) {
 	p.nextToken() // consume INSTANCE
 
@@ -648,18 +613,21 @@ func (p *Parser) parseAPIShowProviderInstance(providerName string) (*Command, er
 	}
 	p.nextToken() // consume instance_name
 
-	if p.curToken.Type == TokenBalance {
+	switch p.curToken.Type {
+	case TokenBalance:
 		return p.parseAPIShowProviderInstanceBalance(providerName, instanceName)
+	case TokenTask:
+		return p.parseAPIShowProviderInstanceTask(providerName, instanceName)
+	case TokenSemicolon, TokenEOF:
+		p.nextToken()
+	default:
+		return nil, fmt.Errorf("unknown SHOW target: %s", p.curToken.Value)
 	}
 
 	cmd := NewCommand("api_show_provider_instance")
 	cmd.Params["instance_name"] = instanceName
 	cmd.Params["provider_name"] = providerName
 
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
 	return cmd, nil
 }
 
@@ -678,6 +646,28 @@ func (p *Parser) parseAPIShowProviderInstanceBalance(providerName, instanceName
 	return cmd, nil
 }
 
+// SHOW PROVIDER <name> INSTANCE <instance_name> TASK <task_id>
+func (p *Parser) parseAPIShowProviderInstanceTask(providerName, instanceName string) (*Command, error) {
+	p.nextToken() // consume TASK
+
+	taskID, err := p.parseQuotedString()
+	if err != nil {
+		return nil, fmt.Errorf("expected task id: %w", err)
+	}
+	p.nextToken() // consume task_id
+
+	cmd := NewCommand("api_show_provider_instance_task")
+	cmd.Params["instance_name"] = instanceName
+	cmd.Params["provider_name"] = providerName
+	cmd.Params["task_id"] = taskID
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+	return cmd, nil
+}
+
 // SHOW PROVIDER <name> MODEL <model_name>
 func (p *Parser) parseAPIShowProviderModel(providerName string) (*Command, error) {
 	p.nextToken() // consume MODEL
@@ -711,16 +701,20 @@ func (p *Parser) parseListAllModels() (*Command, error) {
 	return cmd, nil
 }
 
-func (p *Parser) parseCreateCommand() (*Command, error) {
+func (p *Parser) parseAPICreateCommands() (*Command, error) {
 	p.nextToken() // consume CREATE
 
 	switch p.curToken.Type {
-	case TokenModel:
-		return p.parseCreateModelProvider()
 	case TokenDataset:
-		return p.parseCreateDataset()
+		return p.parseAPICreateDataset()
 	case TokenChat:
-		return p.parseCreateChat()
+		return p.parseAPICreateChat()
+	case TokenSearch:
+		return p.parseAPICreateSearch()
+	case TokenAgent:
+		return p.parseAPICreateAgent()
+	case TokenMemory:
+		return p.parseAPICreateMemory()
 	case TokenKey:
 		return p.parseAPICreateKey()
 	case TokenChunkStore:
@@ -728,7 +722,7 @@ func (p *Parser) parseCreateCommand() (*Command, error) {
 	case TokenMetadata:
 		return p.parseCreateMetadataStore()
 	case TokenProvider:
-		return p.parseCreateProviderInstance()
+		return p.parseAPICreateProviderInstance()
 	default:
 		return nil, fmt.Errorf("unknown CREATE target: %s", p.curToken.Value)
 	}
@@ -858,36 +852,6 @@ func (p *Parser) parseCreateRole() (*Command, error) {
 	return cmd, nil
 }
 
-func (p *Parser) parseCreateModelProvider() (*Command, error) {
-	p.nextToken() // consume MODEL
-	if p.curToken.Type != TokenProvider {
-		return nil, fmt.Errorf("expected PROVIDER")
-	}
-	p.nextToken()
-
-	providerName, err := p.parseQuotedString()
-	if err != nil {
-		return nil, err
-	}
-
-	p.nextToken()
-	providerKey, err := p.parseQuotedString()
-	if err != nil {
-		return nil, err
-	}
-
-	cmd := NewCommand("create_model_provider")
-	cmd.Params["provider_name"] = providerName
-	cmd.Params["provider_key"] = providerKey
-
-	p.nextToken()
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-	return cmd, nil
-}
-
 // parseAddProvider parses ADD PROVIDER commands
 // ADD PROVIDER <name>
 func (p *Parser) parseAddProvider() (*Command, error) {
@@ -1248,18 +1212,18 @@ func (p *Parser) parseDeleteAdminServer() (*Command, error) {
 	return cmd, nil
 }
 
-func (p *Parser) parseUserSaveCommand() (*Command, error) {
+func (p *Parser) parseAPISaveCommand() (*Command, error) {
 	p.nextToken() // consume SAVE
 	switch p.curToken.Type {
 	case TokenConfig:
-		return p.parseSaveConfig()
+		return p.parseAPISaveConfig()
 	default:
 		return nil, fmt.Errorf("unknown ADD target: %s", p.curToken.Value)
 	}
 }
 
-// syntax: save config as 'path'
-func (p *Parser) parseSaveConfig() (*Command, error) {
+// SAVE CONFIG AS 'path'
+func (p *Parser) parseAPISaveConfig() (*Command, error) {
 	p.nextToken() // consume CONFIG
 
 	if p.curToken.Type != TokenAs {
@@ -1272,7 +1236,7 @@ func (p *Parser) parseSaveConfig() (*Command, error) {
 		return nil, err
 	}
 
-	cmd := NewCommand("save_config_command")
+	cmd := NewCommand("api_save_config_command")
 	cmd.Params["path"] = path
 
 	// Semicolon is optional
@@ -1283,7 +1247,9 @@ func (p *Parser) parseSaveConfig() (*Command, error) {
 	return cmd, nil
 }
 
-func (p *Parser) parseCreateDataset() (*Command, error) {
+// CREATE DATASET 'abc' WITH EMBEDDING 'modelName@instanceName@providerName' PARSER 'parserType'
+// CREATE DATASET 'abc' WITH EMBEDDING 'modelName@instanceName@providerName' PIPELINE 'pipelineName'
+func (p *Parser) parseAPICreateDataset() (*Command, error) {
 	p.nextToken() // consume DATASET
 	datasetName, err := p.parseQuotedString()
 	if err != nil {
@@ -1306,13 +1272,14 @@ func (p *Parser) parseCreateDataset() (*Command, error) {
 	}
 
 	p.nextToken()
-	cmd := NewCommand("create_user_dataset")
+	cmd := NewCommand("api_create_dataset")
 	cmd.Params["dataset_name"] = datasetName
 	cmd.Params["embedding"] = embedding
 
 	if p.curToken.Type == TokenParser {
 		p.nextToken()
-		parserType, err := p.parseQuotedString()
+		var parserType string
+		parserType, err = p.parseQuotedString()
 		if err != nil {
 			return nil, err
 		}
@@ -1320,7 +1287,8 @@ func (p *Parser) parseCreateDataset() (*Command, error) {
 		p.nextToken()
 	} else if p.curToken.Type == TokenPipeline {
 		p.nextToken()
-		pipeline, err := p.parseQuotedString()
+		var pipeline string
+		pipeline, err = p.parseQuotedString()
 		if err != nil {
 			return nil, err
 		}
@@ -1337,32 +1305,89 @@ func (p *Parser) parseCreateDataset() (*Command, error) {
 	return cmd, nil
 }
 
-func (p *Parser) parseCreateChat() (*Command, error) {
+// CREAT CHAT 'chat_name'
+func (p *Parser) parseAPICreateChat() (*Command, error) {
 	p.nextToken() // consume CHAT
 	chatName, err := p.parseQuotedString()
 	if err != nil {
 		return nil, err
 	}
+	p.nextToken()
 
-	cmd := NewCommand("create_user_chat")
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	cmd := NewCommand("api_create_chat")
 	cmd.Params["chat_name"] = chatName
 
+	return cmd, nil
+}
+
+// CREAT AGENT 'agent_name'
+func (p *Parser) parseAPICreateAgent() (*Command, error) {
+	p.nextToken() // consume AGENT
+
+	agentName, err := p.parseQuotedString()
+	if err != nil {
+		return nil, err
+	}
+	p.nextToken()
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	cmd := NewCommand("api_create_agent")
+	cmd.Params["agent_name"] = agentName
+	return cmd, nil
+}
+
+// CREAT SEARCH 'search_name'
+func (p *Parser) parseAPICreateSearch() (*Command, error) {
+	p.nextToken() // consume SEARCH
+	searchName, err := p.parseQuotedString()
+	if err != nil {
+		return nil, err
+	}
+	p.nextToken()
+
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	cmd := NewCommand("api_create_search")
+	cmd.Params["search_name"] = searchName
+
+	return cmd, nil
+}
+
+// CREAT MEMORY 'memory_name'
+func (p *Parser) parseAPICreateMemory() (*Command, error) {
+	p.nextToken() // consume MEMORY
+	memoryName, err := p.parseQuotedString()
+	if err != nil {
+		return nil, err
+	}
 	p.nextToken()
 	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
+
+	cmd := NewCommand("api_create_memory")
+	cmd.Params["memory_name"] = memoryName
+
 	return cmd, nil
 }
 
-func (p *Parser) parseDropCommand() (*Command, error) {
+func (p *Parser) parseAPIDropCommands() (*Command, error) {
 	p.nextToken() // consume DROP
 
 	switch p.curToken.Type {
-	case TokenUser:
-		return p.parseDropUser()
-	case TokenRole:
-		return p.parseDropRole()
 	case TokenDataset:
 		return p.parseDropDataset()
 	case TokenChat:
@@ -1484,42 +1509,6 @@ func (p *Parser) parseDropMetadataStore() (*Command, error) {
 	return cmd, nil
 }
 
-func (p *Parser) parseDropUser() (*Command, error) {
-	p.nextToken() // consume USER
-	userName, err := p.parseQuotedString()
-	if err != nil {
-		return nil, err
-	}
-
-	cmd := NewCommand("drop_user")
-	cmd.Params["user_name"] = userName
-
-	p.nextToken()
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-	return cmd, nil
-}
-
-func (p *Parser) parseDropRole() (*Command, error) {
-	p.nextToken() // consume ROLE
-	roleName, err := p.parseIdentifier()
-	if err != nil {
-		return nil, err
-	}
-
-	cmd := NewCommand("drop_role")
-	cmd.Params["role_name"] = roleName
-
-	p.nextToken()
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-	return cmd, nil
-}
-
 // parseDeleteProvider parses DELETE PROVIDER <name> command
 func (p *Parser) parseDeleteProvider() (*Command, error) {
 	p.nextToken() // consume PROVIDER
@@ -1621,9 +1610,8 @@ func (p *Parser) parseAlterProvider() (*Command, error) {
 	return cmd, nil
 }
 
-// parseCreateProviderInstance parses CREATE PROVIDER <name> INSTANCE <instance_name> KEY <api_key> URL <base_url> REGION <region> command
-// instance_name cannot be "default"
-func (p *Parser) parseCreateProviderInstance() (*Command, error) {
+// CREATE PROVIDER <name> INSTANCE <instance_name> KEY <api_key> URL <base_url> REGION <region>
+func (p *Parser) parseAPICreateProviderInstance() (*Command, error) {
 	p.nextToken() // consume PROVIDER
 
 	providerName, err := p.parseQuotedString()
@@ -1678,7 +1666,7 @@ optionsLoop:
 		}
 	}
 
-	cmd := NewCommand("create_provider_instance")
+	cmd := NewCommand("api_create_provider_instance")
 	cmd.Params["provider_name"] = providerName
 	cmd.Params["instance_name"] = instanceName
 	cmd.Params["api_key"] = apiKey
@@ -1699,27 +1687,6 @@ optionsLoop:
 	return cmd, nil
 }
 
-// parseShowTask parses SHOW TASK <task>
-func (p *Parser) parseShowTask() (*Command, error) {
-	p.nextToken() // consume TASK
-
-	taskID, err := p.parseQuotedString()
-	if err != nil {
-		return nil, fmt.Errorf("expected string: %w", err)
-	}
-	p.nextToken()
-
-	cmd := NewCommand("show_task_user_command")
-	cmd.Params["task_id"] = taskID
-	p.nextToken()
-
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-	return cmd, nil
-}
-
 // parseAlterInstance parses ALTER INSTANCE <name> NAME <new_name> FROM PROVIDER <name> command
 func (p *Parser) parseAlterInstance() (*Command, error) {
 	p.nextToken() // consume INSTANCE
@@ -3313,22 +3280,22 @@ func (p *Parser) parseCheckProviderByKeyCommand() (*Command, error) {
 	return cmd, nil
 }
 
-func (p *Parser) parseUseCommand() (*Command, error) {
+func (p *Parser) parseAPIUseCommands() (*Command, error) {
 	p.nextToken() // consume USE
 
 	switch p.curToken.Type {
 	case TokenModel:
-		return p.parseUseModel()
+		return p.parseAPIUseModel()
 	case TokenAPI:
-		return p.parseUseAPIServer()
+		return p.parseAPIUseAPIServer()
 	case TokenAdmin:
-		return p.parseUseAdminServer()
+		return p.parseAPIUseAdminServer()
 	default:
 		return nil, fmt.Errorf("expected MODEL or SKILL after USE")
 	}
 }
 
-func (p *Parser) parseUseModel() (*Command, error) {
+func (p *Parser) parseAPIUseModel() (*Command, error) {
 	p.nextToken() // consume MODEL
 
 	modelNameOrID, err := p.parseQuotedString()
@@ -3342,7 +3309,7 @@ func (p *Parser) parseUseModel() (*Command, error) {
 		p.nextToken()
 	}
 
-	cmd := NewCommand("use_model")
+	cmd := NewCommand("api_use_model")
 
 	if common.IsCompositeModelName(modelNameOrID) {
 		cmd.Params["composite_model_name"] = modelNameOrID
@@ -3359,7 +3326,7 @@ func (p *Parser) parseUseModel() (*Command, error) {
 	return cmd, nil
 }
 
-func (p *Parser) parseUseAPIServer() (*Command, error) {
+func (p *Parser) parseAPIUseAPIServer() (*Command, error) {
 	p.nextToken() // consume API
 
 	serverName, err := p.parseQuotedString()
@@ -3367,7 +3334,7 @@ func (p *Parser) parseUseAPIServer() (*Command, error) {
 		return nil, err
 	}
 	p.nextToken()
-	cmd := NewCommand("use_api_server")
+	cmd := NewCommand("api_use_api_server")
 	cmd.Params["server_name"] = serverName
 
 	// Semicolon is optional
@@ -3377,10 +3344,10 @@ func (p *Parser) parseUseAPIServer() (*Command, error) {
 	return cmd, nil
 }
 
-func (p *Parser) parseUseAdminServer() (*Command, error) {
+func (p *Parser) parseAPIUseAdminServer() (*Command, error) {
 	p.nextToken() // consume ADMIN
 
-	cmd := NewCommand("use_admin_server")
+	cmd := NewCommand("api_use_admin_server")
 
 	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
@@ -3587,10 +3554,6 @@ func (p *Parser) parseUserStatement() (*Command, error) {
 		return p.parseDeleteCommand()
 	case TokenShow:
 		return p.parseAPIShowCommands()
-	case TokenCreate:
-		return p.parseCreateCommand()
-	case TokenDrop:
-		return p.parseDropCommand()
 	case TokenList:
 		return p.parseAPIListCommands()
 	case TokenParse:
@@ -4056,15 +4019,15 @@ func (p *Parser) parseUserStartIngestion() (*Command, error) {
 	return cmd, nil
 }
 
-// parseShowTask parses SHOW ADMIN SERVER
-func (p *Parser) parseUserShowAdmin() (*Command, error) {
+// SHOW ADMIN SERVER
+func (p *Parser) parseAPIShowAdmin() (*Command, error) {
 	p.nextToken() // consume ADMIN
 
 	var cmd *Command
 	switch p.curToken.Type {
 	case TokenServer:
 		p.nextToken()
-		cmd = NewCommand("show_admin_server")
+		cmd = NewCommand("api_show_admin_server")
 	default:
 		return nil, fmt.Errorf("expected SERVER after ADMIN")
 	}
@@ -4160,19 +4123,19 @@ func (p *Parser) parseUserRemoveTask() (*Command, error) {
 	return cmd, nil
 }
 
-// parseShowTask parses SHOW API SERVER <server_name>
-func (p *Parser) parseUserShowAPI() (*Command, error) {
+// SHOW API SERVER <server_name>
+func (p *Parser) parseAPIShowAPI() (*Command, error) {
 	p.nextToken() // consume API
 
 	var cmd *Command
 	switch p.curToken.Type {
 	case TokenServer:
 		p.nextToken()
-		cmd = NewCommand("show_api_server")
+		cmd = NewCommand("api_show_api_server")
 
 		serverName, err := p.parseQuotedString()
 		if err != nil {
-			return nil, fmt.Errorf("expected dataset_name: %w", err)
+			return nil, fmt.Errorf("expected API server name: %w", err)
 		}
 		cmd.Params["api_server_name"] = serverName
 		p.nextToken()