fix(python): accept NumPy text arrays in Ollama embeddings (#4605)

`OllamaEmbeddings.compute_source_embeddings(np.array(["hello",
"world"]))` raises a validation error before sending a request. The
embedding interface accepts NumPy arrays, but the adapter passes the
array directly to Ollama's string-or-sequence request field.

Convert NumPy text arrays to lists before the batched request. This
preserves input order, the single request, model options and
`keep_alive`. The tests cover Unicode/object/sliced arrays, empty input,
existing list/Arrow/query inputs and API error propagation.

The added input-contract tests also cover two-dimensional arrays and
byte strings, with equivalent list inputs as controls. The real Ollama
SDK rejects 2-D inputs and invalid UTF-8 locally, before transport.
Valid UTF-8 bytes are decoded normally. No extra adapter validation is
needed for these cases.

Validation on Python 3.12.14 / macOS arm64:

- Built the Rust/PyO3 bindings using the repository's uv/maturin
environment.
- The initial regression run had 5 failures and 4 passing controls on
the base; all 9 passed with the fix. With the 6 additional
input-contract cases, the related embedding and trust suites now total
55 passed / 11 skipped.
- All Python Ruff lint and formatting checks pass. Root checks still
report the same 49 lint errors and 11 documentation formatting files
reproduced on the untouched base.
- Separate review exercised 13 public API cases. Another 7 groups passed
through a real loopback HTTP transport, including local validation,
UTF-8 serialization and empty-batch model-error propagation.

The regression tests use the real Ollama 0.6.2 SDK with HTTPX
MockTransport. The loopback check uses an HTTP surrogate, not an Ollama
daemon. No live model inference was run.

A live Ollama server was unavailable locally. [The current server
handler](https://github.com/ollama/ollama/blob/2cd63f7a15039ccd790e97b31edc091fa1707c56/server/routes.go#L1212)
explicitly returns HTTP 200 with empty embeddings for empty input after
model lookup and runner setup. The adapter preserves the existing
empty-list request and its model/setup errors. This is a source check,
not a live-server test.

Developed with OpenAI Codex, with separate agent review and executed
local checks.

docs/web/integrations/embedding/ollama.mdx

@@ -10,6 +10,9 @@ Generate embeddings via the [ollama](https://github.com/ollama/ollama-python) py
 - [Ollama docs on embeddings](https://github.com/ollama/ollama/blob/main/docs/api.md#generate-embeddings)
 - [Ollama blog on embeddings](https://ollama.com/blog/embedding-models)
 
+For direct calls, `compute_source_embeddings` accepts a list of strings or a
+one-dimensional NumPy string array. Both inputs are sent to Ollama in one batch.
+
 | Parameter              | Type                       | Default Value            | Description                                                                                                                                    |
 |------------------------|----------------------------|--------------------------|------------------------------------------------------------------------------------------------------------------------------------------------|
 | `name`                 | `str`                      | `nomic-embed-text`       | The name of the model.                                                                                                                         |

python/python/lancedb/embeddings/ollama.py

@@ -70,6 +70,8 @@ class OllamaEmbeddings(TextEmbeddingFunction):
             The texts to embed
         """
         # TODO retry, rate limit, token limit
+        if isinstance(texts, np.ndarray):
+            texts = texts.tolist()
         embeddings = self._compute_embedding(texts)
         return list(embeddings)
 

python/python/tests/test_ollama_embeddings.py

@@ -0,0 +1,126 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright The LanceDB Authors
+
+import json
+
+import httpx
+import numpy as np
+import pyarrow as pa
+import pytest
+from pydantic import ValidationError
+
+from lancedb.embeddings import get_registry
+
+
+@pytest.fixture
+def ollama_embeddings():
+    pytest.importorskip("ollama")
+    requests = []
+
+    def respond(request):
+        body = json.loads(request.content)
+        requests.append(body)
+        if body["model"] == "missing-model":
+            return httpx.Response(404, json={"error": "model not found"})
+        return httpx.Response(
+            200,
+            json={
+                "embeddings": [
+                    [float(index), float(len(text))]
+                    for index, text in enumerate(body["input"])
+                ]
+            },
+        )
+
+    function = (
+        get_registry()
+        .get("ollama")
+        .create(
+            name="nomic-embed-text",
+            options={"num_ctx": 4096},
+            keep_alive="10m",
+            ollama_client_kwargs={
+                "transport": httpx.MockTransport(respond),
+                "trust_env": False,
+            },
+        )
+    )
+    yield function, requests
+    function._ollama_client._client.close()
+
+
+@pytest.mark.parametrize(
+    "texts",
+    [
+        pytest.param(["hello", "世界"], id="list"),
+        pytest.param(np.array(["hello", "世界"]), id="numpy-unicode"),
+        pytest.param(np.array(["hello", "世界"], dtype=object), id="numpy-object"),
+        pytest.param(
+            np.array([b"hello", "世界".encode("utf-8")]), id="numpy-utf8-bytes"
+        ),
+        pytest.param([b"hello", "世界".encode("utf-8")], id="list-utf8-bytes"),
+        pytest.param(np.array(["hello", "unused", "世界"])[::2], id="numpy-slice"),
+        pytest.param(pa.array(["hello", "世界"]), id="arrow"),
+        pytest.param(pa.chunked_array([["hello"], ["世界"]]), id="chunked-arrow"),
+    ],
+)
+def test_ollama_source_embeddings_inputs(ollama_embeddings, texts):
+    function, requests = ollama_embeddings
+
+    assert function.compute_source_embeddings(texts) == [[0.0, 5.0], [1.0, 2.0]]
+    assert requests == [
+        {
+            "model": "nomic-embed-text",
+            "input": ["hello", "世界"],
+            "options": {"num_ctx": 4096},
+            "keep_alive": "10m",
+        }
+    ]
+
+
+@pytest.mark.parametrize(
+    "texts",
+    [
+        pytest.param(np.array([["hello"], ["world"]]), id="numpy-two-dimensional"),
+        pytest.param([["hello"], ["world"]], id="list-two-dimensional"),
+        pytest.param(np.array([b"\xff"]), id="numpy-invalid-utf8"),
+        pytest.param([b"\xff"], id="list-invalid-utf8"),
+    ],
+)
+def test_ollama_source_embeddings_rejects_invalid_input_locally(
+    ollama_embeddings, texts
+):
+    function, requests = ollama_embeddings
+
+    with pytest.raises(ValidationError, match="valid string"):
+        function.compute_source_embeddings(texts)
+
+    assert requests == []
+
+
+def test_ollama_generate_embeddings_empty_array(ollama_embeddings):
+    function, requests = ollama_embeddings
+
+    assert function.generate_embeddings(np.array([], dtype=str)) == []
+    assert len(requests) == 1
+    assert requests[0]["input"] == []
+
+
+def test_ollama_query_embeddings(ollama_embeddings):
+    function, requests = ollama_embeddings
+
+    assert function.compute_query_embeddings("hello") == [[0.0, 5.0]]
+    assert len(requests) == 1
+    assert requests[0]["input"] == ["hello"]
+
+
+def test_ollama_source_embeddings_preserves_api_error(ollama_embeddings):
+    ollama = pytest.importorskip("ollama")
+    function, requests = ollama_embeddings
+    function.name = "missing-model"
+
+    with pytest.raises(ollama.ResponseError, match="model not found") as error:
+        function.compute_source_embeddings(np.array(["hello"]))
+
+    assert error.value.status_code == 404
+    assert len(requests) == 1