diff --git a/sigllm/pipelines/prompter/gpt_prompter.json b/sigllm/pipelines/prompter/gpt_prompter.json
new file mode 100644
index 0000000..381dd5b
--- /dev/null
+++ b/sigllm/pipelines/prompter/gpt_prompter.json
@@ -0,0 +1,65 @@
+{
+    "primitives": [
+        "mlstars.custom.timeseries_preprocessing.time_segments_aggregate",
+        "sklearn.impute.SimpleImputer",
+        "sigllm.primitives.transformation.Float2Scalar",
+        "sigllm.primitives.prompting.timeseries_preprocessing.rolling_window_sequences",
+	    "sigllm.primitives.transformation.format_as_string",
+        "sigllm.primitives.prompting.gpt.GPT",
+        "sigllm.primitives.transformation.format_as_integer",
+        "sigllm.primitives.prompting.anomalies.val2idx",
+        "sigllm.primitives.prompting.anomalies.find_anomalies_in_windows",
+        "sigllm.primitives.prompting.anomalies.merge_anomalous_sequences",
+        "sigllm.primitives.prompting.anomalies.format_anomalies"
+    ],
+    "init_params": {
+        "mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1": {
+            "time_column": "timestamp",
+            "interval": 21600,
+            "method": "mean"
+        },
+        "sigllm.primitives.transformation.Float2Scalar#1": {
+            "decimal": 2,
+            "rescale": true
+        },
+        "sigllm.primitives.prompting.timeseries_preprocessing.rolling_window_sequences#1": {
+            "window_size": 200,
+            "step_size": 40
+        },
+        "sigllm.primitives.transformation.format_as_string#1": {
+            "space": true
+        },
+        "sigllm.primitives.prompting.gpt.GPT#1": {
+            "name": "gpt-3.5-turbo",
+            "samples": 10
+        },
+        "sigllm.primitives.prompting.anomalies.find_anomalies_in_windows#1": {
+            "alpha": 0.4
+        },
+        "sigllm.primitives.prompting.anomalies.merge_anomalous_sequences#1": {
+            "beta": 0.5
+        }
+    },
+    "input_names": {
+        "sigllm.primitives.prompting.gpt.GPT#1": {
+            "X": "X_str"
+        },
+        "sigllm.primitives.transformation.format_as_integer#1":{
+            "X": "y_hat"
+        }
+    },
+    "output_names": {
+        "mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1": {
+            "index": "timestamp"
+        },
+        "sigllm.primitives.transformation.format_as_string#1": {
+            "X": "X_str"
+        },
+        "sigllm.primitives.prompting.gpt.GPT#1": {
+            "y": "y_hat"
+        },
+        "sigllm.primitives.transformation.format_as_integer#1":{
+            "X": "y"
+        }
+    }
+}
\ No newline at end of file
diff --git a/sigllm/pipelines/prompter/mistral_prompter.json b/sigllm/pipelines/prompter/mistral_prompter.json
new file mode 100644
index 0000000..0bc3e10
--- /dev/null
+++ b/sigllm/pipelines/prompter/mistral_prompter.json
@@ -0,0 +1,65 @@
+{
+    "primitives": [
+        "mlstars.custom.timeseries_preprocessing.time_segments_aggregate",
+        "sklearn.impute.SimpleImputer",
+        "sigllm.primitives.transformation.Float2Scalar",
+        "sigllm.primitives.prompting.timeseries_preprocessing.rolling_window_sequences",
+	    "sigllm.primitives.transformation.format_as_string",
+        "sigllm.primitives.prompting.huggingface.HF",
+        "sigllm.primitives.transformation.format_as_integer",
+        "sigllm.primitives.prompting.anomalies.val2idx",
+        "sigllm.primitives.prompting.anomalies.find_anomalies_in_windows",
+        "sigllm.primitives.prompting.anomalies.merge_anomalous_sequences",
+        "sigllm.primitives.prompting.anomalies.format_anomalies"
+    ],
+    "init_params": {
+        "mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1": {
+            "time_column": "timestamp",
+            "interval": 21600,
+            "method": "mean"
+        },
+        "sigllm.primitives.transformation.Float2Scalar#1": {
+            "decimal": 2,
+            "rescale": true
+        },
+        "sigllm.primitives.prompting.timeseries_preprocessing.rolling_window_sequences#1": {
+            "window_size": 200,
+            "step_size": 40
+        },
+        "sigllm.primitives.transformation.format_as_string#1": {
+            "space": false
+        },
+        "sigllm.primitives.prompting.huggingface.HF#1": {
+            "name": "mistralai/Mistral-7B-Instruct-v0.2",
+            "samples": 10
+        },
+        "sigllm.primitives.prompting.anomalies.find_anomalies_in_windows#1": {
+            "alpha": 0.4
+        },
+        "sigllm.primitives.prompting.anomalies.merge_anomalous_sequences#1": {
+            "beta": 0.5
+        }
+    },
+    "input_names": {
+        "sigllm.primitives.prompting.huggingface.HF#1": {
+            "X": "X_str"
+        },
+        "sigllm.primitives.transformation.format_as_integer#1":{
+            "X": "y_hat"
+        }
+    },
+    "output_names": {
+        "mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1": {
+            "index": "timestamp"
+        },
+        "sigllm.primitives.transformation.format_as_string#1": {
+            "X": "X_str"
+        },
+        "sigllm.primitives.prompting.huggingface.HF#1": {
+            "y": "y_hat"
+        },
+        "sigllm.primitives.transformation.format_as_integer#1":{
+            "X": "y"
+        }
+    }
+}
\ No newline at end of file
diff --git a/sigllm/primitives/jsons/sigllm.primitives.prompting.anomalies.find_anomalies_in_windows.json b/sigllm/primitives/jsons/sigllm.primitives.prompting.anomalies.find_anomalies_in_windows.json
new file mode 100644
index 0000000..64648aa
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.prompting.anomalies.find_anomalies_in_windows.json
@@ -0,0 +1,36 @@
+{
+    "name": "sigllm.primitives.prompting.anomalies.find_anomalies_in_windows",
+    "contributors": [
+        "Sarah Alnegheimish <smish@mit.edu>",
+        "Linh Nguyen <linhnk@mit.edu>"
+    ],
+    "description": "Get the final list of anomalous indices of each window",
+    "classifiers": {
+        "type": "postprocessor",
+        "subtype": "merger"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.prompting.anomalies.find_anomalies_in_windows",
+    "produce": {
+        "args": [
+            {
+                "name": "y",
+                "type": "ndarray"
+            }
+        ],
+        "output": [
+            {
+                "name": "y",
+                "type": "ndarray"
+            }
+        ]
+    }, 
+    "hyperparameters": {
+        "fixed": {
+            "alpha": {
+                "type": "float",
+                "default": 0.5
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/sigllm/primitives/jsons/sigllm.primitives.prompting.anomalies.format_anomalies.json b/sigllm/primitives/jsons/sigllm.primitives.prompting.anomalies.format_anomalies.json
new file mode 100644
index 0000000..76990d0
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.prompting.anomalies.format_anomalies.json
@@ -0,0 +1,40 @@
+{
+    "name": "sigllm.primitives.prompting.anomalies.format_anomalies",
+    "contributors": [
+        "Sarah Alnegheimish <smish@mit.edu>",
+        "Linh Nguyen <linhnk@mit.edu>"
+    ],
+    "description": "Convert list of indices to list of intervals by padding to both sides and merge overlapping",
+    "classifiers": {
+        "type": "postprocessor",
+        "subtype": "converter"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.prompting.anomalies.format_anomalies",
+    "produce": {
+        "args": [
+            {
+                "name": "y",
+                "type": "ndarray"
+            },
+            {
+                "name": "timestamp",
+                "type": "ndarray"
+            }
+        ],
+        "output": [
+            {
+                "name": "anomalies",
+                "type": "List"
+            }
+        ]
+    }, 
+    "hyperparameters": {
+        "fixed": {
+            "padding_size": {
+                "type": "int",
+                "default": 50
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/sigllm/primitives/jsons/sigllm.primitives.prompting.anomalies.merge_anomalous_sequences.json b/sigllm/primitives/jsons/sigllm.primitives.prompting.anomalies.merge_anomalous_sequences.json
new file mode 100644
index 0000000..384293c
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.prompting.anomalies.merge_anomalous_sequences.json
@@ -0,0 +1,48 @@
+{
+    "name": "sigllm.primitives.prompting.anomalies.merge_anomalous_sequences",
+    "contributors": [
+        "Sarah Alnegheimish <smish@mit.edu>",
+        "Linh Nguyen <linhnk@mit.edu>"
+    ],
+    "description": "Get the final list of anomalous indices of a sequence when merging all rolling windows",
+    "classifiers": {
+        "type": "postprocessor",
+        "subtype": "merger"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.prompting.anomalies.merge_anomalous_sequences",
+    "produce": {
+        "args": [
+            {
+                "name": "y",
+                "type": "ndarray"
+            }, 
+            {
+                "name": "first_index",
+                "type": "ndarray"
+            },
+            {
+                "name": "window_size",
+                "type": "int"
+            },
+            {
+                "name": "step_size",
+                "type": "int"
+            }
+        ],
+        "output": [
+            {
+                "name": "y",
+                "type": "ndarray"
+            }
+        ]
+    }, 
+    "hyperparameters": {
+        "fixed": {
+            "beta": {
+                "type": "float",
+                "default": 0.5
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/sigllm/primitives/jsons/sigllm.primitives.prompting.anomalies.val2idx.json b/sigllm/primitives/jsons/sigllm.primitives.prompting.anomalies.val2idx.json
new file mode 100644
index 0000000..5a07bf1
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.prompting.anomalies.val2idx.json
@@ -0,0 +1,32 @@
+{
+    "name": "sigllm.primitives.prompting.anomalies.val2idx",
+    "contributors": [
+        "Sarah Alnegheimish <smish@mit.edu>",
+        "Linh Nguyen <linhnk@mit.edu>"
+    ],
+    "description": "Convert detected anomalous values into indices",
+    "classifiers": {
+        "type": "postprocessor",
+        "subtype": "converter"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.prompting.anomalies.val2idx",
+    "produce": {
+        "args": [
+            {
+                "name": "y",
+                "type": "ndarray"
+            },
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ],
+        "output": [
+            {
+                "name": "y",
+                "type": "ndarray"
+            }
+        ]
+    }
+}
\ No newline at end of file
diff --git a/sigllm/primitives/jsons/sigllm.primitives.prompting.gpt.GPT.json b/sigllm/primitives/jsons/sigllm.primitives.prompting.gpt.GPT.json
new file mode 100644
index 0000000..9c07924
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.prompting.gpt.GPT.json
@@ -0,0 +1,73 @@
+{
+    "name": "sigllm.primitives.prompting.gpt.GPT",
+    "contributors": [
+        "Linh Nguyen <linhnk@mit.edu>"
+    ],
+    "description": "Prompt openai GPT model to detect time series anomalies.",
+    "classifiers": {
+        "type": "estimator",
+        "subtype": "detector"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.prompting.gpt.GPT",
+    "produce": {
+        "method": "detect",
+        "args": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ],
+        "output": [
+            {
+                "name": "y",
+                "type": "ndarray"
+            },
+            {
+                "name": "logprob",
+                "type": "ndarray",
+                "default": null
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "name": {
+                "type": "str",
+                "default": "gpt-3.5-turbo"
+            },
+            "sep": {
+                "type": "str",
+                "default": ","
+            },
+            "anomalous_percent": {
+                "type": "float",
+                "default": "0.5"
+            },
+            "temp": {
+                "type": "float",
+                "default": 1
+            },
+            "top_p": {
+                "type": "float",
+                "default": 1
+            },
+            "logprobs": {
+                "type": "bool",
+                "default": false
+            },
+            "top_logprobs": {
+                "type": "int",
+                "default": null
+            },
+            "samples": {
+                "type": "int",
+                "default": 1
+            },
+            "seed": {
+                "type": "int",
+                "default": null
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/sigllm/primitives/jsons/sigllm.primitives.prompting.huggingface.HF.json b/sigllm/primitives/jsons/sigllm.primitives.prompting.huggingface.HF.json
new file mode 100644
index 0000000..91d0530
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.prompting.huggingface.HF.json
@@ -0,0 +1,69 @@
+{
+    "name": "sigllm.primitives.prompting.huggingface.HF",
+    "contributors": [
+        "Linh Nguyen <linhnk@mit.edu>"
+    ],
+    "description": "Prompt any HF model to detect time series anomalies.",
+    "classifiers": {
+        "type": "estimator",
+        "subtype": "detector"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.prompting.huggingface.HF",
+    "produce": {
+        "method": "detect",
+        "args": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ],
+        "output": [
+            {
+                "name": "y",
+                "type": "ndarray"
+            },
+            {
+                "name": "logprob",
+                "type": "ndarray",
+                "default": null
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "name": {
+                "type": "str",
+                "default": "mistralai/Mistral-7B-Instruct-v0.2"
+            },
+            "sep": {
+                "type": "str",
+                "default": ","
+            },
+            "anomalous_percent": {
+                "type": "float",
+                "default": "0.5"
+            },
+            "temp": {
+                "type": "float",
+                "default": 1
+            },
+            "top_p": {
+                "type": "float",
+                "default": 1
+            },
+            "raw": {
+                "type": "bool",
+                "default": false
+            },
+            "samples": {
+                "type": "int",
+                "default": 1
+            },
+            "padding": {
+                "type": "int",
+                "default": 0
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/sigllm/primitives/jsons/sigllm.primitives.prompting.timeseries_preprocessing.rolling_window_sequences.json b/sigllm/primitives/jsons/sigllm.primitives.prompting.timeseries_preprocessing.rolling_window_sequences.json
new file mode 100644
index 0000000..23658e8
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.prompting.timeseries_preprocessing.rolling_window_sequences.json
@@ -0,0 +1,54 @@
+{
+    "name": "sigllm.primitives.prompting.timeseries_preprocessing.rolling_window_sequences",
+    "contributors": [
+        "Sarah Alnegheimish <smish@mit.edu>",
+        "Linh Nguyen <linhnk@mit.edu>"
+    ],
+    "description": "Create rolling windows",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "feature_extractor"
+    },
+    "modalities": [
+        "timeseries"
+    ],
+    "primitive": "sigllm.primitives.prompting.timeseries_preprocessing.rolling_window_sequences",
+    "produce": {
+        "args": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            },
+            {
+                "name": "first_index",
+                "type": "ndarray"
+            }, 
+            {
+                "name": "window_size", 
+                "type": "int"
+            },
+            {
+                "name": "step_size", 
+                "type": "int"
+            }
+        ]
+    }, 
+    "hyperparameters": {
+        "fixed": {
+            "window_size": {
+                "type": "int",
+                "default": 500
+            },
+            "step_size": {
+                "type": "int",
+                "default": 100
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/sigllm/primitives/prompting/anomalies.py b/sigllm/primitives/prompting/anomalies.py
index c23abb4..4c1f497 100644
--- a/sigllm/primitives/prompting/anomalies.py
+++ b/sigllm/primitives/prompting/anomalies.py
@@ -1,109 +1,97 @@
 # -*- coding: utf-8 -*-
 
 """
-Result post-processing module.
+Prompter post-processing module
 
-This module contains functions that help convert model responses back to indices and timestamps.
+This module contains functions that help filter LLMs results to get the final anomalies.
 """
-import numpy as np
-
-
-def str2sig(text, sep=',', decimal=0):
-    """Convert a text string to a signal.
-
-    Convert a string containing digits into an array of numbers.
 
-    Args:
-        text (str):
-            A string containing signal values.
-        sep (str):
-            String that was used to separate each element in text, Default to `","`.
-        decimal (int):
-            Number of decimal points to shift each element in text to. Default to `0`.
-
-    Returns:
-        numpy.ndarray:
-            A 1-dimensional array containing parsed elements in `text`.
-    """
-    # Remove all characters from text except the digits and sep and decimal point
-    text = ''.join(i for i in text if (i.isdigit() or i == sep or i == '.'))
-    values = np.fromstring(text, dtype=float, sep=sep)
-    return values * 10**(-decimal)
+import numpy as np
 
 
-def str2idx(text, len_seq, sep=','):
-    """Convert a text string to indices.
+def val2idx(y, X):
+    """Convert detected anomalies values into indices.
 
-    Convert a string containing digits into an array of indices.
+    Convert windows of detected anomalies values into an array of all indices
+    in the input sequence that have those values.
 
     Args:
-        text (str):
-            A string containing indices values.
-        len_seq (int):
-            The length of processed sequence
-        sep (str):
-            String that was used to separate each element in text, Default to `","`.
-
+        y (ndarray):
+            A 3d array containing detected anomalous values from different
+            responses of each window.
+        X (ndarray):
+            rolling window sequences.
     Returns:
-        numpy.ndarray:
-            A 1-dimensional array containing parsed elements in `text`.
+        List([ndarray]):
+            A 3d array containing detected anomalous indices from different
+            responses of each window.
     """
-    # Remove all characters from text except the digits and sep
-    text = ''.join(i for i in text if (i.isdigit() or i == sep))
-
-    values = np.fromstring(text, dtype=int, sep=sep)
 
-    # Remove indices that exceed the length of sequence
-    values = values[values < len_seq]
-    return values
+    idx_list = []
+    for anomalies_list, seq in zip(y, X):
+        idx_win_list = []
+        for anomalies in anomalies_list:
+            mask = np.isin(seq, anomalies)
+            indices = np.where(mask)[0]
+            idx_win_list.append(indices)
+        idx_list.append(idx_win_list)
+    idx_list = np.array(idx_list, dtype=object)
+    return idx_list
 
 
-def get_anomaly_list_within_seq(res_list, alpha=0.5):
-    """Get the final list of anomalous indices of a sequence
+def find_anomalies_in_windows(y, alpha=0.5):
+    """Get the final list of anomalous indices of each window
 
     Choose anomalous index in the sequence based on multiple LLM responses
 
     Args:
-        res_list (List[numpy.ndarray]):
-            A list of 1-dimensional array containing anomous indices output by LLM
+        y (ndarray):
+            A 3d array containing detected anomalous values from different
+            responses of each window.
         alpha (float):
-            Percentage of votes needed for an index to be deemed anomalous. Default: 0.5
+            Percent of votes needed for an index to be anomalous. Default to `0.5`.
 
     Returns:
-        numpy.ndarray:
-            A 1-dimensional array containing final anomalous indices
+        ndarray:
+            A 2-dimensional array containing final anomalous indices of each windows.
     """
-    min_vote = np.ceil(alpha * len(res_list))
 
-    flattened_res = np.concatenate(res_list)
+    idx_list = []
+    for samples in y:
+        min_vote = np.ceil(alpha * len(samples))
+        # print(type(samples.tolist()))
 
-    unique_elements, counts = np.unique(flattened_res, return_counts=True)
+        flattened_res = np.concatenate(samples.tolist())
 
-    final_list = unique_elements[counts >= min_vote]
+        unique_elements, counts = np.unique(flattened_res, return_counts=True)
+
+        final_list = unique_elements[counts >= min_vote]
 
-    return final_list
+        idx_list.append(final_list)
+    idx_list = np.array(idx_list, dtype=object)
+    return idx_list
 
 
-def merge_anomaly_seq(anomalies, start_indices, window_size, step_size, beta=0.5):
+def merge_anomalous_sequences(y, first_index, window_size, step_size, beta=0.5):
     """Get the final list of anomalous indices of a sequence when merging all rolling windows
 
     Args:
-        anomalies (List[numpy.ndarray]):
-            A list of 1-dimensional array containing anomous indices of each window
-        start_indices (numpy.ndarray):
-            A 1-dimensional array contaning the first index of each window
+        y (ndarray):
+            A 2-dimensional array containing anomalous indices of each window.
+        first_index (ndarray):
+            A 1-dimensional array contaning the first index of each window.
         window_size (int):
             Length of each window
         step_size (int):
             Indicating the number of steps the window moves forward each round.
         beta (float):
-            Percentage of containing windows needed for index to be deemed anomalous. Default: 0.5
+            Percent of windows needed for index to be anomalous. Default to `0.5`.
 
     Return:
-        numpy.ndarray:
-            A 1-dimensional array containing final anomalous indices
+        ndarray:
+            A 1-dimensional array containing final anomalous indices.
     """
-    anomalies = [arr + first_idx for (arr, first_idx) in zip(anomalies, start_indices)]
+    anomalies = [arr + first_idx for (arr, first_idx) in zip(y, first_index)]
 
     min_vote = np.ceil(beta * window_size / step_size)
 
@@ -116,17 +104,46 @@ def merge_anomaly_seq(anomalies, start_indices, window_size, step_size, beta=0.5
     return np.sort(final_list)
 
 
-def idx2time(sequence, idx_list):
-    """Convert list of indices into list of timestamp
+def format_anomalies(y, timestamp, padding_size=50):
+    """Convert list of anomalous indices to list of intervals by padding to both sides
+    and merge overlapping
 
     Args:
-        sequence (pandas.Dataframe):
-            Signal with timestamps and values
-        idx_list (numpy.ndarray):
-            A 1-dimensional array of indices
+        y (ndarray):
+            A 1-dimensional array of indices.
+        timestamp (ndarray):
+            List of full timestamp of the signal
+        padding_size (int):
+            Number of steps to pad on both sides of a timestamp point. Default to `50`.
 
     Returns:
-        numpy.ndarray:
-            A 1-dimensional array containing timestamps
+        List[Tuple]:
+            List of intervals (start, end, score).
     """
-    return sequence.iloc[idx_list].timestamp.to_numpy()
+    y = timestamp[y]  # Convert list of indices into list of timestamps
+    start, end = timestamp[0], timestamp[-1]
+    interval = timestamp[1] - timestamp[0]
+    intervals = []
+    for timestamp in y:
+        intervals.append((max(start, timestamp - padding_size * interval),
+                         min(end, timestamp + padding_size * interval)))
+    if not intervals:
+        return []
+
+    intervals.sort(key=lambda x: x[0])  # Sort intervals based on start time
+    merged_intervals = [intervals[0]]  # Initialize merged intervals with the first interval
+
+    for current_interval in intervals[1:]:
+        previous_interval = merged_intervals[-1]
+
+        # If the current interval overlaps with the previous one, merge them
+        if current_interval[0] <= previous_interval[1]:
+            previous_interval = (
+                previous_interval[0], max(
+                    previous_interval[1], current_interval[1]))
+            merged_intervals[-1] = previous_interval
+        else:
+            merged_intervals.append(current_interval)  # Append the current interval if no overlap
+
+    merged_intervals = [(interval[0], interval[1], 0) for interval in merged_intervals]
+    return merged_intervals
diff --git a/sigllm/primitives/prompting/data.py b/sigllm/primitives/prompting/data.py
deleted file mode 100644
index 7d28dd8..0000000
--- a/sigllm/primitives/prompting/data.py
+++ /dev/null
@@ -1,81 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-Data preprocessing module.
-
-This module contains functions that prepare timeseries for a language model.
-"""
-
-import numpy as np
-
-
-def rolling_window_sequences(X, index, window_size, step_size):
-    """Create rolling window sequences out of time series data.
-
-    The function creates an array of sequences by rolling over the input sequence.
-
-    Args:
-        X (ndarray):
-            The sequence to iterate over.
-        index (ndarray):
-            Array containing the index values of X.
-        window_size (int):
-            Length of window.
-        step_size (int):
-            Indicating the number of steps to move the window forward each round.
-
-    Returns:
-        ndarray, ndarray:
-            * rolling window sequences.
-            * first index value of each input sequence.
-    """
-    out_X = list()
-    X_index = list()
-
-    start = 0
-    max_start = len(X) - window_size + 1
-    while start < max_start:
-        end = start + window_size
-        out_X.append(X[start:end])
-        X_index.append(index[start])
-        start = start + step_size
-
-    return np.asarray(out_X), np.asarray(X_index)
-
-
-def sig2str(values, sep=',', space=False, decimal=0, rescale=True):
-    """Convert a signal to a string.
-
-    Convert a 1-dimensional time series into text by casting and rescaling it
-    to nonnegative integer values then into a string (optional).
-
-    Args:
-        values (numpy.ndarray):
-            A sequence of signal values.
-        sep (str):
-            String to separate each element in values. Default to `","`.
-        space (bool):
-            Whether to add space between each digit in the result. Default to `False`.
-        decimal (int):
-            Number of decimal points to keep from the float representation. Default to `0`.
-        rescale(bool):
-            Whether to rescale the time series. Default to `True`
-
-    Returns:
-        str:
-            Text containing the elements of `values`.
-    """
-    sign = 1 * (values >= 0) - 1 * (values < 0)
-    values = np.abs(values)
-
-    sequence = sign * (values * 10**decimal).astype(int)
-
-    # Rescale all elements to be nonnegative
-    if rescale:
-        sequence = sequence - min(sequence)
-
-    res = sep.join([str(num) for num in sequence])
-    if space:
-        res = ' '.join(res)
-
-    return res
diff --git a/sigllm/primitives/prompting/gpt.py b/sigllm/primitives/prompting/gpt.py
index 3778336..f78bbe0 100644
--- a/sigllm/primitives/prompting/gpt.py
+++ b/sigllm/primitives/prompting/gpt.py
@@ -1,61 +1,117 @@
 # -*- coding: utf-8 -*-
 
-"""
-GPT model module.
-
-This module contains functions that are specifically used for GPT models
-"""
+import json
 import os
 
+import tiktoken
 from openai import OpenAI
-
-
-def load_system_prompt(file_path):
-    with open(file_path) as f:
-        system_prompt = f.read()
-    return system_prompt
-
-
-CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
-
-ZERO_SHOT_FILE = 'gpt_system_prompt_zero_shot.txt'
-ONE_SHOT_FILE = 'gpt_system_prompt_one_shot.txt'
-
-ZERO_SHOT_DIR = os.path.join(CURRENT_DIR, "..", "template", ZERO_SHOT_FILE)
-ONE_SHOT_DIR = os.path.join(CURRENT_DIR, "..", "template", ONE_SHOT_FILE)
-
-
-GPT_model = "gpt-4"  # "gpt-4-0125-preview" #  #  #"gpt-3.5-turbo" #
-client = OpenAI()
-
-
-def get_gpt_model_response(message, gpt_model=GPT_model):
-    completion = client.chat.completions.create(
-        model=gpt_model,
-        messages=message,
-    )
-    return completion.choices[0].message.content
-
-
-def create_message_zero_shot(seq_query, system_prompt_file=ZERO_SHOT_DIR):
-    messages = []
-
-    messages.append({"role": "system", "content": load_system_prompt(system_prompt_file)})
-
-    # final prompt
-    messages.append({"role": "user", "content": f"Sequence: {seq_query}"})
-    return messages
-
-
-def create_message_one_shot(seq_query, seq_ex, ano_idx_ex, system_prompt_file=ONE_SHOT_DIR):
-    messages = []
-
-    messages.append({"role": "system", "content": load_system_prompt(system_prompt_file)})
-
-    # one shot
-    messages.append({"role": "user", "content": f"Sequence: {seq_ex}"})
-    messages.append({"role": "assistant", "content": ano_idx_ex})
-
-    # final prompt
-    messages.append({"role": "user", "content": f"Sequence: {seq_query}"})
-    return messages
+from tqdm import tqdm
+
+PROMPT_PATH = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)),
+    'gpt_messages.json'
+)
+
+PROMPTS = json.load(open(PROMPT_PATH))
+
+VALID_NUMBERS = list("0123456789 ")
+BIAS = 30
+
+
+class GPT:
+    """Prompt GPT models to detect anomalies in a time series.
+
+    Args:
+        name (str):
+            Model name. Default to `'gpt-3.5-turbo'`.
+        sep (str):
+            String to separate each element in values. Default to `','`.
+        anomalous_percent (float):
+                Expected percentage of time series that are anomalous. Default to `0.5`.
+        temp (float):
+            Sampling temperature to use, between 0 and 2. Higher values like 0.8 will
+            make the output more random, while lower values like 0.2 will make it
+            more focused and deterministic. Do not use with `top_p`. Default to `1`.
+        top_p (float):
+            Alternative to sampling with temperature, called nucleus sampling, where the
+            model considers the results of the tokens with top_p probability mass.
+            So 0.1 means only the tokens comprising the top 10% probability mass are
+            considered. Do not use with `temp`. Default to `1`.
+        logprobs (bool):
+            Whether to return the log probabilities of the output tokens or not.
+            Defaults to `False`.
+        top_logprobs (int):
+            An integer between 0 and 20 specifying the number of most likely tokens
+            to return at each token position. Default to `None`.
+        samples (int):
+            Number of responses to generate for each input message. Default to `10`.
+        seed (int):
+            Beta feature by OpenAI to sample deterministically. Default to `None`.
+    """
+
+    def __init__(self, name='gpt-3.5-turbo', sep=',', anomalous_percent=0.5, temp=1,
+                 top_p=1, logprobs=False, top_logprobs=None, samples=10, seed=None):
+        self.name = name
+        self.sep = sep
+        self.anomalous_percent = anomalous_percent
+        self.temp = temp
+        self.top_p = top_p
+        self.logprobs = logprobs
+        self.top_logprobs = top_logprobs
+        self.samples = samples
+        self.seed = seed
+
+        self.tokenizer = tiktoken.encoding_for_model(self.name)
+
+        valid_tokens = []
+        for number in VALID_NUMBERS:
+            token = self.tokenizer.encode(number)
+            valid_tokens.extend(token)
+
+        valid_tokens.extend(self.tokenizer.encode(self.sep))
+        self.logit_bias = {token: BIAS for token in valid_tokens}
+
+        self.client = OpenAI()
+
+    def detect(self, X, **kwargs):
+        """Use GPT to forecast a signal.
+
+        Args:
+            X (ndarray):
+                Input sequences of strings containing signal values.
+
+        Returns:
+            list, list:
+                * List of detected anomalous values.
+                * Optionally, a list of the output tokens' log probabilities.
+        """
+        input_length = len(self.tokenizer.encode(X[0]))
+        max_tokens = int(input_length * float(self.anomalous_percent))
+
+        all_responses, all_probs = [], []
+        for text in tqdm(X):
+            message = ' '.join([PROMPTS['user_message'], text, self.sep])
+            response = self.client.chat.completions.create(
+                model=self.name,
+                messages=[
+                    {"role": "system", "content": PROMPTS['system_message']},
+                    {"role": "user", "content": message}
+                ],
+                max_tokens=max_tokens,
+                temperature=self.temp,
+                logprobs=self.logprobs,
+                top_logprobs=self.top_logprobs,
+                n=self.samples,
+                seed=self.seed
+            )
+            responses = [choice.message.content for choice in response.choices]
+            if self.logprobs:
+                probs = [choice.logprobs for choice in response.choices]
+                all_probs.append(probs)
+
+            all_responses.append(responses)
+
+        if self.logprobs:
+            return all_responses, all_probs
+
+        return all_responses
diff --git a/sigllm/primitives/prompting/gpt_messages.json b/sigllm/primitives/prompting/gpt_messages.json
new file mode 100644
index 0000000..064b6e0
--- /dev/null
+++ b/sigllm/primitives/prompting/gpt_messages.json
@@ -0,0 +1,4 @@
+{
+    "system_message": "You are an exceptionally intelligent assistant that detect anomalies in time series data by listing all the anomalies. Below is a sequence, please return the anomalies in that sequence in. Do not say anything like 'the anomalies in the sequence are', just return the numbers.",
+    "user_message": "Sequence:\n"
+}
\ No newline at end of file
diff --git a/sigllm/primitives/prompting/huggingface.py b/sigllm/primitives/prompting/huggingface.py
new file mode 100644
index 0000000..6143dbe
--- /dev/null
+++ b/sigllm/primitives/prompting/huggingface.py
@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*-
+
+import json
+import logging
+import os
+
+import torch
+from tqdm import tqdm
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+PROMPT_PATH = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)),
+    'huggingface_messages.json'
+)
+
+PROMPTS = json.load(open(PROMPT_PATH))
+
+LOGGER = logging.getLogger(__name__)
+
+DEFAULT_BOS_TOKEN = "<s>"
+DEFAULT_EOS_TOKEN = "</s>"
+DEFAULT_UNK_TOKEN = "<unk>"
+DEFAULT_PAD_TOKEN = "<pad>"
+
+VALID_NUMBERS = list("0123456789")
+
+DEFAULT_MODEL = 'mistralai/Mistral-7B-Instruct-v0.2'
+
+
+class HF:
+    """Prompt Pretrained models on HuggingFace to detect anomalies in a time series.
+
+    Args:
+        name (str):
+            Model name. Default to `'mistralai/Mistral-7B-Instruct-v0.2'`.
+        sep (str):
+            String to separate each element in values. Default to `','`.
+        anomalous_percent (float):
+            Expected percentage of time series that are anomalous. Default to `0.5`.
+        temp (float):
+            The value used to modulate the next token probabilities. Default to `1`.
+        top_p (float):
+            If set to float < 1, only the smallest set of most probable tokens with
+            probabilities that add up to `top_p` or higher are kept for generation.
+            Default to `1`.
+        raw (bool):
+            Whether to return the raw output or not. Defaults to `False`.
+        samples (int):
+            Number of responsed to generate for each input message. Default to `10`.
+        padding (int):
+            Additional padding token to forecast to reduce short horizon predictions.
+            Default to `0`.
+    """
+
+    def __init__(self, name=DEFAULT_MODEL, sep=',', anomalous_percent=0.5, temp=1, top_p=1,
+                 raw=False, samples=10, padding=0):
+        self.name = name
+        self.sep = sep
+        self.anomalous_percent = anomalous_percent
+        self.temp = temp
+        self.top_p = top_p
+        self.raw = raw
+        self.samples = samples
+        self.padding = padding
+
+        self.tokenizer = AutoTokenizer.from_pretrained(self.name, use_fast=False)
+
+        # special tokens
+        special_tokens_dict = dict()
+        if self.tokenizer.eos_token is None:
+            special_tokens_dict["eos_token"] = DEFAULT_EOS_TOKEN
+        if self.tokenizer.bos_token is None:
+            special_tokens_dict["bos_token"] = DEFAULT_BOS_TOKEN
+        if self.tokenizer.unk_token is None:
+            special_tokens_dict["unk_token"] = DEFAULT_UNK_TOKEN
+        if self.tokenizer.pad_token is None:
+            special_tokens_dict["pad_token"] = DEFAULT_PAD_TOKEN
+
+        self.tokenizer.add_special_tokens(special_tokens_dict)
+        self.tokenizer.pad_token = self.tokenizer.eos_token  # indicate the end of the time series
+
+        # invalid tokens
+        valid_tokens = []
+        for number in VALID_NUMBERS:
+            token = self.tokenizer.convert_tokens_to_ids(number)
+            valid_tokens.append(token)
+
+        valid_tokens.append(self.tokenizer.convert_tokens_to_ids(self.sep))
+        self.invalid_tokens = [[i]
+                               for i in range(len(self.tokenizer) - 1) if i not in valid_tokens]
+
+        self.model = AutoModelForCausalLM.from_pretrained(
+            self.name,
+            device_map="auto",
+            torch_dtype=torch.float16,
+        )
+
+        self.model.eval()
+
+    def detect(self, X, **kwargs):
+        """Use HF to detect anomalies of a signal.
+
+        Args:
+            X (ndarray):
+                Input sequences of strings containing signal values
+
+        Returns:
+            list, list:
+                * List of detected anomalous values.
+                * Optionally, a list of dictionaries for raw output.
+        """
+
+        input_length = len(self.tokenizer.encode(X[0].flatten().tolist()[0]))
+        max_tokens = input_length * float(self.anomalous_percent)
+        all_responses, all_generate_ids = [], []
+
+        for text in tqdm(X):
+            system_message = PROMPTS['system_message']
+            user_message = PROMPTS['user_message']
+            message = ' '.join([system_message, user_message, text, '[RESPONSE]'])
+
+            input_length = len(self.tokenizer.encode(message[0]))
+
+            tokenized_input = self.tokenizer(
+                message,
+                return_tensors="pt"
+            ).to("cuda")
+
+            generate_ids = self.model.generate(
+                **tokenized_input,
+                do_sample=True,
+                max_new_tokens=max_tokens,
+                temperature=self.temp,
+                top_p=self.top_p,
+                bad_words_ids=self.invalid_tokens,
+                renormalize_logits=True,
+                num_return_sequences=self.samples
+            )
+
+            responses = self.tokenizer.batch_decode(
+                generate_ids[:, input_length:],
+                skip_special_tokens=True,
+                clean_up_tokenization_spaces=False
+            )
+            all_responses.append(responses)
+            all_generate_ids.append(generate_ids)
+
+        if self.raw:
+            return all_responses, all_generate_ids
+
+        return all_responses
diff --git a/sigllm/primitives/prompting/huggingface_messages.json b/sigllm/primitives/prompting/huggingface_messages.json
new file mode 100644
index 0000000..3ad1dad
--- /dev/null
+++ b/sigllm/primitives/prompting/huggingface_messages.json
@@ -0,0 +1,4 @@
+{
+    "system_message": "You are an exceptionally intelligent assistant that detect anomalies in time series data by listing all the anomalies.",
+    "user_message": "Below is a [SEQUENCE], please return the anomalies in that sequence in [RESPONSE]. Only return the numbers. [SEQUENCE]"
+}
\ No newline at end of file
diff --git a/sigllm/primitives/prompting/timeseries_preprocessing.py b/sigllm/primitives/prompting/timeseries_preprocessing.py
new file mode 100644
index 0000000..b1aec5f
--- /dev/null
+++ b/sigllm/primitives/prompting/timeseries_preprocessing.py
@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+
+"""
+Data preprocessing module.
+
+This module contains functions that prepare timeseries for a language model.
+"""
+
+import numpy as np
+
+
+def rolling_window_sequences(X, window_size=500, step_size=100):
+    """Create rolling window sequences out of time series data.
+
+    This function creates an array of sequences by rolling over the input sequence.
+
+    Args:
+        X (ndarray):
+            The sequence to iterate over.
+        window_size (int):
+            Length of window. Defaults to 500
+        step_size (int):
+            Indicating the number of steps to move the window forward each round. Defaults to 100
+
+    Returns:
+        ndarray, ndarray:
+            * rolling window sequences.
+            * first index value of each input sequence.
+    """
+    index = range(len(X))
+    out_X = list()
+    X_index = list()
+
+    start = 0
+    max_start = len(X) - window_size + 1
+    while start < max_start:
+        end = start + window_size
+        out_X.append(X[start:end])
+        X_index.append(index[start])
+        start = start + step_size
+
+    return np.asarray(out_X), np.asarray(X_index), window_size, step_size
diff --git a/tests/primitives/prompting/test_anomalies.py b/tests/primitives/prompting/test_anomalies.py
index 7ca4d22..bd117c6 100644
--- a/tests/primitives/prompting/test_anomalies.py
+++ b/tests/primitives/prompting/test_anomalies.py
@@ -1,43 +1,26 @@
 # -*- coding: utf-8 -*-
 
 import numpy as np
-import pandas as pd
 from pytest import fixture
 
 from sigllm.primitives.prompting.anomalies import (
-    get_anomaly_list_within_seq, idx2time, merge_anomaly_seq, str2idx, str2sig,)
-
-
-@fixture
-def text():
-    return '1,2,3,4,5,6,7,8,9'
-
-
-@fixture
-def text_1():
-    return 'Result: 1 2 3, 2 3 4,'
-
-
-@fixture
-def text_float():
-    return 'Result: 1.23, 2.34,'
+    find_anomalies_in_windows, format_anomalies, merge_anomalous_sequences, val2idx,)
 
 
 @fixture
 def anomaly_list_within_seq():
-    return [np.array([2, 3, 7, 9]),
-            np.array([5]),
-            np.array([2, 5]),
-            np.array([8, 9])]
+    return np.array([[np.array([0, 3]), np.array([1]), np.array([1, 2])],
+                     [np.array([0]), np.array([1, 4]), np.array([2, 3])],
+                     [np.array([0, 2]), np.array([]), np.array([0, 1])]], dtype=object)
 
 
 @fixture
 def anomaly_list_across_seq():
-    return [np.array([0]),
-            np.array([1, 2]),
-            np.array([0, 2]),
-            np.array([1, 2]),
-            np.array([1])]
+    return np.array([np.array([0]),
+                     np.array([1, 2]),
+                     np.array([0, 2]),
+                     np.array([1, 2]),
+                     np.array([1])], dtype=object)
 
 
 @fixture
@@ -55,69 +38,67 @@ def step_size():
     return 1
 
 
-@fixture
-def signal():
-    d = {'timestamp': [1222819200, 1222840800, 1222862400, 1222884000,
-                       1222905600], 'value': [-1.0, -1.0, -1.0, -1.0, -1.0]}
-    return pd.DataFrame(data=d)
-
-
 @fixture
 def idx_list():
-    return np.array([0, 1, 3])
-
-
-def test_str2sig(text_float):
-    expected = np.array([0.123, 0.234])
-
-    result = str2sig(text_float, decimal=1)
-
-    np.testing.assert_allclose(result, expected, rtol=1e-15, atol=0)
+    return np.array([32, 545, 689, 1103, 1134])
 
 
-def test_str2idx(text):
-    expected = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
-
-    result = str2idx(text, len_seq=20)
-
-    np.testing.assert_equal(result, expected)
+@fixture
+def anomalous_val():
+    return np.array([[np.array([0, 3]), np.array([])],
+                    [np.array([2]), np.array([4])]], dtype=object)
 
 
-def test_str2idx_spurious(text_1):
-    expected = np.array([123, 234])
+@fixture
+def windows():
+    return np.array([[0, 1, 0, 3],
+                     [3, 2, 6, 2]])
 
-    result = str2idx(text_1, len_seq=500)
 
-    np.testing.assert_equal(result, expected)
+@fixture
+def timestamp():
+    return np.array(range(1000, 13000, 10))
 
 
-def test_str2idx_overflow(text):
-    expected = np.array([1, 2, 3, 4, 5, 6, 7])
+def test_ano_within_windows(anomaly_list_within_seq):
+    expected = np.array([np.array([1]),
+                         np.array([]),
+                         np.array([0])], dtype=object)
 
-    result = str2idx(text, len_seq=8)
+    result = find_anomalies_in_windows(anomaly_list_within_seq)
 
-    np.testing.assert_equal(result, expected)
+    for r, e in zip(result, expected):
+        np.testing.assert_equal(r, e)
 
 
-def test_get_anomaly_list_within_seq(anomaly_list_within_seq):
-    expected = np.array([2, 5, 9])
+def test_merge_anomaly_seq(anomaly_list_across_seq, first_indices, window_size, step_size):
+    expected = np.array([2, 4, 5])
 
-    result = get_anomaly_list_within_seq(anomaly_list_within_seq)
+    result = merge_anomalous_sequences(
+        anomaly_list_across_seq,
+        first_indices,
+        window_size,
+        step_size)
 
     np.testing.assert_equal(result, expected)
 
 
-def test_merge_anomaly_seq(anomaly_list_across_seq, first_indices, window_size, step_size):
-    expected = np.array([2, 4, 5])
+# val2idx
+def test_val2idx(anomalous_val, windows):
+    expected = np.array([[np.array([0, 2, 3]), np.array([])],
+                         [np.array([1, 3]), np.array([])]], dtype=object)
+    result = val2idx(anomalous_val, windows)
 
-    result = merge_anomaly_seq(anomaly_list_across_seq, first_indices, window_size, step_size)
-
-    np.testing.assert_equal(result, expected)
+    for r_list, e_list in zip(result, expected):
+        for r, e in zip(r_list, e_list):
+            np.testing.assert_equal(r, e)
 
+# timestamp2interval
 
-def test_idx2time(signal, idx_list):
-    expected = np.array([1222819200, 1222840800, 1222884000])
 
-    result = idx2time(signal, idx_list)
+def test_format_anomalies(idx_list, timestamp):
+    expected = [(1000, 1820, 0), (5950, 6950, 0), (7390, 8390, 0),
+                (11530, 12840, 0)]
+    result = format_anomalies(idx_list, timestamp)
 
-    np.testing.assert_equal(result, expected)
+    assert expected == result
diff --git a/tests/primitives/prompting/test_data.py b/tests/primitives/prompting/test_data.py
deleted file mode 100644
index d4f2c56..0000000
--- a/tests/primitives/prompting/test_data.py
+++ /dev/null
@@ -1,138 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import numpy as np
-from pytest import fixture
-
-from sigllm.primitives.prompting.data import rolling_window_sequences, sig2str
-
-
-@fixture
-def integers():
-    return np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
-
-
-@fixture
-def floats():
-    return np.array([
-        1.283,
-        2.424,
-        3.213,
-        4.583,
-        5.486,
-        6.284,
-        7.297,
-        8.023,
-        9.786
-    ])
-
-
-@fixture
-def negatives():
-    return np.array([
-        -2.5,
-        -1.5,
-        0,
-        1.5,
-        2.5,
-    ])
-
-
-@fixture
-def indices():
-    return np.array([0, 1, 2, 3, 4, 5, 6])
-
-
-@fixture
-def values():
-    return np.array([0.555, 2.345, 1.501, 5.903, 9.116, 3.068, 4.678])
-
-
-@fixture
-def window_size():
-    return 3
-
-
-@fixture
-def step_size():
-    return 1
-
-
-def test_sig2str(integers):
-    expected = '0,1,2,3,4,5,6,7,8'
-
-    result = sig2str(integers)
-
-    assert result == expected
-
-
-def test_sig2str_noscale(integers):
-    expected = '1,2,3,4,5,6,7,8,9'
-
-    result = sig2str(integers, rescale=False)
-
-    assert result == expected
-
-
-def test_sig2str_decimal(integers):
-    expected = '0,100,200,300,400,500,600,700,800'
-
-    result = sig2str(integers, decimal=2)
-
-    assert result == expected
-
-
-def test_sig2str_sep(integers):
-    expected = '0|1|2|3|4|5|6|7|8'
-
-    result = sig2str(integers, sep='|')
-
-    assert result == expected
-
-
-def test_sig2str_space(integers):
-    expected = '0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8'
-
-    result = sig2str(integers, space=True)
-
-    assert result == expected
-
-
-def test_sig2str_float(floats):
-    expected = '0,1,2,3,4,5,6,7,8'
-
-    result = sig2str(floats)
-
-    assert result == expected
-
-
-def test_sig2str_float_decimal(floats):
-    expected = '0,114,193,330,420,500,601,674,850'
-
-    result = sig2str(floats, decimal=2)
-
-    assert result == expected
-
-
-def test_sig2str_negative_decimal(negatives):
-    expected = '0,10,25,40,50'
-
-    result = sig2str(negatives, decimal=1)
-
-    assert result == expected
-
-
-def test_rolling_window_sequences(values, indices, window_size, step_size):
-    expected = (np.array([[0.555, 2.345, 1.501],
-                          [2.345, 1.501, 5.903],
-                          [1.501, 5.903, 9.116],
-                          [5.903, 9.116, 3.068],
-                          [9.116, 3.068, 4.678], ]),
-                np.array([0, 1, 2, 3, 4]))
-
-    result = rolling_window_sequences(values, indices, window_size, step_size)
-
-    if len(result) != len(expected):
-        raise AssertionError("Tuples has different length")
-
-    for arr1, arr2 in zip(result, expected):
-        np.testing.assert_equal(arr1, arr2)
diff --git a/tests/primitives/prompting/test_timeseries_preprocessing.py b/tests/primitives/prompting/test_timeseries_preprocessing.py
new file mode 100644
index 0000000..d16754a
--- /dev/null
+++ b/tests/primitives/prompting/test_timeseries_preprocessing.py
@@ -0,0 +1,38 @@
+import numpy as np
+from pytest import fixture
+
+from sigllm.primitives.prompting.timeseries_preprocessing import rolling_window_sequences
+
+
+@fixture
+def values():
+    return np.array([0.555, 2.345, 1.501, 5.903, 9.116, 3.068, 4.678])
+
+
+@fixture
+def window_size():
+    return 3
+
+
+@fixture
+def step_size():
+    return 1
+
+
+def test_rolling_window_sequences(values, window_size, step_size):
+    expected = (np.array([[0.555, 2.345, 1.501],
+                          [2.345, 1.501, 5.903],
+                          [1.501, 5.903, 9.116],
+                          [5.903, 9.116, 3.068],
+                          [9.116, 3.068, 4.678]]),
+                np.array([0, 1, 2, 3, 4]),
+                3,
+                1)
+
+    result = rolling_window_sequences(values, window_size, step_size)
+
+    if len(result) != len(expected):
+        raise AssertionError("Tuples has different length")
+
+    for arr1, arr2 in zip(result, expected):
+        np.testing.assert_equal(arr1, arr2)
diff --git a/tutorials/pipelines/gpt-prompter-pipeline.ipynb b/tutorials/pipelines/gpt-prompter-pipeline.ipynb
new file mode 100644
index 0000000..ed4ac5d
--- /dev/null
+++ b/tutorials/pipelines/gpt-prompter-pipeline.ipynb
@@ -0,0 +1,1026 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "76f73dbe-645a-4ed5-b042-ab14a1e330ea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import warnings; warnings.simplefilter('ignore')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "67b19cca-149e-4ec1-8cff-11e712c34c29",
+   "metadata": {},
+   "source": [
+    "This notebook requires access to OpenAI API to run.\n",
+    "## 1. Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "32c83a5a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1624, 2)"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from orion.data import load_signal\n",
+    "\n",
+    "data = load_signal('exchange-2_cpm_results')\n",
+    "data.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "8ae34e69",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "plt.plot(data['value']);"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "6b16f040-63b1-4171-8b1c-90c4d721d641",
+   "metadata": {},
+   "source": [
+    "if you want a quick test of how this pipeline works, uncomment the cell below to save time. We will look at a small segment of the time series."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "1029c7ee-8a42-4452-8bc0-20c0fb45b8d9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# start = 900\n",
+    "# end = start + 200\n",
+    "\n",
+    "# data = data.iloc[start: end]\n",
+    "\n",
+    "# plt.plot(data['value']);"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "409dabf0-be06-41fc-8793-01872c2a3055",
+   "metadata": {},
+   "source": [
+    "## 2. Pipeline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "262441fe-841b-4555-bf57-249305b59f92",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from mlblocks import MLPipeline\n",
+    "pipeline = MLPipeline('gpt_prompter')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "be80a076",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hyperparameters = {\n",
+    "    \"mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1\": {\n",
+    "        \"interval\": 3600\n",
+    "    }, \n",
+    "    \"sigllm.primitives.prompting.anomalies.find_anomalies_in_windows#1\": {\n",
+    "        \"alpha\": 0.5\n",
+    "    },\n",
+    "    \"sigllm.primitives.prompting.anomalies.merge_anomalous_sequences#1\": {\n",
+    "        \"beta\": 0.5\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "pipeline.set_hyperparameters(hyperparameters)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "d1190b42",
+   "metadata": {},
+   "source": [
+    "### step-by-step execution\n",
+    "\n",
+    "MLPipelines are compose of a squence of primitives, these primitives apply tranformation and calculation operations to the data and updates the variables within the pipeline. To view the primitives used by the pipeline, we access its primtivies attribute.\n",
+    "\n",
+    "The mistral-detector contains 10 primitives. we will observe how the context (which are the variables held within the pipeline) are updated after the execution of each primitive."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "2e548714",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['mlstars.custom.timeseries_preprocessing.time_segments_aggregate',\n",
+       " 'sklearn.impute.SimpleImputer',\n",
+       " 'sigllm.primitives.transformation.Float2Scalar',\n",
+       " 'sigllm.primitives.prompting.timeseries_preprocessing.rolling_window_sequences',\n",
+       " 'sigllm.primitives.transformation.format_as_string',\n",
+       " 'sigllm.primitives.prompting.gpt.GPT',\n",
+       " 'sigllm.primitives.transformation.format_as_integer',\n",
+       " 'sigllm.primitives.prompting.anomalies.val2idx',\n",
+       " 'sigllm.primitives.prompting.anomalies.find_anomalies_in_windows',\n",
+       " 'sigllm.primitives.prompting.anomalies.merge_anomalous_sequences',\n",
+       " 'sigllm.primitives.prompting.anomalies.format_anomalies']"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pipeline.primitives"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "af16a62a-c4cb-424f-bcdc-cdfaa0a51977",
+   "metadata": {},
+   "source": [
+    "#### time segment aggerate\n",
+    "this primitive creates an equi-spaced time series by aggregating values over fixed specified interval.\n",
+    "\n",
+    "* **input**: `X` which is an n-dimensional sequence of values.\n",
+    "* **output**:\n",
+    "    * `X` sequence of aggregated values, one column for each aggregation method.\n",
+    "    * `timestamp` sequence of timestamp values."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "f683c7f7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['X', 'timestamp'])"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 0\n",
+    "context = pipeline.fit(data, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "533566d5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "entry at 1309471201 has value [0.4010481]\n",
+      "entry at 1309474801 has value [0.39271888]\n",
+      "entry at 1309478401 has value [0.30999612]\n",
+      "entry at 1309482001 has value [0.21293855]\n",
+      "entry at 1309485601 has value [0.20580091]\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i, x in list(zip(context['timestamp'], context['X']))[:5]:\n",
+    "    print(\"entry at {} has value {}\".format(i, x))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "a488bc32",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1648, 1)"
+      ]
+     },
+     "execution_count": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['X'].shape"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "d7e8110b-6d0a-4e67-9346-5317f137b05c",
+   "metadata": {},
+   "source": [
+    "#### Single Imputer\n",
+    "this primitive is an imputation transformer for filling missing values.\n",
+    "\n",
+    "* **input**: `X` which is an n-dimensional sequence of values.\n",
+    "* **output**: `y` which is a transformed version of `X`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "35c41874",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'X'])"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 1\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "d4aa81d9-f6ee-49bd-894b-ec64445b7edb",
+   "metadata": {},
+   "source": [
+    "#### Float2Scalar\n",
+    "this primitive converts float values into scalar up to certain decimal points.\n",
+    "\n",
+    "* **input**: `y` which is an n-dimensional sequence of values in float type.\n",
+    "* **output**: `X` which is a transformed version of `y` in scalar."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "b49c4fbf",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'X', 'minimum', 'decimal'])"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 2\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "f7571fa1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "entry at 1309471201 has value [40]\n",
+      "entry at 1309474801 has value [39]\n",
+      "entry at 1309478401 has value [30]\n",
+      "entry at 1309482001 has value [21]\n",
+      "entry at 1309485601 has value [20]\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i, x in list(zip(context['timestamp'], context['X']))[:5]:\n",
+    "    print(\"entry at {} has value {}\".format(i, x))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "fd1a9ba6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.000385004945833"
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['minimum']"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "3914c439-0452-4151-93d2-9aa0ec0d3442",
+   "metadata": {},
+   "source": [
+    "#### Rolling Window\n",
+    "this primitive generates many sub-sequences of the original sequence. it uses a rolling window approach to create the sub-sequences out of time series data.\n",
+    "* **input**: `X` which is an 1-dimensional sequence to iterate over\n",
+    "* **output**: \n",
+    "    * `X` input sequences\n",
+    "    * `first_index`: first index value of each input sequences"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "bd160c3e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'minimum', 'decimal', 'X', 'first_index', 'window_size', 'step_size'])"
+      ]
+     },
+     "execution_count": 48,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 3\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "id": "ab08a9a9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "X shape = (37, 200, 1)\n",
+      "Timestamp shape = (1648,)\n",
+      "First index shape = (37,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# after slicing X into multiple sub-sequences\n",
+    "# we obtain a 3 dimensional matrix X where\n",
+    "# the shape indicates (# slices, window size, 1)\n",
+    "\n",
+    "print(\"X shape = {}\\nTimestamp shape = {}\\nFirst index shape = {}\".format(\n",
+    "    context['X'].shape, context['timestamp'].shape, context['first_index'].shape))"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "f201cbc8-0c88-4489-a7b0-b5060ac785a1",
+   "metadata": {},
+   "source": [
+    "#### Format as string\n",
+    "this primitive converts each sequence of scalar values into string. \n",
+    "* **input**: `X` which is an n-dimensional sequence of values\n",
+    "* **output**: `X_str` which is a string representation version of X"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "3a1836db-cd6f-4a39-8f00-6a09c620c5f0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'minimum', 'decimal', 'first_index', 'window_size', 'step_size', 'X', 'X_str'])"
+      ]
+     },
+     "execution_count": 50,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 4\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "1259df2c-d656-42a8-973c-b15cf8e031d4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'4 0 , 3 9 , 3 0 , 2 1 , 2 0 , 2 5 , 3 0 , 2 9 , 5 3 , 7 8 , 7 4 , 7 3 , 6 9 , 6 8 , 5 1 , 5 1 , 5 1 , 4 1 , 2 4 , 3 0 , 2 7 , 2 6 , 2 3 , 2 6 , 3 2 , 2 5 , 2 1 , 1 6 , 2 1 , 3 0 , 2 8 , 3 9 , 5 8 , 5 9 , 7 1 , 7 8 , 7 3 , 6 8 , 7 2 , 5 2 , 4 0 , 3 4 , 2 7 , 2 7 , 3 4 , 2 8 , 3 2 , 2 5 , 2 0 , 2 0 , 1 7 , 1 3 , 1 7 , 2 7 , 2 4 , 3 4 , 6 7 , 6 2 , 6 0 , 5 9 , 7 1 , 6 3 , 5 6 , 4 3 , 3 6 , 3 0 , 2 6 , 2 4 , 2 4 , 2 0 , 2 0 , 2 3 , 1 7 , 1 9 , 1 6 , 1 4 , 1 2 , 1 6 , 2 1 , 2 8 , 4 7 , 5 4 , 5 0 , 5 3 , 6 0 , 5 1 , 5 2 , 4 2 , 3 2 , 3 4 , 2 4 , 2 4 , 2 1 , 2 1 , 2 2 , 2 5 , 2 2 , 1 6 , 1 7 , 1 2 , 1 3 , 1 7 , 2 2 , 2 7 , 4 4 , 4 7 , 5 4 , 6 6 , 5 4 , 5 8 , 4 2 , 3 9 , 3 6 , 3 2 , 2 7 , 2 3 , 2 1 , 2 1 , 1 9 , 2 4 , 2 2 , 1 9 , 1 3 , 1 1 , 1 5 , 2 0 , 2 2 , 2 8 , 4 7 , 6 4 , 5 2 , 5 7 , 5 7 , 5 1 , 4 0 , 4 4 , 3 6 , 3 5 , 2 8 , 2 4 , 2 0 , 2 9 , 2 1 , 2 2 , 2 1 , 1 6 , 1 2 , 1 1 , 1 2 , 1 7 , 1 9 , 2 4 , 4 0 , 5 3 , 5 4 , 4 3 , 4 6 , 4 3 , 3 4 , 3 8 , 3 2 , 2 5 , 2 2 , 1 5 , 1 8 , 1 7 , 1 7 , 1 5 , 1 6 , 1 4 , 1 4 , 1 0 , 1 1 , 1 4 , 1 5 , 3 1 , 5 2 , 4 3 , 4 9 , 4 5 , 4 4 , 3 6 , 3 0 , 3 2 , 2 2 , 2 4 , 2 2 , 1 9 , 1 8 , 2 0 , 1 9 , 1 7 , 1 9 , 1 5 , 1 2 , 1 1 , 1 7 , 2 3 , 2 2 , 2 9'"
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['X_str'].flatten().tolist()[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "d05e85ce-6111-494f-88c0-4fc566386b43",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "str"
+      ]
+     },
+     "execution_count": 52,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type(context['X_str'][0][0])"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "a2411064",
+   "metadata": {},
+   "source": [
+    "when inspecting the time series, we can see that we have a single list consisting of 200 values (according the set `window_size`) and it is now of string type, ready to be an input to an LLM."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "7f403aca-ba56-42d3-bcae-b665a234c710",
+   "metadata": {},
+   "source": [
+    "#### GPT\n",
+    "this primitive prompts a gpt model to detect the anomalies\n",
+    "* **input**: `X_str` input sequence\n",
+    "* **output**: `y_hat` detected anomalous values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "b4711e98-c522-4464-b645-607f76e89063",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████| 37/37 [01:04<00:00,  1.74s/it]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'minimum', 'decimal', 'first_index', 'window_size', 'step_size', 'X_str', 'X', 'y_hat'])"
+      ]
+     },
+     "execution_count": 53,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 5\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "id": "d587d1d3-9325-4d45-9e15-d69d2d16bb6d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(37, 10)"
+      ]
+     },
+     "execution_count": 54,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(context['y_hat']), len(context['y_hat'][0])"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "dc70e55b-4a3e-43d8-83f8-b998fa88ee29",
+   "metadata": {},
+   "source": [
+    "#### format as integer\n",
+    "this primitive converts each sequences of string values into integers.\n",
+    "* **input**: `y_hat` which is a sequence of string values\n",
+    "* **output**: `y` which is an integer representation version of `y_hat`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "5ac4fc58-055d-4210-b330-0832508c1cf4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'minimum', 'decimal', 'first_index', 'window_size', 'step_size', 'X_str', 'y_hat', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 6\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "id": "a934005e-5bce-4a47-831a-3cf1f0c92f28",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(37, 10)"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['y'].shape"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "6b1ff549-c823-4a31-b324-19ee21a8c193",
+   "metadata": {},
+   "source": [
+    "#### Val2Idx\n",
+    "this primitive converts integer values into indices they appear in the sequence\n",
+    "* **input**: \n",
+    "    * `y` sequences of anomalous values\n",
+    "    * `X` input sequences\n",
+    "* **output**: \n",
+    "    * `y` sequences of anomalous indices"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "id": "32b4ccf9-d8fa-4110-bc22-717d07e3ae0b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'minimum', 'decimal', 'first_index', 'window_size', 'step_size', 'X_str', 'y_hat', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 7\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "id": "339db91e-cd35-4ae8-abc5-3ba52b6c0bbd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(37, 10)"
+      ]
+     },
+     "execution_count": 58,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['y'].shape"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "bbcf3479-7ff2-4a81-86c0-e678a8f735c6",
+   "metadata": {},
+   "source": [
+    "#### find_anomalies_in_windows\n",
+    "* **input**: `y` n-dimensional array of multiple anomalous indices sequences\n",
+    "* **output**: `y` array of each window's anomalous indices sequences"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "id": "17ce8982-2ba3-4508-a526-8a9960e0ecd3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'minimum', 'decimal', 'first_index', 'window_size', 'step_size', 'X_str', 'y_hat', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 59,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 8\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "id": "5274e7a0-acf5-4b9f-9cb4-070357fc7c10",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(37,)"
+      ]
+     },
+     "execution_count": 60,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['y'].shape"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "03002457-e136-445d-811a-97c20eb47d5d",
+   "metadata": {},
+   "source": [
+    "#### merge_anomalous_sequences\n",
+    "* **input**: \n",
+    "    * `y` array of each window's anomalous indices sequences\n",
+    "    * `first_index` first indices of input sequences\n",
+    "    * `window_size` size of each window\n",
+    "    * `step_size` step of rolling windows\n",
+    "* **output**: \n",
+    "    * `y` anomalous indices of the input timeseries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "id": "bd219c08-29b2-4809-934b-287dfac4e4fa",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'minimum', 'decimal', 'first_index', 'window_size', 'step_size', 'X_str', 'y_hat', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 61,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 9\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "id": "57f900db-d712-4ff1-986b-7f4dc1accda0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(11,)"
+      ]
+     },
+     "execution_count": 62,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['y'].shape"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "2eeac9a9-613a-43b8-abd9-6e455bf82a62",
+   "metadata": {},
+   "source": [
+    "#### format_anomalies\n",
+    "* **input**: \n",
+    "    * `y` sequence of anomalous indices\n",
+    "    * `timestamp` sequence of timestamp of the input series\n",
+    "* **output**:\n",
+    "    * `anomalies` array containing start-index, end-index, score for each anomalous sequence that was found"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "id": "7de109bd-8306-4753-8446-07f438e8c3e8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'minimum', 'decimal', 'first_index', 'window_size', 'step_size', 'X_str', 'y_hat', 'X', 'y', 'anomalies'])"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 10\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "id": "a37daebf-7091-4dab-93dc-928c7163778b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[(1310162401, 1310529601, 0),\n",
+       " (1311472801, 1312142401, 0),\n",
+       " (1312178401, 1312538401, 0),\n",
+       " (1312948801, 1313308801, 0),\n",
+       " (1313877601, 1314241201, 0),\n",
+       " (1314399601, 1314759601, 0)]"
+      ]
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['anomalies']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "id": "60064037-5ed6-49f3-ae13-5f4952f5eabf",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>start</th>\n",
+       "      <th>end</th>\n",
+       "      <th>score</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1310162401</td>\n",
+       "      <td>1310529601</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1311472801</td>\n",
+       "      <td>1312142401</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1312178401</td>\n",
+       "      <td>1312538401</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>1312948801</td>\n",
+       "      <td>1313308801</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>1313877601</td>\n",
+       "      <td>1314241201</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>1314399601</td>\n",
+       "      <td>1314759601</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        start         end  score\n",
+       "0  1310162401  1310529601      0\n",
+       "1  1311472801  1312142401      0\n",
+       "2  1312178401  1312538401      0\n",
+       "3  1312948801  1313308801      0\n",
+       "4  1313877601  1314241201      0\n",
+       "5  1314399601  1314759601      0"
+      ]
+     },
+     "execution_count": 65,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "pd.DataFrame(context['anomalies'], columns=['start', 'end', 'score'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "id": "98b221ef-ff0c-4705-9697-e2d240ff756e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "index, anomalies = list(map(context.get, ['timestamp', 'anomalies']))\n",
+    "\n",
+    "plt.plot(data['timestamp'], data['value'], label='original')\n",
+    "\n",
+    "for ano in anomalies:\n",
+    "\n",
+    "    plt.axvspan(*ano[:2], color='r', alpha=0.2, label='detected anomalies')\n",
+    "plt.legend();"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "prompter",
+   "language": "python",
+   "name": "prompter"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tutorials/pipelines/mistral-prompter-pipeline.ipynb b/tutorials/pipelines/mistral-prompter-pipeline.ipynb
new file mode 100644
index 0000000..c6b7928
--- /dev/null
+++ b/tutorials/pipelines/mistral-prompter-pipeline.ipynb
@@ -0,0 +1,1130 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "76f73dbe-645a-4ed5-b042-ab14a1e330ea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import warnings; warnings.simplefilter('ignore')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "67b19cca-149e-4ec1-8cff-11e712c34c29",
+   "metadata": {},
+   "source": [
+    "This notebook requires **gpu** to run. See [mistral documentation](https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.2) for memory requirements.\n",
+    "## 1. Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "32c83a5a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1624, 2)"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from orion.data import load_signal\n",
+    "\n",
+    "data = load_signal('exchange-2_cpm_results')\n",
+    "data.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "8ae34e69",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "plt.plot(data['value']);"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "6b16f040-63b1-4171-8b1c-90c4d721d641",
+   "metadata": {},
+   "source": [
+    "if you want a quick test of how this pipeline works, uncomment the cell below to save time. We will look at a small segment of the time series."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1029c7ee-8a42-4452-8bc0-20c0fb45b8d9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# start = 900\n",
+    "# end = start + 200\n",
+    "\n",
+    "# data = data.iloc[start: end]\n",
+    "\n",
+    "# plt.plot(data['value']);"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "409dabf0-be06-41fc-8793-01872c2a3055",
+   "metadata": {},
+   "source": [
+    "## 2. Pipeline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "262441fe-841b-4555-bf57-249305b59f92",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9be9a9c4412a47fba8a20063766571f5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from mlblocks import MLPipeline\n",
+    "pipeline = MLPipeline('mistral_prompter')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "id": "be80a076",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hyperparameters = {\n",
+    "    \"mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1\": {\n",
+    "        \"interval\": 3600\n",
+    "    }, \n",
+    "    \"sigllm.primitives.prompting.anomalies.find_anomalies_in_windows#1\": {\n",
+    "        \"alpha\": 1.0\n",
+    "    },\n",
+    "    \"sigllm.primitives.prompting.anomalies.merge_anomalous_sequences#1\": {\n",
+    "        \"beta\": 1.0\n",
+    "    },\n",
+    "    \"sigllm.primitives.prompting.timeseries_preprocessing.rolling_window_sequences#1\": {\n",
+    "            \"window_size\": 200,\n",
+    "            \"step_size\": 150\n",
+    "    },\n",
+    "    \"sigllm.primitives.prompting.anomalies.format_anomalies#1\": {\n",
+    "        \"padding_size\": 5\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "pipeline.set_hyperparameters(hyperparameters)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "9292817b-75d5-4526-a1b8-7475bcb787c5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1': {'interval': 3600,\n",
+       "  'time_column': 'timestamp',\n",
+       "  'method': 'mean'},\n",
+       " 'sklearn.impute.SimpleImputer#1': {'missing_values': nan,\n",
+       "  'fill_value': None,\n",
+       "  'verbose': False,\n",
+       "  'copy': True,\n",
+       "  'strategy': 'mean'},\n",
+       " 'sigllm.primitives.transformation.Float2Scalar#1': {'decimal': 2,\n",
+       "  'rescale': True},\n",
+       " 'sigllm.primitives.prompting.timeseries_preprocessing.rolling_window_sequences#1': {'window_size': 200,\n",
+       "  'step_size': 150},\n",
+       " 'sigllm.primitives.transformation.format_as_string#1': {'sep': ',',\n",
+       "  'space': False},\n",
+       " 'sigllm.primitives.prompting.huggingface.HF#1': {'name': 'mistralai/Mistral-7B-Instruct-v0.2',\n",
+       "  'sep': ',',\n",
+       "  'anomalous_percent': '0.5',\n",
+       "  'temp': 1,\n",
+       "  'top_p': 1,\n",
+       "  'raw': False,\n",
+       "  'samples': 10,\n",
+       "  'padding': 0},\n",
+       " 'sigllm.primitives.transformation.format_as_integer#1': {'sep': ',',\n",
+       "  'trunc': None,\n",
+       "  'errors': 'ignore'},\n",
+       " 'sigllm.primitives.prompting.anomalies.val2idx#1': {},\n",
+       " 'sigllm.primitives.prompting.anomalies.find_anomalies_in_windows#1': {'alpha': 1.0},\n",
+       " 'sigllm.primitives.prompting.anomalies.merge_anomalous_sequences#1': {'beta': 1.0},\n",
+       " 'sigllm.primitives.prompting.anomalies.format_anomalies#1': {'padding_size': 0}}"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pipeline.get_hyperparameters()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "d1190b42",
+   "metadata": {},
+   "source": [
+    "### step-by-step execution\n",
+    "\n",
+    "MLPipelines are compose of a squence of primitives, these primitives apply tranformation and calculation operations to the data and updates the variables within the pipeline. To view the primitives used by the pipeline, we access its primtivies attribute.\n",
+    "\n",
+    "The mistral-detector contains 10 primitives. we will observe how the context (which are the variables held within the pipeline) are updated after the execution of each primitive."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "2e548714",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['mlstars.custom.timeseries_preprocessing.time_segments_aggregate',\n",
+       " 'sklearn.impute.SimpleImputer',\n",
+       " 'sigllm.primitives.transformation.Float2Scalar',\n",
+       " 'sigllm.primitives.prompting.timeseries_preprocessing.rolling_window_sequences',\n",
+       " 'sigllm.primitives.transformation.format_as_string',\n",
+       " 'sigllm.primitives.prompting.huggingface.HF',\n",
+       " 'sigllm.primitives.transformation.format_as_integer',\n",
+       " 'sigllm.primitives.prompting.anomalies.val2idx',\n",
+       " 'sigllm.primitives.prompting.anomalies.find_anomalies_in_windows',\n",
+       " 'sigllm.primitives.prompting.anomalies.merge_anomalous_sequences',\n",
+       " 'sigllm.primitives.prompting.anomalies.format_anomalies']"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pipeline.primitives"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "af16a62a-c4cb-424f-bcdc-cdfaa0a51977",
+   "metadata": {},
+   "source": [
+    "#### time segment aggerate\n",
+    "this primitive creates an equi-spaced time series by aggregating values over fixed specified interval.\n",
+    "\n",
+    "* **input**: `X` which is an n-dimensional sequence of values.\n",
+    "* **output**:\n",
+    "    * `X` sequence of aggregated values, one column for each aggregation method.\n",
+    "    * `timestamp` sequence of timestamp values."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "f683c7f7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['X', 'timestamp'])"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 0\n",
+    "context = pipeline.fit(data, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "533566d5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "entry at 1309471201 has value [0.4010481]\n",
+      "entry at 1309474801 has value [0.39271888]\n",
+      "entry at 1309478401 has value [0.30999612]\n",
+      "entry at 1309482001 has value [0.21293855]\n",
+      "entry at 1309485601 has value [0.20580091]\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i, x in list(zip(context['timestamp'], context['X']))[:5]:\n",
+    "    print(\"entry at {} has value {}\".format(i, x))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "a488bc32",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1648, 1)"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['X'].shape"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "d7e8110b-6d0a-4e67-9346-5317f137b05c",
+   "metadata": {},
+   "source": [
+    "#### Single Imputer\n",
+    "this primitive is an imputation transformer for filling missing values.\n",
+    "\n",
+    "* **input**: `X` which is an n-dimensional sequence of values.\n",
+    "* **output**: `y` which is a transformed version of `X`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "35c41874",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'X'])"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 1\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "d4aa81d9-f6ee-49bd-894b-ec64445b7edb",
+   "metadata": {},
+   "source": [
+    "#### Float2Scalar\n",
+    "this primitive converts float values into scalar up to certain decimal points.\n",
+    "\n",
+    "* **input**: `y` which is an n-dimensional sequence of values in float type.\n",
+    "* **output**: `X` which is a transformed version of `y` in scalar."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "b49c4fbf",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'X', 'minimum', 'decimal'])"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 2\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "f7571fa1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "entry at 1309471201 has value [40]\n",
+      "entry at 1309474801 has value [39]\n",
+      "entry at 1309478401 has value [30]\n",
+      "entry at 1309482001 has value [21]\n",
+      "entry at 1309485601 has value [20]\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i, x in list(zip(context['timestamp'], context['X']))[:5]:\n",
+    "    print(\"entry at {} has value {}\".format(i, x))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "fd1a9ba6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.000385004945833"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['minimum']"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "3914c439-0452-4151-93d2-9aa0ec0d3442",
+   "metadata": {},
+   "source": [
+    "#### Rolling Window\n",
+    "this primitive generates many sub-sequences of the original sequence. it uses a rolling window approach to create the sub-sequences out of time series data.\n",
+    "* **input**: `X` which is an 1-dimensional sequence to iterate over\n",
+    "* **output**: \n",
+    "    * `X` input sequences\n",
+    "    * `first_index`: first index value of each input sequences"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "bd160c3e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'minimum', 'decimal', 'X', 'first_index', 'window_size', 'step_size'])"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 3\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "ab08a9a9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "X shape = (10, 200, 1)\n",
+      "Timestamp shape = (1648,)\n",
+      "First index shape = (10,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# after slicing X into multiple sub-sequences\n",
+    "# we obtain a 3 dimensional matrix X where\n",
+    "# the shape indicates (# slices, window size, 1)\n",
+    "\n",
+    "print(\"X shape = {}\\nTimestamp shape = {}\\nFirst index shape = {}\".format(\n",
+    "    context['X'].shape, context['timestamp'].shape, context['first_index'].shape))"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "f201cbc8-0c88-4489-a7b0-b5060ac785a1",
+   "metadata": {},
+   "source": [
+    "#### Format as string\n",
+    "this primitive converts each sequence of scalar values into string. \n",
+    "* **input**: `X` which is an n-dimensional sequence of values\n",
+    "* **output**: `X_str` which is a string representation version of X"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "3a1836db-cd6f-4a39-8f00-6a09c620c5f0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'minimum', 'decimal', 'first_index', 'window_size', 'step_size', 'X', 'X_str'])"
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 4\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "1259df2c-d656-42a8-973c-b15cf8e031d4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'40,39,30,21,20,25,30,29,53,78,74,73,69,68,51,51,51,41,24,30,27,26,23,26,32,25,21,16,21,30,28,39,58,59,71,78,73,68,72,52,40,34,27,27,34,28,32,25,20,20,17,13,17,27,24,34,67,62,60,59,71,63,56,43,36,30,26,24,24,20,20,23,17,19,16,14,12,16,21,28,47,54,50,53,60,51,52,42,32,34,24,24,21,21,22,25,22,16,17,12,13,17,22,27,44,47,54,66,54,58,42,39,36,32,27,23,21,21,19,24,22,19,13,11,15,20,22,28,47,64,52,57,57,51,40,44,36,35,28,24,20,29,21,22,21,16,12,11,12,17,19,24,40,53,54,43,46,43,34,38,32,25,22,15,18,17,17,15,16,14,14,10,11,14,15,31,52,43,49,45,44,36,30,32,22,24,22,19,18,20,19,17,19,15,12,11,17,23,22,29'"
+      ]
+     },
+     "execution_count": 48,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['X_str'].flatten().tolist()[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "id": "d05e85ce-6111-494f-88c0-4fc566386b43",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "str"
+      ]
+     },
+     "execution_count": 49,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type(context['X_str'][0][0])"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "a2411064",
+   "metadata": {},
+   "source": [
+    "when inspecting the time series, we can see that we have a single list consisting of 200 values (according the set `window_size`) and it is now of string type, ready to be an input to an LLM."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "7f403aca-ba56-42d3-bcae-b665a234c710",
+   "metadata": {},
+   "source": [
+    "#### HF\n",
+    "this primitive prompts a huggingface model to detect the anomalies\n",
+    "* **input**: `X_str` input sequence\n",
+    "* **output**: `y_hat` detected anomalous values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "b4711e98-c522-4464-b645-607f76e89063",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|                                                    | 0/10 [00:00<?, ?it/s]Setting `pad_token_id` to `eos_token_id`:2 for open-end generation.\n",
+      " 10%|████▍                                       | 1/10 [00:23<03:27, 23.09s/it]Setting `pad_token_id` to `eos_token_id`:2 for open-end generation.\n",
+      " 20%|████████▊                                   | 2/10 [00:46<03:04, 23.00s/it]Setting `pad_token_id` to `eos_token_id`:2 for open-end generation.\n",
+      " 30%|█████████████▏                              | 3/10 [01:08<02:40, 22.98s/it]Setting `pad_token_id` to `eos_token_id`:2 for open-end generation.\n",
+      " 40%|█████████████████▌                          | 4/10 [01:31<02:17, 22.97s/it]Setting `pad_token_id` to `eos_token_id`:2 for open-end generation.\n",
+      " 50%|██████████████████████                      | 5/10 [01:54<01:54, 22.99s/it]Setting `pad_token_id` to `eos_token_id`:2 for open-end generation.\n",
+      " 60%|██████████████████████████▍                 | 6/10 [02:17<01:31, 22.99s/it]Setting `pad_token_id` to `eos_token_id`:2 for open-end generation.\n",
+      " 70%|██████████████████████████████▊             | 7/10 [02:40<01:08, 22.99s/it]Setting `pad_token_id` to `eos_token_id`:2 for open-end generation.\n",
+      " 80%|███████████████████████████████████▏        | 8/10 [03:03<00:45, 22.99s/it]Setting `pad_token_id` to `eos_token_id`:2 for open-end generation.\n",
+      " 90%|███████████████████████████████████████▌    | 9/10 [03:26<00:22, 23.00s/it]Setting `pad_token_id` to `eos_token_id`:2 for open-end generation.\n",
+      "100%|███████████████████████████████████████████| 10/10 [03:49<00:00, 23.00s/it]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'minimum', 'decimal', 'first_index', 'window_size', 'step_size', 'X_str', 'X', 'y_hat'])"
+      ]
+     },
+     "execution_count": 50,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 5\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "d587d1d3-9325-4d45-9e15-d69d2d16bb6d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(10, 10)"
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(context['y_hat']), len(context['y_hat'][0])"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "dc70e55b-4a3e-43d8-83f8-b998fa88ee29",
+   "metadata": {},
+   "source": [
+    "#### format as integer\n",
+    "this primitive converts each sequences of string values into integers.\n",
+    "* **input**: `y_hat` which is a sequence of string values\n",
+    "* **output**: `y` which is an integer representation version of `y_hat`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "5ac4fc58-055d-4210-b330-0832508c1cf4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'minimum', 'decimal', 'first_index', 'window_size', 'step_size', 'X_str', 'y_hat', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 52,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 6\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "a934005e-5bce-4a47-831a-3cf1f0c92f28",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(10, 10)"
+      ]
+     },
+     "execution_count": 53,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['y'].shape"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "6b1ff549-c823-4a31-b324-19ee21a8c193",
+   "metadata": {},
+   "source": [
+    "#### Val2Idx\n",
+    "this primitive converts integer values into indices they appear in the sequence\n",
+    "* **input**: \n",
+    "    * `y` sequences of anomalous values\n",
+    "    * `X` input sequences\n",
+    "* **output**: \n",
+    "    * `y` sequences of anomalous indices"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "id": "32b4ccf9-d8fa-4110-bc22-717d07e3ae0b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'minimum', 'decimal', 'first_index', 'window_size', 'step_size', 'X_str', 'y_hat', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 54,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 7\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "339db91e-cd35-4ae8-abc5-3ba52b6c0bbd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(10, 10)"
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['y'].shape"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "bbcf3479-7ff2-4a81-86c0-e678a8f735c6",
+   "metadata": {},
+   "source": [
+    "#### find_anomalies_in_windows\n",
+    "* **input**: `y` n-dimensional array of multiple anomalous indices sequences\n",
+    "* **output**: `y` array of each window's anomalous indices sequences"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "id": "17ce8982-2ba3-4508-a526-8a9960e0ecd3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'minimum', 'decimal', 'first_index', 'window_size', 'step_size', 'X_str', 'y_hat', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 8\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "id": "5274e7a0-acf5-4b9f-9cb4-070357fc7c10",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(10,)"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['y'].shape"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "03002457-e136-445d-811a-97c20eb47d5d",
+   "metadata": {},
+   "source": [
+    "#### merge_anomalous_sequences\n",
+    "* **input**: \n",
+    "    * `y` array of each window's anomalous indices sequences\n",
+    "    * `first_index` first indices of input sequences\n",
+    "    * `window_size` size of each window\n",
+    "    * `step_size` step of rolling windows\n",
+    "* **output**: \n",
+    "    * `y` anomalous indices of the input timeseries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "id": "bd219c08-29b2-4809-934b-287dfac4e4fa",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'minimum', 'decimal', 'first_index', 'window_size', 'step_size', 'X_str', 'y_hat', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 58,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 9\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "id": "57f900db-d712-4ff1-986b-7f4dc1accda0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(449,)"
+      ]
+     },
+     "execution_count": 59,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['y'].shape"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "2eeac9a9-613a-43b8-abd9-6e455bf82a62",
+   "metadata": {},
+   "source": [
+    "#### format_anomalies\n",
+    "* **input**: \n",
+    "    * `y` sequence of anomalous indices\n",
+    "    * `timestamp` sequence of timestamp of the input series\n",
+    "* **output**:\n",
+    "    * `anomalies` array containing start-index, end-index, score for each anomalous sequence that was found"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "id": "7de109bd-8306-4753-8446-07f438e8c3e8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['timestamp', 'minimum', 'decimal', 'first_index', 'window_size', 'step_size', 'X_str', 'y_hat', 'anomalies', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 66,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 10\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "id": "a37daebf-7091-4dab-93dc-928c7163778b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "9"
+      ]
+     },
+     "execution_count": 67,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(context['anomalies'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "id": "60064037-5ed6-49f3-ae13-5f4952f5eabf",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>start</th>\n",
+       "      <th>end</th>\n",
+       "      <th>score</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1309993201</td>\n",
+       "      <td>1310205601</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1310536801</td>\n",
+       "      <td>1310745601</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1311073201</td>\n",
+       "      <td>1311285601</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>1311613201</td>\n",
+       "      <td>1311825601</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>1312153201</td>\n",
+       "      <td>1312365601</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>1312693201</td>\n",
+       "      <td>1312905601</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>1313233201</td>\n",
+       "      <td>1313445601</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>1313773201</td>\n",
+       "      <td>1313985601</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>1314313201</td>\n",
+       "      <td>1314525601</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        start         end  score\n",
+       "0  1309993201  1310205601      0\n",
+       "1  1310536801  1310745601      0\n",
+       "2  1311073201  1311285601      0\n",
+       "3  1311613201  1311825601      0\n",
+       "4  1312153201  1312365601      0\n",
+       "5  1312693201  1312905601      0\n",
+       "6  1313233201  1313445601      0\n",
+       "7  1313773201  1313985601      0\n",
+       "8  1314313201  1314525601      0"
+      ]
+     },
+     "execution_count": 68,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "pd.DataFrame(context['anomalies'], columns=['start', 'end', 'score'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "id": "98b221ef-ff0c-4705-9697-e2d240ff756e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "index, anomalies = list(map(context.get, ['timestamp', 'anomalies']))\n",
+    "\n",
+    "plt.plot(data['timestamp'], data['value'], label='original')\n",
+    "\n",
+    "for ano in anomalies:\n",
+    "    plt.axvspan(*ano[:2], color='r', alpha=0.2, label='detected anomalies')\n",
+    "plt.legend(['original', 'detected anomalies']);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee002d85-571a-4ecd-8f9d-99cb84808d7f",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "prompter",
+   "language": "python",
+   "name": "prompter"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}