Skip to content

~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.

fix(embeddings): list every model the endpoint returns; drop name guessing (#4199)

LearningCircuit4a3a6cddf7e5
diff --git a/changelog.d/4195.bugfix.md b/changelog.d/4195.bugfix.md
new file mode 100644
index 0000000000..05d3c02376
--- /dev/null
+++ b/changelog.d/4195.bugfix.md
@@ -0,0 +1 @@
+Fixed embedding-model dropdown showing "No models available" with LM Studio (and other OpenAI-compatible local servers) when an embedding model whose name didn't include the literal `embedding` token was loaded (e.g. `nomic-embed-text-v1.5`). The OpenAI and Ollama embedding providers no longer guess from the model name — every model the endpoint reports is shown so the user can pick the one they actually loaded. Ollama still tags models when its `/api/show` capabilities response is available. Fixes #4195.
diff --git a/src/local_deep_research/embeddings/providers/base.py b/src/local_deep_research/embeddings/providers/base.py
index 1a2e6fa13a..04d72266a6 100644
--- a/src/local_deep_research/embeddings/providers/base.py
+++ b/src/local_deep_research/embeddings/providers/base.py
@@ -66,19 +66,23 @@ class BaseEmbeddingProvider(ABC):
@classmethod
def get_available_models(
cls, settings_snapshot: Optional[Dict[str, Any]] = None
- ) -> List[Dict[str, str]]:
+ ) -> List[Dict[str, Any]]:
"""
Get list of available embedding models for this provider.
- Implementations should return only models that support embeddings,
- filtering out chat/completion-only models where applicable.
+ Implementations should return every model the backend reports.
+ Filtering by name is unreliable — users may load custom or
+ renamed embedding models — so leave the choice to the user and
+ only tag entries when a real capability signal is available.
Args:
settings_snapshot: Optional settings snapshot
Returns:
- List of dicts with 'value' and 'label' keys for each model.
- May include optional 'is_embedding' (bool) key.
+ List of dicts with ``value`` and ``label`` string keys for
+ each model. May include an optional ``is_embedding`` (bool)
+ key when the provider can detect embedding capability from
+ the backend (e.g. Ollama's ``/api/show`` capabilities).
"""
return []
diff --git a/src/local_deep_research/embeddings/providers/implementations/ollama.py b/src/local_deep_research/embeddings/providers/implementations/ollama.py
index a2e42abefd..46bb06631c 100644
--- a/src/local_deep_research/embeddings/providers/implementations/ollama.py
+++ b/src/local_deep_research/embeddings/providers/implementations/ollama.py
@@ -138,68 +138,77 @@ class OllamaEmbeddingsProvider(BaseEmbeddingProvider):
) -> Optional[bool]:
"""Check whether an Ollama model supports embeddings.
- Uses the /api/show capabilities field. Falls back to name heuristics
- for older Ollama versions that don't expose capabilities.
+ Uses the /api/show capabilities field. Returns ``None`` when the
+ capability list isn't available (older Ollama servers) — the
+ provider doesn't guess from the model name. Callers must treat
+ ``None`` as "unknown", not as "no", so models stay listed even
+ when their capability can't be confirmed.
"""
base_url = get_ollama_base_url(settings_snapshot)
caps = cls._get_model_capabilities(base_url, model)
- if caps is not None:
- return "embedding" in caps
-
- # Fallback: older Ollama without capabilities field
- return _name_looks_like_embedding(model)
+ # No name-based fallback on purpose — see method docstring.
+ if caps is None:
+ return None
+ return "embedding" in caps
@classmethod
def get_available_models(
cls, settings_snapshot: Optional[Dict[str, Any]] = None
- ) -> List[Dict[str, str]]:
- """Get all Ollama models with embedding compatibility info.
-
- Queries each model's capabilities via /api/show and marks models
- with an `is_embedding` flag. Returns embedding models first,
- then non-embedding models.
+ ) -> List[Dict[str, Any]]:
+ """Get all Ollama models, tagged when /api/show reports support.
+
+ No filtering on the model list itself — every model the Ollama
+ server reports is returned. We only *tag* entries with
+ ``is_embedding`` when ``/api/show`` exposes a real capabilities
+ list (so the UI can sort them); we don't guess from the model
+ name. Older Ollama servers without capabilities → models are
+ returned untagged and the user decides.
"""
from ....utilities.llm_utils import fetch_ollama_models
base_url = get_ollama_base_url(settings_snapshot)
+ # fetch_ollama_models returns every installed model. We pass it
+ # through unfiltered — no name heuristic, no exclusions.
all_models = fetch_ollama_models(base_url, timeout=3.0)
if not all_models:
return []
- embedding_models = []
- other_models = []
+ embedding_models: List[Dict[str, Any]] = []
+ untagged_models: List[Dict[str, Any]] = []
+ other_models: List[Dict[str, Any]] = []
for model in all_models:
model_name = model["value"]
caps = cls._get_model_capabilities(base_url, model_name)
- if caps is not None:
- is_embed = "embedding" in caps
- else:
- # Older Ollama without capabilities — use name heuristic
- is_embed = _name_looks_like_embedding(model_name)
-
- model["is_embedding"] = is_embed # type: ignore[assignment]
+ entry: Dict[str, Any] = dict(model)
+ if caps is None:
+ # No capability signal from the server → don't guess.
+ # Keep the model in the list so the user can still
+ # select it.
+ untagged_models.append(entry)
+ continue
+
+ # /api/show capabilities is an API-driven signal (not a
+ # name match), so it's safe to use for the flag.
+ is_embed = "embedding" in caps
+ entry["is_embedding"] = is_embed
if is_embed:
- embedding_models.append(model)
+ embedding_models.append(entry)
else:
- other_models.append(model)
+ other_models.append(entry)
logger.info(
- f"Found {len(embedding_models)} embedding models and "
- f"{len(other_models)} other models from Ollama"
+ "Found {} embedding-capable, {} non-embedding, and {} "
+ "untagged models from Ollama",
+ len(embedding_models),
+ len(other_models),
+ len(untagged_models),
)
- # Embedding models first, then the rest
- return embedding_models + other_models
-
-
-def _name_looks_like_embedding(model_name: str) -> bool:
- """Heuristic: check if a model name suggests it's an embedding model.
-
- Used as fallback for Ollama versions that don't expose capabilities.
- """
- name_lower = model_name.lower()
- return "embed" in name_lower or "bge" in name_lower
+ # Embedding-tagged first so they're the default pick; untagged
+ # next (capability unknown — user decides); then explicit
+ # non-embedding. Nothing is dropped.
+ return embedding_models + untagged_models + other_models
diff --git a/src/local_deep_research/embeddings/providers/implementations/openai.py b/src/local_deep_research/embeddings/providers/implementations/openai.py
index 1113880d81..4f60487341 100644
--- a/src/local_deep_research/embeddings/providers/implementations/openai.py
+++ b/src/local_deep_research/embeddings/providers/implementations/openai.py
@@ -168,8 +168,19 @@ class OpenAIEmbeddingsProvider(BaseEmbeddingProvider):
@classmethod
def get_available_models(
cls, settings_snapshot: Optional[Dict[str, Any]] = None
- ) -> List[Dict[str, str]]:
- """Get list of available OpenAI embedding models from API."""
+ ) -> List[Dict[str, Any]]:
+ """Get every model the configured endpoint reports.
+
+ No filtering: ``/v1/models`` doesn't expose a reliable "is this
+ an embedding model?" signal — neither cloud OpenAI nor
+ OpenAI-compatible local servers (LM Studio, vLLM, llama.cpp).
+ Earlier versions guessed from the model name and ended up
+ hiding real embedding models whose names didn't match the
+ heuristic (e.g. ``nomic-embed-text-v1.5`` was dropped because
+ it lacks the trailing ``-ing``). The dropdown now shows every
+ model the endpoint returns so the user can pick the one they
+ actually loaded.
+ """
try:
from openai import OpenAI
@@ -199,20 +210,22 @@ class OpenAIEmbeddingsProvider(BaseEmbeddingProvider):
client = OpenAI(**client_kwargs)
models_response = client.models.list()
- # Filter for embedding models only
- embedding_models = []
+ # No name-based filtering — see method docstring (#4195).
+ models: List[Dict[str, Any]] = []
for model in models_response.data:
model_id = model.id
- # OpenAI embedding models typically have "embedding" in the name
- if "embedding" in model_id.lower():
- embedding_models.append(
- {
- "value": model_id,
- "label": model_id,
- }
- )
-
- return embedding_models
+ # Skip only blank ids (malformed entry); never skip
+ # based on what the name looks like.
+ if not model_id:
+ continue
+ models.append({"value": model_id, "label": model_id})
+
+ logger.info(
+ "Fetched {} models from OpenAI endpoint{}",
+ len(models),
+ f" at {base_url}" if base_url else "",
+ )
+ return models
except Exception:
logger.exception("Error fetching OpenAI embedding models")
diff --git a/src/local_deep_research/embeddings/providers/implementations/sentence_transformers.py b/src/local_deep_research/embeddings/providers/implementations/sentence_transformers.py
index fab91faee2..794753856d 100644
--- a/src/local_deep_research/embeddings/providers/implementations/sentence_transformers.py
+++ b/src/local_deep_research/embeddings/providers/implementations/sentence_transformers.py
@@ -110,7 +110,7 @@ class SentenceTransformersProvider(BaseEmbeddingProvider):
@classmethod
def get_available_models(
cls, settings_snapshot: Optional[Dict[str, Any]] = None
- ) -> List[Dict[str, str]]:
+ ) -> List[Dict[str, Any]]:
"""
Get list of available Sentence Transformer models.
diff --git a/tests/embeddings/test_ollama_embeddings.py b/tests/embeddings/test_ollama_embeddings.py
index f5061c93af..e13b49988c 100644
--- a/tests/embeddings/test_ollama_embeddings.py
+++ b/tests/embeddings/test_ollama_embeddings.py
@@ -8,7 +8,6 @@ import requests
from local_deep_research.embeddings.providers.implementations.ollama import (
OllamaEmbeddingsProvider,
- _name_looks_like_embedding,
)
@@ -482,25 +481,12 @@ class TestIsEmbeddingModel:
result = OllamaEmbeddingsProvider.is_embedding_model("qwen3:4b")
assert result is False
- def test_falls_back_to_name_heuristic_true(self):
- """Falls back to name heuristic when capabilities unavailable."""
- with patch(
- f"{_OLLAMA_MODULE}.get_ollama_base_url",
- return_value="http://localhost:11434",
- ):
- with patch.object(
- OllamaEmbeddingsProvider,
- "_get_model_capabilities",
- return_value=None,
- ):
- # "embed" in name → True
- result = OllamaEmbeddingsProvider.is_embedding_model(
- "nomic-embed-text"
- )
- assert result is True
+ def test_returns_none_when_capabilities_unavailable(self):
+ """Older Ollama (no capabilities in /api/show) → None, not a guess.
- def test_falls_back_to_name_heuristic_false(self):
- """Falls back to name heuristic and returns False for LLM name."""
+ We refuse to guess from the model name; the caller can decide
+ whether to tag the model, hide it, or just trust the user.
+ """
with patch(
f"{_OLLAMA_MODULE}.get_ollama_base_url",
return_value="http://localhost:11434",
@@ -510,38 +496,18 @@ class TestIsEmbeddingModel:
"_get_model_capabilities",
return_value=None,
):
- result = OllamaEmbeddingsProvider.is_embedding_model(
- "deepseek-r1:32b"
+ assert (
+ OllamaEmbeddingsProvider.is_embedding_model(
+ "nomic-embed-text"
+ )
+ is None
+ )
+ assert (
+ OllamaEmbeddingsProvider.is_embedding_model(
+ "deepseek-r1:32b"
+ )
+ is None
)
- assert result is False
-
-
-# ── _name_looks_like_embedding ───────────────────────────────────────────
-
-
-class TestNameLooksLikeEmbedding:
- """Tests for _name_looks_like_embedding heuristic."""
-
- def test_embed_in_name(self):
- assert _name_looks_like_embedding("nomic-embed-text:latest") is True
-
- def test_embed_prefix(self):
- assert _name_looks_like_embedding("mxbai-embed-large") is True
-
- def test_bge_in_name(self):
- assert _name_looks_like_embedding("bge-m3:latest") is True
-
- def test_llm_name_rejected(self):
- assert _name_looks_like_embedding("qwen3:4b") is False
-
- def test_deepseek_rejected(self):
- assert _name_looks_like_embedding("deepseek-r1:32b") is False
-
- def test_case_insensitive(self):
- assert _name_looks_like_embedding("BGE-Large-EN") is True
-
- def test_empty_string(self):
- assert _name_looks_like_embedding("") is False
# ── get_available_models ─────────────────────────────────────────────────
@@ -643,8 +609,10 @@ class TestOllamaEmbeddingsGetAvailableModels:
assert len(result) == 2
assert all(m["is_embedding"] is False for m in result)
- def test_fallback_to_name_heuristic_when_capabilities_unavailable(self):
- """Uses name heuristic when /api/show returns no capabilities."""
+ def test_capabilities_unavailable_returns_untagged_models(self):
+ """Older Ollama (no /api/show capabilities) → every model is
+ still listed, just without an ``is_embedding`` flag. The
+ provider doesn't guess from the name."""
all_models = [
{
"value": "nomic-embed-text:latest",
@@ -652,17 +620,17 @@ class TestOllamaEmbeddingsGetAvailableModels:
},
{"value": "qwen3:4b", "label": "qwen3:4b"},
]
- # Return None for all models → no capabilities available
- caps = {}
+ caps = {} # No model has capabilities → all untagged
p1, p2, p3 = self._setup_mocks(all_models, caps)
with p1, p2, p3:
result = OllamaEmbeddingsProvider.get_available_models()
- assert len(result) == 2
- embed = [m for m in result if m["is_embedding"]]
- assert len(embed) == 1
- assert embed[0]["value"] == "nomic-embed-text:latest"
+ assert {m["value"] for m in result} == {
+ "nomic-embed-text:latest",
+ "qwen3:4b",
+ }
+ assert all("is_embedding" not in m for m in result)
def test_multiple_embedding_models(self):
"""Multiple embedding models are all sorted first."""
diff --git a/tests/embeddings/test_openai_embeddings.py b/tests/embeddings/test_openai_embeddings.py
index c89540a4fb..1dfa819589 100644
--- a/tests/embeddings/test_openai_embeddings.py
+++ b/tests/embeddings/test_openai_embeddings.py
@@ -273,7 +273,12 @@ class TestOpenAIEmbeddingsProviderGetAvailableModels:
"""Tests for OpenAIEmbeddingsProvider.get_available_models method."""
def test_get_available_models_success(self):
- """Test getting available models from OpenAI API."""
+ """Test getting available models from OpenAI API.
+
+ The provider returns every model the endpoint reports — there's
+ no reliable signal in /v1/models for "is this an embedding
+ model?", so guessing from the name is left to the user.
+ """
from local_deep_research.embeddings.providers.implementations.openai import (
OpenAIEmbeddingsProvider,
)
@@ -283,7 +288,7 @@ class TestOpenAIEmbeddingsProviderGetAvailableModels:
mock_model2 = MagicMock()
mock_model2.id = "text-embedding-3-large"
mock_model3 = MagicMock()
- mock_model3.id = "gpt-4" # Not an embedding model
+ mock_model3.id = "gpt-4"
mock_response = MagicMock()
mock_response.data = [mock_model1, mock_model2, mock_model3]
@@ -291,9 +296,14 @@ class TestOpenAIEmbeddingsProviderGetAvailableModels:
mock_client = MagicMock()
mock_client.models.list.return_value = mock_response
+ def _settings(key, default=None, settings_snapshot=None):
+ if key == "embeddings.openai.api_key":
+ return "test-api-key"
+ return default
+
with patch(
"local_deep_research.embeddings.providers.implementations.openai.get_setting_from_snapshot",
- return_value="test-api-key",
+ side_effect=_settings,
):
with patch(
"openai.OpenAI",
@@ -301,10 +311,14 @@ class TestOpenAIEmbeddingsProviderGetAvailableModels:
):
models = OpenAIEmbeddingsProvider.get_available_models()
- # Should only return embedding models
- assert len(models) == 2
- assert models[0]["value"] == "text-embedding-3-small"
- assert models[1]["value"] == "text-embedding-3-large"
+ assert [m["value"] for m in models] == [
+ "text-embedding-3-small",
+ "text-embedding-3-large",
+ "gpt-4",
+ ]
+ # No name-based tagging — the endpoint can't be trusted
+ # to identify embedding models for us.
+ assert all("is_embedding" not in m for m in models)
def test_get_available_models_no_api_key(self):
"""Test getting models returns empty list when no API key."""
@@ -493,6 +507,100 @@ class TestOpenAIEmbeddingsProviderCompatibleEndpoint:
)
+class TestOpenAIEmbeddingsProviderLMStudioModelDiscovery:
+ """Regression tests for issue #4195.
+
+ LM Studio (and other OpenAI-compatible local servers) returns every
+ loaded model from ``/v1/models``, both embedding models and LLMs,
+ without a reliable ``type`` field to distinguish them. The previous
+ ``"embedding" in id`` filter dropped real embedding models whose
+ names use the shorter ``embed`` token (``nomic-embed-text-v1.5``)
+ and so the embedding-model dropdown ended up empty.
+
+ The fix: stop guessing from the name. Show every model the endpoint
+ returns and let the user pick the one they actually loaded.
+ """
+
+ @staticmethod
+ def _settings_mock(api_key, base_url):
+ values = {
+ "embeddings.openai.api_key": api_key,
+ "embeddings.openai.base_url": base_url,
+ }
+
+ def _side_effect(key, default=None, settings_snapshot=None):
+ if key in values:
+ return values[key]
+ return default
+
+ return _side_effect
+
+ def _fake_models_response(self, ids):
+ models = []
+ for model_id in ids:
+ m = MagicMock()
+ m.id = model_id
+ models.append(m)
+ response = MagicMock()
+ response.data = models
+ return response
+
+ def test_lmstudio_nomic_embed_text_is_listed(self):
+ """The headline regression for #4195: a Nomic embedding model
+ loaded in LM Studio must appear in the dropdown — its name
+ doesn't contain the literal ``embedding`` token but it is the
+ embedding model the user wants to use."""
+ from local_deep_research.embeddings.providers.implementations.openai import (
+ OpenAIEmbeddingsProvider,
+ )
+
+ fake_client = MagicMock()
+ fake_client.models.list.return_value = self._fake_models_response(
+ ["nomic-embed-text-v1.5"]
+ )
+
+ with patch(
+ "local_deep_research.embeddings.providers.implementations.openai.get_setting_from_snapshot",
+ side_effect=self._settings_mock(
+ api_key=None, base_url="http://localhost:1234/v1"
+ ),
+ ):
+ with patch("openai.OpenAI", return_value=fake_client):
+ models = OpenAIEmbeddingsProvider.get_available_models()
+
+ assert [m["value"] for m in models] == ["nomic-embed-text-v1.5"]
+
+ def test_lmstudio_returns_every_loaded_model_unfiltered(self):
+ """Every loaded model — embedding or LLM, well-known name or
+ custom fine-tune — is returned. We don't pre-filter the list."""
+ from local_deep_research.embeddings.providers.implementations.openai import (
+ OpenAIEmbeddingsProvider,
+ )
+
+ ids = [
+ "llama-3.1-8b-instruct",
+ "nomic-embed-text-v1.5",
+ "qwen3-embedding-8b",
+ "bge-large-en-v1.5",
+ "some-custom-finetune",
+ ]
+ fake_client = MagicMock()
+ fake_client.models.list.return_value = self._fake_models_response(ids)
+
+ with patch(
+ "local_deep_research.embeddings.providers.implementations.openai.get_setting_from_snapshot",
+ side_effect=self._settings_mock(
+ api_key=None, base_url="http://localhost:1234/v1"
+ ),
+ ):
+ with patch("openai.OpenAI", return_value=fake_client):
+ models = OpenAIEmbeddingsProvider.get_available_models()
+
+ # Order preserved, nothing dropped, no name-based flags added.
+ assert [m["value"] for m in models] == ids
+ assert all("is_embedding" not in m for m in models)
+
+
class TestOpenAIEmbeddingsSettingsRegistration:
"""The settings file shipped for issue #3883 must register the
keys the UI needs to surface the embeddings form, and the OpenAI