Merge branch 'main' into doc-directory-name

Dockerfile.langflow

@@ -1,4 +1,4 @@
-FROM langflowai/langflow-nightly:1.7.0.dev19
+FROM langflowai/langflow-nightly:1.7.0.dev21
 
 EXPOSE 7860
 

docker-compose-cpu.yml

@@ -129,7 +129,8 @@ services:
       - FILENAME=None
       - MIMETYPE=None
       - FILESIZE=0
-      - LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT=JWT,OPENRAG-QUERY-FILTER,OPENSEARCH_PASSWORD,OWNER,OWNER_NAME,OWNER_EMAIL,CONNECTOR_TYPE,FILENAME,MIMETYPE,FILESIZE
+      - SELECTED_EMBEDDING_MODEL=${SELECTED_EMBEDDING_MODEL:-}
+      - LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT=JWT,OPENRAG-QUERY-FILTER,OPENSEARCH_PASSWORD,OWNER,OWNER_NAME,OWNER_EMAIL,CONNECTOR_TYPE,FILENAME,MIMETYPE,FILESIZE,SELECTED_EMBEDDING_MODEL
       - LANGFLOW_LOG_LEVEL=DEBUG
       - LANGFLOW_AUTO_LOGIN=${LANGFLOW_AUTO_LOGIN}
       - LANGFLOW_SUPERUSER=${LANGFLOW_SUPERUSER}

docker-compose.yml

@@ -45,9 +45,9 @@ services:
 
   openrag-backend:
     image: langflowai/openrag-backend:${OPENRAG_VERSION:-latest}
-    # build:
-    #   context: .
-    #   dockerfile: Dockerfile.backend
+    build:
+      context: .
+      dockerfile: Dockerfile.backend
     container_name: openrag-backend
     depends_on:
       - langflow
@@ -86,9 +86,9 @@ services:
 
   openrag-frontend:
     image: langflowai/openrag-frontend:${OPENRAG_VERSION:-latest}
-    # build:
-    #   context: .
-    #   dockerfile: Dockerfile.frontend
+    build:
+      context: .
+      dockerfile: Dockerfile.frontend
     container_name: openrag-frontend
     depends_on:
       - openrag-backend
@@ -101,20 +101,20 @@ services:
     volumes:
       - ./flows:/app/flows:U,z
     image: langflowai/openrag-langflow:${LANGFLOW_VERSION:-latest}
-    # build:
-    #   context: .
-    #   dockerfile: Dockerfile.langflow
+    build:
+      context: .
+      dockerfile: Dockerfile.langflow
     container_name: langflow
     ports:
       - "7860:7860"
     environment:
       - LANGFLOW_DEACTIVATE_TRACING=true
-      - OPENAI_API_KEY=${OPENAI_API_KEY}
-      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
-      - WATSONX_API_KEY=${WATSONX_API_KEY}
-      - WATSONX_ENDPOINT=${WATSONX_ENDPOINT}
-      - WATSONX_PROJECT_ID=${WATSONX_PROJECT_ID}
-      - OLLAMA_BASE_URL=${OLLAMA_ENDPOINT}
+      - OPENAI_API_KEY=${OPENAI_API_KEY:-None}
+      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY:-None}
+      - WATSONX_API_KEY=${WATSONX_API_KEY:-None}
+      - WATSONX_ENDPOINT=${WATSONX_ENDPOINT:-None}
+      - WATSONX_PROJECT_ID=${WATSONX_PROJECT_ID:-None}
+      - OLLAMA_BASE_URL=${OLLAMA_ENDPOINT:-None}
       - LANGFLOW_LOAD_FLOWS_PATH=/app/flows
       - LANGFLOW_SECRET_KEY=${LANGFLOW_SECRET_KEY}
       - JWT=None  
@@ -128,7 +128,9 @@ services:
       - FILENAME=None
       - MIMETYPE=None
       - FILESIZE=0
-      - LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT=JWT,OPENRAG-QUERY-FILTER,OPENSEARCH_PASSWORD,OWNER,OWNER_NAME,OWNER_EMAIL,CONNECTOR_TYPE,FILENAME,MIMETYPE,FILESIZE
+      - SELECTED_EMBEDDING_MODEL=${SELECTED_EMBEDDING_MODEL:-}
+      - OPENSEARCH_PASSWORD=${OPENSEARCH_PASSWORD}
+      - LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT=JWT,OPENRAG-QUERY-FILTER,OPENSEARCH_PASSWORD,OWNER,OWNER_NAME,OWNER_EMAIL,CONNECTOR_TYPE,FILENAME,MIMETYPE,FILESIZE,SELECTED_EMBEDDING_MODEL,OPENAI_API_KEY,ANTHROPIC_API_KEY,WATSONX_API_KEY,WATSONX_ENDPOINT,WATSONX_PROJECT_ID,OLLAMA_BASE_URL
       - LANGFLOW_LOG_LEVEL=DEBUG
       - LANGFLOW_AUTO_LOGIN=${LANGFLOW_AUTO_LOGIN}
       - LANGFLOW_SUPERUSER=${LANGFLOW_SUPERUSER}

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openrag"
-version = "0.1.40"
+version = "0.1.41"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.13"

src/api/settings.py

@@ -14,6 +14,7 @@ from config.settings import (
     clients,
     get_openrag_config,
     config_manager,
+    is_no_auth_mode,
 )
 from api.provider_validation import validate_provider_setup
 
@@ -614,7 +615,7 @@ async def update_settings(request, session_manager):
                     )
                     logger.info("Set OLLAMA_BASE_URL global variable in Langflow")
 
-                # Update model values across flows if provider or model changed
+                # Update LLM model values across flows if provider or model changed
                 if "llm_provider" in body or "llm_model" in body:
                     flows_service = _get_flows_service()
                     llm_provider = current_config.agent.llm_provider.lower()
@@ -629,19 +630,49 @@ async def update_settings(request, session_manager):
                         f"Successfully updated Langflow flows for LLM provider {llm_provider}"
                     )
 
+                # Update SELECTED_EMBEDDING_MODEL global variable (no flow updates needed)
                 if "embedding_provider" in body or "embedding_model" in body:
-                    flows_service = _get_flows_service()
-                    embedding_provider = current_config.knowledge.embedding_provider.lower()
-                    embedding_provider_config = current_config.get_embedding_provider_config()
-                    embedding_endpoint = getattr(embedding_provider_config, "endpoint", None)
-                    await flows_service.change_langflow_model_value(
-                        embedding_provider,
-                        embedding_model=current_config.knowledge.embedding_model,
-                        endpoint=embedding_endpoint,
+                    await clients._create_langflow_global_variable(
+                        "SELECTED_EMBEDDING_MODEL", current_config.knowledge.embedding_model, modify=True
                     )
                     logger.info(
-                        f"Successfully updated Langflow flows for embedding provider {embedding_provider}"
+                        f"Set SELECTED_EMBEDDING_MODEL global variable to {current_config.knowledge.embedding_model}"
                     )
+                
+                # Update MCP servers with provider credentials
+                try:
+                    from services.langflow_mcp_service import LangflowMCPService
+                    from utils.langflow_headers import build_mcp_global_vars_from_config
+                    
+                    mcp_service = LangflowMCPService()
+                    
+                    # Build global vars using utility function
+                    mcp_global_vars = build_mcp_global_vars_from_config(current_config)
+                    
+                    # In no-auth mode, add the anonymous JWT token and user details
+                    if is_no_auth_mode() and session_manager:
+                        from session_manager import AnonymousUser
+                        
+                        # Create/get anonymous JWT for no-auth mode
+                        anonymous_jwt = session_manager.get_effective_jwt_token(None, None)
+                        if anonymous_jwt:
+                            mcp_global_vars["JWT"] = anonymous_jwt
+                        
+                        # Add anonymous user details
+                        anonymous_user = AnonymousUser()
+                        mcp_global_vars["OWNER"] = anonymous_user.user_id  # "anonymous"
+                        mcp_global_vars["OWNER_NAME"] = f'"{anonymous_user.name}"'  # "Anonymous User" (quoted)
+                        mcp_global_vars["OWNER_EMAIL"] = anonymous_user.email  # "anonymous@localhost"
+                        
+                        logger.debug("Added anonymous JWT and user details to MCP servers for no-auth mode")
+                    
+                    if mcp_global_vars:
+                        result = await mcp_service.update_mcp_servers_with_global_vars(mcp_global_vars)
+                        logger.info("Updated MCP servers with provider credentials after settings change", **result)
+                    
+                except Exception as mcp_error:
+                    logger.warning(f"Failed to update MCP servers after settings change: {str(mcp_error)}")
+                    # Don't fail the entire settings update if MCP update fails
 
             except Exception as e:
                 logger.error(f"Failed to update Langflow settings: {str(e)}")
@@ -660,7 +691,7 @@ async def update_settings(request, session_manager):
         )
 
 
-async def onboarding(request, flows_service):
+async def onboarding(request, flows_service, session_manager=None):
     """Handle onboarding configuration setup"""
     try:
         # Get current configuration
@@ -928,7 +959,7 @@ async def onboarding(request, flows_service):
                 )
                 logger.info("Set OLLAMA_BASE_URL global variable in Langflow")
 
-            # Update flows with model values
+            # Update flows with LLM model values
             if "llm_provider" in body or "llm_model" in body:
                 llm_provider = current_config.agent.llm_provider.lower()
                 llm_provider_config = current_config.get_llm_provider_config()
@@ -940,16 +971,49 @@ async def onboarding(request, flows_service):
                 )
                 logger.info(f"Updated Langflow flows for LLM provider {llm_provider}")
 
+            # Set SELECTED_EMBEDDING_MODEL global variable (no flow updates needed)
             if "embedding_provider" in body or "embedding_model" in body:
-                embedding_provider = current_config.knowledge.embedding_provider.lower()
-                embedding_provider_config = current_config.get_embedding_provider_config()
-                embedding_endpoint = getattr(embedding_provider_config, "endpoint", None)
-                await flows_service.change_langflow_model_value(
-                    provider=embedding_provider,
-                    embedding_model=current_config.knowledge.embedding_model,
-                    endpoint=embedding_endpoint,
+                await clients._create_langflow_global_variable(
+                    "SELECTED_EMBEDDING_MODEL", current_config.knowledge.embedding_model, modify=True
                 )
-                logger.info(f"Updated Langflow flows for embedding provider {embedding_provider}")
+                logger.info(
+                    f"Set SELECTED_EMBEDDING_MODEL global variable to {current_config.knowledge.embedding_model}"
+                )
+            
+            # Update MCP servers with provider credentials during onboarding
+            try:
+                from services.langflow_mcp_service import LangflowMCPService
+                from utils.langflow_headers import build_mcp_global_vars_from_config
+                
+                mcp_service = LangflowMCPService()
+                
+                # Build global vars using utility function
+                mcp_global_vars = build_mcp_global_vars_from_config(current_config)
+                
+                # In no-auth mode, add the anonymous JWT token and user details
+                if is_no_auth_mode() and session_manager:
+                    from session_manager import AnonymousUser
+                    
+                    # Create/get anonymous JWT for no-auth mode
+                    anonymous_jwt = session_manager.get_effective_jwt_token(None, None)
+                    if anonymous_jwt:
+                        mcp_global_vars["JWT"] = anonymous_jwt
+                    
+                    # Add anonymous user details
+                    anonymous_user = AnonymousUser()
+                    mcp_global_vars["OWNER"] = anonymous_user.user_id  # "anonymous"
+                    mcp_global_vars["OWNER_NAME"] = f'"{anonymous_user.name}"'  # "Anonymous User" (quoted)
+                    mcp_global_vars["OWNER_EMAIL"] = anonymous_user.email  # "anonymous@localhost"
+                    
+                    logger.debug("Added anonymous JWT and user details to MCP servers for no-auth mode during onboarding")
+                
+                if mcp_global_vars:
+                    result = await mcp_service.update_mcp_servers_with_global_vars(mcp_global_vars)
+                    logger.info("Updated MCP servers with provider credentials during onboarding", **result)
+                
+            except Exception as mcp_error:
+                logger.warning(f"Failed to update MCP servers during onboarding: {str(mcp_error)}")
+                # Don't fail onboarding if MCP update fails
 
         except Exception as e:
             logger.error(

src/main.py

@@ -387,7 +387,7 @@ async def _ingest_default_documents_langflow(services, file_paths):
 
     # Prepare tweaks for default documents with anonymous user metadata
     default_tweaks = {
-        "OpenSearchHybrid-Ve6bS": {
+        "OpenSearchVectorStoreComponentMultimodalMultiEmbedding-By9U4": {
             "docs_metadata": [
                 {"key": "owner", "value": None},
                 {"key": "owner_name", "value": anonymous_user.name},
@@ -450,6 +450,55 @@ async def _ingest_default_documents_openrag(services, file_paths):
     )
 
 
+async def _update_mcp_servers_with_provider_credentials(services):
+    """Update MCP servers with provider credentials at startup.
+    
+    This is especially important for no-auth mode where users don't go through
+    the OAuth login flow that would normally set these credentials.
+    """
+    try:
+        auth_service = services.get("auth_service")
+        session_manager = services.get("session_manager")
+        
+        if not auth_service or not auth_service.langflow_mcp_service:
+            logger.debug("MCP service not available, skipping credential update")
+            return
+        
+        config = get_openrag_config()
+        
+        # Build global vars with provider credentials using utility function
+        from utils.langflow_headers import build_mcp_global_vars_from_config
+        
+        global_vars = build_mcp_global_vars_from_config(config)
+        
+        # In no-auth mode, add the anonymous JWT token and user details
+        if is_no_auth_mode() and session_manager:
+            from session_manager import AnonymousUser
+            
+            # Create/get anonymous JWT for no-auth mode
+            anonymous_jwt = session_manager.get_effective_jwt_token(None, None)
+            if anonymous_jwt:
+                global_vars["JWT"] = anonymous_jwt
+            
+            # Add anonymous user details
+            anonymous_user = AnonymousUser()
+            global_vars["OWNER"] = anonymous_user.user_id  # "anonymous"
+            global_vars["OWNER_NAME"] = f'"{anonymous_user.name}"'  # "Anonymous User" (quoted for spaces)
+            global_vars["OWNER_EMAIL"] = anonymous_user.email  # "anonymous@localhost"
+            
+            logger.info("Added anonymous JWT and user details to MCP servers for no-auth mode")
+        
+        if global_vars:
+            result = await auth_service.langflow_mcp_service.update_mcp_servers_with_global_vars(global_vars)
+            logger.info("Updated MCP servers with provider credentials at startup", **result)
+        else:
+            logger.debug("No provider credentials configured, skipping MCP server update")
+            
+    except Exception as e:
+        logger.warning("Failed to update MCP servers with provider credentials at startup", error=str(e))
+        # Don't fail startup if MCP update fails
+
+
 async def startup_tasks(services):
     """Startup tasks"""
     logger.info("Starting startup tasks")
@@ -462,6 +511,9 @@ async def startup_tasks(services):
 
     # Configure alerting security
     await configure_alerting_security()
+    
+    # Update MCP servers with provider credentials (especially important for no-auth mode)
+    await _update_mcp_servers_with_provider_credentials(services)
 
 
 async def initialize_services():
@@ -1069,7 +1121,11 @@ async def create_app():
         Route(
             "/onboarding",
             require_auth(services["session_manager"])(
-                partial(settings.onboarding, flows_service=services["flows_service"])
+                partial(
+                    settings.onboarding,
+                    flows_service=services["flows_service"],
+                    session_manager=services["session_manager"]
+                )
             ),
             methods=["POST"],
         ),

src/models/processors.py

@@ -743,9 +743,9 @@ class LangflowFileProcessor(TaskProcessor):
 
             if metadata_tweaks:
                 # Initialize the OpenSearch component tweaks if not already present
-                if "OpenSearchHybrid-Ve6bS" not in final_tweaks:
-                    final_tweaks["OpenSearchHybrid-Ve6bS"] = {}
-                final_tweaks["OpenSearchHybrid-Ve6bS"]["docs_metadata"] = metadata_tweaks
+                if "OpenSearchVectorStoreComponentMultimodalMultiEmbedding-By9U4" not in final_tweaks:
+                    final_tweaks["OpenSearchVectorStoreComponentMultimodalMultiEmbedding-By9U4"] = {}
+                final_tweaks["OpenSearchVectorStoreComponentMultimodalMultiEmbedding-By9U4"]["docs_metadata"] = metadata_tweaks
 
             # Process file using langflow service
             result = await self.langflow_file_service.upload_and_ingest_file(

src/services/auth_service.py

@@ -308,6 +308,16 @@ class AuthService:
                                 global_vars["OWNER_NAME"] = str(f"\"{owner_name}\"")
                         if user_info.get("email"):
                             global_vars["OWNER_EMAIL"] = user_info.get("email")
+                    
+                    # Add provider credentials to MCP servers using utility function
+                    from config.settings import get_openrag_config
+                    from utils.langflow_headers import build_mcp_global_vars_from_config
+                    
+                    config = get_openrag_config()
+                    provider_vars = build_mcp_global_vars_from_config(config)
+                    
+                    # Merge provider credentials with user info
+                    global_vars.update(provider_vars)
 
                     # Run in background to avoid delaying login flow
                     task = asyncio.create_task(

src/services/chat_service.py

@@ -60,11 +60,22 @@ class ChatService:
                 "LANGFLOW_URL and LANGFLOW_CHAT_FLOW_ID environment variables are required"
             )
 
-        # Prepare extra headers for JWT authentication
+        # Prepare extra headers for JWT authentication and embedding model
         extra_headers = {}
         if jwt_token:
             extra_headers["X-LANGFLOW-GLOBAL-VAR-JWT"] = jwt_token
 
+        # Pass the selected embedding model as a global variable
+        from config.settings import get_openrag_config
+        from utils.langflow_headers import add_provider_credentials_to_headers
+        
+        config = get_openrag_config()
+        embedding_model = config.knowledge.embedding_model
+        extra_headers["X-LANGFLOW-GLOBAL-VAR-SELECTED_EMBEDDING_MODEL"] = embedding_model
+        
+        # Add provider credentials to headers
+        add_provider_credentials_to_headers(extra_headers, config)
+        logger.debug(f"[LF] Extra headers {extra_headers}")
         # Get context variables for filters, limit, and threshold
         from auth_context import (
             get_score_threshold,
@@ -169,11 +180,22 @@ class ChatService:
                 "LANGFLOW_URL and NUDGES_FLOW_ID environment variables are required"
             )
 
-        # Prepare extra headers for JWT authentication
+        # Prepare extra headers for JWT authentication and embedding model
         extra_headers = {}
         if jwt_token:
             extra_headers["X-LANGFLOW-GLOBAL-VAR-JWT"] = jwt_token
 
+        # Pass the selected embedding model as a global variable
+        from config.settings import get_openrag_config
+        from utils.langflow_headers import add_provider_credentials_to_headers
+        
+        config = get_openrag_config()
+        embedding_model = config.knowledge.embedding_model
+        extra_headers["X-LANGFLOW-GLOBAL-VAR-SELECTED_EMBEDDING_MODEL"] = embedding_model
+        
+        # Add provider credentials to headers
+        add_provider_credentials_to_headers(extra_headers, config)
+
         # Build the complete filter expression like the chat service does
         filter_expression = {}
         has_user_filters = False
@@ -287,10 +309,22 @@ class ChatService:
         document_prompt = f"I'm uploading a document called '{filename}'. Here is its content:\n\n{document_content}\n\nPlease confirm you've received this document and are ready to answer questions about it."
 
         if endpoint == "langflow":
-            # Prepare extra headers for JWT authentication
+            # Prepare extra headers for JWT authentication and embedding model
             extra_headers = {}
             if jwt_token:
                 extra_headers["X-LANGFLOW-GLOBAL-VAR-JWT"] = jwt_token
+
+            # Pass the selected embedding model as a global variable
+            from config.settings import get_openrag_config
+            from utils.langflow_headers import add_provider_credentials_to_headers
+            
+            config = get_openrag_config()
+            embedding_model = config.knowledge.embedding_model
+            extra_headers["X-LANGFLOW-GLOBAL-VAR-SELECTED_EMBEDDING_MODEL"] = embedding_model
+            
+            # Add provider credentials to headers
+            add_provider_credentials_to_headers(extra_headers, config)
+            
             # Ensure the Langflow client exists; try lazy init if needed
             langflow_client = await clients.ensure_langflow_client()
             if not langflow_client:

src/services/langflow_file_service.py

@@ -94,7 +94,7 @@ class LangflowFileService:
         # Pass JWT token via tweaks using the x-langflow-global-var- pattern
         if jwt_token:
             # Using the global variable pattern that Langflow expects for OpenSearch components
-            tweaks["OpenSearchHybrid-Ve6bS"] = {"jwt_token": jwt_token}
+            tweaks["OpenSearchVectorStoreComponentMultimodalMultiEmbedding-By9U4"] = {"jwt_token": jwt_token}
             logger.debug("[LF] Added JWT token to tweaks for OpenSearch components")
         else:
             logger.warning("[LF] No JWT token provided")
@@ -112,9 +112,9 @@ class LangflowFileService:
         logger.info(f"[LF] Metadata tweaks {metadata_tweaks}")
         # if metadata_tweaks:
         #     # Initialize the OpenSearch component tweaks if not already present
-        #     if "OpenSearchHybrid-Ve6bS" not in tweaks:
-        #         tweaks["OpenSearchHybrid-Ve6bS"] = {}
-        #     tweaks["OpenSearchHybrid-Ve6bS"]["docs_metadata"] = metadata_tweaks
+        #     if "OpenSearchVectorStoreComponentMultimodalMultiEmbedding-By9U4" not in tweaks:
+        #         tweaks["OpenSearchVectorStoreComponentMultimodalMultiEmbedding-By9U4"] = {}
+        #     tweaks["OpenSearchVectorStoreComponentMultimodalMultiEmbedding-By9U4"]["docs_metadata"] = metadata_tweaks
         #     logger.debug(
         #         "[LF] Added metadata to tweaks", metadata_count=len(metadata_tweaks)
         #     )
@@ -140,6 +140,13 @@ class LangflowFileService:
         filename = str(file_tuples[0][0]) if file_tuples and len(file_tuples) > 0 else ""
         mimetype = str(file_tuples[0][2]) if file_tuples and len(file_tuples) > 0 and len(file_tuples[0]) > 2 else ""
 
+        # Get the current embedding model and provider credentials from config
+        from config.settings import get_openrag_config
+        from utils.langflow_headers import add_provider_credentials_to_headers
+        
+        config = get_openrag_config()
+        embedding_model = config.knowledge.embedding_model
+
         headers={
                 "X-Langflow-Global-Var-JWT": str(jwt_token),
                 "X-Langflow-Global-Var-OWNER": str(owner),
@@ -149,7 +156,11 @@ class LangflowFileService:
                 "X-Langflow-Global-Var-FILENAME": filename,
                 "X-Langflow-Global-Var-MIMETYPE": mimetype,
                 "X-Langflow-Global-Var-FILESIZE": str(file_size_bytes),
+                "X-Langflow-Global-Var-SELECTED_EMBEDDING_MODEL": str(embedding_model),
             }
+        
+        # Add provider credentials as global variables for ingestion
+        add_provider_credentials_to_headers(headers, config)
         logger.info(f"[LF] Headers {headers}")
         logger.info(f"[LF] Payload {payload}")
         resp = await clients.langflow_request(

src/utils/langflow_headers.py

@@ -0,0 +1,71 @@
+"""Utility functions for building Langflow request headers."""
+
+from typing import Dict
+from utils.container_utils import transform_localhost_url
+
+
+def add_provider_credentials_to_headers(headers: Dict[str, str], config) -> None:
+    """Add provider credentials to headers as Langflow global variables.
+    
+    Args:
+        headers: Dictionary of headers to add credentials to
+        config: OpenRAGConfig object containing provider configurations
+    """
+    # Add OpenAI credentials
+    if config.providers.openai.api_key:
+        headers["X-LANGFLOW-GLOBAL-VAR-OPENAI_API_KEY"] = str(config.providers.openai.api_key)
+    
+    # Add Anthropic credentials
+    if config.providers.anthropic.api_key:
+        headers["X-LANGFLOW-GLOBAL-VAR-ANTHROPIC_API_KEY"] = str(config.providers.anthropic.api_key)
+    
+    # Add WatsonX credentials
+    if config.providers.watsonx.api_key:
+        headers["X-LANGFLOW-GLOBAL-VAR-WATSONX_API_KEY"] = str(config.providers.watsonx.api_key)
+    
+    if config.providers.watsonx.project_id:
+        headers["X-LANGFLOW-GLOBAL-VAR-WATSONX_PROJECT_ID"] = str(config.providers.watsonx.project_id)
+    
+    # Add Ollama endpoint (with localhost transformation)
+    if config.providers.ollama.endpoint:
+        ollama_endpoint = transform_localhost_url(config.providers.ollama.endpoint)
+        headers["X-LANGFLOW-GLOBAL-VAR-OLLAMA_BASE_URL"] = str(ollama_endpoint)
+
+
+def build_mcp_global_vars_from_config(config) -> Dict[str, str]:
+    """Build MCP global variables dictionary from OpenRAG configuration.
+    
+    Args:
+        config: OpenRAGConfig object containing provider configurations
+        
+    Returns:
+        Dictionary of global variables for MCP servers (without X-Langflow-Global-Var prefix)
+    """
+    global_vars = {}
+    
+    # Add OpenAI credentials
+    if config.providers.openai.api_key:
+        global_vars["OPENAI_API_KEY"] = config.providers.openai.api_key
+    
+    # Add Anthropic credentials
+    if config.providers.anthropic.api_key:
+        global_vars["ANTHROPIC_API_KEY"] = config.providers.anthropic.api_key
+    
+    # Add WatsonX credentials
+    if config.providers.watsonx.api_key:
+        global_vars["WATSONX_API_KEY"] = config.providers.watsonx.api_key
+    
+    if config.providers.watsonx.project_id:
+        global_vars["WATSONX_PROJECT_ID"] = config.providers.watsonx.project_id
+    
+    # Add Ollama endpoint (with localhost transformation)
+    if config.providers.ollama.endpoint:
+        ollama_endpoint = transform_localhost_url(config.providers.ollama.endpoint)
+        global_vars["OLLAMA_BASE_URL"] = ollama_endpoint
+    
+    # Add selected embedding model
+    if config.knowledge.embedding_model:
+        global_vars["SELECTED_EMBEDDING_MODEL"] = config.knowledge.embedding_model
+    
+    return global_vars
+