ml-approach-suggestion-agent 0.1.8__py3-none-any.whl

ml_approach_suggestion_agent/agent.py

@@ -0,0 +1,120 @@
+import json
+import logging
+from typing import Dict, Any, List, Optional, Tuple
+from datetime import datetime
+from sfn_blueprint import SFNAIHandler, self_correcting_sql, Context
+
+
+from .config import MethodologyConfig
+from .constants import format_approach_prompt
+from .models import MethodologyRecommendation
+
+
+class MLApproachDecisionAgent:
+    def __init__(self, config: Optional[MethodologyConfig] = None):
+        self.logger = logging.getLogger(__name__)
+        self.config = config or MethodologyConfig()
+        self.ai_handler = SFNAIHandler()
+
+    def suggest_approach(self, domain_name, domain_description, use_case, column_insights, max_try=1) -> Tuple[MethodologyRecommendation, Dict[str, Any]]:
+        """
+        Suggests a machine learning approach based on the provided domain, use case, and column descriptions.
+        Args:
+            domain_name (str): The name of the domain.
+            domain_description (str): The description of the domain.
+            use_case (str): problem need to solve.
+            column_descriptions (List[str]): A list of column descriptions.
+            column_insights (List[str]): A list of column insights.
+            max_try (int, optional): The maximum number of attempts to make the API call. Defaults to 3.
+
+        Returns:
+            MethodologyRecommendation: The suggested machine learning approach.
+        
+        TODO: 
+            - USER prompt should consider those approaches which will be supported.
+            
+            
+        """
+        system_prompt, user_prompt = format_approach_prompt(domain_name=domain_name, domain_description=domain_description, use_case=use_case, column_insights=column_insights)
+        for _ in range(max_try):
+            try:
+                response, cost_summary = self.ai_handler.route_to(
+                    llm_provider=self.config.methodology_ai_provider,
+                    configuration={
+                        "messages": [
+                            {"role": "system", "content": system_prompt},
+                            {"role": "user", "content": user_prompt}
+                        ],
+                        "max_tokens": self.config.methodology_max_tokens,
+                        # "temperature": self.config.methodology_temperature,
+                        "text_format":MethodologyRecommendation
+                    },
+                    model=self.config.methodology_ai_model
+
+                )
+
+
+                return response, cost_summary
+
+            except Exception as e:
+                self.logger.error(f"Error while executing API call to {self.config.methodology_ai_provider}: {e}")
+
+        return {}, {}
+    
+
+
+    def execute_task(self, task_data: Dict[str, Any]) -> Dict[str, Any]:
+        self.logger.info("Executing data quality assessment task.")
+        domain_name, domain_description, use_case, column_insights = (
+            task_data["domain_name"],
+            task_data["domain_description"],
+            task_data["use_case"],
+            task_data["column_insights"],
+        )
+
+        # Suggest an approach
+        result, cost_summary = self.suggest_approach(
+            domain_name=domain_name,
+            domain_description=domain_description,
+            use_case=use_case,
+            column_insights=column_insights,
+        )
+        if not result:
+            return {
+                "success": False,
+                "error": "Failed to suggest approach.",
+                "agent": self.__class__.__name__
+            }
+
+        try:
+            # Check if we have workflow storage information
+            if 'workflow_storage_path' in task_data or 'workflow_id' in task_data:
+                from sfn_blueprint import WorkflowStorageManager
+                
+                # Determine workflow storage path
+                workflow_storage_path = task_data.get('workflow_storage_path', 'outputs/workflows')
+                workflow_id = task_data.get('workflow_id', 'unknown')
+                
+                # Initialize storage manager
+                storage_manager = WorkflowStorageManager(workflow_storage_path, workflow_id)
+                storage_manager.save_agent_result(
+                    agent_name=self.__class__.__name__,
+                    step_name=" ",
+                    data={"quality_reports": result.model_dump(), "cost_summary": cost_summary},
+                    metadata={ "execution_time": datetime.now().isoformat()}
+                )
+                self.logger.info(" saved to workflow storage.")
+        except Exception as e:
+            self.logger.warning(f"Failed to save results to workflow storage: {e}")
+        
+        return {
+                "success": True,
+                "result": {
+                    "approach": result ,
+                    "cost_summary": cost_summary
+                },
+                "agent": self.__class__.__name__
+            }
+    
+    def __call__(self, task_data: Dict[str, Any]) -> Dict[str, Any]:
+        return self.execute_task(task_data)

ml_approach_suggestion_agent/config.py

@@ -0,0 +1,18 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class MethodologyConfig(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_file='.env',
+        env_file_encoding='utf-8',
+        case_sensitive=False,
+        extra='ignore'
+    )
+
+    methodology_ai_provider: str = Field(default="openai", description="AI provider to use")
+    methodology_ai_model: str = Field(default="gpt-5-mini", description="AI model to use")
+    methodology_temperature: float = Field(default=0.3, ge=0.0, le=0.5, description="AI model temperature")
+    methodology_max_tokens: int = Field(default=4000, ge=100, le=8000, description="Maximum tokens for AI response")
+
+

ml_approach_suggestion_agent/constants.py

@@ -0,0 +1,343 @@
+# METHODOLOGY_SELECTION_SYSTEM_PROMPT = """You are an expert ML methodology advisor. Your task is to analyze the problem carefully and select the single most appropriate methodology from: binary_classification, timeseries_binary_classification, or not_applicable.
+
+# **Methodology Definitions:**
+
+# 1. **Binary Classification**
+#    - Predicts one of TWO possible outcomes (Yes/No, True/False, 1/0, Pass/Fail)
+#    - Uses historical data with labels to learn patterns
+#    - Predictions are categorical, not numerical values
+#    - Time is NOT a critical feature for prediction
+   
+#    **Examples:**
+#    - "Is this transaction fraudulent?" → Fraud/Not Fraud
+#    - "Will the machine fail?" → Fail/Not Fail
+#    - "Is this email spam?" → Spam/Not Spam
+
+# 2. **Timeseries Binary Classification**
+#    - Predicts one of TWO categories for sequential/temporal data
+#    - ORDER and TEMPORAL PATTERNS in the data are CRITICAL for making predictions
+#    - The sequence itself contains information (trends, seasonality, patterns over time)
+#    - Uses time-ordered observations where the temporal relationship matters
+   
+#    **Examples:**
+#    - "Classify equipment state as 'normal' or 'anomalous' based on sensor readings over time"
+#    - "Predict if a patient will be readmitted within 30 days based on their medical history sequence"
+#    - "Classify stock price movement as 'upward' or 'downward' based on historical patterns"
+#    - "Detect if a time series pattern indicates an upcoming failure event"
+
+# 3. **Not Applicable**
+#    - No machine learning prediction is needed
+#    - Pure data analysis, reporting, dashboards, or descriptive statistics
+#    - Insufficient information to determine methodology
+#    - Problem requires regression, multi-class classification, or other ML approaches not listed
+
+# **Critical Decision Framework:**
+
+# Ask yourself these questions in order:
+
+# 1. **Is a prediction needed?**
+#    - No → `not_applicable`
+#    - Yes → Continue
+
+# 2. **What is being predicted?**
+#    - A binary outcome (2 categories) → Continue to question 3
+#    - A numerical value → `not_applicable` (this is regression)
+#    - Multiple categories (3+) → `not_applicable` (this is multi-class)
+#    - Nothing specific → `not_applicable`
+
+# 3. **Are temporal patterns ESSENTIAL for making the prediction?**
+#    - Yes, the sequence/order of observations contains critical information → `timeseries_binary_classification`
+#    - No, individual data points or snapshots are sufficient → `binary_classification`
+
+# **Common Pitfalls to Avoid:**
+
+#  **Don't assume time series just because:**
+# - The data has timestamps (most datasets do)
+# - Events happened over time
+# - There's a date column
+
+# **Choose timeseries binary classification ONLY when:**
+# - The temporal sequence itself reveals patterns needed for classification
+# - Order matters: shuffling observations would lose critical information
+# - Trends, seasonality, or temporal dependencies are key features
+
+
+#  **Don't confuse classification with forecasting:**
+# - Timeseries Binary Classification → Predict a category based on temporal patterns
+# - Time Series Forecasting → Predict future numerical values (NOT an option here)
+
+# **Output Requirements:**
+
+# You must provide:
+
+# 1. **selected_methodology**: Exactly one of: `binary_classification`, `timeseries_binary_classification`, or `not_applicable`
+
+# 2. **justification**: A clear, structured explanation that includes:
+#    - **Business Goal**: What problem is being solved?
+#    - **Prediction Type**: What specific outcome needs to be predicted?
+#    - **Temporal Dependency**: Are time-based patterns essential for this prediction?
+#    - **Methodology Fit**: Why is the selected methodology the best match?
+#    - **Key Reasoning**: The critical factors that led to this decision
+
+# Be decisive, analytical, and precise in your selection.
+# """
+
+METHODOLOGY_SELECTION_SYSTEM_PROMPT = """You are an expert ML methodology advisor. Your task is to analyze the problem carefully and select the single most appropriate methodology from:
+
+binary_classification,
+multiclass_classification,
+regression,
+timeseries_regression,
+timeseries_binary_classification,
+recommendation_engine,
+timeseries_recommendation_engine,
+clustering,
+anomaly_detection,
+timeseries_anomaly_detection,
+or not_applicable.
+
+---
+
+## Methodology Definitions
+
+### 1. Binary Classification
+- Predicts one of TWO discrete outcomes (Yes/No, 1/0, Pass/Fail)
+- Uses labeled historical data
+- Output is categorical (2 classes)
+- Time is NOT essential
+
+**Examples:**
+- "Will a customer churn?" → Yes / No
+- "Is this transaction fraudulent?" → Fraud / Not Fraud
+
+---
+
+### 2. Multiclass Classification
+- Predicts one of THREE OR MORE discrete classes
+- Uses labeled historical data
+- Output is categorical (3+ classes)
+- Time is NOT essential
+
+**Examples:**
+- "Classify customer into Bronze / Silver / Gold"
+- "Predict Heart Disease Level Low / Medium / High"
+
+---
+
+### 3. Regression
+- Predicts a continuous numerical value
+- Uses labeled historical data
+- Time may exist but is NOT the main signal
+
+**Examples:**
+- "Predict loan amount"
+- "Estimate house price"
+- "Predict expected revenue"
+
+---
+
+### 4. Time Series Regression
+- Predicts future numerical values
+- Temporal order and patterns are ESSENTIAL
+- Forecasting based on trends, seasonality, lag effects
+
+**Examples:**
+- "Predict energy consumption over time"
+- "Estimate future demand"
+
+---
+
+### 5. Time Series Binary Classification
+- Predicts one of TWO classes
+- Temporal sequence is ESSENTIAL
+- Order, trends, and patterns matter
+
+**Examples:**
+- "Predict machine failure in next 24 hours using sensor history"
+- "Classify stock movement as Up / Down using price history"
+
+---
+
+### 6. Recommendation Engine
+- Produces ranked lists or personalized suggestions
+- Output is NOT a single class or number
+- Time is NOT essential
+
+**Examples:**
+- "Recommend products to users"
+- "Suggest movies based on viewing history"
+
+---
+
+### 7. Time Series Recommendation Engine
+- Recommendations depend on sequence or recency
+- Session-based or time-aware recommendations
+
+**Examples:**
+- "Recommend next product based on recent actions"
+- "Suggest content based on session behavior"
+
+---
+
+### 8. Clustering
+- No labeled target variable
+- Groups similar entities together
+- Discovers structure in data
+
+**Examples:**
+- "Customer segmentation"
+- "Group users by behavior"
+
+---
+
+### 9. Anomaly Detection
+- Detects rare, unusual, or abnormal observations
+- Snapshot-based (time not essential)
+
+**Examples:**
+- "Detect fraudulent transactions"
+- "Identify outlier sensor readings"
+
+---
+
+### 10. Not Applicable
+- No ML prediction required
+- Pure reporting, dashboards, or descriptive analysis
+- Problem requires an unsupported methodology
+- Insufficient information
+
+---
+
+## Critical Decision Framework
+
+Ask these questions in order:
+
+### 1. Is a prediction, recommendation, grouping, or anomaly detection needed?
+- No → not_applicable
+- Yes → Continue
+
+---
+
+### 2. What is the nature of the output?
+- Ranked list or suggestions → Recommendation Engine
+- Continuous numeric value → Regression
+- Two classes → Binary Classification
+- Three or more classes → Multiclass Classification
+- No labels, discover groups → Clustering
+- Detect rare/abnormal behavior → Anomaly Detection
+
+---
+
+### 3. Are temporal patterns ESSENTIAL?
+If YES:
+- Regression → timeseries_regression
+- Binary classification → timeseries_binary_classification
+- Recommendation → timeseries_recommendation_engine
+
+If NO:
+- Use the non-time-series variant
+
+---
+
+## Common Pitfalls to Avoid
+
+**Don't confuse classification with regression:**
+- "Will customer default?" → Binary Classification
+- "How much will customer default?" → Regression
+
+# **Don't assume time series just because:**
+# - The data has timestamps
+# - Events happened over time
+# - There's a date column
+
+**Don't confuse regression with forecasting:**
+- Regression predicts numeric value using features
+- Forecasting predicts future numeric values using time
+- Forecasting = Time Series Regression
+
+**Don't confuse recommendation with prediction:**
+- "Will user buy product X?" → Binary Classification
+- "Which products should we show?" → Recommendation Engine
+
+---
+
+## Output Requirements
+
+You MUST return:
+
+1. selected_methodology: Exactly ONE of:
+- binary_classification
+- multiclass_classification
+- regression
+- timeseries_regression
+- timeseries_binary_classification
+- recommendation_engine
+- timeseries_recommendation_engine
+- clustering
+- anomaly_detection
+- not_applicable
+
+2. justification:
+A clear, structured explanation including:
+- Business Goal
+- Output Type
+- Target Variable / Output
+- Temporal Dependency
+- Methodology Fit
+- Key Reasoning
+
+Be decisive, analytical, and precise.
+Do NOT choose not_applicable if any methodology clearly fits.
+"""
+
+METHODOLOGY_SELECTION_USER_PROMPT = """**Business Context:**
+Domain: {domain_name}
+{domain_description}
+
+**Use Case:**
+{use_case_description}
+
+**Dataset Characteristics:**
+{column_insights}
+
+Analyze the above information and determine the most appropriate ML methodology."""
+
+
+
+def format_approach_prompt(
+    domain_name: str,
+    domain_description: str,
+    use_case: str,
+    column_insights: str
+) -> tuple[str, str]:
+    """
+    Format the methodology selection prompts for the LLM.
+    
+    Args:
+        domain_name: The domain of the data (e.g., "Healthcare", "Finance")
+        domain_description: Detailed description of the domain context
+        use_case: Description of what the user wants to achieve
+        column_descriptions: Description of the columns in the dataset
+        column_insights: Statistical insights about the columns (data types, 
+                        unique counts, distributions, etc.)
+    
+    Returns:
+        tuple[str, str]: The formatted system prompt and user prompt
+    
+    Example:
+        system_prompt, user_prompt = format_approach_prompt(
+            domain_name="E-commerce",
+            domain_description="Online retail platform with customer transactions",
+            use_case="Predict if a customer will make a purchase",
+            column_descriptions="user_id, page_views, cart_additions, timestamp",
+            column_insights="4 columns, 10000 rows, mixed types"
+        )
+    """
+    user_prompt = METHODOLOGY_SELECTION_USER_PROMPT.format(
+        domain_name=domain_name,
+        domain_description=domain_description,
+        use_case_description=use_case,
+        column_insights=column_insights
+    )
+    
+    return METHODOLOGY_SELECTION_SYSTEM_PROMPT, user_prompt

ml_approach_suggestion_agent/models.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, Field
+from typing import Literal
+
+class MethodologyRecommendation(BaseModel):
+    selected_methodology: Literal[  "binary_classification",
+                                    "multiclass_classification",
+                                    "regression",
+                                    "timeseries_regression",
+                                    "timeseries_binary_classification",
+                                    "recommendation_engine",
+                                    "timeseries_recommendation_engine",
+                                    "clustering",
+                                    "anomaly_detection",
+                                    "not_applicable"] = Field(..., description="The most appropriate ML approach for this problem")
+    
+    justification: str = Field( ..., description="Structured explanation with: business goal, prediction type, temporal dependency analysis, and methodology fit")
+
+

ml_approach_suggestion_agent-0.1.8.dist-info/METADATA

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: ml_approach_suggestion_agent
+Version: 0.1.8
+Summary: Add your description here
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic-settings
+Requires-Dist: sfn-blueprint>=0.6.16
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+
+# ml_approach_suggestion_agent
+
+An AI-powered agent that analyzes a dataset and use case to recommend the most appropriate machine learning methodology.
+
+## Description
+
+This agent takes a detailed description of a business domain, a specific use case, and information about the dataset—including column descriptions, insights, and target variable details—to suggest the best ML approach. It uses a large language model to:
+
+1.  **Analyze** the relationship between the use case and the target variable.
+2.  **Evaluate** the characteristics of the data (especially the target column).
+3.  **Recommend** the most suitable methodology from a predefined list: `Binary Classification`, `Multiclass Classification`, `Regression`, `Forecasting`, `Clustering`, `Recommendation Engine`, `Timeseries Classification`, `Timeseries Recommendation Engine`, `Anomaly Detection`, or `No-ML`.
+4.  **Provide** a clear justification for its recommendation.
+
+This helps data scientists and analysts quickly and confidently choose the right path for their modeling efforts, saving time and reducing the risk of starting with an incorrect approach.
+
+## Key Features
+
+-   **Intelligent Use Case Analysis**: Leverages an LLM to understand the core objective of the business problem.
+-   **Target-Aware Recommendation**: Places special emphasis on the nature of the target variable to guide its decision.
+-   **Context-Driven Suggestions**: Considers the entire data context, including domain and column descriptions, to make an informed choice.
+-   **Accelerates Model Planning**: Provides a validated starting point for ML projects, ensuring alignment between the problem and the proposed solution.
+
+## Installation
+
+### Prerequisites
+
+-   [**uv**](https://docs.astral.sh/uv/getting-started/installation/) – A fast Python package and environment manager.
+    -   For a quick setup on macOS/Linux, you can use:
+        ```bash
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+        ```
+-   [**Git**](https://git-scm.com/)
+
+### Steps
+
+1.  **Clone the `methodology_selection_agent` repository:**
+    ```bash
+    git clone https://github.com/stepfnAI/ml_approach_suggestion_agent.git
+    cd ml_approach_suggestion_agent
+    git switch main
+    ```
+
+2.  **Create a virtual environment and install dependencies:**
+    This command creates a `.venv` folder in the current directory and installs all required packages.
+    ```bash
+    uv sync --extra dev
+    source .venv/bin/activate
+    ```
+
+## Configuration
+
+You can configure the agent by creating a `.env` file in the project root or by exporting environment variables in your shell. Settings loaded via `export` will override those in a `.env` file.
+
+### Available Settings
+
+| Environment Variable            | Description                                  | Default  |
+| ------------------------------- | -------------------------------------------- | -------- |
+| `OPENAI_API_KEY`                | **(Required)** Your OpenAI API key.          | *None*   |
+| `METHODOLOGY_AI_PROVIDER`       | AI provider for methodology suggestions.     | `openai` |
+| `METHODOLOGY_AI_MODEL`          | AI model for methodology suggestions.        | `gpt-4o` |
+| `METHODOLOGY_TEMPERATURE`       | AI model temperature (e.g., `0.0` to `0.5`). | `0.3`    |
+| `METHODOLOGY_MAX_TOKENS`        | Maximum tokens for the AI response.          | `4000`   |
+
+---
+
+### Method 1: Using a `.env` File (Recommended)
+
+Create a `.env` file in the root directory to store API keys and project-wide defaults.
+
+#### Example `.env` file:
+
+```dotenv
+# .env
+
+# --- Required Settings ---
+OPENAI_API_KEY="sk-your-api-key-here"
+
+# --- Optional Overrides ---
+# Use a different model
+METHODOLOGY_AI_MODEL="gpt-4o-mini"
+
+# Use a lower temperature for more deterministic responses
+METHODOLOGY_TEMPERATURE=0.1
+```
+
+---
+
+### Method 2: Using `export` Commands
+
+Use `export` in your terminal for temporary settings or in CI/CD environments.
+
+#### Example `export` commands:
+
+```bash
+# Set the environment variables for the current terminal session
+export OPENAI_API_KEY="sk-your-api-key-here"
+export METHODOLOGY_AI_MODEL="gpt-4o-mini"
+```
+
+## Testing
+
+To run the test suite, use the following command from the root of the project directory:
+
+```bash
+pytest -s
+```
+
+## Usage
+
+### Running the Example Script
+
+To see a quick demonstration, run the provided example script. This will execute the agent with pre-defined data and print the recommended methodology.
+
+```bash
+python examples/basic_usage.py
+```
+
+### Using as a Library
+
+Integrate the `MLApproachDecisionAgent` directly into your Python applications to get methodology recommendations programmatically.
+
+```python
+import logging
+from ml_approach_suggestion_agent.agent import MLApproachDecisionAgent
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+
+# 1. Define the domain, use case, and data context
+domain_name = "Mortgage Loan Servicing"
+domain_description = "Managing mortgage loans from post-origination to payoff, including payment collection, escrow management, and compliance for domestic and international loans."
+use_case = "To predict the likelihood of a borrower becoming delinquent on their mortgage payment within the next 60 days using their demographic and financial data to enable proactive intervention."
+
+column_descriptions = {
+    "CreditScore": "Borrower's credit score from credit bureau sources",
+    "EmploymentStatus": "Current employment status (e.g., employed, self-employed, unemployed)",
+    # ... other column descriptions
+}
+
+column_insights = {
+  "table_info": { "row_count": 50000 },
+  "table_columns_info": {
+    "CreditScore": { "data_type": "Int64", "min_max_value": [350, 850] },
+    "EmploymentStatus": { "data_type": "string", "distinct_count": 5 },
+    # ... other column insights
+  }
+}
+
+target_column_name = "IsDelinquent"
+target_column_insights = {
+    "Target Column Description": "A binary categorical flag indicating if the borrower has missed one or more mortgage payments in the last 60 days.",
+    "Data Type": "Integer (or Boolean)",
+    "Value Distribution": {
+      "0 (Not Delinquent)": "92%",
+      "1 (Delinquent)": "8%"
+    }
+}
+
+# 2. Prepare the task data payload
+task_data = {
+    "domain_name": domain_name,
+    "domain_description": domain_description,
+    "use_case": use_case,
+    "column_descriptions": column_descriptions,
+    "column_insights": column_insights,
+    "target_column_name": target_column_name,
+    "target_column_insights": target_column_insights
+}
+
+# 3. Initialize and execute the agent
+agent = MLApproachDecisionAgent()
+result = agent(task_data)
+
+# 4. Print the suggested methodology
+if result["success"]:
+    print("Successfully suggested an approach:")
+    print(result["result"]["approach"].model_dump_json(indent=4))
+    print(f"Cost summary: {result['result']['cost_summary']}")
+else:
+    print("Failed to suggest an approach.")
+
+```
+
+### Example Output
+
+The agent returns a JSON object containing the recommended methodology and a detailed explanation for the choice.
+
+*(Note: The actual output may vary slightly based on the LLM's response.)*
+
+```json
+{
+    "recommended": "Classification",
+    "description": "The goal is to predict the likelihood of a borrower becoming delinquent on their mortgage payment within the next 60 days. This is a binary outcome (delinquent or not delinquent), making classification the appropriate methodology. The target variable is categorical, and the available demographic and financial data can be used as features to train a classification model."
+}
+```

ml_approach_suggestion_agent-0.1.8.dist-info/RECORD

@@ -0,0 +1,9 @@
+ml_approach_suggestion_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ml_approach_suggestion_agent/agent.py,sha256=ea46aRQVp2uFKj4DslF3rCTX4vMYv0sms9TE-SP-XuE,5009
+ml_approach_suggestion_agent/config.py,sha256=kNZDiHYOB-A90Su-4iFcDik_I60w_cVGvtpASJKn638,701
+ml_approach_suggestion_agent/constants.py,sha256=KLjZXxPhWHhoSgBNXeOwElpYzB4gr1jmjG-prdn9lPc,10628
+ml_approach_suggestion_agent/models.py,sha256=g-rhJZjFpl8Wyu14Gq83NIw1XjP4cAy33XLGL7vE_OM,961
+ml_approach_suggestion_agent-0.1.8.dist-info/METADATA,sha256=rzcEpMZUFNNZbCAfgPITx3dscJtJDWApXQM3EJyTfD8,8205
+ml_approach_suggestion_agent-0.1.8.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+ml_approach_suggestion_agent-0.1.8.dist-info/top_level.txt,sha256=3-KHls6umFXtNFJoP7OFCLvb4zd12AWH71PVKNd5Aok,29
+ml_approach_suggestion_agent-0.1.8.dist-info/RECORD,,

ml_approach_suggestion_agent-0.1.8.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ml_approach_suggestion_agent-0.1.8.dist-info/top_level.txt

@@ -0,0 +1 @@
+ml_approach_suggestion_agent