diff --git a/openedx/core/djangoapps/content/search/api.py b/openedx/core/djangoapps/content/search/api.py
index 9fb49b24b6d1..76bb5eb3f4a4 100644
--- a/openedx/core/djangoapps/content/search/api.py
+++ b/openedx/core/djangoapps/content/search/api.py
@@ -296,16 +296,12 @@ def rebuild_index(status_cb: Callable[[str], None] | None = None) -> None:
     status_cb("Counting courses...")
     num_courses = CourseOverview.objects.count()
 
-    # Get the list of collections
-    status_cb("Counting collections...")
-    num_collections = authoring_api.get_collections().count()
-
     # Some counters so we can track our progress as indexing progresses:
-    num_contexts = num_courses + num_libraries + num_collections
+    num_contexts = num_courses + num_libraries
     num_contexts_done = 0  # How many courses/libraries we've indexed
     num_blocks_done = 0  # How many individual components/XBlocks we've indexed
 
-    status_cb(f"Found {num_courses} courses, {num_libraries} libraries and {num_collections} collections.")
+    status_cb(f"Found {num_courses} courses, {num_libraries} libraries.")
     with _using_temp_index(status_cb) as temp_index_name:
         ############## Configure the index ##############
 
@@ -390,10 +386,43 @@ def index_library(lib_key: str) -> list:
                     status_cb(f"Error indexing library {lib_key}: {err}")
             return docs
 
+        ############## Collections ##############
+        def index_collection_batch(batch, num_done) -> int:
+            docs = []
+            for collection in batch:
+                try:
+                    doc = searchable_doc_for_collection(collection)
+                    # Uncomment below line once collections are tagged.
+                    # doc.update(searchable_doc_tags(collection.id))
+                    docs.append(doc)
+                except Exception as err:  # pylint: disable=broad-except
+                    status_cb(f"Error indexing collection {collection}: {err}")
+                num_done += 1
+
+            if docs:
+                try:
+                    # Add docs in batch of 100 at once (usually faster than adding one at a time):
+                    _wait_for_meili_task(client.index(temp_index_name).add_documents(docs))
+                except (TypeError, KeyError, MeilisearchError) as err:
+                    status_cb(f"Error indexing collection batch {p}: {err}")
+            return num_done
+
         for lib_key in lib_keys:
-            status_cb(f"{num_contexts_done + 1}/{num_contexts}. Now indexing library {lib_key}")
+            status_cb(f"{num_contexts_done + 1}/{num_contexts}. Now indexing blocks in library {lib_key}")
             lib_docs = index_library(lib_key)
             num_blocks_done += len(lib_docs)
+
+            # To reduce memory usage on large instances, split up the Collections into pages of 100 collections:
+            library = lib_api.get_library(lib_key)
+            collections = authoring_api.get_collections(library.learning_package.id, enabled=True)
+            num_collections = collections.count()
+            num_collections_done = 0
+            status_cb(f"{num_collections_done + 1}/{num_collections}. Now indexing collections in library {lib_key}")
+            paginator = Paginator(collections, 100)
+            for p in paginator.page_range:
+                num_collections_done = index_collection_batch(paginator.page(p).object_list, num_collections_done)
+            status_cb(f"{num_collections_done}/{num_collections} collections indexed for library {lib_key}")
+
             num_contexts_done += 1
 
         ############## Courses ##############
@@ -430,39 +459,6 @@ def add_with_children(block):
                 num_contexts_done += 1
                 num_blocks_done += len(course_docs)
 
-        ############## Collections ##############
-        status_cb("Indexing collections...")
-
-        def index_collection_batch(batch, num_contexts_done) -> int:
-            docs = []
-            for collection in batch:
-                status_cb(
-                    f"{num_contexts_done + 1}/{num_contexts}. "
-                    f"Now indexing collection {collection.title} ({collection.id})"
-                )
-                try:
-                    doc = searchable_doc_for_collection(collection)
-                    # Uncomment below line once collections are tagged.
-                    # doc.update(searchable_doc_tags(collection.id))
-                    docs.append(doc)
-                except Exception as err:  # pylint: disable=broad-except
-                    status_cb(f"Error indexing collection {collection}: {err}")
-                finally:
-                    num_contexts_done += 1
-
-            if docs:
-                try:
-                    # Add docs in batch of 100 at once (usually faster than adding one at a time):
-                    _wait_for_meili_task(client.index(temp_index_name).add_documents(docs))
-                except (TypeError, KeyError, MeilisearchError) as err:
-                    status_cb(f"Error indexing collection batch {p}: {err}")
-            return num_contexts_done
-
-        # To reduce memory usage on large instances, split up the Collections into pages of 100 collections:
-        paginator = Paginator(authoring_api.get_collections(enabled=True), 100)
-        for p in paginator.page_range:
-            num_contexts_done = index_collection_batch(paginator.page(p).object_list, num_contexts_done)
-
     status_cb(f"Done! {num_blocks_done} blocks indexed across {num_contexts_done} courses, collections and libraries.")
 
 
diff --git a/openedx/core/djangoapps/content/search/tests/test_api.py b/openedx/core/djangoapps/content/search/tests/test_api.py
index 549817700370..23840997b87b 100644
--- a/openedx/core/djangoapps/content/search/tests/test_api.py
+++ b/openedx/core/djangoapps/content/search/tests/test_api.py
@@ -177,8 +177,15 @@ def setUp(self):
 
         # Create a collection:
         self.learning_package = authoring_api.get_learning_package_by_key(self.library.key)
+        with freeze_time(created_date):
+            self.collection = authoring_api.create_collection(
+                learning_package_id=self.learning_package.id,
+                title="my_collection",
+                created_by=None,
+                description="my collection description"
+            )
         self.collection_dict = {
-            'id': 1,
+            'id': self.collection.id,
             'type': 'collection',
             'display_name': 'my_collection',
             'description': 'my collection description',
@@ -189,13 +196,6 @@ def setUp(self):
             "access_id": lib_access.id,
             'breadcrumbs': [{'display_name': 'Library'}]
         }
-        with freeze_time(created_date):
-            self.collection = authoring_api.create_collection(
-                learning_package_id=self.learning_package.id,
-                title="my_collection",
-                created_by=None,
-                description="my collection description"
-            )
 
     @override_settings(MEILISEARCH_ENABLED=False)
     def test_reindex_meilisearch_disabled(self, mock_meilisearch):
diff --git a/openedx/core/djangoapps/content_libraries/api.py b/openedx/core/djangoapps/content_libraries/api.py
index 9a4ccbd6456e..e3d4adc606d5 100644
--- a/openedx/core/djangoapps/content_libraries/api.py
+++ b/openedx/core/djangoapps/content_libraries/api.py
@@ -69,15 +69,20 @@
 from django.utils.translation import gettext as _
 from edx_rest_api_client.client import OAuthAPIClient
 from lxml import etree
-from opaque_keys.edx.keys import UsageKey, UsageKeyV2
+from opaque_keys.edx.keys import BlockTypeKey, UsageKey, UsageKeyV2
 from opaque_keys.edx.locator import (
     LibraryLocatorV2,
     LibraryUsageLocatorV2,
     LibraryLocator as LibraryLocatorV1
 )
 from opaque_keys import InvalidKeyError
-from openedx_events.content_authoring.data import ContentLibraryData, LibraryBlockData
+from openedx_events.content_authoring.data import (
+    ContentLibraryData,
+    ContentObjectData,
+    LibraryBlockData,
+)
 from openedx_events.content_authoring.signals import (
+    CONTENT_OBJECT_TAGS_CHANGED,
     CONTENT_LIBRARY_CREATED,
     CONTENT_LIBRARY_DELETED,
     CONTENT_LIBRARY_UPDATED,
@@ -86,7 +91,7 @@
     LIBRARY_BLOCK_UPDATED,
 )
 from openedx_learning.api import authoring as authoring_api
-from openedx_learning.api.authoring_models import Component, MediaType, LearningPackage
+from openedx_learning.api.authoring_models import Collection, Component, MediaType, LearningPackage, PublishableEntity
 from organizations.models import Organization
 from xblock.core import XBlock
 from xblock.exceptions import XBlockNotFoundError
@@ -111,6 +116,8 @@
 
 ContentLibraryNotFound = ContentLibrary.DoesNotExist
 
+ContentLibraryCollectionNotFound = Collection.DoesNotExist
+
 
 class ContentLibraryBlockNotFound(XBlockNotFoundError):
     """ XBlock not found in the content library """
@@ -1062,6 +1069,68 @@ def revert_changes(library_key):
     )
 
 
+def update_collection_components(
+    collection: Collection,
+    usage_keys: list[UsageKeyV2],
+    created_by: int | None = None,
+    remove=False,
+) -> Collection:
+    """
+    Associates the Collection with Components for the given UsageKeys.
+
+    By default the Components are added to the Collection.
+    If remove=True, the Components are removed from the Collection.
+
+    Raises:
+    * ContentLibraryCollectionNotFound if no Collection with the given pk is found in the given library.
+    * ContentLibraryBlockNotFound if any of the given usage_keys don't match Components in the given library.
+
+    Returns the updated Collection.
+    """
+    # Fetch the Component.key values for the provided UsageKeys.
+    component_keys = []
+    for usage_key in usage_keys:
+        # Parse the block_family from the key to use as namespace.
+        block_type = BlockTypeKey.from_string(str(usage_key))
+
+        try:
+            component = authoring_api.get_component_by_key(
+                collection.learning_package_id,
+                namespace=block_type.block_family,
+                type_name=usage_key.block_type,
+                local_key=usage_key.block_id,
+            )
+        except Component.DoesNotExist as exc:
+            raise ContentLibraryBlockNotFound(usage_key) from exc
+
+        component_keys.append(component.key)
+
+    # Note: Component.key matches its PublishableEntity.key
+    entities_qset = PublishableEntity.objects.filter(
+        key__in=component_keys,
+    )
+
+    if remove:
+        collection = authoring_api.remove_from_collection(
+            collection.pk,
+            entities_qset,
+        )
+    else:
+        collection = authoring_api.add_to_collection(
+            collection.pk,
+            entities_qset,
+            created_by=created_by,
+        )
+
+    # Emit a CONTENT_OBJECT_TAGS_CHANGED event for each of the objects added/removed
+    for usage_key in usage_keys:
+        CONTENT_OBJECT_TAGS_CHANGED.send_event(
+            content_object=ContentObjectData(object_id=usage_key),
+        )
+
+    return collection
+
+
 # V1/V2 Compatibility Helpers
 # (Should be removed as part of
 #  https://github.com/openedx/edx-platform/issues/32457)
diff --git a/openedx/core/djangoapps/content_libraries/serializers.py b/openedx/core/djangoapps/content_libraries/serializers.py
index 7c49d4af3c2b..6de602c63b36 100644
--- a/openedx/core/djangoapps/content_libraries/serializers.py
+++ b/openedx/core/djangoapps/content_libraries/serializers.py
@@ -4,7 +4,10 @@
 # pylint: disable=abstract-method
 from django.core.validators import validate_unicode_slug
 from rest_framework import serializers
+from rest_framework.exceptions import ValidationError
 
+from opaque_keys.edx.keys import UsageKeyV2
+from opaque_keys import InvalidKeyError
 
 from openedx_learning.api.authoring_models import Collection
 from openedx.core.djangoapps.content_libraries.constants import (
@@ -266,3 +269,33 @@ class ContentLibraryCollectionCreateOrUpdateSerializer(serializers.Serializer):
 
     title = serializers.CharField()
     description = serializers.CharField()
+
+
+class UsageKeyV2Serializer(serializers.Serializer):
+    """
+    Serializes a UsageKeyV2.
+    """
+    def to_representation(self, value: UsageKeyV2) -> str:
+        """
+        Returns the UsageKeyV2 value as a string.
+        """
+        return str(value)
+
+    def to_internal_value(self, value: str) -> UsageKeyV2:
+        """
+        Returns a UsageKeyV2 from the string value.
+
+        Raises ValidationError if invalid UsageKeyV2.
+        """
+        try:
+            return UsageKeyV2.from_string(value)
+        except InvalidKeyError as err:
+            raise ValidationError from err
+
+
+class ContentLibraryCollectionComponentsUpdateSerializer(serializers.Serializer):
+    """
+    Serializer for adding/removing Components to/from a Collection.
+    """
+
+    usage_keys = serializers.ListField(child=UsageKeyV2Serializer(), allow_empty=False)
diff --git a/openedx/core/djangoapps/content_libraries/tests/test_api.py b/openedx/core/djangoapps/content_libraries/tests/test_api.py
index 87ae180d291e..f3226876131e 100644
--- a/openedx/core/djangoapps/content_libraries/tests/test_api.py
+++ b/openedx/core/djangoapps/content_libraries/tests/test_api.py
@@ -13,8 +13,14 @@
     UsageKey,
 )
 from opaque_keys.edx.locator import LibraryLocatorV2
+from openedx_events.content_authoring.data import ContentObjectData
+from openedx_events.content_authoring.signals import CONTENT_OBJECT_TAGS_CHANGED
+from openedx_events.tests.utils import OpenEdxEventsTestMixin
+from openedx_learning.api import authoring as authoring_api
 
 from .. import api
+from ..models import ContentLibrary
+from .base import ContentLibrariesRestApiTest
 
 
 class EdxModulestoreImportClientTest(TestCase):
@@ -241,3 +247,127 @@ def test_import_block_when_url_is_from_studio(
             block_olx
         )
         mock_publish_changes.assert_not_called()
+
+
+class ContentLibraryCollectionsTest(ContentLibrariesRestApiTest, OpenEdxEventsTestMixin):
+    """
+    Tests for Content Library API collections methods.
+
+    Same guidelines as ContentLibrariesTestCase.
+    """
+    ENABLED_OPENEDX_EVENTS = [
+        CONTENT_OBJECT_TAGS_CHANGED.event_type,
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        Set up class method for the Test class.
+
+        TODO: It's unclear why we need to call start_events_isolation ourselves rather than relying on
+              OpenEdxEventsTestMixin.setUpClass to handle it. It fails it we don't, and many other test cases do it,
+              so we're following a pattern here. But that pattern doesn't really make sense.
+        """
+        super().setUpClass()
+        cls.start_events_isolation()
+
+    def setUp(self):
+        super().setUp()
+
+        # Create Content Libraries
+        self._create_library("test-lib-col-1", "Test Library 1")
+        self._create_library("test-lib-col-2", "Test Library 2")
+
+        # Fetch the created ContentLibrare objects so we can access their learning_package.id
+        self.lib1 = ContentLibrary.objects.get(slug="test-lib-col-1")
+        self.lib2 = ContentLibrary.objects.get(slug="test-lib-col-2")
+
+        # Create Content Library Collections
+        self.col1 = authoring_api.create_collection(
+            learning_package_id=self.lib1.learning_package.id,
+            title="Collection 1",
+            description="Description for Collection 1",
+            created_by=self.user.id,
+        )
+        self.col2 = authoring_api.create_collection(
+            learning_package_id=self.lib2.learning_package.id,
+            title="Collection 2",
+            description="Description for Collection 2",
+            created_by=self.user.id,
+        )
+
+        # Create some library blocks in lib1
+        self.lib1_problem_block = self._add_block_to_library(
+            self.lib1.library_key, "problem", "problem1",
+        )
+        self.lib1_html_block = self._add_block_to_library(
+            self.lib1.library_key, "html", "html1",
+        )
+
+    def test_update_collection_components(self):
+        assert not list(self.col1.entities.all())
+
+        self.col1 = api.update_collection_components(
+            collection=self.col1,
+            usage_keys=[
+                UsageKey.from_string(self.lib1_problem_block["id"]),
+                UsageKey.from_string(self.lib1_html_block["id"]),
+            ],
+        )
+        assert len(self.col1.entities.all()) == 2
+
+        self.col1 = api.update_collection_components(
+            collection=self.col1,
+            usage_keys=[
+                UsageKey.from_string(self.lib1_html_block["id"]),
+            ],
+            remove=True,
+        )
+        assert len(self.col1.entities.all()) == 1
+
+    def test_update_collection_components_event(self):
+        """
+        Check that a CONTENT_OBJECT_TAGS_CHANGED event is raised for each added/removed component.
+        """
+        event_receiver = mock.Mock()
+        CONTENT_OBJECT_TAGS_CHANGED.connect(event_receiver)
+        api.update_collection_components(
+            collection=self.col1,
+            usage_keys=[
+                UsageKey.from_string(self.lib1_problem_block["id"]),
+                UsageKey.from_string(self.lib1_html_block["id"]),
+            ],
+        )
+
+        assert event_receiver.call_count == 2
+        self.assertDictContainsSubset(
+            {
+                "signal": CONTENT_OBJECT_TAGS_CHANGED,
+                "sender": None,
+                "content_object": ContentObjectData(
+                    object_id=UsageKey.from_string(self.lib1_problem_block["id"]),
+                ),
+            },
+            event_receiver.call_args_list[0].kwargs,
+        )
+        self.assertDictContainsSubset(
+            {
+                "signal": CONTENT_OBJECT_TAGS_CHANGED,
+                "sender": None,
+                "content_object": ContentObjectData(
+                    object_id=UsageKey.from_string(self.lib1_html_block["id"]),
+                ),
+            },
+            event_receiver.call_args_list[1].kwargs,
+        )
+
+    def test_update_collection_components_from_wrong_library(self):
+        with self.assertRaises(api.ContentLibraryBlockNotFound) as exc:
+            api.update_collection_components(
+                collection=self.col2,
+                usage_keys=[
+                    UsageKey.from_string(self.lib1_problem_block["id"]),
+                    UsageKey.from_string(self.lib1_html_block["id"]),
+                ],
+            )
+            assert self.lib1_problem_block["id"] in str(exc.exception)
diff --git a/openedx/core/djangoapps/content_libraries/tests/test_views_collections.py b/openedx/core/djangoapps/content_libraries/tests/test_views_collections.py
index 1b4ce1a1b2fa..a03c7dd65484 100644
--- a/openedx/core/djangoapps/content_libraries/tests/test_views_collections.py
+++ b/openedx/core/djangoapps/content_libraries/tests/test_views_collections.py
@@ -3,6 +3,7 @@
 """
 
 from __future__ import annotations
+import ddt
 
 from openedx_learning.api.authoring_models import Collection
 from openedx_learning.api.authoring import create_collection
@@ -16,8 +17,10 @@
 URL_PREFIX = '/api/libraries/v2/{lib_key}/'
 URL_LIB_COLLECTIONS = URL_PREFIX + 'collections/'
 URL_LIB_COLLECTION = URL_LIB_COLLECTIONS + '{collection_id}/'
+URL_LIB_COLLECTION_COMPONENTS = URL_LIB_COLLECTION + 'components/'
 
 
+@ddt.ddt
 @skip_unless_cms  # Content Library Collections REST API is only available in Studio
 class ContentLibraryCollectionsViewsTest(ContentLibrariesRestApiTest):
     """
@@ -54,6 +57,20 @@ def setUp(self):
             description="Description for Collection 3",
         )
 
+        # Create some library blocks
+        self.lib1_problem_block = self._add_block_to_library(
+            self.lib1.library_key, "problem", "problem1",
+        )
+        self.lib1_html_block = self._add_block_to_library(
+            self.lib1.library_key, "html", "html1",
+        )
+        self.lib2_problem_block = self._add_block_to_library(
+            self.lib2.library_key, "problem", "problem2",
+        )
+        self.lib2_html_block = self._add_block_to_library(
+            self.lib2.library_key, "html", "html2",
+        )
+
     def test_get_library_collection(self):
         """
         Test retrieving a Content Library Collection
@@ -282,3 +299,119 @@ def test_delete_library_collection(self):
         )
 
         assert resp.status_code == 405
+
+    def test_get_components(self):
+        """
+        Retrieving components is not supported by the REST API;
+        use Meilisearch instead.
+        """
+        resp = self.client.get(
+            URL_LIB_COLLECTION_COMPONENTS.format(
+                lib_key=self.lib1.library_key,
+                collection_id=self.col1.id,
+            ),
+        )
+        assert resp.status_code == 405
+
+    def test_update_components(self):
+        """
+        Test adding and removing components from a collection.
+        """
+        # Add two components to col1
+        resp = self.client.patch(
+            URL_LIB_COLLECTION_COMPONENTS.format(
+                lib_key=self.lib1.library_key,
+                collection_id=self.col1.id,
+            ),
+            data={
+                "usage_keys": [
+                    self.lib1_problem_block["id"],
+                    self.lib1_html_block["id"],
+                ]
+            }
+        )
+        assert resp.status_code == 200
+        assert resp.data == {"count": 2}
+
+        # Remove one of the added components from col1
+        resp = self.client.delete(
+            URL_LIB_COLLECTION_COMPONENTS.format(
+                lib_key=self.lib1.library_key,
+                collection_id=self.col1.id,
+            ),
+            data={
+                "usage_keys": [
+                    self.lib1_problem_block["id"],
+                ]
+            }
+        )
+        assert resp.status_code == 200
+        assert resp.data == {"count": 1}
+
+    @ddt.data("patch", "delete")
+    def test_update_components_wrong_collection(self, method):
+        """
+        Collection must belong to the requested library.
+        """
+        resp = getattr(self.client, method)(
+            URL_LIB_COLLECTION_COMPONENTS.format(
+                lib_key=self.lib2.library_key,
+                collection_id=self.col1.id,
+            ),
+            data={
+                "usage_keys": [
+                    self.lib1_problem_block["id"],
+                ]
+            }
+        )
+        assert resp.status_code == 404
+
+    @ddt.data("patch", "delete")
+    def test_update_components_missing_data(self, method):
+        """
+        List of usage keys must contain at least one item.
+        """
+        resp = getattr(self.client, method)(
+            URL_LIB_COLLECTION_COMPONENTS.format(
+                lib_key=self.lib2.library_key,
+                collection_id=self.col3.id,
+            ),
+        )
+        assert resp.status_code == 400
+        assert resp.data == {
+            "usage_keys": ["This field is required."],
+        }
+
+    @ddt.data("patch", "delete")
+    def test_update_components_from_another_library(self, method):
+        """
+        Adding/removing components from another library raises a 404.
+        """
+        resp = getattr(self.client, method)(
+            URL_LIB_COLLECTION_COMPONENTS.format(
+                lib_key=self.lib2.library_key,
+                collection_id=self.col3.id,
+            ),
+            data={
+                "usage_keys": [
+                    self.lib1_problem_block["id"],
+                    self.lib1_html_block["id"],
+                ]
+            }
+        )
+        assert resp.status_code == 404
+
+    @ddt.data("patch", "delete")
+    def test_update_components_permissions(self, method):
+        """
+        Check that a random user without permissions cannot update a Content Library Collection's components.
+        """
+        random_user = UserFactory.create(username="Random", email="random@example.com")
+        with self.as_user(random_user):
+            resp = getattr(self.client, method)(
+                URL_LIB_COLLECTION_COMPONENTS.format(
+                    lib_key=self.lib1.library_key,
+                    collection_id=self.col1.id,
+                ),
+            )
+            assert resp.status_code == 403
diff --git a/openedx/core/djangoapps/content_libraries/views.py b/openedx/core/djangoapps/content_libraries/views.py
index bb1c4903f478..cc1a58634d4f 100644
--- a/openedx/core/djangoapps/content_libraries/views.py
+++ b/openedx/core/djangoapps/content_libraries/views.py
@@ -146,6 +146,9 @@ def wrapped_fn(*args, **kwargs):
         except api.ContentLibraryBlockNotFound:
             log.exception("XBlock not found in content library")
             raise NotFound  # lint-amnesty, pylint: disable=raise-missing-from
+        except api.ContentLibraryCollectionNotFound:
+            log.exception("Collection not found in content library")
+            raise NotFound  # lint-amnesty, pylint: disable=raise-missing-from
         except api.LibraryBlockAlreadyExists as exc:
             log.exception(str(exc))
             raise ValidationError(str(exc))  # lint-amnesty, pylint: disable=raise-missing-from
diff --git a/openedx/core/djangoapps/content_libraries/views_collections.py b/openedx/core/djangoapps/content_libraries/views_collections.py
index 5a51470077ae..0cfa51817312 100644
--- a/openedx/core/djangoapps/content_libraries/views_collections.py
+++ b/openedx/core/djangoapps/content_libraries/views_collections.py
@@ -4,8 +4,7 @@
 
 from __future__ import annotations
 
-from django.http import Http404
-
+from rest_framework.decorators import action
 from rest_framework.response import Response
 from rest_framework.viewsets import ModelViewSet
 from rest_framework.status import HTTP_405_METHOD_NOT_ALLOWED
@@ -22,6 +21,7 @@
 from openedx.core.djangoapps.content_libraries.views import convert_exceptions
 from openedx.core.djangoapps.content_libraries.serializers import (
     ContentLibraryCollectionSerializer,
+    ContentLibraryCollectionComponentsUpdateSerializer,
     ContentLibraryCollectionCreateOrUpdateSerializer,
 )
 
@@ -36,16 +36,21 @@ class LibraryCollectionsView(ModelViewSet):
 
     serializer_class = ContentLibraryCollectionSerializer
 
-    def _verify_and_fetch_library_collection(self, library_key, collection_id, user, permission) -> Collection | None:
+    def _verify_and_fetch_library_collection(self, lib_key_str, collection_id, user, permission) -> Collection | None:
         """
-        Verify that the collection belongs to the library and the user has the correct permissions
+        Verify that the collection belongs to the library and the user has the correct permissions.
+
+        This method may raise exceptions; these are handled by the @convert_exceptions wrapper on the views.
         """
+        library_key = LibraryLocatorV2.from_string(lib_key_str)
         library_obj = api.require_permission_for_library_key(library_key, user, permission)
         collection = None
         if library_obj.learning_package_id:
-            collection = authoring_api.get_learning_package_collections(
+            collection = authoring_api.get_collections(
                 library_obj.learning_package_id
             ).filter(id=collection_id).first()
+        if not collection:
+            raise api.ContentLibraryCollectionNotFound
         return collection
 
     @convert_exceptions
@@ -53,22 +58,15 @@ def retrieve(self, request, *args, **kwargs):
         """
         Retrieve the Content Library Collection
         """
-        lib_key_str = kwargs.pop('lib_key_str', None)
-        if not lib_key_str:
-            raise Http404
-
-        pk = kwargs.pop("pk", None)
-        library_key = LibraryLocatorV2.from_string(lib_key_str)
+        lib_key_str = kwargs.pop("lib_key_str")
+        pk = kwargs.pop("pk")
 
         # Check if user has permissions to view this collection by checking if
         # user has permission to view the Content Library it belongs to
         collection = self._verify_and_fetch_library_collection(
-            library_key, pk, request.user, permissions.CAN_VIEW_THIS_CONTENT_LIBRARY
+            lib_key_str, pk, request.user, permissions.CAN_VIEW_THIS_CONTENT_LIBRARY
         )
 
-        if not collection:
-            raise Http404
-
         serializer = self.get_serializer(collection)
         return Response(serializer.data)
 
@@ -77,18 +75,16 @@ def list(self, request, *args, **kwargs):
         """
         List Collections that belong to Content Library
         """
-        lib_key_str = kwargs.pop('lib_key_str', None)
-        if not lib_key_str:
-            raise Http404
+        lib_key_str = kwargs.pop("lib_key_str")
+        library_key = LibraryLocatorV2.from_string(lib_key_str)
 
         # Check if user has permissions to view collections by checking if user
         # has permission to view the Content Library they belong to
-        library_key = LibraryLocatorV2.from_string(lib_key_str)
         content_library = api.require_permission_for_library_key(
             library_key, request.user, permissions.CAN_VIEW_THIS_CONTENT_LIBRARY
         )
 
-        collections = authoring_api.get_learning_package_collections(content_library.learning_package.id)
+        collections = authoring_api.get_collections(content_library.learning_package.id)
         serializer = self.get_serializer(collections, many=True)
         return Response(serializer.data)
 
@@ -97,13 +93,11 @@ def create(self, request, *args, **kwargs):
         """
         Create a Collection that belongs to a Content Library
         """
-        lib_key_str = kwargs.pop('lib_key_str', None)
-        if not lib_key_str:
-            raise Http404
+        lib_key_str = kwargs.pop("lib_key_str")
+        library_key = LibraryLocatorV2.from_string(lib_key_str)
 
         # Check if user has permissions to create a collection in the Content Library
         # by checking if user has permission to edit the Content Library
-        library_key = LibraryLocatorV2.from_string(lib_key_str)
         content_library = api.require_permission_for_library_key(
             library_key, request.user, permissions.CAN_EDIT_THIS_CONTENT_LIBRARY
         )
@@ -133,21 +127,16 @@ def partial_update(self, request, *args, **kwargs):
         """
         Update a Collection that belongs to a Content Library
         """
-        lib_key_str = kwargs.pop('lib_key_str', None)
-        if not lib_key_str:
-            raise Http404
-
-        pk = kwargs.pop('pk', None)
+        lib_key_str = kwargs.pop('lib_key_str')
         library_key = LibraryLocatorV2.from_string(lib_key_str)
+        pk = kwargs.pop('pk')
+
         # Check if user has permissions to update a collection in the Content Library
         # by checking if user has permission to edit the Content Library
         collection = self._verify_and_fetch_library_collection(
-            library_key, pk, request.user, permissions.CAN_EDIT_THIS_CONTENT_LIBRARY
+            lib_key_str, pk, request.user, permissions.CAN_EDIT_THIS_CONTENT_LIBRARY
         )
 
-        if not collection:
-            raise Http404
-
         update_serializer = ContentLibraryCollectionCreateOrUpdateSerializer(
             collection, data=request.data, partial=True
         )
@@ -175,3 +164,28 @@ def destroy(self, request, *args, **kwargs):
         # TODO: Implement the deletion logic and emit event signal
 
         return Response(None, status=HTTP_405_METHOD_NOT_ALLOWED)
+
+    @convert_exceptions
+    @action(detail=True, methods=['delete', 'patch'], url_path='components', url_name='components-update')
+    def update_components(self, request, lib_key_str, pk):
+        """
+        Adds (PATCH) or removes (DELETE) Components to/from a Collection.
+
+        Collection and Components must all be part of the given library/learning package.
+        """
+        collection = self._verify_and_fetch_library_collection(
+            lib_key_str, pk, request.user, permissions.CAN_EDIT_THIS_CONTENT_LIBRARY
+        )
+
+        serializer = ContentLibraryCollectionComponentsUpdateSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+
+        usage_keys = serializer.validated_data["usage_keys"]
+        api.update_collection_components(
+            collection,
+            usage_keys=usage_keys,
+            created_by=self.request.user.id,
+            remove=(request.method == "DELETE"),
+        )
+
+        return Response({'count': len(usage_keys)})
diff --git a/requirements/constraints.txt b/requirements/constraints.txt
index 4a2f87e652b8..224344d12a36 100644
--- a/requirements/constraints.txt
+++ b/requirements/constraints.txt
@@ -93,7 +93,7 @@ libsass==0.10.0
 click==8.1.6
 
 # pinning this version to avoid updates while the library is being developed
-openedx-learning==0.11.2
+openedx-learning==0.11.3
 
 # Open AI version 1.0.0 dropped support for openai.ChatCompletion which is currently in use in enterprise.
 openai<=0.28.1
diff --git a/requirements/edx/base.txt b/requirements/edx/base.txt
index ad5659628dee..9638248a1b04 100644
--- a/requirements/edx/base.txt
+++ b/requirements/edx/base.txt
@@ -823,7 +823,7 @@ openedx-filters==1.9.0
     #   -r requirements/edx/kernel.in
     #   lti-consumer-xblock
     #   ora2
-openedx-learning==0.11.2
+openedx-learning==0.11.3
     # via
     #   -c requirements/edx/../constraints.txt
     #   -r requirements/edx/kernel.in
diff --git a/requirements/edx/development.txt b/requirements/edx/development.txt
index 88fad695c43f..d0f3c226c1c3 100644
--- a/requirements/edx/development.txt
+++ b/requirements/edx/development.txt
@@ -1372,7 +1372,7 @@ openedx-filters==1.9.0
     #   -r requirements/edx/testing.txt
     #   lti-consumer-xblock
     #   ora2
-openedx-learning==0.11.2
+openedx-learning==0.11.3
     # via
     #   -c requirements/edx/../constraints.txt
     #   -r requirements/edx/doc.txt
diff --git a/requirements/edx/doc.txt b/requirements/edx/doc.txt
index b6e3bcbeab50..81e8d6839437 100644
--- a/requirements/edx/doc.txt
+++ b/requirements/edx/doc.txt
@@ -982,7 +982,7 @@ openedx-filters==1.9.0
     #   -r requirements/edx/base.txt
     #   lti-consumer-xblock
     #   ora2
-openedx-learning==0.11.2
+openedx-learning==0.11.3
     # via
     #   -c requirements/edx/../constraints.txt
     #   -r requirements/edx/base.txt
diff --git a/requirements/edx/testing.txt b/requirements/edx/testing.txt
index 30200d52ea41..dc021dbd37e4 100644
--- a/requirements/edx/testing.txt
+++ b/requirements/edx/testing.txt
@@ -1033,7 +1033,7 @@ openedx-filters==1.9.0
     #   -r requirements/edx/base.txt
     #   lti-consumer-xblock
     #   ora2
-openedx-learning==0.11.2
+openedx-learning==0.11.3
     # via
     #   -c requirements/edx/../constraints.txt
     #   -r requirements/edx/base.txt