langchain-postgres 0.0.17__tar.gz → 0.0.18__tar.gz

{langchain_postgres-0.0.17 → langchain_postgres-0.0.18}/.github/workflows/_lint.yml

@@ -12,6 +12,9 @@ on:
         type: string
         description: "Python version to use"
 
+permissions:
+  contents: read
+
 env:
   WORKDIR: ${{ inputs.working-directory == '' && '.' || inputs.working-directory }}
 

{langchain_postgres-0.0.17 → langchain_postgres-0.0.18}/.github/workflows/_release.yml

@@ -22,6 +22,9 @@ on:
         default: false
         description: "Release from a non-main branch (danger!)"
 
+permissions:
+  contents: read
+
 env:
   PYTHON_VERSION: "3.11"
   UV_FROZEN: "true"

{langchain_postgres-0.0.17 → langchain_postgres-0.0.18}/.github/workflows/_test.yml

@@ -8,6 +8,9 @@ on:
         type: string
         description: "From which folder this pipeline executes"
 
+permissions:
+  contents: read
+
 env:
   UV_FROZEN: "true"
   UV_NO_SYNC: "true"

{langchain_postgres-0.0.17 → langchain_postgres-0.0.18}/.github/workflows/ci.yml

@@ -13,6 +13,9 @@ on:
 # There's no point in testing an outdated version of the code. GitHub only allows
 # a limited number of job runners to be active at the same time, so it's better to cancel
 # pointless jobs early so that more useful jobs can run sooner.
+permissions:
+  contents: read
+
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true

{langchain_postgres-0.0.17 → langchain_postgres-0.0.18}/PKG-INFO

@@ -1,12 +1,12 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: langchain-postgres
-Version: 0.0.17
+Version: 0.0.18
 Summary: An integration package connecting Postgres and LangChain
 License-Expression: MIT
 License-File: LICENSE
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Requires-Dist: asyncpg>=0.30.0
-Requires-Dist: langchain-core<2.0,>=0.2.13
+Requires-Dist: langchain-core<2.0,>=1.2.11
 Requires-Dist: numpy<3,>=1.21
 Requires-Dist: pgvector<0.4,>=0.2.5
 Requires-Dist: psycopg-pool<4,>=3.2.1
@@ -51,6 +51,9 @@ pip install -U langchain-postgres
 * [Quickstart](https://github.com/langchain-ai/langchain-postgres/blob/main/examples/pg_vectorstore.ipynb)
 * [How-to](https://github.com/langchain-ai/langchain-postgres/blob/main/examples/pg_vectorstore_how_to.ipynb)
 
+> [!TIP]
+> For developing, debugging, and deploying AI agents and LLM applications, see [LangSmith](https://docs.langchain.com/langsmith/home).
+
 ### Example
 
 ```python

{langchain_postgres-0.0.17 → langchain_postgres-0.0.18}/README.md

@@ -35,6 +35,9 @@ pip install -U langchain-postgres
 * [Quickstart](https://github.com/langchain-ai/langchain-postgres/blob/main/examples/pg_vectorstore.ipynb)
 * [How-to](https://github.com/langchain-ai/langchain-postgres/blob/main/examples/pg_vectorstore_how_to.ipynb)
 
+> [!TIP]
+> For developing, debugging, and deploying AI agents and LLM applications, see [LangSmith](https://docs.langchain.com/langsmith/home).
+
 ### Example
 
 ```python

{langchain_postgres-0.0.17 → langchain_postgres-0.0.18}/langchain_postgres/v2/async_vectorstore.py

@@ -291,6 +291,10 @@ class AsyncPGVectorStore(VectorStore):
             metadatas = [{} for _ in texts]
 
         # Check for inline embedding capability
+        inline_template_func = getattr(
+            self.embedding_service, "embed_query_inline_template", None
+        )
+        can_inline_embed_template = callable(inline_template_func)
         inline_embed_func = getattr(self.embedding_service, "embed_query_inline", None)
         can_inline_embed = callable(inline_embed_func)
         # Insert embeddings
@@ -313,7 +317,9 @@ class AsyncPGVectorStore(VectorStore):
             }
             values_stmt = "VALUES (:langchain_id, :content, :embedding"
 
-            if not embedding and can_inline_embed:
+            if not embedding and can_inline_embed_template:
+                values_stmt = f"VALUES (:langchain_id, :content, {inline_template_func(':content')}"  # type: ignore
+            elif not embedding and can_inline_embed:
                 values_stmt = f"VALUES (:langchain_id, :content, {self.embedding_service.embed_query_inline(content)}"  # type: ignore
 
             if self.hybrid_search_config and self.hybrid_search_config.tsv_column:
@@ -383,8 +389,11 @@ class AsyncPGVectorStore(VectorStore):
             :class:`InvalidTextRepresentationError <asyncpg.exceptions.InvalidTextRepresentationError>`: if the `ids` data type does not match that of the `id_column`.
         """
         # Check for inline embedding query
+        inline_template_func = getattr(
+            self.embedding_service, "embed_query_inline_template", None
+        )
         inline_embed_func = getattr(self.embedding_service, "embed_query_inline", None)
-        if callable(inline_embed_func):
+        if callable(inline_template_func) or callable(inline_embed_func):
             embeddings: list[list[float]] = [[] for _ in list(texts)]
         else:
             embeddings = await self.embedding_service.aembed_documents(list(texts))
@@ -664,18 +673,26 @@ class AsyncPGVectorStore(VectorStore):
         if filter and isinstance(filter, dict):
             safe_filter, filter_dict = self._create_filter_clause(filter)
 
+        inline_template_func = getattr(
+            self.embedding_service, "embed_query_inline_template", None
+        )
         inline_embed_func = getattr(self.embedding_service, "embed_query_inline", None)
-        if not embedding and callable(inline_embed_func) and "query" in kwargs:
+        param_dict: dict[str, Any] = {"dense_limit": dense_limit}
+        if not embedding and callable(inline_template_func) and "query" in kwargs:
+            embedding_data_string = inline_template_func(":query_text")
+            param_dict["query_text"] = kwargs["query"]
+        elif not embedding and callable(inline_embed_func) and "query" in kwargs:
             query_embedding = self.embedding_service.embed_query_inline(kwargs["query"])  # type: ignore
             embedding_data_string = f"{query_embedding}"
+            param_dict["query_embedding"] = query_embedding
         else:
             query_embedding = f"{[float(dimension) for dimension in embedding]}"
             embedding_data_string = ":query_embedding"
+            param_dict["query_embedding"] = query_embedding
         where_filters = f"WHERE {safe_filter}" if safe_filter else ""
         dense_query_stmt = f"""SELECT {column_names}, {search_function}("{self.embedding_column}", {embedding_data_string}) as distance
         FROM "{self.schema_name}"."{self.table_name}" {where_filters} ORDER BY "{self.embedding_column}" {operator} {embedding_data_string} LIMIT :dense_limit;
         """
-        param_dict = {"query_embedding": query_embedding, "dense_limit": dense_limit}
         if filter_dict:
             param_dict.update(filter_dict)
         if self.index_query_options:
@@ -769,10 +786,13 @@ class AsyncPGVectorStore(VectorStore):
         **kwargs: Any,
     ) -> list[Document]:
         """Return docs selected by similarity search on query."""
+        inline_template_func = getattr(
+            self.embedding_service, "embed_query_inline_template", None
+        )
         inline_embed_func = getattr(self.embedding_service, "embed_query_inline", None)
         embedding = (
             []
-            if callable(inline_embed_func)
+            if callable(inline_template_func) or callable(inline_embed_func)
             else await self.embedding_service.aembed_query(text=query)
         )
         kwargs["query"] = query
@@ -808,10 +828,13 @@ class AsyncPGVectorStore(VectorStore):
         **kwargs: Any,
     ) -> list[tuple[Document, float]]:
         """Return docs and distance scores selected by similarity search on query."""
+        inline_template_func = getattr(
+            self.embedding_service, "embed_query_inline_template", None
+        )
         inline_embed_func = getattr(self.embedding_service, "embed_query_inline", None)
         embedding = (
             []
-            if callable(inline_embed_func)
+            if callable(inline_template_func) or callable(inline_embed_func)
             else await self.embedding_service.aembed_query(text=query)
         )
         kwargs["query"] = query

{langchain_postgres-0.0.17 → langchain_postgres-0.0.18}/pyproject.toml

@@ -1,15 +1,15 @@
 [project]
 name = "langchain-postgres"
-version = "0.0.17"
+version = "0.0.18"
 description = "An integration package connecting Postgres and LangChain"
 authors = []
 readme = "README.md"
 repository = "https://github.com/langchain-ai/langchain-postgres"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = "MIT"
 dependencies = [
     "asyncpg>=0.30.0",
-    "langchain-core>=0.2.13,<2.0",
+    "langchain-core>=1.2.11,<2.0",
     "pgvector>=0.2.5,<0.4",
     "psycopg[binary]>=3,<4",
     "psycopg-pool>=3.2.1,<4",
@@ -23,7 +23,7 @@ dependencies = [
 [dependency-groups]
 test = [
     "codespell>=2.4.1",
-    "langchain-tests==0.3.7",
+    "langchain-tests>=1.1.5",
     "mypy>=1.15.0",
     "psycopg[binary]>=3,<4",
     "pytest>=8.3.4",
@@ -50,6 +50,14 @@ disallow_untyped_defs = "True"
 [tool.coverage.run]
 omit = ["tests/*"]
 
+[tool.uv]
+constraint-dependencies = [
+    # CVE-2026-25528: langsmith < 0.6.3 is vulnerable to SSRF via tracing header injection.
+    # langchain-core 1.x allows langsmith >=0.3.45,<1.0.0 so the resolver may pick an old version.
+    # Remove this constraint once langchain-core requires langsmith >= 0.6.3.
+    "langsmith>=0.6.3",
+]
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

{langchain_postgres-0.0.17 → langchain_postgres-0.0.18}/tests/unit_tests/v1/test_vectorstore.py

@@ -647,7 +647,7 @@ def test_pgvector_retriever_search_threshold() -> None:
         search_type="similarity_score_threshold",
         search_kwargs={"k": 3, "score_threshold": 0.999},
     )
-    output = retriever.get_relevant_documents("summer")
+    output = retriever.invoke("summer")
     _compare_documents(
         output,
         [
@@ -675,7 +675,7 @@ async def test_async_pgvector_retriever_search_threshold() -> None:
         search_type="similarity_score_threshold",
         search_kwargs={"k": 3, "score_threshold": 0.999},
     )
-    output = await retriever.aget_relevant_documents("summer")
+    output = await retriever.ainvoke("summer")
     _compare_documents(
         output,
         [
@@ -703,7 +703,7 @@ def test_pgvector_retriever_search_threshold_custom_normalization_fn() -> None:
         search_type="similarity_score_threshold",
         search_kwargs={"k": 3, "score_threshold": 0.5},
     )
-    output = retriever.get_relevant_documents("foo")
+    output = retriever.invoke("foo")
     assert output == []
 
 
@@ -728,7 +728,7 @@ async def test_async_pgvector_retriever_search_threshold_custom_normalization_fn
         search_type="similarity_score_threshold",
         search_kwargs={"k": 3, "score_threshold": 0.5},
     )
-    output = await retriever.aget_relevant_documents("foo")
+    output = await retriever.ainvoke("foo")
     assert output == []
 
 
@@ -857,7 +857,6 @@ def pgvector() -> Generator[PGVector, None, None]:
         yield vector_store
 
 
-@pytest.mark.asyncio
 @pytest.fixture
 async def async_pgvector() -> AsyncGenerator[PGVector, None]:
     """Create an async PGVector instance."""

{langchain_postgres-0.0.17 → langchain_postgres-0.0.18}/tests/unit_tests/v2/test_async_pg_vectorstore.py

@@ -1,10 +1,11 @@
 import uuid
 from typing import AsyncIterator, Sequence
+from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 import pytest_asyncio
 from langchain_core.documents import Document
-from langchain_core.embeddings import DeterministicFakeEmbedding
+from langchain_core.embeddings import DeterministicFakeEmbedding, Embeddings
 from sqlalchemy import text
 from sqlalchemy.engine.row import RowMapping
 
@@ -540,3 +541,138 @@ class TestVectorStore:
                 embedding_column="myembedding",
                 metadata_columns=["random_column"],  # invalid metadata column
             )
+
+    async def test_aadd_embeddings_with_inline_template(self) -> None:
+        class TemplateEmbeddings(Embeddings):
+            def embed_documents(self, texts: list[str]) -> list[list[float]]:
+                return []
+
+            def embed_query(self, text: str) -> list[float]:
+                return []
+
+            def embed_query_inline_template(self, param_name: str) -> str:
+                return f"embedding('model_id', {param_name})::vector"
+
+        mock_conn = AsyncMock()
+        mock_engine = MagicMock()
+        mock_engine.connect.return_value.__aenter__.return_value = mock_conn
+        mock_engine.connect.return_value.__aexit__.return_value = None
+
+        create_key = getattr(AsyncPGVectorStore, "_AsyncPGVectorStore__create_key")
+        vs = AsyncPGVectorStore(
+            create_key,
+            engine=mock_engine,
+            embedding_service=TemplateEmbeddings(),
+            table_name="test_table",
+        )
+        await vs.aadd_embeddings(texts=["hello world"], embeddings=[[]])
+        call_args = mock_conn.execute.call_args
+        sql_text = str(call_args[0][0])
+        params = call_args[0][1]
+        assert ":content, embedding('model_id', :content)::vector" in sql_text
+        assert params["content"] == "hello world"
+
+    async def test_aadd_embeddings_with_legacy_inline(self) -> None:
+        class LegacyEmbeddings(Embeddings):
+            def embed_documents(self, texts: list[str]) -> list[list[float]]:
+                return []
+
+            def embed_query(self, text: str) -> list[float]:
+                return []
+
+            def embed_query_inline(self, query: str) -> str:
+                return f"embedding('model_id', '{query}')::vector"
+
+        mock_conn = AsyncMock()
+        mock_engine = MagicMock()
+        mock_engine.connect.return_value.__aenter__.return_value = mock_conn
+        mock_engine.connect.return_value.__aexit__.return_value = None
+
+        create_key = getattr(AsyncPGVectorStore, "_AsyncPGVectorStore__create_key")
+        vs = AsyncPGVectorStore(
+            create_key,
+            engine=mock_engine,
+            embedding_service=LegacyEmbeddings(),
+            table_name="test_table",
+        )
+        await vs.aadd_embeddings(texts=["hello world"], embeddings=[[]])
+        call_args = mock_conn.execute.call_args
+        sql_text = str(call_args[0][0])
+        params = call_args[0][1]
+        assert "embedding('model_id', 'hello world')::vector" in sql_text
+        assert params["content"] == "hello world"
+
+    async def test_asimilarity_search_with_inline_template(self) -> None:
+        class TemplateEmbeddings(Embeddings):
+            def embed_documents(self, texts: list[str]) -> list[list[float]]:
+                return []
+
+            def embed_query(self, text: str) -> list[float]:
+                return []
+
+            def embed_query_inline_template(self, param_name: str) -> str:
+                return f"embedding('model_id', {param_name})::vector"
+
+        mock_conn = AsyncMock()
+        mock_result = MagicMock()
+        mock_result.mappings.return_value.fetchall.return_value = []
+        mock_conn.execute.return_value = mock_result
+
+        mock_engine = MagicMock()
+        mock_engine.connect.return_value.__aenter__.return_value = mock_conn
+        mock_engine.connect.return_value.__aexit__.return_value = None
+
+        create_key = getattr(AsyncPGVectorStore, "_AsyncPGVectorStore__create_key")
+        vs = AsyncPGVectorStore(
+            create_key,
+            engine=mock_engine,
+            embedding_service=TemplateEmbeddings(),
+            table_name="test_table",
+        )
+        await vs.asimilarity_search_with_score_by_vector(
+            embedding=[], query="search query"
+        )
+        call_args = mock_conn.execute.call_args
+        sql_text = str(call_args[0][0])
+        params = call_args[0][1]
+        assert "embedding('model_id', :query_text)::vector" in sql_text
+        assert params["query_text"] == "search query"
+
+    async def test_asimilarity_search_with_legacy_inline(self) -> None:
+        class LegacyEmbeddings(Embeddings):
+            def embed_documents(self, texts: list[str]) -> list[list[float]]:
+                return []
+
+            def embed_query(self, text: str) -> list[float]:
+                return []
+
+            def embed_query_inline(self, query: str) -> str:
+                return f"embedding('model_id', '{query}')::vector"
+
+        mock_conn = AsyncMock()
+        mock_result = MagicMock()
+        mock_result.mappings.return_value.fetchall.return_value = []
+        mock_conn.execute.return_value = mock_result
+
+        mock_engine = MagicMock()
+        mock_engine.connect.return_value.__aenter__.return_value = mock_conn
+        mock_engine.connect.return_value.__aexit__.return_value = None
+
+        create_key = getattr(AsyncPGVectorStore, "_AsyncPGVectorStore__create_key")
+        vs = AsyncPGVectorStore(
+            create_key,
+            engine=mock_engine,
+            embedding_service=LegacyEmbeddings(),
+            table_name="test_table",
+        )
+        await vs.asimilarity_search_with_score_by_vector(
+            embedding=[], query="legacy search"
+        )
+        call_args = mock_conn.execute.call_args
+        sql_text = str(call_args[0][0])
+        params = call_args[0][1]
+        assert "embedding('model_id', 'legacy search')::vector" in sql_text
+        assert (
+            params["query_embedding"]
+            == "embedding('model_id', 'legacy search')::vector"
+        )