diff --git a/river/Diapo_ConformalPrediction.pdf b/river/Diapo_ConformalPrediction.pdf
new file mode 100644
index 0000000000..aedf0c1afc
Binary files /dev/null and b/river/Diapo_ConformalPrediction.pdf differ
diff --git a/river/Notebook_ConformalPrediction.ipynb b/river/Notebook_ConformalPrediction.ipynb
new file mode 100644
index 0000000000..089495761c
--- /dev/null
+++ b/river/Notebook_ConformalPrediction.ipynb
@@ -0,0 +1,940 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "1e022215",
+   "metadata": {},
+   "source": [
+    "# Presentation : Conformal prediction implementation in River\n",
+    "\n",
+    "- BOGGIO Richard\n",
+    "- MDIHI Samy\n",
+    "- VERON Marc"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c63f4c7e",
+   "metadata": {},
+   "source": [
+    "This notebook is a presentation of the possibilities offered by the implementation of Conformal Prediction in the River framework. We rely on the paper by Margaux Zaffran et al. \"Adaptative Conformal Predictions for Time series\" (https://arxiv.org/abs/2202.07282). This paper has 2 parts: expert aggregation for regression or classification, and the definition of confidence intervals on streaming data. We focus here on the implementation in River of these confidence interval estimation techniques. We rely on the work of the research group, visible on github : https://github.com/mzaffran/AdaptiveConformalPredictionsTimeSeries\n",
+    "\n",
+    "Quick Vocabulary: Conformal prediction is a general term for identifying confidence interval definition methods in machine learning that go beyond the simple gaussian approach. \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a812264c",
+   "metadata": {},
+   "source": [
+    "So we first increased the conf module. This one is present on the River git repo, but is not deployed on the downloadable version of Python. These are the parent classes of the interval methods that can be used in different regression models. Next, we augment the time_series module, in which we update the evaluation method to allow for intervals at different horizons. Indeed the logic of this module is to predict not only at horizon 1, but further. The calculation of intervals must therefore be integrated into this logic, hence the basic definition in conf. \n",
+    "\n",
+    "To ensure the integration of all these methods, we have updated the **\\_\\_init\\_\\_** files and the **base** files. This allows us to have an almost functional environment. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5625a67e",
+   "metadata": {},
+   "source": [
+    "## Modules imports"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c416ee1b",
+   "metadata": {},
+   "source": [
+    "The modules that have been modified in River are the below : \n",
+    "- In **conf** : base.py contains the Interval class, the mother for the interval methods (gaussian, CP, ACP)\n",
+    "- **time_series** : Intervals is the mother class that allows to apply the interval method at every horizon. To do so we replicated the metrics.py template. Also contains evaluates, hoeffding_horizon"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "f15ae695",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Existing in River\n",
+    "from river import datasets, metrics, stream\n",
+    "from river import tree, utils\n",
+    "from river import optim\n",
+    "from river import stats \n",
+    "from river import preprocessing\n",
+    "\n",
+    "# Not existing in River\n",
+    "import conf.ACP\n",
+    "import conf.CP\n",
+    "import conf.gaussian\n",
+    "import time_series\n",
+    "import time_series.evaluates\n",
+    "from time_series.holt_winters import HoltWinters\n",
+    "from time_series.hoeffding_horizon import HoeffdingTreeHorizon\n",
+    "from time_series.evaluates import _iter_with_horizon\n",
+    "\n",
+    "# Other \n",
+    "import pandas as pd\n",
+    "import numpy as np \n",
+    "import matplotlib.pyplot as plt\n",
+    "import timeit\n",
+    "import time\n",
+    "from scipy.stats import norm\n",
+    "from ipywidgets import widgets, interact"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "211aef49",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['ACP',\n",
+       " 'AdaptativeConformalPrediction',\n",
+       " 'CP',\n",
+       " 'ConformalPrediction',\n",
+       " 'Gaussian',\n",
+       " 'Interval',\n",
+       " 'RegressionJackknife',\n",
+       " '__all__',\n",
+       " '__builtins__',\n",
+       " '__cached__',\n",
+       " '__doc__',\n",
+       " '__file__',\n",
+       " '__loader__',\n",
+       " '__name__',\n",
+       " '__package__',\n",
+       " '__path__',\n",
+       " '__spec__',\n",
+       " 'base',\n",
+       " 'gaussian',\n",
+       " 'jackknife']"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dir(conf)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "736574b7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['ForecastingInterval',\n",
+       " 'ForecastingMetric',\n",
+       " 'HoeffdingTreeHorizon',\n",
+       " 'HoltWinters',\n",
+       " 'HorizonAggMetric',\n",
+       " 'HorizonInterval',\n",
+       " 'HorizonMetric',\n",
+       " 'SNARIMAX',\n",
+       " '__all__',\n",
+       " '__builtins__',\n",
+       " '__cached__',\n",
+       " '__doc__',\n",
+       " '__file__',\n",
+       " '__loader__',\n",
+       " '__name__',\n",
+       " '__package__',\n",
+       " '__path__',\n",
+       " '__spec__',\n",
+       " '_iter_with_horizon',\n",
+       " 'base',\n",
+       " 'evaluate',\n",
+       " 'evaluates',\n",
+       " 'get_iter_evaluate',\n",
+       " 'hoeffding_horizon',\n",
+       " 'holt_winters',\n",
+       " 'intervals',\n",
+       " 'iter_evaluate',\n",
+       " 'metrics',\n",
+       " 'snarimax']"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dir(time_series)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3a8d3f7b",
+   "metadata": {},
+   "source": [
+    "## Quantile estimation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "692e21e0",
+   "metadata": {},
+   "source": [
+    "The definition of confidence intervals lies mainly in the estimation of quantiles of the distribution of empirical data. Streaming data prevents the use of classical modules, notably numpy, whose approach is batch. Here we want to perform the calculations on a rolling window, relying only on the tools offered by river. We therefore check the validity of the results of the estimation of the quantiles of a normal distribution with river (stats module) compared to Numpy (norm module)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "67e59246",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "with Scipy : 1.960\n",
+      "with River : 1.960\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Get a normal distribution\n",
+    "normal_dist = optim.initializers.Normal(mu=0, sigma=1, seed=42)\n",
+    "big_dist = normal_dist(shape=500000)\n",
+    "\n",
+    "# confidence level\n",
+    "alpha = 0.975\n",
+    "# Compute with river\n",
+    "rolling_quantile = stats.Quantile(alpha)\n",
+    "for x in big_dist:\n",
+    "    _ = rolling_quantile.update(x)\n",
+    "\n",
+    "# Check equivalence\n",
+    "print(f\"with Scipy : {norm.ppf(alpha):.3f}\")\n",
+    "print(f\"with River : {rolling_quantile.get():.3f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "05799b2d",
+   "metadata": {},
+   "source": [
+    "## Airline passengers prediction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9bc96e43",
+   "metadata": {},
+   "source": [
+    "We first present the use of the methods presented above in the HoltWinters model on Airline passengers data. This allows us to see how the intervals work, which is similar to that of the metrics. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "be37cf04",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = datasets.AirlinePassengers()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0ce10404",
+   "metadata": {},
+   "source": [
+    "**Defining the forecasting model**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "4cb77706",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = HoltWinters(\n",
+    "        alpha=0.3,\n",
+    "        beta=0.1,\n",
+    "        gamma=0.6,\n",
+    "        seasonality=12,\n",
+    "        multiplicative=True\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3034ac1e",
+   "metadata": {},
+   "source": [
+    "**Defining the metric and interval method**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "94588d85",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "calib_period = 100\n",
+    "metric = metrics.MAE()\n",
+    "interval = conf.gaussian.Gaussian(window_size=calib_period, alpha=0.10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "303c1bf3",
+   "metadata": {},
+   "source": [
+    "**Evaluation of the model**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "a688d11b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(+1  MAE: 39.432543\n",
+       " +2  MAE: 38.132746\n",
+       " +3  MAE: 37.370918\n",
+       " +4  MAE: 37.74146\n",
+       " +5  MAE: 37.968714\n",
+       " +6  MAE: 38.922898\n",
+       " +7  MAE: 42.079442\n",
+       " +8  MAE: 42.828249\n",
+       " +9  MAE: 47.111859\n",
+       " +10 MAE: 48.481283\n",
+       " +11 MAE: 50.429104\n",
+       " +12 MAE: 50.401671,\n",
+       " +1  (400.3895748950096, 377.02385366644893)\n",
+       " +2  (424.8694745643036, 396.90350188804223)\n",
+       " +3  (405.2395450495128, 373.13925424292086)\n",
+       " +4  (472.8584163332991, 441.92991528302394)\n",
+       " +5  (458.15125908544024, 431.65673049325636)\n",
+       " +6  (480.0768254499125, 457.0372778746278)\n",
+       " +7  (549.0050911151861, 527.8836609308194)\n",
+       " +8  (633.8011412623661, 610.7329624711675)\n",
+       " +9  (644.4401685271714, 620.8860214364877)\n",
+       " +10 (531.3026391346808, 508.6725961298399)\n",
+       " +11 (468.75223087639944, 442.7874125602688)\n",
+       " +12 (413.0926153477715, 387.632074564122))"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "time_series.evaluate(\n",
+    "        dataset,\n",
+    "        model,\n",
+    "        metric,\n",
+    "        interval,\n",
+    "        horizon=12,\n",
+    "        residual_calibration_period = calib_period\n",
+    "        )\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "92522ada",
+   "metadata": {},
+   "source": [
+    "The method get_iter_evaluate presents the integration of the intervals in the library. In fact it returns, in addition to the list of metrics, the list of intervals. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "22803472",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "list_x, list_y, list_y_pred, list_metrics, list_interval = time_series.get_iter_evaluate(\n",
+    "        dataset,\n",
+    "        model,\n",
+    "        metric,\n",
+    "        interval,\n",
+    "        horizon=12,\n",
+    "        residual_calibration_period = calib_period\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ab19daad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "list_interval"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "36a20ea3",
+   "metadata": {},
+   "source": [
+    "### Training a model with conformal predictions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "03d33d39",
+   "metadata": {},
+   "source": [
+    "Below is the **training method of a prediction model with confidence intervals**. In addition to the pre-training part of the model and the prediction part, it is necessary to add a pre-definition part of the intervals. This one is based on the residuals coming from the first part of the pre-train. Once this one is done, we come back to the beginning of the dataset to compute the resulting residuals. This allows us to have a first estimate of the quantiles on enough data. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "e578c390",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run (model: time_series.base.Forecaster,\n",
+    "         stream_dataset, \n",
+    "         metric=metrics.MAE(), \n",
+    "         interval=conf.gaussian.Gaussian(window_size=1000, alpha=0.10),\n",
+    "         horizon=1,\n",
+    "         step=1, \n",
+    "         verbose=True,\n",
+    "         plot=[]\n",
+    "        ):\n",
+    "    \"\"\"Run the model on the dataset, and return the prediction with interval\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    model : tree.HoeffdingAdaptiveTreeRegressor\n",
+    "        the tree model\n",
+    "    dataset : _type_\n",
+    "        _description_\n",
+    "    cache_key : _type_\n",
+    "        _description_\n",
+    "    step : int, optional\n",
+    "        _description_, by default 1\n",
+    "    verbose : bool, optional\n",
+    "        _description_, by default True\n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "    _type_\n",
+    "        _description_\n",
+    "    \"\"\"\n",
+    "    start = time.time()   \n",
+    "\n",
+    "    # Defining the metric for the horizon\n",
+    "    horizon_metric = time_series.HorizonMetric(metric)\n",
+    "    # Defining the interval for a certain horizon\n",
+    "    horizon_interval = time_series.HorizonInterval(interval)\n",
+    "    \n",
+    "    # Defining the receiving list to output\n",
+    "    list_y = []\n",
+    "    list_yh = []\n",
+    "    list_ypred = []\n",
+    "    list_metric = []\n",
+    "    list_interval = []\n",
+    "    i = 0\n",
+    "\n",
+    "    ##############################################################################\n",
+    "    # Pre-train the model\n",
+    "    ##############################################################################\n",
+    "\n",
+    "    # Initialize the dataset from the beginning to get the grace period\n",
+    "    steps = _iter_with_horizon(stream_dataset, horizon)\n",
+    "\n",
+    "    # Pre train the model on a defined quantities of sample \"grace_periode\"\n",
+    "    # Set the grace period as the max between horizon and the interval.window_size\n",
+    "    grace_period = max(horizon, interval.window_size)\n",
+    "\n",
+    "    # Go over the grace_period to fit the model\n",
+    "    for t in range(grace_period):\n",
+    "        x, y, x_horizon, y_horizon = next(steps)\n",
+    "        model.learn_one(y=y, x=x)  # type: ignore\n",
+    "        if t >= interval.window_size:\n",
+    "            break\n",
+    "\n",
+    "\n",
+    "    ##############################################################################\n",
+    "    # Get first residuals series with the pre-trained model\n",
+    "    ##############################################################################\n",
+    "\n",
+    "    # Reinitialize the dataset from the beginning to get the grace period\n",
+    "    # And initialize the interval window\n",
+    "    # TODO : being able to predict_many. Would be easier\n",
+    "    steps = _iter_with_horizon(stream_dataset, horizon)\n",
+    "    for _ in range(grace_period):\n",
+    "        x, y, x_horizon, y_horizon = next(steps)\n",
+    "        # Get the residual that will be used for calibration\n",
+    "        # calibration predictions (subset of training points)\n",
+    "        y_pred = model.forecast(horizon, xs=x_horizon)\n",
+    "        # Initializing the interval for each horizon\n",
+    "        horizon_interval.update(y_horizon, y_pred)\n",
+    "\n",
+    "\n",
+    "    ##############################################################################\n",
+    "    # Forecast with intervals and learn\n",
+    "    ##############################################################################\n",
+    "\n",
+    "    # No reinitialisation of the dataset since we begin from where we stopped \n",
+    "    # at the pre-train stage\n",
+    "    i=0\n",
+    "    for x, y, x_horizon, y_horizon in steps:\n",
+    "        # Predicting future values until a certain horizon\n",
+    "        y_pred = model.forecast(horizon, xs=x_horizon)\n",
+    "        # Updating the metric\n",
+    "        horizon_metric.update(y_horizon, y_pred)\n",
+    "        # Updating the interval for each horizon\n",
+    "        horizon_interval.update(y_horizon, y_pred)\n",
+    "        # Train the model\n",
+    "        model.learn_one(y=y, x=x)  # type: ignore\n",
+    "\n",
+    "\n",
+    "\n",
+    "        # Incremente the list of metric values\n",
+    "        if (i+1)%step==0:\n",
+    "            list_metric.append(horizon_metric.get())\n",
+    "            list_interval.append(horizon_interval.get())\n",
+    "            list_y.append(y)\n",
+    "            list_yh.append(y_horizon)\n",
+    "            list_ypred.append(y_pred)\n",
+    "\n",
+    "            if verbose:\n",
+    "                print(f\"{i+1} samples : full = {list_metric[-1][0]:0.2f}\")\n",
+    "        i += 1\n",
+    "    end = time.time()\n",
+    "    if verbose:\n",
+    "        print(f\"\\nStream passed in {end-start:.2f} seconds\")\n",
+    "\n",
+    "\n",
+    "    return list_y, list_yh, list_ypred, list_metric, list_interval"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "54cd1476",
+   "metadata": {},
+   "source": [
+    "**Plot interval**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "3685fb2b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_interval(list_interval, list_y, range_toPlot):\n",
+    "    \n",
+    "    # Transform in array\n",
+    "    arr_interval = np.asarray(list_interval)\n",
+    "    arr_y = np.asarray(list_y)\n",
+    "\n",
+    "    begin_at, end_at = range_toPlot\n",
+    "\n",
+    "    fig, ax = plt.subplots()\n",
+    "    ax.plot(arr_y[begin_at:end_at], label=\"Water flow\")\n",
+    "    ax.fill_between(np.arange(end_at-begin_at), \n",
+    "                    arr_interval[begin_at:end_at].squeeze(1)[:,0], \n",
+    "                    arr_interval[begin_at:end_at].squeeze(1)[:,1], \n",
+    "                    color='b', alpha=.1)\n",
+    "    if range_toPlot[0] > 0:\n",
+    "        ax.set_title((f\"{interval.__class__.__name__} interval at \"\n",
+    "                        f\"{interval.alpha*100:.0f}% for {model.__class__.__name__} \"\n",
+    "                        f\"on {dataset.__class__.__name__}. ZOOM = {range_toPlot}\"\n",
+    "                        ))\n",
+    "\n",
+    "    else:\n",
+    "        ax.set_title((f\"{interval.__class__.__name__} interval at \"\n",
+    "                        f\"{interval.alpha*100:.0f}% for {model.__class__.__name__} \"\n",
+    "                        f\"on {dataset.__class__.__name__}\"\n",
+    "                        ))\n",
+    "    fig.tight_layout()\n",
+    "    ax.plot()\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8fddd53e",
+   "metadata": {},
+   "source": [
+    "# 1st method : Gaussian Interval"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "704bdd8c",
+   "metadata": {},
+   "source": [
+    "**HoltWinters on bigger dataset : WaterFlow**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3a044e46",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = datasets.WaterFlow()\n",
+    "\n",
+    "model = HoltWinters(\n",
+    "        alpha=0.8,\n",
+    "        beta=0.1,\n",
+    "        gamma=0.6,\n",
+    "        seasonality=2,\n",
+    "        multiplicative=True\n",
+    "        )\n",
+    "\n",
+    "metric = metrics.MSE()\n",
+    "\n",
+    "calib_period = 100\n",
+    "alpha=0.05\n",
+    "interval = conf.gaussian.Gaussian(window_size=calib_period, alpha=alpha)\n",
+    "\n",
+    "# Run and get all the relevant lists\n",
+    "plot_zoom = [180,700]\n",
+    "plot_full = [0,1166]\n",
+    "list_y, _, _, list_metric, list_interval = run(model, dataset, metric, interval, horizon=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "0e1a98f1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "_ = plot_interval(list_interval,list_y,plot_full)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "1373d34b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_interval(list_interval,list_y,plot_zoom)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6b536f2e",
+   "metadata": {},
+   "source": [
+    "We see that the interval with Gaussian method is regular around the residuals, and does not take into account the improvement of the model (the reduction of the std of the residuals)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "4728dad2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[]"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "arr_metrics = np.asarray(list_metric)\n",
+    "plt.plot(arr_metrics[:,0])\n",
+    "plt.title(\"MSE through time\")\n",
+    "plt.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff08f150",
+   "metadata": {},
+   "source": [
+    "# 2nd method : Conformal Prediction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36fd3cd9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = datasets.WaterFlow()\n",
+    "\n",
+    "model = HoltWinters(\n",
+    "        alpha=0.8,\n",
+    "        beta=0.1,\n",
+    "        gamma=0.6,\n",
+    "        seasonality=2,\n",
+    "        multiplicative=True\n",
+    "        )\n",
+    "\n",
+    "metric = metrics.MSE()\n",
+    "\n",
+    "calib_period = 100\n",
+    "alpha=0.05\n",
+    "interval = conf.CP.ConformalPrediction(window_size=calib_period, alpha=alpha)\n",
+    "\n",
+    "list_y, _, _, list_metric, list_interval = run(model, dataset, metric, interval, horizon=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "7c9798e9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_interval(list_interval,list_y,plot_full)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e840d5ce",
+   "metadata": {},
+   "source": [
+    "This time, the performance of the model is taken into account in an iterative way. During periods of volatility in the model, the interval deviates greatly, while in periods of stability the method allows a higher level of confidence"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45c43400",
+   "metadata": {},
+   "source": [
+    "# 3rd method : Adaptative Conformal Prediction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "7ea76646",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = datasets.WaterFlow()\n",
+    "\n",
+    "model = HoltWinters(\n",
+    "        alpha=0.8,\n",
+    "        beta=0.1,\n",
+    "        gamma=0.6,\n",
+    "        seasonality=2,\n",
+    "        multiplicative=True\n",
+    "        )\n",
+    "\n",
+    "metric = metrics.MSE()\n",
+    "\n",
+    "calib_period = 100\n",
+    "alpha=0.05\n",
+    "interval = conf.ACP.AdaptativeConformalPrediction(window_size=calib_period, gamma=0.0072, alpha=0.07)\n",
+    "\n",
+    "# Run and get all the relevant lists\n",
+    "list_y, list_yh, list_ypred, list_metric, list_interval = run(model, dataset, metric, interval, horizon=1,verbose=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "fb7fa5b7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_interval(list_interval,list_y,plot_full)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "0359d47e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tab_gamma = (0,\n",
+    "             0.000005,\n",
+    "             0.00005,\n",
+    "             0.0001,0.0002,0.0003,0.0004,0.0005,0.0006,0.0007,0.0008,0.0009,\n",
+    "             0.001,0.002,0.003,0.004,0.005,0.006,0.007,0.008,0.009,\n",
+    "             0.01,0.02,0.03,0.04,0.05,0.06,0.07,0.08,0.09)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "db63d733",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_gamma_alpha(alpha,gamma):\n",
+    "        zoom = False\n",
+    "        dataset = datasets.WaterFlow()\n",
+    "        model = HoltWinters(\n",
+    "                alpha=0.8,\n",
+    "                beta=0.1,\n",
+    "                gamma=0.6,\n",
+    "                seasonality=2,\n",
+    "                multiplicative=True\n",
+    "        )\n",
+    "        metric = metrics.MSE()\n",
+    "        calib_period = 100\n",
+    "        interval = conf.ACP.AdaptativeConformalPrediction(window_size=calib_period, gamma=gamma, alpha=alpha)\n",
+    "\n",
+    "        # Run and get all the relevant lists\n",
+    "        list_y, _, _, _, list_interval = run(model, dataset, metric, interval, horizon=1,verbose=False)\n",
+    "\n",
+    "        if zoom:\n",
+    "                _ = plot_interval(list_interval,list_y,plot_zoom)\n",
+    "        else:\n",
+    "\n",
+    "                _ = plot_interval(list_interval,list_y,plot_full)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "73c0aaa3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "388ccf573f8b4c65b6c0ab66f84faa9a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(FloatSlider(value=0.05, description='alpha', max=0.2, min=0.01, step=0.01), FloatSlider(…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "widgets.interactive(plot_gamma_alpha,\n",
+    "                    alpha=widgets.FloatSlider(value=0.05,\n",
+    "                                              min=0.01,\n",
+    "                                              max=0.2,\n",
+    "                                              step=0.01,\n",
+    "                                              readout_format='.2f'),\n",
+    "                    gamma=widgets.FloatSlider(value=0.007,\n",
+    "                                              min=0.004,\n",
+    "                                              max=0.01,\n",
+    "                                              step=0.0001,\n",
+    "                                              readout_format='.6f')\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5be6c273",
+   "metadata": {},
+   "source": [
+    "We see that a fine tuning of the 2 parameters alpha and gamma is necessary to obtain the desired performance. The tool above allows to visualize the dependency of the two variables on the construction of the interval. "
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "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.13 (tags/v3.9.13:6de2ca5, May 17 2022, 16:36:42) [MSC v.1929 64 bit (AMD64)]"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "81794d4967e6c3204c66dcd87b604927b115b27c00565d3d43f05ba2f3a2cb0d"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/river/Notebook_ConformalPrediction.pdf b/river/Notebook_ConformalPrediction.pdf
new file mode 100644
index 0000000000..eedee22d0e
Binary files /dev/null and b/river/Notebook_ConformalPrediction.pdf differ
diff --git a/river/README.md b/river/README.md
new file mode 100644
index 0000000000..c61e34ea12
--- /dev/null
+++ b/river/README.md
@@ -0,0 +1,68 @@
+# Conformal prediction implementation in River
+
+- BOGGIO Richard
+- MDIHI Samy
+- VERON Marc
+
+This Conformal Prediction Implementation relies on the paper by Margaux Zaffran et al. "Adaptative Conformal Predictions for Time series" (https://arxiv.org/abs/2202.07282). This paper has 2 parts: expert aggregation for regression or classification, and the definition of **confidence intervals on streaming data**. We focus here on the implementation in River of these confidence interval estimation techniques. We rely on the work of the research group, implemented in Python and available on github : https://github.com/mzaffran/AdaptiveConformalPredictionsTimeSeries
+
+Conformal prediction is a general term for identifying confidence interval definition methods in machine learning that go beyond the simple gaussian approach. 
+
+The aim of our work is to allow users to benefit from these method when using regression and prediction models with River. So we increased the **conf** module first. This one is present on the River git repo, but is not deployed on the downloadable Python version. It contains the parent class **interval** that is used as base for the different methods: **Gaussian**, **ConformalPrediction**, **AdaptativeConformalPrediction**. Next, we augment the **time_series** module, in which we update the evaluation method to allow for intervals at different horizons. Indeed the logic of this module is to predict not only at horizon 1, but further. The calculation of intervals must therefore be integrated into this way, hence the base definition in conf. 
+
+To ensure the integration of all these methods, the **\_\_init\_\_** and **base** files have been updated. This allows to have an almost functional environment as described below. A notebook is also provided in our Git repo : https://github.com/mverontarabeux/river/tree/ConformalPrediction/river
+
+
+## Installation
+
+Use the package manager [pip](https://pip.pypa.io/en/stable/) to install river.
+
+```bash
+pip install river
+```
+
+## Usage
+
+```python
+# import the relevant River modules
+from river import datasets, metrics
+from time_series.holt_winters import HoltWinters
+
+# import the interval methods from the custom conf module (defined as a folder)
+import time_series
+import conf.ACP
+import conf.CP
+import conf.gaussian
+
+# Get some data
+dataset = datasets.AirlinePassengers()
+
+# Define a forecasting model 
+model = HoltWinters(
+        alpha=0.3,
+        beta=0.1,
+        gamma=0.6,
+        seasonality=12,
+        multiplicative=True
+        )
+
+# Set the metric and interval methods
+metric = metrics.MAE()
+interval = conf.gaussian.Gaussian(window_size=calib_period, alpha=0.10)
+
+# Evaluate the model
+time_series.evaluate(dataset,
+                     model,
+                     metric,
+                     interval,
+                     horizon=12,
+                     residual_calibration_period = calib_period
+                     )
+
+```
+## Contribution
+
+A pull requests has been sent with the latest updates. 
+The code is flake8 compliant.
+
+Please also check the Notebook_ConformalPrediction.ipynb for more insight.
\ No newline at end of file
diff --git a/river/conf/ACP.py b/river/conf/ACP.py
new file mode 100644
index 0000000000..d01244845c
--- /dev/null
+++ b/river/conf/ACP.py
@@ -0,0 +1,121 @@
+from river import stats
+from collections import deque
+from typing import Tuple
+import math
+
+from conf.base import Interval
+
+
+class AdaptativeConformalPrediction(Interval):
+    """Adapatative Conformal Prediction method
+
+    Parameters
+    ----------
+    regressor
+        The regressor to be wrapped.
+    confidence_level
+        The confidence level of the prediction intervals.
+    window_size
+        The size of the window used to compute the quantiles of the residuals. If `None`, the
+        quantiles are computed over the whole history. It is advised to set this if you expect the
+        model's performance to change over time.
+
+    Examples
+    --------
+
+    >>> from river import conf
+    >>> from river import datasets
+    >>> from river import linear_model
+    >>> from river import metrics
+    >>> from river import preprocessing
+    >>> from river import stats
+
+    >>> dataset = datasets.TrumpApproval()
+
+    >>> model = conf.AdaptativeConformalPrediction(
+    ...     (
+    ...         preprocessing.StandardScaler() |
+    ...         linear_model.LinearRegression(intercept_lr=.1)
+    ...     ),
+    ...     confidence_level=0.9,
+            gamma=.05
+    ... )
+
+    >>> validity = stats.Mean()
+    >>> efficiency = stats.Mean()
+
+    >>> for x, y in dataset:
+    ...     interval = model.predict_one(x, with_interval=True)
+    ...     validity = validity.update(y in interval)
+    ...     efficiency = efficiency.update(interval.width)
+    ...     model = model.learn_one(x, y)
+
+    The interval's validity is the proportion of times the true value is within the interval. We
+    specified a confidence level of 90%, so we expect the validity to be around 90%.
+
+    >>> validity
+    Mean: 0.903097
+
+    The interval's efficiency is the average width of the intervals.
+
+    >>> efficiency
+    Mean: 3.430883
+
+    Lowering the confidence lowering will mechanically improve the efficiency.
+
+    References
+    ----------
+    [^1]: [Margaux Zaffran, Olivier Féron, Yannig Goude, Julie Josse, Aymeric Dieuleveut.
+    "Adaptive Conformal Predictions for Time Series](https://arxiv.org/abs/2202.07282)
+
+    """
+
+    def __init__(
+        self, window_size: int, gamma:float=0.5, alpha: float = 0.05,
+    ):
+        self.gamma = gamma
+        self.alpha = alpha
+        self.alpha_t = alpha
+        self.window_size = window_size
+        self.residuals = deque()
+
+    def update(self, y_true: float, y_pred: float) -> "Interval":
+        """Update the Interval."""
+
+        if len(self.residuals)==self.window_size:
+            # Remove the oldest residuals
+            self.residuals.popleft()
+            # Add the new one
+            self.residuals.append(abs(y_true - y_pred))
+
+            if(self.alpha_t >= 1): # => 1-alpha_t <= 0 => predict empty set
+                err = 1 # err = 1 if the point is not included, 0 otherwise
+
+            elif(self.alpha_t <= 0): # => 1-alpha_t >= 1 => predict the whole real line
+                self.lower, self.upper = -math.inf, math.inf
+                err = 0
+
+            else: # => 1-alpha_t in ]0,1[ => compute the quantiles
+                # Update the updated quantile
+                rolling_quantile = stats.Quantile(1-self.alpha_t)
+                for x in self.residuals:
+                    _ = rolling_quantile .update(x)
+
+                # Get the window
+                half_inter = rolling_quantile .get()
+
+                # create the bounds for the ACP interval, centered around y_pred
+                self.lower, self.upper = y_pred-half_inter, y_pred+half_inter
+
+                err = 1-float((self.lower <= y_true) & (y_true <= self.upper))
+
+            # compute next value of alpha_t using updating scheme
+            self.alpha_t = self.alpha_t + self.gamma*(self.alpha_t-err)
+
+        else:
+            # Fill the residuals until it reaches window size
+            self.residuals.append(abs(y_true - y_pred))
+
+    def get(self) -> Tuple[float, float]:
+        """Return the current value of the Interval."""
+        return (self.lower, self.upper)
diff --git a/river/conf/CP.py b/river/conf/CP.py
new file mode 100644
index 0000000000..7e86ce5693
--- /dev/null
+++ b/river/conf/CP.py
@@ -0,0 +1,103 @@
+from river import stats
+from collections import deque
+from typing import Tuple
+
+from conf.base import Interval
+
+
+class ConformalPrediction(Interval):
+    """Adapatative Conformal Prediction method
+
+    Parameters
+    ----------
+    regressor
+        The regressor to be wrapped.
+    confidence_level
+        The confidence level of the prediction intervals.
+    window_size
+        The size of the window used to compute the quantiles of the residuals. If `None`, the
+        quantiles are computed over the whole history. It is advised to set this if you expect the
+        model's performance to change over time.
+
+    Examples
+    --------
+
+    >>> from river import conf
+    >>> from river import datasets
+    >>> from river import linear_model
+    >>> from river import metrics
+    >>> from river import preprocessing
+    >>> from river import stats
+
+    >>> dataset = datasets.TrumpApproval()
+
+    >>> model = conf.ConformalPrediction(
+    ...     (
+    ...         preprocessing.StandardScaler() |
+    ...         linear_model.LinearRegression(intercept_lr=.1)
+    ...     ),
+    ...     confidence_level=0.9,
+            gamma=.05
+    ... )
+
+    >>> validity = stats.Mean()
+    >>> efficiency = stats.Mean()
+
+    >>> for x, y in dataset:
+    ...     interval = model.predict_one(x, with_interval=True)
+    ...     validity = validity.update(y in interval)
+    ...     efficiency = efficiency.update(interval.width)
+    ...     model = model.learn_one(x, y)
+
+    The interval's validity is the proportion of times the true value is within the interval. We
+    specified a confidence level of 90%, so we expect the validity to be around 90%.
+
+    >>> validity
+    Mean: 0.903097
+
+    The interval's efficiency is the average width of the intervals.
+
+    >>> efficiency
+    Mean: 3.430883
+
+    Lowering the confidence lowering will mechanically improve the efficiency.
+
+    References
+    ----------
+    [^1]: [Margaux Zaffran, Olivier Féron, Yannig Goude, Julie Josse, Aymeric Dieuleveut.
+    "Adaptive Conformal Predictions for Time Series](https://arxiv.org/abs/2202.07282)
+
+    """
+
+    def __init__(
+        self, window_size: int, alpha: float = 0.05
+    ):
+        self.alpha = alpha
+        self.window_size = window_size
+        self.residuals = deque()
+        self.rolling_quantile = stats.Quantile((1-self.alpha)*(1+1/self.window_size))
+
+    def update(self, y_true: float, y_pred: float) -> "Interval":
+        """Update the Interval."""
+
+        if len(self.residuals)==self.window_size:
+            # Remove the oldest residuals
+            self.residuals.popleft()
+            # Add the new one
+            self.residuals.append(abs(y_true - y_pred))
+
+            # Update the quantile
+            _ = self.rolling_quantile.update(self.residuals[-1])
+
+            # Compute the interval
+            half_inter = self.rolling_quantile.get()
+
+            # And set the borne
+            self.lower, self.upper = y_pred-half_inter, y_pred+half_inter
+        else:
+            # Fill the residuals until it reaches window size
+            self.residuals.append(abs(y_true - y_pred))
+
+    def get(self) -> Tuple[float, float]:
+        """Return the current value of the Interval."""
+        return (self.lower, self.upper)
diff --git a/river/conf/__init__.py b/river/conf/__init__.py
index 1febd8467c..42b1ba97dc 100644
--- a/river/conf/__init__.py
+++ b/river/conf/__init__.py
@@ -1,9 +1,15 @@
 """Conformal predictions. This modules contains wrappers to enable conformal predictions on any
 regressor or classifier."""
-from .interval import Interval
-from .jackknife import RegressionJackknife
+from conf.base import Interval
+from conf.jackknife import RegressionJackknife
+from conf.gaussian import Gaussian
+from conf.ACP import AdaptativeConformalPrediction
+from conf.CP import ConformalPrediction
 
 __all__ = [
     "Interval",
+    "Gaussian",
+    "ConformalPrediction",
+    'AdaptativeConformalPrediction',
     "RegressionJackknife",
 ]
diff --git a/river/conf/base.py b/river/conf/base.py
new file mode 100644
index 0000000000..b090480591
--- /dev/null
+++ b/river/conf/base.py
@@ -0,0 +1,71 @@
+import abc
+from typing import Tuple
+from river import base
+from conf import ConformalPrediction, Gaussian, AdaptativeConformalPrediction
+
+__all__=[
+    "Interval",
+    "ConformalPrediction",
+    "AdaptativeConformalPrediction",
+    "Gaussian"
+]
+
+
+# from river/metrics/base.py
+#@dataclasses.dataclass
+class Interval(base.Base, abc.ABC):
+    """Mother class for all intervals
+
+    An object to represent a (prediction) interval.
+
+    Users are not expected to use this class as-is. Instead, they should use the `with_interval`
+    parameter of the `predict_one` method of any regressor or classifier wrapped with a conformal
+    prediction method.
+
+    Parameters
+    ----------
+    lower
+        The lower bound of the interval.
+    upper
+        The upper bound of the interval.
+
+    """
+
+    lower: float
+    upper: float
+
+    # Begin : From initial interval.py in conf
+    @property
+    def center(self):
+        """The center of the interval."""
+        return (self.lower + self.upper) / 2
+
+    @property
+    def width(self):
+        """The width of the interval."""
+        return self.upper - self.lower
+
+    def __contains__(self, x):
+        return self.lower <= x <= self.upper
+    # End : From initial interval.py in conf
+
+    @abc.abstractmethod
+    def update(self, y_true, y_pred) -> "Interval":
+        """Update the Interval."""
+
+    @abc.abstractmethod
+    def get(self) ->  Tuple[float,float]:
+        """Return the current value of the Interval."""
+
+    def __repr__(self) -> str:
+        """Return the class name along with the current value of the Interval."""
+        return f"{self.__class__.__name__}: {self.get():{self._fmt}}".rstrip("0")
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def __eq__(self, other) -> bool:
+        """Compare two instance of interval"""
+        if isinstance(other, Interval):
+            return self.lower == other.lower and self.upper == other.upper
+        return False
diff --git a/river/conf/gaussian.py b/river/conf/gaussian.py
new file mode 100644
index 0000000000..736b05cdaa
--- /dev/null
+++ b/river/conf/gaussian.py
@@ -0,0 +1,117 @@
+from river import stats
+from river import optim
+
+from conf.base import Interval
+
+from collections import deque
+from typing import Tuple
+
+
+class Gaussian(Interval):
+    """Gaussian method to define intervals
+
+    Parameters
+    ----------
+    regressor
+        The regressor to be wrapped.
+    confidence_level
+        The confidence level of the prediction intervals.
+    window_size
+        The size of the window used to compute the quantiles of the residuals. If `None`, the
+        quantiles are computed over the whole history. It is advised to set this if you expect the
+        model's performance to change over time.
+
+    Examples
+    --------
+
+    >>> from river import conf
+    >>> from river import datasets
+    >>> from river import linear_model
+    >>> from river import metrics
+    >>> from river import preprocessing
+    >>> from river import stats
+
+    >>> dataset = datasets.TrumpApproval()
+
+    >>> model = conf.Gaussian(
+    ...     (
+    ...         preprocessing.StandardScaler() |
+    ...         linear_model.LinearRegression(intercept_lr=.1)
+    ...     ),
+    ...     confidence_level=0.9
+    ... )
+
+    >>> validity = stats.Mean()
+    >>> efficiency = stats.Mean()
+
+    >>> for x, y in dataset:
+    ...     interval = model.predict_one(x, with_interval=True)
+    ...     validity = validity.update(y in interval)
+    ...     efficiency = efficiency.update(interval.width)
+    ...     model = model.learn_one(x, y)
+
+    The interval's validity is the proportion of times the true value is within the interval. We
+    specified a confidence level of 90%, so we expect the validity to be around 90%.
+
+    >>> validity
+    Mean: 0.903097
+
+    The interval's efficiency is the average width of the intervals.
+
+    >>> efficiency
+    Mean: 3.430883
+
+    Lowering the confidence will mechanically improve the efficiency.
+
+    References
+    ----------
+    [^1]: [Barber, Rina Foygel, Emmanuel J. Candes, Aaditya Ramdas, and Ryan J. Tibshirani. "Predictive inference with the jackknife+." The Annals of Statistics 49, no. 1 (2021): 486-507.](https://www.stat.cmu.edu/~ryantibs/papers/jackknife.pdf)
+
+    """
+
+    def __init__(
+        self, window_size: int, alpha: float = 0.05
+    ):
+        self.alpha = alpha
+        self.window_size = window_size
+        self.residuals = deque()
+        self.var = stats.Var()
+
+        # define the ppf on the normal distribution :
+        # Get a normal distribution sampler
+        normal_sampler = optim.initializers.Normal(mu=0, sigma=1, seed=42)
+        # And sample enough samples : 5 millions give the result of scipy
+        normal_samples = normal_sampler(shape=500000)
+        # Initialize a quantile computer in River
+        rolling_quantile = stats.Quantile((1 - alpha) / 2)
+        for x in normal_samples:
+            _ = rolling_quantile.update(x)
+        # set the result
+        self.norm_ppf = rolling_quantile.get()
+
+    def update(self, y_true: float, y_pred: float) -> "Interval":
+        """Update the Interval."""
+
+        if len(self.residuals)==self.window_size:
+            # Remove the oldest residuals
+            self.residuals.popleft()
+            # Add the new one
+            self.residuals.append(y_true - y_pred)
+
+            # Update the variance with the latest residual
+            self.var.update(self.residuals[-1])
+
+            # Compute the interval
+            # First get
+            half_inter = self.norm_ppf*self.var.get()**0.5
+            # And set the borne
+            self.lower, self.upper = y_pred-half_inter, y_pred+half_inter
+        else:
+            # Fill the residuals until it reaches window size
+            self.residuals.append(y_true - y_pred)
+            # Update the variance
+            self.var.update(self.residuals[-1])
+
+    def get(self) -> Tuple[float, float]:
+        """Return the current value of the Interval."""
+        return (self.lower, self.upper)
diff --git a/river/conf/interval.py b/river/conf/interval.py
deleted file mode 100644
index f78a535d4e..0000000000
--- a/river/conf/interval.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import dataclasses
-
-
-@dataclasses.dataclass
-class Interval:
-    """An object to represent a (prediction) interval.
-
-    Users are not expected to use this class as-is. Instead, they should use the `with_interval`
-    parameter of the `predict_one` method of any regressor or classifier wrapped with a conformal
-    prediction method.
-
-    Parameters
-    ----------
-    lower
-        The lower bound of the interval.
-    upper
-        The upper bound of the interval.
-
-    """
-
-    lower: float
-    upper: float
-
-    @property
-    def center(self):
-        """The center of the interval."""
-        return (self.lower + self.upper) / 2
-
-    @property
-    def width(self):
-        """The width of the interval."""
-        return self.upper - self.lower
-
-    def __contains__(self, x):
-        return self.lower <= x <= self.upper
diff --git a/river/conf/jackknife.py b/river/conf/jackknife.py
index b42dbc795f..2358b73296 100644
--- a/river/conf/jackknife.py
+++ b/river/conf/jackknife.py
@@ -1,6 +1,6 @@
 from river import base, stats
 
-from . import interval
+from .base import Interval
 
 
 class RegressionJackknife(base.Wrapper, base.Regressor):
@@ -135,6 +135,7 @@ def predict_one(self, x, with_interval=False):
         if not with_interval:
             return y_pred
 
-        return interval.Interval(
-            lower=y_pred + (self._lower.get() or 0), upper=y_pred + (self._upper.get() or 0)
+        return Interval(
+            lower=y_pred + (self._lower.get() or 0),
+            upper=y_pred + (self._upper.get() or 0)
         )
diff --git a/river/paper_AdaptiveConformalPredictionTimeSeries_MZAFFRAN.pdf b/river/paper_AdaptiveConformalPredictionTimeSeries_MZAFFRAN.pdf
new file mode 100644
index 0000000000..7f13f1f715
Binary files /dev/null and b/river/paper_AdaptiveConformalPredictionTimeSeries_MZAFFRAN.pdf differ
diff --git a/river/time_series/__init__.py b/river/time_series/__init__.py
index 0b6a44427a..6aaade521f 100644
--- a/river/time_series/__init__.py
+++ b/river/time_series/__init__.py
@@ -1,17 +1,25 @@
 """Time series forecasting."""
 from . import base
-from .evaluate import evaluate, iter_evaluate
+from .evaluates import evaluate, get_iter_evaluate, iter_evaluate, _iter_with_horizon
+# renaming module to evaluates to be able to import more than 1 function
 from .holt_winters import HoltWinters
 from .metrics import ForecastingMetric, HorizonAggMetric, HorizonMetric
 from .snarimax import SNARIMAX
+from .intervals import ForecastingInterval, HorizonInterval
+from .hoeffding_horizon import HoeffdingTreeHorizon
 
 __all__ = [
     "base",
-    "evaluate",
+    "_iter_with_horizon",
     "iter_evaluate",
+    "get_iter_evaluate",
+    "evaluate",
+    "ForecastingInterval",
+    "HorizonInterval",
     "ForecastingMetric",
     "HorizonAggMetric",
     "HorizonMetric",
+    "HoeffdingTreeHorizon",
     "HoltWinters",
     "SNARIMAX",
 ]
diff --git a/river/time_series/evaluate.py b/river/time_series/evaluates.py
similarity index 58%
rename from river/time_series/evaluate.py
rename to river/time_series/evaluates.py
index 42ad8f91b0..085c19f9ff 100644
--- a/river/time_series/evaluate.py
+++ b/river/time_series/evaluates.py
@@ -6,6 +6,8 @@
 from typing import Iterator, List, Optional, Tuple
 
 from river import base, metrics, time_series
+import conf
+import time_series
 
 TimeSeries = Iterator[
     Tuple[
@@ -78,9 +80,11 @@ def iter_evaluate(
     dataset: base.typing.Dataset,
     model: time_series.base.Forecaster,
     metric: metrics.base.RegressionMetric,
+    interval: conf.Interval,
     horizon: int,
     agg_func: typing.Callable[[list[float]], float] = None,
     grace_period: int = None,
+    residual_calibration_period: int = None,
 ):
     """Evaluates the performance of a forecaster on a time series dataset and yields results.
 
@@ -95,6 +99,8 @@ def iter_evaluate(
         A sequential time series.
     model
         A forecaster.
+    interval
+        An interval method
     metric
         A regression metric.
     horizon
@@ -105,34 +111,110 @@ def iter_evaluate(
         parameter is equal to the horizon by default.
 
     """
-
+    # Defining the metric for a certain horizon
     horizon_metric = (
         time_series.HorizonAggMetric(metric, agg_func)
         if agg_func
         else time_series.HorizonMetric(metric)
     )
+
+    # Defining the interval for a certain horizon
+    horizon_interval = (time_series.HorizonInterval(interval))
+
+    ##############################################################################
+    # Pre-train the model
+    ##############################################################################
+
+    # Initialize the dataset from the beginning to get the grace period
     steps = _iter_with_horizon(dataset, horizon)
 
+    # Pre train the model on a defined quantities of sample "grace_periode"
     grace_period = horizon if grace_period is None else grace_period
+    # Set the grace period as the max between it and the residual_calibration_period
+    grace_period = max(grace_period, residual_calibration_period)
+
+    # Go over the grace_period to fit the model
     for _ in range(grace_period):
         x, y, x_horizon, y_horizon = next(steps)
         model.learn_one(y=y, x=x)  # type: ignore
 
+    ##############################################################################
+    # Get first residuals series with the pre-trained model
+    ##############################################################################
+
+    # Reinitialize the dataset from the beginning to get the grace period
+    # And initialize the interval window
+    # TODO : being able to predict_many. Would be easier
+    steps = _iter_with_horizon(dataset, horizon)
+    for _ in range(grace_period):
+        x, y, x_horizon, y_horizon = next(steps)
+        # Get the residual that will be used for calibration
+        # calibration predictions (subset of training points)
+        y_pred = model.forecast(horizon, xs=x_horizon)
+        # Initializing the interval for each horizon
+        horizon_interval.update(y_horizon, y_pred)
+
+    ##############################################################################
+    # Forecast with intervals and learn
+    ##############################################################################
+
+    # No reinitialisation of the dataset since we begin from where we stopped
+    # at the pre-train stage
     for x, y, x_horizon, y_horizon in steps:
+        # Predicting future values until a certain horizon
         y_pred = model.forecast(horizon, xs=x_horizon)
+        # Updating the metric
         horizon_metric.update(y_horizon, y_pred)
+        # Updating the interval for each horizon
+        horizon_interval.update(y_horizon, y_pred)
+        # Train the model
         model.learn_one(y=y, x=x)  # type: ignore
-        yield x, y, y_pred, horizon_metric
+        yield x, y, y_pred, horizon_metric, horizon_interval
+
+
+def get_iter_evaluate(
+    dataset: base.typing.Dataset,
+    model: time_series.base.Forecaster,
+    metric: metrics.base.RegressionMetric,
+    interval: conf.Interval,
+    horizon: int,
+    agg_func: typing.Callable[[list[float]], float] = None,
+    grace_period: int = None,
+    residual_calibration_period: int = None,
+) -> Tuple(list, list, list, list, list):
+
+    steps = iter_evaluate(
+                dataset, model, metric, interval,
+                horizon, agg_func, grace_period,
+                residual_calibration_period,
+            )
+
+    list_x = []
+    list_y = []
+    list_y_pred = []
+    list_metrics = []
+    list_interval = []
+
+    for x, y, y_pred, horizon_metric, horizon_interval in steps:
+        list_x.append(x)
+        list_y.append(y)
+        list_y_pred.append(y_pred)
+        list_metrics.append(horizon_metric)
+        list_interval.append(horizon_interval)
+
+    return list_x, list_y, list_y_pred, list_metrics, list_interval
 
 
 def evaluate(
     dataset: base.typing.Dataset,
     model: time_series.base.Forecaster,
     metric: metrics.base.RegressionMetric,
+    interval: conf.Interval,
     horizon: int,
     agg_func: typing.Callable[[list[float]], float] = None,
     grace_period: int = None,
-) -> time_series.HorizonMetric:
+    residual_calibration_period: int = None,
+) -> Tuple(time_series.HorizonMetric, time_series.HorizonInterval):
     """Evaluates the performance of a forecaster on a time series dataset.
 
     To understand why this method is useful, it's important to understand the difference between
@@ -151,6 +233,8 @@ def evaluate(
         A sequential time series.
     model
         A forecaster.
+    interval
+        An interval method
     metric
         A regression metric.
     horizon
@@ -163,8 +247,11 @@ def evaluate(
     """
 
     horizon_metric = None
-    steps = iter_evaluate(dataset, model, metric, horizon, agg_func, grace_period)
-    for *_, horizon_metric in steps:
+    horizon_interval = None
+    steps = iter_evaluate(dataset, model, metric,
+                          interval, horizon, agg_func,
+                          grace_period, residual_calibration_period)
+    for *_, horizon_metric, horizon_interval in steps:
         pass
 
-    return horizon_metric
+    return horizon_metric, horizon_interval
diff --git a/river/time_series/hoeffding_horizon.py b/river/time_series/hoeffding_horizon.py
new file mode 100644
index 0000000000..3e0169519f
--- /dev/null
+++ b/river/time_series/hoeffding_horizon.py
@@ -0,0 +1,65 @@
+
+from river import time_series
+from river import tree
+from river.tree.splitter import Splitter
+from river import base
+
+__all__ = ["HoeffdingTreeHorizon"]
+
+
+class HoeffdingTreeHorizon(time_series.base.Forecaster, tree.HoeffdingTreeRegressor):
+    """
+
+    Parameters
+    ----------
+    time_series : _type_
+        _description_
+    """
+    def __init__(
+        self,
+        grace_period: int = 200,
+        max_depth: int = None,
+        delta: float = 1e-7,
+        tau: float = 0.05,
+        leaf_prediction: str = "adaptive",
+        leaf_model: base.Regressor = None,
+        model_selector_decay: float = 0.95,
+        nominal_attributes: list = None,
+        splitter: Splitter = None,
+        min_samples_split: int = 5,
+        binary_split: bool = False,
+        max_size: float = 500.0,
+        memory_estimate_period: int = 1000000,
+        stop_mem_management: bool = False,
+        remove_poor_attrs: bool = False,
+        merit_preprune: bool = True
+    ):
+        super().__init__(
+            grace_period=grace_period,
+            max_depth=max_depth,
+            delta=delta,
+            tau=tau,
+            leaf_prediction=leaf_prediction,
+            leaf_model=leaf_model,
+            model_selector_decay=model_selector_decay,
+            nominal_attributes=nominal_attributes,
+            splitter=splitter,
+            min_samples_split=min_samples_split,
+            binary_split=binary_split,
+            max_size=max_size,
+            memory_estimate_period=memory_estimate_period,
+            stop_mem_management=stop_mem_management,
+            remove_poor_attrs=remove_poor_attrs,
+            merit_preprune=merit_preprune
+        )
+
+    def learn_one(self, y: float, x: dict):
+        return super().learn_one(y, x)
+
+    def forecast(self, horizon, xs=None):
+        last_pred = xs
+        forecasted_horizon = []
+        for h in range(horizon):
+            forecasted_horizon.append(super().predict_one(last_pred))
+            last_pred = forecasted_horizon[-1]
+        return forecasted_horizon
diff --git a/river/time_series/holt_winters.py b/river/time_series/holt_winters.py
index 5b0ffd367f..0db681de3d 100644
--- a/river/time_series/holt_winters.py
+++ b/river/time_series/holt_winters.py
@@ -209,6 +209,9 @@ def learn_one(self, y, x=None):
 
         return self
 
+    def predict_one(self, x):
+        return
+
     def forecast(self, horizon, xs=None):
         op = operator.mul if self.multiplicative else operator.add
         return [
diff --git a/river/time_series/intervals.py b/river/time_series/intervals.py
new file mode 100644
index 0000000000..024fa88633
--- /dev/null
+++ b/river/time_series/intervals.py
@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import abc
+from numbers import Number
+
+import conf
+
+
+class ForecastingInterval(abc.ABC):
+    @abc.abstractmethod
+    def update(self, y_true: list[Number], y_pred: list[Number]) -> ForecastingInterval:
+        """Update the prediction interval along the horizon.
+
+        Parameters
+        ----------
+        y_true
+            Ground truth values at each time step of the horizon.
+        y_pred
+            Predicted values at each time step of the horizon.
+
+        Returns
+        -------
+        self
+
+        """
+
+    @abc.abstractmethod
+    def get(self) -> list[list[float]]:
+        """Return the current prediction interval along the horizon.
+
+        Returns
+        -------
+        The current performance.
+
+        """
+
+
+class HorizonInterval(ForecastingInterval):
+    """Measures the prediction interval at each time step ahead.
+
+    This allows to measure the performance of a model at each time step along the horizon.
+
+    Parameters
+    ----------
+    interval
+        A regression interval.
+
+    Examples
+    --------
+
+    This is used internally by the `time_series.evaluate` function.
+
+    >>> from river import datasets
+    >>> from river import metrics
+    >>> from river import conf
+    >>> from river import time_series
+
+    >>> metric = time_series.evaluate(
+    ...     dataset=datasets.AirlinePassengers(),
+    ...     model=time_series.HoltWinters(alpha=0.1),
+    ...     metric=metrics.MAE(),
+    ...     conformal_prediction=conformal_prediction.ICP(),
+    ...     horizon=4
+    ... )
+
+    >>> metric
+    +1 MAE: 40.931286
+    +2 MAE: 42.667998
+    +3 MAE: 44.158092
+    +4 MAE: 43.849617
+
+    """
+
+    def __init__(self, interval: conf.Interval):
+        self.interval = interval
+        self.intervals: list[conf.Interval] = []
+
+    def update(self, y_true, y_pred):
+        for t, (yt, yp) in enumerate(zip(y_true, y_pred)):
+            try:
+                interval = self.intervals[t]
+            except IndexError:
+                interval = self.interval.clone()
+                self.intervals.append(interval)
+
+            interval.update(yt, yp)
+
+        return self
+
+    def get(self):
+        return [interval.get() for interval in self.intervals]
+
+    def __repr__(self):
+        prefixes = [f"+{t+1}" for t in range(len(self.intervals))]
+        prefix_pad = max(map(len, prefixes))
+        return "\n".join(
+            f"{prefix:<{prefix_pad}} {interval.get()}" for prefix, interval in zip(prefixes, self.intervals)
+        )
diff --git a/river/time_series/test_cp.py b/river/time_series/test_cp.py
new file mode 100644
index 0000000000..56eac1a070
--- /dev/null
+++ b/river/time_series/test_cp.py
@@ -0,0 +1,28 @@
+from river import datasets
+from river import metrics
+import conf
+from .evaluates import evaluate
+from .holt_winters import HoltWinters
+
+dataset = datasets.AirlinePassengers()
+
+model = HoltWinters(
+        alpha=0.3,
+        beta=0.1,
+        gamma=0.6,
+        seasonality=12,
+        multiplicative=True
+        )
+
+calib_period = 100
+metric = metrics.MAE()
+interval = conf.Gaussian(window_size=calib_period)
+
+evaluate(
+        dataset,
+        model,
+        metric,
+        interval,
+        horizon=12,
+        residual_calibration_period = calib_period
+    )