# Configuration Reference

This document is automatically generated from the application's default settings.
All 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: Web UI Config > Environment Variables > Default Values
> Environmental Variables are used to override default values, easing installation, while allowing for adjustments to configuration via Web UI.

### System Locking
There is a special environment variable `LDR_LOCKED_SETTINGS` that allows administrators to strictly enforce specific settings.

*   **Variable**: `LDR_LOCKED_SETTINGS`
*   **Format**: Comma-separated list of setting keys (e.g., `llm.model,app.port`)
*   **Behavior**:
    1.  Any setting listed here **MUST** have a corresponding value defined in the environment variables (e.g., `LDR_LLM_MODEL`). If not, the application will fail to start.
    2.  The setting becomes **read-only** in the Web UI.
    3.  The **Environment Variable** value takes absolute precedence, ignoring any value in the database.

**Priority for Locked Settings**: Environment Variable > Database (Ignored) > Default (Ignored)


## 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 unencrypted database (for development) | Bootstrap | LDR_ALLOW_UNENCRYPTED |
| `LDR_BOOTSTRAP_CONFIG_DIR` | Path | `None` | No |  | Configuration directory path | Bootstrap |  |
| `LDR_BOOTSTRAP_DATABASE_URL` | String | `None` | No |  | Database connection URL | Bootstrap |  |
| `LDR_BOOTSTRAP_DATA_DIR` | Path | `None` | No |  | Data directory path | Bootstrap |  |
| `LDR_BOOTSTRAP_ENABLE_FILE_LOGGING` | Boolean | `False` | No |  | Enable logging to file | Bootstrap |  |
| `LDR_BOOTSTRAP_ENCRYPTION_KEY` | Secret | `None` | No |  | Database encryption key | Bootstrap |  |
| `LDR_BOOTSTRAP_LOG_DIR` | Path | `None` | No |  | Log directory path | Bootstrap |  |
| `LDR_BOOTSTRAP_SECRET_KEY` | Secret | `None` | No |  | Application secret key for session encryption | Bootstrap |  |
| `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 because Apprise re-resolves DNS at send time, leaving a DNS-rebinding TOCTOU window that cannot be closed in code (Apprise exposes no Session/DNS hook). See SECURITY.md 'Notification Webhook SSRF' for details. Set to true only after reviewing the residual risk. 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_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), and the discard prefix (100::/64) 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_TESTING_TEST_MODE` | Boolean | `False` | No |  | Enable test mode (adds delays for testing concurrency) | Testing |  |


## 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 URL where this application is accessible (e.g., http://localhost:5000, https://myapp.example.com). Used for generating links in notifications. Leave empty to auto-detect from request context. | APP |
| `app.host` | `LDR_APP_HOST` | `0.0.0.0` | IP address or hostname for the web server to bind to. Use '0.0.0.0' to accept connections from any network interface, '127.0.0.1' for localhost only, or a specific IP for targeted access. Requires server restart. | 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 for the web server (1-65535). Requires server restart to take effect. | 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` | `dark` | User interface color theme. Choose from 20 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_reduced` | `LDR_APP_WARNINGS_DISMISS_CONTEXT_REDUCED` | `false` | Dismiss warnings based on historical context usage and 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_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_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.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` | Generate RAG embeddings for semantic search | APP |
| `document_scheduler.interval_seconds` | `LDR_DOCUMENT_SCHEDULER_INTERVAL_SECONDS` | `1800` | How often to process new research (seconds) | 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.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.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 |
| `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.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. | SEARCH |
| `llm.ionos.api_key` | `LDR_LLM_IONOS_API_KEY` | `null` | API key to use for the IONOS AI Model Hub provider. | SEARCH |
| `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_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. | SEARCH |
| `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.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` | `all-MiniLM-L6-v2` | Embedding model used for the local-document search index. Free-form text because available models vary by provider (e.g. Sentence Transformers ships a fixed list, Ollama/OpenAI-compatible servers expose whatever is installed). Defaults to all-MiniLM-L6-v2 (384d) which is fast and good for general use. | 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:YOUR_PASS@smtp.example.com?to=recipient@example.com). See <a href="https://github.com/LearningCircuit/local-deep-research/blob/main/docs/NOTIFICATIONS.md" target="_blank">documentation</a> 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.); BOTH = any classified engine. | SEARCH |
| `rag.indexing_batch_size` | `LDR_RAG_INDEXING_BATCH_SIZE` | `15` | Number of documents to process in parallel during RAG indexing. Higher values are faster but use more memory. | 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 reports as files on disk for external access (reports are always stored in the database regardless). Enable this if you need to access reports from outside the web interface. | 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 |
| `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.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. 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` | Base path for storing research library documents. Each user will have their own 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. When results from multiple search engines are combined, this limits how many total results are displayed. Higher values show more comprehensive results. | 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.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.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` | `y` | Time range filter for Brave results (e.g., 'd' for day, 'w' for week, 'm' for month, 'y' for year). | 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.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.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.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.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.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.weaknesses` | `LDR_SEARCH_ENGINE_WEB_GUTENBERG_WEAKNESSES` | ``["public domain only", "older works", "limited modern titles"]`` | Limitations of Project Gutenberg. | 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.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.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.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` | `` | Email address for polite pool access (optional but recommended). Provides faster response times. | 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", "no API key required", "high rate limits"]`` | 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.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.weaknesses` | `LDR_SEARCH_ENGINE_WEB_OPENLIBRARY_WEAKNESSES` | ``["books only", "variable metadata quality", "English focus"]`` | Limitations of Open Library. | 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.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.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.weaknesses` | `LDR_SEARCH_ENGINE_WEB_PUBCHEM_WEAKNESSES` | ``["chemistry only", "technical data", "requires chemical knowledge"]`` | Limitations of PubChem. | 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.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.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.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.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. | 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.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.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.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` | `y` | Time filter for results: 'd' (day), 'w' (week), 'm' (month), 'y' (year), or empty for all time. | 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.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.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.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.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.weaknesses` | `LDR_SEARCH_ENGINE_WEB_STACKEXCHANGE_WEAKNESSES` | ``["technical focus", "rate limited", "Q&A format only"]`` | Limitations of Stack Exchange. | 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.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.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.default_params.closest_only` | `LDR_SEARCH_ENGINE_WEB_WAYBACK_DEFAULT_PARAMS_CLOSEST_ONLY` | `false` | When enabled, only return the snapshot closest to the target date instead of all available snapshots. | SEARCH |
| `search.engine.web.wayback.default_params.language` | `LDR_SEARCH_ENGINE_WEB_WAYBACK_DEFAULT_PARAMS_LANGUAGE` | `English` | Preferred language for archived content when multiple versions are available. | SEARCH |
| `search.engine.web.wayback.default_params.max_results` | `LDR_SEARCH_ENGINE_WEB_WAYBACK_DEFAULT_PARAMS_MAX_RESULTS` | `15` | Maximum number of archived snapshots to return per search query. | SEARCH |
| `search.engine.web.wayback.default_params.max_snapshots_per_url` | `LDR_SEARCH_ENGINE_WEB_WAYBACK_DEFAULT_PARAMS_MAX_SNAPSHOTS_PER_URL` | `3` | Maximum historical snapshots to retrieve for each URL. Lower values are faster; higher shows more history. | SEARCH |
| `search.engine.web.wayback.description` | `LDR_SEARCH_ENGINE_WEB_WAYBACK_DESCRIPTION` | `Search 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` | Include Wayback in auto search mode | 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.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.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.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.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.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.mode` | `LDR_SEARCH_FETCH_MODE` | `summary_focus_query` | Controls the LangGraph agent's fetch_content tool. '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 the tool entirely so the agent works from search snippets only — useful for diagnosing whether fetching is helping or hurting accuracy. | SEARCH |
| `search.final_max_results` | `LDR_SEARCH_FINAL_MAX_RESULTS` | `100` | Maximum unique sources to include in the final research output. Applied once after all search iterations complete, deduplicating and filtering across all accumulated 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. Reduces API usage and processing time, but provides less context for analysis. | SEARCH |
| `search.time_period` | `LDR_SEARCH_TIME_PERIOD` | `y` | 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. | 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` | `3 per hour` | Rate limit for registration attempts to prevent spam. Configured via LDR_SECURITY_RATE_LIMIT_REGISTRATION environment variable (e.g., '3 per hour'). 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. | APP |
| `web.host` | `LDR_WEB_HOST` | `0.0.0.0` | 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` | Whether to enable HTTPS for the web interface. Configured via LDR_WEB_USE_HTTPS environment variable. Requires server restart. | APP |

*Generated by scripts/generate_config_docs.py*
