Custom pipe model responses only appear after page reload (streaming and non-streaming)

[Keansy]

Hi,

I’m using OpenWebUI with a custom pipe as a model (a Hybrid RAG pipeline for our lighting research documents). The pipe technically works, but the assistant’s response in the UI only appears after I manually reload the page – both with streaming enabled and disabled.

From the backend logs it’s clear that:

• The pipe is called correctly.
• Status messages and the final answer are generated and yielded/returned.
• Uvicorn sends the HTTP 200 response.

But in the browser, I only see the user message while the request is running. The status lines and final answer become visible only after I hit browser reload, which triggers a GET /api/v1/chats/?page=1 and loads the saved chat from the database.

So it looks like the frontend is not rendering the incoming response from the pipe in real time, but it does persist the answer server-side.

---

Environment

• OpenWebUI: current Docker image as of 2025-11-27 (running with open_webui container + pipe function)

• Deployment: Docker Compose

• Reverse proxy: nginx in front of OpenWebUI with proxy_read_timeout etc. set high and WebSocket/Upgrade headers configured

• Backend services:

  • openwebui (uvicorn)
  • ollama (qwen3:30b)
  • hybrid-retriever (custom microservice for RAG search)
  • qdrant

If you need, I can add the exact image tags and docker-compose.yml.

---

Expected behavior

• When I send a message with the custom model (hybrid_rag_pipe defined in server:0):

  • With streaming on, I expect:

    • Status updates like “Starting Hybrid-RAG search…”, “Loading documents…”, etc. to appear live.
    • The final answer to be streamed in chunks and visible immediately once generated.

  • With streaming off, I expect:

    • The full answer to appear in the chat as soon as the /api/chat/completions request finishes, without needing a page reload.

---

Actual behavior

• Streaming on:

  • The backend logs show multiple chunks being yielded from the generator:

    • Status lines (🔄, ✏️, 📚, 🤖)
    • Final answer split into several chunks of ~512 chars

  • Uvicorn logs a 200 for POST /api/chat/completions.

  • In the browser I see status lines appearing but the final answer not being generated.

  • When I manually reload the page (browser reload), the full assistant message suddenly appears, including all status text and the final answer.

• Streaming off:

  • I modified the pipe so that it always uses non-streaming, i.e. it concatenates all chunks internally and returns a single string (no generator).
  • The backend logs confirm that _rag_non_stream collects all chunks and returns a full string.
  • Uvicorn again logs a 200 for POST /api/chat/completions.
  • In the UI, the answer still does not appear until I reload the page. After reload, the complete answer is visible (so it was saved, but not rendered live).

So in both modes, the answer is only visible after a page reload, not when the request completes.

---

Relevant log snippets

This is a shortened version of what I see in the backend logs during one request:

[Hybrid RAG Pipe] _rag_generator: final_query='...'
[Hybrid RAG Pipe] YIELDING CHUNK: 🔍 Such-Query: `...`
[Hybrid RAG Pipe] YIELDING CHUNK: 📚 Lade relevante Dokumente aus der Datenbank …

# LLM-Answer phase
[Hybrid RAG Pipe] _run_completion result: done_reason=stop, prompt_tokens=..., completion_tokens=..., has_content=True
[Hybrid RAG Pipe] _rag_generator: final_answer_length=1752
[Hybrid RAG Pipe] _stream_answer: total_len=1752, chunk_size=512
[Hybrid RAG Pipe] YIELD ANSWER CHUNK 0-512: **Kurzantwort** ...
[Hybrid RAG Pipe] YIELDING CHUNK: **Kurzantwort** ...
[Hybrid RAG Pipe] YIELD ANSWER CHUNK 512-1024: ...
[Hybrid RAG Pipe] YIELDING CHUNK: ...
[Hybrid RAG Pipe] YIELD ANSWER CHUNK 1024-1536: ...
[Hybrid RAG Pipe] YIELDING CHUNK: ...
[Hybrid RAG Pipe] YIELD ANSWER CHUNK 1536-1752: ...
[Hybrid RAG Pipe] YIELDING CHUNK: ...
[Hybrid RAG Pipe] _stream_answer: done streaming answer

uvicorn.protocols.http.httptools_impl:send - "POST /api/chat/completions HTTP/1.1" 200

After that, OpenWebUI triggers additional meta-tasks for follow-ups, title, and tags:

pipe() called ... task_arg=follow_up_generation
pipe(): Meta-Task erkannt, starte _handle_meta_task
_handle_meta_task: task=follow_up_generation ...
...
pipe() called ... task_arg=title_generation
...
pipe() called ... task_arg=tags_generation
...

These meta-tasks are handled by returning simple JSON strings (no streaming, no status), and they only run after the main answer finished streaming, so they shouldn’t interfere.

Finally, when I reload the page, I see:

GET /api/v1/chats/?page=1 HTTP/1.1" 200

and the full conversation including the answer is visible.

---

Things I’ve already tried / ruled out

1. Nginx configuration

   • Added/verified:

     • proxy_http_version 1.1;
     • proxy_set_header Upgrade $http_upgrade;
     • proxy_set_header Connection $connection_upgrade;

   • Increased timeouts:

     • proxy_read_timeout 300s;
     • proxy_send_timeout 300s;
     • client_body_timeout 300s;
     • send_timeout 300s;

   • Result: No change – still only see the answer after page reload.

2. Streaming vs non-streaming in the pipe

   • Implemented a streaming version that yields status and answer chunks.
   • Implemented a non-streaming version that always returns one big string.
   • The logs confirm that in both cases the data is produced and sent, but the UI only updates after reload.

3. Meta-tasks in the same pipe

   • OpenWebUI also uses the same pipe for internal tasks (follow_up_generation, title_generation, tags_generation).

   • I changed _handle_meta_task so that:

     • It returns small static JSON strings.
     • It does not perform RAG / streaming / status updates.

   • Verified in logs that meta-tasks are separate, non-streaming calls after the main answer.

   • Result: Behavior unchanged.

4. Status updates vs final answer

   • Status updates (🔄, ✏️, 📚, 🤖) and the final answer are all emitted by the same generator.
   • In the logs, all these chunks are clearly logged and sent before the request ends.
   • None of them appear live in the UI; everything appears at once only after a manual reload.

---

Hypothesis / Question

From the backend perspective, the pipe is working correctly:

• It streams data (or returns a full string in non-stream mode).
• Uvicorn sends the response with 200.
• The chat (including the answer) is persisted and visible after reload.

This suggests that the OpenWebUI frontend does not correctly render responses from custom server:0 pipe models in real time, but only refreshes the view when the chat list is reloaded (GET /api/v1/chats/?page=1) – i.e. after a page reload.

Is this a known issue or limitation with:

• Pipes as primary chat models (pipe.type = "pipe", used as model: hybrid_rag_pipe), and/or
• The way streaming is wired up for server:0 tools?

Any guidance on:

• How a custom pipe should return data so that OpenWebUI’s frontend updates the chat view live (with or without streaming), or
• Whether this is a bug that needs changes in the frontend/backend integration,

would be greatly appreciated.

The pipe function is attached:

Hybrid RAG Pipe.py

Thanks!