diff --git a/front/admin/db.ts b/front/admin/db.ts
index 044fc1a8f343..0645abad7a88 100644
--- a/front/admin/db.ts
+++ b/front/admin/db.ts
@@ -50,7 +50,7 @@ import {
   DocumentTrackerChangeSuggestion,
   TrackedDocument,
   TrackerConfigurationModel,
-  TrackerDataSouceConfigurationModel,
+  TrackerDataSourceConfigurationModel,
   TrackerGenerationModel,
 } from "@app/lib/models/doc_tracker";
 import { FeatureFlag } from "@app/lib/models/feature_flag";
@@ -129,7 +129,7 @@ async function main() {
   await DocumentTrackerChangeSuggestion.sync({ alter: true });
 
   await TrackerConfigurationModel.sync({ alter: true });
-  await TrackerDataSouceConfigurationModel.sync({ alter: true });
+  await TrackerDataSourceConfigurationModel.sync({ alter: true });
   await TrackerGenerationModel.sync({ alter: true });
 
   await Plan.sync({ alter: true });
diff --git a/front/components/data_source_view/DataSourceViewSelector.tsx b/front/components/data_source_view/DataSourceViewSelector.tsx
index 514de9210255..d19c7c5d2768 100644
--- a/front/components/data_source_view/DataSourceViewSelector.tsx
+++ b/front/components/data_source_view/DataSourceViewSelector.tsx
@@ -90,7 +90,8 @@ interface DataSourceViewsSelectorProps {
   useCase:
     | "spaceDatasourceManagement"
     | "assistantBuilder"
-    | "transcriptsProcessing";
+    | "transcriptsProcessing"
+    | "trackerBuilder";
   dataSourceViews: DataSourceViewType[];
   allowedSpaces?: SpaceType[];
   selectionConfigurations: DataSourceViewSelectionConfigurations;
diff --git a/front/components/trackers/TrackerBuilder.tsx b/front/components/trackers/TrackerBuilder.tsx
index 2b46889775f9..2c01dbdf0508 100644
--- a/front/components/trackers/TrackerBuilder.tsx
+++ b/front/components/trackers/TrackerBuilder.tsx
@@ -11,12 +11,12 @@ import {
   useSendNotification,
 } from "@dust-tt/sparkle";
 import type {
+  DataSourceViewSelectionConfiguration,
   DataSourceViewType,
   SpaceType,
   SubscriptionType,
   SupportedModel,
   TrackerConfigurationStateType,
-  TrackerConfigurationType,
   WorkspaceType,
 } from "@dust-tt/types";
 import {
@@ -28,7 +28,11 @@ import { useState } from "react";
 
 import { AdvancedSettings } from "@app/components/assistant_builder/InstructionScreen";
 import AppLayout from "@app/components/sparkle/AppLayout";
-import { AppLayoutSimpleSaveCancelTitle } from "@app/components/sparkle/AppLayoutTitle";
+import {
+  AppLayoutSimpleCloseTitle,
+  AppLayoutSimpleSaveCancelTitle,
+} from "@app/components/sparkle/AppLayoutTitle";
+import TrackerBuilderDataSourceModal from "@app/components/trackers/TrackerBuilderDataSourceModal";
 import { isEmailValid } from "@app/lib/utils";
 
 export const TrackerBuilder = ({
@@ -36,46 +40,49 @@ export const TrackerBuilder = ({
   subscription,
   globalSpace,
   dataSourceViews,
-  trackerToEdit,
+  initialTrackerState,
+  initialTrackerId,
 }: {
   owner: WorkspaceType;
   subscription: SubscriptionType;
   globalSpace: SpaceType;
   dataSourceViews: DataSourceViewType[];
-  trackerToEdit: TrackerConfigurationType | null;
+  initialTrackerState: TrackerConfigurationStateType | null;
+  initialTrackerId: string | null;
 }) => {
   const router = useRouter();
   const sendNotification = useSendNotification();
-  const [isSubmitting, setIsSubmitting] = useState(false);
 
-  const [tracker, setTracker] = useState<TrackerConfigurationStateType>({
-    name: trackerToEdit?.name ?? null,
-    nameError: null,
-    description: trackerToEdit?.description ?? null,
-    descriptionError: null,
-    prompt: trackerToEdit?.prompt ?? null,
-    promptError: null,
-    frequency: trackerToEdit?.frequency ?? "daily",
-    frequencyError: null,
-    recipients: trackerToEdit?.recipients?.join(", ") ?? null,
-    recipientsError: null,
-    modelId:
-      trackerToEdit?.modelId ?? CLAUDE_3_5_SONNET_DEFAULT_MODEL_CONFIG.modelId,
-    providerId:
-      trackerToEdit?.providerId ??
-      CLAUDE_3_5_SONNET_DEFAULT_MODEL_CONFIG.providerId,
-    temperature: trackerToEdit?.temperature ?? 0.5,
-  });
+  const [edited, setEdited] = useState(false);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [showMaintainedDsModal, setShowMaintainedDsModal] = useState(false);
+  const [showWatchedDsModal, setShowWatchedDataSourcesModal] = useState(false);
 
-  void dataSourceViews; // todo: use this
+  const [tracker, setTracker] = useState<TrackerConfigurationStateType>(
+    initialTrackerState ?? {
+      name: null,
+      nameError: null,
+      description: null,
+      descriptionError: null,
+      prompt: null,
+      promptError: null,
+      frequency: "daily",
+      frequencyError: null,
+      recipients: "",
+      recipientsError: null,
+      modelId: CLAUDE_3_5_SONNET_DEFAULT_MODEL_CONFIG.modelId,
+      providerId: CLAUDE_3_5_SONNET_DEFAULT_MODEL_CONFIG.providerId,
+      temperature: 0.5,
+      maintainedDataSources: {},
+      watchedDataSources: {},
+    }
+  );
 
   const extractEmails = (text: string): string[] => [
     ...new Set(text.split(/[\n,]+/).map((e) => e.trim())),
   ];
 
-  const onSubmit = async () => {
-    // Validate the form
-    setIsSubmitting(true);
+  const validateForm = () => {
     let hasValidationError = false;
     if (!tracker.name) {
       setTracker((t) => ({
@@ -109,6 +116,33 @@ export const TrackerBuilder = ({
       }));
       hasValidationError = true;
     }
+    return hasValidationError;
+  };
+
+  const dataSourceToPayload = (
+    {
+      dataSourceView,
+      selectedResources,
+      isSelectAll,
+    }: DataSourceViewSelectionConfiguration,
+    workspaceId: string
+  ) => ({
+    dataSourceViewId: dataSourceView.sId,
+    workspaceId,
+    filter: {
+      parents: !isSelectAll
+        ? {
+            in: selectedResources.map((r) => r.internalId),
+            not: [],
+          }
+        : null,
+    },
+  });
+
+  // todo use submit function.
+  const onSubmit = async () => {
+    setIsSubmitting(true);
+    const hasValidationError = validateForm();
     if (hasValidationError) {
       setIsSubmitting(false);
       return;
@@ -117,8 +151,8 @@ export const TrackerBuilder = ({
     let route = `/api/w/${owner.sId}/spaces/${globalSpace.sId}/trackers`;
     let method = "POST";
 
-    if (trackerToEdit) {
-      route += `/${trackerToEdit.sId}`;
+    if (initialTrackerId) {
+      route += `/${initialTrackerId}`;
       method = "PATCH";
     }
 
@@ -133,6 +167,12 @@ export const TrackerBuilder = ({
         temperature: tracker.temperature,
         frequency: tracker.frequency,
         recipients: tracker.recipients ? extractEmails(tracker.recipients) : [],
+        maintainedDataSources: Object.values(tracker.maintainedDataSources).map(
+          (ds) => dataSourceToPayload(ds, owner.sId)
+        ),
+        watchedDataSources: Object.values(tracker.watchedDataSources).map(
+          (ds) => dataSourceToPayload(ds, owner.sId)
+        ),
       }),
       headers: {
         "Content-Type": "application/json",
@@ -143,7 +183,7 @@ export const TrackerBuilder = ({
     if (!res.ok) {
       const resJson = await res.json();
       sendNotification({
-        title: trackerToEdit
+        title: initialTrackerId
           ? "Failed to update tracker"
           : "Failed to create tracker",
         description: resJson.error.message,
@@ -154,8 +194,8 @@ export const TrackerBuilder = ({
     }
 
     sendNotification({
-      title: trackerToEdit ? "Tracker updated" : "Tracker Created",
-      description: trackerToEdit
+      title: initialTrackerId ? "Tracker updated" : "Tracker Created",
+      description: initialTrackerId
         ? "Tracker updated successfully"
         : "Tracker created successfully.",
       type: "success",
@@ -170,18 +210,62 @@ export const TrackerBuilder = ({
       subscription={subscription}
       hideSidebar
       isWideMode
-      pageTitle={trackerToEdit ? "Dust - Edit Tracker" : "Dust - New Tracker"}
+      pageTitle={
+        initialTrackerId ? "Dust - Edit Tracker" : "Dust - New Tracker"
+      }
       titleChildren={
-        <AppLayoutSimpleSaveCancelTitle
-          title={trackerToEdit ? "Edit Tracker" : "New Tracker"}
-          onCancel={async () => {
-            await router.push(`/w/${owner.sId}/assistant/labs/trackers`);
-          }}
-          onSave={onSubmit}
-          isSaving={isSubmitting}
-        />
+        !edited ? (
+          <AppLayoutSimpleCloseTitle
+            title={initialTrackerId ? "Edit Tracker" : "New Tracker"}
+            onClose={() => {
+              void router.push(`/w/${owner.sId}/assistant/labs/trackers`);
+            }}
+          />
+        ) : (
+          <AppLayoutSimpleSaveCancelTitle
+            title={initialTrackerId ? "Edit Tracker" : "New Tracker"}
+            onCancel={() => {
+              void router.push(`/w/${owner.sId}/assistant/labs/trackers`);
+            }}
+            onSave={onSubmit}
+            isSaving={isSubmitting}
+          />
+        )
       }
     >
+      <TrackerBuilderDataSourceModal
+        isOpen={showMaintainedDsModal}
+        setOpen={(isOpen) => setShowMaintainedDsModal(isOpen)}
+        owner={owner}
+        onSave={async (dsConfigs) => {
+          setEdited(true);
+          setTracker((t) => ({
+            ...t,
+            maintainedDataSources: dsConfigs,
+          }));
+        }}
+        dataSourceViews={dataSourceViews}
+        initialDataSourceConfigurations={tracker.maintainedDataSources}
+        allowedSpaces={[globalSpace]}
+        viewType="documents"
+      />
+      <TrackerBuilderDataSourceModal
+        isOpen={showWatchedDsModal}
+        setOpen={(isOpen) => setShowWatchedDataSourcesModal(isOpen)}
+        owner={owner}
+        onSave={async (dsConfigs) => {
+          setEdited(true);
+          setTracker((t) => ({
+            ...t,
+            watchedDataSources: dsConfigs,
+          }));
+        }}
+        dataSourceViews={dataSourceViews}
+        initialDataSourceConfigurations={tracker.watchedDataSources}
+        allowedSpaces={[globalSpace]}
+        viewType="documents"
+      />
+
       <div className="mx-auto flex w-full max-w-4xl flex-col gap-16 pb-12">
         <div className="flex">
           <div className="flex flex-grow" />
@@ -343,7 +427,7 @@ export const TrackerBuilder = ({
                 <Button
                   label="Select Documents"
                   onClick={() => {
-                    alert("Select Documents");
+                    setShowMaintainedDsModal(true);
                   }}
                   className="w-fit"
                 />
@@ -359,7 +443,7 @@ export const TrackerBuilder = ({
                 <Button
                   label="Select Documents"
                   onClick={() => {
-                    alert("Select Documents");
+                    setShowWatchedDataSourcesModal(true);
                   }}
                   className="w-fit"
                 />
diff --git a/front/components/trackers/TrackerBuilderDataSourceModal.tsx b/front/components/trackers/TrackerBuilderDataSourceModal.tsx
new file mode 100644
index 000000000000..1e0ad22d5e67
--- /dev/null
+++ b/front/components/trackers/TrackerBuilderDataSourceModal.tsx
@@ -0,0 +1,97 @@
+import { Modal } from "@dust-tt/sparkle";
+import type {
+  ContentNodesViewType,
+  DataSourceViewSelectionConfigurations,
+  DataSourceViewType,
+  SpaceType,
+  WorkspaceType,
+} from "@dust-tt/types";
+import type { SetStateAction } from "react";
+import { useCallback, useMemo, useState } from "react";
+
+import { DataSourceViewsSelector } from "@app/components/data_source_view/DataSourceViewSelector";
+import {
+  supportsDocumentsData,
+  supportsStructuredData,
+} from "@app/lib/data_sources";
+
+interface TrackerBuilderDataSourceModal {
+  initialDataSourceConfigurations: DataSourceViewSelectionConfigurations;
+  allowedSpaces: SpaceType[];
+  dataSourceViews: DataSourceViewType[];
+  isOpen: boolean;
+  onSave: (dsConfigs: DataSourceViewSelectionConfigurations) => void;
+  owner: WorkspaceType;
+  setOpen: (isOpen: boolean) => void;
+  viewType: ContentNodesViewType;
+}
+
+export default function TrackerBuilderDataSourceModal({
+  initialDataSourceConfigurations,
+  allowedSpaces,
+  dataSourceViews,
+  isOpen,
+  onSave,
+  owner,
+  setOpen,
+  viewType,
+}: TrackerBuilderDataSourceModal) {
+  const [hasChanged, setHasChanged] = useState(false);
+
+  const [selectionConfigurations, setSelectionConfigurations] =
+    useState<DataSourceViewSelectionConfigurations>(
+      initialDataSourceConfigurations
+    );
+
+  const setSelectionConfigurationsCallback = useCallback(
+    (func: SetStateAction<DataSourceViewSelectionConfigurations>) => {
+      setHasChanged(true);
+      setSelectionConfigurations(func);
+    },
+    [setSelectionConfigurations]
+  );
+
+  const supportedDataSourceViewsForViewType = useMemo(
+    () =>
+      viewType === "documents"
+        ? dataSourceViews.filter((dsv) => supportsDocumentsData(dsv.dataSource))
+        : dataSourceViews.filter((dsv) =>
+            supportsStructuredData(dsv.dataSource)
+          ),
+    [dataSourceViews, viewType]
+  );
+
+  return (
+    <Modal
+      isOpen={isOpen}
+      onClose={() => {
+        setSelectionConfigurations(initialDataSourceConfigurations);
+        setOpen(false);
+      }}
+      onSave={() => {
+        onSave(selectionConfigurations);
+        setOpen(false);
+      }}
+      hasChanged={hasChanged}
+      variant="side-md"
+      title="Manage data sources selection"
+      className="flex flex-col overflow-hidden"
+    >
+      <div
+        id="dataSourceViewsSelector"
+        className="overflow-y-auto scrollbar-hide"
+      >
+        <DataSourceViewsSelector
+          useCase="trackerBuilder"
+          dataSourceViews={supportedDataSourceViewsForViewType}
+          allowedSpaces={allowedSpaces}
+          owner={owner}
+          selectionConfigurations={selectionConfigurations}
+          setSelectionConfigurations={setSelectionConfigurationsCallback}
+          viewType={viewType}
+          isRootSelectable={true}
+        />
+      </div>
+    </Modal>
+  );
+}
diff --git a/front/lib/models/doc_tracker.ts b/front/lib/models/doc_tracker.ts
index b3238d31b7e9..1ec0a776276c 100644
--- a/front/lib/models/doc_tracker.ts
+++ b/front/lib/models/doc_tracker.ts
@@ -126,7 +126,7 @@ TrackerConfigurationModel.belongsTo(UserModel, {
   foreignKey: { allowNull: true },
 });
 
-export class TrackerDataSouceConfigurationModel extends SoftDeletableModel<TrackerDataSouceConfigurationModel> {
+export class TrackerDataSourceConfigurationModel extends SoftDeletableModel<TrackerDataSourceConfigurationModel> {
   declare createdAt: CreationOptional<Date>;
   declare updatedAt: CreationOptional<Date>;
 
@@ -144,7 +144,7 @@ export class TrackerDataSouceConfigurationModel extends SoftDeletableModel<Track
   declare dataSourceView: NonAttribute<DataSourceViewModel>;
 }
 
-TrackerDataSouceConfigurationModel.init(
+TrackerDataSourceConfigurationModel.init(
   {
     createdAt: {
       type: DataTypes.DATE,
@@ -179,27 +179,28 @@ TrackerDataSouceConfigurationModel.init(
   }
 );
 
-TrackerConfigurationModel.hasMany(TrackerDataSouceConfigurationModel, {
+TrackerConfigurationModel.hasMany(TrackerDataSourceConfigurationModel, {
   foreignKey: { allowNull: false },
   onDelete: "RESTRICT",
+  as: "dataSourceConfigurations",
 });
-TrackerDataSouceConfigurationModel.belongsTo(TrackerConfigurationModel, {
+TrackerDataSourceConfigurationModel.belongsTo(TrackerConfigurationModel, {
   foreignKey: { allowNull: false },
 });
 
-DataSourceModel.hasMany(TrackerDataSouceConfigurationModel, {
+DataSourceModel.hasMany(TrackerDataSourceConfigurationModel, {
   foreignKey: { allowNull: false },
   onDelete: "RESTRICT",
 });
-TrackerDataSouceConfigurationModel.belongsTo(DataSourceModel, {
+TrackerDataSourceConfigurationModel.belongsTo(DataSourceModel, {
   foreignKey: { allowNull: false },
 });
 
-DataSourceViewModel.hasMany(TrackerDataSouceConfigurationModel, {
+DataSourceViewModel.hasMany(TrackerDataSourceConfigurationModel, {
   foreignKey: { allowNull: false },
   onDelete: "RESTRICT",
 });
-TrackerDataSouceConfigurationModel.belongsTo(DataSourceViewModel, {
+TrackerDataSourceConfigurationModel.belongsTo(DataSourceViewModel, {
   foreignKey: { allowNull: false },
 });
 
diff --git a/front/lib/resources/tracker_resource.ts b/front/lib/resources/tracker_resource.ts
index 9e969336798e..c54b3e00be47 100644
--- a/front/lib/resources/tracker_resource.ts
+++ b/front/lib/resources/tracker_resource.ts
@@ -1,15 +1,19 @@
-import type { ModelId, Result, TrackerConfigurationType } from "@dust-tt/types";
+import type {
+  ModelId,
+  Result,
+  TrackerConfigurationType,
+  TrackerDataSourceConfigurationType,
+} from "@dust-tt/types";
 import { Err, Ok, removeNulls } from "@dust-tt/types";
 import assert from "assert";
-import type {
-  Attributes,
-  CreationAttributes,
-  ModelStatic,
-  Transaction,
-} from "sequelize";
+import type { Attributes, CreationAttributes, ModelStatic } from "sequelize";
 
 import type { Authenticator } from "@app/lib/auth";
-import { TrackerConfigurationModel } from "@app/lib/models/doc_tracker";
+import {
+  TrackerConfigurationModel,
+  TrackerDataSourceConfigurationModel,
+} from "@app/lib/models/doc_tracker";
+import { DataSourceViewResource } from "@app/lib/resources/data_source_view_resource";
 import { ResourceWithSpace } from "@app/lib/resources/resource_with_space";
 import type { SpaceResource } from "@app/lib/resources/space_resource";
 import { frontSequelize } from "@app/lib/resources/storage";
@@ -27,32 +31,91 @@ export class TrackerConfigurationResource extends ResourceWithSpace<TrackerConfi
   static model: ModelStatic<TrackerConfigurationModel> =
     TrackerConfigurationModel;
 
+  readonly dataSourceConfigurations: TrackerDataSourceConfigurationModel[];
+
   constructor(
     model: ModelStatic<TrackerConfigurationModel>,
-    blob: Attributes<TrackerConfigurationModel>,
+    blob: Attributes<TrackerConfigurationModel> & {
+      dataSourceConfigurations: TrackerDataSourceConfigurationModel[];
+    },
     space: SpaceResource
   ) {
     super(TrackerConfigurationResource.model, blob, space);
+    this.dataSourceConfigurations = blob.dataSourceConfigurations;
   }
 
   static async makeNew(
     auth: Authenticator,
     blob: CreationAttributes<TrackerConfigurationModel>,
-    space: SpaceResource,
-    transaction?: Transaction
+    maintainedDataSources: TrackerDataSourceConfigurationType[],
+    watchedDataSources: TrackerDataSourceConfigurationType[],
+    space: SpaceResource
   ) {
-    // TODO Daph: Create all related resources.
-    const tracker = await TrackerConfigurationModel.create(
-      {
-        ...blob,
-        workspaceId: auth.getNonNullableWorkspace().id,
-        vaultId: space.id,
-        userId: auth.user()?.id ?? null,
-      },
-      { transaction }
-    );
+    return frontSequelize.transaction(async (transaction) => {
+      const tracker = await TrackerConfigurationModel.create(
+        {
+          ...blob,
+          workspaceId: auth.getNonNullableWorkspace().id,
+          vaultId: space.id,
+          userId: auth.user()?.id ?? null,
+        },
+        { transaction }
+      );
+
+      const createdMaintainedDs = await Promise.all(
+        maintainedDataSources.map(async (m) => {
+          const dataSourceView = await DataSourceViewResource.fetchById(
+            auth,
+            m.dataSourceViewId
+          );
+          return TrackerDataSourceConfigurationModel.create(
+            {
+              scope: "maintained",
+              parentsIn: m.filter.parents?.in ?? null,
+              parentsNotIn: m.filter.parents?.not ?? null,
+              trackerConfigurationId: tracker.id,
+              dataSourceViewId: dataSourceView.id,
+              dataSourceId: dataSourceView.dataSourceId,
+            },
+            { transaction }
+          );
+        })
+      );
+
+      const createdWatchedDs = await Promise.all(
+        watchedDataSources.map(async (w) => {
+          const dataSourceView = await DataSourceViewResource.fetchById(
+            auth,
+            w.dataSourceViewId
+          );
+          return TrackerDataSourceConfigurationModel.create(
+            {
+              scope: "watched",
+              parentsIn: w.filter.parents?.in ?? null,
+              parentsNotIn: w.filter.parents?.not ?? null,
+              trackerConfigurationId: tracker.id,
+              dataSourceViewId: dataSourceView.id,
+              dataSourceId: dataSourceView.dataSourceId,
+            },
+            { transaction }
+          );
+        })
+      );
 
-    return new this(TrackerConfigurationResource.model, tracker.get(), space);
+      const dataSourceConfigurations = [
+        ...createdMaintainedDs,
+        ...createdWatchedDs,
+      ];
+
+      return new this(
+        TrackerConfigurationResource.model,
+        {
+          ...tracker.get(),
+          dataSourceConfigurations,
+        },
+        space
+      );
+    });
   }
 
   // sId.
@@ -81,19 +144,68 @@ export class TrackerConfigurationResource extends ResourceWithSpace<TrackerConfi
 
   async updateConfig(
     auth: Authenticator,
-    blob: Partial<CreationAttributes<TrackerConfigurationModel>>
+    blob: Partial<CreationAttributes<TrackerConfigurationModel>>,
+    maintainedDataSources: TrackerDataSourceConfigurationType[],
+    watchedDataSources: TrackerDataSourceConfigurationType[]
   ): Promise<Result<TrackerConfigurationResource, Error>> {
     assert(this.canWrite(auth), "Unauthorized write attempt");
 
-    await this.update(blob);
-    const updatedTracker = await TrackerConfigurationResource.fetchById(
-      auth,
-      this.sId
-    );
-    if (updatedTracker) {
-      return new Ok(updatedTracker);
-    }
-    return new Err(new Error("Failed to update tracker."));
+    return frontSequelize.transaction(async (transaction) => {
+      await this.update(blob);
+
+      await TrackerDataSourceConfigurationModel.destroy({
+        where: {
+          trackerConfigurationId: this.id,
+        },
+        hardDelete: true,
+        transaction,
+      });
+
+      for (const m of maintainedDataSources) {
+        const dataSourceView = await DataSourceViewResource.fetchById(
+          auth,
+          m.dataSourceViewId
+        );
+        await TrackerDataSourceConfigurationModel.create(
+          {
+            scope: "maintained",
+            parentsIn: m.filter.parents?.in ?? null,
+            parentsNotIn: m.filter.parents?.not ?? null,
+            trackerConfigurationId: this.id,
+            dataSourceViewId: dataSourceView.id,
+            dataSourceId: dataSourceView.dataSourceId,
+          },
+          { transaction }
+        );
+      }
+
+      for (const w of watchedDataSources) {
+        const dataSourceView = await DataSourceViewResource.fetchById(
+          auth,
+          w.dataSourceViewId
+        );
+        await TrackerDataSourceConfigurationModel.create(
+          {
+            scope: "watched",
+            parentsIn: w.filter.parents?.in ?? null,
+            parentsNotIn: w.filter.parents?.not ?? null,
+            trackerConfigurationId: this.id,
+            dataSourceViewId: dataSourceView.id,
+            dataSourceId: dataSourceView.dataSourceId,
+          },
+          { transaction }
+        );
+      }
+
+      const updatedTracker = await TrackerConfigurationResource.fetchById(
+        auth,
+        this.sId
+      );
+      if (updatedTracker) {
+        return new Ok(updatedTracker);
+      }
+      return new Err(new Error("Failed to update tracker."));
+    });
   }
 
   // Fetching.
@@ -102,8 +214,16 @@ export class TrackerConfigurationResource extends ResourceWithSpace<TrackerConfi
     auth: Authenticator,
     options?: ResourceFindOptions<TrackerConfigurationModel>
   ) {
+    // @todo(DOC_TRACKER) Fix to remove the ts-expect-error.
+    // @ts-expect-error Resource with space does not like my include but it works.
     const trackers = await this.baseFetchWithAuthorization(auth, {
       ...options,
+      includes: [
+        {
+          model: TrackerDataSourceConfigurationModel,
+          as: "dataSourceConfigurations",
+        },
+      ],
     });
 
     // This is what enforces the accessibility to an app.
@@ -117,6 +237,7 @@ export class TrackerConfigurationResource extends ResourceWithSpace<TrackerConfi
     ids: string[]
   ): Promise<TrackerConfigurationResource[]> {
     const modelIds = removeNulls(ids.map((id) => getResourceIdFromSId(id)));
+
     return this.baseFetch(auth, {
       where: {
         id: modelIds,
@@ -129,7 +250,6 @@ export class TrackerConfigurationResource extends ResourceWithSpace<TrackerConfi
     id: string
   ): Promise<TrackerConfigurationResource | null> {
     const [tracker] = await this.fetchByIds(auth, [id]);
-
     return tracker ?? null;
   }
 
@@ -186,6 +306,22 @@ export class TrackerConfigurationResource extends ResourceWithSpace<TrackerConfi
   // Serialization.
 
   toJSON(): TrackerConfigurationType {
+    const dataSourceToJSON = (dsc: TrackerDataSourceConfigurationModel) => ({
+      dataSourceViewId: makeSId("data_source_view", {
+        id: dsc.dataSourceViewId,
+        workspaceId: this.workspaceId,
+      }),
+      filter: {
+        parents:
+          dsc.parentsIn === null && dsc.parentsNotIn === null
+            ? null
+            : {
+                in: dsc.parentsIn ?? [],
+                not: dsc.parentsNotIn ?? [],
+              },
+      },
+    });
+
     return {
       id: this.id,
       sId: this.sId,
@@ -196,9 +332,15 @@ export class TrackerConfigurationResource extends ResourceWithSpace<TrackerConfi
       providerId: this.providerId,
       temperature: this.temperature,
       prompt: this.prompt,
-      frequency: this.frequency,
+      frequency: this.frequency ?? "daily",
       recipients: this.recipients ?? [],
       space: this.space.toJSON(),
+      maintainedDataSources: this.dataSourceConfigurations
+        .filter((dsc) => dsc.scope === "maintained")
+        .map(dataSourceToJSON),
+      watchedDataSources: this.dataSourceConfigurations
+        .filter((dsc) => dsc.scope === "watched")
+        .map(dataSourceToJSON),
     };
   }
 }
diff --git a/front/pages/api/w/[wId]/spaces/[spaceId]/trackers/[tId]/index.ts b/front/pages/api/w/[wId]/spaces/[spaceId]/trackers/[tId]/index.ts
new file mode 100644
index 000000000000..85c2dbc266f7
--- /dev/null
+++ b/front/pages/api/w/[wId]/spaces/[spaceId]/trackers/[tId]/index.ts
@@ -0,0 +1,114 @@
+import type { WithAPIErrorResponse } from "@dust-tt/types";
+import { isLeft } from "fp-ts/lib/Either";
+import * as reporter from "io-ts-reporters";
+import type { NextApiRequest, NextApiResponse } from "next";
+
+import { withSessionAuthenticationForWorkspace } from "@app/lib/api/auth_wrappers";
+import { withResourceFetchingFromRoute } from "@app/lib/api/resource_wrappers";
+import type { Authenticator } from "@app/lib/auth";
+import { TrackerConfigurationResource } from "@app/lib/resources/tracker_resource";
+import { apiError } from "@app/logger/withlogging";
+import type { GetTrackersResponseBody } from "@app/pages/api/w/[wId]/spaces/[spaceId]/trackers";
+import { PostTrackersRequestBodySchema } from "@app/pages/api/w/[wId]/spaces/[spaceId]/trackers";
+
+async function handler(
+  req: NextApiRequest,
+  res: NextApiResponse<WithAPIErrorResponse<GetTrackersResponseBody>>,
+  auth: Authenticator
+): Promise<void> {
+  switch (req.method) {
+    case "PATCH":
+      if (typeof req.query.tId !== "string") {
+        return apiError(req, res, {
+          status_code: 400,
+          api_error: {
+            type: "invalid_request_error",
+            message: "Invalid tracker id provided.",
+          },
+        });
+      }
+      const trackerId = req.query.tId;
+      const bodyValidation = PostTrackersRequestBodySchema.decode(req.body);
+
+      if (isLeft(bodyValidation)) {
+        const pathError = reporter.formatValidationErrors(bodyValidation.left);
+        return apiError(req, res, {
+          status_code: 400,
+          api_error: {
+            type: "invalid_request_error",
+            message: `Invalid request body: ${pathError}`,
+          },
+        });
+      }
+
+      const tracker = await TrackerConfigurationResource.fetchById(
+        auth,
+        trackerId
+      );
+
+      if (!tracker) {
+        return apiError(req, res, {
+          status_code: 404,
+          api_error: {
+            type: "invalid_request_error",
+            message: "Tracker not found.",
+          },
+        });
+      }
+
+      if (!tracker.canWrite(auth)) {
+        return apiError(req, res, {
+          status_code: 403,
+          api_error: {
+            type: "workspace_auth_error",
+            message: "You are not authorized to update this tracker.",
+          },
+        });
+      }
+
+      const body = bodyValidation.right;
+
+      const updatedTrackerRes = await tracker.updateConfig(
+        auth,
+        {
+          name: body.name,
+          description: body.description,
+          prompt: body.prompt,
+          modelId: body.modelId,
+          providerId: body.providerId,
+          temperature: body.temperature,
+          status: "active",
+          frequency: body.frequency,
+          recipients: body.recipients,
+        },
+        body.maintainedDataSources,
+        body.watchedDataSources
+      );
+
+      if (updatedTrackerRes.isOk()) {
+        return res.status(201).json({
+          trackers: [updatedTrackerRes.value.toJSON()],
+        });
+      }
+      return apiError(req, res, {
+        status_code: 500,
+        api_error: {
+          type: "internal_server_error",
+          message: "Failed to update tracker.",
+        },
+      });
+
+    default:
+      return apiError(req, res, {
+        status_code: 405,
+        api_error: {
+          type: "method_not_supported_error",
+          message: "The method passed is not supported, PATCH is expected.",
+        },
+      });
+  }
+}
+
+export default withSessionAuthenticationForWorkspace(
+  withResourceFetchingFromRoute(handler, "space")
+);
diff --git a/front/pages/api/w/[wId]/spaces/[spaceId]/trackers/index.ts b/front/pages/api/w/[wId]/spaces/[spaceId]/trackers/index.ts
index a21ef4f4e627..0b526188e9df 100644
--- a/front/pages/api/w/[wId]/spaces/[spaceId]/trackers/index.ts
+++ b/front/pages/api/w/[wId]/spaces/[spaceId]/trackers/index.ts
@@ -23,6 +23,22 @@ export type GetTrackersResponseBody = {
   trackers: TrackerConfigurationType[];
 };
 
+const TrackerDataSourcesConfigurationBodySchema = t.array(
+  t.type({
+    dataSourceViewId: t.string,
+    workspaceId: t.string,
+    filter: t.type({
+      parents: t.union([
+        t.type({
+          in: t.array(t.string),
+          not: t.array(t.string),
+        }),
+        t.null,
+      ]),
+    }),
+  })
+);
+
 export const PostTrackersRequestBodySchema = t.type({
   name: t.string,
   description: t.union([t.string, t.null]),
@@ -32,6 +48,8 @@ export const PostTrackersRequestBodySchema = t.type({
   frequency: FrequencyCodec,
   temperature: t.number,
   recipients: t.array(t.string),
+  maintainedDataSources: TrackerDataSourcesConfigurationBodySchema,
+  watchedDataSources: TrackerDataSourcesConfigurationBodySchema,
 });
 
 async function handler(
@@ -76,8 +94,9 @@ async function handler(
           frequency: body.frequency,
           recipients: body.recipients,
         },
-        space,
-        undefined // transaction
+        body.maintainedDataSources,
+        body.watchedDataSources,
+        space
       );
       return res.status(201).json({
         trackers: [tracker.toJSON()],
diff --git a/front/pages/w/[wId]/assistant/labs/trackers/[tId]/index.tsx b/front/pages/w/[wId]/assistant/labs/trackers/[tId]/index.tsx
index 60956d03ae40..9c2a37a55118 100644
--- a/front/pages/w/[wId]/assistant/labs/trackers/[tId]/index.tsx
+++ b/front/pages/w/[wId]/assistant/labs/trackers/[tId]/index.tsx
@@ -1,19 +1,24 @@
 import type {
+  DataSourceViewSelectionConfigurations,
   DataSourceViewType,
   PlanType,
   SpaceType,
   SubscriptionType,
+  TrackerConfigurationStateType,
   TrackerConfigurationType,
+  TrackerDataSourceConfigurationType,
   WorkspaceType,
 } from "@dust-tt/types";
 import type { InferGetServerSidePropsType } from "next";
 
 import { TrackerBuilder } from "@app/components/trackers/TrackerBuilder";
 import config from "@app/lib/api/config";
+import { getContentNodesForDataSourceView } from "@app/lib/api/data_source_view";
 import { withDefaultUserAuthRequirements } from "@app/lib/iam/session";
 import { DataSourceViewResource } from "@app/lib/resources/data_source_view_resource";
 import { SpaceResource } from "@app/lib/resources/space_resource";
 import { TrackerConfigurationResource } from "@app/lib/resources/tracker_resource";
+import logger from "@app/logger/logger";
 
 export const getServerSideProps = withDefaultUserAuthRequirements<{
   baseUrl: string;
@@ -23,7 +28,8 @@ export const getServerSideProps = withDefaultUserAuthRequirements<{
   subscription: SubscriptionType;
   globalSpace: SpaceType;
   dataSourceViews: DataSourceViewType[];
-  trackerToEdit: TrackerConfigurationType;
+  initialTrackerState: TrackerConfigurationStateType;
+  initialTrackerId: string;
 }>(async (_context, auth) => {
   const owner = auth.workspace();
   const plan = auth.plan();
@@ -55,6 +61,11 @@ export const getServerSideProps = withDefaultUserAuthRequirements<{
     globalSpace,
   ]);
 
+  const initialTrackerState = await initializeTrackerBuilderState(
+    tracker.toJSON(),
+    dataSourceViews
+  );
+
   return {
     props: {
       baseUrl: config.getClientFacingUrl(),
@@ -64,7 +75,8 @@ export const getServerSideProps = withDefaultUserAuthRequirements<{
       plan,
       subscription,
       globalSpace: globalSpace.toJSON(),
-      trackerToEdit: tracker.toJSON(),
+      initialTrackerState: initialTrackerState,
+      initialTrackerId: trackerId,
     },
   };
 });
@@ -74,7 +86,8 @@ export default function DocumentTracker({
   subscription,
   globalSpace,
   dataSourceViews,
-  trackerToEdit,
+  initialTrackerState,
+  initialTrackerId,
 }: InferGetServerSidePropsType<typeof getServerSideProps>) {
   return (
     <TrackerBuilder
@@ -82,7 +95,121 @@ export default function DocumentTracker({
       subscription={subscription}
       globalSpace={globalSpace}
       dataSourceViews={dataSourceViews}
-      trackerToEdit={trackerToEdit}
+      initialTrackerState={initialTrackerState}
+      initialTrackerId={initialTrackerId}
     />
   );
 }
+
+const initializeTrackerBuilderState = async (
+  trackerToEdit: TrackerConfigurationType,
+  dataSourceViews: DataSourceViewResource[]
+): Promise<TrackerConfigurationStateType> => {
+  const maintainedDataSources = await renderDataSourcesConfigurations(
+    trackerToEdit.sId,
+    trackerToEdit.maintainedDataSources,
+    dataSourceViews
+  );
+
+  const watchedDataSources = await renderDataSourcesConfigurations(
+    trackerToEdit.sId,
+    trackerToEdit.watchedDataSources,
+    dataSourceViews
+  );
+
+  return {
+    name: trackerToEdit.name,
+    description: trackerToEdit.description,
+    prompt: trackerToEdit.prompt,
+    modelId: trackerToEdit.modelId,
+    providerId: trackerToEdit.providerId,
+    temperature: trackerToEdit.temperature,
+    frequency: trackerToEdit.frequency ?? "daily",
+    recipients: trackerToEdit.recipients?.join(",") || "",
+    maintainedDataSources,
+    watchedDataSources,
+    nameError: null,
+    descriptionError: null,
+    promptError: null,
+    frequencyError: null,
+    recipientsError: null,
+  };
+};
+
+const renderDataSourcesConfigurations = async (
+  trackerId: string,
+  dataSourceConfigs: TrackerDataSourceConfigurationType[],
+  dataSourceViews: DataSourceViewResource[]
+): Promise<DataSourceViewSelectionConfigurations> => {
+  const selectedResources = dataSourceConfigs.map((ds) => ({
+    dataSourceViewId: ds.dataSourceViewId,
+    resources: ds.filter.parents?.in ?? null,
+    isSelectAll: !ds.filter.parents,
+  }));
+
+  const dataSourceConfigurationsArray = await Promise.all(
+    selectedResources.map(async (sr) => {
+      const dataSourceView = dataSourceViews.find(
+        (dsv) => dsv.sId === sr.dataSourceViewId
+      );
+      if (!dataSourceView) {
+        throw new Error(
+          `Could not find DataSourceView with id ${sr.dataSourceViewId}`
+        );
+      }
+
+      const serializedDataSourceView = dataSourceView.toJSON();
+
+      if (!dataSourceView.dataSource.connectorId || !sr.resources) {
+        return {
+          dataSourceView: serializedDataSourceView,
+          selectedResources: [],
+          isSelectAll: sr.isSelectAll,
+        };
+      }
+
+      const contentNodesRes = await getContentNodesForDataSourceView(
+        dataSourceView,
+        {
+          internalIds: sr.resources,
+          viewType: "documents",
+        }
+      );
+
+      if (contentNodesRes.isErr()) {
+        logger.error(
+          {
+            trackerId: trackerId,
+            dataSourceView: dataSourceView.toTraceJSON(),
+            error: contentNodesRes.error,
+            internalIds: sr.resources,
+            workspace: {
+              id: dataSourceView.workspaceId,
+            },
+          },
+          "Tracker Builder: Error fetching content nodes for documents."
+        );
+
+        return {
+          dataSourceView: serializedDataSourceView,
+          selectedResources: [],
+          isSelectAll: sr.isSelectAll,
+        };
+      }
+
+      return {
+        dataSourceView: serializedDataSourceView,
+        selectedResources: contentNodesRes.value.nodes,
+        isSelectAll: sr.isSelectAll,
+      };
+    })
+  );
+
+  return dataSourceConfigurationsArray.reduce(
+    (acc, curr) => ({
+      ...acc,
+      [curr.dataSourceView.sId]: curr,
+    }),
+    {} as DataSourceViewSelectionConfigurations
+  );
+};
diff --git a/front/pages/w/[wId]/assistant/labs/trackers/new.tsx b/front/pages/w/[wId]/assistant/labs/trackers/new.tsx
index dcd7fa85ac82..86c0e9285237 100644
--- a/front/pages/w/[wId]/assistant/labs/trackers/new.tsx
+++ b/front/pages/w/[wId]/assistant/labs/trackers/new.tsx
@@ -62,7 +62,8 @@ export default function DocumentTracker({
       subscription={subscription}
       globalSpace={globalSpace}
       dataSourceViews={dataSourceViews}
-      trackerToEdit={null}
+      initialTrackerState={null}
+      initialTrackerId={null}
     />
   );
 }
diff --git a/types/src/front/tracker.ts b/types/src/front/tracker.ts
index 9136161a4dc4..06f6f4903071 100644
--- a/types/src/front/tracker.ts
+++ b/types/src/front/tracker.ts
@@ -1,5 +1,6 @@
 import { ModelId } from "../shared/model_id";
 import { ioTsEnum } from "../shared/utils/iots_utils";
+import { DataSourceViewSelectionConfigurations } from "./data_source_view";
 import { ModelIdType, ModelProviderIdType } from "./lib/assistant";
 import { SpaceType } from "./space";
 
@@ -13,9 +14,21 @@ export type TrackerConfigurationType = {
   providerId: ModelProviderIdType;
   temperature: number;
   prompt: string | null;
-  frequency: string | null;
+  frequency: string;
   recipients: string[];
   space: SpaceType;
+  maintainedDataSources: TrackerDataSourceConfigurationType[];
+  watchedDataSources: TrackerDataSourceConfigurationType[];
+};
+
+export type TrackerDataSourceConfigurationType = {
+  dataSourceViewId: string;
+  filter: {
+    parents: {
+      in: string[];
+      not: string[];
+    } | null;
+  };
 };
 
 export type TrackerConfigurationStateType = {
@@ -32,6 +45,8 @@ export type TrackerConfigurationStateType = {
   modelId: ModelIdType;
   providerId: ModelProviderIdType;
   temperature: number;
+  maintainedDataSources: DataSourceViewSelectionConfigurations;
+  watchedDataSources: DataSourceViewSelectionConfigurations;
 };
 
 export const TRACKER_FREQUENCY_TYPES: TrackerFrequencyType[] = [