diff --git a/tests/unit/encoders/test_clip.py b/tests/unit/encoders/test_clip.py
index de997e36deb3c22349fb2f8eeba58878b112fe26..1cfc7d4313a1a17302dff195ac71e137e3ae4581 100644
--- a/tests/unit/encoders/test_clip.py
+++ b/tests/unit/encoders/test_clip.py
@@ -1,12 +1,13 @@
+import os
 import numpy as np
 import pytest
 import torch
 from PIL import Image
+from unittest.mock import patch
 
 from semantic_router.encoders import CLIPEncoder
 
 test_model_name = "aurelio-ai/sr-test-clip"
-clip_encoder = CLIPEncoder(name=test_model_name)
 embed_dim = 64
 
 if torch.cuda.is_available():
@@ -32,46 +33,80 @@ def misshaped_pil_image():
     return Image.fromarray(np.random.rand(64, 64, 3).astype(np.uint8))
 
 
-class TestVitEncoder:
-    def test_clip_encoder__import_errors_transformers(self, mocker):
-        mocker.patch.dict("sys.modules", {"transformers": None})
-        with pytest.raises(ImportError):
-            CLIPEncoder()
+class TestClipEncoder:
+    @pytest.mark.skipif(
+        os.environ.get("RUN_HF_TESTS") is None, reason="Set RUN_HF_TESTS=1 to run"
+    )
+    def test_clip_encoder__import_errors_transformers(self):
+        with patch.dict("sys.modules", {"transformers": None}):
+            with pytest.raises(ImportError) as error:
+                CLIPEncoder()
 
-    def test_clip_encoder__import_errors_torch(self, mocker):
-        mocker.patch.dict("sys.modules", {"torch": None})
-        with pytest.raises(ImportError):
-            CLIPEncoder()
+        assert "install transformers" in str(error.value)
 
+    @pytest.mark.skipif(
+        os.environ.get("RUN_HF_TESTS") is None, reason="Set RUN_HF_TESTS=1 to run"
+    )
+    def test_clip_encoder__import_errors_torch(self):
+        with patch.dict("sys.modules", {"torch": None}):
+            with pytest.raises(ImportError) as error:
+                CLIPEncoder()
+
+        assert "install Pytorch" in str(error.value)
+
+    @pytest.mark.skipif(
+        os.environ.get("RUN_HF_TESTS") is None, reason="Set RUN_HF_TESTS=1 to run"
+    )
     def test_clip_encoder_initialization(self):
+        clip_encoder = CLIPEncoder(name=test_model_name)
         assert clip_encoder.name == test_model_name
         assert clip_encoder.type == "huggingface"
         assert clip_encoder.score_threshold == 0.2
         assert clip_encoder.device == device
 
+    @pytest.mark.skipif(
+        os.environ.get("RUN_HF_TESTS") is None, reason="Set RUN_HF_TESTS=1 to run"
+    )
     def test_clip_encoder_call_text(self):
+        clip_encoder = CLIPEncoder(name=test_model_name)
         embeddings = clip_encoder(["hello", "world"])
 
         assert len(embeddings) == 2
         assert len(embeddings[0]) == embed_dim
 
+    @pytest.mark.skipif(
+        os.environ.get("RUN_HF_TESTS") is None, reason="Set RUN_HF_TESTS=1 to run"
+    )
     def test_clip_encoder_call_image(self, dummy_pil_image):
+        clip_encoder = CLIPEncoder(name=test_model_name)
         encoded_images = clip_encoder([dummy_pil_image] * 3)
 
         assert len(encoded_images) == 3
         assert set(map(len, encoded_images)) == {embed_dim}
 
+    @pytest.mark.skipif(
+        os.environ.get("RUN_HF_TESTS") is None, reason="Set RUN_HF_TESTS=1 to run"
+    )
     def test_clip_encoder_call_misshaped(self, dummy_pil_image, misshaped_pil_image):
+        clip_encoder = CLIPEncoder(name=test_model_name)
         encoded_images = clip_encoder([dummy_pil_image, misshaped_pil_image])
 
         assert len(encoded_images) == 2
         assert set(map(len, encoded_images)) == {embed_dim}
 
+    @pytest.mark.skipif(
+        os.environ.get("RUN_HF_TESTS") is None, reason="Set RUN_HF_TESTS=1 to run"
+    )
     def test_clip_device(self):
+        clip_encoder = CLIPEncoder(name=test_model_name)
         device = clip_encoder._model.device.type
         assert device == device
 
+    @pytest.mark.skipif(
+        os.environ.get("RUN_HF_TESTS") is None, reason="Set RUN_HF_TESTS=1 to run"
+    )
     def test_clip_encoder_ensure_rgb(self, dummy_black_and_white_img):
+        clip_encoder = CLIPEncoder(name=test_model_name)
         rgb_image = clip_encoder._ensure_rgb(dummy_black_and_white_img)
 
         assert rgb_image.mode == "RGB"
diff --git a/tests/unit/encoders/test_huggingface.py b/tests/unit/encoders/test_huggingface.py
index f14c7a685a497c4fbb7a6afca4c2f8f85c355007..b615a87d13d64d0a45f6542f137d31ef9fc9a05f 100644
--- a/tests/unit/encoders/test_huggingface.py
+++ b/tests/unit/encoders/test_huggingface.py
@@ -1,12 +1,12 @@
 from unittest.mock import patch
 
+import os
 import numpy as np
 import pytest
 
 from semantic_router.encoders.huggingface import HuggingFaceEncoder
 
 test_model_name = "aurelio-ai/sr-test-huggingface"
-encoder = HuggingFaceEncoder(name=test_model_name)
 
 
 class TestHuggingFaceEncoder:
@@ -26,7 +26,11 @@ class TestHuggingFaceEncoder:
 
         assert "Please install Pytorch to use HuggingFaceEncoder" in str(error.value)
 
+    @pytest.mark.skipif(
+        os.environ.get("RUN_HF_TESTS") is None, reason="Set RUN_HF_TESTS=1 to run"
+    )
     def test_huggingface_encoder_mean_pooling(self):
+        encoder = HuggingFaceEncoder(name=test_model_name)
         test_docs = ["This is a test", "This is another test"]
         embeddings = encoder(test_docs, pooling_strategy="mean")
         assert isinstance(embeddings, list)
@@ -34,7 +38,11 @@ class TestHuggingFaceEncoder:
         assert all(isinstance(embedding, list) for embedding in embeddings)
         assert all(len(embedding) > 0 for embedding in embeddings)
 
+    @pytest.mark.skipif(
+        os.environ.get("RUN_HF_TESTS") is None, reason="Set RUN_HF_TESTS=1 to run"
+    )
     def test_huggingface_encoder_max_pooling(self):
+        encoder = HuggingFaceEncoder(name=test_model_name)
         test_docs = ["This is a test", "This is another test"]
         embeddings = encoder(test_docs, pooling_strategy="max")
         assert isinstance(embeddings, list)
@@ -42,7 +50,11 @@ class TestHuggingFaceEncoder:
         assert all(isinstance(embedding, list) for embedding in embeddings)
         assert all(len(embedding) > 0 for embedding in embeddings)
 
+    @pytest.mark.skipif(
+        os.environ.get("RUN_HF_TESTS") is None, reason="Set RUN_HF_TESTS=1 to run"
+    )
     def test_huggingface_encoder_normalized_embeddings(self):
+        encoder = HuggingFaceEncoder(name=test_model_name)
         docs = ["This is a test document.", "Another test document."]
         unnormalized_embeddings = encoder(docs, normalize_embeddings=False)
         normalized_embeddings = encoder(docs, normalize_embeddings=True)
diff --git a/tests/unit/test_layer.py b/tests/unit/test_layer.py
index 3490baa41bc698380bc23bd857621ba4db9479de..bc7be980b21c9dcc9308d3264fbe4584cd2429ff 100644
--- a/tests/unit/test_layer.py
+++ b/tests/unit/test_layer.py
@@ -276,6 +276,9 @@ class TestRouteLayer:
 
         assert query_result in ["Route 1"]
 
+    @pytest.mark.skipif(
+        os.environ.get("PINECONE_API_KEY") is None, reason="Pinecone API key required"
+    )
     def test_query_filter_pinecone(self, openai_encoder, routes, index_cls):
         pinecone_api_key = os.environ["PINECONE_API_KEY"]
         pineconeindex = PineconeIndex(api_key=pinecone_api_key)
@@ -292,6 +295,9 @@ class TestRouteLayer:
 
         assert query_result in ["Route 1"]
 
+    @pytest.mark.skipif(
+        os.environ.get("PINECONE_API_KEY") is None, reason="Pinecone API key required"
+    )
     def test_namespace_pinecone_index(self, openai_encoder, routes, index_cls):
         pinecone_api_key = os.environ["PINECONE_API_KEY"]
         pineconeindex = PineconeIndex(api_key=pinecone_api_key, namespace="test")