# Troubleshoot Document Retrieval (RAG) Source: https://docs.openwebui.com/troubleshooting/rag If a model cannot find an answer in your documents, check that the files finished processing, the conversation can access them, and the model has the tools and context it needs to retrieve their contents. This guide covers upload failures, retrieval settings, and model-specific context limits. This page covers the most common RAG problems and their solutions. --- ## Recommended Settings by Scenario RAG performance depends heavily on your model setup. The defaults are conservative to work everywhere, but you will get much better results by tuning them to your specific deployment. All of these are configured in **Settings > Admin > Documents**. > **Agentic retrieval: enable kb_exec** > > If your models use **native function calling**, set [`ENABLE_KB_EXEC=True`](/reference/env-configuration#enable_kb_exec) for a noticeably better knowledge-base experience. It gives the model a filesystem-style interface (`ls`, `tree`, `grep`, `cat`, read-by-line) over your knowledge that capable models chain more reliably than the individual search tools. It has no effect in Legacy Mode. See [Filesystem-style access](/features/workspace/knowledge#filesystem-style-access-kb_exec). ### Local models with constrained context (โ‰ค 8K tokens) Typical for Ollama models on consumer hardware (Qwen 3.5 4B, Gemma 4 12B, Muse Glimmer 30B, etc.) where context windows are limited. | Setting | Value | Why | | --- | --- | --- | | Text Splitter | token | Consistent chunk sizes aligned to actual token counts | | Markdown Header Splitting | On | Preserves document structure | | Chunk Size | 1000 | Smaller chunks so each retrieval result fits comfortably | | Chunk Overlap | 100 | Standard overlap | | Top K | 3 to 5 | Fewer chunks to avoid blowing out your limited context budget | | Full Context Mode | Off | Cannot afford to send full documents | > **Context budget math** > > With a chunk size of 1000 tokens and Top K of 5, RAG will inject roughly 5,000 tokens of retrieved content. Add your system prompt and conversation history. If your model has an 8K context window, that leaves about 2 to 3K tokens for the conversation itself. Adjust Top K downward if follow-up questions get cut off. ### Cloud models with large context (32K+ tokens) Typical for OpenAI (GPT-5.6), Anthropic (Claude), Google (Gemini), DeepSeek, and other API providers where context windows are 32K to 1M+ tokens. | Setting | Value | Why | | --- | --- | --- | | Text Splitter | token | Consistent chunk sizes | | Markdown Header Splitting | On | Preserves document structure | | Chunk Size | 2000 | Larger chunks preserve more surrounding context per hit | | Chunk Overlap | 200 | More overlap prevents sentence splits | | Top K | 15 to 25 | Cast a wide net, you have the context budget for it | | Full Context Mode | Consider for small docs | If a document is under ~20K tokens, full context can outperform retrieval | > **When to use Full Context Mode** > > If you are working with a single small-to-medium document (under ~50 pages) and a large-context model, Full Context Mode often gives better results than chunked retrieval because the model sees everything with no retrieval gaps. Toggle it per-chat in the chat settings. ### Mixed environment (local + cloud) If you use both local and cloud models, configure for the lowest common denominator and override per-model or per-chat: | Setting | Value | Why | | --- | --- | --- | | Text Splitter | token | Works for both | | Markdown Header Splitting | On | Works for both | | Chunk Size | 1500 | Compromise, not too large for local, not too small for cloud | | Chunk Overlap | 200 | Safe default | | Top K | 10 | Moderate, a good middle ground for mixed model usage | --- ## Embedding Model Recommendations The embedding model determines retrieval quality. The right choice depends on your deployment: | Scenario | Recommended | Why | | --- | --- | --- | | Single user, getting started | all-MiniLM-L6-v2 (default) | Runs locally, no setup needed | | Multi-user, Ollama available | nomic-embed-text via Ollama | Offloads to Ollama, frees Open WebUI RAM | | Production, API budget available | text-embedding-3-small via OpenAI | Best retrieval quality per dollar | | Air-gapped / self-hosted | nomic-embed-text or mxbai-embed-large via Ollama | No external API calls needed | After changing your embedding model, **reindex all existing documents** in **Settings > Admin > Documents** for the new embeddings to take effect. --- ## Common RAG Issues and How to Fix Them ### 1. The Model "Can't See" Your Content This is the most common problem, and it's typically caused by issues during content ingestion. The model doesn't hallucinate because it's wrong; it hallucinates because it was never given the right content in the first place. **Solution:** Check your content extraction settings. - Navigate to: **Settings > Admin > Documents**. - Make sure you're using a robust content extraction engine such as: - Apache Tika - Docling - Custom extractors (depending on your document types) > **tip** > > Try uploading a document and preview the extracted content. If it's blank or missing key sections, you need to adjust your extractor settings or use a different engine. --- ### 2. Only a Small Part of the Document is Being Used Open WebUI is designed to work with models that have limited context windows by default. For instance, Ollama picks a model's default context length from available VRAM, and on GPUs with less than 24 GiB that is 4096 tokens (see [Ollama's context length documentation](https://docs.ollama.com/context-length)), well below what most models support. Because of this, Open WebUI aggressively trims down the retrieved content to fit within the assumed available space. **Solutions:** - Go to **Settings > Admin > Documents** - Either: - **Enable "Bypass Embedding and Retrieval"**: sends full content directly without applying retrieval filters. - **Toggle on "Full Context Mode"**: injects more comprehensive content into the model prompt. > **warning** > > Be mindful of context limits: if your model can't handle more tokens, content will still be truncated. --- ### 3. Token Limit is Too Short Even if retrieval works, your model might still not process all the content it receives, because it simply can't. By default, Ollama-hosted models on GPUs with less than 24 GiB of VRAM run with a 4096-token context window (Ollama picks the default from available VRAM: 4096 below 24 GiB, 32768 from 24 to 48 GiB, and 262144 at 48 GiB and above). That means only a fraction of your retrieved data will actually be used. **Why Web Search Especially Needs Larger Context Windows:** Web pages are particularly challenging for small context windows because they contain far more content than typical documents. A single web page often includes: - Main content (the actual information you want) - Navigation menus, headers, and footers - Sidebar content and advertisements - Comments sections and related links - Metadata and embedded scripts Even after content extraction and cleaning, web pages easily consume 4,000-8,000+ tokens of context. With a 4096-token limit, you're often getting only half the content, missing the most relevant information that appears later in the page. Even 4096 tokens is frequently insufficient for comprehensive web content analysis. **Solutions:** - **For Ollama Models**: Extend the model's context length: - Navigate to: **Settings > Admin > Models**, then click the pencil (**Edit**) on the model you want to change - Go to **Advanced Params** - Modify the context length (e.g., increase to 8192+ or ideally beyond 16000 tokens if supported by your model) - **For OpenAI and Other Integrated Models**: These models typically have their own context limits that cannot be modified through Open WebUI settings. Ensure you're using a model with sufficient context length. Ollama's 4096-token default on smaller GPUs is a significant limiter for web search. For better RAG results with web content, use at least 8192 tokens, with 16384+ being ideal for complex web pages. **Alternative:** Use an external LLM with larger context capacity (e.g., GPT-5.6, Claude, Gemini with 8k+ context). Comparing results with a large-context model is a good way to isolate whether token limits are the bottleneck. > **tip** > > For web search and complex document analysis, stick with models that support 8192+ token contexts in production use cases. --- ### 4. Embedding Model is Low-Quality or Mismatched Bad embeddings = bad retrieval. If the vector representation of your content is poor, the retriever won't pull the right content, no matter how powerful your LLM is. **Solution:** - Change to a high-quality embedding model (e.g., all-MiniLM-L6-v2, Instructor X, or OpenAI embeddings) - Go to: **Settings > Admin > Documents** - After changing the model, be sure to: After changing the model, **reindex all existing documents** so the new embeddings take effect. Embedding quality directly affects what content is retrieved. --- ### 5. 400: 'NoneType' object has no attribute 'encode' This error indicates a misconfigured or missing embedding model. When Open WebUI tries to create embeddings but doesn't have a valid model loaded, it can't process the text, and the result is this cryptic error. **Cause:** - Your embedding model isn't set up properly. - It might not have downloaded completely. - Or if you're using an external embedding model, it may not be accessible. **Solution:** - Go to: **Settings > Admin > Documents > Embedding Model** - Save the embedding model again, even if it's already selected. This forces a recheck/download. - If you're using a remote/external embedding tool, make sure it's running and accessible to Open WebUI. > **tip** > > After fixing the configuration, try re-embedding a document and verify no error is shown in the logs. --- ### 6. Upload Limits and Restrictions Open WebUI implements various limits to ensure system stability and prevent abuse. It is important to understand how these limits apply to different upload methods: - **Chat Uploads:** Subject to global file size and count limits. - **Max File Size:** Controlled by `RAG_FILE_MAX_SIZE` (default: Unlimited). Configurable in **Settings > Admin > Documents > General > Max Upload Size**. - **Office and EPUB documents** are additionally checked against what they contain, because those formats are archives. One that unpacks to far more than its own size is refused with a message about the archive being too large after decompression, even though the file itself is small. A genuine document rarely trips this; one that does is either corrupt or built to exhaust memory on whatever opens it. - **Max File Count:** Controlled by `RAG_FILE_MAX_COUNT` (default: Unlimited). Configurable in **Settings > Admin > Documents > General > Max Upload Count**. - **Allowed File Extensions:** Controlled by `RAG_ALLOWED_FILE_EXTENSIONS` (default: All). Configurable in **Settings > Admin > Documents > General > Allowed File Extensions**. - **Folder Uploads:** Subject to the `FOLDER_MAX_FILE_COUNT` [environment variable](/reference/env-configuration/#folder_max_file_count) (defaults to 100). This limit applies to the number of files directly associated with a folder. - **Knowledge Base Uploads:** - **File Limit:** Subject to the same `RAG_FILE_MAX_SIZE` limit as chats, but **not** subject to the `RAG_FILE_MAX_COUNT` limit, allowing for unlimited file uploads. - **RAG Enforcement:** All files uploaded to a Knowledge Base are automatically indexed. However, similar to chat uploads, Knowledge Bases can also be used in **Full Context Mode** (accessible in chat settings), which feeds the full document content to the model instead of using vector search retrieval. > **info** > > By separating these limits, administrators can better manage resource usage across different features. For example, you might want to allow larger uploads in a curated Knowledge Base while restricting the number of files in ad-hoc Folder uploads. --- ### 7. Fragmented or Tiny Chunks When using the **Markdown Header Splitter**, documents can sometimes be split into very small fragments (e.g., just a table of contents entry or a short sub-header). These tiny chunks often lack enough semantic context for the embedding model to represent them accurately, leading to poor RAG results and unnecessary overhead. **Solution:** - Go to **Settings > Admin > Documents**. - Increase the **Chunk Min Size Target**. - Setting this to a value like `1000` (or ~50-60% of your `CHUNK_SIZE`) merges small fragments with neighboring chunks, resulting in better semantic coherence and fewer total chunks. --- ### 8. Slow Follow-up Responses (KV Cache Invalidation) If your initial response is fast but follow-up questions become increasingly slow, you are likely experiencing **KV Cache invalidation**. **The Problem**: By default, Open WebUI injects RAG context into the **user message**. As the chat progresses, new messages shift the position of this context, forcing models (like Ollama, llama.cpp, or vLLM) and cloud providers (like OpenAI or Vertex AI) to re-process the entire context for every turn. **Solution:** - Set the environment variable `RAG_SYSTEM_CONTEXT=True`. - This injects the RAG context into the **system message**, which stays at a fixed position at the start of the conversation. - This allows providers to effectively use **KV prefix caching** or **Prompt Caching**, resulting in nearly instant follow-up responses even with large documents. --- | Problem | Fix | | --- | --- | | ๐Ÿค” Model can't "see" content | Check document extractor settings | | ๐Ÿงน Only part of content used | Enable Full Context Mode or Bypass Embedding | | โฑ Limited by a small context length | Increase model context length or use large-context LLM | | ๐Ÿ“‰ Inaccurate retrieval | Switch to a better embedding model, then reindex | | โŒ Upload limits bypass | Use Folder uploads (with FOLDER_MAX_FILE_COUNT); Knowledge Base limits are separate | | ๐Ÿงฉ Fragmented/Tiny Chunks | Increase Chunk Min Size Target to merge small sections | | ๐ŸŒ Slow follow-up responses | Enable RAG_SYSTEM_CONTEXT=True to fix KV cache invalidation | | ๐Ÿ“„ API returns "empty content" | Wait for file processing to complete before adding to knowledge base | | ๐Ÿ’ฅ CUDA OOM during embedding | Reduce batch size, isolate GPU, or restart container | | ๐Ÿ“ท PDF images not extracted | Use Tika/Docling, enable OCR, or update pypdf | | ๐Ÿ’€ Worker dies during upload (instant) | Switch away from default ChromaDB (SQLite) in multi-worker setups | | ๐Ÿ’€ Worker dies during upload (timeout) | Update Open WebUI, or increase --timeout-worker-healthcheck | | ๐Ÿง  Model ignores attached KB | Enable Builtin Tools, add system prompt hints, or disable native function calling | | ๐Ÿ—‚ Single attached file returns nothing | Re-index to rebuild the per-file indexes | | ๐Ÿ“‘ Docling citations show the wrong page | Re-upload the file | --- ### 9. API File Upload: "The content provided is empty" Error When uploading files via the API and immediately adding them to a knowledge base, you may encounter: ``` 400: The content provided is empty. Please ensure that there is text or data present before proceeding. ``` **The Problem**: This is a **race condition**, not an actual empty file. By default, file uploads are processed asynchronously: the upload endpoint returns immediately with a file ID while content extraction and embedding computation happen in the background. If you try to add the file to a knowledge base before processing completes, the system sees empty content. โœ… **Solution: Wait for Processing to Complete** Before adding a file to a knowledge base, poll the status endpoint until processing is done: ``` import requests import time def wait_for_processing(token, file_id, timeout=300): url = f'http://localhost:3000/api/v1/files/{file_id}/process/status' headers = {'Authorization': f'Bearer {token}'} start_time = time.time() while time.time() - start_time < timeout: response = requests.get(url, headers=headers) status = response.json().get('status') if status == 'completed': return True elif status == 'failed': raise Exception(f"Processing failed: {response.json().get('error')}") time.sleep(2) # Poll every 2 seconds raise TimeoutError("File processing timed out") ``` **Status Values:** | Status | Meaning | | --- | --- | | pending | Still processing | | completed | Ready to add to knowledge base | | failed | Processing failed (check error field) | > **tip** > > For complete API workflow examples including proper status checking, see the [API Endpoints documentation](/reference/api-endpoints#checking-file-processing-status). --- ### 10. CUDA Out of Memory During Embedding When processing large files or many files in sequence, you may encounter CUDA OOM errors like: ``` CUDA out of memory. Tried to allocate X MiB. GPU has a total capacity of Y GiB of which Z MiB is free. ``` **Common Causes:** - Embedding model competing with chat model for GPU memory - PyTorch memory fragmentation from repeated small allocations - Large documents creating memory spikes during embedding โœ… **Solutions:** 1. **Isolate Embedding to a Different GPU** (if available): Set `CUDA_VISIBLE_DEVICES` to pin embedding to a specific GPU separate from your chat model. 2. **Reduce Embedding Batch Size**: Lower `RAG_EMBEDDING_BATCH_SIZE` (e.g., from 32 to 8 or 4) to reduce peak memory usage. 3. **Enable Expandable Segments**: Set the environment variable to reduce fragmentation: ``` PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True ``` 4. **Restart Between Large Ingestion Jobs**: If memory fragmentation builds up, restart the Open WebUI container to clear CUDA contexts. 5. **Use Smaller Embedding Models**: Consider using lighter embedding models for bulk ingestion, then switch to higher-quality models for production queries. 6. **Separate Ingestion from Chat**: Don't run the chat model during large ingestion jobs. Load the chat model after embeddings finish. --- ### 10b. 429 Rate Limit Errors During Embedding When using a **remote/external embedding provider** (OpenAI, Azure OpenAI, etc.) with [`ENABLE_ASYNC_EMBEDDING`](/reference/env-configuration#enable_async_embedding) enabled, you may see HTTP 429 "Too Many Requests" errors in the logs during bulk document ingestion: ``` Error generating embeddings: 429 Rate limit reached ``` **The Problem**: With async embedding enabled, Open WebUI sends embedding requests concurrently. If you're ingesting many documents or large documents at once, this can easily exceed your provider's API rate limits, especially on free-tier or lower-tier plans. โœ… **Solutions:** 1. **Limit Concurrent Embedding Requests**: Set [`RAG_EMBEDDING_CONCURRENT_REQUESTS`](/reference/env-configuration#rag_embedding_concurrent_requests) to cap the number of simultaneous embedding API calls. For example, set it to `5` or `10` depending on your provider's rate limits: ``` # docker-compose.yaml environment: RAG_EMBEDDING_CONCURRENT_REQUESTS: 5 ``` Or configure it in the **Settings > Admin > Documents > Concurrent Requests** field. The default of `0` means unlimited concurrency. 2. **Reduce Batch Size**: Lower [`RAG_EMBEDDING_BATCH_SIZE`](/reference/env-configuration#rag_embedding_batch_size) to send fewer texts per API call. 3. **Disable Async Embedding**: If rate limits remain an issue, set `ENABLE_ASYNC_EMBEDDING` to `False` to process embeddings sequentially (slower but avoids rate limit pressure). ### 11. PDF OCR Not Extracting Text from Images If PDFs containing images with text are returning empty content: **The Problem**: The default "pypdf" content extractor may struggle with certain PDF formats, especially those containing primarily image-based content. โœ… **Solutions:** 1. **Use a Different Content Extraction Engine**: - Navigate to **Settings > Admin > Documents** - Try **Apache Tika** or **Docling** for better OCR support 2. **Enable PDF Image Extraction**: - In **Settings > Admin > Documents**, ensure **PDF Extract Images (OCR)** is enabled 3. **Update pypdf** (if using the default engine): Recent pypdf releases (6.0.0+) have improved handling of various PDF formats 4. **Check for Corrupted PDFs**: Verify the PDF opens correctly in a standard PDF viewer before uploading --- ### 12. Worker Dies During Document Upload When uploading documents in a **multi-worker** deployment, you may see: ``` INFO: Waiting for child process [12]INFO: Child process [12] died ``` There are **two distinct causes** for this in multi-worker setups: #### Cause A: ChromaDB SQLite + Fork (Instant Crash) If you are using the **default ChromaDB** vector database (which uses a local SQLite-backed `PersistentClient`) with `UVICORN_WORKERS > 1`, the crash is caused by SQLite being **not fork-safe**. When uvicorn forks multiple workers, each process inherits the same SQLite database connection. Concurrent writes to the vector database from multiple workers cause an immediate crash, not a timeout, but an instant fatal error. You will typically see this pattern all within the same second: ``` save_docs_to_vector_db:1619 - adding to collection file-idINFO: Waiting for child process [pid]INFO: Child process [pid] died ``` **Solution:** You **must** switch away from the default local ChromaDB when using multiple workers: - Set [`VECTOR_DB`](/reference/env-configuration#vector_db) to `pgvector`, `mariadb-vector`, `milvus`, or `qdrant` - Or run ChromaDB as a separate HTTP server and set [`CHROMA_HTTP_HOST`](/reference/env-configuration#chroma_http_host) / [`CHROMA_HTTP_PORT`](/reference/env-configuration#chroma_http_port) See the [Scaling & HA guide](/troubleshooting/multi-replica#6-worker-crashes-during-document-upload-chromadb--multi-worker) for full details. #### Cause B: SentenceTransformers Health Check Timeout (Older Versions) When using the **default SentenceTransformers** embedding engine (local embeddings) with multiple workers, uvicorn monitors worker health via periodic pings. The default health check timeout is just **5 seconds**. In older versions of Open WebUI, the embedding call blocked the event loop entirely, preventing the worker from responding to health checks. Uvicorn then killed the worker as unresponsive. > **note** > > This issue was **fixed** in Open WebUI. The embedding system now uses `run_coroutine_threadsafe` to keep the main event loop responsive during embedding operations, so workers will no longer be killed during uploads regardless of how long embeddings take. > > > > If you are running a version with this fix and still experiencing worker death, check **Cause A** above (ChromaDB SQLite) first, then ensure your Open WebUI is up to date. **Who is affected:** - Only deployments using the **default SentenceTransformers** embedding engine (local embeddings). - Only when running **multiple uvicorn workers**. Single-worker deployments don't have health check timeouts. - External embedding engines (Ollama, OpenAI, Azure OpenAI) are **not affected** since their API calls don't block the event loop. โœ… **Solutions (for older versions without the fix):** 1. **Update Open WebUI** to a version that includes the `run_coroutine_threadsafe` fix. 2. **Increase the health check timeout** as a workaround: ``` # docker-compose.yaml command: ["bash", "start.sh", "--workers", "2", "--timeout-worker-healthcheck", "120"] ``` 3. **Switch to an external embedding engine** to avoid local blocking entirely: ``` RAG_EMBEDDING_ENGINE=ollamaRAG_EMBEDDING_MODEL=nomic-embed-text ``` 4. **Optionally set a safety timeout** via [`RAG_EMBEDDING_TIMEOUT`](/reference/env-configuration#rag_embedding_timeout) to abort abnormally long embedding operations (does not affect health checks). --- ### 13. Knowledge Base Attached to Model Not Working You attached a knowledge base to a model in **Workspace > Models > Edit**, but when you chat with the model it doesn't seem to know about the knowledge base content at all. **The Problem**: Open WebUI has two distinct RAG modes, and they handle model-attached knowledge bases very differently: | Mode | How Knowledge Works | | --- | --- | | Legacy (non-native) | Open WebUI automatically performs RAG: it queries the attached knowledge base, retrieves relevant chunks, and injects them into the conversation context. This happens behind the scenes without the model doing anything. | | Native Function Calling | Knowledge is not auto-injected. Instead, the model receives tools (like query_knowledge_bases) and must actively decide to call them. This is agentic RAG: the model autonomously searches when it determines it needs information. | Because **Native Function Calling is now the default**, the model needs both the **ability** and the **instruction** to use the knowledge tools. Keep Native mode enabled while checking the retrieval setup below. #### Knowledge Retrieval Behavior Matrix | | KB Attached to Model | No KB Attached | | --- | --- | --- | | Legacy Mode | Open WebUI auto-injects RAG results from the attached KB(s) only | No automatic RAG; user must manually add a knowledge base to the chat via # | | Native Function Calling | Model receives tools scoped to attached KB(s) only (must actively call them) | Model receives tools with access to all accessible KBs (if Builtin Tools enabled); must actively call them | Key takeaway: in Native Mode (the supported mode), the model must use its knowledge tools regardless. Attaching a KB only restricts _which_ KBs are searchable. Legacy Mode's auto-injection behavior is documented here for legacy deployments only; Legacy Mode is no longer supported and all models should be on Native Mode. > **Preventing Knowledge Base Access in Native Mode** > > If you want to prevent a model from accessing **any** knowledge base in native mode, you don't need to disable Builtin Tools entirely. Instead, disable only the **Knowledge Base** category in **Workspace > Models > Edit > Builtin Tools**. This removes all knowledge-related tools while keeping other builtin tools (web search, memory, notes, etc.) active. See [Granular Builtin Tool Categories](/features/extensibility/plugin/tools#granular-builtin-tool-categories-per-model) for the full list of categories. ![Builtin Tools categories in the Model Editor](data:image/png;base64,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) โœ… **Solutions (check in order):** 1. **Check Global Model Settings first**: - Go to **Settings > Admin > Models** and open **Model Defaults** - Expand **Model Parameters** and check if **Function Calling** is set to `native` - Models without an explicit per-model value inherit this setting. Keep the effective value set to `native` and check that the selected model supports tool calling - Also check the **Model Capabilities** section: **File Context** controls file processing, while **Builtin Tools** and its **Knowledge Base** category control native knowledge-tool access > **Check the effective model settings** > > Per-model settings in **Workspace > Models > Edit > Advanced Params** override the global default when explicitly set. A model without its own `function_calling` value inherits the global setting. Check both places when the model's behavior differs from what you expect. 1. **Ensure Built-in Tools are enabled for the model**: - Go to **Workspace > Models > Edit** for your model - Under **Builtin Tools**, make sure the **Knowledge Base** category is enabled (it is by default) - If this is disabled, the model has no way to query attached knowledge bases 2. **Add a system prompt hint**: - Some models need explicit guidance to use their tools. Add something like: > "When users ask about attached documents, use the available knowledge tools to search those documents before answering, and cite the relevant passage." 3. **Check processing and access**: - Confirm the uploaded file finished processing and the current user can access the knowledge base - Try a model with reliable native tool calling, then ask about a specific fact you can verify in the document 4. **For a small document, try Full Context mode**: - Click on the attached knowledge base and select **"Use Entire Document"** - This sends the full extracted content instead of retrieving selected passages. Ensure the document fits the model's context window > **Why the Change?** > > Open WebUI uses **agentic RAG**, where the model decides when and how to search knowledge bases and can retry with different queries. This requires a model that can use tools effectively. If the selected model cannot retrieve a known fact reliably, use a model with stronger tool calling or test a small document in Full Context mode. For the full explanation of how knowledge scoping and retrieval modes work, see the [Knowledge documentation](/features/workspace/knowledge#agentic-knowledge-tools) and [File Context vs Builtin Tools](/features/chat-conversations/rag#file-context-vs-builtin-tools). --- ### 14. Attaching a Link or a YouTube Video Fails A webpage or YouTube attachment came back as an error toast. The message names the step that failed: a link that could not be read names the link, a refused YouTube transcript gives the reason, and a message about the knowledge base means the content was read and only saving it failed. `[ERROR: Could not read content from ]` means nothing was attached. The usual causes are a site that blocks the request or serves its content only after JavaScript runs, which [`WEB_LOADER_ENGINE=playwright`](/reference/env-configuration#web_loader_engine) handles; a proxy Open WebUI is not being told to use, see [`WEB_SEARCH_TRUST_ENV`](/reference/env-configuration#web_search_trust_env); or an address refused on purpose, since private and loopback addresses, cloud metadata endpoints and anything matched by [`WEB_FETCH_FILTER_LIST`](/reference/env-configuration#web_fetch_filter_list) are never requested. A YouTube attachment is the video's transcript, so a video without a usable one cannot be attached at all. Where the message says YouTube blocked the request from your server's address, common for cloud provider ranges, route it through [`YOUTUBE_LOADER_PROXY_URL`](/reference/env-configuration#youtube_loader_proxy_url). Where a transcript exists but not in the languages asked for, add yours to [`YOUTUBE_LOADER_LANGUAGE`](/reference/env-configuration#youtube_loader_language). Captions switched off by the uploader, age restriction and unavailable videos cannot be worked around. ### 15. Attaching a Single File Returns No Sources Attaching one file with `#` retrieves nothing, while attaching the knowledge base that contains the same file works normally. **The Problem**: a file belonging to a knowledge base is indexed twice, once with the knowledge base and once on its own. Attaching it by itself searches only its own index, which can go missing after a vector database migration, a partial reset or a deletion made directly in the vector database. โœ… **Solutions:** 1. **Re-index** at **Settings > Admin > Documents > Reindex Knowledge Base Vectors**. This rebuilds each knowledge base and the per-file index of every file inside it. It re-embeds everything, so allow for the time and, on a paid embedding model, the cost. 2. **Re-upload the file** if it is not in any knowledge base, since re-indexing only covers knowledge bases. --- By optimizing these areas (extraction, embedding, retrieval, and model context) you can dramatically improve how accurately your LLM works with your documents.