diff --git a/pyproject.toml b/pyproject.toml
index cd3a0bbb..b6c70501 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -34,6 +34,7 @@ dependencies = [
     "httpx",
     "jsonschema",
     "numpy",
+    "networkx",
     "pandas",
     "pyteomics",
     "rich",
diff --git a/src/nplinker/nplinker.py b/src/nplinker/nplinker.py
index 537f68fa..dd3f8984 100644
--- a/src/nplinker/nplinker.py
+++ b/src/nplinker/nplinker.py
@@ -15,7 +15,6 @@
 from .metabolomics import Spectrum
 from .pickler import save_pickled_data
 from .scoring.abc import ScoringBase
-from .scoring.link_collection import LinkCollection
 from .scoring.metcalf_scoring import MetcalfScoring
 from .scoring.np_class_scoring import NPClassScoring
 from .scoring.rosetta_scoring import RosettaScoring
diff --git a/src/nplinker/scoring/__init__.py b/src/nplinker/scoring/__init__.py
index 0a5b6298..597fa4f9 100644
--- a/src/nplinker/scoring/__init__.py
+++ b/src/nplinker/scoring/__init__.py
@@ -1,7 +1,14 @@
 from .abc import ScoringBase
-from .link_collection import LinkCollection
+from .link_graph import LinkGraph
 from .metcalf_scoring import MetcalfScoring
-from .object_link import ObjectLink
+from .score import Score
+from .scoring_method import ScoringMethod
 
 
-__all__ = ["LinkCollection", "MetcalfScoring", "ScoringBase", "ObjectLink"]
+__all__ = [
+    "LinkGraph",
+    "MetcalfScoring",
+    "Score",
+    "ScoringBase",
+    "ScoringMethod",
+]
diff --git a/src/nplinker/scoring/abc.py b/src/nplinker/scoring/abc.py
index 7c8e71ad..a96e858f 100644
--- a/src/nplinker/scoring/abc.py
+++ b/src/nplinker/scoring/abc.py
@@ -6,8 +6,8 @@
 
 
 if TYPE_CHECKING:
-    from nplinker import NPLinker
-    from . import LinkCollection
+    from nplinker.nplinker import NPLinker
+    from .link_graph import LinkGraph
 
 logger = logging.getLogger(__name__)
 
@@ -36,15 +36,19 @@ def setup(cls, npl: NPLinker):
         """Setup class level attributes."""
 
     @abstractmethod
-    def get_links(self, *objects, link_collection: LinkCollection) -> LinkCollection:
+    def get_links(
+        self,
+        *objects,
+        **parameters,
+    ) -> LinkGraph:
         """Get links information for the given objects.
 
         Args:
-            objects: A set of objects.
-            link_collection: The LinkCollection object.
+            objects: A list of objects to get links for.
+            parameters: The parameters used for scoring.
 
         Returns:
-            The LinkCollection object.
+            The LinkGraph object.
         """
 
     @abstractmethod
diff --git a/src/nplinker/scoring/link_collection.py b/src/nplinker/scoring/link_collection.py
deleted file mode 100644
index f734686e..00000000
--- a/src/nplinker/scoring/link_collection.py
+++ /dev/null
@@ -1,192 +0,0 @@
-import itertools
-import logging
-
-
-logger = logging.getLogger(__name__)
-
-
-class LinkCollection:
-    """Class which stores the results of running one or more scoring methods.
-
-    It provides access to the set of objects which were found to have links,
-    the set of objects linked to each of those objects, and the information
-    produced by the scoring method(s) about each link.
-
-    There are also some useful utility methods to filter the original results.
-    """
-
-    def __init__(self, and_mode=True):
-        self._methods = set()
-        self._link_data = {}
-        self._targets = {}
-        self._and_mode = and_mode
-
-    def _add_links_from_method(self, method, object_links):
-        if method in self._methods:
-            # this is probably an error...
-            raise Exception("Duplicate method found in LinkCollection: {}".format(method.name))
-
-        # if this is the first set of results to be generated, can just dump
-        # them all straight in
-        if len(self._methods) == 0:
-            self._link_data = {k: v for k, v in object_links.items()}
-        else:
-            # if already some results added, in OR mode can just merge the new set
-            # with the existing set, but in AND mode need to ensure we end up with
-            # only results that appear in both sets
-
-            if not self._and_mode:
-                logger.info(
-                    "Merging {} results from method {} in OR mode".format(
-                        len(object_links), method.name
-                    )
-                )
-                self._merge_or_mode(object_links)
-            else:
-                logger.info(
-                    "Merging {} results from method {} in AND mode".format(
-                        len(object_links), method.name
-                    )
-                )
-                self._merge_and_mode(object_links)
-
-        self._methods.add(method)
-
-    def _merge_and_mode(self, object_links):
-        # set of ObjectLinks common to existing + new results
-        intersect1 = self._link_data.keys() & object_links.keys()
-
-        # iterate over the existing set of link info, remove entries for objects
-        # that aren't common to both that and the new set of info, and merge in
-        # any common links
-        to_remove = set()
-        for source, existing_links in self._link_data.items():
-            if source not in intersect1:
-                to_remove.add(source)
-                continue
-
-            links_to_merge = object_links[source]
-            intersect2 = existing_links.keys() & links_to_merge.keys()
-
-            self._link_data[source] = {k: v for k, v in existing_links.items() if k in intersect2}
-
-            for target, object_link in object_links[source].items():
-                if target in self._link_data[source]:
-                    self._link_data[source][target]._merge(object_link)
-
-            if len(self._link_data[source]) == 0:
-                to_remove.add(source)
-
-        for source in to_remove:
-            del self._link_data[source]
-
-    def _merge_or_mode(self, object_links):
-        # source = GCF/Spectrum, links = {Spectrum/GCF: ObjectLink} dict
-        for source, links in object_links.items():
-            # update the existing dict with the new entries that don't appear in it already
-            if source not in self._link_data:
-                self._link_data[source] = links
-            else:
-                self._link_data[source].update(
-                    {k: v for k, v in links.items() if k not in self._link_data[source]}
-                )
-
-            # now merge the remainder (common to both)
-            for target, object_link in links.items():
-                self._link_data[source][target]._merge(object_link)
-
-    def filter_no_shared_strains(self):
-        len_before = len(self._link_data)
-        self.filter_links(lambda x: len(x.shared_strains) > 0)
-        logger.info("filter_no_shared_strains: {} => {}".format(len_before, len(self._link_data)))
-
-    def filter_sources(self, callable_obj):
-        len_before = len(self._link_data)
-        self._link_data = {k: v for k, v in self._link_data.items() if callable_obj(k)}
-        logger.info("filter_sources: {} => {}".format(len_before, len(self._link_data)))
-
-    def filter_targets(self, callable_obj, sources=None):
-        to_remove = []
-        sources_list = self._link_data.keys() if sources is None else sources
-        for source in sources_list:
-            self._link_data[source] = {
-                k: v for k, v in self._link_data[source].items() if callable_obj(k)
-            }
-            # if there are now no links for this source, remove it completely
-            if len(self._link_data[source]) == 0:
-                to_remove.append(source)
-
-        for source in to_remove:
-            del self._link_data[source]
-
-    def filter_links(self, callable_obj, sources=None):
-        to_remove = []
-        sources_list = self._link_data.keys() if sources is None else sources
-        for source in sources_list:
-            self._link_data[source] = {
-                k: v for k, v in self._link_data[source].items() if callable_obj(v)
-            }
-            # if there are now no links for this source, remove it completely
-            if len(self._link_data[source]) == 0:
-                to_remove.append(source)
-
-        for source in to_remove:
-            del self._link_data[source]
-
-    def get_sorted_links(self, method, source, reverse=True, strict=False):
-        # This method allows for the sorting of a set of links according to the
-        # sorting implemented by a specific method. However because there may be
-        # links from multiple methods present in the collection, it isn't as simple
-        # as running <method>.sort(links) and returning the result, because that
-        # will only work on links which have the expected method data. To get around
-        # this, the "strict" parameter is used. If set to True, it simply returns
-        # the sorted links *for the specific method only*, which may be a subset
-        # of the total collection if multiple methods were used to generate it. If
-        # set to False, it will return a list consisting of the sorted links for
-        # the given method, with any remaining links appended in arbitrary order.
-
-        # run <method>.sort on the links found by that method
-        sorted_links_for_method = method.sort(
-            [link for link in self._link_data[source].values() if method in link.methods], reverse
-        )
-
-        if not strict:
-            # append any remaining links
-            sorted_links_for_method.extend(
-                [link for link in self._link_data[source].values() if method not in link.methods]
-            )
-
-        return sorted_links_for_method
-
-    def get_all_targets(self):
-        return list(
-            set(
-                itertools.chain.from_iterable(
-                    self._link_data[x].keys() for x in self._link_data.keys()
-                )
-            )
-        )
-
-    @property
-    def methods(self):
-        return self._methods
-
-    @property
-    def sources(self):
-        # the set of objects supplied as input, which have links
-        return list(self._link_data.keys())
-
-    @property
-    def links(self):
-        return self._link_data
-
-    @property
-    def source_count(self):
-        return len(self._link_data)
-
-    @property
-    def method_count(self):
-        return len(self._methods)
-
-    def __len__(self):
-        return len(self._link_data)
diff --git a/src/nplinker/scoring/link_graph.py b/src/nplinker/scoring/link_graph.py
new file mode 100644
index 00000000..96596dc4
--- /dev/null
+++ b/src/nplinker/scoring/link_graph.py
@@ -0,0 +1,194 @@
+from __future__ import annotations
+from functools import wraps
+from networkx import Graph
+from nplinker.genomics import GCF
+from nplinker.metabolomics import MolecularFamily
+from nplinker.metabolomics import Spectrum
+from .score import Score
+from .scoring_method import ScoringMethod
+
+
+def validate_u(func):
+    """A decorator to validate the type of the u object."""
+
+    @wraps(func)
+    def wrapper(self, u: GCF | Spectrum | MolecularFamily, *args, **kwargs):
+        if not isinstance(u, (GCF, Spectrum, MolecularFamily)):
+            raise TypeError(f"{u} is not a GCF, Spectrum, or MolecularFamily object.")
+
+        return func(self, u, *args, **kwargs)
+
+    return wrapper
+
+
+def validate_uv(func):
+    """A decorator to validate the types of the u and v objects."""
+
+    @wraps(func)
+    def wrapper(
+        self,
+        u: GCF | Spectrum | MolecularFamily,
+        v: GCF | Spectrum | MolecularFamily,
+        *args,
+        **kwargs,
+    ):
+        if isinstance(u, GCF):
+            if not isinstance(v, (Spectrum, MolecularFamily)):
+                raise TypeError(f"{v} is not a Spectrum or MolecularFamily object.")
+        elif isinstance(u, (Spectrum, MolecularFamily)):
+            if not isinstance(v, GCF):
+                raise TypeError(f"{v} is not a GCF object.")
+        else:
+            raise TypeError(f"{u} is not a GCF, Spectrum, or MolecularFamily object.")
+
+        return func(self, u, v, *args, **kwargs)
+
+    return wrapper
+
+
+class LinkGraph:
+    """A class to represent the links between objects in NPLinker.
+
+    This class wraps the `networkx.Graph` class to provide a more user-friendly interface for
+    working with the links.
+
+    The links between objects are stored as edges in a graph, while the objects themselves are
+    stored as nodes.
+
+    The scoring data for each link (or link data) is stored as the key/value attributes of the edge.
+
+
+    Examples:
+        Create a LinkGraph object:
+        >>> lg = LinkGraph()
+
+        Add a link between a GCF and a Spectrum object:
+        >>> lg.add_link(gcf, spectrum, metcalf=Score("metcalf", 1.0, {"cutoff": 0.5}))
+
+        Get all links for a given object:
+        >>> lg[gcf]
+        {spectrum: {"metcalf": Score("metcalf", 1.0, {"cutoff": 0.5})}}
+
+        Get all links:
+        >>> lg.links
+        [(gcf, spectrum, {"metcalf": Score("metcalf", 1.0, {"cutoff": 0.5})})]
+
+        Check if there is a link between two objects:
+        >>> lg.has_link(gcf, spectrum)
+        True
+
+        Get the link data between two objects:
+        >>> lg.get_link_data(gcf, spectrum)
+        {"metcalf": Score("metcalf", 1.0, {"cutoff": 0.5})}
+    """
+
+    def __init__(self) -> None:
+        self._g = Graph()
+
+    def __str__(self) -> str:
+        """Get a short summary of the LinkGraph."""
+        return f"{self.__class__.__name__}(#links={len(self.links)}, #objects={len(self)})"
+
+    def __len__(self) -> int:
+        """Get the number of objects."""
+        return len(self._g)
+
+    @validate_u
+    def __getitem__(
+        self, u: GCF | Spectrum | MolecularFamily
+    ) -> dict[GCF | Spectrum | MolecularFamily, dict[str, Score]]:
+        """Get all links for a given object.
+
+        Args:
+            u: the given object
+
+        Returns:
+            A dictionary of links for the given object.
+
+        Raises:
+            KeyError: if the input object is not found in the link graph.
+        """
+        try:
+            links = self._g[u]
+        except KeyError:
+            raise KeyError(f"{u} not found in the link graph.")
+
+        return {**links}
+
+    @property
+    def links(
+        self,
+    ) -> list[
+        tuple[GCF | Spectrum | MolecularFamily, GCF | Spectrum | MolecularFamily, dict[str, Score]]
+    ]:
+        """Get all links.
+
+        Returns:
+            A list of tuples containing the links between objects.
+        """
+        return list(self._g.edges(data=True))
+
+    @validate_uv
+    def add_link(
+        self,
+        u: GCF | Spectrum | MolecularFamily,
+        v: GCF | Spectrum | MolecularFamily,
+        **data: Score,
+    ) -> None:
+        """Add a link between two objects.
+
+        The objects `u` and `v` must be different types, i.e. one must be a GCF and the other must be
+        a Spectrum or MolecularFamily.
+
+        Args:
+            u: the first object, either a GCF, Spectrum, or MolecularFamily
+            v: the second object, either a GCF, Spectrum, or MolecularFamily
+            data: keyword arguments. At least one scoring method and its data must be provided.
+                The key must be the name of the scoring method defined in `ScoringMethod`, and the
+                value is a `Score` object, e.g. `metcalf=Score("metcalf", 1.0, {"cutoff": 0.5})`.
+        """
+        # validate the data
+        if not data:
+            raise ValueError("At least one scoring method and its data must be provided.")
+        for key, value in data.items():
+            if not ScoringMethod.has_value(key):
+                raise ValueError(
+                    f"{key} is not a valid name of scoring method. See `ScoringMethod` for valid names."
+                )
+            if not isinstance(value, Score):
+                raise TypeError(f"{value} is not a Score object.")
+
+        self._g.add_edge(u, v, **data)
+
+    @validate_uv
+    def has_link(
+        self, u: GCF | Spectrum | MolecularFamily, v: GCF | Spectrum | MolecularFamily
+    ) -> bool:
+        """Check if there is a link between two objects.
+
+        Args:
+            u: the first object, either a GCF, Spectrum, or MolecularFamily
+            v: the second object, either a GCF, Spectrum, or MolecularFamily
+
+        Returns:
+            True if there is a link between the two objects, False otherwise
+        """
+        return self._g.has_edge(u, v)
+
+    @validate_uv
+    def get_link_data(
+        self,
+        u: GCF | Spectrum | MolecularFamily,
+        v: GCF | Spectrum | MolecularFamily,
+    ) -> dict[str, Score] | None:
+        """Get the data for a link between two objects.
+
+        Args:
+            u: the first object, either a GCF, Spectrum, or MolecularFamily
+            v: the second object, either a GCF, Spectrum, or MolecularFamily
+
+        Returns:
+            A dictionary of scoring methods and their data for the link between the two objects, or
+            None if there is no link between the two objects.
+        """
+        return self._g.get_edge_data(u, v)
diff --git a/src/nplinker/scoring/metcalf_scoring.py b/src/nplinker/scoring/metcalf_scoring.py
index d8ea0add..54b81c18 100644
--- a/src/nplinker/scoring/metcalf_scoring.py
+++ b/src/nplinker/scoring/metcalf_scoring.py
@@ -11,7 +11,8 @@
 from nplinker.pickler import load_pickled_data
 from nplinker.pickler import save_pickled_data
 from .abc import ScoringBase
-from .object_link import ObjectLink
+from .link_graph import LinkGraph
+from .link_graph import Score
 from .utils import get_presence_gcf_strain
 from .utils import get_presence_mf_strain
 from .utils import get_presence_spec_strain
@@ -20,7 +21,6 @@
 
 if TYPE_CHECKING:
     from ..nplinker import NPLinker
-    from . import LinkCollection
 
 
 logger = logging.getLogger(__name__)
@@ -70,8 +70,6 @@ def __init__(self, npl: NPLinker) -> None:
                 to True.
         """
         super().__init__(npl)
-        self.cutoff: float = 1.0
-        self.standardised: bool = True
 
     # TODO CG: refactor this method and extract code for cache file to a separate method
     @classmethod
@@ -166,29 +164,32 @@ def calc_score(
             n_strains = cls.presence_gcf_strain.shape[1]
             cls.metcalf_mean, cls.metcalf_std = cls._calc_mean_std(n_strains, scoring_weights)
 
-    def get_links(
-        self, *objects: GCF | Spectrum | MolecularFamily, link_collection: LinkCollection
-    ) -> LinkCollection:
-        """Get links for the given objects and add them to the given LinkCollection.
+    def get_links(self, *objects: GCF | Spectrum | MolecularFamily, **parameters) -> LinkGraph:
+        """Get links for the given objects.
 
-        The given objects are treated as input or source objects, which must
-        be GCF, Spectrum or MolecularFamily objects.
+        The given objects are treated as input or source objects, which must be GCF, Spectrum or
+        MolecularFamily objects.
 
         Args:
-            objects: The objects to get links for. Must be GCF, Spectrum
-                or MolecularFamily objects.
-            link_collection: The LinkCollection object to add the links to.
+            objects: The objects to get links for. Must be GCF, Spectrum or MolecularFamily objects.
+            parameters: The scoring parameters to use for the links. The parameters are:
+
+                    - cutoff: The minimum score to consider a link (≥cutoff). Default is 0.
+                    - standardised: Whether to use standardised scores. Default is False.
 
         Returns:
-            The LinkCollection object with the new links added.
+            The LinkGraph object containing the links involving the input objects.
 
         Raises:
             ValueError: If the input objects are empty.
             TypeError: If the input objects are not of the correct type.
         """
+        # validate input objects
+        # if the input objects are empty, use all objects
         if len(objects) == 0:
-            raise ValueError("Empty input objects.")
+            objects = self.npl.gcfs
 
+        # TODO: allow mixed input types?
         if isinstance_all(*objects, objtype=GCF):
             obj_type = "gcf"
         elif isinstance_all(*objects, objtype=Spectrum):
@@ -201,9 +202,14 @@ def get_links(
                 f"Invalid type {set(types)}. Input objects must be GCF, Spectrum or MolecularFamily objects."
             )
 
-        logger.info(f"MetcalfScoring: standardised = {self.standardised}")
-        if not self.standardised:
-            scores_list = self._get_links(*objects, score_cutoff=self.cutoff)
+        # validate scoring parameters
+        self._cutoff: float = parameters.get("cutoff", 0)
+        self._standardised: bool = parameters.get("standardised", False)
+        parameters.update({"cutoff": self._cutoff, "standardised": self._standardised})
+
+        logger.info(f"MetcalfScoring: standardised = {self._standardised}")
+        if not self._standardised:
+            scores_list = self._get_links(*objects, score_cutoff=self._cutoff)
         # TODO CG: verify the logics of standardised score and add unit tests
         else:
             # use negative infinity as the score cutoff to ensure we get all links
@@ -214,14 +220,13 @@ def get_links(
             else:
                 scores_list = self._calc_standardised_score_met(scores_list)
 
-        link_scores: dict[
-            GCF | Spectrum | MolecularFamily, dict[GCF | Spectrum | MolecularFamily, ObjectLink]
-        ] = {}
+        links = LinkGraph()
         if obj_type == "gcf":
             logger.info(
                 f"MetcalfScoring: input_type=GCF, result_type=Spec/MolFam, "
                 f"#inputs={len(objects)}."
             )
+            # scores is the DataFrame with index "source", "target", "score"
             for scores in scores_list:
                 # when no links found
                 if scores.shape[1] == 0:
@@ -234,13 +239,12 @@ def get_links(
                             met = self.npl.lookup_spectrum(scores.loc["target", col_index])
                         else:
                             met = self.npl.lookup_mf(scores.loc["target", col_index])
-                        if gcf not in link_scores:
-                            link_scores[gcf] = {}
-                        # TODO CG: use id instead of object for gcf, met and self?
-                        link_scores[gcf][met] = ObjectLink(
-                            gcf, met, self, scores.loc["score", col_index]
+                        links.add_link(
+                            gcf,
+                            met,
+                            metcalf=Score(self.name, scores.loc["score", col_index], parameters),
                         )
-                    logger.info(f"MetcalfScoring: found {len(link_scores)} {scores.name} links.")
+                    logger.info(f"MetcalfScoring: found {len(links)} {scores.name} links.")
         else:
             logger.info(
                 f"MetcalfScoring: input_type=Spec/MolFam, result_type=GCF, "
@@ -257,16 +261,15 @@ def get_links(
                         met = self.npl.lookup_spectrum(scores.loc["source", col_index])
                     else:
                         met = self.npl.lookup_mf(scores.loc["source", col_index])
-                    if met not in link_scores:
-                        link_scores[met] = {}
-                    link_scores[met][gcf] = ObjectLink(
-                        met, gcf, self, scores.loc["score", col_index]
+                    links.add_link(
+                        met,
+                        gcf,
+                        metcalf=Score(self.name, scores.loc["score", col_index], parameters),
                     )
-                logger.info(f"MetcalfScoring: found {len(link_scores)} {scores.name} links.")
+                logger.info(f"MetcalfScoring: found {len(links)} {scores.name} links.")
 
-        link_collection._add_links_from_method(self, link_scores)
         logger.info("MetcalfScoring: completed")
-        return link_collection
+        return links
 
     # TODO CG: refactor this method
     def format_data(self, data):
@@ -345,15 +348,14 @@ def _calc_mean_std(
     def _get_links(
         self,
         *objects: tuple[GCF, ...] | tuple[Spectrum, ...] | tuple[MolecularFamily, ...],
-        score_cutoff: float = 0.5,
+        score_cutoff: float = 0,
     ) -> list[pd.DataFrame]:
         """Get links and scores for given objects.
 
         Args:
             objects: A list of GCF, Spectrum or MolecularFamily objects
                 and all objects must be of the same type.
-            score_cutoff: Minimum score to consider a link (≥score_cutoff).
-                Default is 0.5.
+            score_cutoff: Minimum score to consider a link (≥score_cutoff). Default is 0.
 
         Returns:
             List of data frames containing the ids of the linked objects
@@ -457,7 +459,7 @@ def _calc_standardised_score_met(self, results: list) -> list[pd.DataFrame]:
             z_scores.append(z_score)
 
         z_scores = np.array(z_scores)
-        mask = z_scores >= self.cutoff
+        mask = z_scores >= self._cutoff
 
         scores_df = pd.DataFrame(
             [
@@ -495,7 +497,7 @@ def _calc_standardised_score_gen(self, results: list) -> list[pd.DataFrame]:
                 z_scores.append(z_score)
 
             z_scores = np.array(z_scores)
-            mask = z_scores >= self.cutoff
+            mask = z_scores >= self._cutoff
 
             scores_df = pd.DataFrame(
                 [
diff --git a/src/nplinker/scoring/np_class_scoring.py b/src/nplinker/scoring/np_class_scoring.py
index 5bf2dd7a..e351f872 100644
--- a/src/nplinker/scoring/np_class_scoring.py
+++ b/src/nplinker/scoring/np_class_scoring.py
@@ -3,9 +3,10 @@
 from nplinker.genomics import BGC
 from nplinker.genomics import GCF
 from nplinker.metabolomics import Spectrum
-from nplinker.scoring.abc import ScoringBase
-from nplinker.scoring.metcalf_scoring import MetcalfScoring
-from nplinker.scoring.object_link import ObjectLink
+from nplinker.strain import StrainCollection
+from .abc import ScoringBase
+from .link_graph import LinkGraph
+from .score import Score
 
 
 logger = logging.getLogger(__name__)
@@ -329,7 +330,8 @@ def setup(cls, npl):
             logger.info(f"Currently the method '{met_options[0]}' is selected")
         # todo: give info about parameters
 
-    def get_links(self, objects, link_collection):
+    def get_links(self, *objects, **parameters):
+        # TODO: replace some attributes with parameters
         """Given a set of objects, return link information."""
         # todo: pickle results
         logger.info("Running NPClassScore...")
@@ -344,14 +346,9 @@ def get_links(self, objects, link_collection):
         else:
             targets_classes = [self._get_gen_classes(target) for target in targets]
 
-        logger.info("Using Metcalf scoring to get shared strains")
-        # get mapping of shared strains
-        if not self.npl._datalinks:
-            self.npl._datalinks = self.npl.scoring_method(MetcalfScoring.name).datalinks
-        if obj_is_gen:
-            common_strains = self.npl.get_common_strains(targets, objects)
-        else:
-            common_strains = self.npl.get_common_strains(objects, targets)
+        # TODO: implement the computation of common strains between objects and targets
+        common_strains = StrainCollection()
+
         logger.info(
             f"Calculating NPClassScore for {len(objects)} objects to "
             f"{len(targets)} targets ({len(common_strains)} pairwise "
@@ -359,6 +356,7 @@ def get_links(self, objects, link_collection):
             f"take a while."
         )
 
+        lg = LinkGraph()
         results = {}
         for obj in objects:
             results[obj] = {}
@@ -370,7 +368,14 @@ def get_links(self, objects, link_collection):
 
             for target, target_classes in zip(targets, targets_classes):
                 self._create_object_link(
-                    obj_is_gen, common_strains, results, obj, obj_classes, target, target_classes
+                    obj_is_gen,
+                    common_strains,
+                    lg,
+                    obj,
+                    obj_classes,
+                    target,
+                    target_classes,
+                    parameters,
                 )
 
         # info about spectra/MFs with missing scoring
@@ -387,11 +392,10 @@ def get_links(self, objects, link_collection):
             )
 
         logger.info(f"NPClassScore completed in {time.time() - begin:.1f}s")
-        link_collection._add_links_from_method(self, results)
-        return link_collection
+        return lg
 
     def _create_object_link(
-        self, obj_is_gen, common_strains, results, obj, obj_classes, target, target_classes
+        self, obj_is_gen, common_strains, lg, obj, obj_classes, target, target_classes, parameters
     ):
         # only consider targets that have shared strains
         common_tup = (obj, target)
@@ -408,10 +412,10 @@ def _create_object_link(
                 # no score is found due to missing classes for spectra
                 self._target_no_scores.add(target)  # keep track
                 if not self.filter_missing_scores:
-                    results[obj][target] = ObjectLink(obj, target, self, full_score)
+                    lg.add_link(obj, target, Score(self.name, full_score, parameters))
             else:
                 if npclassscore > self.cutoff:
-                    results[obj][target] = ObjectLink(obj, target, self, full_score)
+                    lg.add_link(obj, target, Score(self.name, full_score, parameters))
 
     def format_data(self, data):
         """Given whatever output data the method produces, return a readable string version."""
diff --git a/src/nplinker/scoring/object_link.py b/src/nplinker/scoring/object_link.py
deleted file mode 100644
index ab493c77..00000000
--- a/src/nplinker/scoring/object_link.py
+++ /dev/null
@@ -1,82 +0,0 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING
-
-
-if TYPE_CHECKING:
-    from nplinker.genomics import GCF
-    from nplinker.metabolomics import MolecularFamily
-    from nplinker.metabolomics import Spectrum
-    from nplinker.scoring import ScoringBase
-    from nplinker.strain import StrainCollection
-
-
-class ObjectLink:
-    """Class which stores information about a single link between two objects.
-
-    There will be at most one instance of an ObjectLink for a given pair of
-    objects (source, target) after running 1 or more scoring methods. Some
-    methods, e.g. Metcalf, will always produce a single output per link.
-    However other methods like Rosetta may find multiple "hits" for a given
-    pair. In either case the data for a given method is associated with the
-    ObjectLink so it can be retrieved afterwards.
-
-    The information stored is basically:
-     - the "source" of the link (original object provided as part of the input)
-     - the "target" of the link (linked object, as determined by the method(s) used)
-     - a (possibly empty) list of Strain objects shared between source and target
-     - the output of the scoring method(s) used for this link (e.g. a metcalf score)
-    """
-
-    def __init__(
-        self,
-        source: GCF | Spectrum | MolecularFamily,
-        target: GCF | Spectrum | MolecularFamily,
-        method: ScoringBase,
-        data=None,
-    ):
-        self.source = source
-        self.target = target
-        self._method_data = {method: data}
-
-    def _merge(self, other_link):
-        self._method_data.update(other_link._method_data)
-        return self
-
-    def set_data(self, method, newdata):
-        self._method_data[method] = newdata
-
-    @property
-    def common_strains(self) -> StrainCollection:
-        """Get the strains common to both source and target."""
-        return self.source.strains(self.target.strains)
-
-    @property
-    def method_count(self):
-        return len(self._method_data)
-
-    @property
-    def methods(self):
-        return list(self._method_data.keys())
-
-    def data(self, method):
-        return self._method_data[method]
-
-    def __getitem__(self, name):
-        if name in self._method_data:
-            return self._method_data[name]
-
-        return object.__getitem__(self, name)
-
-    def __hash__(self):
-        # return the nplinker internal ID as hash value (for set/dict etc)
-        # TODO: hashable object should also have `__eq__` defined, see #136.
-        # this implementation is not ideal as the hash value is not unique
-        return hash(self.source.id)
-
-    def __str__(self):
-        return "ObjectLink(source={}, target={}, #methods={})".format(
-            self.source, self.target, len(self._method_data)
-        )
-
-    def __repr__(self):
-        return str(self)
diff --git a/src/nplinker/scoring/rosetta_scoring.py b/src/nplinker/scoring/rosetta_scoring.py
index 9ad960d1..c8a6ce62 100644
--- a/src/nplinker/scoring/rosetta_scoring.py
+++ b/src/nplinker/scoring/rosetta_scoring.py
@@ -4,8 +4,9 @@
 from nplinker.genomics.gcf import GCF
 from nplinker.metabolomics import MolecularFamily
 from nplinker.scoring.abc import ScoringBase
-from nplinker.scoring.object_link import ObjectLink
 from nplinker.scoring.rosetta.rosetta import Rosetta
+from .link_graph import LinkGraph
+from .score import Score
 
 
 logger = logging.getLogger(__name__)
@@ -66,32 +67,31 @@ def _include_hit(self, hit):
     def _insert_result_gen(self, results, src, hit):
         if src not in results:
             results[src] = {}
-        # Rosetta can produce multiple "hits" per link, need to
-        # ensure the ObjectLink contains all the RosettaHit objects
-        # in these cases
+        # Rosetta can produce multiple "hits" per link
         if hit.spec in results[src]:
             original_data = results[src][hit.spec].data(self)
             results[src][hit.spec].set_data(self, original_data + [hit])
         else:
-            results[src][hit.spec] = ObjectLink(src, hit.spec, self, data=[hit])
+            results[src][hit.spec] = Score(name=self.name, value=[hit], parameter=self._params)
 
         return results
 
     def _insert_result_met(self, results, spec, target, hit):
         if spec not in results:
             results[spec] = {}
-        # Rosetta can produce multiple "hits" per link, need to
-        # ensure the ObjectLink contains all the RosettaHit objects
-        # in these cases
+        # Rosetta can produce multiple "hits" per link
         if target in results[spec]:
             original_data = results[spec][target].data(self)
             results[spec][target].set_data(self, original_data + [hit])
         else:
-            results[spec][target] = ObjectLink(spec, target, self, data=[hit])
+            results[spec][target] = Score(name=self.name, value=[hit], parameter=self._params)
 
         return results
 
-    def get_links(self, objects, link_collection):
+    def get_links(self, *objects, **parameters):
+        # TODO: replace some attributes with parameters
+        self._params = parameters
+
         self._validate_inputs(objects)
 
         if isinstance(objects[0], GCF):
@@ -115,10 +115,13 @@ def get_links(self, objects, link_collection):
             results = self._collect_results_bgc(objects, ro_hits, results)
         else:  # Spectrum
             results = self._collect_results_spectra(objects, ro_hits, results)
-
-        link_collection._add_links_from_method(self, results)
         logger.debug(f"RosettaScoring found {len(results)} results")
-        return link_collection
+
+        lg = LinkGraph()
+        for src, links in results.items():
+            for target, score in links.items():
+                lg.add_link(src, target, score)
+        return lg
 
     def _collect_results_spectra(self, objects, ro_hits, results):
         for spec in objects:
diff --git a/src/nplinker/scoring/score.py b/src/nplinker/scoring/score.py
new file mode 100644
index 00000000..7aa80913
--- /dev/null
+++ b/src/nplinker/scoring/score.py
@@ -0,0 +1,48 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from dataclasses import fields
+from .scoring_method import ScoringMethod
+
+
+@dataclass
+class Score:
+    """A data class to represent score data.
+
+    Attributes:
+        name: the name of the scoring method. See `ScoringMethod` for valid values.
+        value: the score value.
+        parameter: the parameters used for the scoring method.
+    """
+
+    name: str
+    value: float
+    parameter: dict
+
+    def __post_init__(self) -> None:
+        """Check if the value of `name` is valid.
+
+        Raises:
+            ValueError: if the value of `name` is not valid.
+        """
+        if ScoringMethod.has_value(self.name) is False:
+            raise ValueError(
+                f"{self.name} is not a valid value. Valid values are: {[e.value for e in ScoringMethod]}"
+            )
+
+    def __getitem__(self, key):
+        if key in {field.name for field in fields(self)}:
+            return getattr(self, key)
+        else:
+            raise KeyError(f"{key} not found in {self.__class__.__name__}")
+
+    def __setitem__(self, key, value):
+        # validate the value of `name`
+        if key == "name" and ScoringMethod.has_value(value) is False:
+            raise ValueError(
+                f"{value} is not a valid value. Valid values are: {[e.value for e in ScoringMethod]}"
+            )
+
+        if key in {field.name for field in fields(self)}:
+            setattr(self, key, value)
+        else:
+            raise KeyError(f"{key} not found in {self.__class__.__name__}")
diff --git a/src/nplinker/scoring/scoring_method.py b/src/nplinker/scoring/scoring_method.py
new file mode 100644
index 00000000..ac256edc
--- /dev/null
+++ b/src/nplinker/scoring/scoring_method.py
@@ -0,0 +1,16 @@
+from enum import Enum
+from enum import unique
+
+
+@unique
+class ScoringMethod(Enum):
+    """Enum class for scoring methods."""
+
+    METCALF = "metcalf"
+    ROSETTA = "rosetta"
+    NPLCLASS = "nplclass"
+
+    @classmethod
+    def has_value(cls, value: str) -> bool:
+        """Check if the enum has a value."""
+        return any(value == item.value for item in cls)
diff --git a/tests/unit/scoring/test_link_graph.py b/tests/unit/scoring/test_link_graph.py
new file mode 100644
index 00000000..545fee2c
--- /dev/null
+++ b/tests/unit/scoring/test_link_graph.py
@@ -0,0 +1,85 @@
+import pytest
+from pytest import fixture
+from nplinker.scoring import LinkGraph
+from nplinker.scoring import Score
+
+
+@fixture(scope="module")
+def score():
+    return Score("metcalf", 1.0, {"cutoff": 0.5})
+
+
+@fixture
+def lg(gcfs, spectra, score):
+    lg = LinkGraph()
+    lg.add_link(gcfs[0], spectra[0], metcalf=score)
+    return lg
+
+
+def test_init():
+    lg = LinkGraph()
+    assert len(lg) == 0
+
+
+def test_len(lg):
+    assert len(lg) == 2  # 2 objects or nodes
+
+
+def test_getitem(lg, gcfs, spectra, score):
+    # test existing objects
+    assert lg[gcfs[0]] == {spectra[0]: {"metcalf": score}}
+    assert lg[spectra[0]] == {gcfs[0]: {"metcalf": score}}
+
+    # test non-existing object
+    with pytest.raises(KeyError, match=".* not found in the link graph."):
+        lg[gcfs[1]]
+
+    # test invalid object
+    with pytest.raises(TypeError, match=".* is not a GCF, Spectrum, or MolecularFamily object."):
+        lg["gcf"]
+
+
+def test_links(lg, gcfs, spectra, score):
+    assert len(lg.links) == 1
+    assert lg.links == [(gcfs[0], spectra[0], {"metcalf": score})]
+
+
+def test_add_link(gcfs, spectra, score):
+    lg = LinkGraph()
+    lg.add_link(gcfs[0], spectra[0], metcalf=score)
+
+    # test invalid objects
+    with pytest.raises(TypeError, match=".* is not a GCF, Spectrum, or MolecularFamily object."):
+        lg.add_link("gcf", spectra[0], metcalf=score)
+
+    with pytest.raises(TypeError, match=".* is not a Spectrum or MolecularFamily object."):
+        lg.add_link(gcfs[0], "spectrum", metcalf=score)
+
+    with pytest.raises(TypeError, match=".* is not a Spectrum or MolecularFamily object."):
+        lg.add_link(gcfs[0], gcfs[0], metcalf=score)
+
+    with pytest.raises(TypeError, match=".* is not a GCF object."):
+        lg.add_link(spectra[0], "gcf", metcalf=score)
+
+    # test invalid scoring data
+    with pytest.raises(
+        ValueError, match="At least one scoring method and its data must be provided."
+    ):
+        lg.add_link(gcfs[0], spectra[0])
+
+    with pytest.raises(ValueError, match=".* is not a valid name of scoring method.*"):
+        lg.add_link(gcfs[0], spectra[0], invalid=score)
+
+    with pytest.raises(TypeError, match=".* is not a Score object."):
+        lg.add_link(gcfs[0], spectra[0], metcalf="score")
+
+
+def test_has_link(lg, gcfs, spectra):
+    assert lg.has_link(gcfs[0], spectra[0]) is True
+    assert lg.has_link(gcfs[0], spectra[1]) is False
+    assert lg.has_link(gcfs[1], spectra[1]) is False
+
+
+def test_get_link_data(lg, gcfs, spectra, score):
+    assert lg.get_link_data(gcfs[0], spectra[0]) == {"metcalf": score}
+    assert lg.get_link_data(gcfs[0], spectra[1]) is None
diff --git a/tests/unit/scoring/test_metcalf_scoring.py b/tests/unit/scoring/test_metcalf_scoring.py
index b1cf4c7a..4e6e5651 100644
--- a/tests/unit/scoring/test_metcalf_scoring.py
+++ b/tests/unit/scoring/test_metcalf_scoring.py
@@ -2,17 +2,13 @@
 import pandas as pd
 import pytest
 from pandas.testing import assert_frame_equal
-from nplinker.scoring import LinkCollection
 from nplinker.scoring import MetcalfScoring
-from nplinker.scoring import ObjectLink
 
 
 def test_init(npl):
     mc = MetcalfScoring(npl)
     assert mc.npl == npl
     assert mc.name == "metcalf"
-    assert mc.cutoff == 1.0
-    assert mc.standardised is True
     assert_frame_equal(mc.presence_gcf_strain, pd.DataFrame())
     assert_frame_equal(mc.presence_spec_strain, pd.DataFrame())
     assert_frame_equal(mc.presence_mf_strain, pd.DataFrame())
@@ -168,125 +164,81 @@ def test_calc_score_mean_std(mc):
 #
 
 
+def test_get_links_default(mc, gcfs, spectra, mfs):
+    lg = mc.get_links()
+    assert lg[gcfs[0]][spectra[0]][mc.name].value == 12
+    assert lg[gcfs[1]].get(spectra[0]) is None
+    assert lg[gcfs[2]][spectra[0]][mc.name].value == 11
+    assert lg[gcfs[0]][mfs[0]][mc.name].value == 12
+    assert lg[gcfs[1]][mfs[1]][mc.name].value == 12
+    assert lg[gcfs[2]][mfs[2]][mc.name].value == 21
+
+
 def test_get_links_gcf_standardised_false(mc, gcfs, spectra, mfs):
     """Test `get_links` method when input is GCF objects and `standardised` is False."""
-    # test raw scores (no standardisation)
-    mc.standardised = False
-
     # when cutoff is negative infinity, i.e. taking all scores
-    mc.cutoff = np.NINF
-    links = mc.get_links(*gcfs, link_collection=LinkCollection())
-    assert isinstance(links, LinkCollection)
-    links = links.links  # dict of link values
-    assert len(links) == 3
-    assert {i.gcf_id for i in links.keys()} == {"gcf1", "gcf2", "gcf3"}
-    assert isinstance(links[gcfs[0]][spectra[0]], ObjectLink)
-    assert links[gcfs[0]][spectra[0]].data(mc) == 12
-    assert links[gcfs[1]][spectra[0]].data(mc) == -9
-    assert links[gcfs[2]][spectra[0]].data(mc) == 11
-    assert links[gcfs[0]][mfs[0]].data(mc) == 12
-    assert links[gcfs[1]][mfs[1]].data(mc) == 12
-    assert links[gcfs[2]][mfs[2]].data(mc) == 21
+    lg = mc.get_links(*gcfs, cutoff=np.NINF, standardised=False)
+    assert lg[gcfs[0]][spectra[0]][mc.name].value == 12
+    assert lg[gcfs[1]][spectra[0]][mc.name].value == -9
+    assert lg[gcfs[2]][spectra[0]][mc.name].value == 11
+    assert lg[gcfs[0]][mfs[0]][mc.name].value == 12
+    assert lg[gcfs[1]][mfs[1]][mc.name].value == 12
+    assert lg[gcfs[2]][mfs[2]][mc.name].value == 21
 
     # when test cutoff is 0, i.e. taking scores >= 0
-    mc.cutoff = 0
-    links = mc.get_links(*gcfs, link_collection=LinkCollection())
-    assert isinstance(links, LinkCollection)
-    links = links.links
-    assert {i.gcf_id for i in links.keys()} == {"gcf1", "gcf2", "gcf3"}
-    assert isinstance(links[gcfs[0]][spectra[0]], ObjectLink)
-    assert links[gcfs[0]][spectra[0]].data(mc) == 12
-    assert links[gcfs[1]].get(spectra[0]) is None
-    assert links[gcfs[2]][spectra[0]].data(mc) == 11
-    assert links[gcfs[0]][mfs[0]].data(mc) == 12
-    assert links[gcfs[1]][mfs[1]].data(mc) == 12
-    assert links[gcfs[2]][mfs[2]].data(mc) == 21
+    lg = mc.get_links(*gcfs, cutoff=0, standardised=False)
+    assert lg[gcfs[0]][spectra[0]][mc.name].value == 12
+    assert lg[gcfs[1]].get(spectra[0]) is None
+    assert lg[gcfs[2]][spectra[0]][mc.name].value == 11
+    assert lg[gcfs[0]][mfs[0]][mc.name].value == 12
+    assert lg[gcfs[1]][mfs[1]][mc.name].value == 12
+    assert lg[gcfs[2]][mfs[2]][mc.name].value == 21
 
 
 @pytest.mark.skip(reason="To add after refactoring relevant code.")
 def test_get_links_gcf_standardised_true(mc, gcfs, spectra, mfs):
     """Test `get_links` method when input is GCF objects and `standardised` is True."""
-    mc.standardised = True
     ...
 
 
 def test_get_links_spec_standardised_false(mc, gcfs, spectra):
     """Test `get_links` method when input is Spectrum objects and `standardised` is False."""
-    mc.standardised = False
-
-    mc.cutoff = np.NINF
-    links = mc.get_links(*spectra, link_collection=LinkCollection())
-    assert isinstance(links, LinkCollection)
-    links = links.links  # dict of link values
-    assert len(links) == 3
-    assert {i.spectrum_id for i in links.keys()} == {"spectrum1", "spectrum2", "spectrum3"}
-    assert isinstance(links[spectra[0]][gcfs[0]], ObjectLink)
-    assert links[spectra[0]][gcfs[0]].data(mc) == 12
-    assert links[spectra[0]][gcfs[1]].data(mc) == -9
-    assert links[spectra[0]][gcfs[2]].data(mc) == 11
-
-    mc.cutoff = 0
-    links = mc.get_links(*spectra, link_collection=LinkCollection())
-    assert isinstance(links, LinkCollection)
-    links = links.links  # dict of link values
-    assert len(links) == 3
-    assert {i.spectrum_id for i in links.keys()} == {"spectrum1", "spectrum2", "spectrum3"}
-    assert isinstance(links[spectra[0]][gcfs[0]], ObjectLink)
-    assert links[spectra[0]][gcfs[0]].data(mc) == 12
-    assert links[spectra[0]].get(gcfs[1]) is None
-    assert links[spectra[0]][gcfs[2]].data(mc) == 11
+    lg = mc.get_links(*spectra, cutoff=np.NINF, standardised=False)
+    assert lg[spectra[0]][gcfs[0]][mc.name].value == 12
+    assert lg[spectra[0]][gcfs[1]][mc.name].value == -9
+    assert lg[spectra[0]][gcfs[2]][mc.name].value == 11
+
+    lg = mc.get_links(*spectra, cutoff=0, standardised=False)
+    assert lg[spectra[0]][gcfs[0]][mc.name].value == 12
+    assert lg[spectra[0]].get(gcfs[1]) is None
+    assert lg[spectra[0]][gcfs[2]][mc.name].value == 11
 
 
 @pytest.mark.skip(reason="To add after refactoring relevant code.")
 def test_get_links_spec_standardised_true(mc, gcfs, spectra):
     """Test `get_links` method when input is Spectrum objects and `standardised` is True."""
-    mc.standardised = True
     ...
 
 
 def test_get_links_mf_standardised_false(mc, gcfs, mfs):
     """Test `get_links` method when input is MolecularFamily objects and `standardised` is False."""
-    mc.standardised = False
-
-    mc.cutoff = np.NINF
-    links = mc.get_links(*mfs, link_collection=LinkCollection())
-    assert isinstance(links, LinkCollection)
-    links = links.links
-    assert len(links) == 3
-    assert {i.family_id for i in links.keys()} == {"mf1", "mf2", "mf3"}
-    assert isinstance(links[mfs[0]][gcfs[0]], ObjectLink)
-    assert links[mfs[0]][gcfs[0]].data(mc) == 12
-    assert links[mfs[0]][gcfs[1]].data(mc) == -9
-    assert links[mfs[0]][gcfs[2]].data(mc) == 11
-
-    mc.cutoff = 0
-    links = mc.get_links(*mfs, link_collection=LinkCollection())
-    assert isinstance(links, LinkCollection)
-    links = links.links
-    assert len(links) == 3
-    assert {i.family_id for i in links.keys()} == {"mf1", "mf2", "mf3"}
-    assert isinstance(links[mfs[0]][gcfs[0]], ObjectLink)
-    assert links[mfs[0]][gcfs[0]].data(mc) == 12
-    assert links[mfs[0]].get(gcfs[1]) is None
-    assert links[mfs[0]][gcfs[2]].data(mc) == 11
+    lg = mc.get_links(*mfs, cutoff=np.NINF, standardised=False)
+    assert lg[mfs[0]][gcfs[0]][mc.name].value == 12
+    assert lg[mfs[0]][gcfs[1]][mc.name].value == -9
+    assert lg[mfs[0]][gcfs[2]][mc.name].value == 11
+
+    lg = mc.get_links(*mfs, cutoff=0, standardised=False)
+    assert lg[mfs[0]][gcfs[0]][mc.name].value == 12
+    assert lg[mfs[0]].get(gcfs[1]) is None
+    assert lg[mfs[0]][gcfs[2]][mc.name].value == 11
 
 
 @pytest.mark.skip(reason="To add after refactoring relevant code.")
 def test_get_links_mf_standardised_true(mc, gcfs, mfs):
     """Test `get_links` method when input is MolecularFamily objects and `standardised` is True."""
-    mc.standardised = True
     ...
 
 
-@pytest.mark.parametrize(
-    "objects, expected", [([], "Empty input objects"), ("", "Empty input objects")]
-)
-def test_get_links_invalid_input_value(mc, objects, expected):
-    with pytest.raises(ValueError) as e:
-        mc.get_links(*objects, link_collection=LinkCollection())
-    assert expected in str(e.value)
-
-
 @pytest.mark.parametrize(
     "objects, expected",
     [
@@ -297,14 +249,14 @@ def test_get_links_invalid_input_value(mc, objects, expected):
 )
 def test_get_links_invalid_input_type(mc, objects, expected):
     with pytest.raises(TypeError) as e:
-        mc.get_links(*objects, link_collection=LinkCollection())
+        mc.get_links(*objects)
     assert expected in str(e.value)
 
 
 def test_get_links_invalid_mixed_types(mc, spectra, mfs):
     objects = (*spectra, *mfs)
     with pytest.raises(TypeError) as e:
-        mc.get_links(*objects, link_collection=LinkCollection())
+        mc.get_links(*objects)
     assert "Invalid type" in str(e.value)
     assert ".MolecularFamily" in str(e.value)
     assert ".Spectrum" in str(e.value)
diff --git a/tests/unit/scoring/test_nplinker_scoring.py b/tests/unit/scoring/test_nplinker_scoring.py
index 7464eef7..a76c2231 100644
--- a/tests/unit/scoring/test_nplinker_scoring.py
+++ b/tests/unit/scoring/test_nplinker_scoring.py
@@ -1,7 +1,8 @@
 import numpy as np
 import pytest
-from nplinker.scoring import LinkCollection
-from nplinker.scoring import ObjectLink
+
+
+pytestmark = pytest.mark.skip(reason="Skip until refactoring relevant code.")
 
 
 def test_get_links_gcf_standardised_false(npl, mc, gcfs, spectra, mfs, strains_list):
diff --git a/tests/unit/scoring/test_score.py b/tests/unit/scoring/test_score.py
new file mode 100644
index 00000000..5702d365
--- /dev/null
+++ b/tests/unit/scoring/test_score.py
@@ -0,0 +1,46 @@
+import pytest
+from nplinker.scoring import Score
+
+
+def test_init():
+    s = Score("metcalf", 1.0, {})
+    assert s.name == "metcalf"
+    assert s.value == 1.0
+    assert s.parameter == {}
+
+    s = Score("rosetta", 1.0, {})
+    assert s.name == "rosetta"
+    assert s.value == 1.0
+    assert s.parameter == {}
+
+    s = Score("nplclass", 1.0, {})
+    assert s.name == "nplclass"
+    assert s.value == 1.0
+    assert s.parameter == {}
+
+
+def test_post_init():
+    with pytest.raises(ValueError):
+        Score("invalid", 1.0, {})
+
+
+def test_getitem():
+    score = Score("metcalf", 1.0, {})
+    assert score["name"] == "metcalf"
+    assert score["value"] == 1.0
+    assert score["parameter"] == {}
+
+
+def test_setitem():
+    # valid values
+    score = Score("metcalf", 1.0, {})
+    score["name"] = "rosetta"
+    score["value"] = 2.0
+    score["parameter"] = {"cutoff": 0.5}
+    assert score.name == "rosetta"
+    assert score.value == 2.0
+    assert score.parameter == {"cutoff": 0.5}
+
+    # invalid value for name
+    with pytest.raises(ValueError, match=".* is not a valid value. .*"):
+        score["name"] = "invalid"
diff --git a/tests/unit/scoring/test_scoring_method.py b/tests/unit/scoring/test_scoring_method.py
new file mode 100644
index 00000000..3a433793
--- /dev/null
+++ b/tests/unit/scoring/test_scoring_method.py
@@ -0,0 +1,9 @@
+from nplinker.scoring import ScoringMethod
+
+
+def test_has_value():
+    assert ScoringMethod.has_value("metcalf") is True
+    assert ScoringMethod.has_value("rosetta") is True
+    assert ScoringMethod.has_value("nplclass") is True
+
+    assert ScoringMethod.has_value("invalid") is False