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.pyindex ba9957bc1..f9fd1b31a 100644--- a/src/services/flows_service.py+++ b/src/services/flows_service.py@@ -16,6 +16,7 @@ import osfrom datetime import datetimefrom utils.logging_config import get_loggerfrom utils.telemetry import TelemetryClient, Category, MessageId+import asynciologger = get_logger(__name__)@@ -77,6 +78,21 @@ class FlowsService:def __init__(self):# Cache for flow file mappings to avoid repeated filesystem scansself._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 Nonetry:# 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 flowbackup_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"] = Falselogger.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 Nonetry: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 Noneif 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 Noneflow_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 Nonewith 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_typeelse:logger.warning(f"Failed to create {flow_type} flow (ID: {flow_id}): "f"HTTP {response.status_code} — {response.text}")-+ return Noneexcept 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_typesasync 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 Nonelogger.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_typeelse: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_flowsasync 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 = Falseprovider_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 endpointif "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 providerif 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 Trueelse: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 Falsedef _get_provider_component_ids(self, provider: str):"""Helper to get component display names for various providers."""