OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.
Python
import asyncio
import os
from typing import Any
import pytest
OPENRAG_MCP_SERVER_NAME = "lf-starter_project"
LANGFLOW_GLOBAL_VAR_PREFIX = "x-langflow-global-var-"
MCP_CREDENTIAL_MASK = "********"
async def _wait_for_langflow_client(timeout_s: float = 60.0):
from config.settings import clients
await clients.initialize()
deadline = asyncio.get_event_loop().time() + timeout_s
while asyncio.get_event_loop().time() < deadline:
langflow_client = await clients.ensure_langflow_client()
if langflow_client is not None:
return langflow_client
await asyncio.sleep(1.0)
return None
def _server_name(server: dict[str, Any]) -> str | None:
return server.get("name") or server.get("server") or server.get("id")
def _extract_server_urls(server_config: dict[str, Any]) -> list[str]:
urls = []
url = server_config.get("url")
if isinstance(url, str):
urls.append(url)
args = server_config.get("args", [])
if isinstance(args, list):
urls.extend(
arg
for arg in args
if isinstance(arg, str) and (arg.startswith("http://") or arg.startswith("https://"))
)
return urls
def _extract_server_headers(server_config: dict[str, Any]) -> dict[str, str]:
headers = {}
raw_headers = server_config.get("headers")
if isinstance(raw_headers, dict):
headers.update(
{str(key): str(value) for key, value in raw_headers.items() if value is not None}
)
args = server_config.get("args", [])
if isinstance(args, list):
i = 0
while i < len(args):
if args[i] == "--headers" and i + 2 < len(args):
headers[str(args[i + 1])] = str(args[i + 2])
i += 3
else:
i += 1
return headers
def _assert_has_redacted_required_global_headers(headers: dict[str, str]) -> None:
from services.langflow_mcp_service import REQUIRED_MCP_HEADERS
for key in REQUIRED_MCP_HEADERS:
assert headers.get(key) == MCP_CREDENTIAL_MASK, (
f"Expected required MCP header {key} to be redacted in the Langflow response, "
f"got {headers.get(key)!r}"
)
@pytest.mark.asyncio
async def test_openrag_mcp_server_url_is_patched_without_persisting_request_globals():
from config.settings import LANGFLOW_URL
from services.langflow_mcp_service import LangflowMCPService
langflow_client = await _wait_for_langflow_client()
assert langflow_client is not None, (
"Langflow client not initialized. Provide LANGFLOW_KEY or enable "
"superuser auto-login for integration tests."
)
mcp_service = LangflowMCPService()
await mcp_service.update_all_mcp_server_urls()
servers = await mcp_service.list_mcp_servers()
server_names = [_server_name(server) for server in servers]
assert OPENRAG_MCP_SERVER_NAME in server_names, (
f"Expected OpenRAG MCP server {OPENRAG_MCP_SERVER_NAME!r}; found {server_names}"
)
server_config = await mcp_service.get_mcp_server(OPENRAG_MCP_SERVER_NAME)
urls = _extract_server_urls(server_config)
assert urls, f"MCP server has no configured URL: {server_config}"
expected_base = (LANGFLOW_URL or os.environ.get("LANGFLOW_URL", "")).rstrip("/")
if expected_base and "localhost" not in expected_base:
assert any(url.startswith(expected_base) for url in urls), (
f"MCP server URLs were not rewritten to LANGFLOW_URL={expected_base!r}: {urls}"
)
_assert_has_redacted_required_global_headers(_extract_server_headers(server_config))
@pytest.mark.asyncio
async def test_loaded_chat_flow_includes_url_ingestion_integration():
from config.settings import LANGFLOW_CHAT_FLOW_ID, clients
langflow_client = await _wait_for_langflow_client()
assert langflow_client is not None, (
"Langflow client not initialized. Provide LANGFLOW_KEY or enable "
"superuser auto-login for integration tests."
)
assert LANGFLOW_CHAT_FLOW_ID, "LANGFLOW_CHAT_FLOW_ID is required"
response = await clients.langflow_request(
"GET",
f"/api/v1/flows/{LANGFLOW_CHAT_FLOW_ID}",
)
response.raise_for_status()
assert "opensearch_url_ingestion_flow" in response.text