Coverage for open_webui/env.py: 64%

1import datetime as dt 

2import importlib.metadata 

3import json 

4import logging 

5import os 

6import pkgutil 

7import re 

8import shutil 

9import sys 

10import threading 

11import traceback 

12from contextlib import nullcontext 

13from pathlib import Path 

14from typing import Any, Optional 

15from uuid import uuid4 

16 

17import markdown 

18from bs4 import BeautifulSoup 

19from cryptography.hazmat.primitives import serialization 

20 

21#################################### 

22# Load .env file 

23#################################### 

24 

25# Use .resolve() to get the canonical path, removing any '..' or '.' components 

26ENV_FILE_PATH = Path(__file__).resolve() 

27 

28# OPEN_WEBUI_DIR should be the directory where env.py resides (open_webui/) 

29OPEN_WEBUI_DIR = ENV_FILE_PATH.parent 

30 

31# BACKEND_DIR is the parent of OPEN_WEBUI_DIR (backend/) 

32BACKEND_DIR = OPEN_WEBUI_DIR.parent 

33 

34# BASE_DIR is the parent of BACKEND_DIR (open-webui-dev/) 

35BASE_DIR = BACKEND_DIR.parent 

36 

37try: 

38 from dotenv import find_dotenv, load_dotenv 

39 

40 load_dotenv(find_dotenv(str(BASE_DIR / '.env'))) 

41except ImportError: 

42 print('dotenv not installed, skipping...') 

43 

44DOCKER = os.getenv('DOCKER', 'False').lower() == 'true' 

45USE_SLIM = os.getenv('USE_SLIM_DOCKER', 'False').lower() == 'true' 

46 

47USE_CUDA = os.getenv('USE_CUDA_DOCKER', 'false') 

48DEVICE_TYPE = 'cpu' 

49_cuda_error: Optional[str] = None 

50 

51if not USE_SLIM and USE_CUDA.lower() == 'true': 51 ↛ 52line 51 didn't jump to line 52 because the condition on line 51 was never true

52 try: 

53 import torch # noqa: E402 

54 

55 if not torch.cuda.is_available(): 

56 raise RuntimeError('CUDA not available') 

57 DEVICE_TYPE = 'cuda' 

58 except Exception as exc: 

59 _cuda_error = f'CUDA unavailable (USE_CUDA_DOCKER=true), falling back to CPU: {exc}' 

60 os.environ['USE_CUDA_DOCKER'] = 'false' 

61 USE_CUDA = 'false' 

62 

63if not USE_SLIM and sys.platform == 'darwin' and DEVICE_TYPE == 'cpu': 63 ↛ 64line 63 didn't jump to line 64 because the condition on line 63 was never true

64 try: 

65 import torch # noqa: E402 

66 

67 if torch.backends.mps.is_available() and torch.backends.mps.is_built(): 

68 DEVICE_TYPE = 'mps' 

69 except Exception: 

70 pass 

71 

72# Torch MPS inference is not thread-safe and a concurrent call kills the whole process. 

73MPS_INFERENCE_LOCK = threading.Lock() if DEVICE_TYPE == 'mps' else nullcontext() 

74 

75#################################### 

76# LOGGING 

77#################################### 

78 

79_LEVEL_MAP = { 

80 'DEBUG': 'debug', 

81 'INFO': 'info', 

82 'WARNING': 'warn', 

83 'ERROR': 'error', 

84 'CRITICAL': 'fatal', 

85} 

86 

87 

88class JSONFormatter(logging.Formatter): 

89 """Format log records as single-line JSON objects for structured logging.""" 

90 

91 def format(self, record: logging.LogRecord) -> str: 

92 log_entry: dict[str, Any] = { 

93 'ts': dt.datetime.fromtimestamp(record.created, tz=dt.UTC).isoformat(timespec='milliseconds'), 

94 'level': _LEVEL_MAP.get(record.levelname, record.levelname.lower()), 

95 'msg': record.getMessage(), 

96 'caller': record.name, 

97 } 

98 

99 if record.exc_info and record.exc_info[0] is not None: 

100 log_entry['error'] = ''.join(traceback.format_exception(*record.exc_info)).rstrip() 

101 elif record.exc_text: 

102 log_entry['error'] = record.exc_text 

103 

104 if record.stack_info: 

105 log_entry['stacktrace'] = record.stack_info 

106 

107 return json.dumps(log_entry, ensure_ascii=False, default=str) 

108 

109 

110LOG_FORMAT = os.getenv('LOG_FORMAT', '').lower() 

111LOGURU_DIAGNOSE = os.getenv('LOGURU_DIAGNOSE', 'False').lower() == 'true' 

112 

113GLOBAL_LOG_LEVEL = os.getenv('GLOBAL_LOG_LEVEL', '').upper() 

114if GLOBAL_LOG_LEVEL in logging.getLevelNamesMapping(): 114 ↛ 115line 114 didn't jump to line 115 because the condition on line 114 was never true

115 _log_cfg: dict[str, Any] = {'level': GLOBAL_LOG_LEVEL, 'force': True} 

116 if LOG_FORMAT == 'json': 

117 _json_handler = logging.StreamHandler(sys.stdout) 

118 _json_handler.setFormatter(JSONFormatter()) 

119 _log_cfg['handlers'] = [_json_handler] 

120 else: 

121 _log_cfg['stream'] = sys.stdout 

122 logging.basicConfig(**_log_cfg) 

123else: 

124 GLOBAL_LOG_LEVEL = 'INFO' 

125 

126log = logging.getLogger(__name__) 

127log.info('GLOBAL_LOG_LEVEL: %s', GLOBAL_LOG_LEVEL) 

128 

129if _cuda_error: 129 ↛ 130line 129 didn't jump to line 130 because the condition on line 129 was never true

130 log.error(_cuda_error) 

131 _cuda_error = None 

132 

133SRC_LOG_LEVELS = {} # Legacy variable, do not remove 

134 

135#################################### 

136# ENV (dev,test,prod) 

137#################################### 

138 

139ENV = os.getenv('ENV', 'dev') 

140 

141FROM_INIT_PY = os.getenv('FROM_INIT_PY', 'False').lower() == 'true' 

142 

143if FROM_INIT_PY: 143 ↛ 144line 143 didn't jump to line 144 because the condition on line 143 was never true

144 PACKAGE_DATA = {'version': importlib.metadata.version('open-webui')} 

145else: 

146 try: 

147 PACKAGE_DATA = json.loads((BASE_DIR / 'package.json').read_text()) 

148 except Exception: 

149 PACKAGE_DATA = {'version': '0.0.0'} 

150 

151VERSION = PACKAGE_DATA['version'] 

152 

153 

154DEPLOYMENT_ID = os.getenv('DEPLOYMENT_ID', '') 

155INSTANCE_ID = os.getenv('INSTANCE_ID', str(uuid4())) 

156 

157ENABLE_DB_MIGRATIONS = os.getenv('ENABLE_DB_MIGRATIONS', 'True').lower() == 'true' 

158 

159# Swap the JSON encoder/decoder used across the app (HTTP request bodies, JSONResponse 

160# bodies, upstream provider responses, socket.io payloads) from the stdlib `json` module 

161# to orjson. Faster, but stricter: see open_webui/utils/json_codec.py for the differences. 

162ENABLE_ORJSON = os.getenv('ENABLE_ORJSON', 'False').lower() == 'true' 

163 

164 

165# Function to parse each section 

166def parse_section(section): 

167 items = [] 

168 for li in section.find_all('li'): 

169 # Extract raw HTML string 

170 raw_html = str(li) 

171 

172 # Extract text without HTML tags 

173 text = li.get_text(separator=' ', strip=True) 

174 

175 # Split into title and content 

176 parts = text.split(': ', 1) 

177 title = parts[0].strip() if len(parts) > 1 else '' 

178 content = parts[1].strip() if len(parts) > 1 else text 

179 

180 items.append({'title': title, 'content': content, 'raw': raw_html}) 

181 return items 

182 

183 

184try: 

185 changelog_path = BASE_DIR / 'CHANGELOG.md' 

186 with open(str(changelog_path.absolute()), encoding='utf8') as file: 

187 changelog_content = file.read() 

188 

189except Exception: 

190 changelog_content = (pkgutil.get_data('open_webui', 'CHANGELOG.md') or b'').decode() 

191 

192# Convert markdown content to HTML 

193html_content = markdown.markdown(changelog_content) 

194 

195# Parse the HTML content 

196soup = BeautifulSoup(html_content, 'html.parser') 

197 

198# Initialize JSON structure 

199changelog_json = {} 

200 

201# Iterate over each version 

202for version in soup.find_all('h2'): 

203 version_number = version.get_text().strip().split(' - ')[0][1:-1] # Remove brackets 

204 date = version.get_text().strip().split(' - ')[1] 

205 

206 version_data = {'date': date} 

207 

208 # Find the next sibling that is a h3 tag (section title) 

209 current = version.find_next_sibling() 

210 

211 while current and current.name != 'h2': 

212 if current.name == 'h3': 

213 section_title = current.get_text().lower() # e.g., "added", "fixed" 

214 section_items = parse_section(current.find_next_sibling('ul')) 

215 version_data[section_title] = section_items 

216 

217 # Move to the next element 

218 current = current.find_next_sibling() 

219 

220 changelog_json[version_number] = version_data 

221 

222CHANGELOG = changelog_json 

223 

224#################################### 

225# DATA/FRONTEND BUILD DIR 

226#################################### 

227 

228DATA_DIR = Path(os.getenv('DATA_DIR', BACKEND_DIR / 'data')).resolve() 

229 

230if FROM_INIT_PY: 230 ↛ 231line 230 didn't jump to line 231 because the condition on line 230 was never true

231 NEW_DATA_DIR = Path(os.getenv('DATA_DIR', OPEN_WEBUI_DIR / 'data')).resolve() 

232 NEW_DATA_DIR.mkdir(parents=True, exist_ok=True) 

233 

234 # Check if the data directory exists in the package directory 

235 if DATA_DIR.exists() and DATA_DIR != NEW_DATA_DIR: 

236 log.info('Moving %s to %s', DATA_DIR, NEW_DATA_DIR) 

237 for item in DATA_DIR.iterdir(): 

238 dest = NEW_DATA_DIR / item.name 

239 if item.is_dir(): 

240 shutil.copytree(item, dest, dirs_exist_ok=True) 

241 else: 

242 shutil.copy2(item, dest) 

243 

244 # Zip the data directory 

245 shutil.make_archive(DATA_DIR.parent / 'open_webui_data', 'zip', DATA_DIR) 

246 

247 # Remove the old data directory 

248 shutil.rmtree(DATA_DIR) 

249 

250 DATA_DIR = Path(os.getenv('DATA_DIR', OPEN_WEBUI_DIR / 'data')) 

251 

252STATIC_DIR = Path(os.getenv('STATIC_DIR', OPEN_WEBUI_DIR / 'static')) 

253 

254FRONTEND_BUILD_DIR = Path(os.getenv('FRONTEND_BUILD_DIR', BASE_DIR / 'build')).resolve() 

255 

256if FROM_INIT_PY: 256 ↛ 257line 256 didn't jump to line 257 because the condition on line 256 was never true

257 FRONTEND_BUILD_DIR = Path(os.getenv('FRONTEND_BUILD_DIR', OPEN_WEBUI_DIR / 'frontend')).resolve() 

258 

259#################################### 

260# Database 

261#################################### 

262 

263# Check if the file exists 

264if os.path.exists(f'{DATA_DIR}/ollama.db'): 264 ↛ 266line 264 didn't jump to line 266 because the condition on line 264 was never true

265 # Rename the file 

266 os.rename(f'{DATA_DIR}/ollama.db', f'{DATA_DIR}/webui.db') 

267 log.info('Database migrated from Ollama-WebUI successfully.') 

268else: 

269 pass 

270 

271DATABASE_URL = os.getenv('DATABASE_URL', f'sqlite:///{DATA_DIR}/webui.db') 

272 

273DATABASE_TYPE = os.getenv('DATABASE_TYPE') 

274DATABASE_USER = os.getenv('DATABASE_USER') 

275DATABASE_PASSWORD = os.getenv('DATABASE_PASSWORD') 

276 

277DATABASE_CRED = '' 

278if DATABASE_USER: 278 ↛ 279line 278 didn't jump to line 279 because the condition on line 278 was never true

279 DATABASE_CRED += f'{DATABASE_USER}' 

280if DATABASE_PASSWORD: 280 ↛ 281line 280 didn't jump to line 281 because the condition on line 280 was never true

281 DATABASE_CRED += f':{DATABASE_PASSWORD}' 

282 

283DB_VARS = { 

284 'db_type': DATABASE_TYPE, 

285 'db_cred': DATABASE_CRED, 

286 'db_host': os.getenv('DATABASE_HOST'), 

287 'db_port': os.getenv('DATABASE_PORT'), 

288 'db_name': os.getenv('DATABASE_NAME'), 

289} 

290 

291if all(DB_VARS.values()): 291 ↛ 292line 291 didn't jump to line 292 because the condition on line 291 was never true

292 DATABASE_URL = ( 

293 f'{DB_VARS["db_type"]}://{DB_VARS["db_cred"]}@{DB_VARS["db_host"]}:{DB_VARS["db_port"]}/{DB_VARS["db_name"]}' 

294 ) 

295elif DATABASE_TYPE == 'sqlite+sqlcipher' and not os.getenv('DATABASE_URL'): 295 ↛ 297line 295 didn't jump to line 297 because the condition on line 295 was never true

296 # Handle SQLCipher with local file when DATABASE_URL wasn't explicitly set 

297 DATABASE_URL = f'sqlite+sqlcipher:///{DATA_DIR}/webui.db' 

298 

299# Replace the postgres:// with postgresql:// 

300if 'postgres://' in DATABASE_URL: 300 ↛ 301line 300 didn't jump to line 301 because the condition on line 300 was never true

301 DATABASE_URL = DATABASE_URL.replace('postgres://', 'postgresql://') 

302 

303DATABASE_SCHEMA = os.getenv('DATABASE_SCHEMA', None) 

304DATABASE_ENABLE_IAM_TOKEN_AUTH = os.getenv('DATABASE_ENABLE_IAM_TOKEN_AUTH', 'False').lower() == 'true' 

305 

306_pool_size_raw = os.getenv('DATABASE_POOL_SIZE') 

307try: 

308 DATABASE_POOL_SIZE = int(_pool_size_raw) if _pool_size_raw else None 

309except (ValueError, TypeError): 

310 DATABASE_POOL_SIZE = None 

311 

312_pool_overflow_raw = os.getenv('DATABASE_POOL_MAX_OVERFLOW', '0') 

313try: 

314 DATABASE_POOL_MAX_OVERFLOW = int(_pool_overflow_raw) if _pool_overflow_raw else 0 

315except (ValueError, TypeError): 

316 DATABASE_POOL_MAX_OVERFLOW = 0 

317 

318_pool_timeout_raw = os.getenv('DATABASE_POOL_TIMEOUT', '30') 

319try: 

320 DATABASE_POOL_TIMEOUT = int(_pool_timeout_raw) if _pool_timeout_raw else 30 

321except (ValueError, TypeError): 

322 DATABASE_POOL_TIMEOUT = 30 

323 

324_pool_recycle_raw = os.getenv('DATABASE_POOL_RECYCLE', '3600') 

325try: 

326 DATABASE_POOL_RECYCLE = int(_pool_recycle_raw) if _pool_recycle_raw else 3600 

327except (ValueError, TypeError): 

328 DATABASE_POOL_RECYCLE = 3600 

329 

330DATABASE_ENABLE_SQLITE_WAL = os.getenv('DATABASE_ENABLE_SQLITE_WAL', 'True').lower() == 'true' 

331 

332# SQLite PRAGMA tuning — these defaults are optimised for WAL-mode web-server 

333# workloads. Each can be overridden via its environment variable. 

334# Set any value to an empty string to skip that PRAGMA entirely. 

335 

336# PRAGMA synchronous: NORMAL (1) is safe with WAL and avoids an fsync per 

337# transaction. Valid values: OFF (0), NORMAL (1), FULL (2), EXTRA (3). 

338DATABASE_SQLITE_PRAGMA_SYNCHRONOUS = os.getenv('DATABASE_SQLITE_PRAGMA_SYNCHRONOUS', 'NORMAL') 

339 

340# PRAGMA busy_timeout (ms): how long a connection waits for a write lock 

341# before raising SQLITE_BUSY. 

342DATABASE_SQLITE_PRAGMA_BUSY_TIMEOUT = os.getenv('DATABASE_SQLITE_PRAGMA_BUSY_TIMEOUT', '5000') 

343 

344# PRAGMA cache_size: negative value = KiB. -65536 ≈ 64 MB page cache. 

345DATABASE_SQLITE_PRAGMA_CACHE_SIZE = os.getenv('DATABASE_SQLITE_PRAGMA_CACHE_SIZE', '-65536') 

346 

347# PRAGMA temp_store: MEMORY (2) keeps temp tables and indices in RAM. 

348# Valid values: DEFAULT (0), FILE (1), MEMORY (2). 

349DATABASE_SQLITE_PRAGMA_TEMP_STORE = os.getenv('DATABASE_SQLITE_PRAGMA_TEMP_STORE', 'MEMORY') 

350 

351# PRAGMA mmap_size (bytes): memory-mapped I/O size. 268435456 ≈ 256 MB. 

352# Set to 0 to disable mmap. 

353DATABASE_SQLITE_PRAGMA_MMAP_SIZE = os.getenv('DATABASE_SQLITE_PRAGMA_MMAP_SIZE', '268435456') 

354 

355# PRAGMA journal_size_limit (bytes): caps the WAL file size after checkpoint. 

356# Without this the WAL grows unbounded during write bursts and is never 

357# truncated. 67108864 ≈ 64 MB. Set to -1 for no limit (SQLite default). 

358DATABASE_SQLITE_PRAGMA_JOURNAL_SIZE_LIMIT = os.getenv('DATABASE_SQLITE_PRAGMA_JOURNAL_SIZE_LIMIT', '67108864') 

359 

360# Seconds between presence writes per user per worker; keep under the 180s active-user window. 0 disables. 

361try: 

362 DATABASE_USER_ACTIVE_STATUS_UPDATE_INTERVAL = float(os.getenv('DATABASE_USER_ACTIVE_STATUS_UPDATE_INTERVAL', '60')) 

363except ValueError: 

364 DATABASE_USER_ACTIVE_STATUS_UPDATE_INTERVAL = 60.0 

365 

366DATABASE_ENABLE_SESSION_SHARING = os.getenv('DATABASE_ENABLE_SESSION_SHARING', 'False').lower() == 'true' 

367ENABLE_PUBLIC_ACTIVE_USERS_COUNT = os.getenv('ENABLE_PUBLIC_ACTIVE_USERS_COUNT', 'True').lower() == 'true' 

368RESET_CONFIG_ON_START = os.getenv('RESET_CONFIG_ON_START', 'False').lower() == 'true' 

369ENABLE_REALTIME_CHAT_SAVE = os.getenv('ENABLE_REALTIME_CHAT_SAVE', 'False').lower() == 'true' 

370ENABLE_QUERIES_CACHE = os.getenv('ENABLE_QUERIES_CACHE', 'False').lower() == 'true' 

371ENABLE_ADMIN_CHAT_ACCESS = os.getenv('ENABLE_ADMIN_CHAT_ACCESS', 'True').lower() == 'true' 

372RAG_SYSTEM_CONTEXT = os.getenv('RAG_SYSTEM_CONTEXT', 'False').lower() == 'true' 

373 

374# Empty by default: chunk metadata also holds internal bookkeeping (file hashes, collection names, scores). 

375RAG_SOURCE_METADATA_KEYS = [key.strip() for key in os.getenv('RAG_SOURCE_METADATA_KEYS', '').split(',') if key.strip()] 

376 

377#################################### 

378# REDIS 

379#################################### 

380 

381REDIS_URL = os.getenv('REDIS_URL', '') 

382REDIS_CLUSTER = os.getenv('REDIS_CLUSTER', 'False').lower() == 'true' 

383 

384REDIS_KEY_PREFIX = os.getenv('REDIS_KEY_PREFIX', 'open-webui') 

385 

386try: 

387 REDIS_RESPONSE_STREAM_TTL = int(os.getenv('REDIS_RESPONSE_STREAM_TTL', '3600')) 

388except ValueError: 

389 REDIS_RESPONSE_STREAM_TTL = 3600 

390 

391# Seconds a task survives without a heartbeat. 0 disables expiry. 

392try: 

393 REDIS_TASK_TTL = int(os.getenv('REDIS_TASK_TTL', '300')) 

394 if REDIS_TASK_TTL != 0 and REDIS_TASK_TTL < 60: 394 ↛ 395line 394 didn't jump to line 395 because the condition on line 394 was never true

395 REDIS_TASK_TTL = 300 

396except ValueError: 

397 REDIS_TASK_TTL = 300 

398 

399REDIS_SENTINEL_HOSTS = os.getenv('REDIS_SENTINEL_HOSTS', '') 

400REDIS_SENTINEL_PORT = os.getenv('REDIS_SENTINEL_PORT', '26379') 

401 

402# Maximum number of retries for Redis operations when using Sentinel fail-over 

403REDIS_SENTINEL_MAX_RETRY_COUNT = os.getenv('REDIS_SENTINEL_MAX_RETRY_COUNT', '2') 

404try: 

405 REDIS_SENTINEL_MAX_RETRY_COUNT = int(REDIS_SENTINEL_MAX_RETRY_COUNT) 

406 if REDIS_SENTINEL_MAX_RETRY_COUNT < 1: 406 ↛ 407line 406 didn't jump to line 407 because the condition on line 406 was never true

407 REDIS_SENTINEL_MAX_RETRY_COUNT = 2 

408except ValueError: 

409 REDIS_SENTINEL_MAX_RETRY_COUNT = 2 

410 

411 

412REDIS_SOCKET_CONNECT_TIMEOUT = os.getenv('REDIS_SOCKET_CONNECT_TIMEOUT', '') 

413try: 

414 REDIS_SOCKET_CONNECT_TIMEOUT = float(REDIS_SOCKET_CONNECT_TIMEOUT) 

415except ValueError: 

416 REDIS_SOCKET_CONNECT_TIMEOUT = None 

417 

418REDIS_SOCKET_TIMEOUT = os.getenv('REDIS_SOCKET_TIMEOUT', '') 

419try: 

420 REDIS_SOCKET_TIMEOUT = float(REDIS_SOCKET_TIMEOUT) 

421except ValueError: 

422 REDIS_SOCKET_TIMEOUT = None 

423 

424# Whether to enable TCP SO_KEEPALIVE on Redis client sockets. Opt-in: 

425# defaults to off so behavior is unchanged for existing deployments. When 

426# enabled, the kernel sends TCP keepalive probes on idle connections so 

427# half-closed sockets (e.g. after a silent firewall/LB reset or a NIC 

428# flap) are detected before the next command lands on them. 

429REDIS_SOCKET_KEEPALIVE = os.getenv('REDIS_SOCKET_KEEPALIVE', 'False').lower() == 'true' 

430 

431# How often (in seconds) redis-py should PING an idle pooled connection 

432# before reusing it. Opt-in: defaults to unset (empty string) so behavior 

433# is unchanged for existing deployments. When set, should be shorter than 

434# the Redis server `timeout` setting and any firewall/LB idle timeout on 

435# the path to Redis, so stale connections are detected before a real 

436# command lands on them. Set to 0 or empty to disable. 

437REDIS_HEALTH_CHECK_INTERVAL = os.getenv('REDIS_HEALTH_CHECK_INTERVAL', '') 

438try: 

439 REDIS_HEALTH_CHECK_INTERVAL = int(REDIS_HEALTH_CHECK_INTERVAL) 

440 if REDIS_HEALTH_CHECK_INTERVAL <= 0: 

441 REDIS_HEALTH_CHECK_INTERVAL = None 

442except ValueError: 

443 REDIS_HEALTH_CHECK_INTERVAL = None 

444 

445REDIS_RECONNECT_DELAY = os.getenv('REDIS_RECONNECT_DELAY', '') 

446 

447if REDIS_RECONNECT_DELAY == '': 447 ↛ 450line 447 didn't jump to line 450 because the condition on line 447 was always true

448 REDIS_RECONNECT_DELAY = None 

449else: 

450 try: 

451 REDIS_RECONNECT_DELAY = float(REDIS_RECONNECT_DELAY) 

452 if REDIS_RECONNECT_DELAY < 0: 

453 REDIS_RECONNECT_DELAY = None 

454 except Exception: 

455 REDIS_RECONNECT_DELAY = None 

456 

457#################################### 

458# Uvicorn 

459#################################### 

460 

461try: 

462 UVICORN_WORKERS = max(int(os.getenv('UVICORN_WORKERS', '1')), 1) 

463except (ValueError, TypeError): 

464 UVICORN_WORKERS = 1 

465 

466# tiny delta-stream frames make per-frame websocket compression CPU-bound, allow opting out (true/false) 

467UVICORN_WS_PER_MESSAGE_DEFLATE = os.getenv('UVICORN_WS_PER_MESSAGE_DEFLATE', 'True').lower() == 'true' 

468 

469#################################### 

470# WEBSOCKET SUPPORT 

471#################################### 

472 

473ENABLE_WEBSOCKET_SUPPORT = os.getenv('ENABLE_WEBSOCKET_SUPPORT', 'True').lower() == 'true' 

474 

475 

476WEBSOCKET_MANAGER = os.getenv('WEBSOCKET_MANAGER', '') 

477 

478WEBSOCKET_REDIS_OPTIONS = os.getenv('WEBSOCKET_REDIS_OPTIONS', '') 

479 

480 

481if WEBSOCKET_REDIS_OPTIONS == '': 481 ↛ 486line 481 didn't jump to line 486 because the condition on line 481 was always true

482 WEBSOCKET_REDIS_OPTIONS = {'socket_timeout': None} 

483 if REDIS_SOCKET_CONNECT_TIMEOUT: 483 ↛ 484line 483 didn't jump to line 484 because the condition on line 483 was never true

484 WEBSOCKET_REDIS_OPTIONS['socket_connect_timeout'] = REDIS_SOCKET_CONNECT_TIMEOUT 

485else: 

486 try: 

487 WEBSOCKET_REDIS_OPTIONS = json.loads(WEBSOCKET_REDIS_OPTIONS) 

488 WEBSOCKET_REDIS_OPTIONS.setdefault('socket_timeout', None) 

489 except Exception: 

490 log.warning('Invalid WEBSOCKET_REDIS_OPTIONS, defaulting to socket_timeout=None') 

491 WEBSOCKET_REDIS_OPTIONS = {'socket_timeout': None} 

492 

493WEBSOCKET_REDIS_URL = os.getenv('WEBSOCKET_REDIS_URL', REDIS_URL) 

494WEBSOCKET_REDIS_CLUSTER = os.getenv('WEBSOCKET_REDIS_CLUSTER', str(REDIS_CLUSTER)).lower() == 'true' 

495 

496websocket_redis_lock_timeout = os.getenv('WEBSOCKET_REDIS_LOCK_TIMEOUT', '60') 

497 

498try: 

499 WEBSOCKET_REDIS_LOCK_TIMEOUT = int(websocket_redis_lock_timeout) 

500except ValueError: 

501 WEBSOCKET_REDIS_LOCK_TIMEOUT = 60 

502 

503WEBSOCKET_SENTINEL_HOSTS = os.getenv('WEBSOCKET_SENTINEL_HOSTS', '') 

504WEBSOCKET_SENTINEL_PORT = os.getenv('WEBSOCKET_SENTINEL_PORT', '26379') 

505WEBSOCKET_SERVER_LOGGING = os.getenv('WEBSOCKET_SERVER_LOGGING', 'False').lower() == 'true' 

506WEBSOCKET_SERVER_ENGINEIO_LOGGING = ( 

507 os.getenv( 

508 'WEBSOCKET_SERVER_ENGINEIO_LOGGING', 

509 os.getenv('WEBSOCKET_SERVER_LOGGING', 'False'), 

510 ).lower() 

511 == 'true' 

512) 

513WEBSOCKET_SERVER_PING_TIMEOUT = os.getenv('WEBSOCKET_SERVER_PING_TIMEOUT', '20') 

514try: 

515 WEBSOCKET_SERVER_PING_TIMEOUT = int(WEBSOCKET_SERVER_PING_TIMEOUT) 

516except ValueError: 

517 WEBSOCKET_SERVER_PING_TIMEOUT = 20 

518 

519WEBSOCKET_SERVER_PING_INTERVAL = os.getenv('WEBSOCKET_SERVER_PING_INTERVAL', '25') 

520try: 

521 WEBSOCKET_SERVER_PING_INTERVAL = int(WEBSOCKET_SERVER_PING_INTERVAL) 

522except ValueError: 

523 WEBSOCKET_SERVER_PING_INTERVAL = 25 

524 

525WEBSOCKET_HEARTBEAT_INTERVAL = os.getenv('WEBSOCKET_HEARTBEAT_INTERVAL', '') 

526if WEBSOCKET_HEARTBEAT_INTERVAL == '': 526 ↛ 529line 526 didn't jump to line 529 because the condition on line 526 was always true

527 WEBSOCKET_HEARTBEAT_INTERVAL = None 

528else: 

529 try: 

530 WEBSOCKET_HEARTBEAT_INTERVAL = min(max(int(WEBSOCKET_HEARTBEAT_INTERVAL), 5), 90) 

531 except ValueError: 

532 WEBSOCKET_HEARTBEAT_INTERVAL = 30 

533 

534WEBSOCKET_EVENT_CALLER_TIMEOUT = os.getenv('WEBSOCKET_EVENT_CALLER_TIMEOUT', '') 

535 

536if WEBSOCKET_EVENT_CALLER_TIMEOUT == '': 536 ↛ 539line 536 didn't jump to line 539 because the condition on line 536 was always true

537 WEBSOCKET_EVENT_CALLER_TIMEOUT = None 

538else: 

539 try: 

540 WEBSOCKET_EVENT_CALLER_TIMEOUT = int(WEBSOCKET_EVENT_CALLER_TIMEOUT) 

541 except ValueError: 

542 WEBSOCKET_EVENT_CALLER_TIMEOUT = 300 

543 

544 

545import ssl as _ssl 

546 

547 

548# Dedicated env var for a custom CA bundle file path. When set, this is 

549# used as the default CA bundle for all outbound HTTPS connections that 

550# have SSL verification enabled (i.e. when their per-connection SSL env 

551# var is ``"True"``). Per-connection overrides (setting the SSL env var 

552# to a path directly) take precedence over this global fallback. 

553# 

554# This follows the industry convention of ``SSL_CERT_FILE`` / ``REQUESTS_CA_BUNDLE`` 

555# but is scoped to Open WebUI to avoid interfering with system-level settings. 

556AIOHTTP_CLIENT_SSL_CERT_FILE = os.getenv('AIOHTTP_CLIENT_SSL_CERT_FILE', '').strip() 

557 

558 

559def _build_ssl_context_from_file(path: str) -> '_ssl.SSLContext | None': 

560 """Create an SSLContext from a CA bundle file, or None if invalid.""" 

561 if not path: 561 ↛ 563line 561 didn't jump to line 563 because the condition on line 561 was always true

562 return None 

563 if not os.path.isfile(path): 

564 log.warning( 

565 'SSL CA bundle path does not exist: %r, ignoring', 

566 path, 

567 ) 

568 return None 

569 ctx = _ssl.create_default_context(cafile=path) 

570 log.info('Using custom SSL CA bundle: %s', path) 

571 return ctx 

572 

573 

574# Pre-built SSLContext from the dedicated env var (cached once at startup). 

575_GLOBAL_SSL_CONTEXT = _build_ssl_context_from_file(AIOHTTP_CLIENT_SSL_CERT_FILE) 

576 

577 

578def _parse_ssl_env(value: str) -> 'bool | _ssl.SSLContext': 

579 """Parse an SSL env var into a bool or SSLContext. 

580 

581 - ``"true"`` → uses ``AIOHTTP_CLIENT_SSL_CERT_FILE`` context if set, 

582 otherwise ``True`` (default SSL verification via certifi) 

583 - ``"false"`` → ``False`` (no verification) 

584 - ``"/path/to/ca-bundle.crt"`` → ``SSLContext`` loading that CA file 

585 (takes precedence over ``AIOHTTP_CLIENT_SSL_CERT_FILE``) 

586 

587 This allows users with corporate or internal CAs to point Open WebUI 

588 at a custom CA bundle without disabling verification entirely. 

589 """ 

590 lower = value.strip().lower() 

591 if lower == 'true': 591 ↛ 594line 591 didn't jump to line 594 because the condition on line 591 was always true

592 # Use the global dedicated CA bundle if configured, otherwise default 

593 return _GLOBAL_SSL_CONTEXT if _GLOBAL_SSL_CONTEXT is not None else True 

594 if lower == 'false': 

595 return False 

596 # Treat as a file path to a CA bundle (per-connection override) 

597 ctx = _build_ssl_context_from_file(value.strip()) 

598 if ctx is not None: 

599 return ctx 

600 # Path was invalid — fall back to default 

601 return _GLOBAL_SSL_CONTEXT if _GLOBAL_SSL_CONTEXT is not None else True 

602 

603 

604REQUESTS_VERIFY = os.getenv('REQUESTS_VERIFY', 'True').lower() == 'true' 

605 

606TAVILY_API_BASE_URL = os.getenv('TAVILY_API_BASE_URL', 'https://api.tavily.com').rstrip('/') 

607 

608_aiohttp_timeout_raw = os.getenv('AIOHTTP_CLIENT_TIMEOUT', '') 

609try: 

610 AIOHTTP_CLIENT_TIMEOUT = int(_aiohttp_timeout_raw) if _aiohttp_timeout_raw else None 

611except (ValueError, TypeError): 

612 AIOHTTP_CLIENT_TIMEOUT = 300 

613 

614# Optional between-chunks idle cap for streaming aiohttp requests. 

615AIOHTTP_CLIENT_STREAM_IDLE_TIMEOUT = os.getenv('AIOHTTP_CLIENT_STREAM_IDLE_TIMEOUT', '') 

616if AIOHTTP_CLIENT_STREAM_IDLE_TIMEOUT == '': 616 ↛ 619line 616 didn't jump to line 619 because the condition on line 616 was always true

617 AIOHTTP_CLIENT_STREAM_IDLE_TIMEOUT = None 

618else: 

619 try: 

620 AIOHTTP_CLIENT_STREAM_IDLE_TIMEOUT = int(AIOHTTP_CLIENT_STREAM_IDLE_TIMEOUT) 

621 except (ValueError, TypeError): 

622 AIOHTTP_CLIENT_STREAM_IDLE_TIMEOUT = None 

623 

624if AIOHTTP_CLIENT_STREAM_IDLE_TIMEOUT is not None and AIOHTTP_CLIENT_STREAM_IDLE_TIMEOUT <= 0: 624 ↛ 625line 624 didn't jump to line 625 because the condition on line 624 was never true

625 AIOHTTP_CLIENT_STREAM_IDLE_TIMEOUT = None 

626 

627 

628# SSL verification for general outbound requests (OpenAI, OAuth, etc.). 

629# Accepts "True", "False", or a path to a CA bundle file. 

630# When "True", falls back to AIOHTTP_CLIENT_SSL_CERT_FILE if set. 

631AIOHTTP_CLIENT_SESSION_SSL = _parse_ssl_env(os.getenv('AIOHTTP_CLIENT_SESSION_SSL', 'True')) 

632 

633SEARXNG_CLIENT_CERT_FILE = os.getenv('SEARXNG_CLIENT_CERT_FILE', '').strip() 

634SEARXNG_CLIENT_KEY_FILE = os.getenv('SEARXNG_CLIENT_KEY_FILE', '').strip() 

635 

636# When False (default), outbound HTTP requests do not follow 3xx redirects. 

637AIOHTTP_CLIENT_ALLOW_REDIRECTS = os.getenv('AIOHTTP_CLIENT_ALLOW_REDIRECTS', 'False').lower() == 'true' 

638 

639# Opt-in c-ares DNS resolution (aiodns). Off by default: c-ares breaks name 

640# resolution in some environments (#28013, #28215). Must run before any 

641# TCPConnector is constructed. 

642AIOHTTP_CLIENT_ASYNC_DNS_RESOLVER = os.getenv('AIOHTTP_CLIENT_ASYNC_DNS_RESOLVER', 'False').lower() == 'true' 

643 

644if not AIOHTTP_CLIENT_ASYNC_DNS_RESOLVER: 644 ↛ 654line 644 didn't jump to line 654 because the condition on line 644 was always true

645 import aiohttp 

646 

647 aiohttp.DefaultResolver = aiohttp.resolver.ThreadedResolver # for plugin code 

648 aiohttp.resolver.DefaultResolver = aiohttp.resolver.ThreadedResolver 

649 aiohttp.connector.DefaultResolver = aiohttp.resolver.ThreadedResolver 

650 

651# Optional User-Agent override for outbound web-loader fetches. When set, 

652# SafeWebBaseLoader sends this value instead of the default python-requests UA 

653# which is aggressively blocked by Cloudflare, Wikipedia, and similar services. 

654USER_AGENT = os.getenv('USER_AGENT', '') 

655 

656_model_list_timeout_raw = os.getenv( 

657 'AIOHTTP_CLIENT_TIMEOUT_MODEL_LIST', 

658 os.getenv('AIOHTTP_CLIENT_TIMEOUT_OPENAI_MODEL_LIST', '10'), 

659) 

660try: 

661 AIOHTTP_CLIENT_TIMEOUT_MODEL_LIST = int(_model_list_timeout_raw) if _model_list_timeout_raw else None 

662except (ValueError, TypeError): 

663 AIOHTTP_CLIENT_TIMEOUT_MODEL_LIST = 10 

664 

665_tool_data_timeout_raw = os.getenv('AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER_DATA', '10') 

666try: 

667 AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER_DATA = int(_tool_data_timeout_raw) if _tool_data_timeout_raw else None 

668except (ValueError, TypeError): 

669 AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER_DATA = 10 

670 

671AIOHTTP_FILE_STREAM_CHUNK_SIZE = os.getenv('AIOHTTP_FILE_STREAM_CHUNK_SIZE', str(1024 * 1024)) 

672try: 

673 AIOHTTP_FILE_STREAM_CHUNK_SIZE = int(AIOHTTP_FILE_STREAM_CHUNK_SIZE) 

674except Exception: 

675 AIOHTTP_FILE_STREAM_CHUNK_SIZE = 1024 * 1024 

676 

677if AIOHTTP_FILE_STREAM_CHUNK_SIZE <= 0: 677 ↛ 678line 677 didn't jump to line 678 because the condition on line 677 was never true

678 AIOHTTP_FILE_STREAM_CHUNK_SIZE = 1024 * 1024 

679 

680 

681# SSL verification for tool server connections specifically. 

682# Accepts "True", "False", or a path to a CA bundle file. 

683# When "True", falls back to AIOHTTP_CLIENT_SSL_CERT_FILE if set. 

684AIOHTTP_CLIENT_SESSION_TOOL_SERVER_SSL = _parse_ssl_env(os.getenv('AIOHTTP_CLIENT_SESSION_TOOL_SERVER_SSL', 'True')) 

685 

686AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER = os.getenv('AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER', '') 

687 

688if AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER == '': 688 ↛ 691line 688 didn't jump to line 691 because the condition on line 688 was always true

689 AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER = AIOHTTP_CLIENT_TIMEOUT 

690else: 

691 try: 

692 AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER = int(AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER) 

693 except Exception: 

694 AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER = AIOHTTP_CLIENT_TIMEOUT 

695 

696# Timeout (in seconds) for the MCP session.initialize() handshake. 

697# The handshake performs a list-tools round-trip and can take tens of 

698# seconds on cold-start servers or servers exposing many tools. 

699MCP_INITIALIZE_TIMEOUT = os.getenv('MCP_INITIALIZE_TIMEOUT', '10') 

700try: 

701 MCP_INITIALIZE_TIMEOUT = int(MCP_INITIALIZE_TIMEOUT) 

702except (ValueError, TypeError): 

703 MCP_INITIALIZE_TIMEOUT = 10 

704 

705 

706#################################### 

707# AIOHTTP Connection Pool 

708#################################### 

709 

710AIOHTTP_POOL_CONNECTIONS = os.getenv('AIOHTTP_POOL_CONNECTIONS', '') 

711if AIOHTTP_POOL_CONNECTIONS == '': 711 ↛ 714line 711 didn't jump to line 714 because the condition on line 711 was always true

712 AIOHTTP_POOL_CONNECTIONS = None 

713else: 

714 try: 

715 AIOHTTP_POOL_CONNECTIONS = int(AIOHTTP_POOL_CONNECTIONS) 

716 except ValueError: 

717 AIOHTTP_POOL_CONNECTIONS = None 

718 

719AIOHTTP_POOL_CONNECTIONS_PER_HOST = os.getenv('AIOHTTP_POOL_CONNECTIONS_PER_HOST', '') 

720if AIOHTTP_POOL_CONNECTIONS_PER_HOST == '': 720 ↛ 723line 720 didn't jump to line 723 because the condition on line 720 was always true

721 AIOHTTP_POOL_CONNECTIONS_PER_HOST = None 

722else: 

723 try: 

724 AIOHTTP_POOL_CONNECTIONS_PER_HOST = int(AIOHTTP_POOL_CONNECTIONS_PER_HOST) 

725 except ValueError: 

726 AIOHTTP_POOL_CONNECTIONS_PER_HOST = None 

727 

728AIOHTTP_POOL_DNS_TTL = os.getenv('AIOHTTP_POOL_DNS_TTL', '300') 

729try: 

730 AIOHTTP_POOL_DNS_TTL = int(AIOHTTP_POOL_DNS_TTL) 

731 if AIOHTTP_POOL_DNS_TTL < 0: 731 ↛ 732line 731 didn't jump to line 732 because the condition on line 731 was never true

732 AIOHTTP_POOL_DNS_TTL = 300 

733except ValueError: 

734 AIOHTTP_POOL_DNS_TTL = 300 

735 

736RAG_EMBEDDING_TIMEOUT = os.getenv('RAG_EMBEDDING_TIMEOUT', '') 

737 

738if RAG_EMBEDDING_TIMEOUT == '': 738 ↛ 741line 738 didn't jump to line 741 because the condition on line 738 was always true

739 RAG_EMBEDDING_TIMEOUT = None 

740else: 

741 try: 

742 RAG_EMBEDDING_TIMEOUT = int(RAG_EMBEDDING_TIMEOUT) 

743 except Exception: 

744 RAG_EMBEDDING_TIMEOUT = None 

745 

746 

747#################################### 

748# Auth 

749#################################### 

750 

751WEBUI_AUTH = os.getenv('WEBUI_AUTH', 'True').lower() == 'true' 

752 

753ENABLE_INITIAL_ADMIN_SIGNUP = os.getenv('ENABLE_INITIAL_ADMIN_SIGNUP', 'False').lower() == 'true' 

754ENABLE_SIGNUP_PASSWORD_CONFIRMATION = os.getenv('ENABLE_SIGNUP_PASSWORD_CONFIRMATION', 'False').lower() == 'true' 

755 

756#################################### 

757# Secret key & cookies 

758#################################### 

759 

760# WEBUI_JWT_SECRET_KEY is deprecated; use WEBUI_SECRET_KEY instead. 

761# No hardcoded fallback by design: the supported start scripts set/auto-generate it; unset is rejected below. 

762WEBUI_SECRET_KEY = os.getenv( 

763 'WEBUI_SECRET_KEY', 

764 os.getenv('WEBUI_JWT_SECRET_KEY', ''), 

765) 

766 

767ENABLE_VALVE_ENCRYPTION = os.getenv('ENABLE_VALVE_ENCRYPTION', 'False').lower() == 'true' 

768 

769WEBUI_SESSION_COOKIE_SAME_SITE = os.getenv('WEBUI_SESSION_COOKIE_SAME_SITE', 'lax') 

770WEBUI_SESSION_COOKIE_SECURE = os.getenv('WEBUI_SESSION_COOKIE_SECURE', 'false').lower() == 'true' 

771WEBUI_AUTH_COOKIE_SAME_SITE = os.getenv('WEBUI_AUTH_COOKIE_SAME_SITE', WEBUI_SESSION_COOKIE_SAME_SITE) 

772WEBUI_AUTH_COOKIE_SECURE = ( 

773 os.getenv( 

774 'WEBUI_AUTH_COOKIE_SECURE', 

775 os.getenv('WEBUI_SESSION_COOKIE_SECURE', 'false'), 

776 ).lower() 

777 == 'true' 

778) 

779 

780if WEBUI_AUTH and WEBUI_SECRET_KEY == '': 780 ↛ 781line 780 didn't jump to line 781 because the condition on line 780 was never true

781 raise SystemExit( 

782 'WEBUI_SECRET_KEY is not set. It is a hard requirement when authentication is enabled.\n' 

783 'The supported start methods set or auto-generate it for you: use start.sh (Linux/macOS), ' 

784 'start_windows.bat (Windows), or `open-webui serve`.\n' 

785 'If you start the backend another way (e.g. invoking uvicorn directly, which is unsupported), ' 

786 'you must set WEBUI_SECRET_KEY yourself to a long random value.\n' 

787 'See https://docs.openwebui.com/reference/env-configuration#webui_secret_key' 

788 ) 

789 

790ENABLE_COMPRESSION_MIDDLEWARE = os.getenv('ENABLE_COMPRESSION_MIDDLEWARE', 'True').lower() == 'true' 

791 

792#################################### 

793# Admin Account Runtime Creation 

794#################################### 

795 

796# Optional env vars for creating an admin account on startup 

797# Useful for headless/automated deployments 

798WEBUI_ADMIN_EMAIL = os.getenv('WEBUI_ADMIN_EMAIL', '') 

799WEBUI_ADMIN_PASSWORD = os.getenv('WEBUI_ADMIN_PASSWORD', '') 

800WEBUI_ADMIN_NAME = os.getenv('WEBUI_ADMIN_NAME', 'Admin') 

801 

802WEBUI_AUTH_TRUSTED_EMAIL_HEADER = os.getenv('WEBUI_AUTH_TRUSTED_EMAIL_HEADER', None) 

803WEBUI_AUTH_TRUSTED_NAME_HEADER = os.getenv('WEBUI_AUTH_TRUSTED_NAME_HEADER', None) 

804WEBUI_AUTH_TRUSTED_GROUPS_HEADER = os.getenv('WEBUI_AUTH_TRUSTED_GROUPS_HEADER', None) 

805WEBUI_AUTH_TRUSTED_ROLE_HEADER = os.getenv('WEBUI_AUTH_TRUSTED_ROLE_HEADER', None) 

806 

807# Custom header name for API key authentication. Defaults to 'x-api-key'. 

808# Useful when Open WebUI sits behind a reverse proxy / API gateway that 

809# already uses the Authorization header for its own authentication — set 

810# this to a unique header (e.g. 'X-OpenWebUI-Key') so the middleware 

811# checks the custom header instead and avoids the 401 short-circuit. 

812CUSTOM_API_KEY_HEADER = os.getenv('CUSTOM_API_KEY_HEADER', 'x-api-key') 

813 

814ENABLE_PASSWORD_VALIDATION = os.getenv('ENABLE_PASSWORD_VALIDATION', 'False').lower() == 'true' 

815PASSWORD_HASH_ALGORITHM = os.getenv('PASSWORD_HASH_ALGORITHM', 'bcrypt').lower() 

816PASSWORD_VALIDATION_REGEX_PATTERN = os.getenv( 

817 'PASSWORD_VALIDATION_REGEX_PATTERN', 

818 r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\w\s]).{8,}$', 

819) 

820 

821 

822try: 

823 PASSWORD_VALIDATION_REGEX_PATTERN = rf'{PASSWORD_VALIDATION_REGEX_PATTERN}' 

824 PASSWORD_VALIDATION_REGEX_PATTERN = re.compile(PASSWORD_VALIDATION_REGEX_PATTERN) 

825except Exception as e: 

826 log.error(f'Invalid PASSWORD_VALIDATION_REGEX_PATTERN: {e}') 

827 PASSWORD_VALIDATION_REGEX_PATTERN = re.compile(r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\w\s]).{8,}$') 

828 

829PASSWORD_VALIDATION_HINT = os.getenv('PASSWORD_VALIDATION_HINT', '') 

830 

831 

832BYPASS_MODEL_ACCESS_CONTROL = os.getenv('BYPASS_MODEL_ACCESS_CONTROL', 'False').lower() == 'true' 

833BYPASS_RETRIEVAL_ACCESS_CONTROL = os.getenv('BYPASS_RETRIEVAL_ACCESS_CONTROL', 'False').lower() == 'true' 

834 

835# When True, collection names that do not match any known file-*, user-memory-*, 

836# web-search-*, or knowledge-base collection are allowed through access control 

837# for non-admin users. When False (default), unknown collection names are 

838# denied — closing the legacy unscoped namespace. 

839ENABLE_RETRIEVAL_UNSCOPED_COLLECTIONS = os.getenv('ENABLE_RETRIEVAL_UNSCOPED_COLLECTIONS', 'False').lower() == 'true'