~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.
Python academiaanthropicarxivbravedeep-researchencryptionhome-automationhomeserverlocallocal-deep-researchlocal-llmmistralollamaopenaipubmedresearchresearch-toolretrieval-augmented-generationsearxngself-hosted
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.mdnew file mode 100644index 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.pyindex 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):@classmethoddef 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 snapshotReturns:- 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.pyindex 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@classmethoddef 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_modelsbase_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_embedif 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_modelsdiff --git a/src/local_deep_research/embeddings/providers/implementations/openai.py b/src/local_deep_research/embeddings/providers/implementations/openai.pyindex 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):@classmethoddef 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 modelsexcept 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.pyindex 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):@classmethoddef 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.pyindex f5061c93af..e13b49988c 100644--- a/tests/embeddings/test_ollama_embeddings.py+++ b/tests/embeddings/test_ollama_embeddings.py@@ -8,7 +8,6 @@ import requestsfrom 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) == 2assert 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 untaggedp1, 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.pyindex 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 thekeys the UI needs to surface the embeddings form, and the OpenAI