diff --git a/.gitignore b/.gitignore
index bf0d160a0..f8930d9a6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -53,6 +53,7 @@ _build/
 *.tar.gz
 *.tsv
 *.ann
+!text.ann
 
 # Editors
 .idea
diff --git a/changelog.md b/changelog.md
index 1601e5141..8043660e8 100644
--- a/changelog.md
+++ b/changelog.md
@@ -6,6 +6,14 @@
 
 - `eds.tables` accepts a minimum_table_size (default 2) argument to reduce pollution
 - `RuleBasedQualifier` now expose a `process` method that only returns qualified entities and token without actually tagging them, defering this task to the `__call__` method.
+- Relation implementation in `doc.spans["<label>"][i]._.rel = [{'type':'rel_type', 'target': <span>},]`
+- Relation connector with brat2docs and docs2brat in `edsnlp.connectors.brat` compatible with `edsnlp.data.read_*` and `edsnlp.data.write_*` (modified files : `edsnlp.data.converters`, `edsnlp.data.standoff`)
+- Rule based relation model using proximity and/or sentence in `edsnlp.pipes.misc.relations` registered as `eds.relation`
+- Documentation using Mkdocs for relations `docs.pipes.misc.relations.md` and `docs.pipes.misc.index.md`
+- Tests for relations `tests.pipelines.misc.test_relations` and ressources `ressources.relations`
+- `data.set_processing(...)` now expose an `autocast` parameter to disable or tweak the automatic casting of the tensor
+  during the processing. Autocasting should result in a slight speedup, but may lead to numerical instability.
+- Use `torch.inference_mode` to disable view tracking and version counter bumps during inference.
 
 ### Fixed
 
diff --git a/docs/pipes/misc/index.md b/docs/pipes/misc/index.md
index 5a38acd99..6ab323d5c 100644
--- a/docs/pipes/misc/index.md
+++ b/docs/pipes/misc/index.md
@@ -16,5 +16,6 @@ For instance, the date detection and normalisation pipeline falls in this catego
 | `eds.sections`           | Section detection                           |
 | `eds.reason`             | Rule-based hospitalisation reason detection |
 | `eds.tables`             | Tables detection                            |
+| `eds.relations`          | Relations extraction                        |
 
 <!-- --8<-- [end:components] -->
diff --git a/docs/pipes/misc/relations.md b/docs/pipes/misc/relations.md
new file mode 100644
index 000000000..5157b9db1
--- /dev/null
+++ b/docs/pipes/misc/relations.md
@@ -0,0 +1,8 @@
+# Relations {: #edsnlp.pipes.misc.relations.factory.create_component }
+
+::: edsnlp.pipes.misc.relations.factory.create_component
+    options:
+        heading_level: 2
+        show_bases: false
+        show_source: false
+        only_class_level: true
diff --git a/edsnlp/data/converters.py b/edsnlp/data/converters.py
index 37061cc57..87789ec10 100644
--- a/edsnlp/data/converters.py
+++ b/edsnlp/data/converters.py
@@ -191,6 +191,9 @@ class StandoffDict2DocConverter:
     span_attributes : Optional[AttributesMappingArg]
         Mapping from BRAT attributes to Span extensions (can be a list too).
         By default, all attributes are imported as Span extensions with the same name.
+    span_rel : Optional[AttributesMappingArg]
+        Mapping from BRAT relations to Span extensions (can be a list too).
+        By default, all relations are imported as Span extensions with the name rel.
     keep_raw_attribute_values : bool
         Whether to keep the raw attribute values (as strings) or to convert them to
         Python objects (e.g. booleans).
@@ -214,6 +217,7 @@ def __init__(
         tokenizer: Optional[Tokenizer] = None,
         span_setter: SpanSetterArg = {"ents": True, "*": True},
         span_attributes: Optional[AttributesMappingArg] = None,
+        span_rel: Optional[AttributesMappingArg] = None,  # to keep ?
         keep_raw_attribute_values: bool = False,
         bool_attributes: SequenceStr = [],
         default_attributes: AttributesMappingArg = {},
@@ -223,6 +227,7 @@ def __init__(
         self.tokenizer = tokenizer or (nlp.tokenizer if nlp is not None else None)
         self.span_setter = span_setter
         self.span_attributes = span_attributes  # type: ignore
+        self.span_rel = span_rel  # to keep ?
         self.keep_raw_attribute_values = keep_raw_attribute_values
         self.default_attributes = default_attributes
         self.notes_as_span_attribute = notes_as_span_attribute
@@ -244,12 +249,19 @@ def __call__(self, obj):
             if not Span.has_extension(dst):
                 Span.set_extension(dst, default=None)
 
+        ############## Modifications for relations ###############
+        dict_entities = {}  ## dict for entity storage
         for ent in obj.get("entities") or ():
+            begin = min(f["begin"] for f in ent["fragments"])  # start of the entity
+            end = max(f["end"] for f in ent["fragments"])  # end of the entity
+            dict_entities[ent["entity_id"]] = (
+                ent["label"] + ";" + str(begin) + ";" + str(end)
+            )
             fragments = (
                 [
                     {
-                        "begin": min(f["begin"] for f in ent["fragments"]),
-                        "end": max(f["end"] for f in ent["fragments"]),
+                        "begin": begin,
+                        "end": end,
                     }
                 ]
                 if not self.split_fragments
@@ -267,6 +279,11 @@ def __call__(self, obj):
                     if isinstance(ent["attributes"], list)
                     else ent["attributes"]
                 )
+                attributes = (
+                    {a["label"]: a["value"] for a in ent["attributes"]}
+                    if isinstance(ent["attributes"], list)
+                    else ent["attributes"]
+                )
                 if self.notes_as_span_attribute and ent["notes"]:
                     ent["attributes"][self.notes_as_span_attribute] = "|".join(
                         note["value"] for note in ent["notes"]
@@ -302,6 +319,67 @@ def __call__(self, obj):
                 if span._.get(attr) is None:
                     span._.set(attr, value)
 
+        ############## Modifications fo relations ###############
+        # add relations in spans
+        if self.span_rel is None and not Span.has_extension("rel"):
+            Span.set_extension("rel", default=[])
+
+        for rel in obj.get("relations") or ():  # iterates relations
+            for label in doc.spans:  # iterates source labels
+                for i, spa in enumerate(doc.spans[label]):  # iterates source spans
+                    bo = False
+
+                    # relations
+                    if dict_entities[rel["from_entity_id"]].split(";") == [
+                        label,
+                        str(spa.start_char),
+                        str(spa.end_char),
+                    ]:  # sif source entity is the same as the span
+                        for label2 in doc.spans:  # iiterates target labels
+                            for j, spa2 in enumerate(
+                                doc.spans[label2]
+                            ):  # iterates target label
+                                if dict_entities[rel["to_entity_id"]].split(";") == [
+                                    label2,
+                                    str(spa2.start_char),
+                                    str(spa2.end_char),
+                                ]:  # if target entity is the same as the span
+                                    relation = {
+                                        "type": rel["relation_label"],
+                                        "target": doc.spans[label2][j],
+                                    }  # create the relation
+                                    doc.spans[label][i]._.rel.append(
+                                        relation
+                                    )  # add the relation to the span
+                                    bo = True
+                                    break
+                            if bo:
+                                break
+                    bo = False
+
+                    # inverse relations
+                    if dict_entities[rel["to_entity_id"]].split(";") == [
+                        label,
+                        str(spa.start_char),
+                        str(spa.end_char),
+                    ]:
+                        for label2 in doc.spans:
+                            for j, spa2 in enumerate(doc.spans[label2]):
+                                if dict_entities[rel["from_entity_id"]].split(";") == [
+                                    label2,
+                                    str(spa2.start_char),
+                                    str(spa2.end_char),
+                                ]:
+                                    relation = {
+                                        "type": "inv_" + rel["relation_label"],
+                                        "target": doc.spans[label2][j],
+                                    }
+                                    doc.spans[label][i]._.rel.append(relation)
+                                    bo = True
+                                    break
+                            if bo:
+                                break
+
         return doc
 
 
@@ -346,29 +424,75 @@ def __init__(
 
     def __call__(self, doc):
         spans = get_spans(doc, self.span_getter)
+        entities = [
+            {
+                "entity_id": i,
+                "fragments": [
+                    {
+                        "begin": ent.start_char,
+                        "end": ent.end_char,
+                    }
+                ],
+                "attributes": {
+                    obj_name: getattr(ent._, ext_name)
+                    for ext_name, obj_name in self.span_attributes.items()
+                    if ent._.has(ext_name)
+                },
+                "label": ent.label_,
+            }
+            for i, ent in enumerate(sorted(dict.fromkeys(spans)))
+        ]
+
+        # mapping between entities and their `entity_id`
+        entity_map = {
+            (
+                ent["fragments"][0]["begin"],
+                ent["fragments"][0]["end"],
+                ent["label"],
+            ): ent["entity_id"]
+            for ent in entities
+        }
+
+        # doesn't include 'inv_' relations
+        relations = []
+        relation_idx = 1
+        for span_label, span_list in doc.spans.items():
+            for spa in span_list:
+                source_entity_id = entity_map.get(
+                    (spa.start_char, spa.end_char, spa.label_)
+                )
+                for rel in spa._.rel:
+                    if not rel["type"].startswith("inv_"):
+                        target_entity_id = entity_map.get(
+                            (
+                                rel["target"].start_char,
+                                rel["target"].end_char,
+                                rel["target"].label_,
+                            )
+                        )
+                        if (
+                            source_entity_id is not None
+                            and target_entity_id is not None
+                        ):
+                            relations.append(
+                                {
+                                    "rel_id": relation_idx,
+                                    "from_entity_id": source_entity_id,
+                                    "relation_type": rel["type"],
+                                    "to_entity_id": target_entity_id,
+                                }
+                            )
+                            relation_idx += 1
+
+        # final object
         obj = {
             FILENAME: doc._.note_id,
             "doc_id": doc._.note_id,
             "text": doc.text,
-            "entities": [
-                {
-                    "entity_id": i,
-                    "fragments": [
-                        {
-                            "begin": ent.start_char,
-                            "end": ent.end_char,
-                        }
-                    ],
-                    "attributes": {
-                        obj_name: getattr(ent._, ext_name)
-                        for ext_name, obj_name in self.span_attributes.items()
-                        if ent._.has(ext_name)
-                    },
-                    "label": ent.label_,
-                }
-                for i, ent in enumerate(sorted(dict.fromkeys(spans)))
-            ],
+            "entities": entities,
+            "relations": relations,
         }
+
         return obj
 
 
diff --git a/edsnlp/data/standoff.py b/edsnlp/data/standoff.py
index 59a46aaca..777d1c394 100644
--- a/edsnlp/data/standoff.py
+++ b/edsnlp/data/standoff.py
@@ -264,20 +264,20 @@ def dump_standoff_file(
                                     file=f,
                                 )
                                 attribute_idx += 1
-
-                    # fmt: off
-                    # if "relations" in doc:
-                    #     for i, relation in enumerate(doc["relations"]):
-                    #         entity_from = entities_ids[relation["from_entity_id"]]
-                    #         entity_to = entities_ids[relation["to_entity_id"]]
-                    #         print(
-                    #             "R{}\t{} Arg1:{} Arg2:{}\t".format(
-                    #                 i + 1, str(relation["label"]), entity_from,
-                    #                 entity_to
-                    #             ),
-                    #             file=f,
-                    #         )
-                    # fmt: on
+            # Ajout du traitement des relations
+            relation_idx = 1
+            if "relations" in doc:
+                for relation in doc["relations"]:
+                    print(
+                        "R{}\t{} Arg1:{} Arg2:{}".format(
+                            relation_idx,
+                            relation["relation_type"],
+                            entities_ids[relation["from_entity_id"]],
+                            entities_ids[relation["to_entity_id"]],
+                        ),
+                        file=f,
+                    )
+                    relation_idx += 1
 
 
 class StandoffReader(BaseReader):
diff --git a/edsnlp/pipes/__init__.py b/edsnlp/pipes/__init__.py
index c197e400c..1568e3194 100644
--- a/edsnlp/pipes/__init__.py
+++ b/edsnlp/pipes/__init__.py
@@ -22,6 +22,7 @@
     from .misc.dates.factory import create_component as dates
     from .misc.quantities.factory import create_component as quantities
     from .misc.reason.factory import create_component as reason
+    from .misc.relations.factory import create_component as relations
     from .misc.sections.factory import create_component as sections
     from .misc.tables.factory import create_component as tables
     from .ner.adicap.factory import create_component as adicap
diff --git a/edsnlp/pipes/misc/relations/__init__.py b/edsnlp/pipes/misc/relations/__init__.py
new file mode 100644
index 000000000..5fd446779
--- /dev/null
+++ b/edsnlp/pipes/misc/relations/__init__.py
@@ -0,0 +1 @@
+from .relations import RelationsMatcher
diff --git a/edsnlp/pipes/misc/relations/factory.py b/edsnlp/pipes/misc/relations/factory.py
new file mode 100644
index 000000000..7904fca3b
--- /dev/null
+++ b/edsnlp/pipes/misc/relations/factory.py
@@ -0,0 +1,17 @@
+from edsnlp.core import registry
+
+from .relations import RelationsMatcher
+
+DEFAULT_CONFIG = dict(
+    scheme=None,
+    use_sentences=False,
+    clean_rel=False,
+    proximity_method="right",
+    max_dist=45,
+)
+
+create_component = registry.factory.register(
+    "eds.relations",
+    assigns=["doc.spans"],
+    deprecated=["relations"],
+)(RelationsMatcher)
diff --git a/edsnlp/pipes/misc/relations/patterns.py b/edsnlp/pipes/misc/relations/patterns.py
new file mode 100644
index 000000000..cba035219
--- /dev/null
+++ b/edsnlp/pipes/misc/relations/patterns.py
@@ -0,0 +1,17 @@
+scheme = [
+    {
+        "source": [{"label": "Chemical_and_drugs", "attr": {"Tech": [None]}}],
+        "target": [
+            {
+                "label": "Temporal",
+                "attr": {"AttTemp": [None, "Duration", "Date", "Frequency"]},
+            },
+            {
+                "label": "Chemical_and_drugs",
+                "attr": {"Tech": ["dosage", "route", "strength", "form"]},
+            },
+        ],
+        "type": "Depend",
+        "inv_type": "inv_Depend",
+    },
+]
diff --git a/edsnlp/pipes/misc/relations/relations.py b/edsnlp/pipes/misc/relations/relations.py
new file mode 100644
index 000000000..49aba0266
--- /dev/null
+++ b/edsnlp/pipes/misc/relations/relations.py
@@ -0,0 +1,564 @@
+import json
+from typing import Any, Dict, List, Union
+
+import numpy as np
+from loguru import logger
+from numpy.typing import NDArray
+from spacy.tokens import Doc, Span
+
+from edsnlp.core import PipelineProtocol
+from edsnlp.pipes.misc.relations import patterns
+
+
+class RelationsMatcher:
+    '''
+    The `eds.relations` component links source and target Named Entities +/- Attributes.
+    This component is rule-based and utilizes character proximity
+    to determine relationships.
+
+
+    Examples
+    --------
+    In this simple example, we extract drugs and dates \
+        from a text and link them together.
+    ```python
+    import edsnlp, edsnlp.pipes as eds
+
+    text = """
+        Prise pendant 3 semaines d'Amlodipine 5mg per os une fois par jour \
+            mais l'HTA reste mal contrôlée.
+        Metformine 500 mg deux fois par jour à partir du 27/05/2022.
+        Consultation chez un cardiologue le 11/07 pour évaluation de l'HTA, \
+            dans l'attente majoration de l'AMLODIPINE à 10 mg.
+        """
+
+    scheme = {
+        "source": [{"label": "drug", "attr": None}],
+        "target": [
+            {"label": "dates", "attr": None},
+            {"label": "durations", "attr": None},
+        ],
+        "type": "Temporal",
+        "inv_type": "inv_Temporal",
+    }
+
+    nlp = edsnlp.blank("eds")
+
+    # Extraction of entities
+    nlp.add_pipe("eds.drugs")
+    nlp.add_pipe("eds.dates")
+    # Extraction of sentences
+    nlp.add_pipe("eds.sentences")
+    # Extraction of relations
+    nlp.add_pipe(
+        "eds.relations",
+        config={
+            "scheme": scheme,
+            "use_sentences": True,
+            "clean_rel": True,
+            "proximity_method": "sym",
+            "max_dist": 60,
+        },
+    )
+    doc = nlp(text)
+
+    for label in doc.spans:
+        print("Label: ", label, "\t Entities :", doc.spans[label])
+        for span in doc.spans[label]:
+            print("\t Entity :", span, "\t Relations :", span._.rel)
+
+        # Out: Label:  drug 	 \
+        # Entities : [Amlodipine, Metformine, AMLODIPINE]
+        # Entity : Amlodipine 	 Relations : \
+        # [{'type': 'Temporal', target': pendant 3 semaines}]
+        # Entity : Metformine 	 Relations : \
+        [{"type": "Temporal", "target": 27 / 05 / 2022}]
+        # Entity : AMLODIPINE 	 Relations : []
+
+        # Label:  dates 	 Entities : [27/05/2022, 11/07]
+        # Entity : 27/05/2022 	 Relations : \
+        [{"type": "inv_Temporal", "target": Metformine}]
+        # Entity : 11/07 	 Relations : []
+
+        # Label:  durations 	 Entities : [pendant 3 semaines]
+        # Entity : pendant 3 semaines 	\
+        Relations: [{"type": "inv_Temporal", "target": Amlodipine}]
+
+    # Label:  periods 	 Entities : []
+    ```
+
+    Extensions
+    ----------
+    The `eds.relations` pipeline adds and declares one extension
+    on the `Span` objects called `rel`. By default rel is an empty list.
+
+    The `rel` extension is a list of dictionaries
+    containing the type of the relation and the target `Span`.
+    It automatically adds the inverse relation to the target `Span`.
+
+    Parameters
+    ----------
+    nlp : PipelineProtocol
+        The pipeline object
+    name : str
+        Name of the component
+    scheme : Union[Union[Dict, List[Dict]],str]
+        The scheme to use to match the relations
+    use_sentences: bool = True
+        Whether or not to use the `eds.sentences` matcher to improve results
+    proximity_method: str = "right"
+        The method to use to calculate the proximity between the entities
+        "sym" : symmetrical distance
+        "start" : distance between the start char of the entities
+        "end" : distance between the end char of the entities
+        "middle" : distance between the middle of the entities
+        "right" : distance between the end of the source and the start of the target
+        "left" : distance between the end of the target and the start of the source
+    max_dist: int = 45
+        The maximum distance between the entities to consider them as related
+    clean_rel: bool = True
+        Whether or not to clean the relations before adding new ones
+
+    Scheme
+    ------
+    It can be a dictionary (one relation), \
+        a list of dictionaries (one or more relations)
+    or a string indicating the path of a json file.
+
+    Each dictionary should contain the keys \
+        `source`, `target`, `type` and `inv_type`.
+
+    `source` and `target` are lists of dictionaries \
+        containing the keys `label` and `attr`.
+
+    `label` is the label of the entity to match.
+
+    `attr` is a dictionary containing the attributes \
+        to match on or None if no attribute is needed.
+
+    `type` is the type of the relation.
+
+    `inv_type` is the inverse type of the relation.
+    ```json
+    [
+        {
+            "source": [
+                {
+                    "label": "Chemical_and_drugs",
+                    "attr": {
+                        "Tech": [
+                            null
+                        ]
+                    }
+                }
+            ],
+            "target": [
+                {
+                    "label": "Temporal",
+                    "attr": {
+                        "AttTemp": [
+                            "Duration",
+                            "Date",
+                            "Frequency",
+                            "Time"
+                        ]
+                    }
+                },
+                {
+                    "label": "Chemical_and_drugs",
+                    "attr": {
+                        "Tech": [
+                            "dosage",
+                            "route",
+                            "strength",
+                            "form"
+                        ]
+                    }
+                }
+            ],
+            "type": "Depend",
+            "inv_type": "inv_Depend"
+        }
+    ]
+    ```
+
+    Authors and citation
+    --------------------
+    The `eds.relations` was developed by AP-HP's Data Science team.
+
+    '''
+
+    def __init__(
+        self,
+        nlp: PipelineProtocol,
+        name: str = "relations",
+        *,
+        scheme: Union[Union[Dict, List[Dict]], str] = None,
+        use_sentences: bool = False,
+        proximity_method: str = "right",
+        clean_rel: bool = True,
+        max_dist: int = 45,
+    ):
+        self.nlp = nlp
+        if not isinstance(name, str):
+            raise ValueError("name must be a string")
+        self.name = name
+
+        if scheme is None:
+            scheme = patterns.scheme
+        if isinstance(scheme, str):
+            if not scheme.endswith(".json"):
+                raise ValueError("scheme must be a json file")
+            with open(scheme) as f:
+                scheme = json.load(f)
+        if isinstance(scheme, dict):
+            scheme = [scheme]
+        self.check_scheme(scheme)
+        self.scheme = scheme
+
+        if not isinstance(use_sentences, bool):
+            raise ValueError("use_sentences must be a boolean")
+        self.use_sentences = use_sentences and (
+            "eds.sentences" in nlp.pipe_names or "sentences" in nlp.pipe_names
+        )
+        if use_sentences and not self.use_sentences:
+            logger.warning(
+                "You have requested that the pipeline use annotations "
+                "provided by the `eds.sentences` pipeline, but it was not set. "
+                "Skipping that step."
+            )
+
+        if proximity_method not in ["sym", "start", "end", "middle", "right", "left"]:
+            raise ValueError(
+                """proximity_method must be one of 'sym','start',
+                'end', 'middle', 'right', 'left'"""
+            )
+        self.proximity_method = proximity_method
+
+        if not isinstance(clean_rel, bool):
+            raise ValueError("clean_rel must be a boolean")
+        self.clean_rel = clean_rel
+
+        if not isinstance(max_dist, int):
+            raise ValueError("max_dist must be an integer")
+        self.max_dist = max_dist
+
+        self.set_extensions()
+
+    def check_scheme(self, schemes):
+        for scheme in schemes:
+            if not isinstance(scheme, dict):
+                raise ValueError("scheme must be a dictionary")
+            if "source" not in scheme:
+                raise ValueError("scheme must contain a 'source' key")
+            if "target" not in scheme:
+                raise ValueError("scheme must contain an 'target' key")
+            if "type" not in scheme:
+                raise ValueError("scheme must contain a 'type' key")
+            if "inv_type" not in scheme:
+                raise ValueError("scheme must contain an 'inv_type' key")
+            if not isinstance(scheme["source"], list):
+                raise ValueError("scheme['source'] must be a list")
+            if not isinstance(scheme["target"], list):
+                raise ValueError("scheme['target'] must be a list")
+            if not isinstance(scheme["type"], str):
+                raise ValueError("scheme['type'] must be a string")
+            if not isinstance(scheme["inv_type"], str):
+                raise ValueError("scheme['inv_type'] must be a string")
+            for sub in scheme["source"]:
+                if not isinstance(sub, dict):
+                    raise ValueError("scheme['source'] must contain dictionaries")
+                if "label" not in sub:
+                    raise ValueError("scheme['source'] must contain a 'label' key")
+                if not isinstance(sub["label"], str):
+                    raise ValueError("scheme['source']['label'] must be a string")
+                if "attr" in sub:
+                    if sub["attr"] is not None and not isinstance(sub["attr"], dict):
+                        raise ValueError(
+                            "scheme['source']['attr'] must be a dictionary or None"
+                        )
+            for obj in scheme["target"]:
+                if not isinstance(obj, dict):
+                    raise ValueError("scheme['target'] must contain dictionaries")
+                if "label" not in obj:
+                    raise ValueError("scheme['target'] must contain a 'label' key")
+                if not isinstance(obj["label"], str):
+                    raise ValueError("scheme['target']['label'] must be a string")
+                if "attr" in obj:
+                    if obj["attr"] is not None and not isinstance(obj["attr"], dict):
+                        raise ValueError(
+                            "scheme['target']['attr'] must be a dictionary or None"
+                        )
+        return True
+
+    @classmethod
+    def set_extensions(cls) -> None:
+        """Set the extension rel for the Span target."""
+        if not Span.has_extension("rel"):
+            Span.set_extension("rel", default=[])
+
+    def clean_relations(self, doc: Doc) -> Doc:
+        """Remove the relations from the doc
+
+        Args:
+            doc (Doc): the doc to be processed
+
+        Returns:
+            Doc: the doc with the relations removed
+        """
+        for label, spans in doc.spans.items():
+            for span in spans:
+                if span._.rel:
+                    span._.rel = []
+        return doc
+
+    def __call__(self, doc: Doc) -> Doc:
+        """find the relations in the doc based \
+            on the proximity of the entities attributes
+
+        Args:
+            doc (Doc): the doc to be processed
+
+        Returns:
+            Doc: the doc with the relations added
+        """
+        if self.clean_rel:
+            doc = self.clean_relations(doc)
+
+        dict_r = self.find_relations(doc)
+
+        for r, rel in enumerate(dict_r):
+            if len(dict_r[r]["mat_obj"]) > 0 and len(dict_r[r]["mat_sub"]) > 0:
+                min_distance_indices, distances = self.calculate_min_distances(
+                    dict_r[r]["mat_sub"], dict_r[r]["mat_obj"]
+                )
+                for i, span_obj in enumerate(dict_r[r]["spans_obj"]):
+                    if distances[min_distance_indices[i]][i] <= self.max_dist:
+                        span_sub = dict_r[r]["spans_sub"][min_distance_indices[i]]
+                        if self.use_sentences and not self.sentences(
+                            doc, span_obj["span"], span_sub["span"]
+                        ):
+                            continue
+                        doc.spans[span_obj["label"]][span_obj["num_span"]]._.rel.append(
+                            {
+                                "type": dict_r[r]["inv_type"],
+                                "target": doc.spans[span_sub["label"]][
+                                    span_sub["num_span"]
+                                ],
+                            }
+                        )
+
+                        doc.spans[span_sub["label"]][span_sub["num_span"]]._.rel.append(
+                            {
+                                "type": dict_r[r]["type"],
+                                "target": doc.spans[span_obj["label"]][
+                                    span_obj["num_span"]
+                                ],
+                            }
+                        )
+        return doc
+
+    def sentences(self, doc: Doc, span_obj: Span, span_sub: Span) -> bool:
+        """Check if span_obj and span_sub are in the same sentence.
+
+        Args:
+            doc (Doc): EDSNLP Doc target
+            span_obj (Span): span representing the target
+            span_sub (Span): span representing the source
+
+        Returns:
+            bool: True if span_obj and span_sub \
+                are in the same sentence, False otherwise.
+        """
+        for sent in doc.sents:
+            if (
+                span_obj.start >= sent.start
+                and span_obj.end <= sent.end
+                and span_sub.start >= sent.start
+                and span_sub.end <= sent.end
+            ):
+                return True
+        return False
+
+    def find_relations(self, doc: Doc) -> Dict:
+        """
+        Detect the potential sources and targets in the document
+
+        Args:
+            doc (Doc): EDSNLP Doc target
+
+        Returns:
+            Dict: dict containing the potential sources and targets
+        """
+        dict_r = {}
+        for r, relation in enumerate(self.scheme):
+            dict_r[r] = {
+                "mat_obj": [],
+                "spans_obj": [],
+                "mat_sub": [],
+                "spans_sub": [],
+                "type": relation["type"],
+                "inv_type": relation["inv_type"],
+            }
+            # Treatment of targets
+            for obj in relation["target"]:
+                label_obj = obj["label"]
+                attr_obj = obj["attr"]
+                if label_obj in doc.spans:
+                    if attr_obj is not None:
+                        for num_span_obj, span_obj in enumerate(doc.spans[label_obj]):
+                            if self.filter_spans(
+                                span_obj, *list(attr_obj.items())[0], label_obj
+                            ):
+                                dict_r[r]["mat_obj"].append(
+                                    [span_obj.start_char, span_obj.end_char]
+                                )
+                                dict_r[r]["spans_obj"].append(
+                                    {
+                                        "label": label_obj,
+                                        "num_span": num_span_obj,
+                                        "span": span_obj,
+                                    }
+                                )
+                    else:
+                        for num_span_obj, span_obj in enumerate(doc.spans[label_obj]):
+                            dict_r[r]["mat_obj"].append(
+                                [span_obj.start_char, span_obj.end_char]
+                            )
+                            dict_r[r]["spans_obj"].append(
+                                {
+                                    "label": label_obj,
+                                    "num_span": num_span_obj,
+                                    "span": span_obj,
+                                }
+                            )
+
+            # Treatment of sources
+            for sub in relation["source"]:
+                label_sub = sub["label"]
+                attr_sub = sub["attr"]
+                if label_sub in doc.spans:
+                    if attr_sub is not None:
+                        for num_span_sub, span_sub in enumerate(doc.spans[label_sub]):
+                            if self.filter_spans(
+                                span_sub, *list(attr_sub.items())[0], label_sub
+                            ):
+                                dict_r[r]["mat_sub"].append(
+                                    [span_sub.start_char, span_sub.end_char]
+                                )
+                                dict_r[r]["spans_sub"].append(
+                                    {
+                                        "label": label_sub,
+                                        "num_span": num_span_sub,
+                                        "span": span_sub,
+                                    }
+                                )
+                    else:
+                        for num_span_sub, span_sub in enumerate(doc.spans[label_sub]):
+                            dict_r[r]["mat_sub"].append(
+                                [span_sub.start_char, span_sub.end_char]
+                            )
+                            dict_r[r]["spans_sub"].append(
+                                {
+                                    "label": label_sub,
+                                    "num_span": num_span_sub,
+                                    "span": span_sub,
+                                }
+                            )
+
+            # Convert lists to numpy arrays for easier manipulation later
+        for r in dict_r:
+            dict_r[r]["mat_obj"] = np.array(dict_r[r]["mat_obj"])
+            dict_r[r]["mat_sub"] = np.array(dict_r[r]["mat_sub"])
+
+        return dict_r
+
+    def calculate_min_distances(
+        self, sources: NDArray[Any], targets: NDArray[Any]
+    ) -> NDArray[Any]:
+        """calculate the minimum distance between sources and targets
+
+        Args:
+            sources (NDArray[Any]): entities to be used as sources
+            targets (NDArray[Any]): entities to be used as targets
+
+        Returns:
+            NDArray[Any]: the index of the source that is closest to the target
+        """
+
+        sources_expanded = sources[:, np.newaxis, :]
+        targets_expanded = targets[np.newaxis, :, :]
+
+        # calculate the distances between the entities
+        distance_start_to_end = sources_expanded[:, :, 0] - targets_expanded[:, :, 1]
+        distance_end_to_start = targets_expanded[:, :, 0] - sources_expanded[:, :, 1]
+        distance_start_to_start = sources_expanded[:, :, 0] - targets_expanded[:, :, 0]
+        distance_end_to_end = targets_expanded[:, :, 1] - sources_expanded[:, :, 1]
+        distance_middle = (
+            np.abs(distance_start_to_start) + np.abs(distance_end_to_end)
+        ) / 2
+
+        if self.proximity_method == "sym":
+            distance_middle = np.abs(
+                np.minimum(distance_start_to_start, distance_end_to_end)
+            )
+            # determine the mask for the left and right side of the entities
+            mask_left = targets_expanded[:, :, 1] <= sources_expanded[:, :, 0]
+            mask_right = sources_expanded[:, :, 1] <= targets_expanded[:, :, 0]
+
+            # Assign the distances based on the mask
+            distances = np.where(mask_left, np.abs(distance_start_to_end), np.inf)
+            distances = np.where(mask_right, np.abs(distance_end_to_start), distances)
+            mask_middle = np.logical_not(np.logical_or(mask_left, mask_right))
+            distances = np.where(mask_middle, distance_middle, distances)
+            distances = np.where(distances == 0, np.inf, distances)
+
+            # find the index of the minimum distance
+            min_distance_indices = np.argmin(distances, axis=0)
+
+        if self.proximity_method == "right":
+            distances = np.abs(distance_end_to_start)
+            distances = np.where(distances == 0, np.inf, distances)
+            min_distance_indices = np.argmin(distances, axis=0)
+
+        if self.proximity_method == "left":
+            distances = np.abs(distance_start_to_end)
+            distances = np.where(distances == 0, np.inf, distances)
+            min_distance_indices = np.argmin(distances, axis=0)
+
+        if self.proximity_method == "start":
+            distances = np.abs(distance_start_to_start)
+            distances = np.where(distances == 0, np.inf, distances)
+            min_distance_indices = np.argmin(distances, axis=0)
+
+        if self.proximity_method == "end":
+            distances = np.abs(distance_end_to_end)
+            distances = np.where(distances == 0, np.inf, distances)
+            min_distance_indices = np.argmin(distances, axis=0)
+
+        if self.proximity_method == "middle":
+            distances = distance_middle
+            distances = np.where(distances == 0, np.inf, distances)
+            min_distance_indices = np.argmin(distances, axis=0)
+
+        return min_distance_indices, distances
+
+    def filter_spans(
+        self, span: Span, attr_name: str, attr_values: list, label: str
+    ) -> bool:
+        """Filter the spans based on the attribute values
+
+        Args:
+            span (Span): the span to be filtered
+            attr_name (str): the name of the attribute
+            attr_values (list): the values of the attribute
+            label (str): the label of the span
+
+        Returns:
+            bool: _description_
+        """
+        # Get the attribute value or None if it doesn't exist
+        attr_value = getattr(span._, attr_name, None)
+        if attr_value in attr_values:
+            return True
+        return False
diff --git a/mkdocs.yml b/mkdocs.yml
index 1b736c324..6ceadd52c 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -78,6 +78,7 @@ nav:
           - pipes/misc/sections.md
           - pipes/misc/reason.md
           - pipes/misc/tables.md
+          - pipes/misc/relations.md
       - Named Entity Recognition:
           - Overview: pipes/ner/index.md
           - Scores:
diff --git a/pyproject.toml b/pyproject.toml
index 83e4e85c7..9b9bca356 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -195,6 +195,7 @@ where = ["."]
 "eds.reason"                      = "edsnlp.pipes.misc.reason.factory:create_component"
 "eds.sections"                    = "edsnlp.pipes.misc.sections.factory:create_component"
 "eds.tables"                      = "edsnlp.pipes.misc.tables.factory:create_component"
+"eds.relations"                   = "edsnlp.pipes.misc.relations.factory:create_component"
 
 # Deprecated (links to the same factories as above)
 "SOFA"                   = "edsnlp.pipes.ner.scores.sofa.factory:create_component"
diff --git a/tests/data/test_converters.py b/tests/data/test_converters.py
index 5005ae17a..91ee20af1 100644
--- a/tests/data/test_converters.py
+++ b/tests/data/test_converters.py
@@ -182,6 +182,7 @@ def test_write_standoff_dict(blank_nlp):
                 "label": "test",
             },
         ],
+        "relations": [],
     }
     assert (
         get_doc2dict_converter(
diff --git a/tests/data/test_standoff.py b/tests/data/test_standoff.py
index 0c8c683aa..5e497780a 100644
--- a/tests/data/test_standoff.py
+++ b/tests/data/test_standoff.py
@@ -183,6 +183,7 @@ def assert_doc_read(doc):
 
 
 def assert_doc_write(exported_ann_text):
+    print(exported_ann_text)
     assert exported_ann_text == (
         "T1	sosy 30 38	douleurs\n"
         "A1	etat T1 test\n"
@@ -207,6 +208,8 @@ def assert_doc_write(exported_ann_text):
         "A10	assertion T11 absent\n"
         "T12	test label 0 378 386	anomalie\n"
         "A11	assertion T12 absent\n"
+        "R1\tlieu Arg1:T1 Arg2:T2\n"
+        "R2\tlieu Arg1:T8 Arg2:T9\n"
     )
 
 
diff --git a/tests/pipelines/misc/test_relations.py b/tests/pipelines/misc/test_relations.py
new file mode 100644
index 000000000..a40d9807e
--- /dev/null
+++ b/tests/pipelines/misc/test_relations.py
@@ -0,0 +1,60 @@
+import os
+from pathlib import Path
+
+import pytest
+from pytest import mark
+from spacy.tokens import Doc, Span
+
+import edsnlp
+
+
+@mark.parametrize("use_sentences", [True, False])
+@mark.parametrize("clean_rel", [True, False])
+@mark.parametrize(
+    "proximity_method", ["sym", "right", "left", "middle", "start", "end"]
+)
+@mark.parametrize("max_dist", [1, 45, 100])
+def test_relations(use_sentences, clean_rel, proximity_method, max_dist):
+    dossier = Path(__file__).parent.parent.parent.resolve() / "resources" / "relations"
+    doc_iterator = edsnlp.data.read_standoff(dossier)
+    corpus = list(doc_iterator)
+    assert len(corpus) > 0
+    for doc in corpus:
+        assert isinstance(doc, Doc)
+        for label in doc.spans:
+            for span in doc.spans[label]:
+                assert isinstance(span, Span)
+                assert span.has_extension("rel")
+                for rel in span._.rel:
+                    assert isinstance(rel["target"], Span)
+                    assert isinstance(rel["type"], str)
+                    assert rel["type"] == "Depend" or rel["type"] == "inv_Depend"
+
+    nlp = edsnlp.blank("eds")
+    nlp.add_pipe("eds.sentences")
+    nlp.add_pipe(
+        "eds.relations",
+        config={
+            "scheme": os.path.join(dossier, "relations.json"),
+            "use_sentences": use_sentences,
+            "clean_rel": clean_rel,
+            "proximity_method": proximity_method,
+            "max_dist": max_dist,
+        },
+    )
+
+    doc = nlp(corpus[0])
+
+    for label in doc.spans:
+        for span in doc.spans[label]:
+            print(span, span._.rel)
+            assert isinstance(span, Span)
+            assert span.has_extension("rel")
+            for rel in span._.rel:
+                assert isinstance(rel["target"], Span)
+                assert isinstance(rel["type"], str)
+                assert rel["type"] == "Depend" or rel["type"] == "inv_Depend"
+
+
+if __name__ == "__main__":
+    pytest.main()
diff --git a/tests/resources/relations/relations.json b/tests/resources/relations/relations.json
new file mode 100644
index 000000000..8e9e19387
--- /dev/null
+++ b/tests/resources/relations/relations.json
@@ -0,0 +1,40 @@
+[
+    {
+        "source": [
+            {
+                "label": "Chemical_and_drugs",
+                "attr": {
+                    "Tech": [
+                        null
+                    ]
+                }
+            }
+        ],
+        "target": [
+            {
+                "label": "Temporal",
+                "attr": {
+                    "AttTemp": [
+                        "Duration",
+                        "Date",
+                        "Frequency",
+                        "Time"
+                    ]
+                }
+            },
+            {
+                "label": "Chemical_and_drugs",
+                "attr": {
+                    "Tech": [
+                        "dosage",
+                        "route",
+                        "strength",
+                        "form"
+                    ]
+                }
+            }
+        ],
+        "type": "Depend",
+        "inv_type": "inv_Depend"
+    }
+]
diff --git a/tests/resources/relations/text.ann b/tests/resources/relations/text.ann
new file mode 100644
index 000000000..abc346ad2
--- /dev/null
+++ b/tests/resources/relations/text.ann
@@ -0,0 +1,82 @@
+T1	DISO 24 41	fatigue chronique
+A1	Certainty T1 Certain
+T2	DISO 49 61	maux de tête
+A2	Certainty T2 Certain
+T3	Constantes 97 134	tension artérielle est de 145/90 mmHg
+T4	Constantes 139 172	glycémie à jeun est de 7.8 mmol/L
+T5	Constantes 179 212	saturation en oxygène est de 98 %
+T6	Chemical_and_drugs 238 248	Amlodipine
+A3	Certainty T6 Certain
+A4	Temporality T6 Present
+T7	Chemical_and_drugs 263 267	5 mg
+A5	Tech T7 strength
+T8	Chemical_and_drugs 282 290	comprimé
+A6	Tech T8 form
+T9	Chemical_and_drugs 300 310	voie orale
+A7	Tech T9 route
+T10	Chemical_and_drugs 311 328	une fois par jour
+A8	Tech T10 dosage
+R1	Depend Arg1:T6 Arg2:T7	
+R2	Depend Arg1:T6 Arg2:T8	
+R3	Depend Arg1:T6 Arg2:T9	
+R4	Depend Arg1:T6 Arg2:T10	
+T11	Chemical_and_drugs 330 340	Metformine
+A9	Certainty T11 Certain
+A10	Temporality T11 Present
+T12	Chemical_and_drugs 355 380	500 mg deux fois par jour
+A11	Tech T12 dosage
+T13	Chemical_and_drugs 355 361	500 mg
+A12	Tech T13 strength
+T14	Temporal 362 380	deux fois par jour
+A13	AttTemp T14 Frequency
+T15	Temporal 381 401	depuis le 27/05/2022
+A14	AttTemp T15 Duration
+A15	AttDate T15 StartDate
+A16	RefTemp T15 Absolute
+T16	Chemical_and_drugs 403 413	Salbutamol
+A17	Certainty T16 Certain
+A18	Temporality T16 Present
+T17	Chemical_and_drugs 428 434	100 µg
+A19	Tech T17 strength
+A20	Certainty T17 Conditional
+A21	Temporality T17 Present
+T18	Chemical_and_drugs 448 458	inhalateur
+A22	Tech T18 form
+T19	Chemical_and_drugs 471 483	voie inhalée
+A23	Tech T19 route
+T20	Chemical_and_drugs 502 513	Paracétamol
+A24	Certainty T20 Conditional
+A25	Temporality T20 Present
+T21	Chemical_and_drugs 528 534	500 mg
+A26	Tech T21 strength
+T22	Chemical_and_drugs 535 541	per os
+A27	Tech T22 route
+T23	Temporal 560 588	maximum quatre fois par jour
+A28	AttTemp T23 Frequency
+T24	DISO 598 610	maux de tête
+A29	Certainty T24 Conditional
+T25	DISO 751 754	HTA
+A30	Certainty T25 Certain
+T26	Chemical_and_drugs 787 797	Amlodipine
+A31	Action T26 Increase
+A32	Certainty T26 Certain
+A33	Temporality T26 Present
+T27	Chemical_and_drugs 800 805	10 mg
+A34	Tech T27 dosage
+T28	DISO 845 851	asthme
+A35	Certainty T28 Certain
+T29	DISO 917 929	maux de tête
+A36	Certainty T29 Conditional
+T30	Chemical_and_drugs 970 981	paracétamol
+A37	Certainty T30 Conditional
+R5	Depend Arg1:T11 Arg2:T13	
+R6	Depend Arg1:T11 Arg2:T12	
+R7	Depend Arg1:T11 Arg2:T14	
+R8	Depend Arg1:T11 Arg2:T15	
+R9	Depend Arg1:T16 Arg2:T17	
+R10	Depend Arg1:T16 Arg2:T18	
+R11	Depend Arg1:T16 Arg2:T19	
+R12	Depend Arg1:T20 Arg2:T21	
+R13	Depend Arg1:T20 Arg2:T22	
+R14	Depend Arg1:T20 Arg2:T23	
+R15	Depend Arg1:T26 Arg2:T27	
diff --git a/tests/resources/relations/text.txt b/tests/resources/relations/text.txt
new file mode 100644
index 000000000..4ed1a3e9f
--- /dev/null
+++ b/tests/resources/relations/text.txt
@@ -0,0 +1,3 @@
+Le patient présente une fatigue chronique et des maux de tête fréquents. À l'examen clinique, sa tension artérielle est de 145/90 mmHg, sa glycémie à jeun est de 7.8 mmol/L et sa saturation en oxygène est de 98 %. 
+Traitements en cours : Amlodipine à une dose de 5 mg sous forme de comprimé pris par voie orale une fois par jour. Metformine à une dose de 500 mg deux fois par jour depuis le 27/05/2022. Salbutamol à une dose de 100 µg sous forme d'inhalateur utilisé par voie inhalée en cas de besoin. Paracétamol à une dose de 500 mg per os en cas de besoin, maximum quatre fois par jour pour les maux de tête.
+Recommandations : Surveillance régulière de la tension artérielle et de la glycémie. Consultation chez un cardiologue pour évaluation de l'HTA, dans l'attente majoration de l'Amlodipine à 10 mg. Poursuite du traitement actuel pour l'asthme avec usage de l'inhalateur en cas de symptômes. Réévaluation des maux de tête si persistants malgré le traitement par paracétamol.