Skip to content

~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.

184 KB
Raw Blame

Configuration Reference

This document is automatically generated from the application's default settings. Most settings can be configured via the Web UI (Settings page), or overridden via Environment Variables.

Environment Variables

To override a setting using an environment variable, convert the key to uppercase, replace dots with underscores, and prefix with LDR_. For example, app.debug becomes LDR_APP_DEBUG.

Configuration Priority: Environment Variables > Web UI Config (Database) > Default Values

Environmental Variables are used to override default values, easing installation, while allowing for adjustments to configuration via Web UI. When an environment variable is set, it takes precedence over any value stored in the database, and the Web UI marks that setting as non-editable. Single-setting API updates and deletes are rejected while the setting is environment-locked; low-level programmatic imports that do not request environment-lock preservation may still be stored but remain shadowed by the environment value on read.

research_library.storage_path is operator-only. Set LDR_RESEARCH_LIBRARY_STORAGE_PATH to change it; existing saved paths stay in use if no override is set, including locations outside LDR_DATA_DIR. Audit saved paths when upgrading a multi-user installation. User settings save, delete, import, and reset cannot change this path.

Pre-Database (Env-Only) Settings

These settings are required before database initialization and can only be set via environment variables. They are not available in the Web UI because they are needed to start the application.

Environment Variable Type Default Required Constraints Description Category Deprecated Alias
LDR_BOOTSTRAP_ALLOW_UNENCRYPTED Boolean False No Allow plaintext SQLite for isolated local development when SQLCipher is unavailable or nonfunctional. Working SQLCipher still takes priority; the fallback does not verify account passwords. Bootstrap LDR_ALLOW_UNENCRYPTED
LDR_DB_CONFIG_BUSY_TIMEOUT_MS Integer 30000 No 100..300000 SQLite busy_timeout in milliseconds -- how long a writer waits for the database lock before giving up with 'database is locked'. Set above the p99 latency of in-flight transactions (the background document scheduler can hold a session across multi-second PDF downloads; 30s gives the rate-limit tracker and other short writers enough headroom to land their commit instead of swallowing the error). Db Config LDR_DB_BUSY_TIMEOUT_MS
LDR_DB_CONFIG_CACHE_SIZE_MB Integer 64 No 1..10000 SQLite cache size in MB Db Config LDR_DB_CACHE_SIZE_MB
LDR_DB_CONFIG_CIPHER_MEMORY_SECURITY Enum 'OFF' No OFF, ON SQLCipher memory security (ON=clear memory after use + mlock, OFF=faster). ON requires IPC_LOCK in Docker. Db Config
LDR_DB_CONFIG_HMAC_ALGORITHM Enum 'HMAC_SHA512' No HMAC_SHA1, HMAC_SHA256, HMAC_SHA512 HMAC algorithm for database integrity Db Config LDR_DB_HMAC_ALGORITHM
LDR_DB_CONFIG_JOURNAL_MODE Enum 'WAL' No DELETE, MEMORY, OFF, PERSIST, TRUNCATE, WAL SQLite journal mode Db Config LDR_DB_JOURNAL_MODE
LDR_DB_CONFIG_KDF_ALGORITHM Enum 'PBKDF2_HMAC_SHA512' No PBKDF2_HMAC_SHA1, PBKDF2_HMAC_SHA256, PBKDF2_HMAC_SHA512 Key derivation function algorithm Db Config LDR_DB_KDF_ALGORITHM
LDR_DB_CONFIG_KDF_ITERATIONS Integer 256000 No 1000..1000000 Number of KDF iterations for key derivation Db Config LDR_DB_KDF_ITERATIONS
LDR_DB_CONFIG_PAGE_SIZE Integer 16384 No 512..65536 SQLite page size (must be power of 2) Db Config LDR_DB_PAGE_SIZE
LDR_DB_CONFIG_SYNCHRONOUS Enum 'NORMAL' No EXTRA, FULL, NORMAL, OFF SQLite synchronous mode Db Config LDR_DB_SYNCHRONOUS
LDR_DB_CONFIG_WAL_AUTOCHECKPOINT Integer 250 No 10..10000 WAL frames threshold for automatic PASSIVE checkpoint at commit. Lower = smaller WAL high-water-mark, faster recovery on open, slightly more frequent fsyncs. Db Config
LDR_NEWS_SCHEDULER_ALLOW_API_CONTROL Boolean False No Allow authenticated users to start/stop the global news scheduler via API. Disable in multi-user deployments to prevent users from affecting each other. News Scheduler
LDR_NEWS_SCHEDULER_ENABLED Boolean True No Enable or disable the news subscription scheduler News Scheduler
LDR_NOTIFICATIONS_ALLOW_OUTBOUND Boolean False No Master switch for outbound notification webhooks (Apprise). Disabled by default so outbound delivery requires an explicit operator decision. The send path uses a synchronous DNS guard against rebinding and private/metadata access; see SECURITY.md 'Notification Webhook SSRF' for details. Distinct from the per-user notifications.enabled toggle in the settings UI: this is the server-level operator gate, env-only so it cannot be flipped via the user-writable settings API. Security
LDR_NOTIFICATIONS_ALLOW_PRIVATE_IPS Boolean False No Allow notification webhooks to target private/local IP addresses. Environment-only to prevent SSRF bypass via the user-writable settings API. Only enable this if your notification endpoints are on a trusted local network. Security
LDR_POLICY_ALLOW_UNPROTECTED_EGRESS Boolean False No Allow users to select the UNPROTECTED egress scope. Disabled by default; this is an environment-only operator gate and cannot be changed through the user-writable settings API. Hard SSRF and cloud-metadata protections remain active when enabled. Security
LDR_RESEARCH_LIBRARY_ALLOW_FILESYSTEM_PDF_STORAGE Boolean False No Allow users to select the UNENCRYPTED 'filesystem' PDF storage mode for library-downloaded PDFs. Disabled by default; this is an environment-only operator gate and cannot be changed through the user-writable settings API. Filesystem mode writes fetched third-party PDFs as PLAINTEXT to a shared library directory (cleartext storage of sensitive information, CWE-312). When off, the 'filesystem' option is withheld from the settings UI and any stored or environment value of 'filesystem' is coerced to the encrypted 'database' mode at write time. Previously-written plaintext files remain readable. Enable only when the library directory lives on an operator-controlled encrypted volume. Security
LDR_RESEARCH_LIBRARY_ALLOW_SHARED_LIBRARY Boolean False No Allow shared-library mode, which drops the per-user library directory boundary so all users' downloaded PDFs live in one shared directory. Disabled by default; this is an environment-only operator gate and cannot be enabled through the user-writable settings API. The shared_library flag is otherwise user-editable; leaving shared mode user-toggleable would let an account drop its per-user directory boundary. The storage_path is now operator-only, but legacy saved paths remain in place. When off, the per-user subdirectory is always enforced regardless of the user's shared_library setting. Enable only on single-tenant or mutually-trusted deployments. Security
LDR_SEARCH_ALLOW_PRIVATE_ENGINE_URLS Boolean False No Allow user-editable PUBLIC search-engine URLs (e.g. the SearXNG instance_url) to point at private / loopback / link-local addresses. Environment-only operator gate so it cannot be flipped through the user-writable settings API. Disabled by default: a public-nature engine (its data source is the public internet) pointed at an internal host lets any authenticated user turn a research run into an internal port scan / service probe, breaking the PUBLIC_ONLY egress promise. Enable only when you self-host SearXNG on localhost/LAN and accept that engine fetches may reach your private network. To approve only specific origins instead of all private addresses, use the finer-grained LDR_SEARCH_PRIVATE_ENGINE_URL_ALLOWLIST. Docker deployments instead pin the URL directly via LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_INSTANCE_URL, which is trusted as operator-provisioned. Cloud-metadata endpoints (ALWAYS_BLOCKED_METADATA_IPS and ALWAYS_BLOCKED_METADATA_HOSTNAMES) stay blocked regardless of this flag. Security
LDR_SEARCH_ALLOW_PRIVATE_RESULT_FETCH Boolean False No Allow full-content fetching (search.snippets_only off) to follow the RESULT URLs a PUBLIC search engine returns into private / loopback addresses, e.g. an internal wiki that a self-hosted SearXNG instance indexes. Distinct from, and required in addition to, the instance-URL approval (LDR_SEARCH_ALLOW_PRIVATE_ENGINE_URLS, LDR_SEARCH_PRIVATE_ENGINE_URL_ALLOWLIST or an env-locked instance URL): that approval only covers reaching the engine itself, and because a public engine proxies the public web, extending it to the URLs the engine returns would let a poisoned index turn result fetching into a scan of the LDR host's private network. Environment-only operator gate so it cannot be flipped through the user-writable settings API. Disabled by default and not set by the bundled docker-compose.yml. Link-local addresses (169.254.0.0/16, fe80::/10) and the cloud-metadata endpoints in ALWAYS_BLOCKED_METADATA_IPS and ALWAYS_BLOCKED_METADATA_HOSTNAMES stay blocked regardless of this flag. Takes effect only under the unprotected egress scope: under every other scope, the default adaptive scope included, private result URLs stay blocked even with this flag set. Security
LDR_SEARCH_PRIVATE_ENGINE_URL_ALLOWLIST String None No Comma-separated list of exact URL origins (scheme://host[:port]) that user-editable PUBLIC search-engine URLs (e.g. the SearXNG instance_url) may use even though they are private / loopback / link-local — e.g. 'http://localhost:8080,http://192.168.1.5:8888'. Finer-grained alternative to LDR_SEARCH_ALLOW_PRIVATE_ENGINE_URLS=true: private egress is enabled for an engine only when its configured URL matches a listed origin (the engine's request chain, including redirects, then runs with private access — like the blanket flag, but conditional on the match), rather than for any private URL. Matching is exact scheme + host + port (default ports 80/443 implied, host case-insensitive, path/query ignored); no wildcards or CIDR ranges. Entries that fail to parse are ignored. Environment-only operator setting so it cannot be edited through the user-writable settings API. Cloud-metadata endpoints (ALWAYS_BLOCKED_METADATA_IPS and ALWAYS_BLOCKED_METADATA_HOSTNAMES) and non-http(s) schemes stay blocked even if listed. Security
LDR_SECURITY_ALLOW_NAT64 Boolean False No Allow outbound traffic to NAT64 prefixes (64:ff9b::/96 RFC 6052 well-known and 64:ff9b:1::/48 RFC 8215 local-use). Disabled by default to close the IPv6-wrapped SSRF bypass class — on hosts configured with NAT64 routes, attacker-supplied URLs can wrap cloud-metadata or RFC1918 destinations through these prefixes. Enable only on IPv6-only deployments (DNS64+NAT64) where outbound IPv4 traffic is synthesized through this prefix and the operator has accepted the residual SSRF risk. 6to4 (2002::/16), Teredo (2001::/32), the discard prefix (100::/64), the deprecated IPv4-Compatible IPv6 form (::/96, except ::1 loopback which follows the loopback/private flags), and the IPv4-Translated/SIIT form (::ffff:0:0:0/96) remain unconditionally blocked because they have no live legitimate use in 2026. The cloud-metadata block (ALWAYS_BLOCKED_METADATA_IPS) still applies via embedded-IPv4 extraction — see SECURITY.md. Security
LDR_SECURITY_CORS_ALLOWED_ORIGINS String None No Allowed CORS origins for API routes (comma-separated). Use '*' for all origins, empty for same-origin only. Example: 'https://example.com,https://app.example.com' Security
LDR_SECURITY_WEBSOCKET_ALLOWED_ORIGINS String None No Allowed origins for WebSocket/Socket.IO connections (comma-separated). Unset or empty means same-origin only (default); use '*' to allow all origins. Example: 'https://example.com,https://app.example.com' Security
LDR_SERVER_MAX_CONCURRENT_RESEARCH Integer 10 No 1..1000 Server-wide maximum concurrent research operations. Requires restart. Server LDR_MAX_GLOBAL_CONCURRENT
LDR_SERVER_TRUSTED_PROXY_COUNT Integer 0 No 0..16 Number of X-Forwarded-For entries your trusted reverse proxies append -- one per appending hop for an ordinary proxy, so CDN -> nginx is 2. Used by the rate limiter only while TRUST_PROXY_HEADERS is NOT set: it then reads the N-th entry from the right, provided the direct peer is private/loopback or, once a restricted LDR_SERVER_FORWARDED_ALLOW_IPS is set, listed there (otherwise it keys on the direct peer). N must be exact: too small keys every client on a proxy's address, too large reads an entry the client wrote itself (or, when the header is shorter than N, keys on the direct peer). Zero (default) disables hop counting and keeps the single-proxy behaviour (the right-most entry). With TRUST_PROXY_HEADERS=true this value has no effect -- list every hop in LDR_SERVER_FORWARDED_ALLOW_IPS instead -- and setting it while that allow-list still trusts every peer (the default "*") makes LDR refuse to start. For N >= 2, every intermediate hop must be unreachable directly by clients, or a client connecting to an inner hop chooses the entry read. Does not affect X-Forwarded-Proto/scheme detection. See 'Proxy chains' in docs/deployment/reverse-proxy.md. Accepted values are ASCII decimal integers from 0 to 16 (surrounding whitespace is ignored and -0 reads as 0); an empty or whitespace-only value counts as unset, and any other invalid value prevents startup. Server
LDR_TESTING_TEST_MODE Boolean False No Enable test mode (adds delays for testing concurrency) Testing
LDR_VITE_DEV_MODE Boolean False No When true, templates link to the Vite dev server at http://localhost:5173 for HMR instead of the built manifest under static/dist. Set to true when running npm run dev alongside the Python server. Server
LDR_WEB_QUEUE_PROCESSOR_ENABLED Boolean True No Enable or disable the background research queue processor Queue Processor
LDR_WEB_THREADPOOL_MAX_THREADS Integer None No 1..1000 Maximum AnyIO worker threads serving synchronous route handlers. Leave unset to use AnyIO's default of 40. Every plain def route occupies one worker for its whole duration, and the pool is shared with async dependency solving and response validation, so exhausting it slows async routes too. Raise it if concurrent requests queue behind each other under load; each extra thread costs context switching and contends for the same per-user database pool. Requires restart. Server

Settings List

Key Environment Variable Default Value Description Type
app.allow_registrations LDR_APP_ALLOW_REGISTRATIONS true Allow new user registrations through the web interface. Configured via LDR_APP_ALLOW_REGISTRATIONS environment variable. Set to 'false' to disable on public-facing deployments. Enabled by default so initial account creation works out of the box. Requires server restart. APP
app.debug LDR_APP_DEBUG false Raises log verbosity to DEBUG level. Configured via LDR_APP_DEBUG environment variable. Requires server restart. Does NOT enable Loguru's diagnose mode (local-variable dumps in exception tracebacks); set LDR_LOGURU_DIAGNOSE=true in addition if you need that — see docs/env_configuration.md. APP
app.enable_file_logging LDR_APP_ENABLE_FILE_LOGGING false Enable logging to files (WARNING: Log files are unencrypted and may contain sensitive data) APP
app.enable_notifications LDR_APP_ENABLE_NOTIFICATIONS true Enable browser push notifications to alert you when research completes or encounters errors. Requires browser permission to display notifications. APP
app.enable_web LDR_APP_ENABLE_WEB true Enable the web interface. When disabled, the application runs in CLI-only mode. Requires server restart to take effect. APP
app.external_url LDR_APP_EXTERNAL_URL `` Public base URL used for notification links (e.g., http://localhost:5000, https://myapp.example.com). Set this explicitly for reverse proxies and external deployments. When blank, notification links fall back to app.host and app.port. APP
app.host LDR_APP_HOST 0.0.0.0 Hostname or IP address used only as a fallback when generating notification links while app.external_url is unset. This setting does not control the web listener. To change the bind address, set LDR_WEB_HOST; web.host is the corresponding internal key, not a user-editable listener control. APP
app.lock_settings LDR_APP_LOCK_SETTINGS false When enabled, prevents any modifications to settings through the UI. Useful for locking configuration in production environments. Must be changed directly in the database to re-enable editing. APP
app.max_concurrent_researches LDR_MAX_CONCURRENT 3 Maximum number of concurrent research processes allowed per user APP
app.max_global_concurrent_researches LDR_SERVER_MAX_CONCURRENT_RESEARCH 10 Maximum number of concurrent research processes allowed across all users (server-wide). Set via env var LDR_SERVER_MAX_CONCURRENT_RESEARCH. Requires server restart. APP
app.max_user_query_length LDR_APP_MAX_USER_QUERY_LENGTH 300 Maximum character length for user queries before disabling direct search. Longer queries will use LLM-generated questions only. SEARCH
app.port LDR_APP_PORT 5000 TCP port used only as a fallback when generating notification links while app.external_url is unset. This setting does not control the web listener. To change the listening port, set LDR_WEB_PORT; web.port is the corresponding internal key, not a user-editable listener control. APP
app.queue_mode LDR_QUEUE_MODE direct How new research requests are handled. 'Direct' starts research immediately if a concurrent slot is available. 'Queue' always adds to a background queue for sequential processing in order. APP
app.theme LDR_APP_THEME hashed User interface color theme. Hashed is the existing dark theme, used by default because light themes still need refinement for everyday use. Choose from 33 themes including popular developer themes. APP
app.timezone TZ UTC Timezone for date calculations (e.g., news subscription YYYY-MM-DD placeholder). Use 'UTC' for server time or specify your local timezone. APP
app.warnings.dismiss_adaptive_scope_info LDR_APP_WARNINGS_DISMISS_ADAPTIVE_SCOPE_INFO false Permanently hide the informational banner that states what the Adaptive egress scope resolves to (public / private / both) for the current primary engine. APP
app.warnings.dismiss_cloud_embeddings LDR_APP_WARNINGS_DISMISS_CLOUD_EMBEDDINGS false Permanently hide the 'document chunks will be sent to OpenAI' (cloud embeddings) banner. Separate from the public-egress dismiss flag so acknowledging fresh-install noise never suppresses this critical warning. APP
app.warnings.dismiss_cloud_llm LDR_APP_WARNINGS_DISMISS_CLOUD_LLM false Permanently hide the 'LLM provider is cloud-hosted' banner. Separate from the public-egress dismiss flag so acknowledging fresh-install noise never suppresses this critical warning. APP
app.warnings.dismiss_context_below_history LDR_APP_WARNINGS_DISMISS_CONTEXT_BELOW_HISTORY false Dismiss warnings when the configured context is below historical usage APP
app.warnings.dismiss_context_truncation_history LDR_APP_WARNINGS_DISMISS_CONTEXT_TRUNCATION_HISTORY false Dismiss warnings about historical context truncation APP
app.warnings.dismiss_egress_policy LDR_APP_WARNINGS_DISMISS_EGRESS_POLICY false Permanently hide the 'public search egress enabled' banner (the fresh-install informational one). The critical cloud-LLM and cloud-embeddings banners have their OWN dismiss flags so this can't silently hide them. APP
app.warnings.dismiss_elasticsearch_public_url LDR_APP_WARNINGS_DISMISS_ELASTICSEARCH_PUBLIC_URL false Permanently hide the 'Elasticsearch points at a non-private host' banner that appears when the Elasticsearch engine is active but its hosts (or cloud_id) do not look like private/local addresses (document queries would leave the machine; a private-only egress scope excludes the engine). Dismiss when a hosted endpoint such as Elastic Cloud is intentional. APP
app.warnings.dismiss_embedding_performance LDR_APP_WARNINGS_DISMISS_EMBEDDING_PERFORMANCE false Hide embedding performance tips on collection and embedding settings pages. Turn off to show the tips again. APP
app.warnings.dismiss_high_context LDR_APP_WARNINGS_DISMISS_HIGH_CONTEXT false Permanently hide the warning shown when your local LLM context window is set above 8,192 tokens, which may cause memory issues on some hardware. APP
app.warnings.dismiss_legacy_config LDR_APP_WARNINGS_DISMISS_LEGACY_CONFIG false Dismiss warnings about the deprecated server_config.json file APP
app.warnings.dismiss_model_mismatch LDR_APP_WARNINGS_DISMISS_MODEL_MISMATCH false Permanently hide the warning shown when using a large model (70B+ parameters) with a local provider and high context window, which may exceed available GPU memory. APP
app.warnings.dismiss_paperless_public_url LDR_APP_WARNINGS_DISMISS_PAPERLESS_PUBLIC_URL false Permanently hide the 'Paperless-ngx points at a non-private host' banner that appears when the Paperless engine is active but its API URL does not look like a private/local address (document queries would leave the machine; a private-only egress scope excludes the engine). APP
app.warnings.dismiss_searxng_private_url LDR_APP_WARNINGS_DISMISS_SEARXNG_PRIVATE_URL false Permanently hide the 'SearXNG is disabled: private URL not approved' banner that appears when SearXNG is active (selected as the search engine, or enabled for auto/agent search) but its private/localhost instance URL has no operator approval (allowlist, blanket opt-in, or env-lock) in the server environment. APP
app.warnings.dismiss_searxng_recommendation LDR_APP_WARNINGS_DISMISS_SEARXNG_RECOMMENDATION false Dismiss recommendations about using more questions instead of iterations with SearXNG APP
app.web_interface LDR_APP_WEB_INTERFACE true Enable the web interface for the application. When disabled, only CLI and API access is available. Requires server restart to take effect. APP
backup.enabled LDR_BACKUP_ENABLED true Automatically backup database after successful login. Each backup uses disk space proportional to your database size. Disable this if disk space is limited. APP
backup.max_age_days LDR_BACKUP_MAX_AGE_DAYS 7 Delete backups older than this many days APP
backup.max_count LDR_BACKUP_MAX_COUNT 1 Maximum number of backup files to keep per user APP
benchmark.evaluation.api_key LDR_BENCHMARK_EVALUATION_API_KEY `` API key for the OpenAI-compatible evaluation endpoint. Leave blank to reuse the research endpoint key when its endpoint settings permit it. Local and private evaluation endpoints can run without a key; use a placeholder for other keyless endpoints. APP
benchmark.evaluation.endpoint_url LDR_BENCHMARK_EVALUATION_ENDPOINT_URL https://openrouter.ai/api/v1 Endpoint URL for evaluation model (when using OpenAI-compatible APIs) APP
benchmark.evaluation.model LDR_BENCHMARK_EVALUATION_MODEL anthropic/claude-3.7-sonnet LLM model used as a judge to score benchmark answers against reference answers (e.g., 'anthropic/claude-3.7-sonnet' for OpenRouter, 'gpt-4o' for OpenAI). Must be compatible with the selected evaluation provider. APP
benchmark.evaluation.provider LDR_BENCHMARK_EVALUATION_PROVIDER openai_endpoint LLM provider used to grade benchmark answers by comparing research outputs against reference answers. This is separate from the research LLM being tested. Options: openai_endpoint (recommended, supports OpenRouter), openai, anthropic, ollama. APP
benchmark.evaluation.temperature LDR_BENCHMARK_EVALUATION_TEMPERATURE 0 Sampling temperature for the benchmark judge model (0.0-1.0). Use 0 for deterministic, reproducible grading results. Higher values introduce randomness in evaluation scores. APP
chat.followup_context_mode LDR_CHAT_FOLLOWUP_CONTEXT_MODE summary What prior conversation context a follow-up research turn receives as its 'previous findings'. 'Focused summary' uses the LLM to summarize the whole conversation toward the new question (one extra LLM call per follow-up); 'Raw recent findings' reuses recent answers truncated; 'Full transcript' sends the entire conversation; 'None' sends no prior findings. CHAT
chat.llm_title_generation LDR_CHAT_LLM_TITLE_GENERATION false Use LLM to generate descriptive chat session titles instead of simple query truncation. When disabled, titles are the first 100 characters of the query. CHAT
chat.max_findings_to_include LDR_CHAT_MAX_FINDINGS_TO_INCLUDE 5 Maximum number of recent research findings to include in chat context. Higher values provide more background but increase token usage. CHAT
chat.title_llm_timeout_seconds LDR_CHAT_TITLE_LLM_TIMEOUT_SECONDS 30 Hard wall-clock timeout (seconds) for the LLM call that generates a chat session title. Past this, the request thread falls back to truncation so a slow LLM endpoint cannot block title generation indefinitely. CHAT
document_scheduler.download_pdfs LDR_DOCUMENT_SCHEDULER_DOWNLOAD_PDFS false Automatically download PDF files during scheduled document processing. Files will be stored on disk (requires storage space). WARNING: Downloaded files are stored unencrypted on disk. APP
document_scheduler.enabled LDR_DOCUMENT_SCHEDULER_ENABLED true Enable automatic document processing from research history APP
document_scheduler.extract_text LDR_DOCUMENT_SCHEDULER_EXTRACT_TEXT true Extract text content to database (minimal space usage) APP
document_scheduler.generate_rag LDR_DOCUMENT_SCHEDULER_GENERATE_RAG false Index documents in the background for semantic search. LEGACY/DEPRECATED: this is now equivalent to "Auto-index documents in the background" below — both enable the unified reconciler that indexes every unindexed document (library uploads AND research downloads). Kept for backward compatibility so existing users keep their research downloads indexed; prefer the auto-index setting for new configurations. APP
document_scheduler.interval_seconds LDR_DOCUMENT_SCHEDULER_INTERVAL_SECONDS 1800 How often to process new research (seconds) APP
document_scheduler.sweep_library_collections LDR_DOCUMENT_SCHEDULER_SWEEP_LIBRARY_COLLECTIONS false Periodically index ALL unindexed documents in the background — both library uploads that weren't indexed immediately (e.g. because the immediate auto-index queue was full) AND research downloads that haven't been ingested into your library yet. Idempotent and processed in small batches per run; already-indexed documents are skipped. Off by default. Requires "Enable Document Scheduler" above to be on — the background sweep only runs while the document scheduler is enabled. APP
embeddings.ollama.num_ctx LDR_EMBEDDINGS_OLLAMA_NUM_CTX 8192 Context window size (in tokens) used when generating Ollama embeddings. Must be at least as large as the longest chunk after tokenization; otherwise Ollama returns 'input length exceeds the context length' (HTTP 500) and indexing fails. The default of 8192 covers chunk sizes up to ~5000 characters for most models. Increase for very large chunks; decrease to save VRAM. qwen3-embedding supports up to 32768; nomic-embed-text supports 8192. APP
embeddings.ollama.url LDR_EMBEDDINGS_OLLAMA_URL http://localhost:11434 URL of the Ollama endpoint for embedding models. This setting allows you to use a different Ollama server for embeddings than for LLM operations. If not set, the system will fall back to the LLM Ollama URL. APP
embeddings.openai.api_key LDR_EMBEDDINGS_OPENAI_API_KEY `` API key for the OpenAI embeddings endpoint. Required for the OpenAI cloud API. For OpenAI-compatible local servers (LM Studio, vLLM, llama.cpp), you can leave this blank — LDR will substitute a placeholder so the OpenAI client request succeeds against the keyless server. APP
embeddings.openai.base_url LDR_EMBEDDINGS_OPENAI_BASE_URL `` Custom base URL for the embeddings endpoint. Leave blank to use the OpenAI cloud API (https://api.openai.com/v1). Set to your OpenAI-compatible local server URL to route embeddings there — examples: http://localhost:1234/v1 (LM Studio), http://localhost:8000/v1 (vLLM or llama.cpp server). When set, this overrides the cloud endpoint for embeddings without affecting the chat LLM provider. APP
embeddings.openai.chunk_size LDR_EMBEDDINGS_OPENAI_CHUNK_SIZE 5 Maximum number of embedding inputs sent in one request. The default of 5 is conservative for OpenAI-compatible local endpoints such as LM Studio, vLLM, and llama.cpp. OpenAI cloud users may increase it for higher throughput. APP
embeddings.openai.dimensions LDR_EMBEDDINGS_OPENAI_DIMENSIONS null Optional output vector dimensionality. Only applies to OpenAI text-embedding-3 models (which support truncation); ignored for other models including most local servers. Leave blank to use the model's native dimensionality. APP
embeddings.openai.model LDR_EMBEDDINGS_OPENAI_MODEL text-embedding-3-small Embedding model identifier. For OpenAI cloud: text-embedding-3-small (default), text-embedding-3-large, or text-embedding-ada-002. For OpenAI-compatible local servers, use the exact model name your server reports (e.g. nomic-ai/nomic-embed-text-v1.5 on LM Studio). APP
embeddings.require_local LDR_EMBEDDINGS_REQUIRE_LOCAL false When enabled, the embeddings provider must be local (sentence_transformers, or Ollama pointed at a local URL). Indexing with cloud embeddings (OpenAI) is blocked. Indexing a corpus with cloud embeddings sends every chunk off-machine. LLM
focused_iteration.adaptive_questions LDR_FOCUSED_ITERATION_ADAPTIVE_QUESTIONS false When enabled (1), the system monitors recent search success and warns the LLM to broaden queries if 3+ searches in a recent window returned no results. When disabled (0), queries are generated without feedback from previous result counts. SEARCH
focused_iteration.knowledge_summary_limit LDR_FOCUSED_ITERATION_KNOWLEDGE_SUMMARY_LIMIT 10 Limits the number of top search results included in the knowledge summary shown to the LLM during question generation. Set to 10 to show only the top 10 results, reducing token usage. Set to 0 for unlimited. Note: This only affects question generation prompts — final answer synthesis always uses all results. SEARCH
focused_iteration.previous_searches_limit LDR_FOCUSED_ITERATION_PREVIOUS_SEARCHES_LIMIT 10 Maximum number of recent search iterations to show the LLM when generating follow-up questions. Helps the LLM avoid duplicate queries and reduces token usage. Set to 0 for unlimited (show all previous searches). When active, also caps displayed queries per iteration to 3. SEARCH
focused_iteration.prompt_knowledge_truncate LDR_FOCUSED_ITERATION_PROMPT_KNOWLEDGE_TRUNCATE 1500 Maximum characters of accumulated knowledge to include in the LLM prompt for follow-up question generation. Applied after 'Results Shown for Question Generation' selects the top N results — this further truncates that combined text to a character limit. Set to 0 for unlimited. SEARCH
focused_iteration.question_generator LDR_FOCUSED_ITERATION_QUESTION_GENERATOR browsecomp Algorithm for generating follow-up search queries. 'browsecomp' (default): Systematically extracts and combines entities (names, dates, locations) for predictable, focused searches. 'flexible': Allows the LLM more freedom to explore diverse search strategies — less rigid but may be less consistent. SEARCH
focused_iteration.snippet_truncate LDR_FOCUSED_ITERATION_SNIPPET_TRUNCATE 200 Maximum characters per snippet when showing search results to LLM for question generation. Shorter snippets (e.g., 200) reduce token usage and keep context focused. Set to 0 for full snippets. NOTE: This only affects question generation - the final answer synthesis sees full snippets. SEARCH
general.enable_fact_checking LDR_GENERAL_ENABLE_FACT_CHECKING false Enable LLM-based fact verification for research findings. Adds additional validation pass to check claims against sources. APP
general.knowledge_accumulation LDR_GENERAL_KNOWLEDGE_ACCUMULATION ITERATION How to compress accumulated knowledge between search iterations. 'ITERATION': Compress and carry forward knowledge after each iteration completes (default). 'QUESTION': Compress after every individual question within an iteration (more aggressive, saves tokens). 'NO_KNOWLEDGE': Start fresh each iteration with no carried-forward context. APP
general.knowledge_accumulation_context_limit LDR_GENERAL_KNOWLEDGE_ACCUMULATION_CONTEXT_LIMIT 2000000 Maximum character count for accumulated knowledge context. Reserved for future use — not currently enforced at runtime. APP
general.output_instructions LDR_GENERAL_OUTPUT_INSTRUCTIONS `` Customize how research outputs are formatted: language, tone, style, formatting preferences, audience level, etc. Examples: 'Respond in Spanish with formal tone' | 'Use simple language for beginners' | 'Be concise with bullet points'. Leave empty for default English output. APP
langgraph_agent.cooldown_wait_budget_seconds LDR_LANGGRAPH_AGENT_COOLDOWN_WAIT_BUDGET_SECONDS 3600 Total time in seconds one LangGraph research run may spend waiting when all usable search engines are cooling down. Parallel waits share the same budget. Default is one hour; increase it for providers with long rate limits. This does not limit LLM inference or the overall research duration. Set to 0 to skip cooldown waiting and use the sources already gathered. SEARCH
langgraph_agent.include_sub_research LDR_LANGGRAPH_AGENT_INCLUDE_SUB_RESEARCH true Enable parallel subagent research. When enabled, the agent can decompose complex questions into subtopics and research them simultaneously using separate subagents. SEARCH
langgraph_agent.max_iterations LDR_LANGGRAPH_AGENT_MAX_ITERATIONS 50 Maximum number of agent reasoning cycles (each cycle = one LLM call + one tool call). Higher values let the agent search more thoroughly but use more tokens. The agent typically needs 10-20 cycles for simple queries and 30-50 for complex multi-faceted research. SEARCH
langgraph_agent.max_sub_iterations LDR_LANGGRAPH_AGENT_MAX_SUB_ITERATIONS 8 Maximum reasoning cycles per subagent when researching subtopics in parallel. Each subagent investigates one aspect of the question independently. SEARCH
langgraph_agent.max_subagent_workers LDR_LANGGRAPH_AGENT_MAX_SUBAGENT_WORKERS 4 Maximum number of subagents that may run in parallel within a single research_subtopic call. Each call runs up to min(this setting, the number of subtopics passed to that call) workers; a call accepts at most 10 subtopics, so values above 10 do not increase per-call concurrency. Any subtopics beyond the pool size queue within that call and start as workers free up (a queued subagent keeps its own per-task budget — it is NOT killed by a shared loop timer). The lead agent may issue several research_subtopic calls concurrently in one turn, each with its own worker pool, so total concurrency across calls can be a multiple of this value. Tune this to match what your LLM backend can sustain in parallel (Ollama / LMStudio / llama.cpp OLLAMA_NUM_PARALLEL, an OpenAI tier limit, etc.). Lower values reduce concurrent LLM/search load; recommended to keep this low for local LLM backends. SEARCH
langgraph_agent.subagent_timeout_seconds LDR_LANGGRAPH_AGENT_SUBAGENT_TIMEOUT_SECONDS 7200 Per-subagent wall-clock deadline in seconds, measured from when the subagent starts. The default is two hours to support slow local LLMs. Cooldown waits count toward this time; the effective deadline is automatically at least the configured search cooldown wait budget plus 30 minutes, so cooldown waiting alone cannot exhaust it. Increase this for especially slow models. The LangGraph lead agent has no corresponding per-agent deadline. The separate llm.request_timeout setting controls how long an individual LLM request may be inactive. SEARCH
llm.allowed_local_hostnames LDR_LLM_ALLOWED_LOCAL_HOSTNAMES [] Hostnames the policy will treat as local in addition to loopback / RFC1918 / link-local. Use for self-hosted services on custom hostnames (e.g. 'ollama.lan'). Public hostnames added here are rejected at save time. LLM
llm.anthropic.api_key LDR_LLM_ANTHROPIC_API_KEY `` Your Anthropic API key for Claude models. Get one at console.anthropic.com. Required when using the Anthropic provider. LLM
llm.anthropic_endpoint.api_key LDR_LLM_ANTHROPIC_ENDPOINT_API_KEY `` Optional API key for your Anthropic-compatible endpoint. Leave blank for self-hosted servers that don't require authentication. LLM
llm.anthropic_endpoint.url LDR_LLM_ANTHROPIC_ENDPOINT_URL `` Base URL of a self-hosted service implementing the Anthropic Messages API (/v1/messages). The client appends the API path. Example: http://localhost:9090. Required when using the Anthropic-Compatible Endpoint provider. LLM
llm.atlascloud.api_key LDR_LLM_ATLASCLOUD_API_KEY null API key to use for the Atlas Cloud provider. LLM
llm.context_window_size LDR_LLM_CONTEXT_WINDOW_SIZE 128000 Maximum context window size in tokens for cloud LLMs. Only used when unrestricted context is disabled. LLM
llm.context_window_unrestricted LDR_LLM_CONTEXT_WINDOW_UNRESTRICTED true Let cloud provider APIs manage their own token limits without a hard cap (recommended). Uncheck to enforce a specific limit via the Context Window Size setting. LLM
llm.deepseek.api_key LDR_LLM_DEEPSEEK_API_KEY null API key to use for the DeepSeek provider. LLM
llm.google.api_key LDR_LLM_GOOGLE_API_KEY null API key to use for the Google Gemini provider. LLM
llm.ionos.api_key LDR_LLM_IONOS_API_KEY null API key to use for the IONOS AI Model Hub provider. LLM
llm.llamacpp.api_key LDR_LLM_LLAMACPP_API_KEY `` Optional API key for llama-server if it's behind an auth proxy. Leave empty if your llama-server has no authentication. LLM
llm.llamacpp.url LDR_LLM_LLAMACPP_URL http://localhost:8080/v1 HTTP endpoint URL where llama.cpp's llama-server is running. Include the full path with /v1 (default: http://localhost:8080/v1). Run llama-server -m <model.gguf> to start it. LLM
llm.lmstudio.api_key LDR_LLM_LMSTUDIO_API_KEY `` Optional API key for LM Studio if you've enabled authentication. Leave empty for the default no-auth setup. LLM
llm.lmstudio.url LDR_LLM_LMSTUDIO_URL http://localhost:1234/v1 HTTP endpoint URL where LM Studio is running locally. Include the full path (e.g., http://localhost:1234/v1 for OpenAI-compatible API format). LLM
llm.local_context_window_size LDR_LLM_LOCAL_CONTEXT_WINDOW_SIZE 20480 Context window size in tokens for local LLMs (Ollama, LlamaCpp, LM Studio). The default of 20480 tokens fits on systems with limited VRAM while still leaving room for the synthesis prompt. If your synthesis prompts get truncated, increase this; if you run out of VRAM, reduce it and switch to the source-based strategy. LLM
llm.max_retries LDR_LLM_MAX_RETRIES 2 Maximum provider SDK retries per failed inference or embedding request. Applies to OpenAI-compatible and Anthropic SDKs; the Ollama client does not retry. Configured values must be finite numbers within 0-5; invalid values raise a settings error instead of being replaced. An absent or unset optional value uses the default. Each retry starts another request with its own per-operation timeouts; SDK backoff or server-requested retry delays can further extend elapsed time. This setting does not impose a total request deadline. Model discovery SDK retries are disabled. LLM
llm.max_tokens LDR_LLM_MAX_TOKENS 30000 Maximum tokens in model responses. Automatically capped at 80% of the context window size to leave room for prompt tokens. LLM
llm.model LDR_LLM_MODEL `` The language model to use. Available models depend on the selected provider (e.g., 'gpt-4o' for OpenAI, 'gemma:7b' for Ollama). You can type any model name supported by your provider. LLM
llm.ollama.api_key LDR_LLM_OLLAMA_API_KEY `` Optional API key for Ollama if you've put it behind a proxy that requires authentication. Leave empty for the default no-auth setup. LLM
llm.ollama.enable_thinking LDR_LLM_OLLAMA_ENABLE_THINKING true Enable thinking/reasoning mode for models like deepseek-r1 and qwen2.5. When enabled (recommended), the model performs internal reasoning for more accurate answers, but the reasoning content is automatically separated and excluded from the final response. When disabled, the model gives faster but potentially less accurate direct answers without reasoning. LLM
llm.ollama.url LDR_LLM_OLLAMA_URL http://localhost:11434 HTTP endpoint URL where Ollama is running. Used to connect to local or remote Ollama instances for model inference. LLM
llm.openai.api_key LDR_LLM_OPENAI_API_KEY `` Your OpenAI API key for GPT models. Get one at platform.openai.com. Required when using the OpenAI provider. LLM
llm.openai_endpoint.api_key LDR_LLM_OPENAI_ENDPOINT_API_KEY `` API key for your custom OpenAI-compatible endpoint. For cloud services (OpenRouter, Groq), use your actual API key. For local servers (llama.cpp, vLLM), you can leave this blank — LDR will substitute a placeholder automatically. LLM
llm.openai_endpoint.stream_usage LDR_LLM_OPENAI_ENDPOINT_STREAM_USAGE false Request token usage statistics on streamed responses (sends stream_options.include_usage). Enable this if the token metrics dashboard shows zero token counts for streamed calls. Supported by LM Studio (0.3.18+), llama.cpp server, vLLM, and OpenRouter. Leave disabled if your endpoint rejects requests with a 'stream_options' error (e.g. some API gateways). LLM
llm.openai_endpoint.url LDR_LLM_OPENAI_ENDPOINT_URL https://openrouter.ai/api/v1 URL of a custom OpenAI-compatible API endpoint. Use for llama.cpp server, vLLM, Ollama, OpenRouter, Groq, Together, or any service that implements the OpenAI API format. Example for local llama.cpp: http://localhost:8000/v1 LLM
llm.openrouter.api_key LDR_LLM_OPENROUTER_API_KEY null API key to use for the OpenRouter provider. LLM
llm.orcarouter.api_key LDR_LLM_ORCAROUTER_API_KEY null API key to use for the OrcaRouter provider. LLM
llm.provider LDR_LLM_PROVIDER ollama The LLM service provider. Choose local providers (Ollama, LM Studio, LlamaCpp) for free on-device inference, or cloud APIs (OpenAI, Anthropic, Google, OpenRouter) for hosted models. LLM
llm.qwen.api_key LDR_LLM_QWEN_API_KEY null API key to use for the QwenCloud provider. LLM
llm.request_timeout LDR_LLM_REQUEST_TIMEOUT 1800 Per-operation HTTP timeout in seconds for LLM inference and embedding requests, applied to every supported provider. It bounds each connect, write and wait for the next response chunk individually; it is not a cap on the total duration of a response. A peer that keeps sending data can exceed this value, including for a non-streaming response. Connecting is separately capped at 5 seconds for OpenAI-compatible and Ollama clients; Anthropic inference uses this value for connecting too. There is no upper limit. Configured values must be finite numbers of at least 1 second; invalid values raise a settings error instead of being replaced. An absent or unset optional value uses the default. Model discovery is unaffected: OpenAI-compatible providers and Anthropic use 30 seconds, while Google and Ollama retain provider-specific limits of 10 and 5 seconds, respectively. LLM
llm.requesty.api_key LDR_LLM_REQUESTY_API_KEY null API key to use for the Requesty provider. LLM
llm.require_local_endpoint LDR_LLM_REQUIRE_LOCAL_ENDPOINT false When enabled, the LLM provider's resolved endpoint must be on a local network (loopback, RFC1918, link-local). Cloud-only providers (OpenAI, Anthropic, Google, OpenRouter) are blocked. Independent of egress_scope. LLM
llm.supports_max_tokens LDR_LLM_SUPPORTS_MAX_TOKENS true Feature flag for max_tokens parameter. Disable if your LLM API returns errors when max_tokens is set. When disabled, the parameter is not passed to the API. LLM
llm.temperature LDR_LLM_TEMPERATURE 0.7 Controls randomness in model outputs. Lower values (0.0-0.3) produce deterministic, factual responses; higher values (0.7-1.0) produce more creative and varied outputs. LLM
llm.xai.api_key LDR_LLM_XAI_API_KEY null API key to use for the xAI Grok provider. LLM
local_search_chunk_overlap LDR_LOCAL_SEARCH_CHUNK_OVERLAP 200 Characters shared between adjacent chunks. Prevents important information from being cut at chunk boundaries. Typically 10-20% of chunk size. Affects new indexing only. APP
local_search_chunk_size LDR_LOCAL_SEARCH_CHUNK_SIZE 1000 Number of characters per chunk when splitting documents for embedding. Larger chunks (1000+) keep more context but search is less precise. Smaller chunks (<500) are more granular but may cut off important context. Affects new indexing only. APP
local_search_distance_metric LDR_LOCAL_SEARCH_DISTANCE_METRIC cosine How chunk vectors are compared during retrieval. Cosine similarity is the standard recommendation for text embeddings. L2 (Euclidean) and dot product are alternatives whose suitability depends on whether the embedding model is trained to produce normalized vectors. APP
local_search_embedding_model LDR_LOCAL_SEARCH_EMBEDDING_MODEL Alibaba-NLP/gte-modernbert-base Embedding model used for the local-document search index. Model names vary by provider: Sentence Transformers uses LDR's vetted list, while Ollama/OpenAI-compatible servers expose whatever is installed. Defaults to Alibaba-NLP/gte-modernbert-base (768d); curated Sentence Transformers models require a one-time policy-authorized download, then reuse the local cache. APP
local_search_embedding_provider LDR_LOCAL_SEARCH_EMBEDDING_PROVIDER sentence_transformers Embedding provider used for the local-document search index. Drives which models the Embeddings page lists and which provider runs when documents are indexed. The model dropdown is rebuilt to match this provider. APP
local_search_index_type LDR_LOCAL_SEARCH_INDEX_TYPE flat FAISS index type used for the local-document search index. Flat: exact search, recommended for <10K documents. HNSW: approximate but ~50x faster, recommended for large collections (>10K docs). IVF: balanced for collections that are updated frequently. Changing this requires re-indexing existing collections. APP
local_search_normalize_vectors LDR_LOCAL_SEARCH_NORMALIZE_VECTORS true L2-normalize embedding vectors after generation. Recommended: ensures fair similarity comparison regardless of source document length. Some embedding models already produce normalized output; in that case this is a no-op. APP
local_search_splitter_type LDR_LOCAL_SEARCH_SPLITTER_TYPE recursive How to divide documents into chunks. Recursive uses natural breaks (paragraphs, sentences). Token-based respects model context limits. Sentence-based produces clean sentence boundaries. Semantic uses an embedding model to group related content (smarter but slower). APP
local_search_text_separators LDR_LOCAL_SEARCH_TEXT_SEPARATORS ["\n\n", "\n", ". ", " ", ""] JSON array of separator strings tried in order by the recursive splitter. The default works for general prose. For code, add language-specific separators like "\nclass", "\ndef". APP
news.display.default_headline_max_length LDR_NEWS_DISPLAY_DEFAULT_HEADLINE_MAX_LENGTH 100 Default maximum headline length APP
news.display.max_query_length LDR_NEWS_DISPLAY_MAX_QUERY_LENGTH 50 Maximum query display length in UI APP
news.feed.default_limit LDR_NEWS_FEED_DEFAULT_LIMIT 20 Default number of news items returned per feed page. Applied when user does not specify a limit in the request. Also used as the default limit for subscription history. APP
news.preferences.max_stored LDR_NEWS_PREFERENCES_MAX_STORED 100 Maximum number of stored preferences per user APP
news.progress.complete LDR_NEWS_PROGRESS_COMPLETE 100 Progress percentage when complete APP
news.progress.generating_searches LDR_NEWS_PROGRESS_GENERATING_SEARCHES 50 Progress percentage when generating searches APP
news.refresh.default_hours LDR_NEWS_REFRESH_DEFAULT_HOURS 4 Default refresh interval in hours APP
news.scheduler.activity_check_interval LDR_NEWS_SCHEDULER_ACTIVITY_CHECK_INTERVAL 5 How often (in minutes) the scheduler scans for subscriptions that are due to run. More frequent checks ensure timely updates but increase CPU usage. Range: 1-60 minutes. APP
news.scheduler.allow_api_control LDR_NEWS_SCHEDULER_ALLOW_API_CONTROL false Allow authenticated users to start, stop, and trigger the global news scheduler via API. This setting cannot be changed from the UI for security reasons. Disable in multi-user deployments by setting the environment variable LDR_NEWS_SCHEDULER_ALLOW_API_CONTROL=false. APP
news.scheduler.batch_size LDR_NEWS_SCHEDULER_BATCH_SIZE 5 Number of due subscriptions to pick up and schedule in each check cycle. Larger batches are more efficient but use more memory. Range: 1-20. APP
news.scheduler.cleanup_interval_hours LDR_NEWS_SCHEDULER_CLEANUP_INTERVAL_HOURS 1 How often (in hours) the scheduler checks for and removes expired user sessions. Shorter intervals reduce memory usage but add slight overhead. Range: 0.25-24 hours. APP
news.scheduler.enabled LDR_NEWS_SCHEDULER_ENABLED true Enable the background scheduler that automatically runs news subscriptions on their configured intervals. When disabled, no automatic subscription processing occurs — subscriptions must be refreshed manually. APP
news.scheduler.max_concurrent_jobs LDR_NEWS_SCHEDULER_MAX_CONCURRENT_JOBS 10 Maximum number of subscription refresh tasks that can run simultaneously across all users. Lower values reduce server load; higher values process subscriptions faster. Range: 1-50. APP
news.scheduler.max_jitter_seconds LDR_NEWS_SCHEDULER_MAX_JITTER_SECONDS 300 Maximum random delay (in seconds) added to each subscription's next refresh time. Prevents all subscriptions from running simultaneously, reducing server load spikes. Range: 0-3600 seconds. APP
news.scheduler.retention_hours LDR_NEWS_SCHEDULER_RETENTION_HOURS 48 Hours to keep a user's session active in the scheduler after their last interaction. After this period, the scheduler stops processing that user's subscriptions until they log in again. Range: 1-168 hours. APP
news.storage.default_limit LDR_NEWS_STORAGE_DEFAULT_LIMIT 100 Default limit for storing news items APP
news.subscription.default_type LDR_NEWS_SUBSCRIPTION_DEFAULT_TYPE search Default subscription type APP
news.subscription.refresh_minutes LDR_NEWS_SUBSCRIPTION_REFRESH_MINUTES 360 Default interval (in minutes) for how often new subscriptions check for updates. Users can override this per subscription. Default is 240 minutes (4 hours). Range: 60-2880 minutes. APP
news.trending.lookback_hours LDR_NEWS_TRENDING_LOOKBACK_HOURS 24 Hours to look back for trending analysis APP
notifications.enabled LDR_NOTIFICATIONS_ENABLED false Enable external notifications for research events (email, Discord, Slack, etc.). When disabled, no notifications are sent regardless of individual event settings below. Requires service URL to be configured. APP
notifications.on_api_quota_warning LDR_NOTIFICATIONS_ON_API_QUOTA_WARNING false Send notification when API quota or rate limits are approaching or exceeded. Helps prevent service interruptions from unexpected API usage limits. APP
notifications.on_auth_issue LDR_NOTIFICATIONS_ON_AUTH_ISSUE false Send notification when authentication fails for external API services (e.g., invalid or expired API keys). Alerts you to broken integrations that need attention. APP
notifications.on_research_completed LDR_NOTIFICATIONS_ON_RESEARCH_COMPLETED true Send notification when a research task completes successfully. This is the primary completion alert for tracking long-running research. APP
notifications.on_research_failed LDR_NOTIFICATIONS_ON_RESEARCH_FAILED true Send notification when a research task fails or encounters an error. Enables rapid problem detection without monitoring the web interface. APP
notifications.on_research_queued LDR_NOTIFICATIONS_ON_RESEARCH_QUEUED false Send notification when research is added to the processing queue. Useful in queue mode to confirm your request was accepted and is waiting to be processed. APP
notifications.on_subscription_error LDR_NOTIFICATIONS_ON_SUBSCRIPTION_ERROR false Send notification when a subscription refresh fails or encounters errors. Helps identify broken subscriptions that need attention. APP
notifications.on_subscription_update LDR_NOTIFICATIONS_ON_SUBSCRIPTION_UPDATE true Send notification when news subscriptions detect new content matching your configured topics. APP
notifications.rate_limit_per_day LDR_NOTIFICATIONS_RATE_LIMIT_PER_DAY 50 Maximum number of notifications per day per user. Daily cap prevents notification fatigue. Default of 50 balances staying informed with avoiding excessive alerts. APP
notifications.rate_limit_per_hour LDR_NOTIFICATIONS_RATE_LIMIT_PER_HOUR 10 Maximum number of notifications per hour per user. Prevents notification spam during burst activity. Default of 10 allows important notifications through while limiting noise. APP
notifications.service_url LDR_NOTIFICATIONS_SERVICE_URL `` Notification service URL(s). Supports multiple comma-separated URLs to send notifications to multiple destinations (e.g., discord://YOUR_WEBHOOK_ID/YOUR_TOKEN, mailto://YOUR_USER:[email protected]?to=[email protected]). See documentation for supported services. APP
policy.egress_scope LDR_POLICY_EGRESS_SCOPE adaptive EXPERIMENTAL — this egress boundary is new defense-in-depth, not an absolute guarantee yet; don't rely on it as your only protection for highly sensitive data. Restrict which search engines a research run may use. ADAPTIVE (default) = follow your primary engine: a private primary keeps everything local, a public primary allows public engines. STRICT = only the primary engine you picked; PUBLIC_ONLY = any public web/academic engine; PRIVATE_ONLY = any local engine (library, paperless, etc.); UNPROTECTED = operator-enabled escape hatch that disables egress protection entirely (not recommended; requires LDR_POLICY_ALLOW_UNPROTECTED_EGRESS=true; hard SSRF/cloud-metadata blocking still applies). SEARCH
policy.trusted_inference_providers LDR_POLICY_TRUSTED_INFERENCE_PROVIDERS [] EXPERIMENTAL. LLM/embeddings providers you explicitly trust to receive sensitive content — listing one treats it as a 'contained' inference sink even though it is off-machine (e.g. a zero-retention enterprise Anthropic endpoint). Relaxes the two-axis egress classification; use only for providers you have vetted. LLM
policy.trusted_search_engines LDR_POLICY_TRUSTED_SEARCH_ENGINES [] EXPERIMENTAL. Search engines whose endpoint you explicitly trust — listing one (e.g. a self-hosted Elasticsearch/Paperless on a public hostname) treats it as 'contained' rather than an exposing sink. Relaxes the two-axis egress classification; use only for endpoints you control. SEARCH
rag.indexing_batch_size LDR_RAG_INDEXING_BATCH_SIZE 15 Maximum number of documents grouped into a single SSE progress batch on /api/rag/index-all. Documents within a batch are processed in parallel via rag.indexing_max_parallel_docs. Higher values reduce SSE overhead but increase the unit of cancellation. APP
rag.indexing_max_parallel_docs LDR_RAG_INDEXING_MAX_PARALLEL_DOCS 4 Maximum number of documents indexed concurrently within a single indexing job (per-user). One job holds up to this many workers; each worker calls the existing per-document path so the FAISS write lock still serializes the disk-merge step. Lower if your embedding backend is throughput-bound and concurrent calls contend; local sentence-transformers run one embedding call at a time per process, so raise to e.g. 8-16 mainly for HTTP embedding providers (OpenAI-compatible, vLLM, Ollama with OLLAMA_NUM_PARALLEL>1). Default 4 keeps RAM modest for collections with many large documents. APP
rate_limiting.decay_per_day LDR_RATE_LIMITING_DECAY_PER_DAY 0.95 How much to trust old rate limit data as it ages (0.5-0.99). At 0.95, data retains 95% reliability per day. Lower values discard old data faster, forcing the system to re-learn optimal wait times. APP
rate_limiting.enabled LDR_RATE_LIMITING_ENABLED true Enable adaptive rate limiting that learns optimal wait times for each search engine to avoid hitting API rate limits. When disabled, requests are sent with minimal delay (0.1s), which may trigger rate limit errors from some APIs. APP
rate_limiting.exploration_rate LDR_RATE_LIMITING_EXPLORATION_RATE 0.1 Fraction of requests that test shorter wait times to check if the API allows faster access (0.0-1.0). Higher values adapt faster to relaxed limits but risk more rate limit errors. APP
rate_limiting.learning_rate LDR_RATE_LIMITING_LEARNING_RATE 0.45 How much weight to give new timing data vs. existing estimates (0.0-1.0). Higher values react faster to changes in API rate limits but produce less stable wait times. APP
rate_limiting.llm_enabled LDR_RATE_LIMITING_LLM_ENABLED false Enable adaptive rate limiting for LLM API calls, separate from search engine rate limiting. Useful for free-tier or rate-limited LLM APIs that impose request quotas. APP
rate_limiting.memory_window LDR_RATE_LIMITING_MEMORY_WINDOW 100 Number of recent requests to remember per search engine for calculating optimal wait times. At least 3 successful requests are needed before wait time estimates start updating. APP
rate_limiting.profile LDR_RATE_LIMITING_PROFILE balanced Overall rate limiting behavior. 'Conservative' uses longer waits and adapts slowly (fewer errors). 'Balanced' is the default. 'Aggressive' uses shorter waits and adapts quickly (faster but riskier). APP
report.citation_format LDR_REPORT_CITATION_FORMAT number_hyperlinks Citation formatting style for reports. Options include numbered hyperlinks [1], domain-based hyperlinks [arxiv.org], smart domain numbering [arxiv.org-1], source-tagged citations with the global citation number preserved (e.g. [arxiv-1], [openai.com-2], [arxiv-3]), and plain numbered references without links. REPORT
report.enable_file_backup LDR_REPORT_ENABLE_FILE_BACKUP false Also save plaintext report files in research_outputs/ under the data directory for external access (reports remain in the database). On POSIX, that directory is set to mode 0700 and new or rewritten report files to 0600; on Windows, configure equivalent access controls. If another OS account owns the directory or its filesystem does not keep mode 0700, as on Docker Desktop bind mounts of Windows folders, WSL drives such as /mnt/c, CIFS/SMB shares and exFAT, no files are written and the research page shows a warning. Keep the data directory on a Linux filesystem path or a Docker named volume, or turn this off. REPORT
report.export_formats LDR_REPORT_EXPORT_FORMATS ["markdown", "latex", "quarto", "ris"] Available export format options displayed in the user interface. Supported formats include Markdown (.md), LaTeX (.tex), Quarto (.qmd), and RIS bibliographic format. REPORT
report.max_context_chars LDR_REPORT_MAX_CONTEXT_CHARS 4000 Maximum character limit for previous section context when generating report sections. If accumulated context exceeds this, it is truncated at sentence boundaries. Lower values are safer for smaller local models. Default is 4000. REPORT
report.max_context_sections LDR_REPORT_MAX_CONTEXT_SECTIONS 3 Number of previously generated report sections to include as context when writing new sections. Helps the LLM avoid repeating content. Higher values increase context size but may exceed smaller model limits. Default is 3. REPORT
report.searches_per_section LDR_REPORT_SEARCHES_PER_SECTION 2 Number of web searches to perform per report section. Higher values increase research depth for each section but also increase search engine queries and processing time. Default is 2. REPORT
report.uncited_sources_mode LDR_REPORT_UNCITED_SOURCES_MODE fallback Which sources appear in the final report bibliography. Cited only with fallback keeps sources cited in the report body and falls back to all sources when no citations are detected; strict keeps only cited sources; legacy lists every accumulated search hit. REPORT
research_library.auto_index_enabled LDR_RESEARCH_LIBRARY_AUTO_INDEX_ENABLED false Automatically index documents for RAG search when they are added to collections (via upload or download). Indexing runs in the background without blocking uploads. Disable to defer indexing and improve upload speed for large batches. APP
research_library.auto_persist_research_sources LDR_RESEARCH_LIBRARY_AUTO_PERSIST_RESEARCH_SOURCES false Automatically persist research sources (PDFs and extracted text) into the Library when a research run completes. Default off. When enabled, PDF downloads still honor the scheduler preference document_scheduler.download_pdfs and the PDF storage mode. APP
research_library.confirm_deletions LDR_RESEARCH_LIBRARY_CONFIRM_DELETIONS true Show confirmation dialogs before delete operations. Recommended to keep enabled to prevent accidental data loss. APP
research_library.max_pdf_size_mb LDR_RESEARCH_LIBRARY_MAX_PDF_SIZE_MB 3072 Maximum allowed PDF file size in megabytes for the research library. PDFs larger than this will not be stored; their extracted text is still kept, and a research download whose PDF was refused this way is stored when it is next downloaded after this limit is raised above its size. Uploads are also gated by the per-file upload cap (LDR_SECURITY_UPLOAD_MAX_FILE_SIZE_MB, default 3072 MB / 3 GB) — raising this value above that cap has no effect because uploads are rejected before they reach storage. APP
research_library.pdf_storage_mode RESEARCH_LIBRARY_PDF_STORAGE_MODE database Choose how PDFs are stored. Each user has their own encrypted database. Database mode stores PDFs encrypted within it (secure, portable, isolated per-user). Filesystem mode stores unencrypted files on disk (faster for large files). None stores only extracted text (smallest footprint). APP
research_library.shared_library RESEARCH_LIBRARY_SHARED_LIBRARY false ⚠️ WARNING: When enabled, all users share the same library directory. Documents from all users will be visible to each other. Only enable in trusted environments. APP
research_library.storage_path RESEARCH_LIBRARY_STORAGE_PATH ~/Documents/LocalDeepResearch/Library Operator-controlled base path for research library documents. Existing saved locations remain in use; set LDR_RESEARCH_LIBRARY_STORAGE_PATH to change the path. Each user has a subdirectory unless shared library is enabled. APP
research_library.upload_pdf_storage RESEARCH_LIBRARY_UPLOAD_PDF_STORAGE none Choose how user-uploaded PDFs are stored. Database mode stores PDFs encrypted in your personal database (increases database size but allows viewing/downloading later). Text Only extracts and stores only the text content (smallest footprint). Note: Filesystem storage is not available for uploads for security reasons. APP
search.cross_engine_max_context_items LDR_SEARCH_CROSS_ENGINE_MAX_CONTEXT_ITEMS 30 Maximum number of search result previews sent to the LLM for relevance ranking during cross-engine filtering. Higher values let the model evaluate more candidates, improving recall at the cost of increased prompt size and latency. SEARCH
search.cross_engine_max_results LDR_SEARCH_CROSS_ENGINE_MAX_RESULTS 100 Maximum number of search results to keep after cross-engine filtering in pipeline/source-based strategies. When results from multiple search engines are combined, this limits how many total results are displayed. Higher values show more comprehensive results. Note: Autonomous agent strategies (like langgraph-agent) manage context autonomously and do not apply this filter. SEARCH
search.engine.DEFAULT_SEARCH_ENGINE LDR_SEARCH_ENGINE_DEFAULT_SEARCH_ENGINE wikipedia Fallback search engine used when the configured engine is unavailable or has errors. SEARCH
search.engine.web.arxiv.agent_enabled LDR_SEARCH_ENGINE_WEB_ARXIV_AGENT_ENABLED true Include ArXiv as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.arxiv.default_params.max_results LDR_SEARCH_ENGINE_WEB_ARXIV_DEFAULT_PARAMS_MAX_RESULTS 20 Maximum number of papers to retrieve from arXiv per search query. SEARCH
search.engine.web.arxiv.default_params.sort_by LDR_SEARCH_ENGINE_WEB_ARXIV_DEFAULT_PARAMS_SORT_BY relevance How to sort arXiv results: 'relevance' for best match, 'lastUpdatedDate' for recently updated, 'submittedDate' for newest submissions. SEARCH
search.engine.web.arxiv.default_params.sort_order LDR_SEARCH_ENGINE_WEB_ARXIV_DEFAULT_PARAMS_SORT_ORDER descending Sort order for arXiv results: 'descending' (newest/most relevant first) or 'ascending' (oldest/least relevant first). SEARCH
search.engine.web.arxiv.description LDR_SEARCH_ENGINE_WEB_ARXIV_DESCRIPTION Search papers uploaded to ArXiv. Human-readable description of the search engine. SEARCH
search.engine.web.arxiv.display_name LDR_SEARCH_ENGINE_WEB_ARXIV_DISPLAY_NAME ArXiv Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.arxiv.journal_reputation.enabled LDR_SEARCH_ENGINE_WEB_ARXIV_JOURNAL_REPUTATION_ENABLED true Enable journal quality filtering for this search engine. SEARCH
search.engine.web.arxiv.reliability LDR_SEARCH_ENGINE_WEB_ARXIV_RELIABILITY 0.9 Reliability rating (0-1) for arXiv as a source. Higher values indicate more trustworthy academic content. SEARCH
search.engine.web.arxiv.requires_api_key LDR_SEARCH_ENGINE_WEB_ARXIV_REQUIRES_API_KEY false Whether arXiv requires an API key. arXiv is free and open access, so this is false. SEARCH
search.engine.web.arxiv.strengths LDR_SEARCH_ENGINE_WEB_ARXIV_STRENGTHS ["scientific papers", "academic research", "physics", "computer science", "mathematics", "statistics", "machine learning", "preprints"] Key advantages of arXiv: Free access to preprints, covers physics/math/CS/biology, fast publication of cutting-edge research. SEARCH
search.engine.web.arxiv.use_in_auto_search LDR_SEARCH_ENGINE_WEB_ARXIV_USE_IN_AUTO_SEARCH true Include ArXiv in auto search mode SEARCH
search.engine.web.arxiv.weaknesses LDR_SEARCH_ENGINE_WEB_ARXIV_WEAKNESSES ["non-academic topics", "consumer products", "news", "general information"] Limitations of arXiv: Preprints aren't peer-reviewed, limited to STEM fields, keyword-based search may miss semantic matches. SEARCH
search.engine.web.brave.agent_enabled LDR_SEARCH_ENGINE_WEB_BRAVE_AGENT_ENABLED true Include Brave as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.brave.api_key LDR_SEARCH_ENGINE_WEB_BRAVE_API_KEY `` The Brave API key to use. SEARCH
search.engine.web.brave.default_params.region LDR_SEARCH_ENGINE_WEB_BRAVE_DEFAULT_PARAMS_REGION US Geographic region code for Brave search results (e.g., 'US', 'UK', 'DE'). SEARCH
search.engine.web.brave.default_params.safe_search LDR_SEARCH_ENGINE_WEB_BRAVE_DEFAULT_PARAMS_SAFE_SEARCH true Enable safe search filtering for Brave to exclude adult content. SEARCH
search.engine.web.brave.default_params.search_language LDR_SEARCH_ENGINE_WEB_BRAVE_DEFAULT_PARAMS_SEARCH_LANGUAGE English Preferred language for Brave search results. SEARCH
search.engine.web.brave.default_params.time_period LDR_SEARCH_ENGINE_WEB_BRAVE_DEFAULT_PARAMS_TIME_PERIOD inherit Time range filter for Brave results. 'Use global default' follows Settings → Search → Time Period; a specific value here overrides that saved global setting for this engine ('all' = no filter). When the LDR_SEARCH_TIME_PERIOD environment variable is set it takes precedence over a value saved here, and this engine's own environment variable takes precedence over both. SEARCH
search.engine.web.brave.description LDR_SEARCH_ENGINE_WEB_BRAVE_DESCRIPTION Search the web using the Brave search engine. Human-readable description of the search engine. SEARCH
search.engine.web.brave.display_name LDR_SEARCH_ENGINE_WEB_BRAVE_DISPLAY_NAME Brave Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.brave.reliability LDR_SEARCH_ENGINE_WEB_BRAVE_RELIABILITY 0.7 Reliability rating (0-1) for Brave Search. Good general-purpose search with privacy focus. SEARCH
search.engine.web.brave.requires_api_key LDR_SEARCH_ENGINE_WEB_BRAVE_REQUIRES_API_KEY true Whether Brave Search requires an API key. Yes - get one at brave.com/search/api. SEARCH
search.engine.web.brave.strengths LDR_SEARCH_ENGINE_WEB_BRAVE_STRENGTHS ["privacy-focused web search", "product information", "reviews", "recent content", "news", "broad coverage"] Key advantages of Brave: Privacy-focused, good semantic search, reasonable pricing, full-text retrieval available. SEARCH
search.engine.web.brave.supports_full_search LDR_SEARCH_ENGINE_WEB_BRAVE_SUPPORTS_FULL_SEARCH true Whether Brave supports fetching full webpage content beyond snippets. SEARCH
search.engine.web.brave.use_in_auto_search LDR_SEARCH_ENGINE_WEB_BRAVE_USE_IN_AUTO_SEARCH false Include Brave search in auto search mode SEARCH
search.engine.web.brave.weaknesses LDR_SEARCH_ENGINE_WEB_BRAVE_WEAKNESSES ["requires API key with usage limits", "smaller index than Google"] Limitations of Brave: Smaller index than Google, requires paid API for production use. SEARCH
search.engine.web.elasticsearch.agent_enabled LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_AGENT_ENABLED true Include Elasticsearch as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.elasticsearch.default_params.api_key LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_DEFAULT_PARAMS_API_KEY `` API key for Elasticsearch authentication (optional) SEARCH
search.engine.web.elasticsearch.default_params.cloud_id LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_DEFAULT_PARAMS_CLOUD_ID `` Elastic Cloud ID for cloud-hosted Elasticsearch (optional) SEARCH
search.engine.web.elasticsearch.default_params.highlight_fields LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_DEFAULT_PARAMS_HIGHLIGHT_FIELDS ["content", "title"] Fields to highlight in search results (JSON array) SEARCH
search.engine.web.elasticsearch.default_params.hosts LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_DEFAULT_PARAMS_HOSTS ["http://localhost:9200"] Elasticsearch server URLs (JSON array format) SEARCH
search.engine.web.elasticsearch.default_params.index_name LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_DEFAULT_PARAMS_INDEX_NAME documents Name of the Elasticsearch index to search SEARCH
search.engine.web.elasticsearch.default_params.max_results LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_DEFAULT_PARAMS_MAX_RESULTS 10 Maximum number of search results to return SEARCH
search.engine.web.elasticsearch.default_params.password LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_DEFAULT_PARAMS_PASSWORD `` Password for Elasticsearch authentication (optional) SEARCH
search.engine.web.elasticsearch.default_params.search_fields LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_DEFAULT_PARAMS_SEARCH_FIELDS ["content", "title", "description", "text"] Fields to search in (JSON array) SEARCH
search.engine.web.elasticsearch.default_params.username LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_DEFAULT_PARAMS_USERNAME `` Username for Elasticsearch authentication (optional) SEARCH
search.engine.web.elasticsearch.description LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_DESCRIPTION Search engine for Elasticsearch databases. Efficient for searching document collections and structured data. Human-readable description of the search engine. SEARCH
search.engine.web.elasticsearch.display_name LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_DISPLAY_NAME Elasticsearch Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.elasticsearch.reliability LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_RELIABILITY 0.95 Reliability of the Elasticsearch search engine SEARCH
search.engine.web.elasticsearch.requires_api_key LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_REQUIRES_API_KEY false Whether this search engine requires an API key SEARCH
search.engine.web.elasticsearch.requires_llm LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_REQUIRES_LLM true Whether this search engine requires an LLM for relevance filtering SEARCH
search.engine.web.elasticsearch.strengths LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_STRENGTHS ["Fast full-text search", "Scalable and distributed", "Rich query DSL", "Supports aggregations", "Real-time search"] Strengths of this search engine SEARCH
search.engine.web.elasticsearch.supports_full_search LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_SUPPORTS_FULL_SEARCH true Whether this search engine supports full document search SEARCH
search.engine.web.elasticsearch.use_in_auto_search LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_USE_IN_AUTO_SEARCH false Include Elasticsearch in auto search mode SEARCH
search.engine.web.elasticsearch.weaknesses LDR_SEARCH_ENGINE_WEB_ELASTICSEARCH_WEAKNESSES ["Requires running Elasticsearch instance", "Needs proper index configuration", "Data must be pre-indexed"] Weaknesses of this search engine SEARCH
search.engine.web.exa.agent_enabled LDR_SEARCH_ENGINE_WEB_EXA_AGENT_ENABLED true Include Exa as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.exa.api_key LDR_SEARCH_ENGINE_WEB_EXA_API_KEY `` The Exa API key to use. Get one at exa.ai. SEARCH
search.engine.web.exa.default_params.include_full_content LDR_SEARCH_ENGINE_WEB_EXA_DEFAULT_PARAMS_INCLUDE_FULL_CONTENT true Include full webpage content in results SEARCH
search.engine.web.exa.default_params.search_type LDR_SEARCH_ENGINE_WEB_EXA_DEFAULT_PARAMS_SEARCH_TYPE auto Search type - auto (default), neural (semantic), fast, or deep (comprehensive multi-query) SEARCH
search.engine.web.exa.description LDR_SEARCH_ENGINE_WEB_EXA_DESCRIPTION Neural search engine built for AI with semantic understanding and high-quality results optimized for LLM consumption. Human-readable description of the search engine. SEARCH
search.engine.web.exa.display_name LDR_SEARCH_ENGINE_WEB_EXA_DISPLAY_NAME Exa Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.exa.reliability LDR_SEARCH_ENGINE_WEB_EXA_RELIABILITY 0.85 Reliability score (0-1). Exa rated high (0.85) - neural search with semantic understanding designed for AI applications. SEARCH
search.engine.web.exa.requires_api_key LDR_SEARCH_ENGINE_WEB_EXA_REQUIRES_API_KEY true Indicates this engine requires an Exa API key. Get one at exa.ai. SEARCH
search.engine.web.exa.strengths LDR_SEARCH_ENGINE_WEB_EXA_STRENGTHS ["neural search with semantic understanding", "results optimized for LLM consumption", "high-quality, clean content", "supports deep search for comprehensive results", "built-in highlights and summaries", "date filtering and domain controls"] Advantages: Neural search with semantic understanding, results optimized for LLM consumption, high-quality content, supports deep search mode. SEARCH
search.engine.web.exa.supports_full_search LDR_SEARCH_ENGINE_WEB_EXA_SUPPORTS_FULL_SEARCH true Indicates this engine can fetch full page content after initial search, not just snippets. SEARCH
search.engine.web.exa.use_in_auto_search LDR_SEARCH_ENGINE_WEB_EXA_USE_IN_AUTO_SEARCH false Include Exa in auto search mode SEARCH
search.engine.web.exa.weaknesses LDR_SEARCH_ENGINE_WEB_EXA_WEAKNESSES ["requires API key with usage limits", "newer service still evolving", "costs scale with usage"] Limitations: Requires paid API key with usage limits, newer service with evolving features. SEARCH
search.engine.web.federal_register.agent_enabled LDR_SEARCH_ENGINE_WEB_FEDERAL_REGISTER_AGENT_ENABLED true Include Federal Register as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.federal_register.default_params.document_types LDR_SEARCH_ENGINE_WEB_FEDERAL_REGISTER_DEFAULT_PARAMS_DOCUMENT_TYPES [] Federal Register document types to include in search results. Valid values: RULE (final rules), PRORULE (proposed rules), NOTICE (notices), PRESDOCU (presidential documents), CORRECT (corrections), UNKNOWN (uncategorized documents), SUNSHINE (Sunshine Act documents, a legacy type); case-insensitive. Leave empty to search all types. Any other value is ignored with a warning. SEARCH
search.engine.web.federal_register.description LDR_SEARCH_ENGINE_WEB_FEDERAL_REGISTER_DESCRIPTION FederalRegister.gov informational edition search for rules, proposed rules, notices, and presidential documents; not the official legal edition. Verify against GovInfo for legal reliance. Human-readable description of the search engine. SEARCH
search.engine.web.federal_register.display_name LDR_SEARCH_ENGINE_WEB_FEDERAL_REGISTER_DISPLAY_NAME Federal Register Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.federal_register.reliability LDR_SEARCH_ENGINE_WEB_FEDERAL_REGISTER_RELIABILITY 0.95 Reliability of the Federal Register search engine. SEARCH
search.engine.web.federal_register.requires_api_key LDR_SEARCH_ENGINE_WEB_FEDERAL_REGISTER_REQUIRES_API_KEY false Whether this search engine requires an API key. SEARCH
search.engine.web.federal_register.requires_llm LDR_SEARCH_ENGINE_WEB_FEDERAL_REGISTER_REQUIRES_LLM false Whether this search engine requires an LLM. SEARCH
search.engine.web.federal_register.strengths LDR_SEARCH_ENGINE_WEB_FEDERAL_REGISTER_STRENGTHS ["FederalRegister.gov informational edition, not the official legal edition", "Searches rules, proposed rules, notices, and presidential documents", "Verify against GovInfo for legal reliance", "No API key required"] Strengths of this search engine. SEARCH
search.engine.web.federal_register.supports_full_search LDR_SEARCH_ENGINE_WEB_FEDERAL_REGISTER_SUPPORTS_FULL_SEARCH false Whether this search engine supports generic full document search. SEARCH
search.engine.web.federal_register.use_in_auto_search LDR_SEARCH_ENGINE_WEB_FEDERAL_REGISTER_USE_IN_AUTO_SEARCH false Include Federal Register in auto search mode. SEARCH
search.engine.web.federal_register.weaknesses LDR_SEARCH_ENGINE_WEB_FEDERAL_REGISTER_WEAKNESSES ["Focused on Federal Register documents", "API requests are limited to 20 results by the adapter"] Weaknesses of this search engine. SEARCH
search.engine.web.github.agent_enabled LDR_SEARCH_ENGINE_WEB_GITHUB_AGENT_ENABLED false Include GitHub as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.github.api_key LDR_SEARCH_ENGINE_WEB_GITHUB_API_KEY `` GitHub Personal Access Token for API authentication. Without this, you're limited to 10 requests/minute for search API. With authentication, you get 30 requests/minute for search API. SEARCH
search.engine.web.github.default_params.include_issues LDR_SEARCH_ENGINE_WEB_GITHUB_DEFAULT_PARAMS_INCLUDE_ISSUES false Include recent GitHub issues in repository search results. SEARCH
search.engine.web.github.default_params.include_readme LDR_SEARCH_ENGINE_WEB_GITHUB_DEFAULT_PARAMS_INCLUDE_README true Fetch and include README content when searching repositories. SEARCH
search.engine.web.github.default_params.max_results LDR_SEARCH_ENGINE_WEB_GITHUB_DEFAULT_PARAMS_MAX_RESULTS 15 Maximum number of GitHub results to retrieve per search. SEARCH
search.engine.web.github.default_params.search_type LDR_SEARCH_ENGINE_WEB_GITHUB_DEFAULT_PARAMS_SEARCH_TYPE repositories What to search on GitHub: 'repositories', 'code', 'issues', or 'users'. SEARCH
search.engine.web.github.description LDR_SEARCH_ENGINE_WEB_GITHUB_DESCRIPTION Search projects on Github. Human-readable description of the search engine. SEARCH
search.engine.web.github.display_name LDR_SEARCH_ENGINE_WEB_GITHUB_DISPLAY_NAME Github Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.github.reliability LDR_SEARCH_ENGINE_WEB_GITHUB_RELIABILITY 0.99 Reliability rating (0-1) for GitHub as a source. Great for code and technical projects. SEARCH
search.engine.web.github.requires_api_key LDR_SEARCH_ENGINE_WEB_GITHUB_REQUIRES_API_KEY true Whether GitHub requires a personal access token. Optional but recommended for higher rate limits (10→30 req/min). SEARCH
search.engine.web.github.strengths LDR_SEARCH_ENGINE_WEB_GITHUB_STRENGTHS ["code repositories", "software documentation", "open source projects", "programming issues", "developer information", "technical documentation"] Key advantages of GitHub: Excellent for code/technical queries, includes README content, issue discussions, works without API key. SEARCH
search.engine.web.github.supports_full_search LDR_SEARCH_ENGINE_WEB_GITHUB_SUPPORTS_FULL_SEARCH true Whether GitHub supports fetching full content (README, code files) beyond basic search results. SEARCH
search.engine.web.github.use_in_auto_search LDR_SEARCH_ENGINE_WEB_GITHUB_USE_IN_AUTO_SEARCH true Include GitHub in auto search mode SEARCH
search.engine.web.github.weaknesses LDR_SEARCH_ENGINE_WEB_GITHUB_WEAKNESSES ["non-technical content", "content outside GitHub", "rate limits without API key"] Limitations of GitHub: Limited to code/technical content, strict rate limits without authentication. SEARCH
search.engine.web.google_pse.agent_enabled LDR_SEARCH_ENGINE_WEB_GOOGLE_PSE_AGENT_ENABLED true Include Google PSE as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.google_pse.api_key LDR_SEARCH_ENGINE_WEB_GOOGLE_PSE_API_KEY `` The Google PSE API key to use. SEARCH
search.engine.web.google_pse.default_params.region LDR_SEARCH_ENGINE_WEB_GOOGLE_PSE_DEFAULT_PARAMS_REGION us Geographic region for search results (e.g., 'us', 'uk', 'de'). Results prioritized from this region. SEARCH
search.engine.web.google_pse.default_params.safe_search LDR_SEARCH_ENGINE_WEB_GOOGLE_PSE_DEFAULT_PARAMS_SAFE_SEARCH true Enable Google SafeSearch to filter explicit content from results. SEARCH
search.engine.web.google_pse.default_params.search_language LDR_SEARCH_ENGINE_WEB_GOOGLE_PSE_DEFAULT_PARAMS_SEARCH_LANGUAGE English Language for search queries and results (e.g., 'English', 'German'). Filters results by language. SEARCH
search.engine.web.google_pse.description LDR_SEARCH_ENGINE_WEB_GOOGLE_PSE_DESCRIPTION Search the web using Google's Programmable Search Engine API. Human-readable description of the search engine. SEARCH
search.engine.web.google_pse.display_name LDR_SEARCH_ENGINE_WEB_GOOGLE_PSE_DISPLAY_NAME Google PSE Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.google_pse.reliability LDR_SEARCH_ENGINE_WEB_GOOGLE_PSE_RELIABILITY 0.9 Reliability score (0-1) indicating result quality. Google PSE is highly reliable (0.9) due to Google's indexing quality. SEARCH
search.engine.web.google_pse.requires_api_key LDR_SEARCH_ENGINE_WEB_GOOGLE_PSE_REQUIRES_API_KEY true Indicates this engine requires a Google API key and Custom Search Engine ID. Get credentials from Google Cloud Console. SEARCH
search.engine.web.google_pse.strengths LDR_SEARCH_ENGINE_WEB_GOOGLE_PSE_STRENGTHS ["custom search scope", "high-quality results", "domain-specific search", "configurable search experience", "control over search index"] Advantages of Google PSE: Custom search scope, high-quality results, domain-specific filtering, configurable search experience. SEARCH
search.engine.web.google_pse.supports_full_search LDR_SEARCH_ENGINE_WEB_GOOGLE_PSE_SUPPORTS_FULL_SEARCH true Indicates this engine can fetch full page content after initial search, not just snippets. SEARCH
search.engine.web.google_pse.use_in_auto_search LDR_SEARCH_ENGINE_WEB_GOOGLE_PSE_USE_IN_AUTO_SEARCH false Include Google PSE in auto search mode SEARCH
search.engine.web.google_pse.weaknesses LDR_SEARCH_ENGINE_WEB_GOOGLE_PSE_WEAKNESSES ["requires API key with usage limits", "limited to 10,000 queries/day on free tier", "requires search engine configuration in Google Control Panel"] Limitations: Requires API key, limited to 10,000 queries/day on free tier, requires search engine configuration in Google Control Panel. SEARCH
search.engine.web.gutenberg LDR_SEARCH_ENGINE_WEB_GUTENBERG {"requires_api_key": false, "requires_llm": true, "description": "Search 70,000+ free public domain books with full text via Gutendex.", "reliability": 0.95} Project Gutenberg search engine configuration SEARCH
search.engine.web.gutenberg.agent_enabled LDR_SEARCH_ENGINE_WEB_GUTENBERG_AGENT_ENABLED false Include Project Gutenberg as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.gutenberg.default_params.max_results LDR_SEARCH_ENGINE_WEB_GUTENBERG_DEFAULT_PARAMS_MAX_RESULTS 20 Maximum number of results to retrieve from Project Gutenberg. SEARCH
search.engine.web.gutenberg.description LDR_SEARCH_ENGINE_WEB_GUTENBERG_DESCRIPTION Search 70,000+ free public domain books with full text via Gutendex. Human-readable description of the search engine. SEARCH
search.engine.web.gutenberg.display_name LDR_SEARCH_ENGINE_WEB_GUTENBERG_DISPLAY_NAME Project Gutenberg Display name for Project Gutenberg search engine. SEARCH
search.engine.web.gutenberg.reliability LDR_SEARCH_ENGINE_WEB_GUTENBERG_RELIABILITY 0.95 Reliability score for Project Gutenberg. SEARCH
search.engine.web.gutenberg.requires_api_key LDR_SEARCH_ENGINE_WEB_GUTENBERG_REQUIRES_API_KEY false Project Gutenberg is free and does not require an API key. SEARCH
search.engine.web.gutenberg.strengths LDR_SEARCH_ENGINE_WEB_GUTENBERG_STRENGTHS ["public domain", "full text", "classic literature", "free ebooks", "multiple formats"] Key strengths of Project Gutenberg. SEARCH
search.engine.web.gutenberg.use_in_auto_search LDR_SEARCH_ENGINE_WEB_GUTENBERG_USE_IN_AUTO_SEARCH false Include Project Gutenberg in auto search mode SEARCH
search.engine.web.gutenberg.weaknesses LDR_SEARCH_ENGINE_WEB_GUTENBERG_WEAKNESSES ["public domain only", "older works", "limited modern titles"] Limitations of Project Gutenberg. SEARCH
search.engine.web.mojeek.agent_enabled LDR_SEARCH_ENGINE_WEB_MOJEEK_AGENT_ENABLED true Include Mojeek as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.mojeek.api_key LDR_SEARCH_ENGINE_WEB_MOJEEK_API_KEY `` The Mojeek API key to use. Get one at mojeek.com/services/api. SEARCH
search.engine.web.mojeek.default_params.language LDR_SEARCH_ENGINE_WEB_MOJEEK_DEFAULT_PARAMS_LANGUAGE en Language code in ISO 639-1 format for Mojeek language boost (e.g., 'en', 'fr'). SEARCH
search.engine.web.mojeek.default_params.region LDR_SEARCH_ENGINE_WEB_MOJEEK_DEFAULT_PARAMS_REGION `` Country code in ISO 3166-1 alpha-2 format for Mojeek region boost (e.g., 'GB', 'US'). SEARCH
search.engine.web.mojeek.default_params.safe_search LDR_SEARCH_ENGINE_WEB_MOJEEK_DEFAULT_PARAMS_SAFE_SEARCH false Enable safe search filtering for Mojeek to exclude adult content. SEARCH
search.engine.web.mojeek.description LDR_SEARCH_ENGINE_WEB_MOJEEK_DESCRIPTION Privacy-focused search engine with its own independent web index. Human-readable description of the search engine. SEARCH
search.engine.web.mojeek.display_name LDR_SEARCH_ENGINE_WEB_MOJEEK_DISPLAY_NAME Mojeek Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.mojeek.reliability LDR_SEARCH_ENGINE_WEB_MOJEEK_RELIABILITY 0.65 Reliability rating (0-1) for Mojeek. Independent index, smaller than Google/Bing. SEARCH
search.engine.web.mojeek.requires_api_key LDR_SEARCH_ENGINE_WEB_MOJEEK_REQUIRES_API_KEY true Whether Mojeek requires an API key. Yes - get one at mojeek.com/services/api. SEARCH
search.engine.web.mojeek.strengths LDR_SEARCH_ENGINE_WEB_MOJEEK_STRENGTHS ["privacy-focused with own index", "no tracking or profiling", "independent results", "European-based"] Key advantages of Mojeek: Privacy-focused with own independent web index, no tracking. SEARCH
search.engine.web.mojeek.supports_full_search LDR_SEARCH_ENGINE_WEB_MOJEEK_SUPPORTS_FULL_SEARCH true Whether Mojeek supports fetching full webpage content beyond snippets. SEARCH
search.engine.web.mojeek.use_in_auto_search LDR_SEARCH_ENGINE_WEB_MOJEEK_USE_IN_AUTO_SEARCH false Include Mojeek in auto search mode SEARCH
search.engine.web.mojeek.weaknesses LDR_SEARCH_ENGINE_WEB_MOJEEK_WEAKNESSES ["smaller index than Google/Bing", "requires paid API key"] Limitations of Mojeek: Smaller index than Google/Bing, requires paid API key. SEARCH
search.engine.web.nasa_ads LDR_SEARCH_ENGINE_WEB_NASA_ADS {"requires_api_key": true, "requires_llm": true, "description": "Search millions of astronomy and physics papers with natural language queries", "reliability": 0.95} NASA Astrophysics Data System search engine configuration SEARCH
search.engine.web.nasa_ads.agent_enabled LDR_SEARCH_ENGINE_WEB_NASA_ADS_AGENT_ENABLED false Include NASA ADS as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.nasa_ads.api_key LDR_SEARCH_ENGINE_WEB_NASA_ADS_API_KEY `` NASA ADS API key (required). Get one at https://ui.adsabs.harvard.edu/user/settings/token SEARCH
search.engine.web.nasa_ads.default_params.from_publication_date LDR_SEARCH_ENGINE_WEB_NASA_ADS_DEFAULT_PARAMS_FROM_PUBLICATION_DATE `` Only return papers published after this date (YYYY-MM-DD format, leave empty for all dates) SEARCH
search.engine.web.nasa_ads.default_params.include_arxiv LDR_SEARCH_ENGINE_WEB_NASA_ADS_DEFAULT_PARAMS_INCLUDE_ARXIV true Include ArXiv preprints in search results SEARCH
search.engine.web.nasa_ads.default_params.max_results LDR_SEARCH_ENGINE_WEB_NASA_ADS_DEFAULT_PARAMS_MAX_RESULTS 25 Maximum number of results to retrieve from NASA ADS SEARCH
search.engine.web.nasa_ads.default_params.min_citations LDR_SEARCH_ENGINE_WEB_NASA_ADS_DEFAULT_PARAMS_MIN_CITATIONS 0 Minimum number of citations required (0 for no filter) SEARCH
search.engine.web.nasa_ads.default_params.sort_by LDR_SEARCH_ENGINE_WEB_NASA_ADS_DEFAULT_PARAMS_SORT_BY relevance How to sort the search results SEARCH
search.engine.web.nasa_ads.description LDR_SEARCH_ENGINE_WEB_NASA_ADS_DESCRIPTION NASA Astrophysics Data System - comprehensive database of astronomy, astrophysics, physics, and geophysics papers. Includes both ArXiv preprints and published papers. Human-readable description of the search engine. SEARCH
search.engine.web.nasa_ads.display_name LDR_SEARCH_ENGINE_WEB_NASA_ADS_DISPLAY_NAME NASA ADS Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.nasa_ads.journal_reputation.enabled LDR_SEARCH_ENGINE_WEB_NASA_ADS_JOURNAL_REPUTATION_ENABLED true Enable journal quality filtering for this search engine. SEARCH
search.engine.web.nasa_ads.reliability LDR_SEARCH_ENGINE_WEB_NASA_ADS_RELIABILITY 0.95 Reliability score for NASA ADS search results (0.0-1.0, higher is better) SEARCH
search.engine.web.nasa_ads.requires_api_key LDR_SEARCH_ENGINE_WEB_NASA_ADS_REQUIRES_API_KEY true Whether NASA ADS requires an API key (always true for NASA ADS) SEARCH
search.engine.web.nasa_ads.strengths LDR_SEARCH_ENGINE_WEB_NASA_ADS_STRENGTHS ["astronomy papers", "astrophysics research", "physics papers", "space science", "planetary science", "cosmology", "high energy physics", "historical papers", "citation tracking", "natural language queries"] List of research areas where NASA ADS excels SEARCH
search.engine.web.nasa_ads.use_in_auto_search LDR_SEARCH_ENGINE_WEB_NASA_ADS_USE_IN_AUTO_SEARCH false Include NASA ADS in auto search mode SEARCH
search.engine.web.nasa_ads.weaknesses LDR_SEARCH_ENGINE_WEB_NASA_ADS_WEAKNESSES ["biomedical content", "computer science papers", "social sciences", "humanities", "requires API key for good performance"] List of research areas where NASA ADS has limited coverage SEARCH
search.engine.web.openalex LDR_SEARCH_ENGINE_WEB_OPENALEX {"requires_api_key": false, "requires_llm": true, "description": "Search 250+ million academic papers with natural language queries", "reliability": 0.95} OpenAlex academic search engine configuration SEARCH
search.engine.web.openalex.agent_enabled LDR_SEARCH_ENGINE_WEB_OPENALEX_AGENT_ENABLED true Include OpenAlex as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.openalex.api_key LDR_SEARCH_ENGINE_WEB_OPENALEX_API_KEY `` OpenAlex API key (optional but recommended). Raises the daily request budget 10x. Get a free key at https://openalex.org/settings/api. The old email 'polite pool' was deprecated by OpenAlex in February 2026 and no longer has any effect. SEARCH
search.engine.web.openalex.default_params.filter_open_access LDR_SEARCH_ENGINE_WEB_OPENALEX_DEFAULT_PARAMS_FILTER_OPEN_ACCESS false Only return open access papers that are freely available SEARCH
search.engine.web.openalex.default_params.from_publication_date LDR_SEARCH_ENGINE_WEB_OPENALEX_DEFAULT_PARAMS_FROM_PUBLICATION_DATE `` Only return papers published after this date (YYYY-MM-DD format, leave empty for all dates) SEARCH
search.engine.web.openalex.default_params.max_results LDR_SEARCH_ENGINE_WEB_OPENALEX_DEFAULT_PARAMS_MAX_RESULTS 25 Maximum number of results to retrieve from OpenAlex SEARCH
search.engine.web.openalex.default_params.min_citations LDR_SEARCH_ENGINE_WEB_OPENALEX_DEFAULT_PARAMS_MIN_CITATIONS 0 Minimum number of citations required (0 for no filter) SEARCH
search.engine.web.openalex.default_params.sort_by LDR_SEARCH_ENGINE_WEB_OPENALEX_DEFAULT_PARAMS_SORT_BY relevance How to sort the search results SEARCH
search.engine.web.openalex.description LDR_SEARCH_ENGINE_WEB_OPENALEX_DESCRIPTION Search 250+ million academic papers with natural language queries. Comprehensive scholarly database covering all disciplines. Human-readable description of the search engine. SEARCH
search.engine.web.openalex.display_name LDR_SEARCH_ENGINE_WEB_OPENALEX_DISPLAY_NAME OpenAlex Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.openalex.email LDR_SEARCH_ENGINE_WEB_OPENALEX_EMAIL `` OpenAlex deprecated the email 'polite pool' in February 2026. This email is now included only in the User-Agent for identification; configure an API key instead to raise the daily request budget. SEARCH
search.engine.web.openalex.journal_reputation.enabled LDR_SEARCH_ENGINE_WEB_OPENALEX_JOURNAL_REPUTATION_ENABLED true Enable journal quality filtering for this search engine. SEARCH
search.engine.web.openalex.reliability LDR_SEARCH_ENGINE_WEB_OPENALEX_RELIABILITY 0.95 Reliability score for OpenAlex search results (0.0-1.0, higher is better) SEARCH
search.engine.web.openalex.requires_api_key LDR_SEARCH_ENGINE_WEB_OPENALEX_REQUIRES_API_KEY false Whether OpenAlex requires an API key (always false for OpenAlex) SEARCH
search.engine.web.openalex.strengths LDR_SEARCH_ENGINE_WEB_OPENALEX_STRENGTHS ["academic papers", "scholarly research", "natural language queries", "all disciplines", "citation analysis", "open access content", "comprehensive coverage", "works without an API key", "free API key raises the daily request budget"] List of research areas where OpenAlex excels SEARCH
search.engine.web.openalex.use_in_auto_search LDR_SEARCH_ENGINE_WEB_OPENALEX_USE_IN_AUTO_SEARCH true Include OpenAlex in auto search mode SEARCH
search.engine.web.openalex.weaknesses LDR_SEARCH_ENGINE_WEB_OPENALEX_WEAKNESSES ["non-academic content", "news articles", "general web content", "real-time information"] List of content types where OpenAlex has limited coverage SEARCH
search.engine.web.openlibrary LDR_SEARCH_ENGINE_WEB_OPENLIBRARY {"requires_api_key": false, "requires_llm": true, "description": "Search 2M+ books with metadata, covers, and full text from Internet Archive.", "reliability": 0.9} Open Library search engine configuration SEARCH
search.engine.web.openlibrary.agent_enabled LDR_SEARCH_ENGINE_WEB_OPENLIBRARY_AGENT_ENABLED false Include Open Library as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.openlibrary.default_params.max_results LDR_SEARCH_ENGINE_WEB_OPENLIBRARY_DEFAULT_PARAMS_MAX_RESULTS 20 Maximum number of results to retrieve from Open Library. SEARCH
search.engine.web.openlibrary.description LDR_SEARCH_ENGINE_WEB_OPENLIBRARY_DESCRIPTION Search 2M+ books with metadata, covers, and full text from Internet Archive. Human-readable description of the search engine. SEARCH
search.engine.web.openlibrary.display_name LDR_SEARCH_ENGINE_WEB_OPENLIBRARY_DISPLAY_NAME Open Library Display name for Open Library search engine. SEARCH
search.engine.web.openlibrary.reliability LDR_SEARCH_ENGINE_WEB_OPENLIBRARY_RELIABILITY 0.9 Reliability score for Open Library. SEARCH
search.engine.web.openlibrary.requires_api_key LDR_SEARCH_ENGINE_WEB_OPENLIBRARY_REQUIRES_API_KEY false Open Library is free and does not require an API key. SEARCH
search.engine.web.openlibrary.strengths LDR_SEARCH_ENGINE_WEB_OPENLIBRARY_STRENGTHS ["books", "literature", "metadata", "covers", "full text", "Internet Archive"] Key strengths of Open Library. SEARCH
search.engine.web.openlibrary.use_in_auto_search LDR_SEARCH_ENGINE_WEB_OPENLIBRARY_USE_IN_AUTO_SEARCH false Include Open Library in auto search mode SEARCH
search.engine.web.openlibrary.weaknesses LDR_SEARCH_ENGINE_WEB_OPENLIBRARY_WEAKNESSES ["books only", "variable metadata quality", "English focus"] Limitations of Open Library. SEARCH
search.engine.web.paperless.agent_enabled LDR_SEARCH_ENGINE_WEB_PAPERLESS_AGENT_ENABLED false Include Paperless as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.paperless.api_key PAPERLESS_API_TOKEN `` API key for authentication (get from Paperless admin panel) SEARCH
search.engine.web.paperless.default_params.api_url LDR_SEARCH_ENGINE_WEB_PAPERLESS_DEFAULT_PARAMS_API_URL http://localhost:8000 URL of your Paperless-ngx instance (e.g., http://localhost:8000) SEARCH
search.engine.web.paperless.default_params.include_content LDR_SEARCH_ENGINE_WEB_PAPERLESS_DEFAULT_PARAMS_INCLUDE_CONTENT true Include full document content (not just snippets) SEARCH
search.engine.web.paperless.default_params.max_results LDR_SEARCH_ENGINE_WEB_PAPERLESS_DEFAULT_PARAMS_MAX_RESULTS 10 Maximum number of documents to return SEARCH
search.engine.web.paperless.default_params.timeout LDR_SEARCH_ENGINE_WEB_PAPERLESS_DEFAULT_PARAMS_TIMEOUT 30 Request timeout in seconds SEARCH
search.engine.web.paperless.default_params.verify_ssl LDR_SEARCH_ENGINE_WEB_PAPERLESS_DEFAULT_PARAMS_VERIFY_SSL true Verify SSL certificates (disable for self-signed certs) SEARCH
search.engine.web.paperless.description LDR_SEARCH_ENGINE_WEB_PAPERLESS_DESCRIPTION Search your personal Paperless-ngx document archive. Human-readable description of the search engine. SEARCH
search.engine.web.paperless.display_name LDR_SEARCH_ENGINE_WEB_PAPERLESS_DISPLAY_NAME Paperless Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.paperless.enabled LDR_SEARCH_ENGINE_WEB_PAPERLESS_ENABLED false Enable or disable this search engine SEARCH
search.engine.web.paperless.reliability LDR_SEARCH_ENGINE_WEB_PAPERLESS_RELIABILITY 0.95 Reliability score for this search engine SEARCH
search.engine.web.paperless.requires_api_key LDR_SEARCH_ENGINE_WEB_PAPERLESS_REQUIRES_API_KEY true Whether this engine requires an API key SEARCH
search.engine.web.paperless.requires_llm LDR_SEARCH_ENGINE_WEB_PAPERLESS_REQUIRES_LLM true Whether this engine requires an LLM for operation SEARCH
search.engine.web.paperless.strengths LDR_SEARCH_ENGINE_WEB_PAPERLESS_STRENGTHS ["personal documents", "OCR-processed content", "tagged and organized", "full-text search", "no rate limits", "private data"] Strengths of this search engine SEARCH
search.engine.web.paperless.supports_full_search LDR_SEARCH_ENGINE_WEB_PAPERLESS_SUPPORTS_FULL_SEARCH true Whether this engine supports full document search SEARCH
search.engine.web.paperless.use_in_auto_search LDR_SEARCH_ENGINE_WEB_PAPERLESS_USE_IN_AUTO_SEARCH false Include Paperless in auto search mode SEARCH
search.engine.web.paperless.weaknesses LDR_SEARCH_ENGINE_WEB_PAPERLESS_WEAKNESSES ["keyword-based search only", "no semantic understanding", "limited query operators"] Weaknesses of this search engine SEARCH
search.engine.web.pubchem LDR_SEARCH_ENGINE_WEB_PUBCHEM {"requires_api_key": false, "requires_llm": true, "description": "Search millions of chemical compounds with structures, properties, and bioactivity data.", "reliability": 0.95} PubChem search engine configuration SEARCH
search.engine.web.pubchem.agent_enabled LDR_SEARCH_ENGINE_WEB_PUBCHEM_AGENT_ENABLED false Include PubChem as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.pubchem.default_params.include_synonyms LDR_SEARCH_ENGINE_WEB_PUBCHEM_DEFAULT_PARAMS_INCLUDE_SYNONYMS true Include compound synonyms in full content results. SEARCH
search.engine.web.pubchem.default_params.max_results LDR_SEARCH_ENGINE_WEB_PUBCHEM_DEFAULT_PARAMS_MAX_RESULTS 10 Maximum number of results to retrieve from PubChem. SEARCH
search.engine.web.pubchem.description LDR_SEARCH_ENGINE_WEB_PUBCHEM_DESCRIPTION Search millions of chemical compounds with structures, properties, and bioactivity data. Human-readable description of the search engine. SEARCH
search.engine.web.pubchem.display_name LDR_SEARCH_ENGINE_WEB_PUBCHEM_DISPLAY_NAME PubChem Display name for PubChem search engine. SEARCH
search.engine.web.pubchem.reliability LDR_SEARCH_ENGINE_WEB_PUBCHEM_RELIABILITY 0.95 Reliability score for PubChem. SEARCH
search.engine.web.pubchem.requires_api_key LDR_SEARCH_ENGINE_WEB_PUBCHEM_REQUIRES_API_KEY false PubChem is free and does not require an API key. SEARCH
search.engine.web.pubchem.strengths LDR_SEARCH_ENGINE_WEB_PUBCHEM_STRENGTHS ["chemistry", "compounds", "drug information", "molecular properties", "bioactivity"] Key strengths of PubChem. SEARCH
search.engine.web.pubchem.use_in_auto_search LDR_SEARCH_ENGINE_WEB_PUBCHEM_USE_IN_AUTO_SEARCH false Include PubChem in auto search mode SEARCH
search.engine.web.pubchem.weaknesses LDR_SEARCH_ENGINE_WEB_PUBCHEM_WEAKNESSES ["chemistry only", "technical data", "requires chemical knowledge"] Limitations of PubChem. SEARCH
search.engine.web.pubmed.agent_enabled LDR_SEARCH_ENGINE_WEB_PUBMED_AGENT_ENABLED true Include PubMed as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.pubmed.api_key LDR_SEARCH_ENGINE_WEB_PUBMED_API_KEY `` The PubMed API key to use. SEARCH
search.engine.web.pubmed.default_params.days_limit LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_DAYS_LIMIT 0 Restrict results to articles published within the last N days. Leave empty for no time restriction. SEARCH
search.engine.web.pubmed.default_params.full_text_limit LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_FULL_TEXT_LIMIT 3 Maximum number of full-text articles to download from PubMed Central when get_full_text is enabled. SEARCH
search.engine.web.pubmed.default_params.get_abstracts LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_GET_ABSTRACTS true Fetch article abstracts for search results. Recommended for understanding paper content. SEARCH
search.engine.web.pubmed.default_params.get_full_text LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_GET_FULL_TEXT false Attempt to retrieve full-text articles from PubMed Central (PMC). Only works for open-access papers. SEARCH
search.engine.web.pubmed.default_params.include_authors_in_context LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_INCLUDE_AUTHORS_IN_CONTEXT false Include author names in context for analysis SEARCH
search.engine.web.pubmed.default_params.include_citation_in_context LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_INCLUDE_CITATION_IN_CONTEXT false Include volume, issue, and pages in context for analysis SEARCH
search.engine.web.pubmed.default_params.include_doi_in_context LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_INCLUDE_DOI_IN_CONTEXT false Include DOI (Digital Object Identifier) in context for analysis SEARCH
search.engine.web.pubmed.default_params.include_full_date_in_context LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_INCLUDE_FULL_DATE_IN_CONTEXT false Include full publication date in context for analysis SEARCH
search.engine.web.pubmed.default_params.include_journal_in_context LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_INCLUDE_JOURNAL_IN_CONTEXT true Include journal name in context for analysis SEARCH
search.engine.web.pubmed.default_params.include_keywords_in_context LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_INCLUDE_KEYWORDS_IN_CONTEXT true Include article keywords in context for analysis SEARCH
search.engine.web.pubmed.default_params.include_language_in_context LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_INCLUDE_LANGUAGE_IN_CONTEXT false Include language indicator in context for analysis SEARCH
search.engine.web.pubmed.default_params.include_mesh_terms_in_context LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_INCLUDE_MESH_TERMS_IN_CONTEXT true Include MeSH terms (medical subject headings) in context for analysis SEARCH
search.engine.web.pubmed.default_params.include_pmc_availability_in_context LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_INCLUDE_PMC_AVAILABILITY_IN_CONTEXT false Include PMC free full text availability in context for analysis SEARCH
search.engine.web.pubmed.default_params.include_pmid_in_context LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_INCLUDE_PMID_IN_CONTEXT false Include PubMed ID in context for analysis SEARCH
search.engine.web.pubmed.default_params.include_publication_type_in_context LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_INCLUDE_PUBLICATION_TYPE_IN_CONTEXT true Include publication type (e.g., Clinical Trial, Meta-Analysis) in context for analysis SEARCH
search.engine.web.pubmed.default_params.include_year_in_context LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_INCLUDE_YEAR_IN_CONTEXT true Include publication year in context for analysis SEARCH
search.engine.web.pubmed.default_params.max_keywords LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_MAX_KEYWORDS 3 Maximum number of keywords to show (0 = all) SEARCH
search.engine.web.pubmed.default_params.max_mesh_terms LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_MAX_MESH_TERMS 3 Maximum number of MeSH terms to show (0 = all) SEARCH
search.engine.web.pubmed.default_params.max_results LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_MAX_RESULTS 20 Maximum number of PubMed articles to retrieve per search query. SEARCH
search.engine.web.pubmed.default_params.optimize_queries LDR_SEARCH_ENGINE_WEB_PUBMED_DEFAULT_PARAMS_OPTIMIZE_QUERIES true Automatically optimize natural language queries for PubMed's specialized syntax (MeSH terms, Boolean operators). SEARCH
search.engine.web.pubmed.description LDR_SEARCH_ENGINE_WEB_PUBMED_DESCRIPTION Search papers indexed by PubMed. Human-readable description of the search engine. SEARCH
search.engine.web.pubmed.display_name LDR_SEARCH_ENGINE_WEB_PUBMED_DISPLAY_NAME PubMed Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.pubmed.reliability LDR_SEARCH_ENGINE_WEB_PUBMED_RELIABILITY 0.98 Reliability rating (0-1) for PubMed. Peer-reviewed biomedical literature is highly reliable. SEARCH
search.engine.web.pubmed.requires_api_key LDR_SEARCH_ENGINE_WEB_PUBMED_REQUIRES_API_KEY false Whether PubMed requires an NCBI API key. Optional but recommended for higher rate limits. SEARCH
search.engine.web.pubmed.requires_llm LDR_SEARCH_ENGINE_WEB_PUBMED_REQUIRES_LLM true Whether PubMed query optimization uses LLM. Helps convert natural language to effective PubMed queries. SEARCH
search.engine.web.pubmed.strengths LDR_SEARCH_ENGINE_WEB_PUBMED_STRENGTHS ["biomedical literature", "medical research", "clinical studies", "life sciences", "health information", "scientific papers"] Key advantages of PubMed: Peer-reviewed biomedical literature, MeSH indexing, abstracts, citation data, free access. SEARCH
search.engine.web.pubmed.use_in_auto_search LDR_SEARCH_ENGINE_WEB_PUBMED_USE_IN_AUTO_SEARCH true Include PubMed in auto search mode SEARCH
search.engine.web.pubmed.weaknesses LDR_SEARCH_ENGINE_WEB_PUBMED_WEAKNESSES ["non-medical topics", "very recent papers may be missing", "limited to published research"] Limitations of PubMed: Limited to biomedical literature, keyword-based search, full-text only for open-access papers. SEARCH
search.engine.web.scaleserp.agent_enabled LDR_SEARCH_ENGINE_WEB_SCALESERP_AGENT_ENABLED true Include Scale SERP as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.scaleserp.api_key LDR_SEARCH_ENGINE_WEB_SCALESERP_API_KEY `` The ScaleSerp API key to use. Get yours at https://scaleserp.com SEARCH
search.engine.web.scaleserp.default_params.device LDR_SEARCH_ENGINE_WEB_SCALESERP_DEFAULT_PARAMS_DEVICE desktop Device type for search results SEARCH
search.engine.web.scaleserp.default_params.enable_cache LDR_SEARCH_ENGINE_WEB_SCALESERP_DEFAULT_PARAMS_ENABLE_CACHE true Enable 1-hour caching to save API credits (cached searches are FREE within 1 hour) SEARCH
search.engine.web.scaleserp.default_params.include_full_content LDR_SEARCH_ENGINE_WEB_SCALESERP_DEFAULT_PARAMS_INCLUDE_FULL_CONTENT false Include full webpage content in results (may slow down search) SEARCH
search.engine.web.scaleserp.default_params.language LDR_SEARCH_ENGINE_WEB_SCALESERP_DEFAULT_PARAMS_LANGUAGE en Language code for search results (e.g., 'en', 'es', 'fr') SEARCH
search.engine.web.scaleserp.default_params.location LDR_SEARCH_ENGINE_WEB_SCALESERP_DEFAULT_PARAMS_LOCATION United States Location for localized results (e.g., 'United States', 'London,England,United Kingdom') SEARCH
search.engine.web.scaleserp.default_params.safe_search LDR_SEARCH_ENGINE_WEB_SCALESERP_DEFAULT_PARAMS_SAFE_SEARCH true Enable or disable safe search filtering SEARCH
search.engine.web.scaleserp.description LDR_SEARCH_ENGINE_WEB_SCALESERP_DESCRIPTION Cost-effective Google Search API with 1-hour free caching that can reduce costs by 40-70% for repeated searches. Human-readable description of the search engine. SEARCH
search.engine.web.scaleserp.display_name LDR_SEARCH_ENGINE_WEB_SCALESERP_DISPLAY_NAME ScaleSerp Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.scaleserp.reliability LDR_SEARCH_ENGINE_WEB_SCALESERP_RELIABILITY 0.95 Reliability of the ScaleSerp search engine SEARCH
search.engine.web.scaleserp.requires_api_key LDR_SEARCH_ENGINE_WEB_SCALESERP_REQUIRES_API_KEY true Whether this search engine requires an API key SEARCH
search.engine.web.scaleserp.requires_llm LDR_SEARCH_ENGINE_WEB_SCALESERP_REQUIRES_LLM false Whether this search engine requires an LLM for relevance filtering SEARCH
search.engine.web.scaleserp.strengths LDR_SEARCH_ENGINE_WEB_SCALESERP_STRENGTHS ["1-hour free caching for repeated searches", "High-quality Google search results", "Real-time results with knowledge graph", "Cached searches don't count against quota", "Rich snippets and related questions"] Strengths of this search engine SEARCH
search.engine.web.scaleserp.supports_full_search LDR_SEARCH_ENGINE_WEB_SCALESERP_SUPPORTS_FULL_SEARCH true Whether this search engine supports full document search SEARCH
search.engine.web.scaleserp.use_in_auto_search LDR_SEARCH_ENGINE_WEB_SCALESERP_USE_IN_AUTO_SEARCH false Include Scale SERP in auto search mode SEARCH
search.engine.web.scaleserp.weaknesses LDR_SEARCH_ENGINE_WEB_SCALESERP_WEAKNESSES ["Requires API key with usage limits", "Not specialized for academic content", "Cache only lasts 1 hour"] Weaknesses of this search engine SEARCH
search.engine.web.searxng.agent_enabled LDR_SEARCH_ENGINE_WEB_SEARXNG_AGENT_ENABLED true Include SearXNG as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.searxng.default_params.categories LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_CATEGORIES ["general"] SearXNG search categories to use (general, images, videos, news, music, files, etc.). SEARCH
search.engine.web.searxng.default_params.delay_between_requests SEARXNG_DELAY 0 Seconds to wait between SearXNG requests. Set higher values to avoid rate limiting on public instances. SEARCH
search.engine.web.searxng.default_params.engines LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_ENGINES [] Optional list of SearXNG engines to restrict searches to (e.g. ["kagi", "brave", "wikipedia", "arxiv"] — this field is JSON, so the names must be double-quoted). When empty (default), SearXNG uses all of its own configured engines. Names must match the engines enabled on your SearXNG instance — see /engines on the instance for the full list. SEARCH
search.engine.web.searxng.default_params.include_full_content LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_INCLUDE_FULL_CONTENT true Fetch full webpage content for SearXNG results, not just snippets. SEARCH
search.engine.web.searxng.default_params.instance_url LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_INSTANCE_URL http://localhost:8080 The SearXNG API endpoint URL. A private / loopback / link-local URL (including the default http://localhost:8080) is only fetched when the operator lists its origin in LDR_SEARCH_PRIVATE_ENGINE_URL_ALLOWLIST, sets LDR_SEARCH_ALLOW_PRIVATE_ENGINE_URLS=true, or env-locks this URL via LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_INSTANCE_URL; otherwise the engine disables itself. Cloud-metadata addresses are always blocked. SEARCH
search.engine.web.searxng.default_params.language LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_LANGUAGE en Language code for SearXNG results (e.g., 'en', 'de', 'fr'). SEARCH
search.engine.web.searxng.default_params.max_results LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_MAX_RESULTS 15 Maximum number of results to retrieve from SearXNG per search. SEARCH
search.engine.web.searxng.default_params.result_format LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_RESULT_FORMAT html Response format to request from SearXNG. Use 'json' for instances that enable the JSON API but disable HTML output; 'html' scrapes the results page. SEARCH
search.engine.web.searxng.default_params.safe_search LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_SAFE_SEARCH OFF Configure the safe search level SEARCH
search.engine.web.searxng.description LDR_SEARCH_ENGINE_WEB_SEARXNG_DESCRIPTION A locally-hosted meta-search engine. Human-readable description of the search engine. SEARCH
search.engine.web.searxng.display_name LDR_SEARCH_ENGINE_WEB_SEARXNG_DISPLAY_NAME SearXNG (Locally-hosted) Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.searxng.reliability LDR_SEARCH_ENGINE_WEB_SEARXNG_RELIABILITY 1.0 Reliability rating (0-1) for SearXNG. Aggregates multiple search engines for broad coverage. SEARCH
search.engine.web.searxng.requires_api_key LDR_SEARCH_ENGINE_WEB_SEARXNG_REQUIRES_API_KEY false Whether SearXNG requires an API key. No - SearXNG is self-hosted and free. SEARCH
search.engine.web.searxng.strengths LDR_SEARCH_ENGINE_WEB_SEARXNG_STRENGTHS ["comprehensive general information", "current events and news", "technical documentation", "factual queries", "historical information", "consumer products", "educational content", "multi-source aggregation", "real-time results", "combined results from major search engines"] Key advantages of SearXNG: Free, self-hosted, privacy-respecting, aggregates multiple engines, no API limits. SEARCH
search.engine.web.searxng.supports_full_search LDR_SEARCH_ENGINE_WEB_SEARXNG_SUPPORTS_FULL_SEARCH true Whether SearXNG supports fetching full webpage content beyond snippets. SEARCH
search.engine.web.searxng.use_in_auto_search LDR_SEARCH_ENGINE_WEB_SEARXNG_USE_IN_AUTO_SEARCH true Include SearXNG in auto search mode SEARCH
search.engine.web.searxng.weaknesses LDR_SEARCH_ENGINE_WEB_SEARXNG_WEAKNESSES ["requires self-hosting", "depends on other search engines", "may be rate limited by underlying engines"] Limitations of SearXNG: Requires self-hosting, public instances may have rate limits, result quality varies. SEARCH
search.engine.web.semantic_scholar LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR {"requires_api_key": false, "requires_llm": true, "description": "Search millions of academic papers across all scientific fields with AI-powered features", "reliability": 0.9} Semantic Scholar search engine configuration SEARCH
search.engine.web.semantic_scholar.agent_enabled LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_AGENT_ENABLED true Include Semantic Scholar as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.semantic_scholar.api_key LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_API_KEY `` Semantic Scholar API key (optional but recommended for higher rate limits). Get one at https://www.semanticscholar.org/product/api SEARCH
search.engine.web.semantic_scholar.default_params.citation_limit LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_DEFAULT_PARAMS_CITATION_LIMIT 10 Maximum number of citations to fetch per paper SEARCH
search.engine.web.semantic_scholar.default_params.get_abstracts LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_DEFAULT_PARAMS_GET_ABSTRACTS true Fetch full abstracts for papers SEARCH
search.engine.web.semantic_scholar.default_params.get_citations LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_DEFAULT_PARAMS_GET_CITATIONS false Fetch citation information for papers SEARCH
search.engine.web.semantic_scholar.default_params.get_references LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_DEFAULT_PARAMS_GET_REFERENCES false Fetch reference information for papers SEARCH
search.engine.web.semantic_scholar.default_params.get_tldr LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_DEFAULT_PARAMS_GET_TLDR true Fetch AI-generated TLDR summaries for papers SEARCH
search.engine.web.semantic_scholar.default_params.max_results LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_DEFAULT_PARAMS_MAX_RESULTS 20 Maximum number of results to retrieve SEARCH
search.engine.web.semantic_scholar.default_params.optimize_queries LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_DEFAULT_PARAMS_OPTIMIZE_QUERIES true Use LLM to optimize natural language queries for better search results SEARCH
search.engine.web.semantic_scholar.default_params.reference_limit LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_DEFAULT_PARAMS_REFERENCE_LIMIT 10 Maximum number of references to fetch per paper SEARCH
search.engine.web.semantic_scholar.description LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_DESCRIPTION AI-powered search for scientific literature. Features include TLDR summaries, citation graphs, and semantic search across millions of papers. Human-readable description of the search engine. SEARCH
search.engine.web.semantic_scholar.display_name LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_DISPLAY_NAME Semantic Scholar Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.semantic_scholar.journal_reputation.enabled LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_JOURNAL_REPUTATION_ENABLED true Enable journal quality filtering for this search engine. SEARCH
search.engine.web.semantic_scholar.reliability LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_RELIABILITY 0.9 Reliability rating for the search engine SEARCH
search.engine.web.semantic_scholar.requires_api_key LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_REQUIRES_API_KEY false Whether this search engine requires an API key SEARCH
search.engine.web.semantic_scholar.strengths LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_STRENGTHS ["AI-powered features", "TLDR summaries", "citation graphs", "semantic search", "all scientific fields", "no API key required", "computer science focus", "paper influence metrics"] Strengths of this search engine SEARCH
search.engine.web.semantic_scholar.use_in_auto_search LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_USE_IN_AUTO_SEARCH true Include Semantic Scholar in auto search mode SEARCH
search.engine.web.semantic_scholar.weaknesses LDR_SEARCH_ENGINE_WEB_SEMANTIC_SCHOLAR_WEAKNESSES ["rate limits without API key", "not all papers have TLDR", "coverage varies by field", "newer papers may be missing"] Weaknesses of this search engine SEARCH
search.engine.web.serpapi.agent_enabled LDR_SEARCH_ENGINE_WEB_SERPAPI_AGENT_ENABLED true Include SerpAPI as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.serpapi.api_key LDR_SEARCH_ENGINE_WEB_SERPAPI_API_KEY `` The Serp API key to use. SEARCH
search.engine.web.serpapi.default_params.region LDR_SEARCH_ENGINE_WEB_SERPAPI_DEFAULT_PARAMS_REGION us Geographic region for search results (e.g., 'us', 'uk'). Results prioritized from this region. SEARCH
search.engine.web.serpapi.default_params.safe_search LDR_SEARCH_ENGINE_WEB_SERPAPI_DEFAULT_PARAMS_SAFE_SEARCH true Enable safe search to filter explicit content from results. SEARCH
search.engine.web.serpapi.default_params.search_language LDR_SEARCH_ENGINE_WEB_SERPAPI_DEFAULT_PARAMS_SEARCH_LANGUAGE English Language for search queries and results. Filters results by language. SEARCH
search.engine.web.serpapi.default_params.time_period LDR_SEARCH_ENGINE_WEB_SERPAPI_DEFAULT_PARAMS_TIME_PERIOD inherit Time range filter for SerpAPI results. 'Use global default' follows Settings → Search → Time Period; a specific value here overrides that saved global setting for this engine ('all' = no filter). When the LDR_SEARCH_TIME_PERIOD environment variable is set it takes precedence over a value saved here, and this engine's own environment variable takes precedence over both. SEARCH
search.engine.web.serpapi.description LDR_SEARCH_ENGINE_WEB_SERPAPI_DESCRIPTION Search the web with Google's search API. Human-readable description of the search engine. SEARCH
search.engine.web.serpapi.display_name LDR_SEARCH_ENGINE_WEB_SERPAPI_DISPLAY_NAME SerpApi Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.serpapi.reliability LDR_SEARCH_ENGINE_WEB_SERPAPI_RELIABILITY 0.6 Reliability score (0-1). SerpAPI rated moderate (0.6) - good for general search but less authoritative than specialized sources. SEARCH
search.engine.web.serpapi.requires_api_key LDR_SEARCH_ENGINE_WEB_SERPAPI_REQUIRES_API_KEY true Indicates this engine requires a SerpAPI key. Get one at serpapi.com. SEARCH
search.engine.web.serpapi.strengths LDR_SEARCH_ENGINE_WEB_SERPAPI_STRENGTHS ["comprehensive web search", "product information", "reviews", "recent content", "news", "broad coverage"] Advantages: Comprehensive web search via Google SERP, good for products, reviews, news, and broad coverage. SEARCH
search.engine.web.serpapi.supports_full_search LDR_SEARCH_ENGINE_WEB_SERPAPI_SUPPORTS_FULL_SEARCH true Indicates this engine can fetch full page content after initial search, not just snippets. SEARCH
search.engine.web.serpapi.use_in_auto_search LDR_SEARCH_ENGINE_WEB_SERPAPI_USE_IN_AUTO_SEARCH false Include SerpAPI in auto search mode SEARCH
search.engine.web.serpapi.weaknesses LDR_SEARCH_ENGINE_WEB_SERPAPI_WEAKNESSES ["requires API key with usage limits", "not specialized for academic content"] Limitations: Requires paid API key with usage limits, not specialized for academic or technical content. SEARCH
search.engine.web.serper.agent_enabled LDR_SEARCH_ENGINE_WEB_SERPER_AGENT_ENABLED true Include Serper as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.serper.api_key LDR_SEARCH_ENGINE_WEB_SERPER_API_KEY `` The Serper API key to use. Get yours at https://serper.dev SEARCH
search.engine.web.serper.default_params.include_full_content LDR_SEARCH_ENGINE_WEB_SERPER_DEFAULT_PARAMS_INCLUDE_FULL_CONTENT false Include full webpage content in results (may slow down search) SEARCH
search.engine.web.serper.default_params.region LDR_SEARCH_ENGINE_WEB_SERPER_DEFAULT_PARAMS_REGION us Country code for localized results (e.g., 'us', 'gb', 'fr') SEARCH
search.engine.web.serper.default_params.safe_search LDR_SEARCH_ENGINE_WEB_SERPER_DEFAULT_PARAMS_SAFE_SEARCH true Enable or disable safe search filtering SEARCH
search.engine.web.serper.default_params.search_language LDR_SEARCH_ENGINE_WEB_SERPER_DEFAULT_PARAMS_SEARCH_LANGUAGE en Language code for search results (e.g., 'en', 'es', 'fr') SEARCH
search.engine.web.serper.default_params.time_period LDR_SEARCH_ENGINE_WEB_SERPER_DEFAULT_PARAMS_TIME_PERIOD null Filter results by time period ('day', 'week', 'month', 'year', or null for all time) SEARCH
search.engine.web.serper.description LDR_SEARCH_ENGINE_WEB_SERPER_DESCRIPTION Fast and affordable Google Search API with real-time results. Human-readable description of the search engine. SEARCH
search.engine.web.serper.display_name LDR_SEARCH_ENGINE_WEB_SERPER_DISPLAY_NAME Serper Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.serper.reliability LDR_SEARCH_ENGINE_WEB_SERPER_RELIABILITY 0.95 Reliability of the Serper search engine SEARCH
search.engine.web.serper.requires_api_key LDR_SEARCH_ENGINE_WEB_SERPER_REQUIRES_API_KEY true Whether this search engine requires an API key SEARCH
search.engine.web.serper.requires_llm LDR_SEARCH_ENGINE_WEB_SERPER_REQUIRES_LLM false Whether this search engine requires an LLM for relevance filtering SEARCH
search.engine.web.serper.strengths LDR_SEARCH_ENGINE_WEB_SERPER_STRENGTHS ["Lightning-fast response times (1-2 seconds)", "Very affordable pricing", "High-quality Google search results", "Real-time results", "Knowledge graph and related searches", "People Also Ask data", "Simple pay-per-use pricing"] Strengths of this search engine SEARCH
search.engine.web.serper.supports_full_search LDR_SEARCH_ENGINE_WEB_SERPER_SUPPORTS_FULL_SEARCH true Whether this search engine supports full document search SEARCH
search.engine.web.serper.use_in_auto_search LDR_SEARCH_ENGINE_WEB_SERPER_USE_IN_AUTO_SEARCH false Include Serper in auto search mode SEARCH
search.engine.web.serper.weaknesses LDR_SEARCH_ENGINE_WEB_SERPER_WEAKNESSES ["Requires API key with usage limits", "Not specialized for academic content"] Weaknesses of this search engine SEARCH
search.engine.web.serply.agent_enabled LDR_SEARCH_ENGINE_WEB_SERPLY_AGENT_ENABLED true Include Serply as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool; this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.serply.api_key LDR_SEARCH_ENGINE_WEB_SERPLY_API_KEY `` The Serply API key to use. Get yours at https://serply.io SEARCH
search.engine.web.serply.default_params.search_type LDR_SEARCH_ENGINE_WEB_SERPLY_DEFAULT_PARAMS_SEARCH_TYPE web Which Google index to search: 'web' for general web search, 'news' for Google News, 'scholar' for Google Scholar. See https://serply.io/docs SEARCH
search.engine.web.serply.description LDR_SEARCH_ENGINE_WEB_SERPLY_DESCRIPTION Google search results via the Serply API, with Google News and Google Scholar as alternative search types. Human-readable description of the search engine. SEARCH
search.engine.web.serply.display_name LDR_SEARCH_ENGINE_WEB_SERPLY_DISPLAY_NAME Serply Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.serply.reliability LDR_SEARCH_ENGINE_WEB_SERPLY_RELIABILITY 0.85 Reliability of the Serply search engine SEARCH
search.engine.web.serply.requires_api_key LDR_SEARCH_ENGINE_WEB_SERPLY_REQUIRES_API_KEY true Whether this search engine requires an API key SEARCH
search.engine.web.serply.requires_llm LDR_SEARCH_ENGINE_WEB_SERPLY_REQUIRES_LLM false Whether this search engine requires an LLM for relevance filtering SEARCH
search.engine.web.serply.strengths LDR_SEARCH_ENGINE_WEB_SERPLY_STRENGTHS ["Google web search results", "Google News and Google Scholar available as search types", "Scholar results include author, venue and citation metadata"] Strengths of this search engine SEARCH
search.engine.web.serply.supports_full_search LDR_SEARCH_ENGINE_WEB_SERPLY_SUPPORTS_FULL_SEARCH false Whether this search engine supports full document search SEARCH
search.engine.web.serply.use_in_auto_search LDR_SEARCH_ENGINE_WEB_SERPLY_USE_IN_AUTO_SEARCH false Whether to include this engine in auto/meta search selection SEARCH
search.engine.web.serply.weaknesses LDR_SEARCH_ENGINE_WEB_SERPLY_WEAKNESSES ["Requires API key with usage limits", "One search type per configured engine"] Weaknesses of this search engine SEARCH
search.engine.web.sofya.agent_enabled LDR_SEARCH_ENGINE_WEB_SOFYA_AGENT_ENABLED true Include Sofya as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.sofya.api_key LDR_SEARCH_ENGINE_WEB_SOFYA_API_KEY `` The Sofya API key to use. Get yours at https://sofya.co/dashboard (GitHub sign-up grants 1000 free credits/month). SEARCH
search.engine.web.sofya.default_params.freshness LDR_SEARCH_ENGINE_WEB_SOFYA_DEFAULT_PARAMS_FRESHNESS null Filter results by recency ('day', 'week', 'month', 'year', or null for all time). SEARCH
search.engine.web.sofya.default_params.include_full_content LDR_SEARCH_ENGINE_WEB_SOFYA_DEFAULT_PARAMS_INCLUDE_FULL_CONTENT true Fetch extracted page content. On uses Sofya 'basic' depth (content, 3 credits); off uses cheaper 'snippets' depth (1 credit). SEARCH
search.engine.web.sofya.default_params.topic LDR_SEARCH_ENGINE_WEB_SOFYA_DEFAULT_PARAMS_TOPIC general Search topic. 'general' for broad web search, 'news' for current events. SEARCH
search.engine.web.sofya.description LDR_SEARCH_ENGINE_WEB_SOFYA_DESCRIPTION Hosted web-search API for AI agents. Returns ranked results with SERP snippets and extracted page content (markdown) in a single call. Human-readable description of the search engine. SEARCH
search.engine.web.sofya.display_name LDR_SEARCH_ENGINE_WEB_SOFYA_DISPLAY_NAME Sofya Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.sofya.reliability LDR_SEARCH_ENGINE_WEB_SOFYA_RELIABILITY 0.85 Reliability of the Sofya search engine SEARCH
search.engine.web.sofya.requires_api_key LDR_SEARCH_ENGINE_WEB_SOFYA_REQUIRES_API_KEY true Whether this search engine requires an API key SEARCH
search.engine.web.sofya.requires_llm LDR_SEARCH_ENGINE_WEB_SOFYA_REQUIRES_LLM false Whether this search engine requires an LLM for relevance filtering SEARCH
search.engine.web.sofya.strengths LDR_SEARCH_ENGINE_WEB_SOFYA_STRENGTHS ["Returns SERP snippets and extracted page content (markdown) in one call", "Domain include/exclude filtering and recency filtering", "General and news topics", "1000 free credits/month for GitHub sign-ups", "Built for AI agents"] Strengths of this search engine SEARCH
search.engine.web.sofya.supports_full_search LDR_SEARCH_ENGINE_WEB_SOFYA_SUPPORTS_FULL_SEARCH true Whether this search engine supports full document search SEARCH
search.engine.web.sofya.use_in_auto_search LDR_SEARCH_ENGINE_WEB_SOFYA_USE_IN_AUTO_SEARCH false Whether to include this engine in auto/meta search selection SEARCH
search.engine.web.sofya.weaknesses LDR_SEARCH_ENGINE_WEB_SOFYA_WEAKNESSES ["Requires API key with credit-based usage limits", "Not specialized for academic content"] Weaknesses of this search engine SEARCH
search.engine.web.stackexchange LDR_SEARCH_ENGINE_WEB_STACKEXCHANGE {"requires_api_key": false, "requires_llm": true, "description": "Search Stack Overflow and other Q&A sites for programming answers.", "reliability": 0.9} Stack Exchange search engine configuration SEARCH
search.engine.web.stackexchange.agent_enabled LDR_SEARCH_ENGINE_WEB_STACKEXCHANGE_AGENT_ENABLED false Include Stack Exchange as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.stackexchange.default_params.max_results LDR_SEARCH_ENGINE_WEB_STACKEXCHANGE_DEFAULT_PARAMS_MAX_RESULTS 20 Maximum number of results to retrieve from Stack Exchange. SEARCH
search.engine.web.stackexchange.default_params.site LDR_SEARCH_ENGINE_WEB_STACKEXCHANGE_DEFAULT_PARAMS_SITE stackoverflow Stack Exchange site to search (stackoverflow, serverfault, superuser, etc.). SEARCH
search.engine.web.stackexchange.description LDR_SEARCH_ENGINE_WEB_STACKEXCHANGE_DESCRIPTION Search Stack Overflow and other Q&A sites for programming answers. Human-readable description of the search engine. SEARCH
search.engine.web.stackexchange.display_name LDR_SEARCH_ENGINE_WEB_STACKEXCHANGE_DISPLAY_NAME Stack Exchange Display name for Stack Exchange search engine. SEARCH
search.engine.web.stackexchange.reliability LDR_SEARCH_ENGINE_WEB_STACKEXCHANGE_RELIABILITY 0.9 Reliability score for Stack Exchange. SEARCH
search.engine.web.stackexchange.requires_api_key LDR_SEARCH_ENGINE_WEB_STACKEXCHANGE_REQUIRES_API_KEY false Stack Exchange is free without an API key (300 requests/day). SEARCH
search.engine.web.stackexchange.strengths LDR_SEARCH_ENGINE_WEB_STACKEXCHANGE_STRENGTHS ["programming", "Q&A", "code examples", "community moderated", "multiple sites"] Key strengths of Stack Exchange. SEARCH
search.engine.web.stackexchange.use_in_auto_search LDR_SEARCH_ENGINE_WEB_STACKEXCHANGE_USE_IN_AUTO_SEARCH false Include Stack Exchange in auto search mode SEARCH
search.engine.web.stackexchange.weaknesses LDR_SEARCH_ENGINE_WEB_STACKEXCHANGE_WEAKNESSES ["technical focus", "rate limited", "Q&A format only"] Limitations of Stack Exchange. SEARCH
search.engine.web.tavily.agent_enabled LDR_SEARCH_ENGINE_WEB_TAVILY_AGENT_ENABLED true Include Tavily as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.tavily.api_key LDR_SEARCH_ENGINE_WEB_TAVILY_API_KEY `` The Tavily API key to use. SEARCH
search.engine.web.tavily.default_params.include_full_content LDR_SEARCH_ENGINE_WEB_TAVILY_DEFAULT_PARAMS_INCLUDE_FULL_CONTENT true Include full webpage content in results SEARCH
search.engine.web.tavily.default_params.search_depth LDR_SEARCH_ENGINE_WEB_TAVILY_DEFAULT_PARAMS_SEARCH_DEPTH basic Search depth - basic for speed, advanced for quality SEARCH
search.engine.web.tavily.default_params.time_period LDR_SEARCH_ENGINE_WEB_TAVILY_DEFAULT_PARAMS_TIME_PERIOD inherit Time range filter for Tavily results. 'Use global default' follows Settings → Search → Time Period; a specific value here overrides that saved global setting for this engine ('all' = no filter). When the LDR_SEARCH_TIME_PERIOD environment variable is set it takes precedence over a value saved here, and this engine's own environment variable takes precedence over both. SEARCH
search.engine.web.tavily.description LDR_SEARCH_ENGINE_WEB_TAVILY_DESCRIPTION AI-powered search engine optimized for research with built-in answer extraction. Human-readable description of the search engine. SEARCH
search.engine.web.tavily.display_name LDR_SEARCH_ENGINE_WEB_TAVILY_DISPLAY_NAME Tavily Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.tavily.reliability LDR_SEARCH_ENGINE_WEB_TAVILY_RELIABILITY 0.8 Reliability score (0-1). Tavily rated high (0.8) - AI-optimized search designed for research applications. SEARCH
search.engine.web.tavily.requires_api_key LDR_SEARCH_ENGINE_WEB_TAVILY_REQUIRES_API_KEY true Indicates this engine requires a Tavily API key. Get one at tavily.com. SEARCH
search.engine.web.tavily.strengths LDR_SEARCH_ENGINE_WEB_TAVILY_STRENGTHS ["AI-powered search optimization", "built-in answer extraction", "research-focused results", "high-quality content filtering", "fast response times"] Advantages: AI-powered search optimization, built-in answer extraction, research-focused results, fast responses. SEARCH
search.engine.web.tavily.supports_full_search LDR_SEARCH_ENGINE_WEB_TAVILY_SUPPORTS_FULL_SEARCH true Indicates this engine can fetch full page content after initial search, not just snippets. SEARCH
search.engine.web.tavily.use_in_auto_search LDR_SEARCH_ENGINE_WEB_TAVILY_USE_IN_AUTO_SEARCH false Include Tavily in auto search mode SEARCH
search.engine.web.tavily.weaknesses LDR_SEARCH_ENGINE_WEB_TAVILY_WEAKNESSES ["requires API key with usage limits", "newer service with smaller historical data"] Limitations: Requires paid API key with usage limits, newer service with less historical data coverage. SEARCH
search.engine.web.tinyfish.agent_enabled LDR_SEARCH_ENGINE_WEB_TINYFISH_AGENT_ENABLED true Include Tinyfish as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.tinyfish.api_key LDR_SEARCH_ENGINE_WEB_TINYFISH_API_KEY `` The TinyFish API key to use. Can also be supplied with LDR_SEARCH_ENGINE_WEB_TINYFISH_API_KEY. SEARCH
search.engine.web.tinyfish.default_params.fetch_format LDR_SEARCH_ENGINE_WEB_TINYFISH_DEFAULT_PARAMS_FETCH_FORMAT markdown Output format for fetched page content. SEARCH
search.engine.web.tinyfish.default_params.include_full_content LDR_SEARCH_ENGINE_WEB_TINYFISH_DEFAULT_PARAMS_INCLUDE_FULL_CONTENT true Fetch browser-rendered page content for search results. SEARCH
search.engine.web.tinyfish.default_params.language LDR_SEARCH_ENGINE_WEB_TINYFISH_DEFAULT_PARAMS_LANGUAGE en Language code for search results. SEARCH
search.engine.web.tinyfish.default_params.location LDR_SEARCH_ENGINE_WEB_TINYFISH_DEFAULT_PARAMS_LOCATION US Country code for geo-targeted results. SEARCH
search.engine.web.tinyfish.description LDR_SEARCH_ENGINE_WEB_TINYFISH_DESCRIPTION Fast hosted web search with optional browser-rendered content extraction. Human-readable description of the search engine. SEARCH
search.engine.web.tinyfish.display_name LDR_SEARCH_ENGINE_WEB_TINYFISH_DISPLAY_NAME TinyFish Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.tinyfish.reliability LDR_SEARCH_ENGINE_WEB_TINYFISH_RELIABILITY 0.85 Reliability score (0-1) for TinyFish search. SEARCH
search.engine.web.tinyfish.requires_api_key LDR_SEARCH_ENGINE_WEB_TINYFISH_REQUIRES_API_KEY true Whether this search engine requires an API key. SEARCH
search.engine.web.tinyfish.requires_llm LDR_SEARCH_ENGINE_WEB_TINYFISH_REQUIRES_LLM false Whether this search engine requires an LLM. SEARCH
search.engine.web.tinyfish.strengths LDR_SEARCH_ENGINE_WEB_TINYFISH_STRENGTHS ["fast structured web search", "browser-rendered content extraction", "clean markdown output for LLM consumption", "batch fetches multiple URLs"] Strengths of this search engine. SEARCH
search.engine.web.tinyfish.supports_full_search LDR_SEARCH_ENGINE_WEB_TINYFISH_SUPPORTS_FULL_SEARCH true Whether this search engine can return extracted page content. SEARCH
search.engine.web.tinyfish.use_in_auto_search LDR_SEARCH_ENGINE_WEB_TINYFISH_USE_IN_AUTO_SEARCH false Include TinyFish in auto search mode SEARCH
search.engine.web.tinyfish.weaknesses LDR_SEARCH_ENGINE_WEB_TINYFISH_WEAKNESSES ["requires hosted API key", "external network requests leave the local environment", "fetch latency depends on target page rendering"] Weaknesses of this search engine. SEARCH
search.engine.web.wayback.agent_enabled LDR_SEARCH_ENGINE_WEB_WAYBACK_AGENT_ENABLED true Enable the fetch_archive tool for the lead LangGraph research agent and its subagents. Find URLs with a configured search provider, then fetch an archived version with an optional date. Uses search.fetch.mode and the shared search.fetch.max_per_topic budget; disabled fetch mode or egress policy can still block archive fetching. SEARCH
search.engine.web.wayback.default_params.closest_only LDR_SEARCH_ENGINE_WEB_WAYBACK_DEFAULT_PARAMS_CLOSEST_ONLY false Legacy URL adapter: When enabled, only return the snapshot closest to the target date instead of all available snapshots. Does not control fetch_archive. SEARCH
search.engine.web.wayback.default_params.language LDR_SEARCH_ENGINE_WEB_WAYBACK_DEFAULT_PARAMS_LANGUAGE English Legacy URL adapter: Preferred language for archived content when multiple versions are available. Does not control fetch_archive. SEARCH
search.engine.web.wayback.default_params.max_results LDR_SEARCH_ENGINE_WEB_WAYBACK_DEFAULT_PARAMS_MAX_RESULTS 15 Legacy URL adapter: Maximum number of archived snapshots to return per search query. Does not control fetch_archive. SEARCH
search.engine.web.wayback.default_params.max_snapshots_per_url LDR_SEARCH_ENGINE_WEB_WAYBACK_DEFAULT_PARAMS_MAX_SNAPSHOTS_PER_URL 3 Legacy URL adapter: Maximum historical snapshots to retrieve for each URL. Lower values are faster; higher shows more history. Does not control fetch_archive. SEARCH
search.engine.web.wayback.description LDR_SEARCH_ENGINE_WEB_WAYBACK_DESCRIPTION Fetch archived versions of known URLs from the Internet Archive's Wayback Machine. Human-readable description of the search engine. SEARCH
search.engine.web.wayback.display_name LDR_SEARCH_ENGINE_WEB_WAYBACK_DISPLAY_NAME Wayback Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.wayback.reliability LDR_SEARCH_ENGINE_WEB_WAYBACK_RELIABILITY 0.5 Reliability score (0-1). Wayback rated moderate (0.5) - great for historical content but archives may be incomplete. SEARCH
search.engine.web.wayback.requires_api_key LDR_SEARCH_ENGINE_WEB_WAYBACK_REQUIRES_API_KEY false Wayback Machine is free and does not require an API key. SEARCH
search.engine.web.wayback.strengths LDR_SEARCH_ENGINE_WEB_WAYBACK_STRENGTHS ["historical web content", "archived websites", "content verification", "deleted or changed web pages", "website evolution tracking"] Advantages: Access to historical web content, archived/deleted pages, content verification, and website evolution. SEARCH
search.engine.web.wayback.supports_full_search LDR_SEARCH_ENGINE_WEB_WAYBACK_SUPPORTS_FULL_SEARCH true Indicates this engine can fetch full archived page content, not just metadata. SEARCH
search.engine.web.wayback.use_in_auto_search LDR_SEARCH_ENGINE_WEB_WAYBACK_USE_IN_AUTO_SEARCH false Legacy setting retained for compatibility. Wayback accepts URLs only and is excluded from topic and auto search; choose a configured search provider for topics. SEARCH
search.engine.web.wayback.weaknesses LDR_SEARCH_ENGINE_WEB_WAYBACK_WEAKNESSES ["limited to previously archived content", "may miss recent changes", "archiving quality varies"] Limitations: Only finds previously archived content, may miss recent changes, archive quality varies by site. SEARCH
search.engine.web.webz.agent_enabled LDR_SEARCH_ENGINE_WEB_WEBZ_AGENT_ENABLED false Include Webz.io as an additional specialized news tool for the research agent. Disabled by default; selecting Webz.io as search.tool still uses it as the primary engine. SEARCH
search.engine.web.webz.api_key LDR_SEARCH_ENGINE_WEB_WEBZ_API_KEY `` Webz.io API token with api_news permission and available credits. Stored as a password setting. Requests use HTTPS only with no redirects; direct documentation shows HTTP, and live TLS compatibility has not been smoke-tested. SEARCH
search.engine.web.webz.default_params.filters LDR_SEARCH_ENGINE_WEB_WEBZ_DEFAULT_PARAMS_FILTERS {} Direct-API filters object. Supports language, country, category, sentiment, domain, exclude_domain, topic, person, organization, location, ticker, political_bias, published_from, published_to, source_type, trust_category and domain rank bounds. Dates must be YYYY-MM-DD and ordered; omitted dates leave coverage to the provider. Client bounds array filters to 50 nonempty strings of at most 256 characters. MCP days/allow_all_dates are not accepted. SEARCH
search.engine.web.webz.default_params.score_gte LDR_SEARCH_ENGINE_WEB_WEBZ_DEFAULT_PARAMS_SCORE_GTE 4 Minimum direct-API match score, 0-10; use 0 to disable the floor. SEARCH
search.engine.web.webz.default_params.score_lte LDR_SEARCH_ENGINE_WEB_WEBZ_DEFAULT_PARAMS_SCORE_LTE null Optional direct-API maximum match score, 0-10; null omits the upper bound. Must be at least score_gte. SEARCH
search.engine.web.webz.description LDR_SEARCH_ENGINE_WEB_WEBZ_DESCRIPTION Semantic news search via the Webz.io direct News Search API; publication dates, source metadata and matching article excerpts. Queries are limited to 750 characters and 100 words; requested results are clamped to 1-50. Full article text uses the existing result-URL fetch wrapper, not an additional Webz API. Human-readable description of the search engine. SEARCH
search.engine.web.webz.display_name LDR_SEARCH_ENGINE_WEB_WEBZ_DISPLAY_NAME Webz.io News Search Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.webz.reliability LDR_SEARCH_ENGINE_WEB_WEBZ_RELIABILITY 0.85 Reliability of the Webz.io search engine SEARCH
search.engine.web.webz.requires_api_key LDR_SEARCH_ENGINE_WEB_WEBZ_REQUIRES_API_KEY true Whether this search engine requires an API key SEARCH
search.engine.web.webz.requires_llm LDR_SEARCH_ENGINE_WEB_WEBZ_REQUIRES_LLM false Whether this search engine requires an LLM for relevance filtering SEARCH
search.engine.web.webz.strengths LDR_SEARCH_ENGINE_WEB_WEBZ_STRENGTHS ["Semantic news search", "Publication dates and source metadata", "Relevant article excerpts"] Strengths of this search engine SEARCH
search.engine.web.webz.supports_full_search LDR_SEARCH_ENGINE_WEB_WEBZ_SUPPORTS_FULL_SEARCH true Whether this search engine supports full document search SEARCH
search.engine.web.webz.use_in_auto_search LDR_SEARCH_ENGINE_WEB_WEBZ_USE_IN_AUTO_SEARCH false Whether to include this engine in auto/meta search selection SEARCH
search.engine.web.webz.weaknesses LDR_SEARCH_ENGINE_WEB_WEBZ_WEAKNESSES ["Requires api_news permission and available credits", "Live HTTPS compatibility has not been smoke-tested", "Client caps results at 50: Parameters says 100, but Errors says k greater than 50 returns HTTP 422"] Weaknesses of this search engine SEARCH
search.engine.web.wikinews.adaptive_search LDR_SEARCH_ENGINE_WEB_WIKINEWS_ADAPTIVE_SEARCH true Automatically adjust the search period based on the query type (recent or historical) to improve news search relevance SEARCH
search.engine.web.wikinews.agent_enabled LDR_SEARCH_ENGINE_WEB_WIKINEWS_AGENT_ENABLED true Include Wikinews as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.wikinews.description LDR_SEARCH_ENGINE_WEB_WIKINEWS_DESCRIPTION Search news articles written by volunteers with verified sources Human-readable description of the search engine. SEARCH
search.engine.web.wikinews.display_name LDR_SEARCH_ENGINE_WEB_WIKINEWS_DISPLAY_NAME Wikinews Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.wikinews.reliability LDR_SEARCH_ENGINE_WEB_WIKINEWS_RELIABILITY 0.85 Reliability score (0-1). Wikinews rated moderately high (0.85) - volunteer-written but with verified sources. SEARCH
search.engine.web.wikinews.requires_api_key LDR_SEARCH_ENGINE_WEB_WIKINEWS_REQUIRES_API_KEY false Wikinews is free and does not require an API key. SEARCH
search.engine.web.wikinews.strengths LDR_SEARCH_ENGINE_WEB_WIKINEWS_STRENGTHS ["recent and historical news", "verified sources", "general coverage", "quick overviews"] Advantages: Recent and historical news coverage, verified sources, general topic coverage, quick overviews. SEARCH
search.engine.web.wikinews.use_in_auto_search LDR_SEARCH_ENGINE_WEB_WIKINEWS_USE_IN_AUTO_SEARCH true Include Wikinews in auto search mode SEARCH
search.engine.web.wikinews.weaknesses LDR_SEARCH_ENGINE_WEB_WIKINEWS_WEAKNESSES ["less coverage of specialized topics", "limited editorial oversight", "variable article quality", "not ideal for breaking news"] Limitations: Less coverage of specialized topics, variable article quality, not ideal for breaking news. SEARCH
search.engine.web.wikipedia.agent_enabled LDR_SEARCH_ENGINE_WEB_WIKIPEDIA_AGENT_ENABLED true Include Wikipedia as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.wikipedia.default_params.include_content LDR_SEARCH_ENGINE_WEB_WIKIPEDIA_DEFAULT_PARAMS_INCLUDE_CONTENT true Include full article content in results, not just titles and summaries. SEARCH
search.engine.web.wikipedia.default_params.max_results LDR_SEARCH_ENGINE_WEB_WIKIPEDIA_DEFAULT_PARAMS_MAX_RESULTS 20 Maximum number of Wikipedia articles to return per search query. SEARCH
search.engine.web.wikipedia.description LDR_SEARCH_ENGINE_WEB_WIKIPEDIA_DESCRIPTION Search Wikipedia articles Human-readable description of the search engine. SEARCH
search.engine.web.wikipedia.display_name LDR_SEARCH_ENGINE_WEB_WIKIPEDIA_DISPLAY_NAME Wikipedia Display name to use in the U.I. for this search engine. SEARCH
search.engine.web.wikipedia.reliability LDR_SEARCH_ENGINE_WEB_WIKIPEDIA_RELIABILITY 0.95 Reliability score (0-1). Wikipedia rated very high (0.95) - well-curated, cited content with editorial review. SEARCH
search.engine.web.wikipedia.requires_api_key LDR_SEARCH_ENGINE_WEB_WIKIPEDIA_REQUIRES_API_KEY false Wikipedia is free and does not require an API key. SEARCH
search.engine.web.wikipedia.strengths LDR_SEARCH_ENGINE_WEB_WIKIPEDIA_STRENGTHS ["factual information", "general knowledge", "definitions", "historical facts", "biographies", "overview information"] Advantages: Factual information, general knowledge, definitions, historical facts, biographies, and overviews. SEARCH
search.engine.web.wikipedia.use_in_auto_search LDR_SEARCH_ENGINE_WEB_WIKIPEDIA_USE_IN_AUTO_SEARCH true Include Wikipedia in auto search mode SEARCH
search.engine.web.wikipedia.weaknesses LDR_SEARCH_ENGINE_WEB_WIKIPEDIA_WEAKNESSES ["recent events", "specialized academic topics", "product comparisons"] Limitations: May lag on recent events, less depth on specialized academic topics, no product comparisons. SEARCH
search.engine.web.zenodo LDR_SEARCH_ENGINE_WEB_ZENODO {"requires_api_key": false, "requires_llm": true, "description": "Search millions of research datasets, software, and publications with DOIs.", "reliability": 0.95} Zenodo search engine configuration SEARCH
search.engine.web.zenodo.agent_enabled LDR_SEARCH_ENGINE_WEB_ZENODO_AGENT_ENABLED false Include Zenodo as a specialized tool for the langgraph research agent. The engine selected as search.tool always keeps its generic web_search tool — this flag only controls additional specialized tools. Independent of egress; the per-collection 'available to the research agent' toggle still wins for collections. SEARCH
search.engine.web.zenodo.default_params.max_results LDR_SEARCH_ENGINE_WEB_ZENODO_DEFAULT_PARAMS_MAX_RESULTS 20 Maximum number of results to retrieve from Zenodo. SEARCH
search.engine.web.zenodo.description LDR_SEARCH_ENGINE_WEB_ZENODO_DESCRIPTION Search millions of research datasets, software, and publications with DOIs. Human-readable description of the search engine. SEARCH
search.engine.web.zenodo.display_name LDR_SEARCH_ENGINE_WEB_ZENODO_DISPLAY_NAME Zenodo Display name for Zenodo search engine. SEARCH
search.engine.web.zenodo.reliability LDR_SEARCH_ENGINE_WEB_ZENODO_RELIABILITY 0.95 Reliability score for Zenodo. SEARCH
search.engine.web.zenodo.requires_api_key LDR_SEARCH_ENGINE_WEB_ZENODO_REQUIRES_API_KEY false Zenodo is free and does not require an API key for search. SEARCH
search.engine.web.zenodo.strengths LDR_SEARCH_ENGINE_WEB_ZENODO_STRENGTHS ["research data", "datasets", "DOIs", "software", "open access", "CERN"] Key strengths of Zenodo. SEARCH
search.engine.web.zenodo.use_in_auto_search LDR_SEARCH_ENGINE_WEB_ZENODO_USE_IN_AUTO_SEARCH false Include Zenodo in auto search mode SEARCH
search.engine.web.zenodo.weaknesses LDR_SEARCH_ENGINE_WEB_ZENODO_WEAKNESSES ["research focus", "variable quality", "metadata only"] Limitations of Zenodo. SEARCH
search.favorites LDR_SEARCH_FAVORITES ["arxiv", "searxng", "library", "openalex"] List of favorite search engine IDs that appear at the top of the dropdown. Edit as JSON array, e.g. ["arxiv", "brave"] SEARCH
search.fetch.content_max_length LDR_SEARCH_FETCH_CONTENT_MAX_LENGTH 10000 Maximum page text (in characters) returned directly to the research agent per URL in 'full' fetch mode. Applies to HTTP pages and local library documents. Default is 10000, with a range of 1000 to 50000. Summary modes use Fetch Summary Input Max Length instead. Applies exclusively to the langgraph-agent strategy's fetch_content and fetch_archive tools. SEARCH
search.fetch.max_per_topic LDR_SEARCH_FETCH_MAX_PER_TOPIC 2 Maximum number of page content fetches (fetch_content and fetch_archive calls sharing one budget) allowed per subagent (and lead agent) per topic/section in autonomous agent strategies (like langgraph-agent). Prevents agents from exhausting their recursion/turn budget on page fetches instead of searching and reasoning. Set to 0 for unlimited fetches (only capped by agent recursion limit). Default is 2 (subagents typically need at most 1-2 targeted page fetches to supplement search snippets; a conservative per-agent cap prevents runaway fetches without starving parallel subtopics or consuming entire turn budgets). SEARCH
search.fetch.mode LDR_SEARCH_FETCH_MODE summary_focus_query Controls the LangGraph agent's fetch_content and fetch_archive tools. 'summary_focus_query' (default) asks the LLM to extract only spans relevant to a focus question the agent supplies per call AND the original research query, so vague focus can be disambiguated — keeps small-model context clean. 'summary_focus' is the same but uses only the per-call focus question. 'full' returns the entire extracted page text (legacy behavior; can flood small-model context with boilerplate/metadata and degrade benchmark accuracy). 'disabled' removes both tools entirely so the agent works from search snippets only — useful for diagnosing whether fetching is helping or hurting accuracy. Note: This setting applies exclusively to the langgraph-agent strategy; pipeline strategies retrieve full page text upfront during search when search.snippets_only is disabled. SEARCH
search.fetch.summary_input_max_length LDR_SEARCH_FETCH_SUMMARY_INPUT_MAX_LENGTH 500000 Maximum page text (in characters) sent to the separate summarization step per URL in 'summary_focus' and 'summary_focus_query' fetch modes. Applies to HTTP pages and local library documents; the research agent receives the extracted summary. Default is 500000. Accepts any positive integer, with no fixed upper setting limit. Unless the research model uses a cloud provider with Use Unrestricted Cloud Context Window on, page text is also cut so the whole summarization prompt fits the model's context window minus its reply allowance, estimated at 4 characters per token; at least one character of page text is always kept. The reply allowance is Max Tokens, capped at 80% of the window, or the full 80% when Max Tokens is unset or not supported. For example, a 20480-token window with the default Max Tokens leaves 4096 tokens, or 16384 characters, for the prompt. The window is Local Provider Context Window Size for Ollama, LlamaCpp and LM Studio, and Cloud Provider Context Window Limit for other providers when Use Unrestricted Cloud Context Window is off. LDR sends the local window to Ollama only, so set it to the context length of your LlamaCpp or LM Studio server. With Use Unrestricted Cloud Context Window on, an OpenAI- or Anthropic-compatible endpoint, a provider LDR does not ship and a model LDR did not build use Local Provider Context Window Size instead. For compatible endpoints with Max Tokens supported and set, the summary call also caps requested output to the reserved allowance without changing the research model. Invalid managed context-window or reply settings must be corrected before fetching. Chinese, Japanese and other text that uses more tokens per character can still exceed the window. With unrestricted cloud context, this budget is sent as configured; larger inputs increase latency and cost. Full-text mode uses Fetch Full-Text Max Length instead. Applies exclusively to the langgraph-agent strategy's fetch_content and fetch_archive tools. SEARCH
search.final_max_results LDR_SEARCH_FINAL_MAX_RESULTS 100 Maximum unique sources to include in the final research output. Applied in pipeline/source-based strategies once after all search iterations complete, deduplicating and filtering across all accumulated results. Note: Autonomous agent strategies (like langgraph-agent) manage context autonomously and do not cap final results. SEARCH
search.iterations LDR_SEARCH_ITERATIONS 3 Number of search-and-refine cycles to run. Each iteration generates follow-up questions based on previous results to progressively deepen the research. More iterations yield better coverage but increase search and LLM API usage. SEARCH
search.journal_reputation.enable_llm_scoring LDR_SEARCH_JOURNAL_REPUTATION_ENABLE_LLM_SCORING false Enable Tier 4 LLM journal scoring via SearXNG. When disabled (default), only bundled data (OpenAlex, DOAJ, predatory lists) is used for scoring journal reputation. Tier 4 adds significant latency (1 SearXNG search + 1 LLM call per unknown journal) and only helps for journals outside the 217K-row reference DB. Requires SearXNG to be available. SEARCH
search.journal_reputation.exclude_non_published LDR_SEARCH_JOURNAL_REPUTATION_EXCLUDE_NON_PUBLISHED false When enabled, excludes results without a formal journal publication reference. This ensures only sources with documented journal publications are included in analysis. SEARCH
search.journal_reputation.max_context LDR_SEARCH_JOURNAL_REPUTATION_MAX_CONTEXT 3000 Maximum characters of source content to include when the LLM evaluates journal quality. Larger values provide more context but use more tokens. SEARCH
search.journal_reputation.reanalysis_period LDR_SEARCH_JOURNAL_REPUTATION_REANALYSIS_PERIOD 365 How often to refresh cached journal quality assessments. After this period, the LLM will re-evaluate the journal's reputation. SEARCH
search.journal_reputation.threshold LDR_SEARCH_JOURNAL_REPUTATION_THRESHOLD 2 Minimum journal quality score required for academic results. Sources below this threshold are excluded when the filter is enabled. Scores emitted: 1 predatory, 4 default/unknown, 5-6 moderate, 7-8 strong, 10 elite (values 2, 3, 9 are reserved but never assigned). Default 2 = drop only predatory; raise to 5 to also drop default/unknown venues; raise to 7+ to keep only strong/elite journals. SEARCH
search.max_filtered_results LDR_SEARCH_MAX_FILTERED_RESULTS 20 Per-query limit on results kept after LLM relevance filtering. Raw results (controlled by 'Max Results') are filtered for relevance, then this setting caps how many are kept. Only applies when relevance filtering is active for the search engine. SEARCH
search.max_results LDR_SEARCH_MAX_RESULTS 50 Maximum raw search results to retrieve from the search engine per query, before any relevance filtering is applied. SEARCH
search.quality_check_urls LDR_SEARCH_QUALITY_CHECK_URLS true Validate that fetched webpage content matches the search result's title and snippet. Helps filter out broken links or mismatched content. SEARCH
search.question_context_limit LDR_SEARCH_QUESTION_CONTEXT_LIMIT 30 Maximum number of previous search results provided as context when generating follow-up questions in subsequent iterations. Lower values reduce context size and focus on top results. Set to 0 for unlimited. SEARCH
search.questions_per_iteration LDR_SEARCH_QUESTIONS_PER_ITERATION 1 Number of search queries to generate and execute per iteration. More questions increase coverage but also increase API calls and processing time. SEARCH
search.rag.enable_relevance_filter LDR_SEARCH_RAG_ENABLE_RELEVANCE_FILTER true Apply an LLM relevance filter to local document / collection (RAG) results. Embeddings already rank by similarity, so this is optional; enabling it prunes semantically-near-but-irrelevant chunks at the cost of one extra LLM call per search. SEARCH
search.rag.max_results LDR_SEARCH_RAG_MAX_RESULTS 20 Maximum results (embedding chunks) the local document / collection (RAG) search returns per query. Capped independently of 'Max Results' because vector search returns many near-duplicate chunks that can flood the agent's context across research iterations. SEARCH
search.region LDR_SEARCH_REGION us Geographic region for search results localization. Affects which results are prioritized based on regional relevance. SEARCH
search.safe_search LDR_SEARCH_SAFE_SEARCH true Filter out adult and inappropriate content from search results. Passed to search engines that support content filtering. SEARCH
search.search_language LDR_SEARCH_SEARCH_LANGUAGE English Preferred language for search results. Search engines will attempt to return and prioritize results in this language when available. SEARCH
search.search_strategy LDR_SEARCH_SEARCH_STRATEGY langgraph-agent Research methodology. 'source-based': Finds and extracts from sources (good for comprehensive research). 'focused-iteration': Uses entity-based progressive exploration (optimized for factual Q&A, ~95% SimpleQA accuracy, requires larger context windows). 'focused-iteration-standard': Comprehensive variant of focused-iteration with broader exploration. 'topic-organization': Organizes research around discovered topic clusters. 'langgraph-agent': Autonomous agentic research where the LLM decides what to search and when to synthesize. SEARCH
search.searches_per_section LDR_SEARCH_SEARCHES_PER_SECTION 2 Number of independent searches per report section when generating structured reports. Increases coverage but also increases API usage. SEARCH
search.skip_relevance_filter LDR_SEARCH_SKIP_RELEVANCE_FILTER true When checked, LLM-based relevance filtering is suppressed for general-purpose search engines that do not require it. Keyword-based engines (arXiv, PubMed, Wikipedia, GitHub, etc.) always run the filter regardless of this checkbox; per-engine settings override both. SEARCH
search.snippets_only LDR_SEARCH_SNIPPETS_ONLY true Only retrieve search snippets instead of full webpage content for pipeline/source-based search strategies (source-based, iterative, topic organization, etc.). Reduces API usage and processing time, but provides less context for analysis. Note: Autonomous agent strategies (like langgraph-agent) always return snippets from web_search and retrieve full webpage content on-demand via the fetch_content tool (governed by search.fetch.mode). SEARCH
search.time_period LDR_SEARCH_TIME_PERIOD all Time range filter for search results. Limits results to content published within the specified period (day, week, month, year, or all time). SEARCH
search.tool LDR_SEARCH_TOOL searxng Search engine to use for research queries. The default langgraph-agent strategy can additionally pick specialized engines per query as tools. Each engine may require its own API key or service to be configured separately. Wayback is available through fetch_archive for known URLs. If your saved engine is Wayback, choose a configured search provider for topic queries; saved values are not changed automatically. SEARCH
security.account_lockout_duration_minutes LDR_SECURITY_ACCOUNT_LOCKOUT_DURATION_MINUTES 15 Duration in minutes that an account remains locked after exceeding the failed login threshold. Only configurable via environment variable (LDR_SECURITY_ACCOUNT_LOCKOUT_DURATION_MINUTES). APP
security.account_lockout_threshold LDR_SECURITY_ACCOUNT_LOCKOUT_THRESHOLD 10 Number of consecutive failed login attempts before an account is temporarily locked out. Only configurable via environment variable (LDR_SECURITY_ACCOUNT_LOCKOUT_THRESHOLD). APP
security.rate_limit_default LDR_SECURITY_RATE_LIMIT_DEFAULT 5000 per hour;50000 per day Default rate limit for all HTTP endpoints. Configured via LDR_SECURITY_RATE_LIMIT_DEFAULT environment variable. Multiple limits can be separated by semicolons (e.g., '5000 per hour;50000 per day'). Format: 'N per hour/minute/day'. Requires server restart. APP
security.rate_limit_login LDR_SECURITY_RATE_LIMIT_LOGIN 5 per 15 minutes Rate limit for login attempts to prevent brute force attacks. Configured via LDR_SECURITY_RATE_LIMIT_LOGIN environment variable (e.g., '5 per 15 minutes'). Requires server restart. APP
security.rate_limit_registration LDR_SECURITY_RATE_LIMIT_REGISTRATION 10 per minute;300 per hour Rate limit for registration attempts per client IP, including failed attempts. Defaults to 10 per minute and 300 per hour. Configured via LDR_SECURITY_RATE_LIMIT_REGISTRATION environment variable (e.g., '10 per minute;300 per hour'); semicolon-separated limits all apply. Requires server restart. APP
security.rate_limit_settings LDR_SECURITY_RATE_LIMIT_SETTINGS 30 per minute Rate limit for settings modification endpoints. Configured via LDR_SECURITY_RATE_LIMIT_SETTINGS environment variable. Requires server restart. APP
security.rate_limit_upload_ip LDR_SECURITY_RATE_LIMIT_UPLOAD_IP 60 per minute;1000 per hour Per-IP rate limit for file upload endpoints (applies to anonymous and authenticated requests). Configured via LDR_SECURITY_RATE_LIMIT_UPLOAD_IP environment variable. Multiple limits separated by semicolons. Requires server restart. APP
security.rate_limit_upload_user LDR_SECURITY_RATE_LIMIT_UPLOAD_USER 60 per minute;1000 per hour Per-authenticated-user rate limit for file upload endpoints (e.g., RAG collection uploads). Configured via LDR_SECURITY_RATE_LIMIT_UPLOAD_USER environment variable. Multiple limits separated by semicolons (e.g., '60 per minute;1000 per hour'). Requires server restart. APP
security.session_remember_me_days LDR_SECURITY_SESSION_REMEMBER_ME_DAYS 30 Number of days a 'Remember Me' session remains valid before requiring re-login. APP
security.session_timeout_hours LDR_SECURITY_SESSION_TIMEOUT_HOURS 2 Session timeout in hours for sessions without 'Remember Me' checked. Only applies to internal session validation (browser sessions expire on close). APP
web.enable_javascript_rendering LDR_WEB_ENABLE_JAVASCRIPT_RENDERING false When enabled, falls back to a headless browser (Crawl4AI/Playwright) for pages that need JavaScript to render. Requires Chromium to be installed - the default Docker production image does NOT include it. To enable: install Chromium in the runtime environment (e.g. 'playwright install --with-deps chromium'), then toggle this setting. Note: in our limited (mostly accidental) benchmark comparisons - between dev instances that happened to have Chromium installed and routine Docker runs that did not - JS rendering did not measurably improve research quality, and most of our regular benchmark runs are on Docker without Chromium anyway. Leave disabled unless you have a specific need to scrape JavaScript-only sites. Runs with Public only, Private only, or Strict egress scope use static fetching only because the browser cannot enforce those scopes on its own DNS connections. APP
web.host LDR_WEB_HOST 127.0.0.1 The host address to listen on. Configured via LDR_WEB_HOST environment variable. Requires server restart. APP
web.port LDR_WEB_PORT 5000 The port to listen on. Configured via LDR_WEB_PORT environment variable. Requires server restart. APP
web.use_https LDR_WEB_USE_HTTPS true Does not enable HTTPS or configure TLS certificates: the web listener always serves plain HTTP, so terminate TLS at a reverse proxy. While this is true (the default), LDR logs a startup warning saying so; set it to false to silence the warning. Otherwise it only sets the scheme of an internal fallback server URL that nothing currently uses, so no generated link depends on it. Configured via LDR_WEB_USE_HTTPS; requires server restart. APP
zotero.api_key LDR_ZOTERO_API_KEY `` Your Zotero API key. Create one at https://www.zotero.org/settings/keys (it needs read access to the library you want to import). Not needed if 'Use Local Zotero' is enabled. APP
zotero.auto_sync_enabled LDR_ZOTERO_AUTO_SYNC_ENABLED false Periodically re-sync the configured collections in the background (downloads new items, updates changed ones, and removes items deleted in Zotero). Requires the Zotero integration to be enabled. APP
zotero.collection_keys LDR_ZOTERO_COLLECTION_KEYS `` Comma-separated Zotero collection keys to import (e.g. ABCD1234). Leave empty to import the entire library. Use the 'List collections' button on the Zotero page to find keys. APP
zotero.enabled LDR_ZOTERO_ENABLED true Enable the Zotero integration (on by default; nothing runs until an API key is configured). Turn off to pause all Zotero syncing without removing your credentials. APP
zotero.import_annotations LDR_ZOTERO_IMPORT_ANNOTATIONS false Also import your Zotero PDF annotations (highlights + comments) and child notes, appended to the document's searchable text. Adds extra API calls per item, so it's off by default. Note: annotation/note edits that don't change the parent item are picked up only when the item itself changes. APP
zotero.import_items_without_pdf LDR_ZOTERO_IMPORT_ITEMS_WITHOUT_PDF false Import items that have no attached PDF, using only their title/abstract/metadata as a text-only document. Off by default and generally discouraged: without full text, research over these documents is shallow — prefer attaching the PDF in Zotero. If enabled later, applies to already-skipped items on the next manual Sync now. APP
zotero.import_tags LDR_ZOTERO_IMPORT_TAGS `` Only import items tagged with ALL of these comma-separated Zotero tags (case-insensitive). Leave empty to import everything. This filters what is imported; changing it does not remove items already imported. APP
zotero.library_id LDR_ZOTERO_LIBRARY_ID `` Numeric library ID. Optional for personal libraries — it is detected automatically from the API key (a pasted username is resolved too). Required for group libraries: the group's numeric ID (use the group picker, or the number in the group's URL). APP
zotero.library_type LDR_ZOTERO_LIBRARY_TYPE user Whether to read from your personal user library or a shared group library. APP
zotero.pdf_storage_mode LDR_ZOTERO_PDF_STORAGE_MODE none How to store imported PDFs. 'none' (default) stores only the extracted, indexed text — all that research needs, and much smaller. 'database' additionally keeps the full PDF inside your encrypted database so you can open the original. APP
zotero.sync_interval_minutes LDR_ZOTERO_SYNC_INTERVAL_MINUTES 360 How often the background auto-sync runs (minutes). APP
zotero.use_local_api LDR_ZOTERO_USE_LOCAL_API false Sync from the Zotero desktop app running on this machine (local API at localhost:23119) instead of the cloud Web API. No API key needed, and it can read locally-stored / linked-file attachments the cloud API can't. Requires Zotero 7+ with the local API enabled in its preferences, and Zotero running during sync. Caution on shared/multi-user hosts: the desktop app's local API is unauthenticated, so any user or process on the server able to reach localhost:23119 can read that Zotero library. APP

Generated by scripts/generate_config_docs.py