The agent engineering platform.
Python agentsaiai-agentsanthropicchatgptdeepagentsenterpriseframeworkgeminigenerative-ailangchainlanggraphllmmultiagentopen-sourceopenaipydanticpythonragtypescript
feat(perplexity): add `PerplexityEmbeddings` (#37082)
James Liounis28f5448dd467
diff --git a/libs/partners/perplexity/Makefile b/libs/partners/perplexity/Makefileindex ca7b025aac..f0dcbbc9ca 100644--- a/libs/partners/perplexity/Makefile+++ b/libs/partners/perplexity/Makefile@@ -19,7 +19,8 @@ test_watch:uv run --group test ptw --snapshot-update --now . -- -vv $(TEST_FILE)integration_test integration_tests:- uv run --group test --group test_integration pytest -v --tb=short -n auto $(TEST_FILE)+ uv run --group test --group test_integration pytest -v --tb=short -n 4 \+ --retries 3 --retry-delay 5 $(TEST_FILE)####################### LINTING AND FORMATTINGdiff --git a/libs/partners/perplexity/langchain_perplexity/__init__.py b/libs/partners/perplexity/langchain_perplexity/__init__.pyindex 5db46f6bc4..22447cfde4 100644--- a/libs/partners/perplexity/langchain_perplexity/__init__.py+++ b/libs/partners/perplexity/langchain_perplexity/__init__.py@@ -1,6 +1,7 @@"""Perplexity AI integration for LangChain."""from langchain_perplexity.chat_models import ChatPerplexity+from langchain_perplexity.embeddings import PerplexityEmbeddingsfrom langchain_perplexity.output_parsers import (ReasoningJsonOutputParser,ReasoningStructuredOutputParser,@@ -17,6 +18,7 @@ from langchain_perplexity.types import (__all__ = ["ChatPerplexity",+ "PerplexityEmbeddings","PerplexitySearchRetriever","PerplexitySearchResults","UserLocation",diff --git a/libs/partners/perplexity/langchain_perplexity/chat_models.py b/libs/partners/perplexity/langchain_perplexity/chat_models.pyindex 99e27ede01..ef9970b359 100644--- a/libs/partners/perplexity/langchain_perplexity/chat_models.py+++ b/libs/partners/perplexity/langchain_perplexity/chat_models.py@@ -297,11 +297,18 @@ class ChatPerplexity(BaseChatModel):self.pplx_api_key.get_secret_value() if self.pplx_api_key else None)+ client_params: dict[str, Any] = {+ "api_key": pplx_api_key,+ "max_retries": self.max_retries,+ }+ if self.request_timeout is not None:+ client_params["timeout"] = self.request_timeout+if not self.client:- self.client = Perplexity(api_key=pplx_api_key)+ self.client = Perplexity(**client_params)if not self.async_client:- self.async_client = AsyncPerplexity(api_key=pplx_api_key)+ self.async_client = AsyncPerplexity(**client_params)return self@@ -445,9 +452,30 @@ class ChatPerplexity(BaseChatModel):prev_total_usage = lc_total_usageelse:usage_metadata = None- if len(chunk["choices"]) == 0:+ generation_info = {}+ if (model_name := chunk.get("model")) and not added_model_name:+ generation_info["model_name"] = model_name+ added_model_name = True+ if total_usage := chunk.get("usage"):+ if num_search_queries := total_usage.get("num_search_queries"):+ if not added_search_queries:+ generation_info["num_search_queries"] = num_search_queries+ added_search_queries = True+ if not added_search_context_size:+ if search_context_size := total_usage.get("search_context_size"):+ generation_info["search_context_size"] = search_context_size+ added_search_context_size = True++ choices = chunk.get("choices") or []+ if len(choices) == 0:+ # Usage-only or otherwise empty chunk: still yield so the stream+ # is never empty and downstream callers receive usage metadata.+ message = AIMessageChunk(content="", usage_metadata=usage_metadata)+ yield ChatGenerationChunk(+ message=message, generation_info=generation_info or None+ )continue- choice = chunk["choices"][0]+ choice = choices[0]additional_kwargs = {}if first_chunk:@@ -462,21 +490,6 @@ class ChatPerplexity(BaseChatModel):if chunk.get("reasoning_steps"):additional_kwargs["reasoning_steps"] = chunk["reasoning_steps"]- generation_info = {}- if (model_name := chunk.get("model")) and not added_model_name:- generation_info["model_name"] = model_name- added_model_name = True- # Add num_search_queries to generation_info if present- if total_usage := chunk.get("usage"):- if num_search_queries := total_usage.get("num_search_queries"):- if not added_search_queries:- generation_info["num_search_queries"] = num_search_queries- added_search_queries = True- if not added_search_context_size:- if search_context_size := total_usage.get("search_context_size"):- generation_info["search_context_size"] = search_context_size- added_search_context_size = True-chunk = self._convert_delta_to_message_chunk(choice["delta"], default_chunk_class)@@ -532,9 +545,28 @@ class ChatPerplexity(BaseChatModel):prev_total_usage = lc_total_usageelse:usage_metadata = None- if len(chunk["choices"]) == 0:+ generation_info = {}+ if (model_name := chunk.get("model")) and not added_model_name:+ generation_info["model_name"] = model_name+ added_model_name = True+ if total_usage := chunk.get("usage"):+ if num_search_queries := total_usage.get("num_search_queries"):+ if not added_search_queries:+ generation_info["num_search_queries"] = num_search_queries+ added_search_queries = True+ if search_context_size := total_usage.get("search_context_size"):+ generation_info["search_context_size"] = search_context_size++ choices = chunk.get("choices") or []+ if len(choices) == 0:+ # Usage-only or otherwise empty chunk: still yield so the stream+ # is never empty and downstream callers receive usage metadata.+ message = AIMessageChunk(content="", usage_metadata=usage_metadata)+ yield ChatGenerationChunk(+ message=message, generation_info=generation_info or None+ )continue- choice = chunk["choices"][0]+ choice = choices[0]additional_kwargs = {}if first_chunk:@@ -549,19 +581,6 @@ class ChatPerplexity(BaseChatModel):if chunk.get("reasoning_steps"):additional_kwargs["reasoning_steps"] = chunk["reasoning_steps"]- generation_info = {}- if (model_name := chunk.get("model")) and not added_model_name:- generation_info["model_name"] = model_name- added_model_name = True-- if total_usage := chunk.get("usage"):- if num_search_queries := total_usage.get("num_search_queries"):- if not added_search_queries:- generation_info["num_search_queries"] = num_search_queries- added_search_queries = True- if search_context_size := total_usage.get("search_context_size"):- generation_info["search_context_size"] = search_context_size-chunk = self._convert_delta_to_message_chunk(choice["delta"], default_chunk_class)diff --git a/libs/partners/perplexity/langchain_perplexity/embeddings.py b/libs/partners/perplexity/langchain_perplexity/embeddings.pynew file mode 100644index 0000000000..8ee2dde7d1--- /dev/null+++ b/libs/partners/perplexity/langchain_perplexity/embeddings.py@@ -0,0 +1,184 @@+"""Wrapper around Perplexity Embeddings API."""++from __future__ import annotations++import base64+import struct+from typing import Any++from langchain_core.embeddings import Embeddings+from langchain_core.utils import secret_from_env+from perplexity import AsyncPerplexity, Perplexity+from pydantic import BaseModel, ConfigDict, Field, SecretStr, model_validator+from typing_extensions import Self+++def _decode_int8_embedding(b64: str) -> list[float]:+ """Decode a `base64_int8`-encoded Perplexity embedding into a list of floats."""+ raw = base64.b64decode(b64)+ return [float(v) for v in struct.unpack(f"<{len(raw)}b", raw)]+++class PerplexityEmbeddings(BaseModel, Embeddings):+ """`Perplexity AI` embeddings.++ Setup:+ Install the `perplexityai` package and set the `PPLX_API_KEY`+ (or `PERPLEXITY_API_KEY`) environment variable, or pass the key as+ the `pplx_api_key`/`api_key` argument.++ ```bash+ pip install -U langchain-perplexity+ export PPLX_API_KEY=your_api_key+ ```++ See the Perplexity Embeddings API reference:+ https://docs.perplexity.ai/api-reference/embeddings-post++ Instantiate:++ ```python+ from langchain_perplexity import PerplexityEmbeddings++ embeddings = PerplexityEmbeddings()+ ```++ Embed a single query:++ ```python+ query_vector = embeddings.embed_query("hello world")+ ```++ Embed documents:++ ```python+ doc_vectors = embeddings.embed_documents(["hello", "world"])+ ```++ Select a specific model:++ ```python+ embeddings = PerplexityEmbeddings(model="pplx-embed-v1-0.6b")+ ```++ !!! note+ Perplexity returns base64-encoded signed int8 embeddings. This class+ decodes them into `list[float]` values in the range [-128, 127]. The+ magnitude is preserved from the API's quantized output; cosine+ similarity is unaffected by the lack of unit-length normalization.+ """++ client: Any = Field(default=None, exclude=True)+ """Perplexity SDK client (set automatically)."""++ async_client: Any = Field(default=None, exclude=True)+ """Async Perplexity SDK client (set automatically)."""++ model: str = "pplx-embed-v1-4b"+ """Name of the Perplexity embedding model to use.++ See the API reference for available identifiers, including+ `pplx-embed-v1-0.6b` and `pplx-embed-v1-4b`. Contextualized variants are+ served through a separate endpoint and are not exposed by this class.+ """++ pplx_api_key: SecretStr | None = Field(+ default_factory=secret_from_env(+ ["PPLX_API_KEY", "PERPLEXITY_API_KEY"], default=None+ ),+ alias="api_key",+ )+ """Perplexity API key. Reads from `PPLX_API_KEY` or `PERPLEXITY_API_KEY`."""++ request_timeout: float | tuple[float, float] | None = Field(None, alias="timeout")+ """Timeout for requests to the Perplexity embeddings API."""++ max_retries: int = 6+ """Maximum number of retries to make when calling the embeddings API."""++ model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True)++ @property+ def lc_secrets(self) -> dict[str, str]:+ """Map secret field names to their environment variable names."""+ return {"pplx_api_key": "PPLX_API_KEY"}++ @model_validator(mode="after")+ def validate_environment(self) -> Self:+ """Initialize the Perplexity SDK clients."""+ if not self.pplx_api_key:+ msg = (+ "Perplexity API key not provided. Pass `pplx_api_key` (or "+ "`api_key`) to PerplexityEmbeddings, or set the `PPLX_API_KEY` "+ "or `PERPLEXITY_API_KEY` environment variable."+ )+ raise ValueError(msg)++ api_key = self.pplx_api_key.get_secret_value()+ client_params: dict[str, Any] = {+ "api_key": api_key,+ "max_retries": self.max_retries,+ }+ if self.request_timeout is not None:+ client_params["timeout"] = self.request_timeout++ if self.client is None:+ self.client = Perplexity(**client_params)+ if self.async_client is None:+ self.async_client = AsyncPerplexity(**client_params)+ return self++ def embed_documents(self, texts: list[str]) -> list[list[float]]:+ """Embed a list of documents using the Perplexity embeddings API.++ Args:+ texts: The list of texts to embed.++ Returns:+ A list of embeddings, one per input text. An empty list is returned+ when `texts` is empty.+ """+ if not texts:+ return []+ response = self.client.embeddings.create(model=self.model, input=texts)+ return [_decode_int8_embedding(item.embedding) for item in response.data]++ def embed_query(self, text: str) -> list[float]:+ """Embed a single query string using the Perplexity embeddings API.++ Args:+ text: The text to embed.++ Returns:+ The embedding vector for the input text.+ """+ return self.embed_documents([text])[0]++ async def aembed_documents(self, texts: list[str]) -> list[list[float]]:+ """Asynchronously embed a list of documents.++ Args:+ texts: The list of texts to embed.++ Returns:+ A list of embeddings, one per input text. An empty list is returned+ when `texts` is empty.+ """+ if not texts:+ return []+ response = await self.async_client.embeddings.create(+ model=self.model, input=texts+ )+ return [_decode_int8_embedding(item.embedding) for item in response.data]++ async def aembed_query(self, text: str) -> list[float]:+ """Asynchronously embed a single query string.++ Args:+ text: The text to embed.++ Returns:+ The embedding vector for the input text.+ """+ result = await self.aembed_documents([text])+ return result[0]diff --git a/libs/partners/perplexity/pyproject.toml b/libs/partners/perplexity/pyproject.tomlindex 85e0740679..9304a9e204 100644--- a/libs/partners/perplexity/pyproject.toml+++ b/libs/partners/perplexity/pyproject.toml@@ -24,7 +24,7 @@ version = "1.1.0"requires-python = ">=3.10.0,<4.0.0"dependencies = ["langchain-core>=1.3.2,<2.0.0",- "perplexityai>=0.22.0",+ "perplexityai>=0.32.0,<1.0.0",][project.urls]diff --git a/libs/partners/perplexity/tests/integration_tests/test_embeddings.py b/libs/partners/perplexity/tests/integration_tests/test_embeddings.pynew file mode 100644index 0000000000..9423f1eafe--- /dev/null+++ b/libs/partners/perplexity/tests/integration_tests/test_embeddings.py@@ -0,0 +1,56 @@+"""Integration tests for Perplexity Embeddings API."""++import os++import pytest++from langchain_perplexity import PerplexityEmbeddings+++ not (os.environ.get("PPLX_API_KEY") or os.environ.get("PERPLEXITY_API_KEY")),+ reason="PPLX_API_KEY/PERPLEXITY_API_KEY not set",+)+class TestPerplexityEmbeddings:+ def test_embed_documents(self) -> None:+ """Test embedding a list of documents."""+ embeddings = PerplexityEmbeddings()+ texts = ["hello world", "goodbye world"]+ vectors = embeddings.embed_documents(texts)++ assert len(vectors) == len(texts)+ assert all(isinstance(v, list) for v in vectors)+ assert all(len(v) > 0 for v in vectors)+ # All vectors should have the same dimensionality.+ assert len({len(v) for v in vectors}) == 1+ assert all(isinstance(x, float) for x in vectors[0])++ def test_embed_query(self) -> None:+ """Test embedding a single query."""+ embeddings = PerplexityEmbeddings()+ vector = embeddings.embed_query("What is the capital of France?")++ assert isinstance(vector, list)+ assert len(vector) > 0+ assert all(isinstance(x, float) for x in vector)++ def test_embed_query_matches_documents_dim(self) -> None:+ """Embeddings from query and documents should share dimensionality."""+ embeddings = PerplexityEmbeddings()+ query_vec = embeddings.embed_query("hello")+ doc_vecs = embeddings.embed_documents(["hello"])+ assert len(query_vec) == len(doc_vecs[0])++ async def test_aembed_documents(self) -> None:+ """Test async embedding a list of documents."""+ embeddings = PerplexityEmbeddings()+ vectors = await embeddings.aembed_documents(["hello", "world"])+ assert len(vectors) == 2+ assert all(len(v) > 0 for v in vectors)++ async def test_aembed_query(self) -> None:+ """Test async embedding a single query."""+ embeddings = PerplexityEmbeddings()+ vector = await embeddings.aembed_query("hello")+ assert isinstance(vector, list)+ assert len(vector) > 0diff --git a/libs/partners/perplexity/tests/integration_tests/test_embeddings_standard.py b/libs/partners/perplexity/tests/integration_tests/test_embeddings_standard.pynew file mode 100644index 0000000000..c243b5f4f6--- /dev/null+++ b/libs/partners/perplexity/tests/integration_tests/test_embeddings_standard.py@@ -0,0 +1,23 @@+"""Standard integration tests for `PerplexityEmbeddings`."""++import os++import pytest+from langchain_core.embeddings import Embeddings+from langchain_tests.integration_tests import EmbeddingsIntegrationTests++from langchain_perplexity import PerplexityEmbeddings+++ not (os.environ.get("PPLX_API_KEY") or os.environ.get("PERPLEXITY_API_KEY")),+ reason="PPLX_API_KEY/PERPLEXITY_API_KEY not set",+)+class TestPerplexityEmbeddingsIntegration(EmbeddingsIntegrationTests):+ @property+ def embeddings_class(self) -> type[Embeddings]:+ return PerplexityEmbeddings++ @property+ def embedding_model_params(self) -> dict:+ return {}diff --git a/libs/partners/perplexity/tests/unit_tests/test_embeddings.py b/libs/partners/perplexity/tests/unit_tests/test_embeddings.pynew file mode 100644index 0000000000..eec9725efc--- /dev/null+++ b/libs/partners/perplexity/tests/unit_tests/test_embeddings.py@@ -0,0 +1,203 @@+"""Unit tests for `PerplexityEmbeddings`."""++import base64+import struct+from unittest.mock import AsyncMock, MagicMock++import pytest+from pydantic import SecretStr++from langchain_perplexity import PerplexityEmbeddings+++def _encode_int8(values: list[int]) -> str:+ """Encode signed int8 values as base64 (matches Perplexity's wire format)."""+ raw = struct.pack(f"<{len(values)}b", *values)+ return base64.b64encode(raw).decode("ascii")+++def _make_response(int8_vectors: list[list[int]]) -> MagicMock:+ """Build a stand-in for `EmbeddingCreateResponse` with base64_int8 payloads."""+ response = MagicMock()+ response.data = []+ for values in int8_vectors:+ item = MagicMock()+ item.embedding = _encode_int8(values)+ response.data.append(item)+ return response+++def test_embeddings_initialization() -> None:+ embeddings = PerplexityEmbeddings(pplx_api_key="test")+ assert embeddings.pplx_api_key is not None+ assert embeddings.pplx_api_key.get_secret_value() == "test"+ assert embeddings.model == "pplx-embed-v1-4b"+ assert embeddings.client is not None+ assert embeddings.async_client is not None+++def test_embeddings_custom_model() -> None:+ embeddings = PerplexityEmbeddings(pplx_api_key="test", model="custom-model")+ assert embeddings.model == "custom-model"+++def test_api_key_alias() -> None:+ """`api_key=` should be accepted via populate_by_name alias."""+ embeddings = PerplexityEmbeddings(api_key="aliased")+ assert embeddings.pplx_api_key is not None+ assert embeddings.pplx_api_key.get_secret_value() == "aliased"+++def test_api_key_accepts_secret_str() -> None:+ embeddings = PerplexityEmbeddings(pplx_api_key=SecretStr("typed"))+ assert embeddings.pplx_api_key is not None+ assert embeddings.pplx_api_key.get_secret_value() == "typed"+++def test_lc_secrets() -> None:+ embeddings = PerplexityEmbeddings(pplx_api_key="test")+ assert embeddings.lc_secrets == {"pplx_api_key": "PPLX_API_KEY"}+++def test_pplx_api_key_env_fallback(monkeypatch: pytest.MonkeyPatch) -> None:+ monkeypatch.delenv("PERPLEXITY_API_KEY", raising=False)+ monkeypatch.setenv("PPLX_API_KEY", "from_pplx_env")+ embeddings = PerplexityEmbeddings()+ assert embeddings.pplx_api_key is not None+ assert embeddings.pplx_api_key.get_secret_value() == "from_pplx_env"+++def test_perplexity_api_key_env_fallback(monkeypatch: pytest.MonkeyPatch) -> None:+ monkeypatch.delenv("PPLX_API_KEY", raising=False)+ monkeypatch.setenv("PERPLEXITY_API_KEY", "from_perp_env")+ embeddings = PerplexityEmbeddings()+ assert embeddings.pplx_api_key is not None+ assert embeddings.pplx_api_key.get_secret_value() == "from_perp_env"+++def test_pplx_takes_precedence_over_perplexity(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ monkeypatch.setenv("PPLX_API_KEY", "primary")+ monkeypatch.setenv("PERPLEXITY_API_KEY", "secondary")+ embeddings = PerplexityEmbeddings()+ assert embeddings.pplx_api_key is not None+ assert embeddings.pplx_api_key.get_secret_value() == "primary"+++def test_explicit_kwarg_overrides_env(monkeypatch: pytest.MonkeyPatch) -> None:+ monkeypatch.setenv("PPLX_API_KEY", "from_env")+ embeddings = PerplexityEmbeddings(pplx_api_key="explicit")+ assert embeddings.pplx_api_key is not None+ assert embeddings.pplx_api_key.get_secret_value() == "explicit"+++def test_missing_api_key_raises(monkeypatch: pytest.MonkeyPatch) -> None:+ monkeypatch.delenv("PPLX_API_KEY", raising=False)+ monkeypatch.delenv("PERPLEXITY_API_KEY", raising=False)+ with pytest.raises(ValueError, match="Perplexity API key not provided"):+ PerplexityEmbeddings()+++def test_embed_documents() -> None:+ mock_client = MagicMock()+ mock_client.embeddings.create.return_value = _make_response(+ [[1, -2, 3], [4, 5, -6]]+ )+ embeddings = PerplexityEmbeddings(pplx_api_key="test", client=mock_client)++ result = embeddings.embed_documents(["hello", "world"])++ assert result == [[1.0, -2.0, 3.0], [4.0, 5.0, -6.0]]+ mock_client.embeddings.create.assert_called_once_with(+ model="pplx-embed-v1-4b", input=["hello", "world"]+ )+++def test_embed_documents_empty_short_circuits() -> None:+ mock_client = MagicMock()+ embeddings = PerplexityEmbeddings(pplx_api_key="test", client=mock_client)++ assert embeddings.embed_documents([]) == []+ mock_client.embeddings.create.assert_not_called()+++def test_embed_documents_propagates_errors() -> None:+ mock_client = MagicMock()+ mock_client.embeddings.create.side_effect = RuntimeError("boom")+ embeddings = PerplexityEmbeddings(pplx_api_key="test", client=mock_client)++ with pytest.raises(RuntimeError, match="boom"):+ embeddings.embed_documents(["x"])+++def test_embed_query() -> None:+ mock_client = MagicMock()+ mock_client.embeddings.create.return_value = _make_response([[7, 8, 9]])+ embeddings = PerplexityEmbeddings(pplx_api_key="test", client=mock_client)++ result = embeddings.embed_query("hello")++ assert result == [7.0, 8.0, 9.0]+ mock_client.embeddings.create.assert_called_once_with(+ model="pplx-embed-v1-4b", input=["hello"]+ )+++def test_embed_documents_uses_custom_model() -> None:+ mock_client = MagicMock()+ mock_client.embeddings.create.return_value = _make_response([[0]])+ embeddings = PerplexityEmbeddings(+ pplx_api_key="test", model="custom-model", client=mock_client+ )++ embeddings.embed_documents(["x"])++ mock_client.embeddings.create.assert_called_once_with(+ model="custom-model", input=["x"]+ )+++async def test_aembed_documents() -> None:+ mock_async_client = MagicMock()+ mock_async_client.embeddings.create = AsyncMock(+ return_value=_make_response([[1, 2], [3, 4]])+ )+ embeddings = PerplexityEmbeddings(+ pplx_api_key="test", async_client=mock_async_client+ )++ result = await embeddings.aembed_documents(["a", "b"])++ assert result == [[1.0, 2.0], [3.0, 4.0]]+ mock_async_client.embeddings.create.assert_awaited_once_with(+ model="pplx-embed-v1-4b", input=["a", "b"]+ )+++async def test_aembed_documents_empty_short_circuits() -> None:+ mock_async_client = MagicMock()+ mock_async_client.embeddings.create = AsyncMock()+ embeddings = PerplexityEmbeddings(+ pplx_api_key="test", async_client=mock_async_client+ )++ assert await embeddings.aembed_documents([]) == []+ mock_async_client.embeddings.create.assert_not_awaited()+++async def test_aembed_query() -> None:+ mock_async_client = MagicMock()+ mock_async_client.embeddings.create = AsyncMock(+ return_value=_make_response([[5, 6]])+ )+ embeddings = PerplexityEmbeddings(+ pplx_api_key="test", async_client=mock_async_client+ )++ result = await embeddings.aembed_query("hi")++ assert result == [5.0, 6.0]+ mock_async_client.embeddings.create.assert_awaited_once_with(+ model="pplx-embed-v1-4b", input=["hi"]+ )diff --git a/libs/partners/perplexity/tests/unit_tests/test_embeddings_standard.py b/libs/partners/perplexity/tests/unit_tests/test_embeddings_standard.pynew file mode 100644index 0000000000..ba66e95406--- /dev/null+++ b/libs/partners/perplexity/tests/unit_tests/test_embeddings_standard.py@@ -0,0 +1,20 @@+"""Standard unit tests for `PerplexityEmbeddings`."""++from langchain_core.embeddings import Embeddings+from langchain_tests.unit_tests import EmbeddingsUnitTests++from langchain_perplexity import PerplexityEmbeddings+++class TestPerplexityEmbeddingsStandard(EmbeddingsUnitTests):+ @property+ def embeddings_class(self) -> type[Embeddings]:+ return PerplexityEmbeddings++ @property+ def embedding_model_params(self) -> dict:+ return {"pplx_api_key": "test"}++ @property+ def init_from_env_params(self) -> tuple[dict, dict, dict]:+ return ({"PPLX_API_KEY": "api_key"}, {}, {"pplx_api_key": "api_key"})diff --git a/libs/partners/perplexity/tests/unit_tests/test_imports.py b/libs/partners/perplexity/tests/unit_tests/test_imports.pyindex 67793501c2..57168f50e4 100644--- a/libs/partners/perplexity/tests/unit_tests/test_imports.py+++ b/libs/partners/perplexity/tests/unit_tests/test_imports.py@@ -2,6 +2,7 @@ from langchain_perplexity import __all__EXPECTED_ALL = ["ChatPerplexity",+ "PerplexityEmbeddings","PerplexitySearchRetriever","PerplexitySearchResults","UserLocation",diff --git a/libs/partners/perplexity/uv.lock b/libs/partners/perplexity/uv.lockindex 2b7a96185d..351d13dd8d 100644--- a/libs/partners/perplexity/uv.lock+++ b/libs/partners/perplexity/uv.lock@@ -537,7 +537,7 @@ typing = [[package.metadata]requires-dist = [{ name = "langchain-core", editable = "../../core" },- { name = "perplexityai", specifier = ">=0.22.0" },+ { name = "perplexityai", specifier = ">=0.32.0,<1.0.0" },][package.metadata.requires-dev]@@ -581,7 +581,7 @@ wheels = [[[package]]name = "langchain-tests"-version = "1.1.6"+version = "1.1.7"source = { editable = "../../standard-tests" }dependencies = [{ name = "httpx" },@@ -973,7 +973,7 @@ wheels = [[[package]]name = "perplexityai"-version = "0.22.2"+version = "0.32.1"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "anyio" },@@ -983,9 +983,9 @@ dependencies = [{ name = "sniffio" },{ name = "typing-extensions" },]-sdist = { url = "https://files.pythonhosted.org/packages/47/f0/4ead48afbe4c9d7b57e9d03e253bed2986ac20d2257ed918cac276949018/perplexityai-0.22.2.tar.gz", hash = "sha256:9c3cad307c95aa5e8967358547e548d58793d350318d8d1d4aa33a933cbed844", size = 113014, upload-time = "2025-12-17T19:05:25.572Z" }+sdist = { url = "https://files.pythonhosted.org/packages/09/02/73f460c85a5ec533a97fd1ff34fa729a009b4a217a4a87d8da946b6e1c52/perplexityai-0.32.1.tar.gz", hash = "sha256:b03503498591d06c4d50b666f7f7469875d3586f664c29416aae9012ae7a64d1", size = 135741, upload-time = "2026-04-21T04:35:40.345Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/cb/aa/fc3337fdb014b1584297fc212552e6365d22a6fb77850a56c9038cd47173/perplexityai-0.22.2-py3-none-any.whl", hash = "sha256:92d3dc7f4e110c879ac5009daf7263a04f413523f7d76fba871176516c253890", size = 96860, upload-time = "2025-12-17T19:05:24.292Z" },+ { url = "https://files.pythonhosted.org/packages/d6/11/5c164f114311bc2e2350202393e7c5bd25bb156b5230a1edf5a2b2f4ba04/perplexityai-0.32.1-py3-none-any.whl", hash = "sha256:e5017d245fd8966cf79657edc03a93078d867708542b491b38152618f91e369b", size = 130223, upload-time = "2026-04-21T04:35:38.786Z" },][[package]]