Skip to content

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

Python

cache and execute langflow calls at the same time

Lucas Oliveirafb939a8de037
diff --git a/src/services/flows_service.py b/src/services/flows_service.py
index ba9957bc1..f9fd1b31a 100644
--- a/src/services/flows_service.py
+++ b/src/services/flows_service.py
@@ -16,6 +16,7 @@ import os
from datetime import datetime
from utils.logging_config import get_logger
from utils.telemetry import TelemetryClient, Category, MessageId
+import asyncio
logger = get_logger(__name__)
@@ -77,6 +78,21 @@ class FlowsService:
def __init__(self):
# Cache for flow file mappings to avoid repeated filesystem scans
self._flow_file_cache = {}
+ # Semaphores to prevent race conditions when updating the same flow concurrently
+ self._flow_locks = {}
+ self._lock_creation_lock = asyncio.Lock()
+ # Cache for enabled models to avoid redundant API calls
+ self._enabled_models_cache = None
+ self._enabled_models_cache_time = None
+ self._enabled_models_cache_ttl = 60 # seconds
+ self._enabled_models_lock = asyncio.Lock()
+
+ async def _get_flow_lock(self, flow_id: str) -> asyncio.Lock:
+ """Get or create an asyncio.Lock for a specific flow ID"""
+ async with self._lock_creation_lock:
+ if flow_id not in self._flow_locks:
+ self._flow_locks[flow_id] = asyncio.Lock()
+ return self._flow_locks[flow_id]
def _get_flows_directory(self):
"""Get the flows directory path"""
@@ -173,9 +189,9 @@ class FlowsService:
logger.info("Starting periodic backup of Langflow flows")
- for flow_type, flow_id in flow_configs:
+ async def backup_single_flow(flow_type, flow_id):
if not flow_id:
- continue
+ return None
try:
# Get current flow from Langflow
@@ -184,13 +200,14 @@ class FlowsService:
logger.warning(
f"Failed to get flow {flow_id} for backup: HTTP {response.status_code}"
)
- backup_results["failed"].append({
- "flow_type": flow_type,
- "flow_id": flow_id,
- "error": f"HTTP {response.status_code}",
- })
- backup_results["success"] = False
- continue
+ return {
+ "type": "failed",
+ "data": {
+ "flow_type": flow_type,
+ "flow_id": flow_id,
+ "error": f"HTTP {response.status_code}",
+ }
+ }
current_flow = response.json()
@@ -204,12 +221,14 @@ class FlowsService:
logger.debug(
f"Flow {flow_type} (ID: {flow_id}) is locked and has no backups, skipping backup"
)
- backup_results["skipped"].append({
- "flow_type": flow_type,
- "flow_id": flow_id,
- "reason": "locked_without_backups",
- })
- continue
+ return {
+ "type": "skipped",
+ "data": {
+ "flow_type": flow_type,
+ "flow_id": flow_id,
+ "reason": "locked_without_backups",
+ }
+ }
# Check if we need to backup (only if changed)
if only_if_changed and has_backups:
@@ -222,42 +241,60 @@ class FlowsService:
logger.debug(
f"Flow {flow_type} (ID: {flow_id}) unchanged, skipping backup"
)
- backup_results["skipped"].append({
- "flow_type": flow_type,
- "flow_id": flow_id,
- "reason": "unchanged",
- })
- continue
+ return {
+ "type": "skipped",
+ "data": {
+ "flow_type": flow_type,
+ "flow_id": flow_id,
+ "reason": "unchanged",
+ }
+ }
except Exception as e:
logger.warning(
f"Failed to read latest backup for {flow_type} (ID: {flow_id}): {str(e)}"
)
- # Continue with backup if we can't read the latest backup
# Backup the flow
backup_path = await self._backup_flow(flow_id, flow_type, current_flow)
if backup_path:
- backup_results["backed_up"].append({
- "flow_type": flow_type,
- "flow_id": flow_id,
- "backup_path": backup_path,
- })
+ return {
+ "type": "backed_up",
+ "data": {
+ "flow_type": flow_type,
+ "flow_id": flow_id,
+ "backup_path": backup_path,
+ }
+ }
else:
- backup_results["failed"].append({
- "flow_type": flow_type,
- "flow_id": flow_id,
- "error": "Backup returned None",
- })
- backup_results["success"] = False
+ return {
+ "type": "failed",
+ "data": {
+ "flow_type": flow_type,
+ "flow_id": flow_id,
+ "error": "Backup returned None",
+ }
+ }
except Exception as e:
logger.error(
f"Failed to backup {flow_type} flow (ID: {flow_id}): {str(e)}"
)
- backup_results["failed"].append({
- "flow_type": flow_type,
- "flow_id": flow_id,
- "error": str(e),
- })
+ return {
+ "type": "failed",
+ "data": {
+ "flow_type": flow_type,
+ "flow_id": flow_id,
+ "error": str(e),
+ }
+ }
+
+ tasks = [backup_single_flow(ft, fi) for ft, fi in flow_configs]
+ results = await asyncio.gather(*tasks)
+
+ for result in results:
+ if not result:
+ continue
+ backup_results[result["type"]].append(result["data"])
+ if result["type"] == "failed":
backup_results["success"] = False
logger.info(
@@ -819,10 +856,9 @@ class FlowsService:
]
created_flow_types: set[str] = set()
- for flow_type, flow_id in flow_configs:
+ async def ensure_single_flow_exists(flow_type, flow_id):
if not flow_id:
- continue
-
+ return None
try:
response = await clients.langflow_request(
"GET", f"/api/v1/flows/{flow_id}"
@@ -831,21 +867,21 @@ class FlowsService:
logger.info(
f"Flow {flow_type} (ID: {flow_id}) already exists, skipping creation"
)
- continue
+ return None
if response.status_code != 404:
logger.warning(
f"Unexpected status checking {flow_type} flow (ID: {flow_id}): "
f"HTTP {response.status_code} — skipping creation to avoid overwriting existing data"
)
- continue
+ return None
flow_path = self._find_flow_file_by_id(flow_id)
if not flow_path:
logger.warning(
f"No flow file found for {flow_type} (ID: {flow_id}), cannot create"
)
- continue
+ return None
with open(flow_path, "r") as f:
flow_data = json.load(f)
@@ -857,18 +893,22 @@ class FlowsService:
logger.info(
f"Created {flow_type} flow (ID: {flow_id}) from {os.path.basename(flow_path)}"
)
- created_flow_types.add(flow_type)
+ return flow_type
else:
logger.warning(
f"Failed to create {flow_type} flow (ID: {flow_id}): "
f"HTTP {response.status_code} — {response.text}"
)
-
+ return None
except Exception as e:
logger.error(
f"Error ensuring {flow_type} flow (ID: {flow_id}) exists: {e}"
)
+ return None
+ tasks = [ensure_single_flow_exists(ft, fi) for ft, fi in flow_configs]
+ results = await asyncio.gather(*tasks)
+ created_flow_types = {r for r in results if r is not None}
return created_flow_types
async def check_flows_reset(self):
@@ -885,19 +925,21 @@ class FlowsService:
("url_ingest", LANGFLOW_URL_INGEST_FLOW_ID),
]
- for flow_type, flow_id in flow_configs:
+ async def check_single_flow_reset(flow_type, flow_id):
if not flow_id:
- continue
-
+ return None
logger.info(f"Checking if {flow_type} flow (ID: {flow_id}) was reset")
is_reset = await self._compare_flow_with_file(flow_id)
-
if is_reset:
logger.info(f"Flow {flow_type} (ID: {flow_id}) appears to have been reset")
- reset_flows.append(flow_type)
+ return flow_type
else:
logger.info(f"Flow {flow_type} (ID: {flow_id}) does not match reset state")
+ return None
+ tasks = [check_single_flow_reset(ft, fi) for ft, fi in flow_configs]
+ results = await asyncio.gather(*tasks)
+ reset_flows = [r for r in results if r is not None]
return reset_flows
async def change_langflow_model_value(
@@ -933,10 +975,10 @@ class FlowsService:
{"name": "url_ingest", "flow_id": LANGFLOW_URL_INGEST_FLOW_ID},
]
- results = []
+ tasks = []
for config in flow_configs:
- try:
- result = await self._update_provider_components(
+ tasks.append(
+ self._update_provider_components(
config,
provider,
embedding_model=embedding_model,
@@ -944,10 +986,19 @@ class FlowsService:
force_embedding_update=force_embedding_update,
force_llm_update=force_llm_update,
)
+ )
+
+ # Process all flows simultaneously
+ raw_results = await asyncio.gather(*tasks, return_exceptions=True)
+
+ results = []
+ for i, result in enumerate(raw_results):
+ if isinstance(result, Exception):
+ flow_name = flow_configs[i]["name"]
+ logger.error(f"Error updating {flow_name} flow: {str(result)}")
+ results.append({"flow": flow_name, "success": False, "error": str(result)})
+ else:
results.append(result)
- except Exception as e:
- logger.error(f"Error updating {config['name']} flow: {str(e)}")
- results.append({"flow": config["name"], "success": False, "error": str(e)})
return {
"success": all(r.get("success", False) for r in results),
@@ -971,137 +1022,125 @@ class FlowsService:
"""Update provider components and their dropdown values in a flow"""
flow_name = config["name"]
flow_id = config["flow_id"]
+ # Use a flow-specific lock to prevent race conditions during the GET-Modify-PATCH cycle
+ flow_lock = await self._get_flow_lock(flow_id)
+ async with flow_lock:
+ # Get flow data from Langflow API instead of file
+ response = await clients.langflow_request("GET", f"/api/v1/flows/{flow_id}")
- # Get flow data from Langflow API instead of file
- response = await clients.langflow_request("GET", f"/api/v1/flows/{flow_id}")
+ if response.status_code != 200:
+ raise Exception(
+ f"Failed to get flow from Langflow: HTTP {response.status_code} - {response.text}"
+ )
- if response.status_code != 200:
- raise Exception(
- f"Failed to get flow from Langflow: HTTP {response.status_code} - {response.text}"
+ flow_data = response.json()
+ updates_made = []
+ node_tasks = []
+
+ async def wrap_node_update(node, p, m, label):
+ if await self._update_component_fields(node, p, m):
+ return label
+ return None
+
+ # Update embedding component
+ if not DISABLE_INGEST_WITH_LANGFLOW and (embedding_model or force_embedding_update):
+ # Get all embedding nodes in the flow
+ embedding_nodes = self._find_nodes_in_flow(flow_data, display_name=OPENAI_EMBEDDING_COMPONENT_DISPLAY_NAME)
+ logger.info(f"Found {len(embedding_nodes)} embedding nodes in flow {flow_name} with display name '{OPENAI_EMBEDDING_COMPONENT_DISPLAY_NAME}'")
+
+ # Count configured embedding-enabled providers
+ config_obj = get_openrag_config()
+ configured_providers = []
+ if config_obj.providers.openai.configured: configured_providers.append("openai")
+ if config_obj.providers.watsonx.configured: configured_providers.append("watsonx")
+ if config_obj.providers.ollama.configured: configured_providers.append("ollama")
+
+ # Ensure current provider is in the list for counting purposes if it's being configured
+ if provider in ["openai", "watsonx", "ollama"] and provider not in configured_providers:
+ configured_providers.append(provider)
+
+ all_possible = ["openai", "watsonx", "ollama"]
+ configured_providers = [p for p in all_possible if p in configured_providers]
+ provider_count = len(configured_providers)
+ logger.info(f"Configured embedding providers: {configured_providers} (count: {provider_count})")
+
+ # 1. Check if any node is already this provider - always update those first
+ matched_nodes = []
+ provider_display = self._get_provider_name_display(provider)
+ for node, idx in embedding_nodes:
+ if self._get_node_provider(node) == provider_display:
+ matched_nodes.append((node, idx))
+
+ if matched_nodes:
+ logger.info(f"Found {len(matched_nodes)} nodes already configured for provider '{provider}'")
+ for node, idx in matched_nodes:
+ node_tasks.append(wrap_node_update(node, provider, embedding_model, f"embedding model: {embedding_model} (updated existing {provider} node)"))
+ else:
+ # 2. No existing node matched, use slot-based logic
+ try:
+ p_index = configured_providers.index(provider)
+ logger.info(f"Using slot-based logic for provider '{provider}' (p_index: {p_index}, total configured: {provider_count})")
+
+ if provider_count == 1:
+ # Single provider mode: update all available nodes (up to 3)
+ logger.info(f"Single provider mode: updating all available embedding nodes (available: {len(embedding_nodes)})")
+ for i in range(min(3, len(embedding_nodes))):
+ node, idx = embedding_nodes[i]
+ node_tasks.append(wrap_node_update(node, provider, embedding_model, f"embedding model: {embedding_model} (set node {i+1})"))
+ else:
+ # Multiple providers: each gets one slot based on its list index
+ if p_index < len(embedding_nodes):
+ node, idx = embedding_nodes[p_index]
+ logger.info(f"Multiple provider mode: assigning provider '{provider}' to node slot {p_index} (node {p_index+1})")
+ node_tasks.append(wrap_node_update(node, provider, embedding_model, f"embedding model: {embedding_model} (set node {p_index+1})"))
+ else:
+ logger.info(f"Provider index {p_index} exceeds available embedding nodes ({len(embedding_nodes)}) - skipping automatic assignment")
+ except ValueError:
+ logger.warning(f"Current provider '{provider}' not found in configured providers list: {configured_providers}")
+
+ # Update LLM component (if exists in this flow)
+ if llm_model or force_llm_update:
+ llm_node, _ = self._find_node_in_flow(flow_data, display_name=OPENAI_LLM_COMPONENT_DISPLAY_NAME)
+ if llm_node:
+ node_tasks.append(wrap_node_update(llm_node, provider, llm_model, f"llm model: {llm_model}"))
+
+ agent_node, _ = self._find_node_in_flow(flow_data, display_name=AGENT_COMPONENT_DISPLAY_NAME)
+ if agent_node:
+ node_tasks.append(wrap_node_update(agent_node, provider, llm_model, f"agent model: {llm_model}"))
+
+ # Execute all node updates simultaneously
+ if node_tasks:
+ node_results = await asyncio.gather(*node_tasks)
+ updates_made.extend([r for r in node_results if r])
+
+ # If no updates were made, return skip message
+ if not updates_made:
+ return {
+ "flow": flow_name,
+ "success": True,
+ "message": f"No compatible components found in {flow_name} flow (skipped)",
+ "flow_id": flow_id,
+ }
+
+ logger.info(f"Updated {', '.join(updates_made)} in {flow_name} flow")
+
+ # PATCH the updated flow
+ response = await clients.langflow_request(
+ "PATCH", f"/api/v1/flows/{flow_id}", json=flow_data
)
- flow_data = response.json()
+ if response.status_code != 200:
+ raise Exception(
+ f"Failed to update flow: HTTP {response.status_code} - {response.text}"
+ )
- updates_made = []
-
- # Update embedding component
- if not DISABLE_INGEST_WITH_LANGFLOW and (embedding_model or force_embedding_update):
- # Get all embedding nodes in the flow
- embedding_nodes = self._find_nodes_in_flow(flow_data, display_name=OPENAI_EMBEDDING_COMPONENT_DISPLAY_NAME)
- logger.info(f"Found {len(embedding_nodes)} embedding nodes in flow {flow_name} with display name '{OPENAI_EMBEDDING_COMPONENT_DISPLAY_NAME}'")
-
- # Count configured embedding-enabled providers
- config_obj = get_openrag_config()
- configured_providers = []
- if config_obj.providers.openai.configured: configured_providers.append("openai")
- if config_obj.providers.watsonx.configured: configured_providers.append("watsonx")
- if config_obj.providers.ollama.configured: configured_providers.append("ollama")
-
- # Ensure current provider is in the list for counting purposes if it's being configured
- if provider in ["openai", "watsonx", "ollama"] and provider not in configured_providers:
- configured_providers.append(provider)
-
- all_possible = ["openai", "watsonx", "ollama"]
- configured_providers = [p for p in all_possible if p in configured_providers]
- provider_count = len(configured_providers)
- logger.info(f"Configured embedding providers: {configured_providers} (count: {provider_count})")
-
- # Determine slot mapping context
- if provider_count == 1:
- logger.info("Configuration mode: all 3 slots belong to the single active provider")
- elif provider_count == 2:
- logger.info("Configuration mode: first 2 slots assigned to providers 1 and 2")
- elif provider_count == 3:
- logger.info("Configuration mode: slots 1, 2, and 3 assigned to their respective providers")
-
- # 1. Check if any node is already this provider - always update those first
- matched_nodes = []
- provider_display = self._get_provider_name_display(provider)
- for node, idx in embedding_nodes:
- if self._get_node_provider(node) == provider_display:
- matched_nodes.append((node, idx))
-
- if matched_nodes:
- logger.info(f"Found {len(matched_nodes)} nodes already configured for provider '{provider}'")
- for node, idx in matched_nodes:
- if await self._update_component_fields(node, provider, embedding_model):
- updates_made.append(f"embedding model: {embedding_model} (updated existing {provider} node)")
- else:
- # 2. No existing node matched, use slot-based logic
- try:
- p_index = configured_providers.index(provider)
- logger.info(f"Using slot-based logic for provider '{provider}' (p_index: {p_index}, total configured: {provider_count})")
-
- if provider_count == 1:
- # Single provider mode: update all available nodes (up to 3)
- logger.info(f"Single provider mode: updating all available embedding nodes (available: {len(embedding_nodes)})")
- for i in range(min(3, len(embedding_nodes))):
- node, idx = embedding_nodes[i]
- if await self._update_component_fields(node, provider, embedding_model):
- updates_made.append(
- f"embedding model: {embedding_model} (set node {i+1})"
- )
- else:
- # Multiple providers: each gets one slot based on its list index
- # This satisfies:
- # - 2 providers -> node 0 and node 1 updated ("two first nodes")
- # - 3 providers -> node 0, 1, 2 updated ("each gets its first one")
- if p_index < len(embedding_nodes):
- node, idx = embedding_nodes[p_index]
- logger.info(f"Multiple provider mode: assigning provider '{provider}' to node slot {p_index} (node {p_index+1})")
- if await self._update_component_fields(node, provider, embedding_model):
- updates_made.append(
- f"embedding model: {embedding_model} (set node {p_index+1})"
- )
- else:
- logger.info(f"Provider index {p_index} exceeds available embedding nodes ({len(embedding_nodes)}) - skipping automatic assignment")
- except ValueError:
- logger.warning(f"Current provider '{provider}' not found in configured providers list: {configured_providers}")
-
- # Update LLM component (if exists in this flow)
- if llm_model or force_llm_update:
- llm_node, _ = self._find_node_in_flow(flow_data, display_name=OPENAI_LLM_COMPONENT_DISPLAY_NAME)
- if llm_node:
- if await self._update_component_fields(
- llm_node, provider, llm_model
- ):
- updates_made.append(f"llm model: {llm_model}")
- # Update LLM component (if exists in this flow)
- agent_node, _ = self._find_node_in_flow(flow_data, display_name=AGENT_COMPONENT_DISPLAY_NAME)
- if agent_node:
- if await self._update_component_fields(
- agent_node, provider, llm_model
- ):
- updates_made.append(f"agent model: {llm_model}")
-
- # If no updates were made, return skip message
- if not updates_made:
return {
"flow": flow_name,
"success": True,
- "message": f"No compatible components found in {flow_name} flow (skipped)",
+ "message": f"Successfully updated {', '.join(updates_made)}",
"flow_id": flow_id,
}
- logger.info(f"Updated {', '.join(updates_made)} in {flow_name} flow")
-
- # PATCH the updated flow
- response = await clients.langflow_request(
- "PATCH", f"/api/v1/flows/{flow_id}", json=flow_data
- )
-
- if response.status_code != 200:
- raise Exception(
- f"Failed to update flow: HTTP {response.status_code} - {response.text}"
- )
-
- return {
- "flow": flow_name,
- "success": True,
- "message": f"Successfully updated {', '.join(updates_made)}",
- "flow_id": flow_id,
- }
-
async def _update_component_langflow(self, template, model: str):
# Call custom_component/update endpoint to get updated template
# Only call if code field exists (custom components should have code)
@@ -1151,17 +1190,16 @@ class FlowsService:
updated = False
provider_name = self._get_provider_name_display(provider)
- # Enable the model in Langflow first
- await self._enable_model_in_langflow(provider_name, model_value)
-
# Update model field and call custom_component/update endpoint
if "model" in template:
if "options" not in template["model"]:
return False
- # Update template via Langflow API to get latest options
- template = await self._update_component_langflow(template, template["model"]["value"]) or template
- component_node["data"]["node"]["template"] = template
+ # Enable the model in Langflow first
+ if (await self._enable_model_in_langflow(provider_name, model_value)):
+ # Update template via Langflow API to get latest options
+ template = await self._update_component_langflow(template, template["model"]["value"]) or template
+ component_node["data"]["node"]["template"] = template
# Find the specific model option for the provider
if model_value:
@@ -1228,6 +1266,27 @@ class FlowsService:
async def _enable_model_in_langflow(self, provider_name: str, model_value: str):
"""Ensure the specified model is enabled in Langflow."""
try:
+ enabled_data = None
+ async with self._enabled_models_lock:
+ # Check if cache is still valid
+ if (self._enabled_models_cache and self._enabled_models_cache_time and
+ (datetime.now() - self._enabled_models_cache_time).total_seconds() < self._enabled_models_cache_ttl):
+ enabled_data = self._enabled_models_cache
+ else:
+ # Cache miss or stale, fetch from Langflow
+ get_response = await clients.langflow_request("GET", "/api/v1/models/enabled_models")
+ if get_response.status_code == 200:
+ enabled_data = get_response.json().get("enabled_models", {})
+ self._enabled_models_cache = enabled_data
+ self._enabled_models_cache_time = datetime.now()
+ logger.debug("Refreshed enabled models cache from Langflow")
+
+ if enabled_data:
+ provider_models = enabled_data.get(provider_name, {})
+ if provider_models.get(model_value) is True:
+ logger.info(f"Model {model_value} for provider {provider_name} is already enabled. Skipping.")
+ return False
+
enable_payload = [{
"provider": provider_name,
"model_id": model_value,
@@ -1240,12 +1299,18 @@ class FlowsService:
if response.status_code == 200:
logger.info(f"Successfully enabled model {model_value} for provider {provider_name}")
+ # Invalidate cache so it reflects the new state on next check if needed,
+ # or we could update it locally. Clearing it is safer.
+ async with self._enabled_models_lock:
+ self._enabled_models_cache = None
+ return True
else:
logger.warning(
f"Failed to enable model: HTTP {response.status_code} - {response.text}"
)
except Exception as e:
- logger.error(f"Error enabling model {model_value}: {str(e)}")
+ logger.error(f"Error enabling model in Langflow: {str(e)}")
+ return False
def _get_provider_component_ids(self, provider: str):
"""Helper to get component display names for various providers."""