From a2d163adbf30e58b0ca6e7d8898569135fbea13b Mon Sep 17 00:00:00 2001
From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com>
Date: Wed, 29 Jul 2026 09:00:19 +0800
Subject: [PATCH 01/17] feat: add enable_thinking support for OpenAI-compatible
providers
Closes #2149
Adds enable_thinking configuration parameter for OpenAI-compatible
providers (qwen, deepseek, minimax) to control whether the model
produces reasoning blocks before the actual response.
Changes:
- Added enable_thinking field (bool | None) to OpenAILLMConfig
- None (default): preserve provider's default behavior
- True: explicitly enable thinking mode
- False: explicitly disable thinking mode (prevents JSON breaking)
- OpenAILLM.generate / generate_stream now pass enable_thinking
to API calls when configured, via enable_thinking body param
- AzureLLM.generate / generate_stream also support the parameter
(gated by getattr for backward compatibility with older configs)
- Per-call override supported via kwargs (enable_thinking=True/False)
- Added tests covering default, config-level, and kwarg-level
enable_thinking behavior in test_enable_thinking.py
This is a non-breaking change: when enable_thinking is unset,
request bodies are identical to previous versions.
Test: python3 -m py_compile src/memos/configs/llm.py
Test: python3 -m py_compile src/memos/llms/openai.py
Test: python3 -m py_compile tests/llms/test_enable_thinking.py
---
src/memos/configs/llm.py | 5 ++
src/memos/llms/openai.py | 73 +++++++++++++++++----------
tests/llms/test_enable_thinking.py | 80 ++++++++++++++++++++++++++++++
3 files changed, 131 insertions(+), 27 deletions(-)
create mode 100644 tests/llms/test_enable_thinking.py
diff --git a/src/memos/configs/llm.py b/src/memos/configs/llm.py
index 81f7038fa..627a7daed 100644
--- a/src/memos/configs/llm.py
+++ b/src/memos/configs/llm.py
@@ -28,6 +28,11 @@ class OpenAILLMConfig(BaseLLMConfig):
default="https://api.openai.com/v1", description="Base URL for OpenAI API"
)
extra_body: Any = Field(default=None, description="extra body")
+ enable_thinking: bool | None = Field(
+ default=None,
+ description="Enable/disable thinking mode for models that support it (e.g. Qwen3, DeepSeek-R1). "
+ "When None (default), the provider's default behavior is preserved.",
+ )
backup_client: bool = Field(
default=False,
description="Whether to enable backup client for fallback on primary failure",
diff --git a/src/memos/llms/openai.py b/src/memos/llms/openai.py
index 9a29ea68a..e4c45eca3 100644
--- a/src/memos/llms/openai.py
+++ b/src/memos/llms/openai.py
@@ -61,15 +61,7 @@ def _parse_response(self, response) -> str:
return reasoning_content + (response_content or "")
return response_content or ""
- @timed_with_status(
- log_prefix="OpenAI LLM",
- log_extra_args=lambda self, messages, **kwargs: {
- "model_name_or_path": kwargs.get("model_name_or_path", self.config.model_name_or_path),
- "messages": messages,
- },
- )
- def generate(self, messages: MessageList, **kwargs) -> str:
- """Generate a response from OpenAI LLM, optionally overriding generation params."""
+ def _build_request_body(self, messages: MessageList, **kwargs) -> dict:
request_body = {
"model": kwargs.get("model_name_or_path", self.config.model_name_or_path),
"messages": messages,
@@ -79,6 +71,21 @@ def generate(self, messages: MessageList, **kwargs) -> str:
"extra_body": kwargs.get("extra_body", self.config.extra_body),
"tools": kwargs.get("tools", NOT_GIVEN),
}
+ enable_thinking = kwargs.get("enable_thinking", self.config.enable_thinking)
+ if enable_thinking is not None:
+ request_body["enable_thinking"] = enable_thinking
+ return request_body
+
+ @timed_with_status(
+ log_prefix="OpenAI LLM",
+ log_extra_args=lambda self, messages, **kwargs: {
+ "model_name_or_path": kwargs.get("model_name_or_path", self.config.model_name_or_path),
+ "messages": messages,
+ },
+ )
+ def generate(self, messages: MessageList, **kwargs) -> str:
+ """Generate a response from OpenAI LLM, optionally overriding generation params."""
+ request_body = self._build_request_body(messages, **kwargs)
start_time = time.perf_counter()
logger.info(f"OpenAI LLM Request body: {request_body}")
@@ -132,6 +139,10 @@ def generate_stream(self, messages: MessageList, **kwargs) -> Generator[str, Non
"tools": kwargs.get("tools", NOT_GIVEN),
}
+ enable_thinking = kwargs.get("enable_thinking", self.config.enable_thinking)
+ if enable_thinking is not None:
+ request_body["enable_thinking"] = enable_thinking
+
logger.info(f"OpenAI LLM Stream Request body: {request_body}")
response = self.client.chat.completions.create(**request_body)
@@ -184,15 +195,19 @@ def __init__(self, config: AzureLLMConfig):
def generate(self, messages: MessageList, **kwargs) -> str:
"""Generate a response from Azure OpenAI LLM."""
- response = self.client.chat.completions.create(
- model=self.config.model_name_or_path,
- messages=messages,
- temperature=kwargs.get("temperature", self.config.temperature),
- max_tokens=kwargs.get("max_tokens", self.config.max_tokens),
- top_p=kwargs.get("top_p", self.config.top_p),
- tools=kwargs.get("tools", NOT_GIVEN),
- extra_body=kwargs.get("extra_body", self.config.extra_body),
- )
+ request_body = {
+ "model": self.config.model_name_or_path,
+ "messages": messages,
+ "temperature": kwargs.get("temperature", self.config.temperature),
+ "max_tokens": kwargs.get("max_tokens", self.config.max_tokens),
+ "top_p": kwargs.get("top_p", self.config.top_p),
+ "tools": kwargs.get("tools", NOT_GIVEN),
+ "extra_body": kwargs.get("extra_body", self.config.extra_body),
+ }
+ enable_thinking = kwargs.get("enable_thinking", getattr(self.config, "enable_thinking", None))
+ if enable_thinking is not None:
+ request_body["enable_thinking"] = enable_thinking
+ response = self.client.chat.completions.create(**request_body)
logger.info(f"Response from Azure OpenAI: {response.model_dump_json()}")
if not response.choices:
logger.warning("Azure OpenAI response has no choices")
@@ -212,15 +227,19 @@ def generate_stream(self, messages: MessageList, **kwargs) -> Generator[str, Non
logger.info("stream api not support tools")
return
- response = self.client.chat.completions.create(
- model=self.config.model_name_or_path,
- messages=messages,
- stream=True,
- temperature=kwargs.get("temperature", self.config.temperature),
- max_tokens=kwargs.get("max_tokens", self.config.max_tokens),
- top_p=kwargs.get("top_p", self.config.top_p),
- extra_body=kwargs.get("extra_body", self.config.extra_body),
- )
+ request_body = {
+ "model": self.config.model_name_or_path,
+ "messages": messages,
+ "stream": True,
+ "temperature": kwargs.get("temperature", self.config.temperature),
+ "max_tokens": kwargs.get("max_tokens", self.config.max_tokens),
+ "top_p": kwargs.get("top_p", self.config.top_p),
+ "extra_body": kwargs.get("extra_body", self.config.extra_body),
+ }
+ enable_thinking = kwargs.get("enable_thinking", getattr(self.config, "enable_thinking", None))
+ if enable_thinking is not None:
+ request_body["enable_thinking"] = enable_thinking
+ response = self.client.chat.completions.create(**request_body)
reasoning_started = False
diff --git a/tests/llms/test_enable_thinking.py b/tests/llms/test_enable_thinking.py
new file mode 100644
index 000000000..ffe17e5b5
--- /dev/null
+++ b/tests/llms/test_enable_thinking.py
@@ -0,0 +1,80 @@
+"""Tests for enable_thinking parameter in OpenAILLM."""
+
+from types import SimpleNamespace
+from unittest.mock import patch
+
+import pytest
+
+from memos.configs.llm import OpenAILLMConfig
+from memos.llms.openai import AzureLLM, OpenAILLM
+
+
+def _make_config(**overrides):
+ defaults = {
+ "provider": "openai",
+ "api_key": "test-key",
+ "model_name_or_path": "gpt-4o",
+ }
+ defaults.update(overrides)
+ return OpenAILLMConfig(**defaults)
+
+
+class TestEnableThinkingConfig:
+ def test_enable_thinking_defaults_to_none(self):
+ config = _make_config()
+ assert config.enable_thinking is None
+
+ def test_enable_thinking_can_be_set(self):
+ config = _make_config(enable_thinking=True)
+ assert config.enable_thinking is True
+
+ def test_enable_thinking_false(self):
+ config = _make_config(enable_thinking=False)
+ assert config.enable_thinking is False
+
+
+class TestEnableThinkingInRequest:
+ def test_build_request_body_without_enable_thinking(self):
+ config = _make_config()
+ embedder = OpenAILLM.__new__(OpenAILLM)
+ embedder.config = config
+
+ body = embedder._build_request_body([{"role": "user", "content": "hi"}])
+ assert "enable_thinking" not in body
+
+ def test_build_request_body_with_enable_thinking_from_config(self):
+ config = _make_config(enable_thinking=True)
+ embedder = OpenAILLM.__new__(OpenAILLM)
+ embedder.config = config
+
+ body = embedder._build_request_body([{"role": "user", "content": "hi"}])
+ assert body["enable_thinking"] is True
+
+ def test_build_request_body_with_enable_thinking_from_kwargs(self):
+ config = _make_config(enable_thinking=True)
+ embedder = OpenAILLM.__new__(OpenAILLM)
+ embedder.config = config
+
+ body = embedder._build_request_body(
+ [{"role": "user", "content": "hi"}], enable_thinking=False
+ )
+ assert body["enable_thinking"] is False
+
+ def test_build_request_body_with_enable_thinking_false(self):
+ config = _make_config(enable_thinking=False)
+ embedder = OpenAILLM.__new__(OpenAILLM)
+ embedder.config = config
+
+ body = embedder._build_request_body([{"role": "user", "content": "hi"}])
+ assert body["enable_thinking"] is False
+
+ def test_build_request_body_preserves_other_params(self):
+ config = _make_config(enable_thinking=True, temperature=0.5, max_tokens=100)
+ embedder = OpenAILLM.__new__(OpenAILLM)
+ embedder.config = config
+
+ body = embedder._build_request_body([{"role": "user", "content": "hi"}])
+ assert body["enable_thinking"] is True
+ assert body["temperature"] == 0.5
+ assert body["max_tokens"] == 100
+ assert body["model"] == "gpt-4o"
From f418e82ef3617b4615f1901c9348a84e00804fc9 Mon Sep 17 00:00:00 2001
From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com>
Date: Fri, 31 Jul 2026 10:02:34 +0800
Subject: [PATCH 02/17] style(test): ruff cleanups for enable_thinking tests
---
tests/llms/test_enable_thinking.py | 7 +------
1 file changed, 1 insertion(+), 6 deletions(-)
diff --git a/tests/llms/test_enable_thinking.py b/tests/llms/test_enable_thinking.py
index ffe17e5b5..be3441faa 100644
--- a/tests/llms/test_enable_thinking.py
+++ b/tests/llms/test_enable_thinking.py
@@ -1,12 +1,7 @@
"""Tests for enable_thinking parameter in OpenAILLM."""
-from types import SimpleNamespace
-from unittest.mock import patch
-
-import pytest
-
from memos.configs.llm import OpenAILLMConfig
-from memos.llms.openai import AzureLLM, OpenAILLM
+from memos.llms.openai import OpenAILLM
def _make_config(**overrides):
From 4dd095e86cf18aeac62d09dbaf53c71b6f3d003e Mon Sep 17 00:00:00 2001
From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com>
Date: Mon, 3 Aug 2026 11:50:26 +0800
Subject: [PATCH 03/17] style(llm): ruff format openai.py
---
src/memos/llms/openai.py | 8 ++++++--
1 file changed, 6 insertions(+), 2 deletions(-)
diff --git a/src/memos/llms/openai.py b/src/memos/llms/openai.py
index e4c45eca3..cf5302552 100644
--- a/src/memos/llms/openai.py
+++ b/src/memos/llms/openai.py
@@ -204,7 +204,9 @@ def generate(self, messages: MessageList, **kwargs) -> str:
"tools": kwargs.get("tools", NOT_GIVEN),
"extra_body": kwargs.get("extra_body", self.config.extra_body),
}
- enable_thinking = kwargs.get("enable_thinking", getattr(self.config, "enable_thinking", None))
+ enable_thinking = kwargs.get(
+ "enable_thinking", getattr(self.config, "enable_thinking", None)
+ )
if enable_thinking is not None:
request_body["enable_thinking"] = enable_thinking
response = self.client.chat.completions.create(**request_body)
@@ -236,7 +238,9 @@ def generate_stream(self, messages: MessageList, **kwargs) -> Generator[str, Non
"top_p": kwargs.get("top_p", self.config.top_p),
"extra_body": kwargs.get("extra_body", self.config.extra_body),
}
- enable_thinking = kwargs.get("enable_thinking", getattr(self.config, "enable_thinking", None))
+ enable_thinking = kwargs.get(
+ "enable_thinking", getattr(self.config, "enable_thinking", None)
+ )
if enable_thinking is not None:
request_body["enable_thinking"] = enable_thinking
response = self.client.chat.completions.create(**request_body)
From 333852d7cee9b9866e12eb66b5181f2ff4a28949 Mon Sep 17 00:00:00 2001
From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com>
Date: Wed, 5 Aug 2026 13:24:39 +0800
Subject: [PATCH 04/17] test(llm): align enable-thinking config coverage
---
tests/configs/test_llm.py | 2 ++
tests/llms/test_enable_thinking.py | 1 -
2 files changed, 2 insertions(+), 1 deletion(-)
diff --git a/tests/configs/test_llm.py b/tests/configs/test_llm.py
index d1507e389..bc036fdb8 100644
--- a/tests/configs/test_llm.py
+++ b/tests/configs/test_llm.py
@@ -57,6 +57,7 @@ def test_openai_llm_config():
"remove_think_prefix",
"extra_body",
"default_headers",
+ "enable_thinking",
"backup_client",
"backup_api_key",
"backup_api_base",
@@ -159,6 +160,7 @@ def test_minimax_llm_config():
"remove_think_prefix",
"extra_body",
"default_headers",
+ "enable_thinking",
"backup_client",
"backup_api_key",
"backup_api_base",
diff --git a/tests/llms/test_enable_thinking.py b/tests/llms/test_enable_thinking.py
index be3441faa..0ad34e5f3 100644
--- a/tests/llms/test_enable_thinking.py
+++ b/tests/llms/test_enable_thinking.py
@@ -6,7 +6,6 @@
def _make_config(**overrides):
defaults = {
- "provider": "openai",
"api_key": "test-key",
"model_name_or_path": "gpt-4o",
}
From ca3c2332d4b6b12f22784d05d37ed4ac9c8add9c Mon Sep 17 00:00:00 2001
From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com>
Date: Tue, 28 Jul 2026 23:06:28 +0800
Subject: [PATCH 05/17] fix: UniversalAPIEmbedder now passes embedding_dims to
API calls
Closes #2177
The UniversalAPIEmbedder previously silently ignored the
embedding_dims config field when making embeddings.create()
calls. This caused models like text-embedding-3-large to always
return the full default dimension embedding, making it impossible
to use the dimensions parameter for reduced-dimensional embeddings.
Changes:
- Added _build_embedding_kwargs() helper that conditionally
includes the 'dimensions' parameter when embedding_dims is set
- Extracted _call_embeddings_api() method that handles both
primary and backup client paths with unified dimension support
- Added graceful fallback: if the API rejects the dimensions
parameter (e.g. older model versions), automatically retries
without it
- Both primary and backup client paths now use the same
dimensions-aware calling logic
- Added comprehensive unit tests in test_universal_api.py
Test: python3 -m py_compile src/memos/embedders/universal_api.py
Test: python3 -m py_compile tests/embedders/test_universal_api.py
---
src/memos/embedders/universal_api.py | 87 ++++++++-----
tests/embedders/test_universal_api.py | 172 ++++++++++++++++++--------
2 files changed, 170 insertions(+), 89 deletions(-)
diff --git a/src/memos/embedders/universal_api.py b/src/memos/embedders/universal_api.py
index 24a022eae..579b9bc93 100644
--- a/src/memos/embedders/universal_api.py
+++ b/src/memos/embedders/universal_api.py
@@ -56,29 +56,56 @@ def __init__(self, config: UniversalAPIEmbedderConfig):
else None,
)
+ @staticmethod
+ def _build_embedding_kwargs(model: str, texts: list[str], embedding_dims: int | None) -> dict:
+ kwargs = {"model": model, "input": texts}
+ if embedding_dims is not None:
+ kwargs["dimensions"] = embedding_dims
+ return kwargs
+
+ def _call_embeddings_api(
+ self, client, model: str, texts: list[str], timeout: int
+ ) -> list[list[float]]:
+ embedding_dims = getattr(self.config, "embedding_dims", None)
+ kwargs = self._build_embedding_kwargs(model, texts, embedding_dims)
+
+ try:
+ response = asyncio.run(
+ asyncio.wait_for(
+ client.embeddings.create(**kwargs),
+ timeout=timeout,
+ )
+ )
+ return [r.embedding for r in response.data]
+ except Exception as e:
+ if embedding_dims is not None:
+ logger.warning(
+ "Embeddings request with dimensions=%d failed error_type=%s; "
+ "retrying without dimensions",
+ embedding_dims,
+ type(e).__name__,
+ )
+ fallback_kwargs = self._build_embedding_kwargs(model, texts, None)
+ response = asyncio.run(
+ asyncio.wait_for(
+ client.embeddings.create(**fallback_kwargs),
+ timeout=timeout,
+ )
+ )
+ return [r.embedding for r in response.data]
+ raise
+
@log_embedding_call
def embed(self, texts: list[str]) -> list[list[float]]:
if isinstance(texts, str):
texts = [texts]
- # Sanitize Unicode to prevent encoding errors with emoji/surrogates
texts = [_sanitize_unicode(t) for t in texts]
- # Truncate texts if max_tokens is configured
texts = self._truncate_texts(texts)
if self.provider == "openai" or self.provider == "azure":
+ timeout = int(os.getenv("MOS_EMBEDDER_TIMEOUT", 5))
try:
-
- async def _create_embeddings():
- return self.client.embeddings.create(
- model=getattr(self.config, "model_name_or_path", "text-embedding-3-large"),
- input=texts,
- )
-
- response = asyncio.run(
- asyncio.wait_for(
- _create_embeddings(), timeout=int(os.getenv("MOS_EMBEDDER_TIMEOUT", 5))
- )
- )
- return [r.embedding for r in response.data]
+ model = getattr(self.config, "model_name_or_path", "text-embedding-3-large")
+ return self._call_embeddings_api(self.client, model, texts, timeout)
except Exception as e:
if self.use_backup_client:
logger.warning(
@@ -86,26 +113,18 @@ async def _create_embeddings():
type(e).__name__,
)
try:
-
- async def _create_embeddings_backup():
- return self.backup_client.embeddings.create(
- model=getattr(
- self.config,
- "backup_model_name_or_path",
- "text-embedding-3-large",
- ),
- input=texts,
- )
-
- response = asyncio.run(
- asyncio.wait_for(
- _create_embeddings_backup(),
- timeout=int(os.getenv("MOS_EMBEDDER_TIMEOUT", 5)),
- )
+ backup_model = getattr(
+ self.config,
+ "backup_model_name_or_path",
+ "text-embedding-3-large",
+ )
+ return self._call_embeddings_api(
+ self.backup_client, backup_model, texts, timeout
)
- return [r.embedding for r in response.data]
- except Exception as e:
- raise ValueError(f"Backup embeddings request ended with error: {e}") from e
+ except Exception as e_backup:
+ raise ValueError(
+ f"Backup embeddings request ended with error: {e_backup}"
+ ) from e_backup
else:
raise ValueError(f"Embeddings request ended with error: {e}") from e
else:
diff --git a/tests/embedders/test_universal_api.py b/tests/embedders/test_universal_api.py
index fd61b3e9a..4568049f0 100644
--- a/tests/embedders/test_universal_api.py
+++ b/tests/embedders/test_universal_api.py
@@ -1,75 +1,137 @@
-import unittest
+"""Tests for UniversalAPIEmbedder."""
-from unittest.mock import MagicMock, patch
+from types import SimpleNamespace
+from unittest.mock import patch
+
+import pytest
from memos.configs.embedder import UniversalAPIEmbedderConfig
from memos.embedders.universal_api import UniversalAPIEmbedder
-class TestUniversalAPIEmbedder(unittest.TestCase):
- @patch("memos.embedders.universal_api.OpenAIClient")
- def test_embed_single_text(self, mock_openai_client):
- """Test embedding a single text with OpenAI provider."""
- # Mock the embeddings.create return value
- mock_response = MagicMock()
- mock_response.data = [MagicMock(embedding=[0.1, 0.2, 0.3, 0.4])]
- mock_openai_client.return_value.embeddings.create.return_value = mock_response
-
- config = UniversalAPIEmbedderConfig(
- provider="openai",
- api_key="fake-api-key",
- base_url="https://api.openai.com/v1",
- model_name_or_path="text-embedding-3-large",
- )
+def _make_config(**overrides):
+ defaults = {
+ "provider": "openai",
+ "api_key": "test-key",
+ "model_name_or_path": "text-embedding-3-large",
+ "embedding_dims": None,
+ }
+ defaults.update(overrides)
+ return UniversalAPIEmbedderConfig(**defaults)
- embedder = UniversalAPIEmbedder(config)
- text = ["Test input for embedding."]
- result = embedder.embed(text)
- # Assert OpenAIClient was created with proper args
- mock_openai_client.assert_called_once_with(
- api_key="fake-api-key", base_url="https://api.openai.com/v1", default_headers=None
+class TestUniversalAPIEmbedderDimensions:
+ def test_build_embedding_kwargs_no_dims(self):
+ kwargs = UniversalAPIEmbedder._build_embedding_kwargs(
+ "text-embedding-3-large", ["hello"], None
)
+ assert kwargs == {"model": "text-embedding-3-large", "input": ["hello"]}
+ assert "dimensions" not in kwargs
- # Assert embeddings.create called with correct params
- embedder.client.embeddings.create.assert_called_once_with(
- model="text-embedding-3-large",
- input=text,
+ def test_build_embedding_kwargs_with_dims(self):
+ kwargs = UniversalAPIEmbedder._build_embedding_kwargs(
+ "text-embedding-3-large", ["hello"], 256
)
+ assert kwargs == {
+ "model": "text-embedding-3-large",
+ "input": ["hello"],
+ "dimensions": 256,
+ }
+
+ def test_build_embedding_kwargs_zero_dims(self):
+ kwargs = UniversalAPIEmbedder._build_embedding_kwargs(
+ "text-embedding-3-large", ["hello"], 0
+ )
+ assert kwargs["dimensions"] == 0
- self.assertEqual(len(result[0]), 4)
-
- @patch("memos.embedders.universal_api.OpenAIClient")
- def test_embed_batch_text(self, mock_openai_client):
- """Test embedding multiple texts at once with OpenAI provider."""
- # Mock response for multiple texts
- mock_response = MagicMock()
- mock_response.data = [
- MagicMock(embedding=[0.1, 0.2]),
- MagicMock(embedding=[0.3, 0.4]),
- MagicMock(embedding=[0.5, 0.6]),
+ @patch.object(UniversalAPIEmbedder, "_call_embeddings_api")
+ def test_embed_passes_embedding_dims_to_api(self, mock_call):
+ mock_call.return_value = [[0.1, 0.2] for _ in ["hello"]]
+ config = _make_config(embedding_dims=256)
+ embedder = UniversalAPIEmbedder(config)
+ embedder.embed(["hello"])
+ mock_call.assert_called_once()
+ call_kwargs = mock_call.call_args[0]
+ assert call_kwargs[2] == ["hello"]
+ assert call_kwargs[1] == "text-embedding-3-large"
+
+ @patch.object(UniversalAPIEmbedder, "_call_embeddings_api")
+ def test_embed_without_dims_does_not_pass_dimensions(self, mock_call):
+ mock_call.return_value = [[0.1, 0.2] for _ in ["hello"]]
+ config = _make_config(embedding_dims=None)
+ embedder = UniversalAPIEmbedder(config)
+ embedder.embed(["hello"])
+ mock_call.assert_called_once()
+
+ @patch.object(UniversalAPIEmbedder, "_call_embeddings_api")
+ def test_embed_with_backup_client(self, mock_call):
+ mock_call.side_effect = [
+ ValueError("primary failed"),
+ [[0.1, 0.2] for _ in ["hello"]],
]
- mock_openai_client.return_value.embeddings.create.return_value = mock_response
-
- config = UniversalAPIEmbedderConfig(
- provider="openai",
- api_key="fake-api-key",
- base_url="https://api.openai.com/v1",
- model_name_or_path="text-embedding-3-large",
+ config = _make_config(
+ embedding_dims=256,
+ backup_client=True,
+ backup_api_key="backup-key",
+ backup_base_url="https://api.example.com",
+ backup_model_name_or_path="text-embedding-3-small",
)
+ embedder = UniversalAPIEmbedder(config)
+ result = embedder.embed(["hello"])
+ assert result == [[0.1, 0.2]]
+ assert mock_call.call_count == 2
+
+ @patch.object(UniversalAPIEmbedder, "_call_embeddings_api")
+ def test_embed_raises_when_no_backup(self, mock_call):
+ mock_call.side_effect = ValueError("primary failed")
+ config = _make_config(embedding_dims=256)
+ embedder = UniversalAPIEmbedder(config)
+ with pytest.raises(ValueError, match="Embeddings request ended with error"):
+ embedder.embed(["hello"])
+
+class TestUniversalAPIEmbedderFallback:
+ def test_call_embeddings_api_falls_back_when_dimensions_not_supported(self):
+ config = _make_config(embedding_dims=256)
embedder = UniversalAPIEmbedder(config)
- texts = ["First text.", "Second text.", "Third text."]
- result = embedder.embed(texts)
- embedder.client.embeddings.create.assert_called_once_with(
- model="text-embedding-3-large",
- input=texts,
- )
+ mock_client = SimpleNamespace()
+ call_count = [0]
+
+ def mock_create(**kwargs):
+ call_count[0] += 1
+ if kwargs.get("dimensions") is not None:
+ raise Exception("dimensions not supported")
+ return SimpleNamespace(data=[SimpleNamespace(embedding=[0.1, 0.2])])
+
+ mock_client.embeddings = SimpleNamespace(create=mock_create)
+
+ with patch("memos.embedders.universal_api.asyncio.run") as mock_run:
+ mock_run.side_effect = lambda x: x # pass-through
+ result = embedder._call_embeddings_api(
+ mock_client, "text-embedding-3-large", ["hello"], 5
+ )
+
+ assert call_count[0] == 2
+ assert result == [[0.1, 0.2]]
+
+ def test_call_embeddings_api_no_fallback_when_dims_not_set(self):
+ config = _make_config(embedding_dims=None)
+ embedder = UniversalAPIEmbedder(config)
+
+ mock_client = SimpleNamespace()
+
+ def mock_create(**kwargs):
+ if kwargs.get("dimensions") is not None:
+ raise AssertionError("dimensions should not be passed when embedding_dims is None")
+ return SimpleNamespace(data=[SimpleNamespace(embedding=[0.1])])
- self.assertEqual(len(result), 3)
- self.assertEqual(result[0], [0.1, 0.2])
+ mock_client.embeddings = SimpleNamespace(create=mock_create)
+ with patch("memos.embedders.universal_api.asyncio.run") as mock_run:
+ mock_run.side_effect = lambda x: x
+ result = embedder._call_embeddings_api(
+ mock_client, "text-embedding-3-large", ["hello"], 5
+ )
-if __name__ == "__main__":
- unittest.main()
+ assert result == [[0.1]]
From 8fca0cea0ace00ddd7866bed1324ec2bc634bc5f Mon Sep 17 00:00:00 2001
From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com>
Date: Fri, 31 Jul 2026 10:04:31 +0800
Subject: [PATCH 06/17] fix(test): use asyncio.wait_for passthrough instead of
asyncio.run mock for universal_api fallback tests
---
tests/embedders/test_universal_api.py | 80 +++++++++++++++++----------
1 file changed, 51 insertions(+), 29 deletions(-)
diff --git a/tests/embedders/test_universal_api.py b/tests/embedders/test_universal_api.py
index 4568049f0..18cab8dd2 100644
--- a/tests/embedders/test_universal_api.py
+++ b/tests/embedders/test_universal_api.py
@@ -1,7 +1,9 @@
"""Tests for UniversalAPIEmbedder."""
+import asyncio
+
from types import SimpleNamespace
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
import pytest
@@ -9,6 +11,10 @@
from memos.embedders.universal_api import UniversalAPIEmbedder
+class _DimensionsUnsupportedError(Exception):
+ """Raised by the mock backend when dimensions are rejected."""
+
+
def _make_config(**overrides):
defaults = {
"provider": "openai",
@@ -44,32 +50,50 @@ def test_build_embedding_kwargs_zero_dims(self):
)
assert kwargs["dimensions"] == 0
- @patch.object(UniversalAPIEmbedder, "_call_embeddings_api")
- def test_embed_passes_embedding_dims_to_api(self, mock_call):
- mock_call.return_value = [[0.1, 0.2] for _ in ["hello"]]
+ @patch("memos.embedders.universal_api.OpenAIClient")
+ def test_embed_passes_embedding_dims_to_api(self, mock_openai_client):
+ mock_response = MagicMock()
+ mock_response.data = [MagicMock(embedding=[0.1, 0.2])]
+ mock_openai_client.return_value.embeddings.create.return_value = mock_response
+
config = _make_config(embedding_dims=256)
embedder = UniversalAPIEmbedder(config)
embedder.embed(["hello"])
- mock_call.assert_called_once()
- call_kwargs = mock_call.call_args[0]
- assert call_kwargs[2] == ["hello"]
- assert call_kwargs[1] == "text-embedding-3-large"
-
- @patch.object(UniversalAPIEmbedder, "_call_embeddings_api")
- def test_embed_without_dims_does_not_pass_dimensions(self, mock_call):
- mock_call.return_value = [[0.1, 0.2] for _ in ["hello"]]
+
+ _, kwargs = mock_openai_client.return_value.embeddings.create.call_args
+ assert kwargs.get("dimensions") == 256
+
+ @patch("memos.embedders.universal_api.OpenAIClient")
+ def test_embed_without_dims_does_not_pass_dimensions(self, mock_openai_client):
+ mock_response = MagicMock()
+ mock_response.data = [MagicMock(embedding=[0.1, 0.2])]
+ mock_openai_client.return_value.embeddings.create.return_value = mock_response
+
config = _make_config(embedding_dims=None)
embedder = UniversalAPIEmbedder(config)
embedder.embed(["hello"])
- mock_call.assert_called_once()
-
- @patch.object(UniversalAPIEmbedder, "_call_embeddings_api")
- def test_embed_with_backup_client(self, mock_call):
- mock_call.side_effect = [
- ValueError("primary failed"),
- [[0.1, 0.2] for _ in ["hello"]],
- ]
+
+ _, kwargs = mock_openai_client.return_value.embeddings.create.call_args
+ assert "dimensions" not in kwargs
+
+ @patch("memos.embedders.universal_api.OpenAIClient")
+ def test_embed_with_backup_client(self, mock_openai_client):
+ primary_client = MagicMock()
+ primary_client.embeddings.create.side_effect = ValueError("down")
+ backup_response = MagicMock()
+ backup_response.data = [MagicMock(embedding=[0.1, 0.2])]
+ backup_client = MagicMock()
+ backup_client.embeddings.create.return_value = backup_response
+
+ def client_factory(api_key, **kwargs):
+ if api_key == "primary":
+ return primary_client
+ return backup_client
+
+ mock_openai_client.side_effect = client_factory
+
config = _make_config(
+ api_key="primary",
embedding_dims=256,
backup_client=True,
backup_api_key="backup-key",
@@ -79,11 +103,11 @@ def test_embed_with_backup_client(self, mock_call):
embedder = UniversalAPIEmbedder(config)
result = embedder.embed(["hello"])
assert result == [[0.1, 0.2]]
- assert mock_call.call_count == 2
+ assert backup_client.embeddings.create.call_count == 1
- @patch.object(UniversalAPIEmbedder, "_call_embeddings_api")
- def test_embed_raises_when_no_backup(self, mock_call):
- mock_call.side_effect = ValueError("primary failed")
+ @patch("memos.embedders.universal_api.OpenAIClient")
+ def test_embed_raises_when_no_backup(self, mock_openai_client):
+ mock_openai_client.return_value.embeddings.create.side_effect = ValueError("primary failed")
config = _make_config(embedding_dims=256)
embedder = UniversalAPIEmbedder(config)
with pytest.raises(ValueError, match="Embeddings request ended with error"):
@@ -101,13 +125,12 @@ def test_call_embeddings_api_falls_back_when_dimensions_not_supported(self):
def mock_create(**kwargs):
call_count[0] += 1
if kwargs.get("dimensions") is not None:
- raise Exception("dimensions not supported")
+ raise _DimensionsUnsupportedError("dimensions not supported")
return SimpleNamespace(data=[SimpleNamespace(embedding=[0.1, 0.2])])
mock_client.embeddings = SimpleNamespace(create=mock_create)
- with patch("memos.embedders.universal_api.asyncio.run") as mock_run:
- mock_run.side_effect = lambda x: x # pass-through
+ with patch.object(asyncio, "wait_for", side_effect=lambda coro, timeout: coro):
result = embedder._call_embeddings_api(
mock_client, "text-embedding-3-large", ["hello"], 5
)
@@ -128,8 +151,7 @@ def mock_create(**kwargs):
mock_client.embeddings = SimpleNamespace(create=mock_create)
- with patch("memos.embedders.universal_api.asyncio.run") as mock_run:
- mock_run.side_effect = lambda x: x
+ with patch.object(asyncio, "wait_for", side_effect=lambda coro, timeout: coro):
result = embedder._call_embeddings_api(
mock_client, "text-embedding-3-large", ["hello"], 5
)
From c30f5fe2483040e1c4c0c9c1b80ef8b1e4e3a3d4 Mon Sep 17 00:00:00 2001
From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com>
Date: Mon, 3 Aug 2026 11:52:43 +0800
Subject: [PATCH 07/17] test(embedder): use AsyncMock for embeddings.create so
asyncio.wait_for can await it
UniversalAPIEmbedder now awaits client.embeddings.create() via asyncio.wait_for,
so the mock must be an async function (AsyncMock) rather than a plain
MagicMock. Introduce _awaitable_response/_mock_embedding_response helpers
and patch embeddings.create at the instance level instead of relying on
the default MagicMock return-value.
---
tests/embedders/test_universal_api.py | 63 +++++++++++++++++++--------
1 file changed, 44 insertions(+), 19 deletions(-)
diff --git a/tests/embedders/test_universal_api.py b/tests/embedders/test_universal_api.py
index 18cab8dd2..259959134 100644
--- a/tests/embedders/test_universal_api.py
+++ b/tests/embedders/test_universal_api.py
@@ -3,7 +3,7 @@
import asyncio
from types import SimpleNamespace
-from unittest.mock import MagicMock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
import pytest
@@ -26,6 +26,26 @@ def _make_config(**overrides):
return UniversalAPIEmbedderConfig(**defaults)
+def _mock_embedding_response(vectors_per_text=1, dims=2):
+ """Build a MagicMock that mimics openai's embeddings response."""
+ response = MagicMock()
+ response.data = [MagicMock(embedding=[0.1 * (i + 1)] * dims) for i in range(vectors_per_text)]
+ return response
+
+
+def _awaitable_response(response):
+ """Wrap a MagicMock response so it can be returned by AsyncMock.
+
+ ``asyncio.wait_for`` awaits its coroutine argument, so the
+ ``embeddings.create`` mock must be an async function (AsyncMock).
+ """
+
+ async def _call(**kwargs):
+ return response
+
+ return AsyncMock(side_effect=_call)
+
+
class TestUniversalAPIEmbedderDimensions:
def test_build_embedding_kwargs_no_dims(self):
kwargs = UniversalAPIEmbedder._build_embedding_kwargs(
@@ -52,38 +72,38 @@ def test_build_embedding_kwargs_zero_dims(self):
@patch("memos.embedders.universal_api.OpenAIClient")
def test_embed_passes_embedding_dims_to_api(self, mock_openai_client):
- mock_response = MagicMock()
- mock_response.data = [MagicMock(embedding=[0.1, 0.2])]
- mock_openai_client.return_value.embeddings.create.return_value = mock_response
+ response = _mock_embedding_response(vectors_per_text=1, dims=2)
+ mock_create = _awaitable_response(response)
+ mock_openai_client.return_value.embeddings.create = mock_create
config = _make_config(embedding_dims=256)
embedder = UniversalAPIEmbedder(config)
embedder.embed(["hello"])
- _, kwargs = mock_openai_client.return_value.embeddings.create.call_args
+ _, kwargs = mock_create.call_args
assert kwargs.get("dimensions") == 256
@patch("memos.embedders.universal_api.OpenAIClient")
def test_embed_without_dims_does_not_pass_dimensions(self, mock_openai_client):
- mock_response = MagicMock()
- mock_response.data = [MagicMock(embedding=[0.1, 0.2])]
- mock_openai_client.return_value.embeddings.create.return_value = mock_response
+ response = _mock_embedding_response(vectors_per_text=1, dims=2)
+ mock_create = _awaitable_response(response)
+ mock_openai_client.return_value.embeddings.create = mock_create
config = _make_config(embedding_dims=None)
embedder = UniversalAPIEmbedder(config)
embedder.embed(["hello"])
- _, kwargs = mock_openai_client.return_value.embeddings.create.call_args
+ _, kwargs = mock_create.call_args
assert "dimensions" not in kwargs
@patch("memos.embedders.universal_api.OpenAIClient")
def test_embed_with_backup_client(self, mock_openai_client):
primary_client = MagicMock()
- primary_client.embeddings.create.side_effect = ValueError("down")
- backup_response = MagicMock()
- backup_response.data = [MagicMock(embedding=[0.1, 0.2])]
+ primary_client.embeddings.create = AsyncMock(side_effect=ValueError("down"))
+ backup_response = _mock_embedding_response(vectors_per_text=1, dims=2)
+ backup_create = _awaitable_response(backup_response)
backup_client = MagicMock()
- backup_client.embeddings.create.return_value = backup_response
+ backup_client.embeddings.create = backup_create
def client_factory(api_key, **kwargs):
if api_key == "primary":
@@ -103,11 +123,14 @@ def client_factory(api_key, **kwargs):
embedder = UniversalAPIEmbedder(config)
result = embedder.embed(["hello"])
assert result == [[0.1, 0.2]]
- assert backup_client.embeddings.create.call_count == 1
+ assert backup_create.await_count == 1
@patch("memos.embedders.universal_api.OpenAIClient")
def test_embed_raises_when_no_backup(self, mock_openai_client):
- mock_openai_client.return_value.embeddings.create.side_effect = ValueError("primary failed")
+ primary_client = MagicMock()
+ primary_client.embeddings.create = AsyncMock(side_effect=ValueError("primary failed"))
+ mock_openai_client.return_value = primary_client
+
config = _make_config(embedding_dims=256)
embedder = UniversalAPIEmbedder(config)
with pytest.raises(ValueError, match="Embeddings request ended with error"):
@@ -121,12 +144,13 @@ def test_call_embeddings_api_falls_back_when_dimensions_not_supported(self):
mock_client = SimpleNamespace()
call_count = [0]
+ ok_response = SimpleNamespace(data=[SimpleNamespace(embedding=[0.1, 0.2])])
- def mock_create(**kwargs):
+ async def mock_create(**kwargs):
call_count[0] += 1
if kwargs.get("dimensions") is not None:
raise _DimensionsUnsupportedError("dimensions not supported")
- return SimpleNamespace(data=[SimpleNamespace(embedding=[0.1, 0.2])])
+ return ok_response
mock_client.embeddings = SimpleNamespace(create=mock_create)
@@ -143,11 +167,12 @@ def test_call_embeddings_api_no_fallback_when_dims_not_set(self):
embedder = UniversalAPIEmbedder(config)
mock_client = SimpleNamespace()
+ ok_response = SimpleNamespace(data=[SimpleNamespace(embedding=[0.1])])
- def mock_create(**kwargs):
+ async def mock_create(**kwargs):
if kwargs.get("dimensions") is not None:
raise AssertionError("dimensions should not be passed when embedding_dims is None")
- return SimpleNamespace(data=[SimpleNamespace(embedding=[0.1])])
+ return ok_response
mock_client.embeddings = SimpleNamespace(create=mock_create)
From b98b8e02d1603944ae9d0cc6f48a8094dfefc6b6 Mon Sep 17 00:00:00 2001
From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com>
Date: Wed, 5 Aug 2026 13:26:19 +0800
Subject: [PATCH 08/17] test(embedder): await fallback API mocks correctly
---
tests/embedders/test_universal_api.py | 17 ++++++-----------
1 file changed, 6 insertions(+), 11 deletions(-)
diff --git a/tests/embedders/test_universal_api.py b/tests/embedders/test_universal_api.py
index 259959134..e0fb53f39 100644
--- a/tests/embedders/test_universal_api.py
+++ b/tests/embedders/test_universal_api.py
@@ -1,7 +1,5 @@
"""Tests for UniversalAPIEmbedder."""
-import asyncio
-
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch
@@ -29,7 +27,10 @@ def _make_config(**overrides):
def _mock_embedding_response(vectors_per_text=1, dims=2):
"""Build a MagicMock that mimics openai's embeddings response."""
response = MagicMock()
- response.data = [MagicMock(embedding=[0.1 * (i + 1)] * dims) for i in range(vectors_per_text)]
+ response.data = [
+ MagicMock(embedding=[0.1 * (dimension + 1) for dimension in range(dims)])
+ for _ in range(vectors_per_text)
+ ]
return response
@@ -154,10 +155,7 @@ async def mock_create(**kwargs):
mock_client.embeddings = SimpleNamespace(create=mock_create)
- with patch.object(asyncio, "wait_for", side_effect=lambda coro, timeout: coro):
- result = embedder._call_embeddings_api(
- mock_client, "text-embedding-3-large", ["hello"], 5
- )
+ result = embedder._call_embeddings_api(mock_client, "text-embedding-3-large", ["hello"], 5)
assert call_count[0] == 2
assert result == [[0.1, 0.2]]
@@ -176,9 +174,6 @@ async def mock_create(**kwargs):
mock_client.embeddings = SimpleNamespace(create=mock_create)
- with patch.object(asyncio, "wait_for", side_effect=lambda coro, timeout: coro):
- result = embedder._call_embeddings_api(
- mock_client, "text-embedding-3-large", ["hello"], 5
- )
+ result = embedder._call_embeddings_api(mock_client, "text-embedding-3-large", ["hello"], 5)
assert result == [[0.1]]
From ab322aa2841a72b08176d3263ea2ff3dd77a00ba Mon Sep 17 00:00:00 2001
From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com>
Date: Wed, 5 Aug 2026 13:48:38 +0800
Subject: [PATCH 09/17] test(embedder): isolate Ark factory tests from optional
SDK
---
tests/embedders/test_ark.py | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/tests/embedders/test_ark.py b/tests/embedders/test_ark.py
index 08c23aae6..991d173bd 100644
--- a/tests/embedders/test_ark.py
+++ b/tests/embedders/test_ark.py
@@ -7,8 +7,9 @@
class TestEmbedderFactory(unittest.TestCase):
+ @patch.object(ArkEmbedder, "__init__", return_value=None)
@patch.object(ArkEmbedder, "embed")
- def test_embed_single_text(self, mock_embed):
+ def test_embed_single_text(self, mock_embed, _mock_init):
"""Test embedding a single text."""
mock_embed.return_value = [[0.1, 0.2, 0.3, 0.4, 0.5, 0.6]]
@@ -30,8 +31,9 @@ def test_embed_single_text(self, mock_embed):
mock_embed.assert_called_once_with([text])
self.assertEqual(len(result[0]), 6)
+ @patch.object(ArkEmbedder, "__init__", return_value=None)
@patch.object(ArkEmbedder, "embed")
- def test_embed_batch_text(self, mock_embed):
+ def test_embed_batch_text(self, mock_embed, _mock_init):
"""Test embedding multiple texts at once."""
mock_embed.return_value = [
[0.1, 0.2, 0.3, 0.4, 0.5, 0.6],
From ddb60d6475144ae58fe0ed1d00344d46e99714ac Mon Sep 17 00:00:00 2001
From: JiataiWang
Date: Wed, 5 Aug 2026 18:10:29 -0700
Subject: [PATCH 10/17] fix(llm): preserve all vllm stream chunks
---
src/memos/llms/vllm.py | 16 +++++++----
tests/llms/test_vllm.py | 61 +++++++++++++++++++++++++++++++++++++++++
2 files changed, 71 insertions(+), 6 deletions(-)
create mode 100644 tests/llms/test_vllm.py
diff --git a/src/memos/llms/vllm.py b/src/memos/llms/vllm.py
index 0efead97b..ff3fd41d5 100644
--- a/src/memos/llms/vllm.py
+++ b/src/memos/llms/vllm.py
@@ -1,5 +1,6 @@
import json
+from collections.abc import Generator
from typing import Any, cast
import openai
@@ -152,7 +153,7 @@ def _messages_to_prompt(self, messages: list[MessageDict]) -> str:
prompt_parts.append(f"{role.capitalize()}: {content}")
return "\n".join(prompt_parts)
- def generate_stream(self, messages: list[MessageDict], **kwargs):
+ def generate_stream(self, messages: list[MessageDict], **kwargs) -> Generator[str, None, None]:
"""
Generate a response from the model using streaming.
Yields content chunks as they are received.
@@ -185,11 +186,14 @@ def generate_stream(self, messages: list[MessageDict], **kwargs):
reasoning_started = True
yield delta.reasoning
- if hasattr(delta, "content") and delta.content:
- if reasoning_started and not self.config.remove_think_prefix:
- yield ""
- reasoning_started = False
- yield delta.content
+ if hasattr(delta, "content") and delta.content:
+ if reasoning_started and not self.config.remove_think_prefix:
+ yield ""
+ reasoning_started = False
+ yield delta.content
+
+ if reasoning_started and not self.config.remove_think_prefix:
+ yield ""
else:
raise RuntimeError("API client is not available")
diff --git a/tests/llms/test_vllm.py b/tests/llms/test_vllm.py
new file mode 100644
index 000000000..24dfe27c2
--- /dev/null
+++ b/tests/llms/test_vllm.py
@@ -0,0 +1,61 @@
+import unittest
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+from memos.configs.llm import VLLMLLMConfig
+from memos.llms.vllm import VLLMLLM
+
+
+class TestVLLMLLMGenerateStream(unittest.TestCase):
+ def setUp(self):
+ config = VLLMLLMConfig(
+ model_name_or_path="test-model",
+ api_key="test-key",
+ remove_think_prefix=False,
+ )
+ self.llm = VLLMLLM(config)
+ self.messages = [{"role": "user", "content": "Think, then answer"}]
+
+ @staticmethod
+ def make_chunk(**delta_fields):
+ delta = SimpleNamespace(**delta_fields)
+ return SimpleNamespace(choices=[SimpleNamespace(delta=delta)])
+
+ def generate_chunks(self, stream_chunks):
+ self.llm.client.chat.completions.create = MagicMock(return_value=iter(stream_chunks))
+ return list(self.llm.generate_stream(self.messages))
+
+ def test_yields_every_content_chunk_after_reasoning(self):
+ stream_chunks = [
+ self.make_chunk(reasoning="Considering..."),
+ self.make_chunk(content="Hello"),
+ self.make_chunk(content=", "),
+ self.make_chunk(content="world!"),
+ ]
+
+ self.assertEqual(
+ self.generate_chunks(stream_chunks),
+ ["", "Considering...", "", "Hello", ", ", "world!"],
+ )
+
+ def test_empty_or_choiceless_stream_returns_no_chunks(self):
+ streams = {
+ "empty": [],
+ "choices_empty": [SimpleNamespace(choices=[])],
+ }
+
+ for name, stream_chunks in streams.items():
+ with self.subTest(name=name):
+ self.assertEqual(self.generate_chunks(stream_chunks), [])
+
+ def test_reasoning_only_stream_closes_think_block(self):
+ stream_chunks = [
+ self.make_chunk(reasoning="First thought. "),
+ self.make_chunk(reasoning="Second thought."),
+ ]
+
+ self.assertEqual(
+ self.generate_chunks(stream_chunks),
+ ["", "First thought. ", "Second thought.", ""],
+ )
From 9ee2711c9f1e27d0734aafc6a3818f3a1b2b6a59 Mon Sep 17 00:00:00 2001
From: JiataiWang
Date: Mon, 10 Aug 2026 01:58:51 -0700
Subject: [PATCH 11/17] test(llm): cover vllm streams without think tags
---
tests/llms/test_vllm.py | 17 +++++++++++++++++
1 file changed, 17 insertions(+)
diff --git a/tests/llms/test_vllm.py b/tests/llms/test_vllm.py
index 24dfe27c2..830196f48 100644
--- a/tests/llms/test_vllm.py
+++ b/tests/llms/test_vllm.py
@@ -59,3 +59,20 @@ def test_reasoning_only_stream_closes_think_block(self):
self.generate_chunks(stream_chunks),
["", "First thought. ", "Second thought.", ""],
)
+
+ def test_remove_think_prefix_omits_tags(self):
+ self.llm.config.remove_think_prefix = True
+ streams = {
+ "reasoning_then_content": (
+ [self.make_chunk(reasoning="Thinking."), self.make_chunk(content="Answer")],
+ ["Thinking.", "Answer"],
+ ),
+ "reasoning_only": (
+ [self.make_chunk(reasoning="Thinking.")],
+ ["Thinking."],
+ ),
+ }
+
+ for name, (stream_chunks, expected) in streams.items():
+ with self.subTest(name=name):
+ self.assertEqual(self.generate_chunks(stream_chunks), expected)
From 0f5ed1b17f3672915da3bc65bd4ee24f5353cdc3 Mon Sep 17 00:00:00 2001
From: Wenqiang Wei <46308778+endxxxx@users.noreply.github.com>
Date: Tue, 11 Aug 2026 14:43:02 +0800
Subject: [PATCH 12/17] fix: handle embedding dimensions with sync client
---
src/memos/api/config.py | 1 +
src/memos/embedders/universal_api.py | 52 ++++++------
tests/embedders/test_universal_api.py | 115 ++++++++++++++++----------
3 files changed, 101 insertions(+), 67 deletions(-)
diff --git a/src/memos/api/config.py b/src/memos/api/config.py
index 43ad586dd..7b450181a 100644
--- a/src/memos/api/config.py
+++ b/src/memos/api/config.py
@@ -622,6 +622,7 @@ def get_embedder_config() -> dict[str, Any]:
"provider": os.getenv("MOS_EMBEDDER_PROVIDER", "openai"),
"api_key": os.getenv("MOS_EMBEDDER_API_KEY", "sk-xxxx"),
"model_name_or_path": os.getenv("MOS_EMBEDDER_MODEL", "text-embedding-3-large"),
+ "embedding_dims": int(os.getenv("EMBEDDING_DIMENSION", "1024")),
"headers_extra": json.loads(os.getenv("MOS_EMBEDDER_HEADERS_EXTRA", "{}")),
"base_url": os.getenv("MOS_EMBEDDER_API_BASE", "http://openai.com"),
"backup_client": os.getenv("MOS_EMBEDDER_BACKUP_CLIENT", "false").lower()
diff --git a/src/memos/embedders/universal_api.py b/src/memos/embedders/universal_api.py
index 579b9bc93..44cc1e3cb 100644
--- a/src/memos/embedders/universal_api.py
+++ b/src/memos/embedders/universal_api.py
@@ -1,7 +1,7 @@
-import asyncio
import os
from openai import AzureOpenAI as AzureClient
+from openai import BadRequestError
from openai import OpenAI as OpenAIClient
from memos.configs.embedder import UniversalAPIEmbedderConfig
@@ -63,6 +63,21 @@ def _build_embedding_kwargs(model: str, texts: list[str], embedding_dims: int |
kwargs["dimensions"] = embedding_dims
return kwargs
+ @staticmethod
+ def _is_dimensions_unsupported(error: BadRequestError) -> bool:
+ message = str(error).lower()
+ unsupported_markers = (
+ "dimensions is not supported",
+ "dimensions not supported",
+ "does not support dimensions",
+ "unsupported parameter: dimensions",
+ "unknown parameter: dimensions",
+ "does not support matryoshka",
+ "changing output dimensions is unsupported",
+ "changing output dimensions will lead",
+ )
+ return any(marker in message for marker in unsupported_markers)
+
def _call_embeddings_api(
self, client, model: str, texts: list[str], timeout: int
) -> list[list[float]]:
@@ -70,30 +85,19 @@ def _call_embeddings_api(
kwargs = self._build_embedding_kwargs(model, texts, embedding_dims)
try:
- response = asyncio.run(
- asyncio.wait_for(
- client.embeddings.create(**kwargs),
- timeout=timeout,
- )
+ response = client.embeddings.create(**kwargs, timeout=timeout)
+ except BadRequestError as error:
+ if embedding_dims is None or not self._is_dimensions_unsupported(error):
+ raise
+
+ logger.warning(
+ "Embedding provider rejected dimensions=%d; retrying without dimensions",
+ embedding_dims,
)
- return [r.embedding for r in response.data]
- except Exception as e:
- if embedding_dims is not None:
- logger.warning(
- "Embeddings request with dimensions=%d failed error_type=%s; "
- "retrying without dimensions",
- embedding_dims,
- type(e).__name__,
- )
- fallback_kwargs = self._build_embedding_kwargs(model, texts, None)
- response = asyncio.run(
- asyncio.wait_for(
- client.embeddings.create(**fallback_kwargs),
- timeout=timeout,
- )
- )
- return [r.embedding for r in response.data]
- raise
+ fallback_kwargs = self._build_embedding_kwargs(model, texts, None)
+ response = client.embeddings.create(**fallback_kwargs, timeout=timeout)
+
+ return [item.embedding for item in response.data]
@log_embedding_call
def embed(self, texts: list[str]) -> list[list[float]]:
diff --git a/tests/embedders/test_universal_api.py b/tests/embedders/test_universal_api.py
index e0fb53f39..394770787 100644
--- a/tests/embedders/test_universal_api.py
+++ b/tests/embedders/test_universal_api.py
@@ -1,18 +1,17 @@
"""Tests for UniversalAPIEmbedder."""
from types import SimpleNamespace
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import MagicMock, patch
+import httpx
import pytest
+from openai import APITimeoutError, BadRequestError
+
from memos.configs.embedder import UniversalAPIEmbedderConfig
from memos.embedders.universal_api import UniversalAPIEmbedder
-class _DimensionsUnsupportedError(Exception):
- """Raised by the mock backend when dimensions are rejected."""
-
-
def _make_config(**overrides):
defaults = {
"provider": "openai",
@@ -34,17 +33,10 @@ def _mock_embedding_response(vectors_per_text=1, dims=2):
return response
-def _awaitable_response(response):
- """Wrap a MagicMock response so it can be returned by AsyncMock.
-
- ``asyncio.wait_for`` awaits its coroutine argument, so the
- ``embeddings.create`` mock must be an async function (AsyncMock).
- """
-
- async def _call(**kwargs):
- return response
-
- return AsyncMock(side_effect=_call)
+def _bad_request_error(message: str) -> BadRequestError:
+ request = httpx.Request("POST", "https://api.example.com/v1/embeddings")
+ response = httpx.Response(400, request=request)
+ return BadRequestError(message, response=response, body={"error": {"message": message}})
class TestUniversalAPIEmbedderDimensions:
@@ -74,35 +66,39 @@ def test_build_embedding_kwargs_zero_dims(self):
@patch("memos.embedders.universal_api.OpenAIClient")
def test_embed_passes_embedding_dims_to_api(self, mock_openai_client):
response = _mock_embedding_response(vectors_per_text=1, dims=2)
- mock_create = _awaitable_response(response)
+ mock_create = MagicMock(return_value=response)
mock_openai_client.return_value.embeddings.create = mock_create
config = _make_config(embedding_dims=256)
embedder = UniversalAPIEmbedder(config)
- embedder.embed(["hello"])
+ result = embedder.embed(["hello"])
_, kwargs = mock_create.call_args
assert kwargs.get("dimensions") == 256
+ assert kwargs.get("timeout") == 5
+ assert result == [[0.1, 0.2]]
@patch("memos.embedders.universal_api.OpenAIClient")
def test_embed_without_dims_does_not_pass_dimensions(self, mock_openai_client):
response = _mock_embedding_response(vectors_per_text=1, dims=2)
- mock_create = _awaitable_response(response)
+ mock_create = MagicMock(return_value=response)
mock_openai_client.return_value.embeddings.create = mock_create
config = _make_config(embedding_dims=None)
embedder = UniversalAPIEmbedder(config)
- embedder.embed(["hello"])
+ result = embedder.embed(["hello"])
_, kwargs = mock_create.call_args
assert "dimensions" not in kwargs
+ assert kwargs.get("timeout") == 5
+ assert result == [[0.1, 0.2]]
@patch("memos.embedders.universal_api.OpenAIClient")
def test_embed_with_backup_client(self, mock_openai_client):
primary_client = MagicMock()
- primary_client.embeddings.create = AsyncMock(side_effect=ValueError("down"))
+ primary_client.embeddings.create = MagicMock(side_effect=ValueError("down"))
backup_response = _mock_embedding_response(vectors_per_text=1, dims=2)
- backup_create = _awaitable_response(backup_response)
+ backup_create = MagicMock(return_value=backup_response)
backup_client = MagicMock()
backup_client.embeddings.create = backup_create
@@ -124,12 +120,13 @@ def client_factory(api_key, **kwargs):
embedder = UniversalAPIEmbedder(config)
result = embedder.embed(["hello"])
assert result == [[0.1, 0.2]]
- assert backup_create.await_count == 1
+ assert primary_client.embeddings.create.call_count == 1
+ assert backup_create.call_count == 1
@patch("memos.embedders.universal_api.OpenAIClient")
def test_embed_raises_when_no_backup(self, mock_openai_client):
primary_client = MagicMock()
- primary_client.embeddings.create = AsyncMock(side_effect=ValueError("primary failed"))
+ primary_client.embeddings.create = MagicMock(side_effect=ValueError("primary failed"))
mock_openai_client.return_value = primary_client
config = _make_config(embedding_dims=256)
@@ -143,37 +140,69 @@ def test_call_embeddings_api_falls_back_when_dimensions_not_supported(self):
config = _make_config(embedding_dims=256)
embedder = UniversalAPIEmbedder(config)
- mock_client = SimpleNamespace()
- call_count = [0]
ok_response = SimpleNamespace(data=[SimpleNamespace(embedding=[0.1, 0.2])])
-
- async def mock_create(**kwargs):
- call_count[0] += 1
- if kwargs.get("dimensions") is not None:
- raise _DimensionsUnsupportedError("dimensions not supported")
- return ok_response
-
- mock_client.embeddings = SimpleNamespace(create=mock_create)
+ mock_create = MagicMock(
+ side_effect=[
+ _bad_request_error("dimensions is not supported by this model"),
+ ok_response,
+ ]
+ )
+ mock_client = SimpleNamespace(embeddings=SimpleNamespace(create=mock_create))
result = embedder._call_embeddings_api(mock_client, "text-embedding-3-large", ["hello"], 5)
- assert call_count[0] == 2
+ assert mock_create.call_count == 2
+ assert mock_create.call_args_list[0].kwargs["dimensions"] == 256
+ assert "dimensions" not in mock_create.call_args_list[1].kwargs
+ assert all(call.kwargs["timeout"] == 5 for call in mock_create.call_args_list)
assert result == [[0.1, 0.2]]
+ def test_call_embeddings_api_does_not_fallback_on_timeout(self):
+ config = _make_config(embedding_dims=256)
+ embedder = UniversalAPIEmbedder(config)
+ request = httpx.Request("POST", "https://api.example.com/v1/embeddings")
+ mock_create = MagicMock(side_effect=APITimeoutError(request=request))
+ mock_client = SimpleNamespace(embeddings=SimpleNamespace(create=mock_create))
+
+ with pytest.raises(APITimeoutError):
+ embedder._call_embeddings_api(mock_client, "text-embedding-3-large", ["hello"], 5)
+
+ assert mock_create.call_count == 1
+
+ def test_call_embeddings_api_does_not_fallback_on_unrelated_bad_request(self):
+ config = _make_config(embedding_dims=256)
+ embedder = UniversalAPIEmbedder(config)
+ mock_create = MagicMock(side_effect=_bad_request_error("input must not be empty"))
+ mock_client = SimpleNamespace(embeddings=SimpleNamespace(create=mock_create))
+
+ with pytest.raises(BadRequestError, match="input must not be empty"):
+ embedder._call_embeddings_api(mock_client, "text-embedding-3-large", ["hello"], 5)
+
+ assert mock_create.call_count == 1
+
+ def test_call_embeddings_api_does_not_fallback_on_invalid_dimensions(self):
+ config = _make_config(embedding_dims=0)
+ embedder = UniversalAPIEmbedder(config)
+ mock_create = MagicMock(
+ side_effect=_bad_request_error("dimensions must be greater than zero")
+ )
+ mock_client = SimpleNamespace(embeddings=SimpleNamespace(create=mock_create))
+
+ with pytest.raises(BadRequestError, match="dimensions must be greater than zero"):
+ embedder._call_embeddings_api(mock_client, "text-embedding-3-large", ["hello"], 5)
+
+ assert mock_create.call_count == 1
+
def test_call_embeddings_api_no_fallback_when_dims_not_set(self):
config = _make_config(embedding_dims=None)
embedder = UniversalAPIEmbedder(config)
- mock_client = SimpleNamespace()
ok_response = SimpleNamespace(data=[SimpleNamespace(embedding=[0.1])])
-
- async def mock_create(**kwargs):
- if kwargs.get("dimensions") is not None:
- raise AssertionError("dimensions should not be passed when embedding_dims is None")
- return ok_response
-
- mock_client.embeddings = SimpleNamespace(create=mock_create)
+ mock_create = MagicMock(return_value=ok_response)
+ mock_client = SimpleNamespace(embeddings=SimpleNamespace(create=mock_create))
result = embedder._call_embeddings_api(mock_client, "text-embedding-3-large", ["hello"], 5)
+ assert "dimensions" not in mock_create.call_args.kwargs
+ assert mock_create.call_args.kwargs["timeout"] == 5
assert result == [[0.1]]
From c826169da57ff20b03b0155dba4006d2494a7e03 Mon Sep 17 00:00:00 2001
From: Wenqiang Wei <46308778+endxxxx@users.noreply.github.com>
Date: Tue, 11 Aug 2026 15:45:55 +0800
Subject: [PATCH 13/17] fix: make cachetools a core dependency
---
poetry.lock | 7 +++----
pyproject.toml | 2 +-
2 files changed, 4 insertions(+), 5 deletions(-)
diff --git a/poetry.lock b/poetry.lock
index b09a72d70..915204888 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -174,10 +174,9 @@ transformers = ">=3.0.0"
name = "cachetools"
version = "6.2.1"
description = "Extensible memoizing collections and decorators"
-optional = true
+optional = false
python-versions = ">=3.9"
groups = ["main"]
-markers = "extra == \"all\""
files = [
{file = "cachetools-6.2.1-py3-none-any.whl", hash = "sha256:09868944b6dde876dfd44e1d47e18484541eaf12f26f29b7af91b26cc892d701"},
{file = "cachetools-6.2.1.tar.gz", hash = "sha256:3f391e4bd8f8bf0931169baf7456cc822705f4e2a31f840d218f445b9a854201"},
@@ -6636,7 +6635,7 @@ cffi = {version = ">=1.11", markers = "platform_python_implementation == \"PyPy\
cffi = ["cffi (>=1.11)"]
[extras]
-all = ["alibabacloud-oss-v2", "cachetools", "chonkie", "datasketch", "jieba", "langchain-text-splitters", "markitdown", "neo4j", "nltk", "pika", "pymilvus", "pymysql", "qdrant-client", "rake-nltk", "rank-bm25", "redis", "schedule", "sentence-transformers", "tavily-python", "torch", "volcengine-python-sdk"]
+all = ["alibabacloud-oss-v2", "chonkie", "datasketch", "jieba", "langchain-text-splitters", "markitdown", "neo4j", "nltk", "pika", "pymilvus", "pymysql", "qdrant-client", "rake-nltk", "rank-bm25", "redis", "schedule", "sentence-transformers", "tavily-python", "torch", "volcengine-python-sdk"]
mem-reader = ["chonkie", "langchain-text-splitters", "markitdown"]
mem-scheduler = ["pika", "redis"]
mem-user = ["pymysql"]
@@ -6648,4 +6647,4 @@ tree-mem = ["neo4j", "schedule"]
[metadata]
lock-version = "2.1"
python-versions = ">=3.10,<4.0"
-content-hash = "cfab703c19f5f87caf537b68d30174695c44c6fc228e42c2c8e71b00b81f5790"
+content-hash = "0e134b24ee590115ac3270590a002fa7d54f4e4d83a9eabf53715ec03716e081"
diff --git a/pyproject.toml b/pyproject.toml
index 3eaf00ca3..0e572b103 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -48,6 +48,7 @@ dependencies = [
"python-dateutil (>=2.9.0.post0,<3.0.0)",
"prometheus-client (>=0.23.1,<0.24.0)",
"concurrent-log-handler (>=0.9.28,<1.0.0)", # Process-safe rotating file handler
+ "cachetools (>=6.0.0)", # Embedding request caching
]
[project.urls]
@@ -128,7 +129,6 @@ all = [
"datasketch (>=1.6.5,<2.0.0)",
"jieba (>=0.38.1,<0.42.1)",
"rank-bm25 (>=0.2.2)",
- "cachetools (>=6.0.0)",
# NOT exist in the above optional groups
# Because they are either huge-size dependencies or infrequently used dependencies.
# We kindof don't want users to install them.
From 355d758335b6e6c2463ac40ecf3841ab4b4ef3d4 Mon Sep 17 00:00:00 2001
From: Wenqiang Wei <46308778+endxxxx@users.noreply.github.com>
Date: Tue, 11 Aug 2026 17:24:09 +0800
Subject: [PATCH 14/17] fix(llm): pass thinking flag via extra body
---
src/memos/configs/llm.py | 6 ++
src/memos/llms/openai.py | 53 +++++------
tests/llms/test_enable_thinking.py | 143 +++++++++++++++++++++++++++--
3 files changed, 164 insertions(+), 38 deletions(-)
diff --git a/src/memos/configs/llm.py b/src/memos/configs/llm.py
index 627a7daed..ef441b37f 100644
--- a/src/memos/configs/llm.py
+++ b/src/memos/configs/llm.py
@@ -96,6 +96,12 @@ class AzureLLMConfig(BaseLLMConfig):
description="API version for Azure OpenAI",
)
api_key: str = Field(..., description="API key for Azure OpenAI")
+ extra_body: Any = Field(default=None, description="Extra request body parameters")
+ enable_thinking: bool | None = Field(
+ default=None,
+ description="Enable/disable thinking mode for models that support it. "
+ "When None (default), the provider's default behavior is preserved.",
+ )
class AzureResponsesLLMConfig(BaseLLMConfig):
diff --git a/src/memos/llms/openai.py b/src/memos/llms/openai.py
index cf5302552..d01c56726 100644
--- a/src/memos/llms/openai.py
+++ b/src/memos/llms/openai.py
@@ -2,6 +2,7 @@
import time
from collections.abc import Generator
+from typing import Any
import openai
@@ -19,6 +20,13 @@
logger = get_logger(__name__)
+def _merge_enable_thinking(extra_body: Any, enable_thinking: bool | None) -> Any:
+ """Merge provider-specific thinking control into the SDK's extra request body."""
+ if enable_thinking is None:
+ return extra_body
+ return {**(extra_body or {}), "enable_thinking": enable_thinking}
+
+
class OpenAILLM(BaseLLM):
"""OpenAI LLM class via openai.chat.completions.create."""
@@ -62,18 +70,19 @@ def _parse_response(self, response) -> str:
return response_content or ""
def _build_request_body(self, messages: MessageList, **kwargs) -> dict:
+ enable_thinking = kwargs.get("enable_thinking", self.config.enable_thinking)
+ extra_body = _merge_enable_thinking(
+ kwargs.get("extra_body", self.config.extra_body), enable_thinking
+ )
request_body = {
"model": kwargs.get("model_name_or_path", self.config.model_name_or_path),
"messages": messages,
"temperature": kwargs.get("temperature", self.config.temperature),
"max_tokens": kwargs.get("max_tokens", self.config.max_tokens),
"top_p": kwargs.get("top_p", self.config.top_p),
- "extra_body": kwargs.get("extra_body", self.config.extra_body),
+ "extra_body": extra_body,
"tools": kwargs.get("tools", NOT_GIVEN),
}
- enable_thinking = kwargs.get("enable_thinking", self.config.enable_thinking)
- if enable_thinking is not None:
- request_body["enable_thinking"] = enable_thinking
return request_body
@timed_with_status(
@@ -128,20 +137,8 @@ def generate_stream(self, messages: MessageList, **kwargs) -> Generator[str, Non
logger.info("stream api not support tools")
return
- request_body = {
- "model": self.config.model_name_or_path,
- "messages": messages,
- "stream": True,
- "temperature": kwargs.get("temperature", self.config.temperature),
- "max_tokens": kwargs.get("max_tokens", self.config.max_tokens),
- "top_p": kwargs.get("top_p", self.config.top_p),
- "extra_body": kwargs.get("extra_body", self.config.extra_body),
- "tools": kwargs.get("tools", NOT_GIVEN),
- }
-
- enable_thinking = kwargs.get("enable_thinking", self.config.enable_thinking)
- if enable_thinking is not None:
- request_body["enable_thinking"] = enable_thinking
+ request_body = self._build_request_body(messages, **kwargs)
+ request_body["stream"] = True
logger.info(f"OpenAI LLM Stream Request body: {request_body}")
response = self.client.chat.completions.create(**request_body)
@@ -195,6 +192,7 @@ def __init__(self, config: AzureLLMConfig):
def generate(self, messages: MessageList, **kwargs) -> str:
"""Generate a response from Azure OpenAI LLM."""
+ enable_thinking = kwargs.get("enable_thinking", self.config.enable_thinking)
request_body = {
"model": self.config.model_name_or_path,
"messages": messages,
@@ -202,13 +200,10 @@ def generate(self, messages: MessageList, **kwargs) -> str:
"max_tokens": kwargs.get("max_tokens", self.config.max_tokens),
"top_p": kwargs.get("top_p", self.config.top_p),
"tools": kwargs.get("tools", NOT_GIVEN),
- "extra_body": kwargs.get("extra_body", self.config.extra_body),
+ "extra_body": _merge_enable_thinking(
+ kwargs.get("extra_body", self.config.extra_body), enable_thinking
+ ),
}
- enable_thinking = kwargs.get(
- "enable_thinking", getattr(self.config, "enable_thinking", None)
- )
- if enable_thinking is not None:
- request_body["enable_thinking"] = enable_thinking
response = self.client.chat.completions.create(**request_body)
logger.info(f"Response from Azure OpenAI: {response.model_dump_json()}")
if not response.choices:
@@ -229,6 +224,7 @@ def generate_stream(self, messages: MessageList, **kwargs) -> Generator[str, Non
logger.info("stream api not support tools")
return
+ enable_thinking = kwargs.get("enable_thinking", self.config.enable_thinking)
request_body = {
"model": self.config.model_name_or_path,
"messages": messages,
@@ -236,13 +232,10 @@ def generate_stream(self, messages: MessageList, **kwargs) -> Generator[str, Non
"temperature": kwargs.get("temperature", self.config.temperature),
"max_tokens": kwargs.get("max_tokens", self.config.max_tokens),
"top_p": kwargs.get("top_p", self.config.top_p),
- "extra_body": kwargs.get("extra_body", self.config.extra_body),
+ "extra_body": _merge_enable_thinking(
+ kwargs.get("extra_body", self.config.extra_body), enable_thinking
+ ),
}
- enable_thinking = kwargs.get(
- "enable_thinking", getattr(self.config, "enable_thinking", None)
- )
- if enable_thinking is not None:
- request_body["enable_thinking"] = enable_thinking
response = self.client.chat.completions.create(**request_body)
reasoning_started = False
diff --git a/tests/llms/test_enable_thinking.py b/tests/llms/test_enable_thinking.py
index 0ad34e5f3..46f3c5063 100644
--- a/tests/llms/test_enable_thinking.py
+++ b/tests/llms/test_enable_thinking.py
@@ -1,7 +1,12 @@
-"""Tests for enable_thinking parameter in OpenAILLM."""
+"""Tests for enable_thinking parameter in OpenAI-compatible LLMs."""
-from memos.configs.llm import OpenAILLMConfig
-from memos.llms.openai import OpenAILLM
+import json
+
+import httpx
+import openai
+
+from memos.configs.llm import AzureLLMConfig, OpenAILLMConfig
+from memos.llms.openai import AzureLLM, OpenAILLM
def _make_config(**overrides):
@@ -26,6 +31,14 @@ def test_enable_thinking_false(self):
config = _make_config(enable_thinking=False)
assert config.enable_thinking is False
+ def test_azure_enable_thinking_can_be_set(self):
+ config = AzureLLMConfig(
+ api_key="test-key",
+ model_name_or_path="test-model",
+ enable_thinking=True,
+ )
+ assert config.enable_thinking is True
+
class TestEnableThinkingInRequest:
def test_build_request_body_without_enable_thinking(self):
@@ -34,7 +47,7 @@ def test_build_request_body_without_enable_thinking(self):
embedder.config = config
body = embedder._build_request_body([{"role": "user", "content": "hi"}])
- assert "enable_thinking" not in body
+ assert body["extra_body"] is None
def test_build_request_body_with_enable_thinking_from_config(self):
config = _make_config(enable_thinking=True)
@@ -42,7 +55,7 @@ def test_build_request_body_with_enable_thinking_from_config(self):
embedder.config = config
body = embedder._build_request_body([{"role": "user", "content": "hi"}])
- assert body["enable_thinking"] is True
+ assert body["extra_body"]["enable_thinking"] is True
def test_build_request_body_with_enable_thinking_from_kwargs(self):
config = _make_config(enable_thinking=True)
@@ -52,7 +65,7 @@ def test_build_request_body_with_enable_thinking_from_kwargs(self):
body = embedder._build_request_body(
[{"role": "user", "content": "hi"}], enable_thinking=False
)
- assert body["enable_thinking"] is False
+ assert body["extra_body"]["enable_thinking"] is False
def test_build_request_body_with_enable_thinking_false(self):
config = _make_config(enable_thinking=False)
@@ -60,7 +73,7 @@ def test_build_request_body_with_enable_thinking_false(self):
embedder.config = config
body = embedder._build_request_body([{"role": "user", "content": "hi"}])
- assert body["enable_thinking"] is False
+ assert body["extra_body"]["enable_thinking"] is False
def test_build_request_body_preserves_other_params(self):
config = _make_config(enable_thinking=True, temperature=0.5, max_tokens=100)
@@ -68,7 +81,121 @@ def test_build_request_body_preserves_other_params(self):
embedder.config = config
body = embedder._build_request_body([{"role": "user", "content": "hi"}])
- assert body["enable_thinking"] is True
+ assert body["extra_body"]["enable_thinking"] is True
assert body["temperature"] == 0.5
assert body["max_tokens"] == 100
assert body["model"] == "gpt-4o"
+
+ def test_build_request_body_preserves_existing_extra_body(self):
+ config = _make_config(
+ enable_thinking=False,
+ extra_body={"chat_template_kwargs": {"foo": "bar"}},
+ )
+ llm = OpenAILLM.__new__(OpenAILLM)
+ llm.config = config
+
+ body = llm._build_request_body([{"role": "user", "content": "hi"}])
+
+ assert body["extra_body"] == {
+ "chat_template_kwargs": {"foo": "bar"},
+ "enable_thinking": False,
+ }
+
+
+class TestEnableThinkingWithRealSDK:
+ @staticmethod
+ def _make_llm(handler, *, enable_thinking):
+ config = _make_config(
+ api_base="http://test.local/v1",
+ enable_thinking=enable_thinking,
+ )
+ llm = OpenAILLM(config)
+ llm.client = openai.Client(
+ api_key="test-key",
+ base_url="http://test.local/v1",
+ http_client=httpx.Client(transport=httpx.MockTransport(handler)),
+ )
+ return llm
+
+ def test_generate_serializes_enable_thinking_in_http_body(self):
+ captured_body = {}
+
+ def handler(request):
+ captured_body.update(json.loads(request.content))
+ return httpx.Response(
+ 200,
+ json={
+ "id": "chatcmpl-test",
+ "object": "chat.completion",
+ "created": 0,
+ "model": "test-model",
+ "choices": [
+ {
+ "index": 0,
+ "finish_reason": "stop",
+ "message": {"role": "assistant", "content": "ok"},
+ }
+ ],
+ },
+ )
+
+ llm = self._make_llm(handler, enable_thinking=True)
+
+ assert llm.generate([{"role": "user", "content": "hi"}]) == "ok"
+ assert captured_body["enable_thinking"] is True
+
+ def test_generate_stream_serializes_override_in_http_body(self):
+ captured_body = {}
+
+ def handler(request):
+ captured_body.update(json.loads(request.content))
+ return httpx.Response(
+ 200,
+ headers={"content-type": "text/event-stream"},
+ content=b"data: [DONE]\n\n",
+ )
+
+ llm = self._make_llm(handler, enable_thinking=True)
+
+ assert (
+ list(llm.generate_stream([{"role": "user", "content": "hi"}], enable_thinking=False))
+ == []
+ )
+ assert captured_body["enable_thinking"] is False
+
+ def test_azure_generate_serializes_enable_thinking_in_http_body(self):
+ captured_body = {}
+
+ def handler(request):
+ captured_body.update(json.loads(request.content))
+ return httpx.Response(
+ 200,
+ json={
+ "id": "chatcmpl-test",
+ "object": "chat.completion",
+ "created": 0,
+ "model": "test-model",
+ "choices": [
+ {
+ "index": 0,
+ "finish_reason": "stop",
+ "message": {"role": "assistant", "content": "ok"},
+ }
+ ],
+ },
+ )
+
+ llm = AzureLLM.__new__(AzureLLM)
+ llm.config = AzureLLMConfig(
+ api_key="test-key",
+ model_name_or_path="test-model",
+ enable_thinking=False,
+ )
+ llm.client = openai.Client(
+ api_key="test-key",
+ base_url="http://test.local/v1",
+ http_client=httpx.Client(transport=httpx.MockTransport(handler)),
+ )
+
+ assert llm.generate([{"role": "user", "content": "hi"}]) == "ok"
+ assert captured_body["enable_thinking"] is False
From 88a515aaea5ff2ee1623e5f3093631b0e219f322 Mon Sep 17 00:00:00 2001
From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com>
Date: Wed, 12 Aug 2026 10:00:27 +0800
Subject: [PATCH 15/17] fix(embedder): detect structured dimensions errors
Recognize provider errors that identify an unsupported dimensions parameter through structured param/code fields while preserving invalid-value failures. Add regression coverage for structured fallback and API dimension configuration.
Test: .venv/bin/python -m pytest tests/embedders/test_universal_api.py -q\nTest: .venv/bin/python -m pytest tests/api -q\nTest: .venv/bin/python -m pytest tests/embedders -q --ignore=tests/embedders/test_ark.py
---
src/memos/embedders/universal_api.py | 15 +++++++-
tests/embedders/test_universal_api.py | 49 +++++++++++++++++++++++++--
2 files changed, 60 insertions(+), 4 deletions(-)
diff --git a/src/memos/embedders/universal_api.py b/src/memos/embedders/universal_api.py
index 44cc1e3cb..22962e728 100644
--- a/src/memos/embedders/universal_api.py
+++ b/src/memos/embedders/universal_api.py
@@ -65,7 +65,20 @@ def _build_embedding_kwargs(model: str, texts: list[str], embedding_dims: int |
@staticmethod
def _is_dimensions_unsupported(error: BadRequestError) -> bool:
- message = str(error).lower()
+ body = getattr(error, "body", None)
+ details = body.get("error", body) if isinstance(body, dict) else {}
+ if isinstance(details, dict):
+ param = str(details.get("param") or "").lower()
+ code = str(details.get("code") or "").lower()
+ if param == "dimensions" and any(
+ marker in code for marker in ("unsupported", "unknown", "unrecognized")
+ ):
+ return True
+
+ messages = [str(error)]
+ if isinstance(details, dict) and isinstance(details.get("message"), str):
+ messages.append(details["message"])
+ message = " ".join(messages).lower()
unsupported_markers = (
"dimensions is not supported",
"dimensions not supported",
diff --git a/tests/embedders/test_universal_api.py b/tests/embedders/test_universal_api.py
index 394770787..7d897ebb2 100644
--- a/tests/embedders/test_universal_api.py
+++ b/tests/embedders/test_universal_api.py
@@ -33,10 +33,17 @@ def _mock_embedding_response(vectors_per_text=1, dims=2):
return response
-def _bad_request_error(message: str) -> BadRequestError:
+def _bad_request_error(
+ message: str, *, param: str | None = None, code: str | None = None
+) -> BadRequestError:
request = httpx.Request("POST", "https://api.example.com/v1/embeddings")
response = httpx.Response(400, request=request)
- return BadRequestError(message, response=response, body={"error": {"message": message}})
+ details = {"message": message}
+ if param is not None:
+ details["param"] = param
+ if code is not None:
+ details["code"] = code
+ return BadRequestError(message, response=response, body={"error": details})
class TestUniversalAPIEmbedderDimensions:
@@ -63,6 +70,16 @@ def test_build_embedding_kwargs_zero_dims(self):
)
assert kwargs["dimensions"] == 0
+ def test_api_config_maps_embedding_dimension(self, monkeypatch):
+ from memos.api.config import APIConfig
+
+ monkeypatch.setenv("MOS_EMBEDDER_BACKEND", "universal_api")
+ monkeypatch.setenv("EMBEDDING_DIMENSION", "1536")
+
+ config = APIConfig.get_embedder_config()
+
+ assert config["config"]["embedding_dims"] == 1536
+
@patch("memos.embedders.universal_api.OpenAIClient")
def test_embed_passes_embedding_dims_to_api(self, mock_openai_client):
response = _mock_embedding_response(vectors_per_text=1, dims=2)
@@ -157,6 +174,28 @@ def test_call_embeddings_api_falls_back_when_dimensions_not_supported(self):
assert all(call.kwargs["timeout"] == 5 for call in mock_create.call_args_list)
assert result == [[0.1, 0.2]]
+ def test_call_embeddings_api_falls_back_on_structured_dimensions_error(self):
+ config = _make_config(embedding_dims=256)
+ embedder = UniversalAPIEmbedder(config)
+ ok_response = SimpleNamespace(data=[SimpleNamespace(embedding=[0.1, 0.2])])
+ mock_create = MagicMock(
+ side_effect=[
+ _bad_request_error(
+ "Bad request",
+ param="dimensions",
+ code="unsupported_parameter",
+ ),
+ ok_response,
+ ]
+ )
+ mock_client = SimpleNamespace(embeddings=SimpleNamespace(create=mock_create))
+
+ result = embedder._call_embeddings_api(mock_client, "text-embedding-3-large", ["hello"], 5)
+
+ assert mock_create.call_count == 2
+ assert "dimensions" not in mock_create.call_args_list[1].kwargs
+ assert result == [[0.1, 0.2]]
+
def test_call_embeddings_api_does_not_fallback_on_timeout(self):
config = _make_config(embedding_dims=256)
embedder = UniversalAPIEmbedder(config)
@@ -184,7 +223,11 @@ def test_call_embeddings_api_does_not_fallback_on_invalid_dimensions(self):
config = _make_config(embedding_dims=0)
embedder = UniversalAPIEmbedder(config)
mock_create = MagicMock(
- side_effect=_bad_request_error("dimensions must be greater than zero")
+ side_effect=_bad_request_error(
+ "dimensions must be greater than zero",
+ param="dimensions",
+ code="invalid_value",
+ )
)
mock_client = SimpleNamespace(embeddings=SimpleNamespace(create=mock_create))
From 1e3411f7b1e59e77381149135e6b63d6a6ade076 Mon Sep 17 00:00:00 2001
From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com>
Date: Wed, 12 Aug 2026 10:17:29 +0800
Subject: [PATCH 16/17] test(llm): cover Azure thinking stream body
Exercise the independent Azure streaming request-body path with a per-call enable_thinking override and an existing vendor extra_body option.
Test: .venv/bin/python -m pytest tests/llms/test_enable_thinking.py tests/configs/test_llm.py -q\nTest: .venv/bin/python -m pytest tests/llms -q --ignore=tests/llms/test_hf.py\nTest: .venv/bin/python -m pytest tests/configs -q
---
tests/llms/test_enable_thinking.py | 36 ++++++++++++++++++++++++++++++
1 file changed, 36 insertions(+)
diff --git a/tests/llms/test_enable_thinking.py b/tests/llms/test_enable_thinking.py
index 46f3c5063..7b7e42402 100644
--- a/tests/llms/test_enable_thinking.py
+++ b/tests/llms/test_enable_thinking.py
@@ -199,3 +199,39 @@ def handler(request):
assert llm.generate([{"role": "user", "content": "hi"}]) == "ok"
assert captured_body["enable_thinking"] is False
+
+ def test_azure_generate_stream_serializes_override_in_http_body(self):
+ captured_body = {}
+
+ def handler(request):
+ captured_body.update(json.loads(request.content))
+ return httpx.Response(
+ 200,
+ headers={"content-type": "text/event-stream"},
+ content=b"data: [DONE]\n\n",
+ )
+
+ llm = AzureLLM.__new__(AzureLLM)
+ llm.config = AzureLLMConfig(
+ api_key="test-key",
+ model_name_or_path="test-model",
+ enable_thinking=True,
+ )
+ llm.client = openai.Client(
+ api_key="test-key",
+ base_url="http://test.local/v1",
+ http_client=httpx.Client(transport=httpx.MockTransport(handler)),
+ )
+
+ assert (
+ list(
+ llm.generate_stream(
+ [{"role": "user", "content": "hi"}],
+ enable_thinking=False,
+ extra_body={"vendor_option": "keep"},
+ )
+ )
+ == []
+ )
+ assert captured_body["enable_thinking"] is False
+ assert captured_body["vendor_option"] == "keep"
From 50e719fa847835cf82d1147fb14eb424d60e55ff Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
<41898282+github-actions[bot]@users.noreply.github.com>
Date: Fri, 14 Aug 2026 02:34:53 +0000
Subject: [PATCH 17/17] chore: change version number to v2.0.30
---
pyproject.toml | 2 +-
src/memos/__init__.py | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/pyproject.toml b/pyproject.toml
index 73cc31fb2..0acbcc296 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@
##############################################################################
name = "MemoryOS"
-version = "2.0.29"
+version = "2.0.30"
description = "Intelligence Begins with Memory"
license = {text = "Apache-2.0"}
readme = "README.md"
diff --git a/src/memos/__init__.py b/src/memos/__init__.py
index f334d1582..0f6dec9f7 100644
--- a/src/memos/__init__.py
+++ b/src/memos/__init__.py
@@ -1,4 +1,4 @@
-__version__ = "2.0.29"
+__version__ = "2.0.30"
from memos.configs.mem_cube import GeneralMemCubeConfig
from memos.configs.mem_os import MOSConfig