OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.
Python
from typing import Any
from tenacity import (
retry,
retry_if_exception_type,
stop_after_attempt,
wait_exponential,
)
from config.settings import MCP_URL_PATTERNS, clients
from utils.logging_config import get_logger
logger = get_logger(__name__)
REQUIRED_MCP_HEADERS: dict[str, str] = {
"X-Langflow-Global-Var-OPENRAG_INGEST_URL": "OPENRAG_INGEST_URL",
"X-Langflow-Global-Var-OPENRAG_INGEST_TOKEN": "OPENRAG_INGEST_TOKEN",
"X-Langflow-Global-Var-OPENRAG_INGEST_RUN_ID": "OPENRAG_INGEST_RUN_ID",
"X-Langflow-Global-Var-OPENRAG_INGEST_BATCH_SIZE": "OPENRAG_INGEST_BATCH_SIZE",
"X-Langflow-Global-Var-SELECTED_EMBEDDING_MODEL": "SELECTED_EMBEDDING_MODEL",
"X-Langflow-Global-Var-SELECTED_EMBEDDING_PROVIDER": "SELECTED_EMBEDDING_MODEL_PROVIDER",
"X-Langflow-Global-Var-OPENSEARCH_URL": "OPENSEARCH_URL",
"X-Langflow-Global-Var-OPENRAG_LLM_BASE_URL": "OPENRAG_LLM_BASE_URL",
"X-Langflow-Global-Var-OPENRAG_LLM_TOKEN": "OPENRAG_LLM_TOKEN",
}
class MCPServerURLUpdateError(Exception):
def __init__(self, message: str, summary: dict[str, Any]):
super().__init__(message)
self.summary = summary
class LangflowMCPService:
@retry(
stop=stop_after_attempt(3),
wait=wait_exponential(multiplier=1, min=1, max=4),
retry=retry_if_exception_type(Exception),
reraise=True,
)
async def _list_mcp_servers_with_retry(self) -> list[dict[str, Any]]:
"""Internal method with retry logic for listing MCP servers."""
response = await clients.langflow_request(
method="GET",
endpoint="/api/v2/mcp/servers",
params={"action_count": "false"},
)
response.raise_for_status()
data = response.json()
if isinstance(data, list):
return data
logger.warning(
"Unexpected response format for MCP servers list",
data_type=type(data).__name__,
)
return []
async def list_mcp_servers(self) -> list[dict[str, Any]]:
"""Fetch list of MCP servers from Langflow (v2 API).
Includes retry logic to handle startup timing issues.
"""
try:
return await self._list_mcp_servers_with_retry()
except Exception as e:
logger.error("Failed to list MCP servers after retries", error=str(e))
return []
async def get_mcp_server(self, server_name: str) -> dict[str, Any]:
"""Get MCP server configuration by name."""
response = await clients.langflow_request(
method="GET",
endpoint=f"/api/v2/mcp/servers/{server_name}",
)
response.raise_for_status()
return response.json()
def _parse_stdio_args(self, args: list[str]) -> tuple[str | None, dict[str, str]]:
"""Extract URL and headers from stdio args.
Args format: [URL, "--headers", key1, value1, "--headers", key2, value2, ...]
or: ["--transport", "sse", URL, "--headers", ...]
Returns: (url, headers_dict)
"""
if not isinstance(args, list) or not args:
return None, {}
url: str | None = None
headers: dict[str, str] = {}
url_index: int = -1
# Find the URL by scanning for http:// or https://
for idx, arg in enumerate(args):
if isinstance(arg, str) and (arg.startswith("http://") or arg.startswith("https://")):
url = arg
url_index = idx
break
# Parse --headers triplets: --headers key value
i = 0
while i < len(args):
# Skip the URL element
if i == url_index:
i += 1
continue
token = args[i]
if token == "--headers" and i + 2 < len(args):
header_key = args[i + 1]
header_value = args[i + 2]
if isinstance(header_key, str) and isinstance(header_value, str):
headers[header_key] = header_value
i += 3
else:
i += 1
return url, headers
def _is_convertible_to_streamable_http(self, server_config: dict[str, Any]) -> bool:
"""Check if stdio server can be converted to streamable HTTP.
Returns True if:
- Server has 'command' field (stdio mode)
- Args contain a URL (starting with http:// or https://)
"""
if not server_config.get("command"):
return False
args = server_config.get("args", [])
if not isinstance(args, list) or not args:
return False
# Scan args to find a URL (may not be at position 0)
for arg in args:
if not isinstance(arg, str):
continue
if arg.startswith("http://") or arg.startswith("https://"):
if any(arg.rstrip("/").endswith(pat) or pat in arg for pat in MCP_URL_PATTERNS):
return True
return False
def _is_streamable_http_mode(self, server_config: dict[str, Any]) -> bool:
"""Check if server is in streamable HTTP mode (has url field)."""
return bool(server_config.get("url"))
def _patch_url_with_langflow_url(self, url: str) -> str:
"""Patch the URL to include the Langflow URL.
Args:
url: The URL to patch
Returns:
The patched URL
"""
import os
import re
langflow_url = os.environ.get("LANGFLOW_URL")
if not langflow_url:
return url
# Pattern to match 'http://localhost', 'https://localhost', WITH optional :<port>
pattern = re.compile(r"https?://localhost(:\d+)?", re.IGNORECASE)
if pattern.search(url):
url = pattern.sub(langflow_url.rstrip("/"), url)
logger.debug(f"Patched URL: {url}")
return url
@retry(
stop=stop_after_attempt(3),
wait=wait_exponential(multiplier=0.1, min=0.1, max=1),
retry=retry_if_exception_type(Exception),
reraise=True,
)
async def patch_mcp_server_url(self, server_name: str) -> str:
"""Patch a single MCP server to update the Langflow URL and convert to streamable HTTP if applicable.
Also ensures required global variable headers are configured for lf-starter_project.
Returns 'patched', 'skipped', or 'failed'.
"""
try:
current = await self.get_mcp_server(server_name)
headers = current.get("headers")
if not isinstance(headers, dict):
headers = {}
else:
headers = dict(headers)
headers_updated = False
if server_name == "lf-starter_project":
for k, v in REQUIRED_MCP_HEADERS.items():
if headers.get(k) != v:
headers[k] = v
headers_updated = True
if self._is_convertible_to_streamable_http(current):
# Convert stdio to streamable HTTP: extract URL from args, patch it
args = current.get("args", [])
url, stdio_headers = self._parse_stdio_args(args)
if stdio_headers:
for k, v in stdio_headers.items():
if headers.get(k) != v:
headers[k] = v
headers_updated = True
if url:
payload = {"url": self._patch_url_with_langflow_url(url), "headers": headers}
mode = "streamable_http (converted)"
logger.info(
"Converting MCP server to streamable HTTP",
server_name=server_name,
)
else:
logger.debug(
"Could not extract URL from stdio args, skipping",
server_name=server_name,
)
return "skipped"
elif self._is_streamable_http_mode(current):
url = current.get("url")
patched_url = self._patch_url_with_langflow_url(url)
url_changed = patched_url != url
if not url_changed and not headers_updated:
logger.debug(
"MCP server configuration unchanged, skipping patch",
server_name=server_name,
)
return "skipped"
payload = {"url": patched_url, "headers": headers}
mode = "streamable_http"
else:
# Stdio mode, not convertible — patch URL in args if present
args = current.get("args", [])
patched_args = list(args)
url_patched = False
for i, arg in enumerate(patched_args):
if isinstance(arg, str) and (
arg.startswith("http://") or arg.startswith("https://")
):
new_url = self._patch_url_with_langflow_url(arg)
if new_url != arg:
patched_args[i] = new_url
url_patched = True
if not url_patched and not headers_updated:
logger.debug(
"No URL or headers to patch in stdio args, skipping",
server_name=server_name,
)
return "skipped"
command = current.get("command")
payload = {"command": command, "args": patched_args, "headers": headers}
mode = "stdio"
response = await clients.langflow_request(
method="PATCH",
endpoint=f"/api/v2/mcp/servers/{server_name}",
json=payload,
idempotent=True,
)
if response.status_code in (502, 503, 504):
response.raise_for_status()
if response.status_code in (200, 201):
logger.info(
"Patched MCP server configuration",
server_name=server_name,
mode=mode,
)
return "patched"
else:
logger.warning(
"Failed to patch MCP server configuration",
server_name=server_name,
mode=mode,
status_code=response.status_code,
body=response.text,
)
return "failed"
except Exception as e:
logger.error(
"Exception while patching MCP server configuration",
server_name=server_name,
error=str(e),
)
raise
async def update_all_mcp_server_urls(self, strict: bool = False) -> dict[str, Any]:
"""Fetch all MCP servers and update their URLs (replacing localhost with LANGFLOW_URL).
Also converts eligible stdio servers to streamable HTTP mode and ensures required headers.
Returns a summary dict with counts.
"""
servers = await self.list_mcp_servers()
if not servers:
return {"patched": 0, "skipped": 0, "failed": 0, "total": 0}
patched_count = 0
skipped_count = 0
failed_count = 0
failed_servers = []
for server in servers:
name = server.get("name") or server.get("server") or server.get("id")
if not name:
continue
ok = await self.patch_mcp_server_url(name)
if ok == "patched":
patched_count += 1
elif ok == "skipped":
skipped_count += 1
else:
failed_count += 1
failed_servers.append(name)
summary = {
"patched": patched_count,
"skipped": skipped_count,
"failed": failed_count,
"total": len(servers),
}
if failed_count == 0:
logger.info("MCP servers URL update completed", **summary)
else:
logger.warning("MCP servers URL update had failures", **summary)
if strict and failed_count > 0:
raise MCPServerURLUpdateError(
f"Failed to update MCP server URLs for: {failed_servers}",
summary={**summary, "failed_servers": failed_servers},
)
return summary