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.pyindex 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 vendorkeys. 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.pyindex 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.jsonindex 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.jsonindex 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.jsonindex 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.jsonindex 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.pyindex 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 realbackend still does. Its sole job is network-surface isolation.@@ -17,6 +18,7 @@ import threadingimport httpximport uvicornfrom fastapi import FastAPI, Request, Response+from fastapi.responses import StreamingResponsefrom app.middleware import RequestLoggingMiddlewarefrom 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 appdiff --git a/src/config/settings.py b/src/config/settings.pyindex 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_URLreturn f"{OPENRAG_BACKEND_INTERNAL_URL}/v1"diff --git a/src/mcp_http/server.py b/src/mcp_http/server.pyindex 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 ondiff --git a/tests/unit/test_backend_router.py b/tests/unit/test_backend_router.pyindex 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 pytestfrom 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 == 405diff --git a/tests/unit/test_mcp_llm_proxy_exclusion.py b/tests/unit/test_mcp_llm_proxy_exclusion.pynew file mode 100644index 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])