feat: Add data analysis tool, implement task-specific model training with enhanced metrics and deployment examples, and refactor UI for manual testing.

.gitignore

@@ -3,3 +3,4 @@ __pycache__/
 *.pyc
 .ipynb_checkpoints/
 local/models/
+.venv

app.py

@@ -3,36 +3,58 @@ import modal
 import json
 
 # Initialize Modal function references
-f_analyze = modal.Function.lookup("mlops-backend", "analyze_data")
-f_train = modal.Function.lookup("mlops-backend", "train_model")
-f_check = modal.Function.lookup("mlops-backend", "check_model")
+f_analyze = modal.Function.from_name("mlops-backend", "analyze_data")
+f_train = modal.Function.from_name("mlops-backend", "train_model")
+f_check = modal.Function.from_name("mlops-backend", "check_model")
 
-def train_model_tool(file_path: str, target_column: str):
+def analyze_data_tool(file_path: str) -> str:
+    """
+    Analyzes the uploaded CSV file and returns statistical metadata.
+    
+    Args:
+        file_path: The path to the uploaded CSV file.
+    Returns:
+        str: JSON string with analysis results.
+    """
+    with open(file_path, "r") as f:
+        content = f.read()
+        
+    # Call Modal backend
+    result = f_analyze.remote(content)
+    
+    return json.dumps(result, indent=2)
+
+def train_model_tool(file_path: str, target_column: str, task_type: str = "classification") -> str:
     """
     Trains a model on the uploaded CSV file.
     
     Args:
         file_path: The path to the uploaded CSV file.
         target_column: The name of the column to predict.
+        task_type: The type of task: "classification", "regression", or "time_series".
+    Returns:
+        str: JSON string with training results.
     """
     with open(file_path, "r") as f:
         content = f.read()
         
     # Call Modal backend
-    result = f_train.remote(content, target_column)
+    result = f_train.remote(content, target_column, task_type)
     
     return json.dumps({
-        "message": "Training complete.",
+        "message": result['message'],
         "model_id": result['model_id'],
-        "accuracy": result['accuracy']
+        "metric": f"{result['metric_name']}: {result['metric_value']:.4f}"
     }, indent=2)
 
-def deploy_model_tool(model_id: str):
+def deploy_model_tool(model_id: str) -> str:
     """
     Deploys a trained model and returns the API usage code.
     
     Args:
         model_id: The ID of the model to deploy.
+    Returns:
+        str: Deployment status and usage code.
     """
     # Verify model exists
     check = f_check.remote(model_id)
@@ -40,7 +62,7 @@ def deploy_model_tool(model_id: str):
         return f"Error: Model {model_id} not found."
 
     # Construct the API usage example
-    api_url = "https://[YOUR_MODAL_USERNAME]--mlops-backend-predict-api.modal.run" 
+    api_url = "https://abidali899--mlops-backend-predict-api.modal.run" 
     
     usage_code = f"""
 import requests
@@ -48,21 +70,33 @@ import requests
 url = "{api_url}"
 payload = {{
     "model_id": "{model_id}",
-    "data": {{ ... your input data ... }}
+    "data": {{ "col1": "val1", "col2": "val2" }}
 }}
 response = requests.post(url, json=payload)
 print(response.json())
     """
     
-    return f"Model {model_id} is live!\n\nEndpoint: {api_url}\n\nUsage:\n```python\n{usage_code}\n```"
+    curl_code = f"""
+curl -X POST {api_url} \\
+-H "Content-Type: application/json" \\
+-d '{{
+    "model_id": "{model_id}",
+    "data": {{ "col1": "val1", "col2": "val2" }}
+}}'
+    """
+    
+    return f"Model {model_id} is live!\n\nEndpoint: {api_url}\n\n### Usage (Python):\n```python\n{usage_code}\n```\n\n### Usage (cURL):\n```bash\n{curl_code}\n```"
 
-def auto_deploy_tool(file_path: str, target_column: str):
+def auto_deploy_tool(file_path: str, target_column: str, task_type: str = "classification") -> str:
     """
     Full Pipeline: Analyzes data, trains model, evaluates, and deploys it in one go.
     
     Args:
         file_path: The path to the uploaded CSV file.
         target_column: The name of the column to predict.
+        task_type: The type of task: "classification", "regression", or "time_series".
+    Returns:
+        str: A detailed report of the pipeline execution.
     """
     with open(file_path, "r") as f:
         content = f.read()
@@ -71,12 +105,13 @@ def auto_deploy_tool(file_path: str, target_column: str):
     analysis = f_analyze.remote(content)
     
     # 2. Train & Evaluate
-    train_result = f_train.remote(content, target_column)
+    train_result = f_train.remote(content, target_column, task_type)
     model_id = train_result['model_id']
-    accuracy = train_result['accuracy']
+    metric_val = train_result['metric_value']
+    metric_name = train_result['metric_name']
     
     # 3. Deploy (Construct Info)
-    api_url = "https://[YOUR_MODAL_USERNAME]--mlops-backend-predict-api.modal.run"
+    api_url = "https://abidali899--mlops-backend-predict-api.modal.run"
     
     usage_code = f"""
 import requests
@@ -89,6 +124,15 @@ payload = {{
 response = requests.post(url, json=payload)
 print(response.json())
     """
+
+    curl_code = f"""
+curl -X POST {api_url} \\
+-H "Content-Type: application/json" \\
+-d '{{
+    "model_id": "{model_id}",
+    "data": {{ "col1": "val1", "col2": "val2" }}
+}}'
+    """
     
     report = f"""# Auto-Deployment Report
 
@@ -97,31 +141,70 @@ print(response.json())
 - **Columns**: {', '.join(analysis['columns'])}
 
 ## 2. Model Training
-- **Status**: Success
+- **Task**: {task_type}
 - **Model ID**: `{model_id}`
-- **Accuracy**: {accuracy:.2%}
+- **{metric_name.capitalize()}**: {metric_val:.4f}
 
 ## 3. Deployment
 The model is live at: `{api_url}`
 
-### Usage Code
+### Usage Code (Python)
 ```python
 {usage_code}
 ```
+
+### Usage Code (cURL)
+```bash
+{curl_code}
+```
 """
     return report
 
-def dummy_chat(message, history):
-    return "I am an MCP Server. Please connect to me via an MCP client to use my tools."
+with gr.Blocks() as demo:
+    gr.Markdown("# Auto-Deployer MCP Server")
+    gr.Markdown("This server exposes the following tools to MCP clients:")
+    gr.Markdown("- `analyze_data_tool`")
+    gr.Markdown("- `train_model_tool`")
+    gr.Markdown("- `deploy_model_tool`")
+    gr.Markdown("- `auto_deploy_tool`")
+    
+    # Register tools using gr.api
+    gr.api(analyze_data_tool)
+    gr.api(train_model_tool)
+    gr.api(deploy_model_tool)
+    gr.api(auto_deploy_tool)
 
-# Expose tools via ChatInterface
-# When mcp_server=True, the tools listed here are exposed to the client
-demo = gr.ChatInterface(
-    fn=dummy_chat,
-    tools=[train_model_tool, deploy_model_tool, auto_deploy_tool],
-    title="Auto-Deployer MCP Server",
-    description="MCP Server with Training, Deployment, and Auto-Deploy tools."
-)
+    gr.Markdown("## Manual Testing Interface")
+    
+    with gr.Tab("Analyze"):
+        an_file = gr.File(label="CSV File")
+        an_btn = gr.Button("Analyze Data")
+        an_out = gr.JSON(label="Output")
+        an_btn.click(analyze_data_tool, [an_file], an_out)
+
+    with gr.Tab("Train"):
+        t_file = gr.File(label="CSV File")
+        t_col = gr.Textbox(label="Target Column")
+        t_type = gr.Dropdown(["classification", "regression", "time_series"], label="Task Type", value="classification")
+        t_btn = gr.Button("Train")
+        t_out = gr.JSON(label="Output")
+        t_btn.click(train_model_tool, [t_file, t_col, t_type], t_out)
+
+    with gr.Tab("Deploy"):
+        d_id = gr.Textbox(label="Model ID")
+        d_btn = gr.Button("Deploy")
+        d_out = gr.Markdown(label="Output")
+        d_btn.click(deploy_model_tool, [d_id], d_out)
+
+    with gr.Tab("Auto Deploy"):
+        a_file = gr.File(label="CSV File")
+        a_col = gr.Textbox(label="Target Column")
+        a_type = gr.Dropdown(["classification", "regression", "time_series"], label="Task Type", value="classification")
+        a_btn = gr.Button("Auto Deploy")
+        a_out = gr.Markdown(label="Output")
+        a_btn.click(auto_deploy_tool, [a_file, a_col, a_type], a_out)
 
 if __name__ == "__main__":
     demo.launch(mcp_server=True)
+
+

modal_backend.py

@@ -1,7 +1,7 @@
 import modal
 import pandas as pd
 import io
-from sklearn.ensemble import RandomForestClassifier
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
 from sklearn.model_selection import train_test_split
 from sklearn.metrics import accuracy_score
 import joblib
@@ -10,7 +10,7 @@ import json
 app = modal.App("mlops-backend")
 volume = modal.Volume.from_name("model-registry", create_if_missing=True)
 
-image = modal.Image.debian_slim().pip_install("pandas", "scikit-learn", "joblib")
+image = modal.Image.debian_slim().pip_install("pandas", "scikit-learn", "joblib", "fastapi[standard]")
 
 @app.function(image=image)
 def analyze_data(csv_content: str):
@@ -27,9 +27,10 @@ def analyze_data(csv_content: str):
     }
 
 @app.function(image=image, volumes={"/models": volume})
-def train_model(csv_content: str, target_col: str):
+def train_model(csv_content: str, target_col: str, task_type: str = "classification"):
     """
-    Trains a Random Forest model on the CSV content.
+    Trains a model based on the task type.
+    task_type: "classification", "regression", or "time_series"
     """
     df = pd.read_csv(io.StringIO(csv_content))
     
@@ -39,35 +40,58 @@ def train_model(csv_content: str, target_col: str):
     X = df.drop(columns=[target_col])
     y = df[target_col]
     
-    # Simple handling for non-numeric data for demo purposes
+    # Simple handling for non-numeric data
     X = pd.get_dummies(X)
     
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+    # Configure split and model based on task
+    if task_type == "time_series":
+        # Time series requires non-shuffled split
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)
+        model = RandomForestRegressor()
+    elif task_type == "regression":
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+        model = RandomForestRegressor()
+    else: # classification
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+        model = RandomForestClassifier()
     
-    model = RandomForestClassifier()
     model.fit(X_train, y_train)
     
     y_pred = model.predict(X_test)
-    accuracy = accuracy_score(y_test, y_pred)
+    
+    # Calculate metrics
+    if task_type == "classification":
+        from sklearn.metrics import accuracy_score
+        metric_name = "accuracy"
+        metric_val = accuracy_score(y_test, y_pred)
+    else:
+        from sklearn.metrics import mean_squared_error
+        metric_name = "mse"
+        metric_val = mean_squared_error(y_test, y_pred)
     
     model_id = f"model_{int(pd.Timestamp.now().timestamp())}"
     model_path = f"/models/{model_id}.joblib"
     joblib.dump(model, model_path)
-    volume.commit() # Ensure data is persisted
+    volume.commit()
     
-    # Save metadata for the API to know expected columns
+    # Save metadata
     meta_path = f"/models/{model_id}_meta.json"
     with open(meta_path, "w") as f:
-        json.dump({"columns": list(X.columns)}, f)
+        json.dump({
+            "columns": list(X.columns),
+            "task_type": task_type
+        }, f)
     volume.commit()
 
     return {
         "model_id": model_id,
-        "accuracy": accuracy,
-        "message": "Model trained successfully."
+        "metric_name": metric_name,
+        "metric_value": metric_val,
+        "message": f"{task_type.capitalize()} model trained successfully."
     }
 
-@app.web_endpoint(method="POST")
+@app.function(image=image, volumes={"/models": volume})
+@modal.fastapi_endpoint(method="POST")
 def predict_api(item: dict):
     """
     Prediction API endpoint.

requirements.txt

@@ -1,5 +1,6 @@
 modal==1.2.2
-gradio==5.49.1
+gradio[mcp]==5.49.1
 pandas==2.3.3
 scikit-learn==1.7.2
 joblib==1.5.2
+requests==2.32.5