ai-data-science-team 0.0.0.9010__py3-none-any.whl → 0.0.0.9012__py3-none-any.whl

ai_data_science_team/tools/data_loader.py

@@ -1,41 +1,77 @@
 
 from langchain.tools import tool
+from langgraph.prebuilt import InjectedState
 
 import pandas as pd
+import os
 
-from typing import Tuple, List, Dict
+from typing import Tuple, List, Dict, Optional, Annotated
 
 
 @tool(response_format='content_and_artifact')
-def load_directory(dir_path: str) -> Tuple[str, Dict]:
+def load_directory(
+    directory_path: str = os.getcwd(),  
+    file_type: Optional[str] = None
+) -> Tuple[str, Dict]:
     """
     Tool: load_directory
-    Description: Loads all recognized tabular files in a directory.
+    Description: Loads all recognized tabular files in a directory. 
+                 If file_type is specified (e.g., 'csv'), only files 
+                 with that extension are loaded.
     
     Parameters:
     ----------
-    dir_path : str
-        The path to the directory to load.
+    directory_path : str
+        The path to the directory to load. Defaults to the current working directory.
+
+    file_type : str, optional
+        The extension of the file type you want to load exclusively 
+        (e.g., 'csv', 'xlsx', 'parquet'). If None or not provided, 
+        attempts to load all recognized tabular files.
     
     Returns:
     -------
     Tuple[str, Dict]
         A tuple containing a message and a dictionary of data frames.
     """
-    print("    * Tool: load_directory")
+    print(f"    * Tool: load_directory | {directory_path}")
+    
     import os
     import pandas as pd
+    
+    if directory_path is None:
+        return "No directory path provided.", {}
+    
+    if not os.path.isdir(directory_path):
+        return f"Directory not found: {directory_path}", {}
+
     data_frames = {}
-    for filename in os.listdir(dir_path):
-        file_path = os.path.join(dir_path, filename)
+
+    for filename in os.listdir(directory_path):
+        file_path = os.path.join(directory_path, filename)
+        
         # Skip directories
         if os.path.isdir(file_path):
             continue
+
+        # If file_type is specified, only process files that match.
+        if file_type:
+            # Make sure extension check is case-insensitive
+            if not filename.lower().endswith(f".{file_type.lower()}"):
+                continue
+        
         try:
+            # Attempt to auto-detect and load the file
             data_frames[filename] = auto_load_file(file_path).to_dict()
         except Exception as e:
+            # If loading fails, record the error message
             data_frames[filename] = f"Error loading file: {e}"
-    return f"Returned the following data frames: {list(data_frames.keys())}", data_frames
+
+    return (
+        f"Returned the following data frames: {list(data_frames.keys())}",
+        data_frames
+    )
+
 
 @tool(response_format='content_and_artifact')
 def load_file(file_path: str) -> Tuple[str, Dict]:
@@ -52,12 +88,15 @@ def load_file(file_path: str) -> Tuple[str, Dict]:
     Tuple[str, Dict]
         A tuple containing a message and a dictionary of the data frame.
     """
-    print("    * Tool: load_file")
+    print(f"    * Tool: load_file | {file_path}")
     return f"Returned the following data frame from this file: {file_path}", auto_load_file(file_path).to_dict()
 
 
 @tool(response_format='content_and_artifact')
-def list_directory_contents(directory_path: str, show_hidden: bool = False) -> Tuple[List[str], List[Dict]]:
+def list_directory_contents(
+    directory_path: str = os.getcwd(),  
+    show_hidden: bool = False
+) -> Tuple[List[str], List[Dict]]:
     """
     Tool: list_directory_contents
     Description: Lists all files and folders in the specified directory.
@@ -67,30 +106,51 @@ def list_directory_contents(directory_path: str, show_hidden: bool = False) -> T
     Returns:
         tuple:
             - content (list[str]): A list of filenames/folders (suitable for display)
-            - artifact (list[dict]): A list of dictionaries where each dict has keys like {"filename": <name>}.
-                                     This structure can be easily converted to a pandas DataFrame.
+            - artifact (list[dict]): A list of dictionaries where each dict includes 
+              the keys {"filename": <name>, "type": <'file' or 'directory'>}.
+              This structure can be easily converted to a pandas DataFrame.
     """
-    print("    * Tool: list_directory_contents")
+    print(f"    * Tool: list_directory_contents | {directory_path}")
     import os
-
+    
+    if directory_path is None:
+        return "No directory path provided.", []
+    
+    if not os.path.isdir(directory_path):
+        return f"Directory not found: {directory_path}", []
+    
     items = []
     for item in os.listdir(directory_path):
         # If show_hidden is False, skip items starting with '.'
         if not show_hidden and item.startswith('.'):
             continue
         items.append(item)
+    items.reverse()
 
-    # content: just the raw list of filenames
-    content = items
-
-    # artifact: list of dicts (each row is {"filename": ...}), easily turned into a DataFrame
-    artifact = [{"filename": item} for item in items]
+    # content: just the raw list of item names (files/folders).
+    content = items.copy()
+    
+    content.append(f"Total items: {len(items)}")
+    content.append(f"Directory: {directory_path}")
+
+    # artifact: list of dicts with both "filename" and "type" keys.
+    artifact = []
+    for item in items:
+        item_path = os.path.join(directory_path, item)
+        artifact.append({
+            "filename": item,
+            "type": "directory" if os.path.isdir(item_path) else "file"
+        })
 
     return content, artifact
 
 
+
 @tool(response_format='content_and_artifact')
-def list_directory_recursive(directory_path: str, show_hidden: bool = False) -> Tuple[str, List[Dict]]:
+def list_directory_recursive(
+    directory_path: str = os.getcwd(), 
+    show_hidden: bool = False
+) -> Tuple[str, List[Dict]]:
     """
     Tool: list_directory_recursive
     Description:
@@ -111,13 +171,19 @@ def list_directory_recursive(directory_path: str, show_hidden: bool = False) ->
     Example:
         content, artifact = list_directory_recursive("/path/to/folder", show_hidden=False)
     """
-    print("    * Tool: list_directory_recursive")
+    print(f"    * Tool: list_directory_recursive | {directory_path}")
 
     # We'll store two things as we recurse:
     # 1) lines for building the "tree" string
     # 2) records in a list of dicts for easy DataFrame creation
     import os
     
+    if directory_path is None:
+        return "No directory path provided.", {}
+    
+    if not os.path.isdir(directory_path):
+        return f"Directory not found: {directory_path}", {}
+    
     lines = []
     records = []
 
@@ -210,7 +276,7 @@ def get_file_info(file_path: str) -> Tuple[str, List[Dict]]:
     Example:
         content, artifact = get_file_info("/path/to/mydata.csv")
     """
-    print("    * Tool: get_file_info")
+    print(f"    * Tool: get_file_info | {file_path}")
     
     # Ensure the file exists
     import os
@@ -244,7 +310,11 @@ def get_file_info(file_path: str) -> Tuple[str, List[Dict]]:
 
 
 @tool(response_format='content_and_artifact')
-def search_files_by_pattern(directory_path: str, pattern: str = "*.csv", recursive: bool = False) -> Tuple[str, List[Dict]]:
+def search_files_by_pattern(
+    directory_path: str = os.getcwd(),  
+    pattern: str = "*.csv", 
+    recursive: bool = False
+) -> Tuple[str, List[Dict]]:
     """
     Tool: search_files_by_pattern
     Description:
@@ -266,7 +336,7 @@ def search_files_by_pattern(directory_path: str, pattern: str = "*.csv", recursi
     Example:
         content, artifact = search_files_by_pattern("/path/to/folder", "*.csv", recursive=True)
     """
-    print("    * Tool: search_files_by_pattern")
+    print(f"    * Tool: search_files_by_pattern | {directory_path}")
     
     import os
     import fnmatch

ai_data_science_team/tools/eda.py

@@ -0,0 +1,293 @@
+
+from typing import Annotated, Dict, Tuple, Union
+
+import os
+
+from langchain.tools import tool
+
+from langgraph.prebuilt import InjectedState  
+
+
+@tool(response_format='content_and_artifact')
+def describe_dataset(
+    data_raw: Annotated[dict, InjectedState("data_raw")]
+) -> Tuple[str, Dict]:
+    """
+    Tool: describe_dataset
+    Description:
+        Describe the dataset by computing summary
+        statistics using the DataFrame's describe() method.
+        
+    Returns:
+    -------
+    Tuple[str, Dict]:
+        content: A textual summary of the DataFrame's descriptive statistics.
+        artifact: A dictionary (from DataFrame.describe()) for further inspection.
+    """
+    print("    * Tool: describe_dataset")
+    import pandas as pd
+    df = pd.DataFrame(data_raw)
+    description_df = df.describe(include='all')
+    content = "Summary statistics computed using pandas describe()."
+    artifact = description_df.to_dict()
+    return content, artifact
+
+
+@tool(response_format='content_and_artifact')
+def visualize_missing(
+    data_raw: Annotated[dict, InjectedState("data_raw")],
+    n_sample: int = None
+) -> Tuple[str, Dict]:
+    """
+    Tool: visualize_missing
+    Description:
+        Missing value analysis using the missingno library. Generates a matrix plot, bar plot, and heatmap plot.
+        
+    Parameters:
+    -----------
+    data_raw : dict
+        The raw data in dictionary format.
+    n_sample : int, optional (default: None)
+        The number of rows to sample from the dataset if it is large.
+        
+    Returns:
+    -------
+    Tuple[str, Dict]:
+        content: A message describing the generated plots.
+        artifact: A dict with keys 'matrix_plot', 'bar_plot', and 'heatmap_plot' each containing the
+                  corresponding base64 encoded PNG image.
+    """
+    print("    * Tool: visualize_missing")
+    
+    try:
+        import missingno as msno  # Ensure missingno is installed
+    except ImportError:
+        raise ImportError("Please install the 'missingno' package to use this tool. pip install missingno")
+    
+    import pandas as pd
+    import base64
+    from io import BytesIO
+    import matplotlib.pyplot as plt
+
+    # Create the DataFrame and sample if n_sample is provided.
+    df = pd.DataFrame(data_raw)
+    if n_sample is not None:
+        df = df.sample(n=n_sample, random_state=42)
+
+    # Dictionary to store the base64 encoded images for each plot.
+    encoded_plots = {}
+
+    # Define a helper function to create a plot, save it, and encode it.
+    def create_and_encode_plot(plot_func, plot_name: str):
+        plt.figure(figsize=(8, 6))
+        # Call the missingno plotting function.
+        plot_func(df)
+        plt.tight_layout()
+        buf = BytesIO()
+        plt.savefig(buf, format="png")
+        plt.close()
+        buf.seek(0)
+        return base64.b64encode(buf.getvalue()).decode("utf-8")
+
+    # Create and encode the matrix plot.
+    encoded_plots["matrix_plot"] = create_and_encode_plot(msno.matrix, "matrix")
+    
+    # Create and encode the bar plot.
+    encoded_plots["bar_plot"] = create_and_encode_plot(msno.bar, "bar")
+    
+    # Create and encode the heatmap plot.
+    encoded_plots["heatmap_plot"] = create_and_encode_plot(msno.heatmap, "heatmap")
+
+    content = "Missing data visualizations (matrix, bar, and heatmap) have been generated."
+    artifact = encoded_plots
+    return content, artifact
+
+
+
+@tool(response_format='content_and_artifact')
+def correlation_funnel(
+    data_raw: Annotated[dict, InjectedState("data_raw")],
+    target: str,
+    target_bin_index: Union[int, str] = -1,
+    corr_method: str = "pearson",
+    n_bins: int = 4,
+    thresh_infreq: float = 0.01,
+    name_infreq: str = "-OTHER",
+) -> Tuple[str, Dict]:
+    """
+    Tool: correlation_funnel
+    Description:
+        Correlation analysis using the correlation funnel method. The tool binarizes the data and computes correlation versus a target column.
+    
+    Parameters:
+    ----------
+    target : str
+        The base target column name (e.g., 'Member_Status'). The tool will look for columns that begin
+        with this string followed by '__' (e.g., 'Member_Status__Gold', 'Member_Status__Platinum').
+    target_bin_index : int or str, default -1
+        If an integer, selects the target level by position from the matching columns.
+        If a string (e.g., "Yes"), attempts to match to the suffix of a column name 
+        (i.e., 'target__Yes'). 
+    corr_method : str
+        The correlation method ('pearson', 'kendall', or 'spearman'). Default is 'pearson'.
+    n_bins : int
+        The number of bins to use for binarization. Default is 4.
+    thresh_infreq : float
+        The threshold for infrequent levels. Default is 0.01.
+    name_infreq : str
+        The name to use for infrequent levels. Default is '-OTHER'.
+    """
+    print("    * Tool: correlation_funnel")
+    try:
+        import pytimetk as tk
+    except ImportError:
+        raise ImportError("Please install the 'pytimetk' package to use this tool. pip install pytimetk")
+    import pandas as pd
+    import base64
+    from io import BytesIO
+    import matplotlib.pyplot as plt
+    import json
+    import plotly.graph_objects as go
+    import plotly.io as pio
+    from typing import Union
+
+    # Convert the raw injected state into a DataFrame.
+    df = pd.DataFrame(data_raw)
+    
+    # Apply the binarization method.
+    df_binarized = df.binarize(
+        n_bins=n_bins, 
+        thresh_infreq=thresh_infreq, 
+        name_infreq=name_infreq, 
+        one_hot=True
+    )
+    
+    # Determine the full target column name.
+    # Look for all columns that start with "target__"
+    matching_columns = [col for col in df_binarized.columns if col.startswith(f"{target}__")]
+    if not matching_columns:
+        # If no matching columns are found, warn and use the provided target as-is.
+        full_target = target
+    else:
+        # Determine the full target based on target_bin_index.
+        if isinstance(target_bin_index, str):
+            # Build the candidate column name
+            candidate = f"{target}__{target_bin_index}"
+            if candidate in matching_columns:
+                full_target = candidate
+            else:
+                # If no matching candidate is found, default to the last matching column.
+                full_target = matching_columns[-1]
+        else:
+            # target_bin_index is an integer.
+            try:
+                full_target = matching_columns[target_bin_index]
+            except IndexError:
+                # If index is out of bounds, use the last matching column.
+                full_target = matching_columns[-1]
+    
+    # Compute correlation funnel using the full target column name.
+    df_correlated = df_binarized.correlate(target=full_target, method=corr_method)
+    
+    # Attempt to generate a static plot.
+    try:
+        # Here we assume that your DataFrame has a method plot_correlation_funnel.
+        fig = df_correlated.plot_correlation_funnel(engine='plotnine', height=600)
+        buf = BytesIO()
+        # Use the appropriate save method for your figure object.
+        fig.save(buf, format="png")
+        plt.close()
+        buf.seek(0)
+        encoded = base64.b64encode(buf.getvalue()).decode("utf-8")
+    except Exception as e:
+        encoded = {"error": str(e)}
+    
+    # Attempt to generate a Plotly plot.
+    try:
+        fig = df_correlated.plot_correlation_funnel(engine='plotly')
+        fig_json = pio.to_json(fig)
+        fig_dict = json.loads(fig_json)
+    except Exception as e:
+        fig_dict = {"error": str(e)}
+
+    content = (f"Correlation funnel computed using method '{corr_method}' for target level '{full_target}'. "
+               f"Base target was '{target}' with target_bin_index '{target_bin_index}'.")
+    artifact = {
+        "correlation_data": df_correlated.to_dict(orient="list"),
+        "plot_image": encoded,
+        "plotly_figure": fig_dict,
+    }
+    return content, artifact
+
+
+
+@tool(response_format='content_and_artifact')
+def generate_sweetviz_report(
+    data_raw: Annotated[dict, InjectedState("data_raw")],
+    target: str = None,
+    report_name: str = "sweetviz_report.html",
+    report_directory: str = os.path.join(os.getcwd(), "reports"),
+    open_browser: bool = True,
+) -> Tuple[str, Dict]:
+    """
+    Tool: generate_sweetviz_report
+    Description:
+        Make an Exploratory Data Analysis (EDA) report using the Sweetviz library.
+    
+    Parameters:
+    -----------
+    data_raw : dict
+        The raw data injected as a dictionary (converted from a DataFrame).
+    target : str, optional
+        The target feature to analyze. Default is None.
+    report_name : str, optional
+        The file name to save the Sweetviz HTML report. Default is "sweetviz_report.html".
+    report_directory : str, optional
+        The directory where the report should be saved. Defaults to a 'reports' directory in the current working directory.
+    open_browser : bool, optional
+        Whether to open the report in a web browser. Default is True.
+    
+    Returns:
+    --------
+    Tuple[str, Dict]:
+        content: A summary message describing the generated report.
+        artifact: A dictionary with the report file path and optionally the report's HTML content.
+    """
+    print("    * Tool: generate_sweetviz_report")
+    try:
+        import sweetviz as sv
+    except ImportError:
+        raise ImportError("Please install the 'sweetviz' package to use this tool. Run: pip install sweetviz")
+    import pandas as pd
+    # Convert injected raw data to a DataFrame.
+    df = pd.DataFrame(data_raw)
+    
+    # Create the Sweetviz report.
+    report = sv.analyze(df, target_feat=target)
+    
+    # Ensure the directory exists; default is os.getcwd()/reports
+    if not os.path.exists(report_directory):
+        os.makedirs(report_directory)
+    
+    # Determine the full path for the report.
+    full_report_path = os.path.join(report_directory, report_name)
+    
+    # Save the report to the specified HTML file.
+    report.show_html(
+        filepath=full_report_path,
+        open_browser=True,
+    )
+    
+    # Optionally, read the HTML content (if desired to pass along in the artifact).
+    try:
+        with open(full_report_path, "r", encoding="utf-8") as f:
+            html_content = f.read()
+    except Exception:
+        html_content = None
+    
+    content = f"Sweetviz EDA report generated and saved as '{os.path.abspath(full_report_path)}'."
+    artifact = {
+        "report_file": os.path.abspath(full_report_path),
+        "report_html": html_content,
+    }
+    return content, artifact

ai_data_science_team/utils/html.py

@@ -0,0 +1,27 @@
+
+
+import webbrowser
+import os
+
+def open_html_file_in_browser(file_path: str):
+    """
+    Opens an HTML file in the default web browser.
+    
+    Parameters:
+    -----------
+    file_path : str
+        The file path or URL of the HTML file to open.
+        
+    Returns:
+    --------
+    None
+    """
+    # Check if the file exists if a local path is provided.
+    if os.path.isfile(file_path):
+        # Convert file path to a file URL
+        file_url = 'file://' + os.path.abspath(file_path)
+    else:
+        # If the file doesn't exist locally, assume it's a URL
+        file_url = file_path
+
+    webbrowser.open(file_url)

ai_data_science_team/utils/matplotlib.py

@@ -0,0 +1,46 @@
+import base64
+from io import BytesIO
+import matplotlib.pyplot as plt
+from PIL import Image
+
+def matplotlib_from_base64(encoded: str, title: str = None, figsize: tuple = (8, 6)):
+    """
+    Convert a base64-encoded image to a matplotlib plot and display it.
+    
+    Parameters:
+    -----------
+    encoded : str
+        The base64-encoded image string.
+    title : str, optional
+        A title for the plot. Default is None.
+    figsize : tuple, optional
+        Figure size (width, height) for the plot. Default is (8, 6).
+    
+    Returns:
+    --------
+    fig, ax : tuple
+        The matplotlib figure and axes objects.
+    """
+    # Decode the base64 string to bytes
+    img_data = base64.b64decode(encoded)
+    
+    # Load the bytes data into a BytesIO buffer
+    buf = BytesIO(img_data)
+    
+    # Open the image using Pillow
+    img = Image.open(buf)
+    
+    # Create a matplotlib figure and axis
+    fig, ax = plt.subplots(figsize=figsize)
+    
+    # Display the image
+    ax.imshow(img)
+    ax.axis('off')  # Hide the axis
+    
+    if title:
+        ax.set_title(title)
+    
+    # Show the plot
+    plt.show()
+    
+    return fig, ax

{ai_data_science_team-0.0.0.9010.dist-info → ai_data_science_team-0.0.0.9012.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ai-data-science-team
-Version: 0.0.0.9010
+Version: 0.0.0.9012
 Summary: Build and run an AI-powered data science team.
 Home-page: https://github.com/business-science/ai-data-science-team
 Author: Matt Dancho
@@ -31,9 +31,16 @@ Requires-Dist: psutil
 Provides-Extra: machine-learning
 Requires-Dist: h2o; extra == "machine-learning"
 Requires-Dist: mlflow; extra == "machine-learning"
+Provides-Extra: data-science
+Requires-Dist: pytimetk; extra == "data-science"
+Requires-Dist: missingno; extra == "data-science"
+Requires-Dist: sweetviz; extra == "data-science"
 Provides-Extra: all
 Requires-Dist: h2o; extra == "all"
 Requires-Dist: mlflow; extra == "all"
+Requires-Dist: pytimetk; extra == "all"
+Requires-Dist: missingno; extra == "all"
+Requires-Dist: sweetviz; extra == "all"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -59,6 +66,8 @@ Dynamic: summary
   <a href="https://pypi.python.org/pypi/ai-data-science-team"><img src="https://img.shields.io/pypi/v/ai-data-science-team.svg?style=for-the-badge" alt="PyPI"></a>
   <a href="https://github.com/business-science/ai-data-science-team"><img src="https://img.shields.io/pypi/pyversions/ai-data-science-team.svg?style=for-the-badge" alt="versions"></a>
   <a href="https://github.com/business-science/ai-data-science-team/blob/main/LICENSE"><img src="https://img.shields.io/github/license/business-science/ai-data-science-team.svg?style=for-the-badge" alt="license"></a>
+  <img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/business-science/ai-data-science-team?style=for-the-badge">
+
 </div>
 
 
@@ -93,8 +102,9 @@ The AI Data Science Team of Copilots includes Agents that specialize data cleani
     - [Apps Available Now](#apps-available-now)
       - [🔥 Agentic Applications](#-agentic-applications)
     - [Agents Available Now](#agents-available-now)
+      - [Standard Agents](#standard-agents)
       - [🔥🔥 NEW! Machine Learning Agents](#-new-machine-learning-agents)
-      - [Data Science Agents](#data-science-agents-1)
+      - [🔥 NEW! Data Science Agents](#-new-data-science-agents)
       - [Multi-Agents](#multi-agents)
     - [Agents Coming Soon](#agents-coming-soon)
   - [Disclaimer](#disclaimer)
@@ -122,7 +132,7 @@ If you're an aspiring data scientist who wants to learn how to build AI Agents a
 
 This project is a work in progress. New data science agents will be released soon.
 
-![Data Science Team](/img/ai_data_science_team.jpg)
+![AI Data Science Team](/img/ai_data_science_team.jpg) 
 
 ### NEW: Multi-Agents
 
@@ -146,18 +156,25 @@ This is a top secret project I'm working on. It's a multi-agent data science app
 
 ### Agents Available Now
 
+#### Standard Agents
+
+1. **Data Wrangling Agent:** Merges, Joins, Preps and Wrangles data into a format that is ready for data analysis. [See Example](https://github.com/business-science/ai-data-science-team/blob/master/examples/data_wrangling_agent.ipynb)
+2. **Data Visualization Agent:** Creates visualizations to help you understand your data. Returns JSON serializable plotly visualizations. [See Example](https://github.com/business-science/ai-data-science-team/blob/master/examples/data_visualization_agent.ipynb)
+3. **🔥 Data Cleaning Agent:** Performs Data Preparation steps including handling missing values, outliers, and data type conversions. [See Example](https://github.com/business-science/ai-data-science-team/blob/master/examples/data_cleaning_agent.ipynb)
+4. **Feature Engineering Agent:** Converts the prepared data into ML-ready data. Adds features to increase predictive accuracy of ML models. [See Example](https://github.com/business-science/ai-data-science-team/blob/master/examples/feature_engineering_agent.ipynb)
+5. **🔥 SQL Database Agent:** Connects to SQL databases to pull data into the data science environment. Creates pipelines to automate data extraction. Performs Joins, Aggregations, and other SQL Query operations. [See Example](https://github.com/business-science/ai-data-science-team/blob/master/examples/sql_database_agent.ipynb)
+6. **🔥 Data Loader Tools Agent:** Loads data from various sources including CSV, Excel, Parquet, and Pickle files. [See Example](https://github.com/business-science/ai-data-science-team/blob/master/examples/data_loader_tools_agent.ipynb)
+
+
 #### 🔥🔥 NEW! Machine Learning Agents
 
 1. **🔥 H2O Machine Learning Agent:** Builds and logs 100's of high-performance machine learning models. [See Example](https://github.com/business-science/ai-data-science-team/blob/master/examples/ml_agents/h2o_machine_learning_agent.ipynb)
 2. **🔥 MLflow Tools Agent (MLOps):** This agent has 11+ tools for managing models, ML projects, and making production ML predictions with MLflow. [See Example](https://github.com/business-science/ai-data-science-team/blob/master/examples/ml_agents/mlflow_tools_agent.ipynb)
 
-#### Data Science Agents
+#### 🔥 NEW! Data Science Agents
+
+1. **🔥🔥 EDA Tools Agent:** Performs automated exploratory data analysis (EDA) with EDA Reporting, Missing Data Analysis, Correlation Analysis, and more. [See Example](https://github.com/business-science/ai-data-science-team/blob/master/examples/ds_agents/eda_tools_agent.ipynb)
 
-1. **Data Wrangling Agent:** Merges, Joins, Preps and Wrangles data into a format that is ready for data analysis. [See Example](https://github.com/business-science/ai-data-science-team/blob/master/examples/data_wrangling_agent.ipynb)
-2. **Data Visualization Agent:** Creates visualizations to help you understand your data. Returns JSON serializable plotly visualizations. [See Example](https://github.com/business-science/ai-data-science-team/blob/master/examples/data_visualization_agent.ipynb)
-3. **Data Cleaning Agent:** Performs Data Preparation steps including handling missing values, outliers, and data type conversions. [See Example](https://github.com/business-science/ai-data-science-team/blob/master/examples/data_cleaning_agent.ipynb)
-4. **Feature Engineering Agent:** Converts the prepared data into ML-ready data. Adds features to increase predictive accuracy of ML models. [See Example](https://github.com/business-science/ai-data-science-team/blob/master/examples/feature_engineering_agent.ipynb)
-5. **SQL Database Agent:** Connects to SQL databases to pull data into the data science environment. Creates pipelines to automate data extraction. Performs Joins, Aggregations, and other SQL Query operations. [See Example](https://github.com/business-science/ai-data-science-team/blob/master/examples/sql_database_agent.ipynb)
 
 #### Multi-Agents