Skip to content

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

Python
12.3 KB
Raw Blame
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