.env

# -----------------------------------------------------------------------------
# SECURITY WARNING: DO NOT DEPLOY WITH DEFAULT PASSWORDS
# For non-local deployments, please change all passwords (ELASTIC_PASSWORD,
# MYSQL_PASSWORD, MINIO_PASSWORD, etc.) to strong, unique values.
# You can generate a random string using: openssl rand -hex 32
# -----------------------------------------------------------------------------

# ------------------------------
# Development mode
# ------------------------------
# Set to `true` only while developing: the server then starts even when the
# running code reports a version older than the database migration marker,
# which any branch targeting a not-yet-tagged release does. Leave it off in
# production, where an older binary must not touch a newer database.
#
# CI (.github/workflows/sep-tests.yml) appends `true` here on every run: the
# image stamps its own git-describe output into /ragflow/VERSION, so a CI build
# reports v0.27.x against the v1.0.0-rc1 marker it migrated to moments
# earlier. Do not treat that generated value as the default.
# RAGFLOW_DEV_MODE=false

# ------------------------------
# docker env var for specifying vector db type at startup
# (based on the vector db type, the corresponding docker
# compose profile will be used)
# ------------------------------
# The type of doc engine to use.
# Available options:
# - `elasticsearch` (default)
# - `infinity` (https://github.com/infiniflow/infinity)
# - `oceanbase` (https://github.com/oceanbase/oceanbase)
# - `opensearch` (https://github.com/opensearch-project/OpenSearch)
# - `seekdb` (https://github.com/oceanbase/seekdb)
# - `gaussdb` GaussDB Centralized / Distributed DocEngine
# - `vastbase` Vastbase G100 (PG-compatible; B or PG dbcompatibility)
DOC_ENGINE=${DOC_ENGINE:-elasticsearch}

# The business metadata database type used by DB_TYPE.
# Available options: mysql (default), postgres, gaussdb, oceanbase.
DB_TYPE=${DB_TYPE:-mysql}

# Device on which deepdoc inference run.
# Available levels:
# - `cpu` (default)
# - `gpu`
DEVICE=${DEVICE:-cpu}

# This controls only the bundled metadata service started by Compose; DB_TYPE
# independently selects the metadata backend used by RAGFlow. Keep `mysql` to
# start the in-cluster MySQL service. For external GaussDB, set both
# DB_TYPE=gaussdb and METADATA_DB_PROFILE=gaussdb so MySQL stays disabled.
METADATA_DB_PROFILE=${METADATA_DB_PROFILE:-mysql}
COMPOSE_PROFILES=${DOC_ENGINE},${DEVICE},metadata-${METADATA_DB_PROFILE}

# The version of Elasticsearch.
STACK_VERSION=${STACK_VERSION:-8.11.3}

# The hostname where the Elasticsearch service is exposed
ES_HOST=es01

# The port used to expose the Elasticsearch service to the host machine,
# allowing EXTERNAL access to the service running inside the Docker container.
ES_PORT=1200

# The password for Elasticsearch.
# WARNING: Change this for production!
ELASTIC_PASSWORD=infini_rag_flow

# the hostname where OpenSearch service is exposed, set it not the same as elasticsearch
OS_PORT=1201

# The hostname where the OpenSearch service is exposed
OS_HOST=opensearch01

# The password for OpenSearch.
# At least one uppercase letter, one lowercase letter, one digit, and one special character
OPENSEARCH_PASSWORD=infini_rag_flow_OS_01

# The port used to expose the Kibana service to the host machine,
# allowing EXTERNAL access to the service running inside the Docker container.
# To enable kibana, you need to:
# 1. Ensure that COMPOSE_PROFILES includes kibana, for example: COMPOSE_PROFILES=${COMPOSE_PROFILES},kibana
# 2. Comment out or delete the following configurations of the es service in docker-compose-base.yml: xpack.security.enabled、xpack.security.http.ssl.enabled、xpack.security.transport.ssl.enabled (for details: https://www.elastic.co/docs/deploy-manage/security/self-auto-setup#stack-existing-settings-detected)
# 3. Adjust the es.hosts in conf/service_config.yaml or docker/service_conf.yaml.template to 'https://localhost:1200'
# 4. After the startup is successful, in the es container, execute the command to generate the kibana token: `bin/elasticsearch-create-enrollment-token -s kibana`, then you can use kibana normally
KIBANA_PORT=6601

# The maximum amount of the memory, in bytes, that a specific Docker container can use while running.
# Update it according to the available memory in the host machine.
MEM_LIMIT=8073741824

# The hostname where the Infinity service is exposed
INFINITY_HOST=infinity

# Port to expose Infinity API to the host
INFINITY_THRIFT_PORT=23817
INFINITY_HTTP_PORT=23820
INFINITY_PSQL_PORT=5432

# The hostname where the SereneDB service is exposed. SereneDB speaks the
# PostgreSQL wire protocol, so DOC_ENGINE=serenedb connects over lib/pq/psycopg2.
SERENEDB_HOST=serenedb
# Port to expose SereneDB to the host
SERENEDB_PORT=7890
# The password for SereneDB (POSTGRES_PASSWORD in the container)
SERENEDB_PASSWORD=infini_rag_flow

# The hostname where the OceanBase service is exposed
OCEANBASE_HOST=oceanbase
# The port used to expose the OceanBase service
OCEANBASE_PORT=2881
# The username for OceanBase
OCEANBASE_USER=root@ragflow
# The password for OceanBase
OCEANBASE_PASSWORD=infini_rag_flow
# The doc database of the OceanBase service to use
OCEANBASE_DOC_DBNAME=ragflow_doc

# GaussDB DocEngine connection. RAGFlow does not start or manage GaussDB;
# configure an existing GaussDB instance here.
# GaussDB host.
GAUSSDB_HOST=
# GaussDB port.
GAUSSDB_PORT=
# GaussDB database name.
GAUSSDB_DATABASE=postgres
# GaussDB login user.
GAUSSDB_USER=
# GaussDB login password.
GAUSSDB_PASSWORD=
# GaussDB schema for RAGFlow DocEngine objects.
GAUSSDB_SCHEMA=

# OceanBase container configuration
OB_CLUSTER_NAME=${OB_CLUSTER_NAME:-ragflow}
OB_TENANT_NAME=${OB_TENANT_NAME:-ragflow}
OB_SYS_PASSWORD=${OCEANBASE_PASSWORD:-infini_rag_flow}
OB_TENANT_PASSWORD=${OCEANBASE_PASSWORD:-infini_rag_flow}
OB_MEMORY_LIMIT=${OB_MEMORY_LIMIT:-10G}
OB_SYSTEM_MEMORY=${OB_SYSTEM_MEMORY:-2G}
OB_DATAFILE_SIZE=${OB_DATAFILE_SIZE:-20G}
OB_LOG_DISK_SIZE=${OB_LOG_DISK_SIZE:-20G}

# The hostname where the SeekDB service is exposed
SEEKDB_HOST=seekdb
# The port used to expose the SeekDB service
SEEKDB_PORT=2881
# The username for SeekDB
SEEKDB_USER=root
# The password for SeekDB
SEEKDB_PASSWORD=infini_rag_flow
# The doc database of the SeekDB service to use
SEEKDB_DOC_DBNAME=ragflow_doc
# SeekDB memory limit
SEEKDB_MEMORY_LIMIT=2G

# The hostname where the Vastbase service is exposed
VB_HOST=vastbase
# The port used to connect to Vastbase from the RAGFlow container.
# Change this if you use external Vastbase.
VB_PORT=5432
# The port used to expose the Vastbase service to the host machine,
# allowing EXTERNAL access to Vastbase running inside the Docker container.
EXPOSE_VB_PORT=5432
# The host address the exposed port binds to. Defaults to loopback only:
# the database ships default credentials and RAGFlow itself reaches Vastbase
# over the internal docker network. Exposing it to other machines is a
# deliberate choice — set 0.0.0.0 or a specific interface IP here.
# VB_BIND_ADDR=127.0.0.1
# The username for Vastbase
VB_USERNAME=ragflow
# The password for Vastbase.
# Must contain uppercase and lowercase letters, digits, and special
# characters, with a minimum length of 8 (Vastbase password policy).
# WARNING: Change this for production!
VB_PASSWORD=Infini_Rag@123
# The doc database of the Vastbase service to use
VB_VEC_DBNAME=ragflow
# The compatibility mode of Vastbase.
# Available options:
# - `B` (default): MySQL-compatible mode
# - `PG`: PostgreSQL-compatible mode
# Passed to the image's vb_initdb at first initialization and fixed for
# the instance afterwards; changing it on an existing data volume has no
# effect.
VB_DBCOMPATIBILITY=B
# TLS mode for the Vastbase connection (lib/pq sslmode).
# `disable` is the explicit plaintext opt-in for this private container
# network; the bundled container serves no TLS, so keep it set there.
# Pointing RAGFlow at an external Vastbase over an untrusted network
# should use require/verify-ca/verify-full instead — when ssl_mode is
# left unset, non-loopback hosts default to verify-full.
VB_SSL_MODE=disable

# The password for MySQL.
# WARNING: Change this for production!
MYSQL_PASSWORD=infini_rag_flow
# The hostname where the MySQL service is exposed
MYSQL_HOST=mysql
# The database of the MySQL service to use
MYSQL_DBNAME=rag_flow
# The port used to connect to MySQL from RAGFlow container.
# Change this if you use external MySQL.
MYSQL_PORT=3306
# The port used to expose the MySQL service to the host machine,
# allowing EXTERNAL access to the MySQL database running inside the Docker container.
EXPOSE_MYSQL_PORT=3306
# The maximum size of communication packets sent to the MySQL server
MYSQL_MAX_PACKET=1073741824

# External GaussDB metadata database settings, used when DB_TYPE=gaussdb.
# These are intentionally separate from the GAUSSDB_* DocEngine settings.
GAUSSDB_METADATA_HOST=
GAUSSDB_METADATA_PORT=
GAUSSDB_METADATA_USER=
GAUSSDB_METADATA_PASSWORD=
GAUSSDB_METADATA_DBNAME=rag_flow
GAUSSDB_METADATA_SCHEMA=public
GAUSSDB_METADATA_MAX_CONNECTIONS=100
GAUSSDB_METADATA_STALE_TIMEOUT=30

# The hostname where the MinIO service is exposed
MINIO_HOST=minio
# The port used to expose the MinIO console interface to the host machine,
# allowing EXTERNAL access to the web-based console running inside the Docker container.
MINIO_CONSOLE_PORT=9001
# The port used to expose the MinIO API service to the host machine,
# allowing EXTERNAL access to the MinIO object storage service running inside the Docker container.
MINIO_PORT=9000
# The username for MinIO.
# When updated, you must revise the `minio.user` entry in service_conf.yaml accordingly.
MINIO_USER=rag_flow
# The password for MinIO.
# When updated, you must revise the `minio.password` entry in service_conf.yaml accordingly.
MINIO_PASSWORD=infini_rag_flow

# The hostname where the Kvrocks service is exposed. Kvrocks is the only
# cache/queue backend the Go services use (Redis-protocol, RocksDB-backed).
# For a host-run Go binary, point this at the published Kvrocks port on localhost.
KVROCKS_HOST=kvrocks
# The host port that maps to the Kvrocks container port 6379. The Go deployment
# disables the Valkey/Redis service, so Kvrocks reuses the conventional 6379.
KVROCKS_PORT=6379
# The password for Kvrocks (shared with the Valkey service; see kvrocks-entrypoint.sh).
REDIS_PASSWORD=infini_rag_flow

NATS_HOST=nats
# Port used by RAGFlow's Go services to connect to NATS inside the container network.
# Do NOT change this unless you also change `nats.port` in conf/service_conf.yaml.template.
NATS_PORT=4222
# Host-side port that maps to the NATS container port 4222. Change this to avoid
# clashing with a port already used on the host machine. This ONLY affects the
# published host port and is never read by RAGFlow's internal services.
EXPOSE_NATS_PORT=4222
# Host-side port that maps to the NATS monitoring/HTTP port 8222. Change this
# to avoid clashing with a port already used on the host machine.
EXPOSE_NATS_MONITORING_PORT=8222


# The hostname where the ClickHouse service is exposed
CLICKHOUSE_HOST=clickhouse
# Native TCP port used by RAGFlow's Go services to connect to ClickHouse inside
# the container network. Do NOT change this unless you also change `clickhouse.port`
# in conf/service_conf.yaml.template.
CLICKHOUSE_TCP_PORT=9000
# Host-side port that maps to the ClickHouse container native TCP port 9000. Change
# this to avoid clashing with a port already used on the host machine. This ONLY
# affects the published host port and is never read by RAGFlow's internal services.
EXPOSE_CLICKHOUSE_TCP_PORT=9900
# The port used to expose the ClickHouse HTTP service
CLICKHOUSE_HTTP_PORT=8123
# The username for ClickHouse
CLICKHOUSE_USER=ragflow
# The password for ClickHouse
CLICKHOUSE_PASSWORD=infini_rag_flow
# The database for ClickHouse
CLICKHOUSE_DATABASE=ragflow

# Jaeger (distributed tracing)
# Enable by adding `jaeger` to COMPOSE_PROFILES, e.g.:
# COMPOSE_PROFILES=${COMPOSE_PROFILES},jaeger
# Then update otel.host in service_conf.yaml to "jaeger".
JAEGER_VERSION=2.19.0
JAEGER_OTLP_GRPC_PORT=4317
JAEGER_OTLP_HTTP_PORT=4318
JAEGER_UI_PORT=16686

# The port used to expose RAGFlow's HTTP API service to the host machine,
# allowing EXTERNAL access to the service running inside the Docker container.
SVR_WEB_HTTP_PORT=80
SVR_WEB_HTTPS_PORT=443
SVR_HTTP_PORT=9380
# Admin server REST API port, published externally by design (direct API
# access is supported).
ADMIN_SVR_HTTP_PORT=9381
SVR_MCP_PORT=9382

# Password for the default superuser (admin@ragflow.io) that the admin server
# creates on first start when no superuser exists. When unset (and
# DEFAULT_SUPERUSER_PASSWORD is also unset), a random password is generated and
# written once to logs/admin_bootstrap_password.txt (mode 0600, the container's
# /ragflow/logs volume) - read it there and change it immediately after the
# first login.
ADMIN_DEFAULT_PASSWORD=admin

# Development-only: set to 1 to allow private database and connector hosts
# (MySQL, PostgreSQL, IMAP, test_db_connection, ExeSQL), including
# host.docker.internal. The dial stays pinned to the resolved address.
# Agent URL and Invoke checks stay in force. Do not enable in production.
ALLOW_ANY_HOST=0

# The RAGFlow Docker image to download. v0.22+ doesn't include embedding models.
RAGFLOW_IMAGE=infiniflow/ragflow:v1.0.0-rc2

# If you cannot download the RAGFlow Docker image:
# RAGFLOW_IMAGE=swr.cn-north-4.myhuaweicloud.com/infiniflow/ragflow:v1.0.0-rc2
# RAGFLOW_IMAGE=registry.cn-hangzhou.aliyuncs.com/infiniflow/ragflow:v1.0.0-rc2
#
# - For the `nightly` edition, uncomment either of the following:
# RAGFLOW_IMAGE=swr.cn-north-4.myhuaweicloud.com/infiniflow/ragflow:nightly
# RAGFLOW_IMAGE=registry.cn-hangzhou.aliyuncs.com/infiniflow/ragflow:nightly

# The embedding service image, model and port.
# Important: To enable the embedding service, you need to uncomment one of the following two lines:
# COMPOSE_PROFILES=${COMPOSE_PROFILES},tei-cpu
# COMPOSE_PROFILES=${COMPOSE_PROFILES},tei-gpu

# The embedding service image:
TEI_IMAGE_CPU=infiniflow/text-embeddings-inference:cpu-1.8
TEI_IMAGE_GPU=infiniflow/text-embeddings-inference:1.8

# The embedding service model:
# Available options:
# - `Qwen/Qwen3-Embedding-0.6B` (default, requires 25GB RAM/vRAM to load)
# - `BAAI/bge-m3` (requires 21GB RAM/vRAM to load)
# - `BAAI/bge-small-en-v1.5` (requires 1.2GB RAM/vRAM to load)
TEI_MODEL=${TEI_MODEL:-Qwen/Qwen3-Embedding-0.6B}

# The embedding service hostname inside the Docker network:
TEI_HOST=tei
# The port used to expose the TEI service to the host machine,
# allowing EXTERNAL access to the service running inside the Docker container.
TEI_PORT=6380

# The local time zone.
TZ=Asia/Shanghai

# Uncomment the following line if you have limited access to huggingface.co:
# HF_ENDPOINT=https://hf-mirror.com

# Optimizations for MacOS
# Uncomment the following line if your operating system is MacOS:
# MACOS=1

# The maximum file size limit (in bytes) for each upload to your dataset or RAGFlow's File system.
# To change the 1GB file size limit, uncomment the line below and update as needed.
# MAX_CONTENT_LENGTH=1073741824
# After updating, ensure `client_max_body_size` in nginx/nginx.conf is updated accordingly.
# Note that neither `MAX_CONTENT_LENGTH` nor `client_max_body_size` sets the maximum size for files uploaded to an agent.
# See https://ragflow.io/docs/dev/begin_component for details.

# Controls how many documents are processed in a single batch.
# Defaults to 4 if DOC_BULK_SIZE is not explicitly set.
DOC_BULK_SIZE=${DOC_BULK_SIZE:-4}

# Defines the number of items to process per batch when generating embeddings.
# Defaults to 16 if EMBEDDING_BATCH_SIZE is not set in the environment.
EMBEDDING_BATCH_SIZE=${EMBEDDING_BATCH_SIZE:-16}

# Connector ingest: documents (e.g. one MySQL row = one file) written per batch.
# Defaults to 2. Raise this for large RDBMS syncs so fewer write round-trips hit MySQL.
# INDEX_BATCH_SIZE=32
# Pause between connector write batches so the file/storage API can use MySQL.
# 0 still yields the sync worker event loop. A small value (e.g. 0.05) reduces lock wait.
# SYNC_BATCH_PAUSE_SECONDS=0.05

# Controls how rerank inputs that exceed the configured model token limit are handled.
# Available options:
# - `truncate` (default): truncate each document so its tokens plus the query tokens fit the limit.
# - `passthrough`: send the query and documents unchanged and let the rerank provider handle oversized inputs.
# - `raise_error`: reject the request before calling the provider if a query document pair exceeds the limit.
RERANK_TOKEN_LIMIT_MODE=${RERANK_TOKEN_LIMIT_MODE:-truncate}

# Log level for the RAGFlow's own and imported packages.
# Available levels:
# - `DEBUG`
# - `INFO` (default)
# - `WARNING`
# - `ERROR`
# For example, the following line changes the log level of `ragflow.es_conn` to `DEBUG`:
# LOG_LEVELS=ragflow.es_conn=DEBUG

# Enable debug logging for the LLM provider, it will log the request and response of the LLM provider.
# This may contain sensitive information and generate massive logs. Use with caution.
# LLM_DEBUG=true

# aliyun OSS configuration
# STORAGE_IMPL=OSS
# ACCESS_KEY=xxx
# SECRET_KEY=eee
# ENDPOINT=http://oss-cn-hangzhou.aliyuncs.com
# REGION=cn-hangzhou
# BUCKET=ragflow65536
#

# A user registration switch:
# - Enable registration: 1
# - Disable registration: 0
REGISTER_ENABLED=1
ENABLE_REGISTER=1

# -----------------------------------------------------------------------------
# Sandbox
# -----------------------------------------------------------------------------
# Sandbox provider type and runtime settings are configured in Admin > Sandbox
# Settings.

# Start the optional published-image executor manager.
# COMPOSE_PROFILES=${COMPOSE_PROFILES},sandbox

# Shared sandbox settings
# The MinIO bucket name for storing sandbox-generated artifacts.
# SANDBOX_ARTIFACT_BUCKET=sandbox-artifacts

# Self-managed deployment defaults
# These values configure the optional `sandbox` Compose service, not the
# RAGFlow client. Build and security guidance: https://github.com/infiniflow/sandbox
# Pull the required base images before running:
#   docker pull infiniflow/sandbox-base-nodejs:latest
#   docker pull infiniflow/sandbox-base-python:latest
# Default runtime images include:
# - Node.js base image: axios
# - Python base image: requests, numpy, pandas
# SANDBOX_EXECUTOR_MANAGER_IMAGE=${SANDBOX_EXECUTOR_MANAGER_IMAGE:-infiniflow/sandbox-executor-manager:latest}
# SANDBOX_EXECUTOR_MANAGER_POOL_SIZE=${SANDBOX_EXECUTOR_MANAGER_POOL_SIZE:-3}
# SANDBOX_BASE_PYTHON_IMAGE=${SANDBOX_BASE_PYTHON_IMAGE:-infiniflow/sandbox-base-python:latest}
# SANDBOX_BASE_NODEJS_IMAGE=${SANDBOX_BASE_NODEJS_IMAGE:-infiniflow/sandbox-base-nodejs:latest}
# SANDBOX_EXECUTOR_MANAGER_PORT=${SANDBOX_EXECUTOR_MANAGER_PORT:-9385}
# SANDBOX_ENABLE_SECCOMP=false
# SANDBOX_MAX_MEMORY=256m # b, k, m, g
# SANDBOX_TIMEOUT=10s # s, m, 1m30s

# Shared secret required by sandbox-executor-manager's /run endpoint
# (Authorization: Bearer or X-Sandbox-Token). The same value is injected into
# RAGFlow. Current Sandbox source rejects /run without configured authentication;
# verify the behavior of the published image version you deploy.
# Generate token with: openssl rand -hex 32
# SANDBOX_EXECUTOR_MANAGER_ALLOW_UNAUTHENTICATED=false
# SANDBOX_EXECUTOR_MANAGER_API_TOKEN=

# Docker network used for sandbox runner containers. "none" (default) means
# sandboxed code has no external network access. Set to "bridge" only if your
# sandboxed code genuinely needs outbound network (e.g. runtime pip/npm
# installs); prefer baking dependencies into the base images instead.
# SANDBOX_CONTAINER_NETWORK=none

# SSH deployment defaults
# RAGFLOW_SSH_KNOWN_HOSTS=${HOME}/.ssh/known_hosts
# SSH_KNOWN_HOSTS=/etc/ragflow/ssh_known_hosts
# -----------------------------------------------------------------------------
# Sandbox End
# -----------------------------------------------------------------------------

# Enable DocLing
USE_DOCLING=false

# Enable Mineru
# Uncommenting these lines will automatically add MinerU to the model provider whenever possible.
# More details see https://ragflow.io/docs/faq#how-to-use-mineru-to-parse-pdf-documents.
# MINERU_DELETE_OUTPUT=0   # keep output directory
# MINERU_BACKEND=pipeline  # or another backend you prefer

# pptx support
DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=1

# crypto utils
# RAGFLOW_CRYPTO_ENABLED=true
# RAGFLOW_CRYPTO_ALGORITHM=aes-256-cbc # one of aes-256-cbc, aes-128-cbc, sm4-cbc
# RAGFLOW_CRYPTO_KEY=ragflow-crypto-key


# Used for ThreadPoolExecutor
THREAD_POOL_MAX_WORKERS=128

#Option to disable login form for SSO
DISABLE_PASSWORD_LOGIN=false

# -----------------------------------------------------------------------------
# Knowledge compilation
# -----------------------------------------------------------------------------
# Wiki LLM pool and phase timeouts. Values are read when the Python service
# starts; restart the service after changing them.
WIKI_MAP_LLM_POOL_SIZE=20
WIKI_MAP_MAX_PENDING=25
WIKI_REFINE_WORKERS=4
WIKI_MAP_WORKERS=20
WIKI_MAP_TIMEOUT=600
WIKI_REDUCE_TIMEOUT=60
WIKI_PLAN_TIMEOUT=600
WIKI_REFINE_TIMEOUT=300
WIKI_MERGE_TIMEOUT=600

# Structure Compile batching, pool, and timeout settings.
DOC_STRUCTURE_COMPILE_BATCH_CHUNKS=4
DOC_STRUCTURE_COMPILE_MAX_IN_FLIGHT=15
DOC_STRUCTURE_LLM_POOL_SIZE=20
STRUCTURE_CONTEXT_FRACTION=0.5
STRUCTURE_DEFAULT_CONTEXT=100000
KNOWLEDGE_GRAPH_CONTEXT_FRACTION=0.1
KNOWLEDGE_GRAPH_MIN_BATCH_TOKENS=2048
KNOWLEDGE_GRAPH_MAX_BATCH_TOKENS=4096
STRUCTURE_CHAIN_CORRECTION_TIMEOUT_S=120

# Shared LLM pool rate-limit retry settings.
LLM_POOL_RATE_LIMIT_RETRIES=3
LLM_POOL_RATE_LIMIT_RETRY_BASE_DELAY=1.0
LLM_POOL_RATE_LIMIT_RETRY_MAX_DELAY=30.0

# Recycle the task_executor worker process after this many completed tasks, to
# release the ONNX Runtime / CUDA arena fragmentation that builds up over the
# lifetime of the process. The supervisor loop in entrypoint.sh restarts the
# worker automatically after a clean exit. Set a small value (e.g. 20) on
# low-VRAM GPUs where long-running workers eventually run out of memory.
# The threshold is soft: tasks already in flight are allowed to finish, so up to
# MAX_CONCURRENT_TASKS - 1 extra tasks may complete before the worker exits.
# 0 disables recycling.
# MAX_TASKS_PER_WORKER=0
# How long (seconds) a recycling worker waits for in-flight tasks to finish
# before cancelling them. Only has an effect when MAX_TASKS_PER_WORKER > 0.
# RECYCLE_SHUTDOWN_TIMEOUT=300

#Option to disable login form for SSO
DISABLE_PASSWORD_LOGIN=false

# Option to allow OAuth/OIDC just-in-time user provisioning. Independent of
# REGISTER_ENABLED: set to false to require that an OAuth/OIDC user already exists.
OAUTH_AUTO_REGISTER=true

# -----------------------------------------------------------------------------
# DeepDoc (in-process)
# -----------------------------------------------------------------------------
# DeepDoc layout analysis (DLA), OCR, and TSR run in-process inside the RAGFlow
# server using ONNX Runtime — there is no separate DeepDoc service. Set ORT /
# model overrides if needed:
# DEEPDOC_MODEL_DIR=/path/to/InfiniFlow/deepdoc

# -----------------------------------------------------------------------------
# Native Go MCP listener settings
# -----------------------------------------------------------------------------
# RAGFLOW_MCP_ENABLED=true
# RAGFLOW_MCP_HOST=0.0.0.0
# RAGFLOW_MCP_PORT=9382
# RAGFLOW_MCP_LAUNCH_MODE=self-host
# RAGFLOW_MCP_HOST_API_KEY=