Address PR #15 review comments

- Fix experiment.UUID -> experiment.uuid
- Add None check for experiment in create_experiment
- Fix MemoryLeakDetection: remove outputs param, use analyze_memory_leaks()
- Fix ChangePointAnalysis: method -> methods (list of analysis modes)
- Fix CorrelationAnalysis: analyze_correlation -> analyze_correlations,
  plot_correlation -> plot_correlation_matrix
- Fix IdleResourceDetection: single threshold -> per-resource thresholds
- Fix CapacityPlanning: plan_capacity -> forecast_capacity(forecast_steps=)
- Remove clustering command (module not meaningful)
- Fix help text: 'UUID or name' -> 'UUID'
- Handle nested dict data in fetch_data_cmd
- Move scripts to tmll/mcp package
- Fix MCP server CLI_PATH to use Path(__file__) for reliable resolution
- Make MCP call_tool arguments Optional[dict] with None guard
- Add mcp==1.27.0 to requirements.txt

Author: MatthewKhouzam

requirements.txt

@@ -10,4 +10,5 @@ matplotlib>=3.8.0
 seaborn==0.13.2
 statsmodels>=0.14.1
 ruptures==1.1.9
-rich==13.9.4
+rich==13.9.4
+mcp==1.27.0

tmll/mcp/__init__.py

@@ -0,0 +1 @@
+

tmll_cli.py tmll/mcp/cli.pytmll_cli.py renamed to tmll/mcp/cli.py

@@ -3,6 +3,7 @@
 import argparse
 import sys
 import json
+import pandas as pd
 from tmll.tmll_client import TMLLClient
 from tmll.common.models.experiment import Experiment
 from tmll.ml.modules.anomaly_detection.anomaly_detection_module import AnomalyDetection
@@ -11,7 +12,6 @@
 from tmll.ml.modules.root_cause.correlation_module import CorrelationAnalysis
 from tmll.ml.modules.resource_optimization.idle_resource_detection_module import IdleResourceDetection
 from tmll.ml.modules.predictive_maintenance.capacity_planning_module import CapacityPlanning
-from tmll.ml.unsupervised.clustering import Clustering
 
 
 def get_experiment(client, exp_uuid):
@@ -30,7 +30,10 @@ def create_experiment(args):
     client = TMLLClient(args.host, args.port, verbose=args.verbose)
     traces = [{"path": os.path.expanduser(path)} for path in args.traces]
     experiment = client.create_experiment(traces=traces, experiment_name=args.name)
-    print(f"Created experiment: {experiment.name} (UUID: {experiment.UUID})")
+    if not experiment:
+        print("Failed to create experiment")
+        return
+    print(f"Created experiment: {experiment.name} (UUID: {experiment.uuid})")
 
 
 def list_outputs(args):
@@ -65,11 +68,22 @@ def fetch_data_cmd(args):
     data = client.fetch_data(experiment, outputs_with_tree)
 
     if args.output:
-        for key, df in data.items():
-            df.to_csv(f"{args.output}_{key}.csv", index=False)
+        for key, value in data.items():
+            if isinstance(value, pd.DataFrame):
+                value.to_csv(f"{args.output}_{key}.csv", index=False)
+            elif isinstance(value, dict):
+                for sub_key, df in value.items():
+                    if isinstance(df, pd.DataFrame):
+                        df.to_csv(f"{args.output}_{key}_{sub_key}.csv", index=False)
         print(f"Data exported to {args.output}_*.csv")
     else:
-        print(json.dumps({k: v.to_dict() for k, v in data.items()}, indent=2))
+        result = {}
+        for k, v in data.items():
+            if isinstance(v, pd.DataFrame):
+                result[k] = v.to_dict()
+            elif isinstance(v, dict):
+                result[k] = {sk: sv.to_dict() for sk, sv in v.items() if isinstance(sv, pd.DataFrame)}
+        print(json.dumps(result, indent=2, default=str))
 
 
 def detect_anomalies(args):
@@ -106,15 +120,9 @@ def detect_memory_leak(args):
         print("Experiment not found")
         return
 
-    outputs = experiment.find_outputs(keyword=args.keywords, type=['xy'])
-    
-    if not outputs:
-        print("No outputs found")
-        return
-    
-    mld = MemoryLeakDetection(client, experiment, outputs)
-    result = mld.detect_memory_leak()
-    print(f"Memory leak detected: {result}")
+    mld = MemoryLeakDetection(client, experiment)
+    result = mld.analyze_memory_leaks()
+    print(f"Memory leak analysis: {result}")
 
 
 def detect_changepoints(args):
@@ -133,12 +141,12 @@ def detect_changepoints(args):
         return
 
     cpa = ChangePointAnalysis(client, experiment, outputs)
-    changepoints = cpa.get_change_points(method=args.method)
+    changepoints = cpa.get_change_points(methods=args.methods)
 
     if args.plot:
         cpa.plot_change_points(changepoints)
     else:
-        print(f"Found {len(changepoints)} change points")
+        print(f"Found {len(changepoints.metrics) if changepoints else 0} change point metrics")
 
 
 def analyze_correlation(args):
@@ -157,10 +165,10 @@ def analyze_correlation(args):
         return
 
     ca = CorrelationAnalysis(client, experiment, outputs)
-    correlations = ca.analyze_correlation(method=args.method)
+    correlations = ca.analyze_correlations(method=args.method)
 
     if args.plot:
-        ca.plot_correlation(correlations)
+        ca.plot_correlation_matrix(correlations)
     else:
         print(f"Correlation results: {correlations}")
 
@@ -181,7 +189,11 @@ def detect_idle_resources(args):
         return
 
     ird = IdleResourceDetection(client, experiment, outputs)
-    idle = ird.detect_idle_resources(threshold=args.threshold)
+    idle = ird.analyze_idle_resources(
+        cpu_idle_threshold=args.cpu_idle_threshold,
+        memory_idle_threshold=args.memory_idle_threshold,
+        disk_idle_threshold=args.disk_idle_threshold,
+    )
     print(f"Idle resources: {idle}")
 
 
@@ -201,8 +213,8 @@ def plan_capacity(args):
         return
 
     cp = CapacityPlanning(client, experiment, outputs)
-    plan = cp.plan_capacity(horizon=args.horizon)
-    print(f"Capacity plan: {plan}")
+    plan = cp.forecast_capacity(forecast_steps=args.horizon)
+    print(f"Capacity forecast: {plan}")
 
 
 def list_experiments(args):
@@ -225,28 +237,6 @@ def delete_experiment(args):
     print(f"Deleted experiment: {args.experiment}")
 
 
-def cluster_data(args):
-    """Perform clustering analysis"""
-    client = TMLLClient(args.host, args.port, verbose=args.verbose)
-    experiment = get_experiment(client, args.experiment)
-    
-    if not experiment:
-        print("Experiment not found")
-        return
-    
-    outputs = experiment.find_outputs(keyword=args.keywords, type=['xy'])
-    
-    if not outputs:
-        print("No outputs found")
-        return
-    
-    outputs_with_tree = client.fetch_outputs_with_tree(experiment, [o.id for o in outputs])
-    data = client.fetch_data(experiment, outputs_with_tree)
-    clustering = Clustering(data, n_clusters=args.n_clusters, model=args.method)
-    clusters = clustering.get_clusters()
-    print(f"Clustering results:\n{clusters}")
-
-
 def main():
     parser = argparse.ArgumentParser(description="TMLL CLI - Trace-Server Machine Learning Library")
     parser.add_argument("--host", default="localhost", help="Trace server host")
@@ -287,56 +277,51 @@ def main():
 
     # anomaly command
     anomaly_parser = subparsers.add_parser("anomaly", help="Detect anomalies")
-    anomaly_parser.add_argument("experiment", help="Experiment UUID or name")
+    anomaly_parser.add_argument("experiment", help="Experiment UUID")
     anomaly_parser.add_argument("-k", "--keywords", nargs="+", default=["cpu usage"], help="Output keywords")
     anomaly_parser.add_argument("-m", "--method", default="iforest", help="Detection method")
     anomaly_parser.add_argument("-p", "--plot", action="store_true", help="Plot anomalies")
     anomaly_parser.set_defaults(func=detect_anomalies)
 
     # memory-leak command
     memleak_parser = subparsers.add_parser("memory-leak", help="Detect memory leaks")
-    memleak_parser.add_argument("experiment", help="Experiment UUID or name")
+    memleak_parser.add_argument("experiment", help="Experiment UUID")
     memleak_parser.add_argument("-k", "--keywords", nargs="+", default=["memory"], help="Output keywords")
     memleak_parser.set_defaults(func=detect_memory_leak)
 
     # changepoint command
     cp_parser = subparsers.add_parser("changepoint", help="Detect change points")
-    cp_parser.add_argument("experiment", help="Experiment UUID or name")
+    cp_parser.add_argument("experiment", help="Experiment UUID")
     cp_parser.add_argument("-k", "--keywords", nargs="+", default=["cpu usage"], help="Output keywords")
-    cp_parser.add_argument("-m", "--method", default="pelt", help="Detection method")
+    cp_parser.add_argument("-m", "--methods", nargs="+", default=["single", "zscore", "voting", "pca"],
+                           help="Analysis methods (single, zscore, voting, pca)")
     cp_parser.add_argument("-p", "--plot", action="store_true", help="Plot change points")
     cp_parser.set_defaults(func=detect_changepoints)
 
     # correlation command
     corr_parser = subparsers.add_parser("correlation", help="Analyze correlation")
-    corr_parser.add_argument("experiment", help="Experiment UUID or name")
+    corr_parser.add_argument("experiment", help="Experiment UUID")
     corr_parser.add_argument("-k", "--keywords", nargs="+", default=["cpu", "memory"], help="Output keywords")
     corr_parser.add_argument("-m", "--method", default="pearson", help="Correlation method")
     corr_parser.add_argument("-p", "--plot", action="store_true", help="Plot correlation")
     corr_parser.set_defaults(func=analyze_correlation)
 
     # idle-resources command
     idle_parser = subparsers.add_parser("idle-resources", help="Detect idle resources")
-    idle_parser.add_argument("experiment", help="Experiment UUID or name")
+    idle_parser.add_argument("experiment", help="Experiment UUID")
     idle_parser.add_argument("-k", "--keywords", nargs="+", default=["cpu usage"], help="Output keywords")
-    idle_parser.add_argument("-t", "--threshold", type=float, default=5.0, help="Idle threshold")
+    idle_parser.add_argument("--cpu-idle-threshold", type=float, default=5.0, help="CPU idle threshold percentage")
+    idle_parser.add_argument("--memory-idle-threshold", type=float, default=5.0, help="Memory idle threshold percentage")
+    idle_parser.add_argument("--disk-idle-threshold", type=float, default=5.0, help="Disk idle threshold percentage")
     idle_parser.set_defaults(func=detect_idle_resources)
 
     # capacity command
     capacity_parser = subparsers.add_parser("capacity", help="Perform capacity planning")
-    capacity_parser.add_argument("experiment", help="Experiment UUID or name")
+    capacity_parser.add_argument("experiment", help="Experiment UUID")
     capacity_parser.add_argument("-k", "--keywords", nargs="+", default=["cpu usage"], help="Output keywords")
-    capacity_parser.add_argument("-H", "--horizon", type=int, default=30, help="Planning horizon (days)")
+    capacity_parser.add_argument("-H", "--horizon", type=int, default=100, help="Forecast steps")
     capacity_parser.set_defaults(func=plan_capacity)
 
-    # cluster command
-    cluster_parser = subparsers.add_parser("cluster", help="Perform clustering analysis")
-    cluster_parser.add_argument("experiment", help="Experiment UUID or name")
-    cluster_parser.add_argument("-k", "--keywords", nargs="+", default=["cpu usage"], help="Output keywords")
-    cluster_parser.add_argument("-n", "--n-clusters", type=int, default=3, help="Number of clusters")
-    cluster_parser.add_argument("-m", "--method", default="kmeans", help="Clustering method")
-    cluster_parser.set_defaults(func=cluster_data)
-    
     args = parser.parse_args()
 
     if args.log_stderr:

mcp_server_cli.py tmll/mcp/server.pymcp_server_cli.py renamed to tmll/mcp/server.py

@@ -5,15 +5,16 @@
 import json
 import subprocess
 import sys
-from typing import Any
+from pathlib import Path
+from typing import Any, Optional
 
 from mcp.server import Server
 from mcp.server.stdio import stdio_server
 from mcp.types import Tool, TextContent
 
 server = Server("tmll-cli-mcp-server")
 
-CLI_PATH = sys.argv[1] if len(sys.argv) > 1 else "tmll_cli.py"
+CLI_PATH = sys.argv[1] if len(sys.argv) > 1 else str(Path(__file__).resolve().parent / "cli.py")
 
 
 def run_cli(*args: str) -> str:
@@ -127,13 +128,14 @@ async def list_tools() -> list[Tool]:
         ),
         Tool(
             name="detect_changepoints",
-            description="Detect change points in performance trends (pelt, binseg, window)",
+            description="Detect change points in performance trends (single, zscore, voting, pca)",
             inputSchema={
                 "type": "object",
                 "properties": {
                     "experiment_id": {"type": "string"},
                     "keywords": {"type": "array", "items": {"type": "string"}, "default": ["cpu usage"]},
-                    "method": {"type": "string", "default": "pelt", "enum": ["pelt", "binseg", "window"]},
+                    "methods": {"type": "array", "items": {"type": "string"}, "default": ["single", "zscore", "voting", "pca"],
+                               "description": "Analysis methods (single, zscore, voting, pca)"},
                 },
                 "required": ["experiment_id"],
             },
@@ -159,7 +161,9 @@ async def list_tools() -> list[Tool]:
                 "properties": {
                     "experiment_id": {"type": "string"},
                     "keywords": {"type": "array", "items": {"type": "string"}, "default": ["cpu usage"]},
-                    "threshold": {"type": "number", "default": 5.0, "description": "Idle threshold percentage"},
+                    "cpu_idle_threshold": {"type": "number", "default": 5.0, "description": "CPU idle threshold percentage"},
+                    "memory_idle_threshold": {"type": "number", "default": 5.0, "description": "Memory idle threshold percentage"},
+                    "disk_idle_threshold": {"type": "number", "default": 5.0, "description": "Disk idle threshold percentage"},
                 },
                 "required": ["experiment_id"],
             },
@@ -172,21 +176,7 @@ async def list_tools() -> list[Tool]:
                 "properties": {
                     "experiment_id": {"type": "string"},
                     "keywords": {"type": "array", "items": {"type": "string"}, "default": ["cpu usage"]},
-                    "horizon": {"type": "integer", "default": 30, "description": "Planning horizon in days"},
-                },
-                "required": ["experiment_id"],
-            },
-        ),
-        Tool(
-            name="cluster_data",
-            description="Perform clustering analysis on trace data (kmeans, dbscan, hierarchical)",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "experiment_id": {"type": "string"},
-                    "keywords": {"type": "array", "items": {"type": "string"}, "default": ["cpu usage"]},
-                    "n_clusters": {"type": "integer", "default": 3},
-                    "method": {"type": "string", "default": "kmeans", "enum": ["kmeans", "dbscan", "hierarchical"]},
+                    "horizon": {"type": "integer", "default": 100, "description": "Number of forecast steps"},
                 },
                 "required": ["experiment_id"],
             },
@@ -195,7 +185,8 @@ async def list_tools() -> list[Tool]:
 
 
 @server.call_tool()
-async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+async def call_tool(name: str, arguments: Optional[dict] = None) -> list[TextContent]:
+    arguments = arguments if isinstance(arguments, dict) else {}
     global_args = build_args(arguments, {"host": "--host", "port": "--port"})
 
     if name == "create_experiment":
@@ -224,25 +215,24 @@ async def call_tool(name: str, arguments: dict) -> list[TextContent]:
         out = run_cli(*global_args, "memory-leak", arguments["experiment_id"], *args)
 
     elif name == "detect_changepoints":
-        args = build_args(arguments, {"keywords": "-k", "method": "-m"})
+        args = build_args(arguments, {"keywords": "-k", "methods": "-m"})
         out = run_cli(*global_args, "changepoint", arguments["experiment_id"], *args)
 
     elif name == "analyze_correlation":
         args = build_args(arguments, {"keywords": "-k", "method": "-m"})
         out = run_cli(*global_args, "correlation", arguments["experiment_id"], *args)
 
     elif name == "detect_idle_resources":
-        args = build_args(arguments, {"keywords": "-k", "threshold": "-t"})
+        args = build_args(arguments, {"keywords": "-k",
+                                       "cpu_idle_threshold": "--cpu-idle-threshold",
+                                       "memory_idle_threshold": "--memory-idle-threshold",
+                                       "disk_idle_threshold": "--disk-idle-threshold"})
         out = run_cli(*global_args, "idle-resources", arguments["experiment_id"], *args)
 
     elif name == "plan_capacity":
         args = build_args(arguments, {"keywords": "-k", "horizon": "-H"})
         out = run_cli(*global_args, "capacity", arguments["experiment_id"], *args)
 
-    elif name == "cluster_data":
-        args = build_args(arguments, {"keywords": "-k", "n_clusters": "-n", "method": "-m"})
-        out = run_cli(*global_args, "cluster", arguments["experiment_id"], *args)
-
     else:
         raise ValueError(f"Unknown tool: {name}")