OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.
Python
import json
from typing import Any
from agent import async_chat, async_chat_stream, async_langflow
from auth_context import set_auth_context
from config.settings import LANGFLOW_CHAT_FLOW_ID, LANGFLOW_URL, NUDGES_FLOW_ID, clients
from utils.langflow_utils import fence_untrusted_text
from utils.logging_config import get_logger
from utils.opensearch_queries import build_filter_clauses
logger = get_logger(__name__)
class ChatService:
def __init__(self, flows_service=None):
self.flows_service = flows_service
async def chat(
self,
prompt: str,
user_id: str = None,
jwt_token: str = None,
previous_response_id: str = None,
stream: bool = False,
filter_id: str = None,
storage_user_id: str = None,
):
"""Handle chat requests using the patched OpenAI client"""
if not prompt:
raise ValueError("Prompt is required")
conversation_user_id = storage_user_id or user_id
# Set authentication context for this request so tools can access it
if user_id and jwt_token:
set_auth_context(user_id, jwt_token)
if stream:
return async_chat_stream(
clients.patched_llm_client,
prompt,
conversation_user_id,
previous_response_id=previous_response_id,
filter_id=filter_id,
)
else:
response_text, response_id = await async_chat(
clients.patched_llm_client,
prompt,
conversation_user_id,
previous_response_id=previous_response_id,
filter_id=filter_id,
)
response_data = {"response": response_text}
if response_id:
response_data["response_id"] = response_id
return response_data
async def langflow_chat(
self,
prompt: str,
user_id: str = None,
jwt_token: str = None,
previous_response_id: str = None,
conversation_id: str = None,
stream: bool = False,
filter_id: str = None,
owner: str = None,
owner_name: str = None,
owner_email: str = None,
storage_user_id: str = None,
):
"""Handle Langflow chat requests"""
if not prompt:
raise ValueError("Prompt is required")
conversation_user_id = storage_user_id or user_id
if not LANGFLOW_URL or not LANGFLOW_CHAT_FLOW_ID:
raise ValueError(
"LANGFLOW_URL and LANGFLOW_CHAT_FLOW_ID environment variables are required"
)
# Prepare extra headers for JWT authentication and embedding model.
# NOTE: extra_headers accumulates raw secrets (JWT, provider API keys —
# see add_provider_credentials_to_headers below). Never log this dict or
# pass it to a logger call (e.g. logger.info(..., extra_headers=...)).
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 services.langflow_llm_token_service import HOP_PURPOSE_CHAT
from utils.langflow_headers import (
add_provider_credentials_to_headers,
build_model_provider_headers,
)
config = get_openrag_config()
embedding_model = config.knowledge.embedding_model
embedding_provider = config.knowledge.embedding_provider or "openai"
chunk_size = getattr(config.knowledge, "chunk_size", 1000)
chunk_overlap = getattr(config.knowledge, "chunk_overlap", 200)
extra_headers.update(build_model_provider_headers(config))
# Configure ingest callback credentials/vars like ingestion does
import uuid
from config.settings import (
LANGFLOW_INGEST_CALLBACK_BATCH_SIZE,
get_index_name,
get_ingest_callback_url,
)
from services.document_index_writer import DocumentIndexContext
from services.langflow_ingest_token_service import LangflowIngestTokenService
doc_id = str(uuid.uuid4())
ingest_run_id = f"{doc_id}-{uuid.uuid4().hex}"
context = DocumentIndexContext(
document_id=doc_id,
filename="",
mimetype="",
embedding_model=embedding_model,
embedding_provider=embedding_provider,
owner=owner,
owner_name=owner_name,
owner_email=owner_email,
file_size=0,
connector_type="url",
source_url=None,
allowed_users=[],
allowed_groups=[],
allowed_principals=[],
allowed_principal_labels=[],
ingest_run_id=ingest_run_id,
is_sample_data=False,
index_name=get_index_name(),
parser="URL Ingester",
chunk_size=chunk_size,
chunk_overlap=chunk_overlap,
)
token_service = LangflowIngestTokenService()
ingest_token = token_service.create_token(context)
extra_headers["X-Langflow-Global-Var-OPENRAG_INGEST_URL"] = get_ingest_callback_url()
extra_headers["X-Langflow-Global-Var-OPENRAG_INGEST_TOKEN"] = ingest_token
extra_headers["X-Langflow-Global-Var-OPENRAG_INGEST_RUN_ID"] = ingest_run_id
extra_headers["X-Langflow-Global-Var-OPENRAG_INGEST_BATCH_SIZE"] = str(
LANGFLOW_INGEST_CALLBACK_BATCH_SIZE
)
extra_headers["X-Langflow-Global-Var-CONNECTOR_TYPE"] = "url"
# Add provider credentials to headers
await add_provider_credentials_to_headers(
extra_headers,
config,
flows_service=self.flows_service,
jwt_token=jwt_token,
user_id=user_id,
purpose=HOP_PURPOSE_CHAT,
)
# Get context variables for filters, limit, and threshold
from auth_context import (
get_score_threshold,
get_search_filters,
get_search_limit,
)
filters = get_search_filters()
limit = get_search_limit()
score_threshold = get_score_threshold()
# Build the complete filter expression like the search service does
filter_expression: dict[str, Any] = {}
if filters:
filter_clauses = build_filter_clauses(filters)
if filter_clauses:
filter_expression["filter"] = filter_clauses
# Add limit and score threshold to the filter expression (only if different from defaults)
if limit and limit != 10: # 10 is the default limit
filter_expression["limit"] = limit
if score_threshold and score_threshold != 0: # 0 is the default threshold
filter_expression["score_threshold"] = score_threshold
# Pass the complete filter expression as a single header to Langflow (only if we have something to send)
logger.info(
"Sending OpenRAG query filter to Langflow",
filter_expression=filter_expression,
)
extra_headers["X-LANGFLOW-GLOBAL-VAR-OPENRAG-QUERY-FILTER"] = json.dumps(filter_expression)
logger.info(
"[CHAT] Langflow chat request", stream=stream, filters_applied=bool(filter_expression)
)
# Ensure the Langflow client exists; try lazy init if needed
langflow_client = await clients.ensure_langflow_client()
if not langflow_client:
raise ValueError(
"Langflow client not initialized. Ensure LANGFLOW is reachable or set LANGFLOW_KEY."
)
if stream:
from agent import async_langflow_chat_stream
return async_langflow_chat_stream(
langflow_client,
LANGFLOW_CHAT_FLOW_ID,
prompt,
conversation_user_id,
extra_headers=extra_headers,
previous_response_id=previous_response_id,
conversation_id=conversation_id,
filter_id=filter_id,
)
else:
from agent import async_langflow_chat
response_text, response_id, sources = await async_langflow_chat(
langflow_client,
LANGFLOW_CHAT_FLOW_ID,
prompt,
conversation_user_id,
extra_headers=extra_headers,
previous_response_id=previous_response_id,
conversation_id=conversation_id,
filter_id=filter_id,
)
response_data = {"response": response_text}
if response_id:
response_data["response_id"] = response_id
if sources:
response_data["sources"] = sources
return response_data
async def langflow_nudges_chat(
self,
user_id: str = None,
jwt_token: str = None,
previous_response_id: str = None,
filters: dict = None,
limit: int = None,
score_threshold: float = None,
storage_user_id: str = None,
):
"""Handle Langflow nudges chat requests with knowledge filters"""
conversation_user_id = storage_user_id or user_id
if not LANGFLOW_URL or not NUDGES_FLOW_ID:
raise ValueError("LANGFLOW_URL and NUDGES_FLOW_ID environment variables are required")
# Prepare extra headers for JWT authentication and embedding model.
# NOTE: extra_headers accumulates raw secrets (JWT, provider API keys —
# see add_provider_credentials_to_headers below). Never log this dict or
# pass it to a logger call (e.g. logger.info(..., extra_headers=...)).
extra_headers = {}
if jwt_token:
extra_headers["X-LANGFLOW-GLOBAL-VAR-JWT"] = jwt_token
from config.settings import get_openrag_config
from services.langflow_llm_token_service import HOP_PURPOSE_CHAT
from utils.langflow_headers import (
add_provider_credentials_to_headers,
build_model_provider_headers,
)
config = get_openrag_config()
extra_headers.update(build_model_provider_headers(config))
# Add provider credentials to headers
await add_provider_credentials_to_headers(
extra_headers,
config,
flows_service=self.flows_service,
jwt_token=jwt_token,
user_id=user_id,
purpose=HOP_PURPOSE_CHAT,
)
# Build the complete filter expression like the chat service does
filter_expression: dict[str, Any] = {}
has_user_filters = False
filter_clauses = build_filter_clauses(filters)
if filters:
if filter_clauses:
has_user_filters = True
# If no user filters are active, exclude sample data from nudges
if not has_user_filters:
# Add a bool query with must_not to exclude sample data
filter_clauses.append({"bool": {"must_not": [{"term": {"is_sample_data": "true"}}]}})
logger.info("Excluding sample data from nudges (no user filters active)")
# Set the filter clauses if we have any
if filter_clauses:
filter_expression["filter"] = filter_clauses
# Add limit and score threshold to the filter expression (only if different from defaults)
if limit and limit != 10: # 10 is the default limit
filter_expression["limit"] = limit
if score_threshold and score_threshold != 0: # 0 is the default threshold
filter_expression["score_threshold"] = score_threshold
# Pass the complete filter expression as a single header to Langflow (only if we have something to send)
extra_headers["X-LANGFLOW-GLOBAL-VAR-OPENRAG-QUERY-FILTER"] = json.dumps(filter_expression)
logger.info("[CHAT] Nudges request", filters_applied=bool(filter_expression))
# Ensure the Langflow client exists; try lazy init if needed
langflow_client = await clients.ensure_langflow_client()
if not langflow_client:
raise ValueError(
"Langflow client not initialized. Ensure LANGFLOW is reachable or set LANGFLOW_KEY."
)
prompt = ""
if previous_response_id:
messages = []
# Try in-memory active conversation first
from agent import active_conversations
if (
conversation_user_id in active_conversations
and previous_response_id in active_conversations[conversation_user_id]
):
messages = active_conversations[conversation_user_id][previous_response_id].get(
"messages", []
)
# Filter out system messages
user_ast_messages = [m for m in messages if m.get("role") in ["user", "assistant"]]
# If no history in memory, try fetching from Langflow persistent history
if not user_ast_messages:
from services.langflow_history_service import langflow_history_service
try:
lf_messages = await langflow_history_service.get_session_messages(
conversation_user_id, previous_response_id
)
if lf_messages:
messages = lf_messages
user_ast_messages = [
m for m in messages if m.get("role") in ["user", "assistant"]
]
except Exception as e:
logger.warning(f"Failed to fetch session messages for nudges: {e}")
if user_ast_messages:
# Return at max 8 messages (the last ones)
user_ast_messages = user_ast_messages[-8:]
formatted_messages = []
def trim_results(r, depth=0):
MAX_DEPTH = 3
MAX_LIST_LEN = 3
MAX_DICT_KEYS = 5
MAX_STR_LEN = 1000
if isinstance(r, str):
return r[:MAX_STR_LEN] + ("..." if len(r) > MAX_STR_LEN else "")
elif isinstance(r, list):
if depth >= MAX_DEPTH:
return "[Max depth reached]"
return [trim_results(x, depth + 1) for x in r[:MAX_LIST_LEN]]
elif isinstance(r, dict):
if depth >= MAX_DEPTH:
return "[Max depth reached]"
trimmed = {}
for i, (k, v) in enumerate(r.items()):
if i >= MAX_DICT_KEYS:
trimmed["_more_keys"] = f"... ({len(r) - MAX_DICT_KEYS} omitted)"
break
trimmed[k] = trim_results(v, depth + 1)
return trimmed
return r
for msg in user_ast_messages:
role = msg.get("role")
content = msg.get("content", "")
msg_str = f"{role}: {content}"
# Extract tool calls and chunks if this is an assistant message
if role == "assistant":
extracted_chunks = []
# 1. From chunks list
chunks = msg.get("chunks") or []
if isinstance(chunks, list):
last_tc = None
for chunk in chunks:
if isinstance(chunk, dict):
item = chunk.get("item", {})
if isinstance(item, dict) and item.get("type") in [
"tool_call",
"retrieval_call",
]:
t_name = item.get("tool_name") or item.get("name") or "tool"
res = trim_results(item.get("results"))
tc = {"tool_name": t_name, "results": res}
extracted_chunks.append(tc)
last_tc = tc
elif chunk.get("type") in [
"response.tool_call.result",
"tool_call_result",
]:
res = trim_results(chunk.get("result") or chunk)
if last_tc:
last_tc["results"] = res
else:
extracted_chunks.append(
{"tool_name": "tool", "results": res}
)
# 2. From response_data dict/string
resp_data = msg.get("response_data")
if resp_data:
if isinstance(resp_data, str):
try:
resp_data = json.loads(resp_data)
except Exception:
resp_data = {}
if isinstance(resp_data, dict):
t_calls = resp_data.get("tool_calls") or []
if isinstance(t_calls, list):
for tc in t_calls:
if isinstance(tc, dict):
t_name = tc.get("name")
func = tc.get("function")
if isinstance(func, dict) and not t_name:
t_name = func.get("name")
res = trim_results(tc.get("result"))
extracted_chunks.append(
{"tool_name": t_name or "tool", "results": res}
)
if extracted_chunks:
chunks_strs = []
for tc in extracted_chunks:
t_name = tc.get("tool_name", "tool")
res = tc.get("results")
if res is not None:
res_str = json.dumps(res, ensure_ascii=False, default=str)
chunks_strs.append(f"[Tool: {t_name}, Results: {res_str}]")
if chunks_strs:
msg_str += "\nContext Chunks:\n" + "\n".join(chunks_strs)
formatted_messages.append(msg_str)
prompt = "\n\n".join(formatted_messages)
from agent import async_langflow_chat
response_text, response_id, _sources = await async_langflow_chat(
langflow_client,
NUDGES_FLOW_ID,
prompt,
conversation_user_id,
extra_headers=extra_headers,
store_conversation=False,
)
response_data = {"response": response_text}
if response_id:
response_data["response_id"] = response_id
return response_data
async def upload_context_chat(
self,
document_content: str,
filename: str,
user_id: str = None,
jwt_token: str = None,
previous_response_id: str = None,
endpoint: str = "langflow",
owner: str = None,
owner_name: str = None,
owner_email: str = None,
storage_user_id: str = None,
):
"""Send document content as user message to get proper response_id"""
document_prompt = (
f"I'm uploading a document called '{filename}'. Here is its content:\n\n"
f"{fence_untrusted_text(document_content)}\n\n"
"Please confirm you've received this document and are ready to answer questions about it."
)
conversation_user_id = storage_user_id or user_id
if endpoint == "langflow":
# Prepare extra headers for JWT authentication and embedding model.
# NOTE: extra_headers accumulates raw secrets (JWT, provider API keys).
# Never log this dict or pass it to a logger call
# (e.g. logger.info(..., extra_headers=...)).
extra_headers = {}
if jwt_token:
extra_headers["X-LANGFLOW-GLOBAL-VAR-JWT"] = jwt_token
from config.settings import get_openrag_config
from services.langflow_llm_token_service import HOP_PURPOSE_CHAT
from utils.langflow_headers import (
add_provider_credentials_to_headers,
build_model_provider_headers,
)
config = get_openrag_config()
embedding_model = config.knowledge.embedding_model
embedding_provider = config.knowledge.embedding_provider or "openai"
chunk_size = getattr(config.knowledge, "chunk_size", 1000)
chunk_overlap = getattr(config.knowledge, "chunk_overlap", 200)
extra_headers.update(build_model_provider_headers(config))
# Configure ingest callback credentials/vars like ingestion does
import uuid
from config.settings import (
LANGFLOW_INGEST_CALLBACK_BATCH_SIZE,
get_index_name,
get_ingest_callback_url,
)
from services.document_index_writer import DocumentIndexContext
from services.langflow_ingest_token_service import LangflowIngestTokenService
doc_id = str(uuid.uuid4())
ingest_run_id = f"{doc_id}-{uuid.uuid4().hex}"
context = DocumentIndexContext(
document_id=doc_id,
filename="",
mimetype="",
embedding_model=embedding_model,
embedding_provider=embedding_provider,
owner=owner,
owner_name=owner_name,
owner_email=owner_email,
file_size=0,
connector_type="url",
source_url=None,
allowed_users=[],
allowed_groups=[],
allowed_principals=[],
allowed_principal_labels=[],
ingest_run_id=ingest_run_id,
is_sample_data=False,
index_name=get_index_name(),
parser="URL Ingester",
chunk_size=chunk_size,
chunk_overlap=chunk_overlap,
)
token_service = LangflowIngestTokenService()
ingest_token = token_service.create_token(context)
extra_headers["X-Langflow-Global-Var-OPENRAG_INGEST_URL"] = get_ingest_callback_url()
extra_headers["X-Langflow-Global-Var-OPENRAG_INGEST_TOKEN"] = ingest_token
extra_headers["X-Langflow-Global-Var-OPENRAG_INGEST_RUN_ID"] = ingest_run_id
extra_headers["X-Langflow-Global-Var-OPENRAG_INGEST_BATCH_SIZE"] = str(
LANGFLOW_INGEST_CALLBACK_BATCH_SIZE
)
extra_headers["X-Langflow-Global-Var-CONNECTOR_TYPE"] = "url"
# Add provider credentials to headers
await add_provider_credentials_to_headers(
extra_headers,
config,
flows_service=self.flows_service,
jwt_token=jwt_token,
user_id=user_id,
purpose=HOP_PURPOSE_CHAT,
)
# Ensure the Langflow client exists; try lazy init if needed
langflow_client = await clients.ensure_langflow_client()
if not langflow_client:
raise ValueError(
"Langflow client not initialized. Ensure LANGFLOW is reachable or set LANGFLOW_KEY."
)
response_text, response_id = await async_langflow(
langflow_client=langflow_client,
flow_id=LANGFLOW_CHAT_FLOW_ID,
prompt=document_prompt,
extra_headers=extra_headers,
previous_response_id=previous_response_id,
)
else: # chat
# Set auth context for chat tools and provide user_id
if user_id and jwt_token:
set_auth_context(user_id, jwt_token)
response_text, response_id = await async_chat(
clients.patched_llm_client,
document_prompt,
conversation_user_id,
previous_response_id=previous_response_id,
)
return response_text, response_id
async def get_chat_history(self, user_id: str):
"""Get chat conversation history for a user"""
from agent import active_conversations, get_user_conversations
if not user_id:
return {"error": "User ID is required", "conversations": []}
# Get metadata from persistent storage
conversations_dict = await get_user_conversations(user_id)
# Get in-memory conversations (with function calls)
in_memory_conversations = active_conversations.get(user_id, {})
logger.debug(
"Getting chat history for user",
user_id=user_id,
persistent_count=len(conversations_dict),
in_memory_count=len(in_memory_conversations),
)
# Convert conversations dict to list format with metadata
conversations = []
# First, process in-memory conversations (they have function calls)
for response_id, conversation_state in in_memory_conversations.items():
# Filter out system messages
messages = []
for msg in conversation_state.get("messages", []):
if msg.get("role") in ["user", "assistant"]:
message_data = {
"role": msg["role"],
"content": msg["content"],
"timestamp": msg.get("timestamp").isoformat()
if msg.get("timestamp")
else None,
}
if msg.get("response_id"):
message_data["response_id"] = msg["response_id"]
# Include function call data if present
if msg.get("chunks"):
message_data["chunks"] = msg["chunks"]
if msg.get("response_data"):
message_data["response_data"] = msg["response_data"]
messages.append(message_data)
if messages: # Only include conversations with actual messages
# Generate title from first user message
first_user_msg = next((msg for msg in messages if msg["role"] == "user"), None)
title = (
first_user_msg["content"][:50] + "..."
if first_user_msg and len(first_user_msg["content"]) > 50
else first_user_msg["content"]
if first_user_msg
else "New chat"
)
persisted_metadata = conversation_state.get("_persisted_metadata", {})
conversations.append(
{
"response_id": response_id,
"title": persisted_metadata.get("title") or title,
"endpoint": "chat",
"messages": messages,
"created_at": conversation_state.get("created_at").isoformat()
if conversation_state.get("created_at")
else None,
"last_activity": conversation_state.get("last_activity").isoformat()
if conversation_state.get("last_activity")
else None,
"previous_response_id": conversation_state.get("previous_response_id"),
"filter_id": conversation_state.get("filter_id"),
"total_messages": (persisted_metadata.get("total_messages") or 0)
+ len(messages),
"source": "in_memory",
}
)
# Then, add any persistent metadata that doesn't have in-memory data
for response_id, metadata in conversations_dict.items():
if response_id not in in_memory_conversations:
# This is metadata-only conversation (no function calls)
conversations.append(
{
"response_id": response_id,
"title": metadata.get("title", "New Chat"),
"endpoint": "chat",
"messages": [], # No messages in metadata-only
"created_at": metadata.get("created_at"),
"last_activity": metadata.get("last_activity"),
"previous_response_id": metadata.get("previous_response_id"),
"filter_id": metadata.get("filter_id"),
"total_messages": metadata.get("total_messages", 0),
"source": "metadata_only",
}
)
# Sort by last activity (most recent first)
conversations.sort(key=lambda c: c.get("last_activity", ""), reverse=True)
return {
"user_id": user_id,
"endpoint": "chat",
"conversations": conversations,
"total_conversations": len(conversations),
}
@staticmethod
def _messages_from_active_conversation(conversation_state: dict) -> list[dict]:
"""Serialize in-memory OpenRAG thread messages for the history API."""
messages = []
for msg in conversation_state.get("messages", []):
if msg.get("role") not in ["user", "assistant"]:
continue
message_data = {
"role": msg["role"],
"content": msg["content"],
"timestamp": msg.get("timestamp").isoformat()
if hasattr(msg.get("timestamp"), "isoformat")
else msg.get("timestamp"),
"source": "openrag_memory",
}
if msg.get("error"):
message_data["error"] = True
if msg.get("chunks"):
message_data["chunks"] = msg["chunks"]
if msg.get("response_data"):
message_data["response_data"] = msg["response_data"]
messages.append(message_data)
return messages
async def get_langflow_history(self, user_id: str):
"""Get langflow conversation history for a user - now fetches from both OpenRAG memory and Langflow database"""
from agent import active_conversations, get_user_conversations
from services.langflow_history_service import langflow_history_service
if not user_id:
return {"error": "User ID is required", "conversations": []}
all_conversations = []
local_metadata: dict = {}
in_memory = active_conversations.get(user_id, {})
try:
# 1. Get local conversation metadata (no actual messages stored here)
conversations_dict = await get_user_conversations(user_id)
for response_id, conversation_metadata in conversations_dict.items():
# Store metadata for later use with Langflow data
local_metadata[response_id] = conversation_metadata
# 2. Get actual conversations from Langflow database (source of truth for messages)
logger.debug(f"Attempting to fetch Langflow history for user: {user_id}")
langflow_history = await langflow_history_service.get_user_conversation_history(
user_id, flow_id=LANGFLOW_CHAT_FLOW_ID
)
if langflow_history.get("conversations"):
for conversation in langflow_history["conversations"]:
session_id = conversation["session_id"]
# Only process sessions that belong to this user (exist in local metadata)
if session_id not in local_metadata:
continue
# Use Langflow messages (with function calls) as source of truth
messages = []
for msg in conversation.get("messages", []):
message_data = {
"role": msg["role"],
"content": msg["content"],
"timestamp": msg.get("timestamp"),
"langflow_message_id": msg.get("langflow_message_id"),
"source": "langflow",
}
if msg.get("error"):
message_data["error"] = True
# Include function call data if present
if msg.get("chunks"):
message_data["chunks"] = msg["chunks"]
if msg.get("response_data"):
message_data["response_data"] = msg["response_data"]
messages.append(message_data)
# Prefer OpenRAG memory when it has more turns (error retries use a
# fresh Langflow session under the same OpenRAG thread id).
memory_messages = self._messages_from_active_conversation(
in_memory.get(session_id, {})
)
if len(memory_messages) > len(messages):
messages = memory_messages
source = "openrag_memory_preferred"
else:
source = "langflow_enhanced"
if messages:
metadata = local_metadata.get(session_id, {})
first_user_msg = next(
(msg for msg in messages if msg["role"] == "user"), None
)
title = metadata.get("title") or (
first_user_msg["content"][:50] + "..."
if first_user_msg and len(first_user_msg["content"]) > 50
else first_user_msg["content"]
if first_user_msg
else "Langflow chat"
)
all_conversations.append(
{
"response_id": session_id,
"title": title,
"endpoint": "langflow",
"messages": messages,
"created_at": metadata.get("created_at")
or conversation.get("created_at"),
"last_activity": metadata.get("last_activity")
or conversation.get("last_activity"),
"filter_id": metadata.get("filter_id"),
"total_messages": len(messages),
"source": source,
"langflow_session_id": session_id,
"langflow_flow_id": conversation.get("flow_id"),
}
)
except Exception as e:
logger.error(f"Failed to fetch Langflow history: {e}")
# Local-only threads + upgrade listed ones from memory/metadata snapshots
# (Langflow history is incomplete after fresh-session error retries).
listed_ids = {c["response_id"] for c in all_conversations}
for response_id, metadata in local_metadata.items():
conversation_state = in_memory.get(response_id, {})
messages = self._messages_from_active_conversation(conversation_state)
if not messages and isinstance(metadata.get("messages"), list):
messages = [
m
for m in metadata["messages"]
if isinstance(m, dict) and m.get("role") in ["user", "assistant"]
]
if response_id in listed_ids:
existing = next(c for c in all_conversations if c["response_id"] == response_id)
if len(messages) > len(existing.get("messages") or []):
existing["messages"] = messages
existing["total_messages"] = len(messages)
existing["source"] = "openrag_memory_preferred"
continue
if not messages and not metadata.get("title"):
continue
first_user_msg = next((msg for msg in messages if msg["role"] == "user"), None)
title = metadata.get("title") or (
first_user_msg["content"][:50] + "..."
if first_user_msg and len(first_user_msg["content"]) > 50
else first_user_msg["content"]
if first_user_msg
else "New Chat"
)
created_at = metadata.get("created_at") or conversation_state.get("created_at")
last_activity = metadata.get("last_activity") or conversation_state.get("last_activity")
all_conversations.append(
{
"response_id": response_id,
"title": title,
"endpoint": "langflow",
"messages": messages,
"created_at": created_at.isoformat()
if hasattr(created_at, "isoformat")
else created_at,
"last_activity": last_activity.isoformat()
if hasattr(last_activity, "isoformat")
else last_activity,
"filter_id": metadata.get("filter_id") or conversation_state.get("filter_id"),
"total_messages": len(messages) or metadata.get("total_messages", 0),
"source": "local_error_fallback",
}
)
# Sort by last activity (most recent first)
all_conversations.sort(key=lambda c: c.get("last_activity", ""), reverse=True)
logger.debug(
"[CHAT] Returning conversations",
total=len(all_conversations),
from_local_metadata=len(local_metadata),
)
return {
"user_id": user_id,
"endpoint": "langflow",
"conversations": all_conversations,
"total_conversations": len(all_conversations),
}
async def delete_session(self, user_id: str, session_id: str):
"""Delete a session from both local storage and Langflow"""
try:
# Resolve the complete, owned group before removing any associations.
from agent import delete_user_conversation
from services.session_ownership_service import session_ownership_service
session_ids = await session_ownership_service.get_conversation_sessions(
user_id, session_id
)
# Attempt every upstream deletion first: local revocation failures
# must not erase JSON-only aliases before their cleanup is attempted.
upstream_results = [
await self._delete_langflow_session(owned_id) for owned_id in session_ids
]
langflow_deleted = bool(upstream_results) and all(upstream_results)
local_deleted = await delete_user_conversation(
user_id, session_id, session_ids=session_ids
)
if not local_deleted:
return {
"success": False,
"not_found": True,
"error": "Conversation not found",
}
return {
"success": True,
"local_deleted": local_deleted,
"langflow_deleted": langflow_deleted,
"error": None,
}
except Exception as e:
logger.error(f"Error deleting session {session_id} for user {user_id}: {e}")
return {"success": False, "error": str(e)}
async def delete_sessions(self, user_id: str, session_ids: list[str]) -> dict[str, list[str]]:
"""Best-effort bulk delete, any failures are returned in response + logged
Returns {"deleted": [ids], "failed": [ids]}.
"""
from services.session_ownership_service import session_ownership_service
deleted: list[str] = []
failed: list[str] = []
for session_id in dict.fromkeys(session_ids):
try:
owner = await session_ownership_service.get_session_owner(session_id)
if owner is not None and owner != user_id:
logger.warning("bulk_delete: %s not owned by %s", session_id, user_id)
failed.append(session_id)
continue
result = await self.delete_session(user_id, session_id)
if result.get("success"):
deleted.append(session_id)
else:
logger.warning("bulk_delete: %s error: %s", session_id, result.get("error"))
failed.append(session_id)
except Exception:
logger.exception("bulk_delete: %s unexpected error", session_id)
failed.append(session_id)
return {"deleted": deleted, "failed": failed}
async def _delete_langflow_session(self, session_id: str):
"""Delete a session from Langflow using the monitor API"""
try:
response = await clients.langflow_request(
"DELETE", f"/api/v1/monitor/messages/session/{session_id}"
)
if response.status_code == 200 or response.status_code == 204:
logger.info(f"Successfully deleted session {session_id} from Langflow")
return True
else:
logger.warning(
f"Failed to delete session {session_id} from Langflow: "
f"{response.status_code} - {response.text}"
)
return False
except Exception as e:
logger.error(f"Error deleting session {session_id} from Langflow: {e}")
return False
async def delete_all_user_sessions(self, user_id: str):
"""Delete all sessions for a user from both local storage and Langflow"""
from agent import get_user_conversations
conversations = await get_user_conversations(user_id)
session_ids = list(conversations.keys())
results = []
for session_id in session_ids:
result = await self.delete_session(user_id, session_id)
results.append(result)
return {
"success": True,
"deleted_count": len([r for r in results if r.get("success")]),
"total_count": len(session_ids),
}