fix: add log level, change list_data_stream to get_data_stream, add count on all array responses, add users tool

Author: andersh

README.md

@@ -19,6 +19,9 @@ This project provides an MCP (Message Context Protocol) server for [Parseable](h
 - Environment variable and flag-based configuration
 - The mcp server returns responses in json where the payload is both in text and structured format.
 
+> In Parseable dataset and data stream names are used interchangeably, as Parseable's datasets are essentially 
+> named data streams. In all tool description we try to use the term data stream to avoid confusion with the term dataset which can have different 
+> meanings in other contexts.
 
 # Testing
 To test the server you can use the [mcp-cli](https://github.com/philschmid/mcp-cli)
@@ -96,6 +99,8 @@ You can configure the Parseable connection using environment variables or flags:
 - `PARSEABLE_PASSWORD` or `--parseable-pass` (default: admin)
 - `LISTEN_ADDR` or `--listen` - the address when running the mcp server in http mode (default: :9034)
 - `INSECURE` - set to `true` to skip TLS verification (default: false)`
+- `LOG_LEVEL` - set log level. Supported levels are debug, info, warn and error (default: info)
+
 Example:
 ```sh
 PARSEABLE_URL="http://your-parseable-host:8000" PARSEABLE_USER="admin" PARSEABLE_PASS="admin" ./mcp-parseable-server
@@ -112,7 +117,7 @@ Execute a SQL query against a data stream.
   - `endTime`: ISO 8601 end time
 - **Returns:** Query result
 
-## 2. `list_data_streams`
+## 2. `get_data_streams`
 List all available data streams in Parseable.
 - **Returns:** Array of stream names
 

cmd/mcp_parseable_server/main.go

@@ -18,12 +18,34 @@ func main() {
 	parseableUserFlag := flag.String("parseable-username", "", "Parseable basic auth username (or set PARSEABLE_USER env var)")
 	parseablePassFlag := flag.String("parseable-password", "", "Parseable basic auth password (or set PARSEABLE_PASS env var)")
 	listenAddr := flag.String("listen", ":9034", "address to listen on")
+	logLevel := flag.String("log-level", "info", "log level: debug, info, warn, error (or set LOG_LEVEL env var)")
 	versionFlag := flag.Bool("version", false, "print version and exit")
 	flag.Parse()
 
+	// Determine log level from environment variable or flag
+	logLevelStr := os.Getenv("LOG_LEVEL")
+	if logLevelStr == "" {
+		logLevelStr = *logLevel
+	}
+
+	// Parse log level string to slog.Level
+	var level slog.Level
+	switch logLevelStr {
+	case "debug":
+		level = slog.LevelDebug
+	case "info":
+		level = slog.LevelInfo
+	case "warn":
+		level = slog.LevelWarn
+	case "error":
+		level = slog.LevelError
+	default:
+		level = slog.LevelInfo
+	}
+
 	// Setup structured logger for stdout
 	logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
+		Level: level,
 	}))
 	slog.SetDefault(logger)
 

tools/parseable.go

@@ -75,33 +75,9 @@ func doParseableQuery(query string, streamName string, startTime string, endTime
 	return arrResult, nil
 }
 
-func listParseableStreams() ([]string, error) {
+func listParseableStreams() ([]map[string]interface{}, error) {
 	url := ParseableBaseURL + "/api/v1/logstream"
-	httpReq, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return nil, err
-	}
-	addBasicAuth(httpReq)
-	resp, err := HTTPClient.Do(httpReq)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		if err := resp.Body.Close(); err != nil {
-			slog.Error("failed to close response body", "error", err)
-		}
-	}()
-	var apiResult []struct {
-		Name string `json:"name"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&apiResult); err != nil {
-		return nil, err
-	}
-	streams := make([]string, 0, len(apiResult))
-	for _, s := range apiResult {
-		streams = append(streams, s.Name)
-	}
-	return streams, nil
+	return doSimpleGetArray(url)
 }
 
 func getParseableSchema(stream string) (map[string]interface{}, error) {
@@ -129,38 +105,31 @@ func getParseableSchema(stream string) (map[string]interface{}, error) {
 
 func getParseableStats(streamName string) (map[string]interface{}, error) {
 	url := ParseableBaseURL + "/api/v1/logstream/" + streamName + "/stats"
-	stats, m, err := doSimpleGet(url)
-	if err != nil {
-		return m, err
-	}
-	return stats, nil
+	stats, _, err := doSimpleGet(url)
+	return stats, err
 }
 
 func getParseableInfo(streamName string) (map[string]interface{}, error) {
 	url := ParseableBaseURL + "/api/v1/logstream/" + streamName + "/info"
-	info, m, err := doSimpleGet(url)
-	if err != nil {
-		return m, err
-	}
-	return info, nil
+	info, _, err := doSimpleGet(url)
+	return info, err
 }
 
 func getParseableAbout() (map[string]interface{}, error) {
 	url := ParseableBaseURL + "/api/v1/about"
-	about, m, err := doSimpleGet(url)
-	if err != nil {
-		return m, err
-	}
-	return about, nil
+	about, _, err := doSimpleGet(url)
+	return about, err
 }
 
 func getParseableRoles() (map[string]interface{}, error) {
 	url := ParseableBaseURL + "/api/v1/roles"
-	roles, m, err := doSimpleGet(url)
-	if err != nil {
-		return m, err
-	}
-	return roles, nil
+	roles, _, err := doSimpleGet(url)
+	return roles, err
+}
+
+func getParseableUsers() ([]map[string]interface{}, error) {
+	url := ParseableBaseURL + "/api/v1/users"
+	return doSimpleGetArray(url)
 }
 
 func doSimpleGet(url string) (map[string]interface{}, map[string]interface{}, error) {
@@ -178,9 +147,31 @@ func doSimpleGet(url string) (map[string]interface{}, map[string]interface{}, er
 			slog.Error("failed to close response body", "error", err)
 		}
 	}()
-	var stats map[string]interface{}
-	if err := json.NewDecoder(resp.Body).Decode(&stats); err != nil {
+	var response map[string]interface{}
+	if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
 		return nil, nil, err
 	}
-	return stats, nil, nil
+	return response, nil, nil
+}
+
+func doSimpleGetArray(url string) ([]map[string]interface{}, error) {
+	httpReq, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	addBasicAuth(httpReq)
+	resp, err := HTTPClient.Do(httpReq)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		if err := resp.Body.Close(); err != nil {
+			slog.Error("failed to close response body", "error", err)
+		}
+	}()
+	var response []map[string]interface{}
+	if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
+		return nil, err
+	}
+	return response, nil
 }

tools/parseable_list_streams.go

@@ -10,20 +10,22 @@ import (
 
 func RegisterListDataStreamsTool(mcpServer *server.MCPServer) {
 	mcpServer.AddTool(mcp.NewTool(
-		"list_data_streams",
+		"get_data_streams",
 		mcp.WithDescription("List all available data streams in Parseable. "+
 			"Use this tool to discover which data streams are available before executing queries. "+
 			"Each stream is a table-like collection of data and must be referenced by exact name in query_data_stream operations. "+
-			"Returns a JSON object with a 'streams' array containing stream names as strings. "+
+			"Returns a JSON object with a 'streams' array containing stream objects with metadata (including 'name' field for the stream name) and 'count' (number of streams). "+
 			"All returned streams are accessible and queryable by the current user."),
 	), func(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-		slog.Info("listing all data streams")
 		streams, err := listParseableStreams()
 		if err != nil {
-			slog.Error("failed to get response", "error", err, "tool", "list_data_streams")
+			slog.Error("failed to get response", "error", err, "tool", "get_data_streams")
 			return mcp.NewToolResultError(err.Error()), nil
 		}
 
-		return mcp.NewToolResultJSON(map[string]interface{}{"streams": streams})
+		return mcp.NewToolResultJSON(map[string]interface{}{
+			"streams": streams,
+			"count":   len(streams),
+		})
 	})
 }

tools/parseable_roles.go

@@ -12,22 +12,23 @@ func RegisterGetRolesTool(mcpServer *server.MCPServer) {
 	mcpServer.AddTool(mcp.NewTool(
 		"get_roles",
 		mcp.WithDescription(`Get role-based access control (RBAC) information for the Parseable instance.
-Use this to understand user roles, permissions, and dataset access controls.
+Use this to understand user roles, permissions, and data stream access controls. 
 Calls /api/v1/role.
 
 Returns a JSON object where each key is a role name and the value is an array of privileges assigned to that role.
 
 Available Privilege Types:
 - admin: Full system access with all privileges (no resource restrictions)
 - editor: Limited administrative privileges for cluster features (no resource restrictions)
-- reader: Read-only access to specific datasets (requires at least one dataset resource)
-- writer: Read and write access to specific datasets (requires at least one dataset resource)
-- ingestor: Write-only access to specific datasets for data ingestion (requires at least one dataset resource)
+- reader: Read-only access to specific data streams (requires at least one stream resource)
+- writer: Read and write access to specific data streams (requires at least one stream resource)
+- ingestor: Write-only access to specific data streams for data ingestion (requires at least one stream resource)
 
 Resource Assignment:
 - admin and editor roles apply globally across the entire Parseable instance
-- reader, writer, and ingestor roles are always associated with specific dataset resources
-- Each role entry includes the list of datasets (resources) the role has access to
+- reader, writer, and ingestor roles are always associated with specific stream resources
+- Each role entry includes the list of data streams (resources) the role has access to
+- Note: In Parseable, "dataset" and "data stream" are synonymous terms referring to the same concept
 
 Use this tool to understand access controls before querying or ingesting data.
 For detailed RBAC documentation, see: https://www.parseable.com/docs/user-guide/rbac
@@ -38,7 +39,6 @@ For detailed RBAC documentation, see: https://www.parseable.com/docs/user-guide/
 			slog.Error("failed to get roles", "error", err)
 			return mcp.NewToolResultError(err.Error()), nil
 		}
-
 		return mcp.NewToolResultJSON(roles)
 	})
 }

tools/parseable_users.go

@@ -0,0 +1,54 @@
+package tools
+
+import (
+	"context"
+	"log/slog"
+
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
+func RegisterGetUsersTool(mcpServer *server.MCPServer) {
+	mcpServer.AddTool(mcp.NewTool(
+		"get_users",
+		mcp.WithDescription(`Get all configured users in the Parseable instance with their authentication methods and role assignments.
+Use this to understand user access, authentication configuration, and role-based permissions.
+Calls /api/v1/users.
+
+Returns a JSON object with a 'users' array where each element is a user object with the following structure, plus 'count' (number of users):
+
+User Information:
+- id: unique user identifier
+- username: the user's login name
+- method: authentication method ("native" for local auth, "oidc" for OpenID Connect)
+- email: user's email address (null if not configured)
+- picture: user's profile picture URL (null if not set)
+
+Role Assignments:
+- roles: object mapping role names to arrays of privilege grants
+  Each privilege grant contains:
+  - privilege: the permission level ("admin", "editor", "reader", "writer", or "ingestor")
+  - resource: object specifying the resource this privilege applies to
+    - stream: the data stream name this privilege grants access to
+- group_roles: object containing roles inherited from group membership
+- user_groups: array of groups this user belongs to
+
+Use this tool to:
+- Verify user access permissions before executing operations
+- Understand which users have access to specific data streams
+- Check authentication methods configured for users
+- Audit user-role-stream relationships
+`),
+	), func(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+		users, err := getParseableUsers()
+		if err != nil {
+			slog.Error("failed to get users", "error", err)
+			return mcp.NewToolResultError(err.Error()), nil
+		}
+
+		return mcp.NewToolResultJSON(map[string]interface{}{
+			"users": users,
+			"count": len(users),
+		})
+	})
+}

tools/register.go

@@ -10,4 +10,5 @@ func RegisterParseableTools(mcpServer *server.MCPServer) {
 	RegisterGetDataStreamInfoTool(mcpServer)
 	RegisterGetAboutTool(mcpServer)
 	RegisterGetRolesTool(mcpServer)
+	RegisterGetUsersTool(mcpServer)
 }