Skip to content

OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.

Python

fix: model providers routing (#2328)

Edwin Jose3699350d2a15
diff --git a/custom_components/openrag/openai_compatible_embedding.py b/custom_components/openrag/openai_compatible_embedding.py
index 7f7f29782..f5cb351c7 100644
--- a/custom_components/openrag/openai_compatible_embedding.py
+++ b/custom_components/openrag/openai_compatible_embedding.py
@@ -1,10 +1,11 @@
-"""OpenAI-compatible embeddings that talk to the OpenRAG `/v1` proxy.
+"""OpenAI-compatible embeddings that talk to the OpenRAG LLM proxy.
Embeddings work the same way as chat: Langflow never holds upstream vendor
keys. At runtime OpenRAG injects:
- ``OPENRAG_LLM_TOKEN`` — the same short-lived hop token as chat
-- ``OPENRAG_LLM_BASE_URL`` — the same ``http://<backend>/v1`` base URL
+- ``OPENRAG_LLM_BASE_URL`` — the backend's ``/v1`` base or the router's
+ private unversioned base
- ``SELECTED_EMBEDDING_MODEL`` — configured embedding model id
``OpenAIEmbeddings`` posts to ``{base_url}/embeddings``. The backend gateway
@@ -126,7 +127,7 @@ class OpenRAGEmbeddings(Embeddings):
class OpenAICompatibleEmbeddingComponent(LCEmbeddingsModel):
display_name = "OpenRAG Embeddings"
description = (
- "Embeddings via OpenRAG's OpenAI-compatible /v1 proxy. "
+ "Embeddings via OpenRAG's OpenAI-compatible proxy. "
"Uses the same base URL and hop token as the chat component."
)
icon = "OpenRAG"
@@ -159,8 +160,8 @@ class OpenAICompatibleEmbeddingComponent(LCEmbeddingsModel):
name="api_base",
display_name="OpenAI API Base",
info=(
- "Must end with /v1 (for example http://openrag-backend:8000/v1). "
- "Bound to OPENRAG_LLM_BASE_URL at runtime. Same URL as chat."
+ "Bound to OPENRAG_LLM_BASE_URL at runtime. It is either the public "
+ "/v1 base or the private router base. Same URL as chat."
),
value=OPENRAG_LLM_BASE_URL_VAR,
load_from_db=True,
diff --git a/custom_components/openrag/openai_compatible_llm.py b/custom_components/openrag/openai_compatible_llm.py
index de147d013..e54ed14ce 100644
--- a/custom_components/openrag/openai_compatible_llm.py
+++ b/custom_components/openrag/openai_compatible_llm.py
@@ -1,9 +1,10 @@
-"""OpenAI-compatible chat model that talks to the OpenRAG `/v1` proxy.
+"""OpenAI-compatible chat model that talks to the OpenRAG LLM proxy.
Langflow never holds upstream vendor keys. At runtime OpenRAG injects:
- ``OPENRAG_LLM_TOKEN`` — short-lived hop token (Authorization Bearer)
-- ``OPENRAG_LLM_BASE_URL`` — ``http://<backend>/v1``
+- ``OPENRAG_LLM_BASE_URL`` — the backend's ``/v1`` base or the router's
+ private unversioned base
- ``SELECTED_LANGUAGE_MODEL`` — configured chat model id
``ChatOpenAI`` posts to ``{base_url}/chat/completions``. The backend gateway
@@ -42,7 +43,7 @@ def _as_str(value: object) -> str | None:
class OpenAICompatibleLLMComponent(LCModelComponent):
display_name = "OpenRAG LLM"
description = (
- "Chat model via OpenRAG's OpenAI-compatible /v1 proxy. "
+ "Chat model via OpenRAG's OpenAI-compatible proxy. "
"Base URL and hop token come from global variables at runtime."
)
icon = "OpenRAG"
@@ -86,8 +87,8 @@ class OpenAICompatibleLLMComponent(LCModelComponent):
name="api_base",
display_name="OpenAI API Base",
info=(
- "Must end with /v1 (for example http://openrag-backend:8000/v1). "
- "Bound to OPENRAG_LLM_BASE_URL at runtime. Same URL as embeddings."
+ "Bound to OPENRAG_LLM_BASE_URL at runtime. It is either the public "
+ "/v1 base or the private router base. Same URL as embeddings."
),
value=OPENRAG_LLM_BASE_URL_VAR,
load_from_db=True,
diff --git a/flows/ingestion_flow.json b/flows/ingestion_flow.json
index 8f5028d0d..5759d6cae 100644
--- a/flows/ingestion_flow.json
+++ b/flows/ingestion_flow.json
@@ -4015,7 +4015,7 @@
"icon": "OpenRAG",
"legacy": false,
"metadata": {
- "code_hash": "230c964bdd9f",
+ "code_hash": "d4b6a5d67c0b",
"dependencies": {
"dependencies": [
{
@@ -4132,7 +4132,7 @@
"show": true,
"title_case": false,
"type": "code",
- "value": "\"\"\"OpenAI-compatible embeddings that talk to the OpenRAG `/v1` proxy.\n\nEmbeddings work the same way as chat: Langflow never holds upstream vendor\nkeys. At runtime OpenRAG injects:\n\n- ``OPENRAG_LLM_TOKEN`` — the same short-lived hop token as chat\n- ``OPENRAG_LLM_BASE_URL`` — the same ``http://<backend>/v1`` base URL\n- ``SELECTED_EMBEDDING_MODEL`` — configured embedding model id\n\n``OpenAIEmbeddings`` posts to ``{base_url}/embeddings``. The backend gateway\nroutes by the configured embedding provider (which can differ from the chat\nprovider).\n\"\"\"\n\nfrom __future__ import annotations\n\nfrom typing import Any\n\nfrom langchain_core.embeddings import Embeddings\nfrom langchain_openai import OpenAIEmbeddings\nfrom lfx.base.embeddings.model import LCEmbeddingsModel\nfrom lfx.io import IntInput, SecretStrInput, StrInput\n\n# Names must match src/api/settings/langflow_sync.py + src/utils/langflow_headers.py\nOPENRAG_LLM_BASE_URL_VAR = \"OPENRAG_LLM_BASE_URL\"\nOPENRAG_LLM_TOKEN_VAR = \"OPENRAG_LLM_TOKEN\"\nSELECTED_EMBEDDING_MODEL_VAR = \"SELECTED_EMBEDDING_MODEL\"\nSELECTED_EMBEDDING_PROVIDER_VAR = \"SELECTED_EMBEDDING_PROVIDER\"\nLEGACY_EMBEDDING_ROUTE_PREFIX = \"legacy:\"\nINDEXED_EMBEDDING_ROUTE_PREFIX = \"space:\"\n\n\ndef _as_str(value: object) -> str | None:\n if value is None:\n return None\n getter = getattr(value, \"get_secret_value\", None)\n if callable(getter):\n value = getter()\n text = str(value).strip()\n return text or None\n\n\ndef _embedding_route_identity(route: str) -> tuple[str | None, str]:\n \"\"\"Return the provider and model identity encoded in a retrieval route.\"\"\"\n if route.startswith(LEGACY_EMBEDDING_ROUTE_PREFIX):\n return None, route.removeprefix(LEGACY_EMBEDDING_ROUTE_PREFIX)\n if route.startswith(INDEXED_EMBEDDING_ROUTE_PREFIX):\n qualified = route.removeprefix(INDEXED_EMBEDDING_ROUTE_PREFIX)\n provider, separator, model_name = qualified.partition(\":\")\n if separator and provider and model_name:\n return provider.lower(), model_name\n return None, qualified\n return None, route\n\n\nclass OpenRAGEmbeddings(Embeddings):\n \"\"\"One immutable model route plus a factory for other retrieval routes.\"\"\"\n\n def __init__(\n self,\n *,\n model_name: str,\n api_key: str | None,\n api_base: str | None,\n provider_name: str | None = None,\n chunk_size: int | None = None,\n dimensions: int | None = None,\n ) -> None:\n self.model = model_name\n self.deployment = model_name\n self._api_key = api_key\n self._api_base = api_base\n self._provider_name = (provider_name or \"openai\").strip().lower()\n self._chunk_size = chunk_size\n self._dimensions = dimensions\n\n kwargs: dict[str, Any] = {\n \"model\": self.model,\n # Keep identity aligned with ``model``. LangChain otherwise exposes\n # its ada-002 class default as the deployment for every instance.\n \"deployment\": self.model_name,\n \"api_key\": api_key,\n \"base_url\": api_base,\n \"check_embedding_ctx_length\": False,\n }\n if chunk_size:\n kwargs[\"chunk_size\"] = chunk_size\n if dimensions:\n kwargs[\"dimensions\"] = dimensions\n self._delegate = OpenAIEmbeddings(**kwargs)\n\n @property\n def model_name(self) -> str:\n return self.model\n\n def for_model(self, model_name: str) -> Embeddings:\n \"\"\"Return a dedicated adapter; never mutate the selected ingestion model.\"\"\"\n route = (model_name or \"\").strip()\n if not route:\n raise ValueError(\"Embedding model route is required\")\n route_provider, route_model = _embedding_route_identity(route)\n is_selected_route = route_provider == self._provider_name and route_model == self.model_name\n dimensions = self._dimensions if is_selected_route else None\n return OpenRAGEmbeddings(\n model_name=route,\n api_key=self._api_key,\n api_base=self._api_base,\n provider_name=self._provider_name,\n chunk_size=self._chunk_size,\n dimensions=dimensions,\n )\n\n def embed_documents(self, texts: list[str]) -> list[list[float]]:\n return self._delegate.embed_documents(texts)\n\n def embed_query(self, text: str) -> list[float]:\n return self._delegate.embed_query(text)\n\n async def aembed_documents(self, texts: list[str]) -> list[list[float]]:\n return await self._delegate.aembed_documents(texts)\n\n async def aembed_query(self, text: str) -> list[float]:\n return await self._delegate.aembed_query(text)\n\n\nclass OpenAICompatibleEmbeddingComponent(LCEmbeddingsModel):\n display_name = \"OpenRAG Embeddings\"\n description = (\n \"Embeddings via OpenRAG's OpenAI-compatible /v1 proxy. \"\n \"Uses the same base URL and hop token as the chat component.\"\n )\n icon = \"OpenRAG\"\n name = \"OpenAICompatibleEmbedding\"\n\n inputs = [\n StrInput(\n name=\"model_name\",\n display_name=\"Model Name\",\n info=\"Embedding model id. Bound to SELECTED_EMBEDDING_MODEL at runtime.\",\n value=SELECTED_EMBEDDING_MODEL_VAR,\n load_from_db=True,\n ),\n StrInput(\n name=\"provider_name\",\n display_name=\"Provider Name\",\n info=\"Embedding provider id. Bound to SELECTED_EMBEDDING_PROVIDER at runtime.\",\n value=SELECTED_EMBEDDING_PROVIDER_VAR,\n load_from_db=True,\n ),\n SecretStrInput(\n name=\"api_key\",\n display_name=\"OpenRAG LLM Token\",\n info=\"Hop token from OPENRAG_LLM_TOKEN. Same token as the chat component.\",\n value=OPENRAG_LLM_TOKEN_VAR,\n required=False,\n load_from_db=True,\n ),\n StrInput(\n name=\"api_base\",\n display_name=\"OpenAI API Base\",\n info=(\n \"Must end with /v1 (for example http://openrag-backend:8000/v1). \"\n \"Bound to OPENRAG_LLM_BASE_URL at runtime. Same URL as chat.\"\n ),\n value=OPENRAG_LLM_BASE_URL_VAR,\n load_from_db=True,\n ),\n IntInput(\n name=\"dimensions\",\n display_name=\"Dimensions\",\n info=\"Output dimensions when the embedding model supports it.\",\n advanced=True,\n ),\n IntInput(\n name=\"chunk_size\",\n display_name=\"Chunk Size\",\n advanced=True,\n value=1000,\n ),\n ]\n\n def build_embeddings(self) -> Embeddings:\n api_key = _as_str(self.api_key)\n api_base = _as_str(self.api_base)\n if api_base:\n api_base = api_base.rstrip(\"/\")\n return OpenRAGEmbeddings(\n model_name=self.model_name,\n api_key=api_key,\n api_base=api_base,\n provider_name=getattr(self, \"provider_name\", None),\n chunk_size=getattr(self, \"chunk_size\", None),\n dimensions=getattr(self, \"dimensions\", None),\n )\n"
+ "value": "\"\"\"OpenAI-compatible embeddings that talk to the OpenRAG LLM proxy.\n\nEmbeddings work the same way as chat: Langflow never holds upstream vendor\nkeys. At runtime OpenRAG injects:\n\n- ``OPENRAG_LLM_TOKEN`` — the same short-lived hop token as chat\n- ``OPENRAG_LLM_BASE_URL`` — the backend's ``/v1`` base or the router's\n private unversioned base\n- ``SELECTED_EMBEDDING_MODEL`` — configured embedding model id\n\n``OpenAIEmbeddings`` posts to ``{base_url}/embeddings``. The backend gateway\nroutes by the configured embedding provider (which can differ from the chat\nprovider).\n\"\"\"\n\nfrom __future__ import annotations\n\nfrom typing import Any\n\nfrom langchain_core.embeddings import Embeddings\nfrom langchain_openai import OpenAIEmbeddings\nfrom lfx.base.embeddings.model import LCEmbeddingsModel\nfrom lfx.io import IntInput, SecretStrInput, StrInput\n\n# Names must match src/api/settings/langflow_sync.py + src/utils/langflow_headers.py\nOPENRAG_LLM_BASE_URL_VAR = \"OPENRAG_LLM_BASE_URL\"\nOPENRAG_LLM_TOKEN_VAR = \"OPENRAG_LLM_TOKEN\"\nSELECTED_EMBEDDING_MODEL_VAR = \"SELECTED_EMBEDDING_MODEL\"\nSELECTED_EMBEDDING_PROVIDER_VAR = \"SELECTED_EMBEDDING_PROVIDER\"\nLEGACY_EMBEDDING_ROUTE_PREFIX = \"legacy:\"\nINDEXED_EMBEDDING_ROUTE_PREFIX = \"space:\"\n\n\ndef _as_str(value: object) -> str | None:\n if value is None:\n return None\n getter = getattr(value, \"get_secret_value\", None)\n if callable(getter):\n value = getter()\n text = str(value).strip()\n return text or None\n\n\ndef _embedding_route_identity(route: str) -> tuple[str | None, str]:\n \"\"\"Return the provider and model identity encoded in a retrieval route.\"\"\"\n if route.startswith(LEGACY_EMBEDDING_ROUTE_PREFIX):\n return None, route.removeprefix(LEGACY_EMBEDDING_ROUTE_PREFIX)\n if route.startswith(INDEXED_EMBEDDING_ROUTE_PREFIX):\n qualified = route.removeprefix(INDEXED_EMBEDDING_ROUTE_PREFIX)\n provider, separator, model_name = qualified.partition(\":\")\n if separator and provider and model_name:\n return provider.lower(), model_name\n return None, qualified\n return None, route\n\n\nclass OpenRAGEmbeddings(Embeddings):\n \"\"\"One immutable model route plus a factory for other retrieval routes.\"\"\"\n\n def __init__(\n self,\n *,\n model_name: str,\n api_key: str | None,\n api_base: str | None,\n provider_name: str | None = None,\n chunk_size: int | None = None,\n dimensions: int | None = None,\n ) -> None:\n self.model = model_name\n self.deployment = model_name\n self._api_key = api_key\n self._api_base = api_base\n self._provider_name = (provider_name or \"openai\").strip().lower()\n self._chunk_size = chunk_size\n self._dimensions = dimensions\n\n kwargs: dict[str, Any] = {\n \"model\": self.model,\n # Keep identity aligned with ``model``. LangChain otherwise exposes\n # its ada-002 class default as the deployment for every instance.\n \"deployment\": self.model_name,\n \"api_key\": api_key,\n \"base_url\": api_base,\n \"check_embedding_ctx_length\": False,\n }\n if chunk_size:\n kwargs[\"chunk_size\"] = chunk_size\n if dimensions:\n kwargs[\"dimensions\"] = dimensions\n self._delegate = OpenAIEmbeddings(**kwargs)\n\n @property\n def model_name(self) -> str:\n return self.model\n\n def for_model(self, model_name: str) -> Embeddings:\n \"\"\"Return a dedicated adapter; never mutate the selected ingestion model.\"\"\"\n route = (model_name or \"\").strip()\n if not route:\n raise ValueError(\"Embedding model route is required\")\n route_provider, route_model = _embedding_route_identity(route)\n is_selected_route = route_provider == self._provider_name and route_model == self.model_name\n dimensions = self._dimensions if is_selected_route else None\n return OpenRAGEmbeddings(\n model_name=route,\n api_key=self._api_key,\n api_base=self._api_base,\n provider_name=self._provider_name,\n chunk_size=self._chunk_size,\n dimensions=dimensions,\n )\n\n def embed_documents(self, texts: list[str]) -> list[list[float]]:\n return self._delegate.embed_documents(texts)\n\n def embed_query(self, text: str) -> list[float]:\n return self._delegate.embed_query(text)\n\n async def aembed_documents(self, texts: list[str]) -> list[list[float]]:\n return await self._delegate.aembed_documents(texts)\n\n async def aembed_query(self, text: str) -> list[float]:\n return await self._delegate.aembed_query(text)\n\n\nclass OpenAICompatibleEmbeddingComponent(LCEmbeddingsModel):\n display_name = \"OpenRAG Embeddings\"\n description = (\n \"Embeddings via OpenRAG's OpenAI-compatible proxy. \"\n \"Uses the same base URL and hop token as the chat component.\"\n )\n icon = \"OpenRAG\"\n name = \"OpenAICompatibleEmbedding\"\n\n inputs = [\n StrInput(\n name=\"model_name\",\n display_name=\"Model Name\",\n info=\"Embedding model id. Bound to SELECTED_EMBEDDING_MODEL at runtime.\",\n value=SELECTED_EMBEDDING_MODEL_VAR,\n load_from_db=True,\n ),\n StrInput(\n name=\"provider_name\",\n display_name=\"Provider Name\",\n info=\"Embedding provider id. Bound to SELECTED_EMBEDDING_PROVIDER at runtime.\",\n value=SELECTED_EMBEDDING_PROVIDER_VAR,\n load_from_db=True,\n ),\n SecretStrInput(\n name=\"api_key\",\n display_name=\"OpenRAG LLM Token\",\n info=\"Hop token from OPENRAG_LLM_TOKEN. Same token as the chat component.\",\n value=OPENRAG_LLM_TOKEN_VAR,\n required=False,\n load_from_db=True,\n ),\n StrInput(\n name=\"api_base\",\n display_name=\"OpenAI API Base\",\n info=(\n \"Bound to OPENRAG_LLM_BASE_URL at runtime. It is either the public \"\n \"/v1 base or the private router base. Same URL as chat.\"\n ),\n value=OPENRAG_LLM_BASE_URL_VAR,\n load_from_db=True,\n ),\n IntInput(\n name=\"dimensions\",\n display_name=\"Dimensions\",\n info=\"Output dimensions when the embedding model supports it.\",\n advanced=True,\n ),\n IntInput(\n name=\"chunk_size\",\n display_name=\"Chunk Size\",\n advanced=True,\n value=1000,\n ),\n ]\n\n def build_embeddings(self) -> Embeddings:\n api_key = _as_str(self.api_key)\n api_base = _as_str(self.api_base)\n if api_base:\n api_base = api_base.rstrip(\"/\")\n return OpenRAGEmbeddings(\n model_name=self.model_name,\n api_key=api_key,\n api_base=api_base,\n provider_name=getattr(self, \"provider_name\", None),\n chunk_size=getattr(self, \"chunk_size\", None),\n dimensions=getattr(self, \"dimensions\", None),\n )\n"
},
"dimensions": {
"_input_type": "IntInput",
diff --git a/flows/openrag_agent.json b/flows/openrag_agent.json
index a3d5babf1..5b5ec1899 100644
--- a/flows/openrag_agent.json
+++ b/flows/openrag_agent.json
@@ -2542,7 +2542,7 @@
"icon": "OpenRAG",
"legacy": false,
"metadata": {
- "code_hash": "230c964bdd9f",
+ "code_hash": "d4b6a5d67c0b",
"dependencies": {
"dependencies": [
{
@@ -2659,7 +2659,7 @@
"show": true,
"title_case": false,
"type": "code",
- "value": "\"\"\"OpenAI-compatible embeddings that talk to the OpenRAG `/v1` proxy.\n\nEmbeddings work the same way as chat: Langflow never holds upstream vendor\nkeys. At runtime OpenRAG injects:\n\n- ``OPENRAG_LLM_TOKEN`` — the same short-lived hop token as chat\n- ``OPENRAG_LLM_BASE_URL`` — the same ``http://<backend>/v1`` base URL\n- ``SELECTED_EMBEDDING_MODEL`` — configured embedding model id\n\n``OpenAIEmbeddings`` posts to ``{base_url}/embeddings``. The backend gateway\nroutes by the configured embedding provider (which can differ from the chat\nprovider).\n\"\"\"\n\nfrom __future__ import annotations\n\nfrom typing import Any\n\nfrom langchain_core.embeddings import Embeddings\nfrom langchain_openai import OpenAIEmbeddings\nfrom lfx.base.embeddings.model import LCEmbeddingsModel\nfrom lfx.io import IntInput, SecretStrInput, StrInput\n\n# Names must match src/api/settings/langflow_sync.py + src/utils/langflow_headers.py\nOPENRAG_LLM_BASE_URL_VAR = \"OPENRAG_LLM_BASE_URL\"\nOPENRAG_LLM_TOKEN_VAR = \"OPENRAG_LLM_TOKEN\"\nSELECTED_EMBEDDING_MODEL_VAR = \"SELECTED_EMBEDDING_MODEL\"\nSELECTED_EMBEDDING_PROVIDER_VAR = \"SELECTED_EMBEDDING_PROVIDER\"\nLEGACY_EMBEDDING_ROUTE_PREFIX = \"legacy:\"\nINDEXED_EMBEDDING_ROUTE_PREFIX = \"space:\"\n\n\ndef _as_str(value: object) -> str | None:\n if value is None:\n return None\n getter = getattr(value, \"get_secret_value\", None)\n if callable(getter):\n value = getter()\n text = str(value).strip()\n return text or None\n\n\ndef _embedding_route_identity(route: str) -> tuple[str | None, str]:\n \"\"\"Return the provider and model identity encoded in a retrieval route.\"\"\"\n if route.startswith(LEGACY_EMBEDDING_ROUTE_PREFIX):\n return None, route.removeprefix(LEGACY_EMBEDDING_ROUTE_PREFIX)\n if route.startswith(INDEXED_EMBEDDING_ROUTE_PREFIX):\n qualified = route.removeprefix(INDEXED_EMBEDDING_ROUTE_PREFIX)\n provider, separator, model_name = qualified.partition(\":\")\n if separator and provider and model_name:\n return provider.lower(), model_name\n return None, qualified\n return None, route\n\n\nclass OpenRAGEmbeddings(Embeddings):\n \"\"\"One immutable model route plus a factory for other retrieval routes.\"\"\"\n\n def __init__(\n self,\n *,\n model_name: str,\n api_key: str | None,\n api_base: str | None,\n provider_name: str | None = None,\n chunk_size: int | None = None,\n dimensions: int | None = None,\n ) -> None:\n self.model = model_name\n self.deployment = model_name\n self._api_key = api_key\n self._api_base = api_base\n self._provider_name = (provider_name or \"openai\").strip().lower()\n self._chunk_size = chunk_size\n self._dimensions = dimensions\n\n kwargs: dict[str, Any] = {\n \"model\": self.model,\n # Keep identity aligned with ``model``. LangChain otherwise exposes\n # its ada-002 class default as the deployment for every instance.\n \"deployment\": self.model_name,\n \"api_key\": api_key,\n \"base_url\": api_base,\n \"check_embedding_ctx_length\": False,\n }\n if chunk_size:\n kwargs[\"chunk_size\"] = chunk_size\n if dimensions:\n kwargs[\"dimensions\"] = dimensions\n self._delegate = OpenAIEmbeddings(**kwargs)\n\n @property\n def model_name(self) -> str:\n return self.model\n\n def for_model(self, model_name: str) -> Embeddings:\n \"\"\"Return a dedicated adapter; never mutate the selected ingestion model.\"\"\"\n route = (model_name or \"\").strip()\n if not route:\n raise ValueError(\"Embedding model route is required\")\n route_provider, route_model = _embedding_route_identity(route)\n is_selected_route = route_provider == self._provider_name and route_model == self.model_name\n dimensions = self._dimensions if is_selected_route else None\n return OpenRAGEmbeddings(\n model_name=route,\n api_key=self._api_key,\n api_base=self._api_base,\n provider_name=self._provider_name,\n chunk_size=self._chunk_size,\n dimensions=dimensions,\n )\n\n def embed_documents(self, texts: list[str]) -> list[list[float]]:\n return self._delegate.embed_documents(texts)\n\n def embed_query(self, text: str) -> list[float]:\n return self._delegate.embed_query(text)\n\n async def aembed_documents(self, texts: list[str]) -> list[list[float]]:\n return await self._delegate.aembed_documents(texts)\n\n async def aembed_query(self, text: str) -> list[float]:\n return await self._delegate.aembed_query(text)\n\n\nclass OpenAICompatibleEmbeddingComponent(LCEmbeddingsModel):\n display_name = \"OpenRAG Embeddings\"\n description = (\n \"Embeddings via OpenRAG's OpenAI-compatible /v1 proxy. \"\n \"Uses the same base URL and hop token as the chat component.\"\n )\n icon = \"OpenRAG\"\n name = \"OpenAICompatibleEmbedding\"\n\n inputs = [\n StrInput(\n name=\"model_name\",\n display_name=\"Model Name\",\n info=\"Embedding model id. Bound to SELECTED_EMBEDDING_MODEL at runtime.\",\n value=SELECTED_EMBEDDING_MODEL_VAR,\n load_from_db=True,\n ),\n StrInput(\n name=\"provider_name\",\n display_name=\"Provider Name\",\n info=\"Embedding provider id. Bound to SELECTED_EMBEDDING_PROVIDER at runtime.\",\n value=SELECTED_EMBEDDING_PROVIDER_VAR,\n load_from_db=True,\n ),\n SecretStrInput(\n name=\"api_key\",\n display_name=\"OpenRAG LLM Token\",\n info=\"Hop token from OPENRAG_LLM_TOKEN. Same token as the chat component.\",\n value=OPENRAG_LLM_TOKEN_VAR,\n required=False,\n load_from_db=True,\n ),\n StrInput(\n name=\"api_base\",\n display_name=\"OpenAI API Base\",\n info=(\n \"Must end with /v1 (for example http://openrag-backend:8000/v1). \"\n \"Bound to OPENRAG_LLM_BASE_URL at runtime. Same URL as chat.\"\n ),\n value=OPENRAG_LLM_BASE_URL_VAR,\n load_from_db=True,\n ),\n IntInput(\n name=\"dimensions\",\n display_name=\"Dimensions\",\n info=\"Output dimensions when the embedding model supports it.\",\n advanced=True,\n ),\n IntInput(\n name=\"chunk_size\",\n display_name=\"Chunk Size\",\n advanced=True,\n value=1000,\n ),\n ]\n\n def build_embeddings(self) -> Embeddings:\n api_key = _as_str(self.api_key)\n api_base = _as_str(self.api_base)\n if api_base:\n api_base = api_base.rstrip(\"/\")\n return OpenRAGEmbeddings(\n model_name=self.model_name,\n api_key=api_key,\n api_base=api_base,\n provider_name=getattr(self, \"provider_name\", None),\n chunk_size=getattr(self, \"chunk_size\", None),\n dimensions=getattr(self, \"dimensions\", None),\n )\n"
+ "value": "\"\"\"OpenAI-compatible embeddings that talk to the OpenRAG LLM proxy.\n\nEmbeddings work the same way as chat: Langflow never holds upstream vendor\nkeys. At runtime OpenRAG injects:\n\n- ``OPENRAG_LLM_TOKEN`` — the same short-lived hop token as chat\n- ``OPENRAG_LLM_BASE_URL`` — the backend's ``/v1`` base or the router's\n private unversioned base\n- ``SELECTED_EMBEDDING_MODEL`` — configured embedding model id\n\n``OpenAIEmbeddings`` posts to ``{base_url}/embeddings``. The backend gateway\nroutes by the configured embedding provider (which can differ from the chat\nprovider).\n\"\"\"\n\nfrom __future__ import annotations\n\nfrom typing import Any\n\nfrom langchain_core.embeddings import Embeddings\nfrom langchain_openai import OpenAIEmbeddings\nfrom lfx.base.embeddings.model import LCEmbeddingsModel\nfrom lfx.io import IntInput, SecretStrInput, StrInput\n\n# Names must match src/api/settings/langflow_sync.py + src/utils/langflow_headers.py\nOPENRAG_LLM_BASE_URL_VAR = \"OPENRAG_LLM_BASE_URL\"\nOPENRAG_LLM_TOKEN_VAR = \"OPENRAG_LLM_TOKEN\"\nSELECTED_EMBEDDING_MODEL_VAR = \"SELECTED_EMBEDDING_MODEL\"\nSELECTED_EMBEDDING_PROVIDER_VAR = \"SELECTED_EMBEDDING_PROVIDER\"\nLEGACY_EMBEDDING_ROUTE_PREFIX = \"legacy:\"\nINDEXED_EMBEDDING_ROUTE_PREFIX = \"space:\"\n\n\ndef _as_str(value: object) -> str | None:\n if value is None:\n return None\n getter = getattr(value, \"get_secret_value\", None)\n if callable(getter):\n value = getter()\n text = str(value).strip()\n return text or None\n\n\ndef _embedding_route_identity(route: str) -> tuple[str | None, str]:\n \"\"\"Return the provider and model identity encoded in a retrieval route.\"\"\"\n if route.startswith(LEGACY_EMBEDDING_ROUTE_PREFIX):\n return None, route.removeprefix(LEGACY_EMBEDDING_ROUTE_PREFIX)\n if route.startswith(INDEXED_EMBEDDING_ROUTE_PREFIX):\n qualified = route.removeprefix(INDEXED_EMBEDDING_ROUTE_PREFIX)\n provider, separator, model_name = qualified.partition(\":\")\n if separator and provider and model_name:\n return provider.lower(), model_name\n return None, qualified\n return None, route\n\n\nclass OpenRAGEmbeddings(Embeddings):\n \"\"\"One immutable model route plus a factory for other retrieval routes.\"\"\"\n\n def __init__(\n self,\n *,\n model_name: str,\n api_key: str | None,\n api_base: str | None,\n provider_name: str | None = None,\n chunk_size: int | None = None,\n dimensions: int | None = None,\n ) -> None:\n self.model = model_name\n self.deployment = model_name\n self._api_key = api_key\n self._api_base = api_base\n self._provider_name = (provider_name or \"openai\").strip().lower()\n self._chunk_size = chunk_size\n self._dimensions = dimensions\n\n kwargs: dict[str, Any] = {\n \"model\": self.model,\n # Keep identity aligned with ``model``. LangChain otherwise exposes\n # its ada-002 class default as the deployment for every instance.\n \"deployment\": self.model_name,\n \"api_key\": api_key,\n \"base_url\": api_base,\n \"check_embedding_ctx_length\": False,\n }\n if chunk_size:\n kwargs[\"chunk_size\"] = chunk_size\n if dimensions:\n kwargs[\"dimensions\"] = dimensions\n self._delegate = OpenAIEmbeddings(**kwargs)\n\n @property\n def model_name(self) -> str:\n return self.model\n\n def for_model(self, model_name: str) -> Embeddings:\n \"\"\"Return a dedicated adapter; never mutate the selected ingestion model.\"\"\"\n route = (model_name or \"\").strip()\n if not route:\n raise ValueError(\"Embedding model route is required\")\n route_provider, route_model = _embedding_route_identity(route)\n is_selected_route = route_provider == self._provider_name and route_model == self.model_name\n dimensions = self._dimensions if is_selected_route else None\n return OpenRAGEmbeddings(\n model_name=route,\n api_key=self._api_key,\n api_base=self._api_base,\n provider_name=self._provider_name,\n chunk_size=self._chunk_size,\n dimensions=dimensions,\n )\n\n def embed_documents(self, texts: list[str]) -> list[list[float]]:\n return self._delegate.embed_documents(texts)\n\n def embed_query(self, text: str) -> list[float]:\n return self._delegate.embed_query(text)\n\n async def aembed_documents(self, texts: list[str]) -> list[list[float]]:\n return await self._delegate.aembed_documents(texts)\n\n async def aembed_query(self, text: str) -> list[float]:\n return await self._delegate.aembed_query(text)\n\n\nclass OpenAICompatibleEmbeddingComponent(LCEmbeddingsModel):\n display_name = \"OpenRAG Embeddings\"\n description = (\n \"Embeddings via OpenRAG's OpenAI-compatible proxy. \"\n \"Uses the same base URL and hop token as the chat component.\"\n )\n icon = \"OpenRAG\"\n name = \"OpenAICompatibleEmbedding\"\n\n inputs = [\n StrInput(\n name=\"model_name\",\n display_name=\"Model Name\",\n info=\"Embedding model id. Bound to SELECTED_EMBEDDING_MODEL at runtime.\",\n value=SELECTED_EMBEDDING_MODEL_VAR,\n load_from_db=True,\n ),\n StrInput(\n name=\"provider_name\",\n display_name=\"Provider Name\",\n info=\"Embedding provider id. Bound to SELECTED_EMBEDDING_PROVIDER at runtime.\",\n value=SELECTED_EMBEDDING_PROVIDER_VAR,\n load_from_db=True,\n ),\n SecretStrInput(\n name=\"api_key\",\n display_name=\"OpenRAG LLM Token\",\n info=\"Hop token from OPENRAG_LLM_TOKEN. Same token as the chat component.\",\n value=OPENRAG_LLM_TOKEN_VAR,\n required=False,\n load_from_db=True,\n ),\n StrInput(\n name=\"api_base\",\n display_name=\"OpenAI API Base\",\n info=(\n \"Bound to OPENRAG_LLM_BASE_URL at runtime. It is either the public \"\n \"/v1 base or the private router base. Same URL as chat.\"\n ),\n value=OPENRAG_LLM_BASE_URL_VAR,\n load_from_db=True,\n ),\n IntInput(\n name=\"dimensions\",\n display_name=\"Dimensions\",\n info=\"Output dimensions when the embedding model supports it.\",\n advanced=True,\n ),\n IntInput(\n name=\"chunk_size\",\n display_name=\"Chunk Size\",\n advanced=True,\n value=1000,\n ),\n ]\n\n def build_embeddings(self) -> Embeddings:\n api_key = _as_str(self.api_key)\n api_base = _as_str(self.api_base)\n if api_base:\n api_base = api_base.rstrip(\"/\")\n return OpenRAGEmbeddings(\n model_name=self.model_name,\n api_key=api_key,\n api_base=api_base,\n provider_name=getattr(self, \"provider_name\", None),\n chunk_size=getattr(self, \"chunk_size\", None),\n dimensions=getattr(self, \"dimensions\", None),\n )\n"
},
"dimensions": {
"_input_type": "IntInput",
@@ -3731,7 +3731,7 @@
"icon": "OpenRAG",
"legacy": false,
"metadata": {
- "code_hash": "c71fbff77a9e",
+ "code_hash": "31b36c673cfe",
"dependencies": {
"dependencies": [
{
@@ -3846,7 +3846,7 @@
"show": true,
"title_case": false,
"type": "code",
- "value": "\"\"\"OpenAI-compatible chat model that talks to the OpenRAG `/v1` proxy.\n\nLangflow never holds upstream vendor keys. At runtime OpenRAG injects:\n\n- ``OPENRAG_LLM_TOKEN`` — short-lived hop token (Authorization Bearer)\n- ``OPENRAG_LLM_BASE_URL`` — ``http://<backend>/v1``\n- ``SELECTED_LANGUAGE_MODEL`` — configured chat model id\n\n``ChatOpenAI`` posts to ``{base_url}/chat/completions``. The backend gateway\nthen calls the real vendor (OpenAI, Anthropic, Watsonx, Ollama, or any other\nLiteLLM provider). Embeddings use the same base URL and hop token; see\n``openai_compatible_embedding.py``.\n\"\"\"\n\nfrom __future__ import annotations\n\nfrom typing import Any\n\nfrom langchain_openai import ChatOpenAI\nfrom lfx.base.models.model import LCModelComponent\nfrom lfx.field_typing.constants import LanguageModel\nfrom lfx.field_typing.range_spec import RangeSpec\nfrom lfx.inputs.inputs import BoolInput, StrInput\nfrom lfx.io import IntInput, MessageInput, MultilineInput, SecretStrInput, SliderInput\n\n# Names must match src/api/settings/langflow_sync.py + src/utils/langflow_headers.py\nOPENRAG_LLM_BASE_URL_VAR = \"OPENRAG_LLM_BASE_URL\"\nOPENRAG_LLM_TOKEN_VAR = \"OPENRAG_LLM_TOKEN\"\nSELECTED_LANGUAGE_MODEL_VAR = \"SELECTED_LANGUAGE_MODEL\"\n\n\ndef _as_str(value: object) -> str | None:\n if value is None:\n return None\n getter = getattr(value, \"get_secret_value\", None)\n if callable(getter):\n value = getter()\n text = str(value).strip()\n return text or None\n\n\nclass OpenAICompatibleLLMComponent(LCModelComponent):\n display_name = \"OpenRAG LLM\"\n description = (\n \"Chat model via OpenRAG's OpenAI-compatible /v1 proxy. \"\n \"Base URL and hop token come from global variables at runtime.\"\n )\n icon = \"OpenRAG\"\n name = \"OpenAICompatibleLLM\"\n\n inputs = [\n MessageInput(\n name=\"input_value\",\n display_name=\"Input\",\n info=\"The input text to send to the model\",\n ),\n MultilineInput(\n name=\"system_message\",\n display_name=\"System Message\",\n info=\"A system message that helps set the behavior of the assistant\",\n advanced=False,\n ),\n BoolInput(\n name=\"stream\",\n display_name=\"Stream\",\n info=\"Whether to stream the response\",\n value=False,\n advanced=True,\n ),\n StrInput(\n name=\"model_name\",\n display_name=\"Model Name\",\n info=\"Chat model id. Bound to SELECTED_LANGUAGE_MODEL at runtime.\",\n value=SELECTED_LANGUAGE_MODEL_VAR,\n load_from_db=True,\n ),\n SecretStrInput(\n name=\"api_key\",\n display_name=\"OpenRAG LLM Token\",\n info=\"Hop token from OPENRAG_LLM_TOKEN. OpenRAG injects this per Langflow run.\",\n value=OPENRAG_LLM_TOKEN_VAR,\n required=False,\n load_from_db=True,\n ),\n StrInput(\n name=\"api_base\",\n display_name=\"OpenAI API Base\",\n info=(\n \"Must end with /v1 (for example http://openrag-backend:8000/v1). \"\n \"Bound to OPENRAG_LLM_BASE_URL at runtime. Same URL as embeddings.\"\n ),\n value=OPENRAG_LLM_BASE_URL_VAR,\n load_from_db=True,\n ),\n SliderInput(\n name=\"temperature\",\n display_name=\"Temperature\",\n value=0.1,\n info=\"Controls randomness in responses\",\n range_spec=RangeSpec(min=0, max=1, step=0.01),\n advanced=True,\n ),\n IntInput(\n name=\"max_tokens\",\n display_name=\"Max Tokens\",\n info=\"Maximum number of tokens to generate. Leave empty for the model default.\",\n advanced=True,\n ),\n IntInput(\n name=\"seed\",\n display_name=\"Seed\",\n info=\"The seed controls the reproducibility of the job.\",\n advanced=True,\n value=1,\n ),\n ]\n\n def build_model(self) -> LanguageModel:\n api_key = _as_str(self.api_key)\n api_base = _as_str(self.api_base)\n if api_base:\n api_base = api_base.rstrip(\"/\")\n\n kwargs: dict[str, Any] = {\n \"model\": self.model_name,\n \"api_key\": api_key,\n \"base_url\": api_base or None,\n \"streaming\": bool(getattr(self, \"stream\", False)),\n }\n max_tokens = getattr(self, \"max_tokens\", None)\n if max_tokens:\n kwargs[\"max_tokens\"] = max_tokens\n temperature = getattr(self, \"temperature\", None)\n if temperature is not None:\n kwargs[\"temperature\"] = temperature\n seed = getattr(self, \"seed\", None)\n if seed is not None:\n kwargs[\"seed\"] = seed\n return ChatOpenAI(**kwargs)\n"
+ "value": "\"\"\"OpenAI-compatible chat model that talks to the OpenRAG LLM proxy.\n\nLangflow never holds upstream vendor keys. At runtime OpenRAG injects:\n\n- ``OPENRAG_LLM_TOKEN`` — short-lived hop token (Authorization Bearer)\n- ``OPENRAG_LLM_BASE_URL`` — the backend's ``/v1`` base or the router's\n private unversioned base\n- ``SELECTED_LANGUAGE_MODEL`` — configured chat model id\n\n``ChatOpenAI`` posts to ``{base_url}/chat/completions``. The backend gateway\nthen calls the real vendor (OpenAI, Anthropic, Watsonx, Ollama, or any other\nLiteLLM provider). Embeddings use the same base URL and hop token; see\n``openai_compatible_embedding.py``.\n\"\"\"\n\nfrom __future__ import annotations\n\nfrom typing import Any\n\nfrom langchain_openai import ChatOpenAI\nfrom lfx.base.models.model import LCModelComponent\nfrom lfx.field_typing.constants import LanguageModel\nfrom lfx.field_typing.range_spec import RangeSpec\nfrom lfx.inputs.inputs import BoolInput, StrInput\nfrom lfx.io import IntInput, MessageInput, MultilineInput, SecretStrInput, SliderInput\n\n# Names must match src/api/settings/langflow_sync.py + src/utils/langflow_headers.py\nOPENRAG_LLM_BASE_URL_VAR = \"OPENRAG_LLM_BASE_URL\"\nOPENRAG_LLM_TOKEN_VAR = \"OPENRAG_LLM_TOKEN\"\nSELECTED_LANGUAGE_MODEL_VAR = \"SELECTED_LANGUAGE_MODEL\"\n\n\ndef _as_str(value: object) -> str | None:\n if value is None:\n return None\n getter = getattr(value, \"get_secret_value\", None)\n if callable(getter):\n value = getter()\n text = str(value).strip()\n return text or None\n\n\nclass OpenAICompatibleLLMComponent(LCModelComponent):\n display_name = \"OpenRAG LLM\"\n description = (\n \"Chat model via OpenRAG's OpenAI-compatible proxy. \"\n \"Base URL and hop token come from global variables at runtime.\"\n )\n icon = \"OpenRAG\"\n name = \"OpenAICompatibleLLM\"\n\n inputs = [\n MessageInput(\n name=\"input_value\",\n display_name=\"Input\",\n info=\"The input text to send to the model\",\n ),\n MultilineInput(\n name=\"system_message\",\n display_name=\"System Message\",\n info=\"A system message that helps set the behavior of the assistant\",\n advanced=False,\n ),\n BoolInput(\n name=\"stream\",\n display_name=\"Stream\",\n info=\"Whether to stream the response\",\n value=False,\n advanced=True,\n ),\n StrInput(\n name=\"model_name\",\n display_name=\"Model Name\",\n info=\"Chat model id. Bound to SELECTED_LANGUAGE_MODEL at runtime.\",\n value=SELECTED_LANGUAGE_MODEL_VAR,\n load_from_db=True,\n ),\n SecretStrInput(\n name=\"api_key\",\n display_name=\"OpenRAG LLM Token\",\n info=\"Hop token from OPENRAG_LLM_TOKEN. OpenRAG injects this per Langflow run.\",\n value=OPENRAG_LLM_TOKEN_VAR,\n required=False,\n load_from_db=True,\n ),\n StrInput(\n name=\"api_base\",\n display_name=\"OpenAI API Base\",\n info=(\n \"Bound to OPENRAG_LLM_BASE_URL at runtime. It is either the public \"\n \"/v1 base or the private router base. Same URL as embeddings.\"\n ),\n value=OPENRAG_LLM_BASE_URL_VAR,\n load_from_db=True,\n ),\n SliderInput(\n name=\"temperature\",\n display_name=\"Temperature\",\n value=0.1,\n info=\"Controls randomness in responses\",\n range_spec=RangeSpec(min=0, max=1, step=0.01),\n advanced=True,\n ),\n IntInput(\n name=\"max_tokens\",\n display_name=\"Max Tokens\",\n info=\"Maximum number of tokens to generate. Leave empty for the model default.\",\n advanced=True,\n ),\n IntInput(\n name=\"seed\",\n display_name=\"Seed\",\n info=\"The seed controls the reproducibility of the job.\",\n advanced=True,\n value=1,\n ),\n ]\n\n def build_model(self) -> LanguageModel:\n api_key = _as_str(self.api_key)\n api_base = _as_str(self.api_base)\n if api_base:\n api_base = api_base.rstrip(\"/\")\n\n kwargs: dict[str, Any] = {\n \"model\": self.model_name,\n \"api_key\": api_key,\n \"base_url\": api_base or None,\n \"streaming\": bool(getattr(self, \"stream\", False)),\n }\n max_tokens = getattr(self, \"max_tokens\", None)\n if max_tokens:\n kwargs[\"max_tokens\"] = max_tokens\n temperature = getattr(self, \"temperature\", None)\n if temperature is not None:\n kwargs[\"temperature\"] = temperature\n seed = getattr(self, \"seed\", None)\n if seed is not None:\n kwargs[\"seed\"] = seed\n return ChatOpenAI(**kwargs)\n"
},
"input_value": {
"_input_type": "MessageInput",
diff --git a/flows/openrag_nudges.json b/flows/openrag_nudges.json
index 359502812..dea4e3c48 100644
--- a/flows/openrag_nudges.json
+++ b/flows/openrag_nudges.json
@@ -2363,7 +2363,7 @@
"icon": "OpenRAG",
"legacy": false,
"metadata": {
- "code_hash": "230c964bdd9f",
+ "code_hash": "d4b6a5d67c0b",
"dependencies": {
"dependencies": [
{
@@ -2480,7 +2480,7 @@
"show": true,
"title_case": false,
"type": "code",
- "value": "\"\"\"OpenAI-compatible embeddings that talk to the OpenRAG `/v1` proxy.\n\nEmbeddings work the same way as chat: Langflow never holds upstream vendor\nkeys. At runtime OpenRAG injects:\n\n- ``OPENRAG_LLM_TOKEN`` — the same short-lived hop token as chat\n- ``OPENRAG_LLM_BASE_URL`` — the same ``http://<backend>/v1`` base URL\n- ``SELECTED_EMBEDDING_MODEL`` — configured embedding model id\n\n``OpenAIEmbeddings`` posts to ``{base_url}/embeddings``. The backend gateway\nroutes by the configured embedding provider (which can differ from the chat\nprovider).\n\"\"\"\n\nfrom __future__ import annotations\n\nfrom typing import Any\n\nfrom langchain_core.embeddings import Embeddings\nfrom langchain_openai import OpenAIEmbeddings\nfrom lfx.base.embeddings.model import LCEmbeddingsModel\nfrom lfx.io import IntInput, SecretStrInput, StrInput\n\n# Names must match src/api/settings/langflow_sync.py + src/utils/langflow_headers.py\nOPENRAG_LLM_BASE_URL_VAR = \"OPENRAG_LLM_BASE_URL\"\nOPENRAG_LLM_TOKEN_VAR = \"OPENRAG_LLM_TOKEN\"\nSELECTED_EMBEDDING_MODEL_VAR = \"SELECTED_EMBEDDING_MODEL\"\nSELECTED_EMBEDDING_PROVIDER_VAR = \"SELECTED_EMBEDDING_PROVIDER\"\nLEGACY_EMBEDDING_ROUTE_PREFIX = \"legacy:\"\nINDEXED_EMBEDDING_ROUTE_PREFIX = \"space:\"\n\n\ndef _as_str(value: object) -> str | None:\n if value is None:\n return None\n getter = getattr(value, \"get_secret_value\", None)\n if callable(getter):\n value = getter()\n text = str(value).strip()\n return text or None\n\n\ndef _embedding_route_identity(route: str) -> tuple[str | None, str]:\n \"\"\"Return the provider and model identity encoded in a retrieval route.\"\"\"\n if route.startswith(LEGACY_EMBEDDING_ROUTE_PREFIX):\n return None, route.removeprefix(LEGACY_EMBEDDING_ROUTE_PREFIX)\n if route.startswith(INDEXED_EMBEDDING_ROUTE_PREFIX):\n qualified = route.removeprefix(INDEXED_EMBEDDING_ROUTE_PREFIX)\n provider, separator, model_name = qualified.partition(\":\")\n if separator and provider and model_name:\n return provider.lower(), model_name\n return None, qualified\n return None, route\n\n\nclass OpenRAGEmbeddings(Embeddings):\n \"\"\"One immutable model route plus a factory for other retrieval routes.\"\"\"\n\n def __init__(\n self,\n *,\n model_name: str,\n api_key: str | None,\n api_base: str | None,\n provider_name: str | None = None,\n chunk_size: int | None = None,\n dimensions: int | None = None,\n ) -> None:\n self.model = model_name\n self.deployment = model_name\n self._api_key = api_key\n self._api_base = api_base\n self._provider_name = (provider_name or \"openai\").strip().lower()\n self._chunk_size = chunk_size\n self._dimensions = dimensions\n\n kwargs: dict[str, Any] = {\n \"model\": self.model,\n # Keep identity aligned with ``model``. LangChain otherwise exposes\n # its ada-002 class default as the deployment for every instance.\n \"deployment\": self.model_name,\n \"api_key\": api_key,\n \"base_url\": api_base,\n \"check_embedding_ctx_length\": False,\n }\n if chunk_size:\n kwargs[\"chunk_size\"] = chunk_size\n if dimensions:\n kwargs[\"dimensions\"] = dimensions\n self._delegate = OpenAIEmbeddings(**kwargs)\n\n @property\n def model_name(self) -> str:\n return self.model\n\n def for_model(self, model_name: str) -> Embeddings:\n \"\"\"Return a dedicated adapter; never mutate the selected ingestion model.\"\"\"\n route = (model_name or \"\").strip()\n if not route:\n raise ValueError(\"Embedding model route is required\")\n route_provider, route_model = _embedding_route_identity(route)\n is_selected_route = route_provider == self._provider_name and route_model == self.model_name\n dimensions = self._dimensions if is_selected_route else None\n return OpenRAGEmbeddings(\n model_name=route,\n api_key=self._api_key,\n api_base=self._api_base,\n provider_name=self._provider_name,\n chunk_size=self._chunk_size,\n dimensions=dimensions,\n )\n\n def embed_documents(self, texts: list[str]) -> list[list[float]]:\n return self._delegate.embed_documents(texts)\n\n def embed_query(self, text: str) -> list[float]:\n return self._delegate.embed_query(text)\n\n async def aembed_documents(self, texts: list[str]) -> list[list[float]]:\n return await self._delegate.aembed_documents(texts)\n\n async def aembed_query(self, text: str) -> list[float]:\n return await self._delegate.aembed_query(text)\n\n\nclass OpenAICompatibleEmbeddingComponent(LCEmbeddingsModel):\n display_name = \"OpenRAG Embeddings\"\n description = (\n \"Embeddings via OpenRAG's OpenAI-compatible /v1 proxy. \"\n \"Uses the same base URL and hop token as the chat component.\"\n )\n icon = \"OpenRAG\"\n name = \"OpenAICompatibleEmbedding\"\n\n inputs = [\n StrInput(\n name=\"model_name\",\n display_name=\"Model Name\",\n info=\"Embedding model id. Bound to SELECTED_EMBEDDING_MODEL at runtime.\",\n value=SELECTED_EMBEDDING_MODEL_VAR,\n load_from_db=True,\n ),\n StrInput(\n name=\"provider_name\",\n display_name=\"Provider Name\",\n info=\"Embedding provider id. Bound to SELECTED_EMBEDDING_PROVIDER at runtime.\",\n value=SELECTED_EMBEDDING_PROVIDER_VAR,\n load_from_db=True,\n ),\n SecretStrInput(\n name=\"api_key\",\n display_name=\"OpenRAG LLM Token\",\n info=\"Hop token from OPENRAG_LLM_TOKEN. Same token as the chat component.\",\n value=OPENRAG_LLM_TOKEN_VAR,\n required=False,\n load_from_db=True,\n ),\n StrInput(\n name=\"api_base\",\n display_name=\"OpenAI API Base\",\n info=(\n \"Must end with /v1 (for example http://openrag-backend:8000/v1). \"\n \"Bound to OPENRAG_LLM_BASE_URL at runtime. Same URL as chat.\"\n ),\n value=OPENRAG_LLM_BASE_URL_VAR,\n load_from_db=True,\n ),\n IntInput(\n name=\"dimensions\",\n display_name=\"Dimensions\",\n info=\"Output dimensions when the embedding model supports it.\",\n advanced=True,\n ),\n IntInput(\n name=\"chunk_size\",\n display_name=\"Chunk Size\",\n advanced=True,\n value=1000,\n ),\n ]\n\n def build_embeddings(self) -> Embeddings:\n api_key = _as_str(self.api_key)\n api_base = _as_str(self.api_base)\n if api_base:\n api_base = api_base.rstrip(\"/\")\n return OpenRAGEmbeddings(\n model_name=self.model_name,\n api_key=api_key,\n api_base=api_base,\n provider_name=getattr(self, \"provider_name\", None),\n chunk_size=getattr(self, \"chunk_size\", None),\n dimensions=getattr(self, \"dimensions\", None),\n )\n"
+ "value": "\"\"\"OpenAI-compatible embeddings that talk to the OpenRAG LLM proxy.\n\nEmbeddings work the same way as chat: Langflow never holds upstream vendor\nkeys. At runtime OpenRAG injects:\n\n- ``OPENRAG_LLM_TOKEN`` — the same short-lived hop token as chat\n- ``OPENRAG_LLM_BASE_URL`` — the backend's ``/v1`` base or the router's\n private unversioned base\n- ``SELECTED_EMBEDDING_MODEL`` — configured embedding model id\n\n``OpenAIEmbeddings`` posts to ``{base_url}/embeddings``. The backend gateway\nroutes by the configured embedding provider (which can differ from the chat\nprovider).\n\"\"\"\n\nfrom __future__ import annotations\n\nfrom typing import Any\n\nfrom langchain_core.embeddings import Embeddings\nfrom langchain_openai import OpenAIEmbeddings\nfrom lfx.base.embeddings.model import LCEmbeddingsModel\nfrom lfx.io import IntInput, SecretStrInput, StrInput\n\n# Names must match src/api/settings/langflow_sync.py + src/utils/langflow_headers.py\nOPENRAG_LLM_BASE_URL_VAR = \"OPENRAG_LLM_BASE_URL\"\nOPENRAG_LLM_TOKEN_VAR = \"OPENRAG_LLM_TOKEN\"\nSELECTED_EMBEDDING_MODEL_VAR = \"SELECTED_EMBEDDING_MODEL\"\nSELECTED_EMBEDDING_PROVIDER_VAR = \"SELECTED_EMBEDDING_PROVIDER\"\nLEGACY_EMBEDDING_ROUTE_PREFIX = \"legacy:\"\nINDEXED_EMBEDDING_ROUTE_PREFIX = \"space:\"\n\n\ndef _as_str(value: object) -> str | None:\n if value is None:\n return None\n getter = getattr(value, \"get_secret_value\", None)\n if callable(getter):\n value = getter()\n text = str(value).strip()\n return text or None\n\n\ndef _embedding_route_identity(route: str) -> tuple[str | None, str]:\n \"\"\"Return the provider and model identity encoded in a retrieval route.\"\"\"\n if route.startswith(LEGACY_EMBEDDING_ROUTE_PREFIX):\n return None, route.removeprefix(LEGACY_EMBEDDING_ROUTE_PREFIX)\n if route.startswith(INDEXED_EMBEDDING_ROUTE_PREFIX):\n qualified = route.removeprefix(INDEXED_EMBEDDING_ROUTE_PREFIX)\n provider, separator, model_name = qualified.partition(\":\")\n if separator and provider and model_name:\n return provider.lower(), model_name\n return None, qualified\n return None, route\n\n\nclass OpenRAGEmbeddings(Embeddings):\n \"\"\"One immutable model route plus a factory for other retrieval routes.\"\"\"\n\n def __init__(\n self,\n *,\n model_name: str,\n api_key: str | None,\n api_base: str | None,\n provider_name: str | None = None,\n chunk_size: int | None = None,\n dimensions: int | None = None,\n ) -> None:\n self.model = model_name\n self.deployment = model_name\n self._api_key = api_key\n self._api_base = api_base\n self._provider_name = (provider_name or \"openai\").strip().lower()\n self._chunk_size = chunk_size\n self._dimensions = dimensions\n\n kwargs: dict[str, Any] = {\n \"model\": self.model,\n # Keep identity aligned with ``model``. LangChain otherwise exposes\n # its ada-002 class default as the deployment for every instance.\n \"deployment\": self.model_name,\n \"api_key\": api_key,\n \"base_url\": api_base,\n \"check_embedding_ctx_length\": False,\n }\n if chunk_size:\n kwargs[\"chunk_size\"] = chunk_size\n if dimensions:\n kwargs[\"dimensions\"] = dimensions\n self._delegate = OpenAIEmbeddings(**kwargs)\n\n @property\n def model_name(self) -> str:\n return self.model\n\n def for_model(self, model_name: str) -> Embeddings:\n \"\"\"Return a dedicated adapter; never mutate the selected ingestion model.\"\"\"\n route = (model_name or \"\").strip()\n if not route:\n raise ValueError(\"Embedding model route is required\")\n route_provider, route_model = _embedding_route_identity(route)\n is_selected_route = route_provider == self._provider_name and route_model == self.model_name\n dimensions = self._dimensions if is_selected_route else None\n return OpenRAGEmbeddings(\n model_name=route,\n api_key=self._api_key,\n api_base=self._api_base,\n provider_name=self._provider_name,\n chunk_size=self._chunk_size,\n dimensions=dimensions,\n )\n\n def embed_documents(self, texts: list[str]) -> list[list[float]]:\n return self._delegate.embed_documents(texts)\n\n def embed_query(self, text: str) -> list[float]:\n return self._delegate.embed_query(text)\n\n async def aembed_documents(self, texts: list[str]) -> list[list[float]]:\n return await self._delegate.aembed_documents(texts)\n\n async def aembed_query(self, text: str) -> list[float]:\n return await self._delegate.aembed_query(text)\n\n\nclass OpenAICompatibleEmbeddingComponent(LCEmbeddingsModel):\n display_name = \"OpenRAG Embeddings\"\n description = (\n \"Embeddings via OpenRAG's OpenAI-compatible proxy. \"\n \"Uses the same base URL and hop token as the chat component.\"\n )\n icon = \"OpenRAG\"\n name = \"OpenAICompatibleEmbedding\"\n\n inputs = [\n StrInput(\n name=\"model_name\",\n display_name=\"Model Name\",\n info=\"Embedding model id. Bound to SELECTED_EMBEDDING_MODEL at runtime.\",\n value=SELECTED_EMBEDDING_MODEL_VAR,\n load_from_db=True,\n ),\n StrInput(\n name=\"provider_name\",\n display_name=\"Provider Name\",\n info=\"Embedding provider id. Bound to SELECTED_EMBEDDING_PROVIDER at runtime.\",\n value=SELECTED_EMBEDDING_PROVIDER_VAR,\n load_from_db=True,\n ),\n SecretStrInput(\n name=\"api_key\",\n display_name=\"OpenRAG LLM Token\",\n info=\"Hop token from OPENRAG_LLM_TOKEN. Same token as the chat component.\",\n value=OPENRAG_LLM_TOKEN_VAR,\n required=False,\n load_from_db=True,\n ),\n StrInput(\n name=\"api_base\",\n display_name=\"OpenAI API Base\",\n info=(\n \"Bound to OPENRAG_LLM_BASE_URL at runtime. It is either the public \"\n \"/v1 base or the private router base. Same URL as chat.\"\n ),\n value=OPENRAG_LLM_BASE_URL_VAR,\n load_from_db=True,\n ),\n IntInput(\n name=\"dimensions\",\n display_name=\"Dimensions\",\n info=\"Output dimensions when the embedding model supports it.\",\n advanced=True,\n ),\n IntInput(\n name=\"chunk_size\",\n display_name=\"Chunk Size\",\n advanced=True,\n value=1000,\n ),\n ]\n\n def build_embeddings(self) -> Embeddings:\n api_key = _as_str(self.api_key)\n api_base = _as_str(self.api_base)\n if api_base:\n api_base = api_base.rstrip(\"/\")\n return OpenRAGEmbeddings(\n model_name=self.model_name,\n api_key=api_key,\n api_base=api_base,\n provider_name=getattr(self, \"provider_name\", None),\n chunk_size=getattr(self, \"chunk_size\", None),\n dimensions=getattr(self, \"dimensions\", None),\n )\n"
},
"dimensions": {
"_input_type": "IntInput",
@@ -2574,7 +2574,7 @@
"icon": "OpenRAG",
"legacy": false,
"metadata": {
- "code_hash": "c71fbff77a9e",
+ "code_hash": "31b36c673cfe",
"dependencies": {
"dependencies": [
{
@@ -2689,7 +2689,7 @@
"show": true,
"title_case": false,
"type": "code",
- "value": "\"\"\"OpenAI-compatible chat model that talks to the OpenRAG `/v1` proxy.\n\nLangflow never holds upstream vendor keys. At runtime OpenRAG injects:\n\n- ``OPENRAG_LLM_TOKEN`` — short-lived hop token (Authorization Bearer)\n- ``OPENRAG_LLM_BASE_URL`` — ``http://<backend>/v1``\n- ``SELECTED_LANGUAGE_MODEL`` — configured chat model id\n\n``ChatOpenAI`` posts to ``{base_url}/chat/completions``. The backend gateway\nthen calls the real vendor (OpenAI, Anthropic, Watsonx, Ollama, or any other\nLiteLLM provider). Embeddings use the same base URL and hop token; see\n``openai_compatible_embedding.py``.\n\"\"\"\n\nfrom __future__ import annotations\n\nfrom typing import Any\n\nfrom langchain_openai import ChatOpenAI\nfrom lfx.base.models.model import LCModelComponent\nfrom lfx.field_typing.constants import LanguageModel\nfrom lfx.field_typing.range_spec import RangeSpec\nfrom lfx.inputs.inputs import BoolInput, StrInput\nfrom lfx.io import IntInput, MessageInput, MultilineInput, SecretStrInput, SliderInput\n\n# Names must match src/api/settings/langflow_sync.py + src/utils/langflow_headers.py\nOPENRAG_LLM_BASE_URL_VAR = \"OPENRAG_LLM_BASE_URL\"\nOPENRAG_LLM_TOKEN_VAR = \"OPENRAG_LLM_TOKEN\"\nSELECTED_LANGUAGE_MODEL_VAR = \"SELECTED_LANGUAGE_MODEL\"\n\n\ndef _as_str(value: object) -> str | None:\n if value is None:\n return None\n getter = getattr(value, \"get_secret_value\", None)\n if callable(getter):\n value = getter()\n text = str(value).strip()\n return text or None\n\n\nclass OpenAICompatibleLLMComponent(LCModelComponent):\n display_name = \"OpenRAG LLM\"\n description = (\n \"Chat model via OpenRAG's OpenAI-compatible /v1 proxy. \"\n \"Base URL and hop token come from global variables at runtime.\"\n )\n icon = \"OpenRAG\"\n name = \"OpenAICompatibleLLM\"\n\n inputs = [\n MessageInput(\n name=\"input_value\",\n display_name=\"Input\",\n info=\"The input text to send to the model\",\n ),\n MultilineInput(\n name=\"system_message\",\n display_name=\"System Message\",\n info=\"A system message that helps set the behavior of the assistant\",\n advanced=False,\n ),\n BoolInput(\n name=\"stream\",\n display_name=\"Stream\",\n info=\"Whether to stream the response\",\n value=False,\n advanced=True,\n ),\n StrInput(\n name=\"model_name\",\n display_name=\"Model Name\",\n info=\"Chat model id. Bound to SELECTED_LANGUAGE_MODEL at runtime.\",\n value=SELECTED_LANGUAGE_MODEL_VAR,\n load_from_db=True,\n ),\n SecretStrInput(\n name=\"api_key\",\n display_name=\"OpenRAG LLM Token\",\n info=\"Hop token from OPENRAG_LLM_TOKEN. OpenRAG injects this per Langflow run.\",\n value=OPENRAG_LLM_TOKEN_VAR,\n required=False,\n load_from_db=True,\n ),\n StrInput(\n name=\"api_base\",\n display_name=\"OpenAI API Base\",\n info=(\n \"Must end with /v1 (for example http://openrag-backend:8000/v1). \"\n \"Bound to OPENRAG_LLM_BASE_URL at runtime. Same URL as embeddings.\"\n ),\n value=OPENRAG_LLM_BASE_URL_VAR,\n load_from_db=True,\n ),\n SliderInput(\n name=\"temperature\",\n display_name=\"Temperature\",\n value=0.1,\n info=\"Controls randomness in responses\",\n range_spec=RangeSpec(min=0, max=1, step=0.01),\n advanced=True,\n ),\n IntInput(\n name=\"max_tokens\",\n display_name=\"Max Tokens\",\n info=\"Maximum number of tokens to generate. Leave empty for the model default.\",\n advanced=True,\n ),\n IntInput(\n name=\"seed\",\n display_name=\"Seed\",\n info=\"The seed controls the reproducibility of the job.\",\n advanced=True,\n value=1,\n ),\n ]\n\n def build_model(self) -> LanguageModel:\n api_key = _as_str(self.api_key)\n api_base = _as_str(self.api_base)\n if api_base:\n api_base = api_base.rstrip(\"/\")\n\n kwargs: dict[str, Any] = {\n \"model\": self.model_name,\n \"api_key\": api_key,\n \"base_url\": api_base or None,\n \"streaming\": bool(getattr(self, \"stream\", False)),\n }\n max_tokens = getattr(self, \"max_tokens\", None)\n if max_tokens:\n kwargs[\"max_tokens\"] = max_tokens\n temperature = getattr(self, \"temperature\", None)\n if temperature is not None:\n kwargs[\"temperature\"] = temperature\n seed = getattr(self, \"seed\", None)\n if seed is not None:\n kwargs[\"seed\"] = seed\n return ChatOpenAI(**kwargs)\n"
+ "value": "\"\"\"OpenAI-compatible chat model that talks to the OpenRAG LLM proxy.\n\nLangflow never holds upstream vendor keys. At runtime OpenRAG injects:\n\n- ``OPENRAG_LLM_TOKEN`` — short-lived hop token (Authorization Bearer)\n- ``OPENRAG_LLM_BASE_URL`` — the backend's ``/v1`` base or the router's\n private unversioned base\n- ``SELECTED_LANGUAGE_MODEL`` — configured chat model id\n\n``ChatOpenAI`` posts to ``{base_url}/chat/completions``. The backend gateway\nthen calls the real vendor (OpenAI, Anthropic, Watsonx, Ollama, or any other\nLiteLLM provider). Embeddings use the same base URL and hop token; see\n``openai_compatible_embedding.py``.\n\"\"\"\n\nfrom __future__ import annotations\n\nfrom typing import Any\n\nfrom langchain_openai import ChatOpenAI\nfrom lfx.base.models.model import LCModelComponent\nfrom lfx.field_typing.constants import LanguageModel\nfrom lfx.field_typing.range_spec import RangeSpec\nfrom lfx.inputs.inputs import BoolInput, StrInput\nfrom lfx.io import IntInput, MessageInput, MultilineInput, SecretStrInput, SliderInput\n\n# Names must match src/api/settings/langflow_sync.py + src/utils/langflow_headers.py\nOPENRAG_LLM_BASE_URL_VAR = \"OPENRAG_LLM_BASE_URL\"\nOPENRAG_LLM_TOKEN_VAR = \"OPENRAG_LLM_TOKEN\"\nSELECTED_LANGUAGE_MODEL_VAR = \"SELECTED_LANGUAGE_MODEL\"\n\n\ndef _as_str(value: object) -> str | None:\n if value is None:\n return None\n getter = getattr(value, \"get_secret_value\", None)\n if callable(getter):\n value = getter()\n text = str(value).strip()\n return text or None\n\n\nclass OpenAICompatibleLLMComponent(LCModelComponent):\n display_name = \"OpenRAG LLM\"\n description = (\n \"Chat model via OpenRAG's OpenAI-compatible proxy. \"\n \"Base URL and hop token come from global variables at runtime.\"\n )\n icon = \"OpenRAG\"\n name = \"OpenAICompatibleLLM\"\n\n inputs = [\n MessageInput(\n name=\"input_value\",\n display_name=\"Input\",\n info=\"The input text to send to the model\",\n ),\n MultilineInput(\n name=\"system_message\",\n display_name=\"System Message\",\n info=\"A system message that helps set the behavior of the assistant\",\n advanced=False,\n ),\n BoolInput(\n name=\"stream\",\n display_name=\"Stream\",\n info=\"Whether to stream the response\",\n value=False,\n advanced=True,\n ),\n StrInput(\n name=\"model_name\",\n display_name=\"Model Name\",\n info=\"Chat model id. Bound to SELECTED_LANGUAGE_MODEL at runtime.\",\n value=SELECTED_LANGUAGE_MODEL_VAR,\n load_from_db=True,\n ),\n SecretStrInput(\n name=\"api_key\",\n display_name=\"OpenRAG LLM Token\",\n info=\"Hop token from OPENRAG_LLM_TOKEN. OpenRAG injects this per Langflow run.\",\n value=OPENRAG_LLM_TOKEN_VAR,\n required=False,\n load_from_db=True,\n ),\n StrInput(\n name=\"api_base\",\n display_name=\"OpenAI API Base\",\n info=(\n \"Bound to OPENRAG_LLM_BASE_URL at runtime. It is either the public \"\n \"/v1 base or the private router base. Same URL as embeddings.\"\n ),\n value=OPENRAG_LLM_BASE_URL_VAR,\n load_from_db=True,\n ),\n SliderInput(\n name=\"temperature\",\n display_name=\"Temperature\",\n value=0.1,\n info=\"Controls randomness in responses\",\n range_spec=RangeSpec(min=0, max=1, step=0.01),\n advanced=True,\n ),\n IntInput(\n name=\"max_tokens\",\n display_name=\"Max Tokens\",\n info=\"Maximum number of tokens to generate. Leave empty for the model default.\",\n advanced=True,\n ),\n IntInput(\n name=\"seed\",\n display_name=\"Seed\",\n info=\"The seed controls the reproducibility of the job.\",\n advanced=True,\n value=1,\n ),\n ]\n\n def build_model(self) -> LanguageModel:\n api_key = _as_str(self.api_key)\n api_base = _as_str(self.api_base)\n if api_base:\n api_base = api_base.rstrip(\"/\")\n\n kwargs: dict[str, Any] = {\n \"model\": self.model_name,\n \"api_key\": api_key,\n \"base_url\": api_base or None,\n \"streaming\": bool(getattr(self, \"stream\", False)),\n }\n max_tokens = getattr(self, \"max_tokens\", None)\n if max_tokens:\n kwargs[\"max_tokens\"] = max_tokens\n temperature = getattr(self, \"temperature\", None)\n if temperature is not None:\n kwargs[\"temperature\"] = temperature\n seed = getattr(self, \"seed\", None)\n if seed is not None:\n kwargs[\"seed\"] = seed\n return ChatOpenAI(**kwargs)\n"
},
"input_value": {
"_input_type": "MessageInput",
diff --git a/flows/openrag_url_mcp.json b/flows/openrag_url_mcp.json
index 05927e027..cf65f1863 100644
--- a/flows/openrag_url_mcp.json
+++ b/flows/openrag_url_mcp.json
@@ -5692,7 +5692,7 @@
"icon": "OpenRAG",
"legacy": false,
"metadata": {
- "code_hash": "230c964bdd9f",
+ "code_hash": "d4b6a5d67c0b",
"dependencies": {
"dependencies": [
{
@@ -5809,7 +5809,7 @@
"show": true,
"title_case": false,
"type": "code",
- "value": "\"\"\"OpenAI-compatible embeddings that talk to the OpenRAG `/v1` proxy.\n\nEmbeddings work the same way as chat: Langflow never holds upstream vendor\nkeys. At runtime OpenRAG injects:\n\n- ``OPENRAG_LLM_TOKEN`` — the same short-lived hop token as chat\n- ``OPENRAG_LLM_BASE_URL`` — the same ``http://<backend>/v1`` base URL\n- ``SELECTED_EMBEDDING_MODEL`` — configured embedding model id\n\n``OpenAIEmbeddings`` posts to ``{base_url}/embeddings``. The backend gateway\nroutes by the configured embedding provider (which can differ from the chat\nprovider).\n\"\"\"\n\nfrom __future__ import annotations\n\nfrom typing import Any\n\nfrom langchain_core.embeddings import Embeddings\nfrom langchain_openai import OpenAIEmbeddings\nfrom lfx.base.embeddings.model import LCEmbeddingsModel\nfrom lfx.io import IntInput, SecretStrInput, StrInput\n\n# Names must match src/api/settings/langflow_sync.py + src/utils/langflow_headers.py\nOPENRAG_LLM_BASE_URL_VAR = \"OPENRAG_LLM_BASE_URL\"\nOPENRAG_LLM_TOKEN_VAR = \"OPENRAG_LLM_TOKEN\"\nSELECTED_EMBEDDING_MODEL_VAR = \"SELECTED_EMBEDDING_MODEL\"\nSELECTED_EMBEDDING_PROVIDER_VAR = \"SELECTED_EMBEDDING_PROVIDER\"\nLEGACY_EMBEDDING_ROUTE_PREFIX = \"legacy:\"\nINDEXED_EMBEDDING_ROUTE_PREFIX = \"space:\"\n\n\ndef _as_str(value: object) -> str | None:\n if value is None:\n return None\n getter = getattr(value, \"get_secret_value\", None)\n if callable(getter):\n value = getter()\n text = str(value).strip()\n return text or None\n\n\ndef _embedding_route_identity(route: str) -> tuple[str | None, str]:\n \"\"\"Return the provider and model identity encoded in a retrieval route.\"\"\"\n if route.startswith(LEGACY_EMBEDDING_ROUTE_PREFIX):\n return None, route.removeprefix(LEGACY_EMBEDDING_ROUTE_PREFIX)\n if route.startswith(INDEXED_EMBEDDING_ROUTE_PREFIX):\n qualified = route.removeprefix(INDEXED_EMBEDDING_ROUTE_PREFIX)\n provider, separator, model_name = qualified.partition(\":\")\n if separator and provider and model_name:\n return provider.lower(), model_name\n return None, qualified\n return None, route\n\n\nclass OpenRAGEmbeddings(Embeddings):\n \"\"\"One immutable model route plus a factory for other retrieval routes.\"\"\"\n\n def __init__(\n self,\n *,\n model_name: str,\n api_key: str | None,\n api_base: str | None,\n provider_name: str | None = None,\n chunk_size: int | None = None,\n dimensions: int | None = None,\n ) -> None:\n self.model = model_name\n self.deployment = model_name\n self._api_key = api_key\n self._api_base = api_base\n self._provider_name = (provider_name or \"openai\").strip().lower()\n self._chunk_size = chunk_size\n self._dimensions = dimensions\n\n kwargs: dict[str, Any] = {\n \"model\": self.model,\n # Keep identity aligned with ``model``. LangChain otherwise exposes\n # its ada-002 class default as the deployment for every instance.\n \"deployment\": self.model_name,\n \"api_key\": api_key,\n \"base_url\": api_base,\n \"check_embedding_ctx_length\": False,\n }\n if chunk_size:\n kwargs[\"chunk_size\"] = chunk_size\n if dimensions:\n kwargs[\"dimensions\"] = dimensions\n self._delegate = OpenAIEmbeddings(**kwargs)\n\n @property\n def model_name(self) -> str:\n return self.model\n\n def for_model(self, model_name: str) -> Embeddings:\n \"\"\"Return a dedicated adapter; never mutate the selected ingestion model.\"\"\"\n route = (model_name or \"\").strip()\n if not route:\n raise ValueError(\"Embedding model route is required\")\n route_provider, route_model = _embedding_route_identity(route)\n is_selected_route = route_provider == self._provider_name and route_model == self.model_name\n dimensions = self._dimensions if is_selected_route else None\n return OpenRAGEmbeddings(\n model_name=route,\n api_key=self._api_key,\n api_base=self._api_base,\n provider_name=self._provider_name,\n chunk_size=self._chunk_size,\n dimensions=dimensions,\n )\n\n def embed_documents(self, texts: list[str]) -> list[list[float]]:\n return self._delegate.embed_documents(texts)\n\n def embed_query(self, text: str) -> list[float]:\n return self._delegate.embed_query(text)\n\n async def aembed_documents(self, texts: list[str]) -> list[list[float]]:\n return await self._delegate.aembed_documents(texts)\n\n async def aembed_query(self, text: str) -> list[float]:\n return await self._delegate.aembed_query(text)\n\n\nclass OpenAICompatibleEmbeddingComponent(LCEmbeddingsModel):\n display_name = \"OpenRAG Embeddings\"\n description = (\n \"Embeddings via OpenRAG's OpenAI-compatible /v1 proxy. \"\n \"Uses the same base URL and hop token as the chat component.\"\n )\n icon = \"OpenRAG\"\n name = \"OpenAICompatibleEmbedding\"\n\n inputs = [\n StrInput(\n name=\"model_name\",\n display_name=\"Model Name\",\n info=\"Embedding model id. Bound to SELECTED_EMBEDDING_MODEL at runtime.\",\n value=SELECTED_EMBEDDING_MODEL_VAR,\n load_from_db=True,\n ),\n StrInput(\n name=\"provider_name\",\n display_name=\"Provider Name\",\n info=\"Embedding provider id. Bound to SELECTED_EMBEDDING_PROVIDER at runtime.\",\n value=SELECTED_EMBEDDING_PROVIDER_VAR,\n load_from_db=True,\n ),\n SecretStrInput(\n name=\"api_key\",\n display_name=\"OpenRAG LLM Token\",\n info=\"Hop token from OPENRAG_LLM_TOKEN. Same token as the chat component.\",\n value=OPENRAG_LLM_TOKEN_VAR,\n required=False,\n load_from_db=True,\n ),\n StrInput(\n name=\"api_base\",\n display_name=\"OpenAI API Base\",\n info=(\n \"Must end with /v1 (for example http://openrag-backend:8000/v1). \"\n \"Bound to OPENRAG_LLM_BASE_URL at runtime. Same URL as chat.\"\n ),\n value=OPENRAG_LLM_BASE_URL_VAR,\n load_from_db=True,\n ),\n IntInput(\n name=\"dimensions\",\n display_name=\"Dimensions\",\n info=\"Output dimensions when the embedding model supports it.\",\n advanced=True,\n ),\n IntInput(\n name=\"chunk_size\",\n display_name=\"Chunk Size\",\n advanced=True,\n value=1000,\n ),\n ]\n\n def build_embeddings(self) -> Embeddings:\n api_key = _as_str(self.api_key)\n api_base = _as_str(self.api_base)\n if api_base:\n api_base = api_base.rstrip(\"/\")\n return OpenRAGEmbeddings(\n model_name=self.model_name,\n api_key=api_key,\n api_base=api_base,\n provider_name=getattr(self, \"provider_name\", None),\n chunk_size=getattr(self, \"chunk_size\", None),\n dimensions=getattr(self, \"dimensions\", None),\n )\n"
+ "value": "\"\"\"OpenAI-compatible embeddings that talk to the OpenRAG LLM proxy.\n\nEmbeddings work the same way as chat: Langflow never holds upstream vendor\nkeys. At runtime OpenRAG injects:\n\n- ``OPENRAG_LLM_TOKEN`` — the same short-lived hop token as chat\n- ``OPENRAG_LLM_BASE_URL`` — the backend's ``/v1`` base or the router's\n private unversioned base\n- ``SELECTED_EMBEDDING_MODEL`` — configured embedding model id\n\n``OpenAIEmbeddings`` posts to ``{base_url}/embeddings``. The backend gateway\nroutes by the configured embedding provider (which can differ from the chat\nprovider).\n\"\"\"\n\nfrom __future__ import annotations\n\nfrom typing import Any\n\nfrom langchain_core.embeddings import Embeddings\nfrom langchain_openai import OpenAIEmbeddings\nfrom lfx.base.embeddings.model import LCEmbeddingsModel\nfrom lfx.io import IntInput, SecretStrInput, StrInput\n\n# Names must match src/api/settings/langflow_sync.py + src/utils/langflow_headers.py\nOPENRAG_LLM_BASE_URL_VAR = \"OPENRAG_LLM_BASE_URL\"\nOPENRAG_LLM_TOKEN_VAR = \"OPENRAG_LLM_TOKEN\"\nSELECTED_EMBEDDING_MODEL_VAR = \"SELECTED_EMBEDDING_MODEL\"\nSELECTED_EMBEDDING_PROVIDER_VAR = \"SELECTED_EMBEDDING_PROVIDER\"\nLEGACY_EMBEDDING_ROUTE_PREFIX = \"legacy:\"\nINDEXED_EMBEDDING_ROUTE_PREFIX = \"space:\"\n\n\ndef _as_str(value: object) -> str | None:\n if value is None:\n return None\n getter = getattr(value, \"get_secret_value\", None)\n if callable(getter):\n value = getter()\n text = str(value).strip()\n return text or None\n\n\ndef _embedding_route_identity(route: str) -> tuple[str | None, str]:\n \"\"\"Return the provider and model identity encoded in a retrieval route.\"\"\"\n if route.startswith(LEGACY_EMBEDDING_ROUTE_PREFIX):\n return None, route.removeprefix(LEGACY_EMBEDDING_ROUTE_PREFIX)\n if route.startswith(INDEXED_EMBEDDING_ROUTE_PREFIX):\n qualified = route.removeprefix(INDEXED_EMBEDDING_ROUTE_PREFIX)\n provider, separator, model_name = qualified.partition(\":\")\n if separator and provider and model_name:\n return provider.lower(), model_name\n return None, qualified\n return None, route\n\n\nclass OpenRAGEmbeddings(Embeddings):\n \"\"\"One immutable model route plus a factory for other retrieval routes.\"\"\"\n\n def __init__(\n self,\n *,\n model_name: str,\n api_key: str | None,\n api_base: str | None,\n provider_name: str | None = None,\n chunk_size: int | None = None,\n dimensions: int | None = None,\n ) -> None:\n self.model = model_name\n self.deployment = model_name\n self._api_key = api_key\n self._api_base = api_base\n self._provider_name = (provider_name or \"openai\").strip().lower()\n self._chunk_size = chunk_size\n self._dimensions = dimensions\n\n kwargs: dict[str, Any] = {\n \"model\": self.model,\n # Keep identity aligned with ``model``. LangChain otherwise exposes\n # its ada-002 class default as the deployment for every instance.\n \"deployment\": self.model_name,\n \"api_key\": api_key,\n \"base_url\": api_base,\n \"check_embedding_ctx_length\": False,\n }\n if chunk_size:\n kwargs[\"chunk_size\"] = chunk_size\n if dimensions:\n kwargs[\"dimensions\"] = dimensions\n self._delegate = OpenAIEmbeddings(**kwargs)\n\n @property\n def model_name(self) -> str:\n return self.model\n\n def for_model(self, model_name: str) -> Embeddings:\n \"\"\"Return a dedicated adapter; never mutate the selected ingestion model.\"\"\"\n route = (model_name or \"\").strip()\n if not route:\n raise ValueError(\"Embedding model route is required\")\n route_provider, route_model = _embedding_route_identity(route)\n is_selected_route = route_provider == self._provider_name and route_model == self.model_name\n dimensions = self._dimensions if is_selected_route else None\n return OpenRAGEmbeddings(\n model_name=route,\n api_key=self._api_key,\n api_base=self._api_base,\n provider_name=self._provider_name,\n chunk_size=self._chunk_size,\n dimensions=dimensions,\n )\n\n def embed_documents(self, texts: list[str]) -> list[list[float]]:\n return self._delegate.embed_documents(texts)\n\n def embed_query(self, text: str) -> list[float]:\n return self._delegate.embed_query(text)\n\n async def aembed_documents(self, texts: list[str]) -> list[list[float]]:\n return await self._delegate.aembed_documents(texts)\n\n async def aembed_query(self, text: str) -> list[float]:\n return await self._delegate.aembed_query(text)\n\n\nclass OpenAICompatibleEmbeddingComponent(LCEmbeddingsModel):\n display_name = \"OpenRAG Embeddings\"\n description = (\n \"Embeddings via OpenRAG's OpenAI-compatible proxy. \"\n \"Uses the same base URL and hop token as the chat component.\"\n )\n icon = \"OpenRAG\"\n name = \"OpenAICompatibleEmbedding\"\n\n inputs = [\n StrInput(\n name=\"model_name\",\n display_name=\"Model Name\",\n info=\"Embedding model id. Bound to SELECTED_EMBEDDING_MODEL at runtime.\",\n value=SELECTED_EMBEDDING_MODEL_VAR,\n load_from_db=True,\n ),\n StrInput(\n name=\"provider_name\",\n display_name=\"Provider Name\",\n info=\"Embedding provider id. Bound to SELECTED_EMBEDDING_PROVIDER at runtime.\",\n value=SELECTED_EMBEDDING_PROVIDER_VAR,\n load_from_db=True,\n ),\n SecretStrInput(\n name=\"api_key\",\n display_name=\"OpenRAG LLM Token\",\n info=\"Hop token from OPENRAG_LLM_TOKEN. Same token as the chat component.\",\n value=OPENRAG_LLM_TOKEN_VAR,\n required=False,\n load_from_db=True,\n ),\n StrInput(\n name=\"api_base\",\n display_name=\"OpenAI API Base\",\n info=(\n \"Bound to OPENRAG_LLM_BASE_URL at runtime. It is either the public \"\n \"/v1 base or the private router base. Same URL as chat.\"\n ),\n value=OPENRAG_LLM_BASE_URL_VAR,\n load_from_db=True,\n ),\n IntInput(\n name=\"dimensions\",\n display_name=\"Dimensions\",\n info=\"Output dimensions when the embedding model supports it.\",\n advanced=True,\n ),\n IntInput(\n name=\"chunk_size\",\n display_name=\"Chunk Size\",\n advanced=True,\n value=1000,\n ),\n ]\n\n def build_embeddings(self) -> Embeddings:\n api_key = _as_str(self.api_key)\n api_base = _as_str(self.api_base)\n if api_base:\n api_base = api_base.rstrip(\"/\")\n return OpenRAGEmbeddings(\n model_name=self.model_name,\n api_key=api_key,\n api_base=api_base,\n provider_name=getattr(self, \"provider_name\", None),\n chunk_size=getattr(self, \"chunk_size\", None),\n dimensions=getattr(self, \"dimensions\", None),\n )\n"
},
"dimensions": {
"_input_type": "IntInput",
diff --git a/src/app/router_app.py b/src/app/router_app.py
index 805dd144b..126626eba 100644
--- a/src/app/router_app.py
+++ b/src/app/router_app.py
@@ -1,10 +1,11 @@
-"""Standalone ingestion-callback proxy router.
+"""Standalone Langflow proxy router.
A deliberately tiny FastAPI/uvicorn app that exposes ONLY the Langflow ingest
-callback endpoint (``POST /internal/ingest/chunks``) and forwards it to the real
-backend. It runs in the same process as the main backend (a daemon thread on its
-own port) when ``OPENRAG_BACKEND_ROUTER_ENABLE`` is set, so Langflow's reachable
-surface narrows to this single route instead of the full backend internal API.
+callback endpoint and the OpenAI-compatible LLM paths Langflow needs, then
+forwards them to the real backend. It runs in the same process as the main
+backend (a daemon thread on its own port) when ``OPENRAG_BACKEND_ROUTER_ENABLE``
+is set, so Langflow's reachable surface is an explicit allowlist rather than
+the full backend internal API.
It is a thin reverse proxy only — it does NOT validate the ingest JWT; the real
backend still does. Its sole job is network-surface isolation.
@@ -17,6 +18,7 @@ import threading
import httpx
import uvicorn
from fastapi import FastAPI, Request, Response
+from fastapi.responses import StreamingResponse
from app.middleware import RequestLoggingMiddleware
from config.settings import (
@@ -34,10 +36,20 @@ logger = get_logger(__name__)
# advertised service name, which may not resolve from where the router runs).
_UPSTREAM_URL = f"{OPENRAG_BACKEND_ROUTER_UPSTREAM_URL}{INGEST_CALLBACK_PATH}"
+# Deliberately exact private paths: Langflow gets an unversioned internal
+# interface, while the router maps each one to the backend's public /v1 API.
+# Do not proxy arbitrary paths. This app runs on a separate port from FastMCP;
+# the mapping ensures neither /mcp nor any public /v1 path is exposed here.
+_LLM_PROXY_UPSTREAM_PATHS = {
+ "/models": "/v1/models",
+ "/chat/completions": "/v1/chat/completions",
+ "/embeddings": "/v1/embeddings",
+}
+
# Only these request headers are forwarded upstream; everything else (Host,
# hop-by-hop headers, etc.) is dropped so the router cannot be abused as an open
# proxy. The ingest token travels in either Authorization or the custom header.
-_FORWARDED_HEADERS = ("authorization", "x-openrag-ingest-token", "content-type")
+_FORWARDED_HEADERS = ("authorization", "x-openrag-ingest-token", "content-type", "accept")
_UPSTREAM_TIMEOUT = httpx.Timeout(60.0)
@@ -75,14 +87,74 @@ async def _proxy_ingest_chunks(request: Request) -> Response:
)
+async def _proxy_llm_request(request: Request) -> Response:
+ """Proxy one allowlisted OpenAI-compatible request to the main backend.
+
+ The response is streamed so chat-completion SSE responses retain their
+ streaming behaviour. Authentication is still verified by the real backend.
+ """
+ upstream_path = _LLM_PROXY_UPSTREAM_PATHS.get(request.url.path)
+ if upstream_path is None: # Defensive guard if a route is changed.
+ return Response(status_code=404)
+
+ upstream_url = f"{OPENRAG_BACKEND_ROUTER_UPSTREAM_URL}{upstream_path}"
+ body = await request.body()
+ headers = {
+ key: value for key, value in request.headers.items() if key.lower() in _FORWARDED_HEADERS
+ }
+ client = httpx.AsyncClient(timeout=_UPSTREAM_TIMEOUT)
+ try:
+ upstream = await client.send(
+ client.build_request(
+ request.method,
+ upstream_url,
+ content=body,
+ headers=headers,
+ params=request.query_params,
+ ),
+ stream=True,
+ )
+ except httpx.HTTPError as e:
+ await client.aclose()
+ logger.error(
+ "[Router] LLM proxy failed to reach backend", upstream=upstream_url, error=str(e)
+ )
+ return Response(
+ content=b'{"error":{"message":"LLM proxy upstream unreachable","type":"api_error"}}',
+ status_code=502,
+ media_type="application/json",
+ )
+
+ async def stream_body():
+ try:
+ async for chunk in upstream.aiter_raw():
+ yield chunk
+ finally:
+ await upstream.aclose()
+ await client.aclose()
+
+ response_headers = {
+ key: value
+ for key, value in upstream.headers.items()
+ if key.lower() in {"content-type", "cache-control", "x-accel-buffering"}
+ }
+ logger.info(
+ "[Router] Forwarding LLM proxy request", upstream=upstream_url, method=request.method
+ )
+ return StreamingResponse(
+ stream_body(), status_code=upstream.status_code, headers=response_headers
+ )
+
+
async def _health() -> dict[str, str]:
return {"status": "ok"}
def create_router_app() -> FastAPI:
- """Build the minimal proxy app: only the ingest callback + a health probe.
+ """Build the allowlisted Langflow proxy app and a health probe.
- No other paths are registered, so every other request returns 404.
+ No other paths are registered, so MCP and every non-allowlisted path return
+ 404 on this port.
"""
app = FastAPI(
title="OpenRAG Ingest Router",
@@ -95,6 +167,9 @@ def create_router_app() -> FastAPI:
# stdout as the backend. Without this, uvicorn.access is globally silenced.
app.add_middleware(RequestLoggingMiddleware)
app.add_api_route(INGEST_CALLBACK_PATH, _proxy_ingest_chunks, methods=["POST"])
+ app.add_api_route("/models", _proxy_llm_request, methods=["GET"])
+ app.add_api_route("/chat/completions", _proxy_llm_request, methods=["POST"])
+ app.add_api_route("/embeddings", _proxy_llm_request, methods=["POST"])
app.add_api_route("/health", _health, methods=["GET"])
return app
diff --git a/src/config/settings.py b/src/config/settings.py
index 9bb9e875b..2c7478f71 100644
--- a/src/config/settings.py
+++ b/src/config/settings.py
@@ -128,14 +128,20 @@ OPENRAG_BACKEND_INTERNAL_URL = os.getenv(
def get_langflow_llm_base_url() -> str:
- """OpenAI-compatible base URL Langflow should call (must end with /v1).
+ """OpenAI-compatible base URL Langflow should call.
- Override with OPENRAG_LLM_PROXY_URL when Langflow cannot reach
- OPENRAG_BACKEND_INTERNAL_URL (rare; same cases as a custom ingest router).
+ When the narrowed backend router is enabled, Langflow uses its private,
+ unversioned LLM paths; the router maps them onto the backend's public /v1
+ API. SaaS network policy exposes that port rather than the full backend.
+
+ OPENRAG_LLM_PROXY_URL remains an explicit escape hatch for deployments
+ with a separate proxy or Service.
"""
override = os.getenv("OPENRAG_LLM_PROXY_URL")
if override:
return override.rstrip("/")
+ if OPENRAG_BACKEND_ROUTER_ENABLE:
+ return OPENRAG_BACKEND_ROUTER_URL
return f"{OPENRAG_BACKEND_INTERNAL_URL}/v1"
diff --git a/src/mcp_http/server.py b/src/mcp_http/server.py
index 35503195c..78d18de07 100644
--- a/src/mcp_http/server.py
+++ b/src/mcp_http/server.py
@@ -155,15 +155,7 @@ COMPONENT_CUSTOMIZATIONS: dict[tuple[str, str], dict[str, str]] = {
"system prompt, and document processing options."
),
},
- # Models / LLM proxy
- ("/v1/models", "GET"): {
- "name": "openrag_list_openai_models",
- "description": (
- "List every language and embedding model OpenRAG can serve, in OpenAI "
- "`GET /v1/models` format. Use this from an OpenAI-compatible client "
- "pointed at the LLM proxy."
- ),
- },
+ # Models
("/v1/model-catalog", "GET"): {
"name": "openrag_model_catalog",
"description": (
@@ -178,21 +170,6 @@ COMPONENT_CUSTOMIZATIONS: dict[tuple[str, str], dict[str, str]] = {
"(oss / on_prem / saas), with their display names."
),
},
- ("/v1/chat/completions", "POST"): {
- "name": "openrag_chat_completions",
- "description": (
- "OpenAI-compatible chat completions. OpenRAG routes to the configured "
- "provider via LiteLLM. Send a Langflow hop token, user JWT, or orag_ "
- "API key as Bearer."
- ),
- },
- ("/v1/embeddings", "POST"): {
- "name": "openrag_embeddings",
- "description": (
- "OpenAI-compatible embeddings. OpenRAG routes to the configured "
- "embedding provider via LiteLLM."
- ),
- },
("/v1/models/{provider}", "GET"): {
"name": "openrag_list_models",
"description": (
@@ -273,7 +250,7 @@ def create_mcp_server(app: FastAPI) -> FastMCP:
FastMCP.from_fastapi() can discover them.
Route mapping:
- - POST /v1/documents/ingest → excluded (multipart not supported by FastMCP proxy)
+ - Langflow-only LLM proxy endpoints and POST /v1/documents/ingest → excluded
- /v1/* routes → MCP tools (GET, POST, PUT, DELETE, PATCH)
- GET /v2/files, GET /v2/files/search → MCP tools
- all other routes → excluded
@@ -285,6 +262,19 @@ def create_mcp_server(app: FastAPI) -> FastMCP:
operations like `openrag_get_knowledge_filter` callable in agent loops.
"""
route_maps = [
+ # Exclude Langflow-only LLM proxy endpoints. They accept the short-lived
+ # Langflow hop token and are transport plumbing, not agent capabilities.
+ # Keep these exact patterns ahead of the /v1 catch-all.
+ RouteMap(
+ methods=["GET"],
+ pattern=r"^/v1/models$",
+ mcp_type=MCPType.EXCLUDE,
+ ),
+ RouteMap(
+ methods=["POST"],
+ pattern=r"^/v1/chat/completions$|^/v1/embeddings$",
+ mcp_type=MCPType.EXCLUDE,
+ ),
# Exclude /v1/documents/ingest: multipart/form-data file uploads are
# not supported through FastMCP's from_fastapi proxy (the LLM-facing
# base64-array schema does not get marshaled back into multipart on
diff --git a/tests/unit/test_backend_router.py b/tests/unit/test_backend_router.py
index e168e6cbc..0a3149b21 100644
--- a/tests/unit/test_backend_router.py
+++ b/tests/unit/test_backend_router.py
@@ -1,5 +1,4 @@
-"""Tests for the standalone ingestion-callback proxy router and the callback-URL
-selection helper that points Langflow at it."""
+"""Tests for the standalone allowlisted Langflow proxy router."""
import pytest
from fastapi.testclient import TestClient
@@ -44,6 +43,25 @@ def test_callback_url_uses_backend_when_disabled(monkeypatch):
assert settings.get_ingest_callback_url() == "http://be:8000/internal/ingest/chunks"
+def test_llm_base_url_uses_router_when_enabled(monkeypatch):
+ monkeypatch.setattr(settings, "OPENRAG_BACKEND_ROUTER_ENABLE", True)
+ monkeypatch.setattr(settings, "OPENRAG_BACKEND_ROUTER_URL", "http://router:8100")
+ assert settings.get_langflow_llm_base_url() == "http://router:8100"
+
+
+def test_llm_base_url_uses_backend_when_router_disabled(monkeypatch):
+ monkeypatch.delenv("OPENRAG_LLM_PROXY_URL", raising=False)
+ monkeypatch.setattr(settings, "OPENRAG_BACKEND_ROUTER_ENABLE", False)
+ monkeypatch.setattr(settings, "OPENRAG_BACKEND_INTERNAL_URL", "http://be:8000")
+ assert settings.get_langflow_llm_base_url() == "http://be:8000/v1"
+
+
+def test_llm_base_url_override_wins_over_router(monkeypatch):
+ monkeypatch.setenv("OPENRAG_LLM_PROXY_URL", "https://llm-proxy.example/v1/")
+ monkeypatch.setattr(settings, "OPENRAG_BACKEND_ROUTER_ENABLE", True)
+ assert settings.get_langflow_llm_base_url() == "https://llm-proxy.example/v1"
+
+
def test_router_url_derives_backend_host_on_router_port(monkeypatch):
monkeypatch.setattr(settings, "OPENRAG_BACKEND_INTERNAL_URL", "http://openrag-be:8000")
monkeypatch.setattr(settings, "OPENRAG_BACKEND_ROUTER_PORT", 8100)
@@ -79,6 +97,34 @@ class _FakeClient:
return _FakeResponse(200, b'{"status":"ok"}', {"content-type": "application/json"})
+class _FakeStreamingResponse(_FakeResponse):
+ async def aiter_raw(self):
+ yield self.content
+
+ async def aclose(self):
+ pass
+
+
+class _FakeLlmClient:
+ def __init__(self, captured):
+ self._captured = captured
+
+ def build_request(self, method, url, content=None, headers=None, params=None):
+ self._captured.update(
+ method=method, url=url, content=content, headers=headers, params=dict(params or {})
+ )
+ return object()
+
+ async def send(self, request, stream=False):
+ self._captured["stream"] = stream
+ return _FakeStreamingResponse(
+ 200, b'{"object":"list","data":[]}', {"content-type": "application/json"}
+ )
+
+ async def aclose(self):
+ pass
+
+
def test_proxy_forwards_only_allowlisted_headers(monkeypatch):
captured: dict = {}
monkeypatch.setattr(router_app.httpx, "AsyncClient", lambda *a, **k: _FakeClient(captured))
@@ -120,10 +166,40 @@ def test_proxy_returns_502_when_upstream_unreachable(monkeypatch):
assert resp.status_code == 502
-def test_router_exposes_only_the_callback_and_health():
+def test_llm_proxy_forwards_only_allowlisted_headers_and_maps_private_path(monkeypatch):
+ captured: dict = {}
+ monkeypatch.setattr(router_app.httpx, "AsyncClient", lambda *a, **k: _FakeLlmClient(captured))
+
+ client = TestClient(router_app.create_router_app())
+ resp = client.post(
+ "/embeddings?trace=1",
+ content=b'{"model":"text-embedding-3-small","input":"hello"}',
+ headers={
+ "Authorization": "Bearer hop-token",
+ "Content-Type": "application/json",
+ "Accept": "application/json",
+ "X-Evil": "should-be-dropped",
+ },
+ )
+
+ assert resp.status_code == 200
+ assert resp.json() == {"object": "list", "data": []}
+ assert captured["url"] == f"{router_app.OPENRAG_BACKEND_ROUTER_UPSTREAM_URL}/v1/embeddings"
+ assert captured["params"] == {"trace": "1"}
+ assert captured["stream"] is True
+ forwarded = {key.lower() for key in captured["headers"]}
+ assert {"authorization", "content-type", "accept"} <= forwarded
+ assert "x-evil" not in forwarded
+
+
+def test_router_exposes_only_allowlisted_paths_and_health():
client = TestClient(router_app.create_router_app())
assert client.get("/health").status_code == 200
- # No other path is registered.
+ # No arbitrary proxying, and FastMCP's streamable HTTP endpoint is not
+ # exposed by this separate router app.
assert client.get("/some/other/path").status_code == 404
+ assert client.get("/mcp").status_code == 404
+ assert client.get("/v1/embeddings").status_code == 404
+ assert client.get("/v1/anything-else").status_code == 404
# Callback is POST-only.
assert client.get("/internal/ingest/chunks").status_code == 405
diff --git a/tests/unit/test_mcp_llm_proxy_exclusion.py b/tests/unit/test_mcp_llm_proxy_exclusion.py
new file mode 100644
index 000000000..362903634
--- /dev/null
+++ b/tests/unit/test_mcp_llm_proxy_exclusion.py
@@ -0,0 +1,25 @@
+"""The Langflow LLM proxy must never be exposed as a FastMCP tool."""
+
+from mcp_http.server import MCPType, RouteMap, create_mcp_server
+
+
+def test_langflow_llm_proxy_routes_are_excluded_before_the_v1_tool_catch_all(monkeypatch):
+ captured: dict[str, list[RouteMap]] = {}
+
+ def fake_from_fastapi(*, app, name, route_maps, mcp_component_fn):
+ captured["route_maps"] = route_maps
+ return object()
+
+ monkeypatch.setattr("mcp_http.server.FastMCP.from_fastapi", fake_from_fastapi)
+ create_mcp_server(object())
+
+ route_maps = captured["route_maps"]
+ excluded = [route_map for route_map in route_maps if route_map.mcp_type is MCPType.EXCLUDE]
+ patterns = {route_map.pattern for route_map in excluded}
+ assert r"^/v1/models$" in patterns
+ assert r"^/v1/chat/completions$|^/v1/embeddings$" in patterns
+
+ catch_all_index = next(
+ index for index, route_map in enumerate(route_maps) if route_map.pattern == r"^/v1/"
+ )
+ assert all(route_maps.index(route_map) < catch_all_index for route_map in excluded[:3])