~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.
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