File stream handling

Adapt File Storage Layer to handle files as Stream and don't store them on local FS
Adapted:
- Files Router
- Audio Router
- Retrieval Router

- main Retrieval
- Mistral Document Loader

In Function Model added update Function for better updates

Refs:
  - PRODAI-115

Author: toscharfmoc

backend/open_webui/retrieval/loaders/main.py

@@ -2,6 +2,9 @@
 import logging
 import ftfy
 import sys
+import os
+import tempfile
+from typing import BinaryIO
 
 from langchain_community.document_loaders import (
     AzureAIDocumentIntelligenceLoader,
@@ -85,14 +88,12 @@
 
 
 class TikaLoader:
-    def __init__(self, url, file_path, mime_type=None):
+    def __init__(self, url, file_stream, mime_type=None):
         self.url = url
-        self.file_path = file_path
+        self.file_stream = file_stream
         self.mime_type = mime_type
 
     def load(self) -> list[Document]:
-        with open(self.file_path, "rb") as f:
-            data = f.read()
 
         if self.mime_type is not None:
             headers = {"Content-Type": self.mime_type}
@@ -104,7 +105,7 @@ def load(self) -> list[Document]:
             endpoint += "/"
         endpoint += "tika/text"
 
-        r = requests.put(endpoint, data=data, headers=headers)
+        r = requests.put(endpoint, data=self.file_stream, headers=headers)
 
         if r.ok:
             raw_metadata = r.json()
@@ -119,30 +120,30 @@ def load(self) -> list[Document]:
         else:
             raise Exception(f"Error calling Tika: {r.reason}")
 
-
 class DoclingLoader:
-    def __init__(self, url, file_path=None, mime_type=None):
+    def __init__(self, url, file_name, file_stream=None, mime_type=None):
         self.url = url.rstrip("/")
-        self.file_path = file_path
+        self.file_stream = file_stream
         self.mime_type = mime_type
+        self.file_name = file_name
 
     def load(self) -> list[Document]:
-        with open(self.file_path, "rb") as f:
-            files = {
-                "files": (
-                    self.file_path,
-                    f,
-                    self.mime_type or "application/octet-stream",
-                )
-            }
-
-            params = {
-                "image_export_mode": "placeholder",
-                "table_mode": "accurate",
-            }
-
-            endpoint = f"{self.url}/v1alpha/convert/file"
-            r = requests.post(endpoint, files=files, data=params)
+
+        files = {
+			"files": (
+				self.file_name,
+				self.file_stream,
+				self.mime_type or "application/octet-stream",
+			)
+		}
+
+        params = {
+        	"image_export_mode": "placeholder",
+            "table_mode": "accurate",
+        }
+
+        endpoint = f"{self.url}/v1alpha/convert/file"
+        r = requests.post(endpoint, files=files, data=params)
 
         if r.ok:
             result = r.json()
@@ -172,10 +173,48 @@ def __init__(self, engine: str = "", **kwargs):
         self.kwargs = kwargs
 
     def load(
-        self, filename: str, file_content_type: str, file_path: str
+        self, filename: str, file_content_type: str, file_stream: BinaryIO
     ) -> list[Document]:
-        loader = self._get_loader(filename, file_content_type, file_path)
-        docs = loader.load()
+
+        if self.engine == "tika" and self.kwargs.get("TIKA_SERVER_URL"):
+            log.debug(f"Using Tika loader with server URL: {self.kwargs.get('TIKA_SERVER_URL')}")
+            loader = TikaLoader(
+                url=self.kwargs.get("TIKA_SERVER_URL"),
+                file_stream=file_stream,
+                mime_type=file_content_type,
+            )
+            docs = loader.load()
+
+        elif self.engine == "docling" and self.kwargs.get("DOCLING_API_URL"):
+            log.debug(f"Using Docling loader with server URL: {self.kwargs.get('DOCLING_API_URL')}")
+            loader = DoclingLoader(
+                url=self.kwargs.get("DOCLING_SERVER_URL"),
+                file_name=filename,
+                file_stream=file_stream,
+                mime_type=file_content_type,
+            )
+            docs = loader.load()
+
+        elif (
+            self.engine == "mistral_ocr"
+            and self.kwargs.get("MISTRAL_OCR_API_KEY") != ""
+            and file_ext
+            in ["pdf"]  # Mistral OCR currently only supports PDF and images
+        ):
+            loader = MistralLoader(
+                api_key=self.kwargs.get("MISTRAL_OCR_API_KEY"), file_name=filename, file_stream=file_stream
+            )
+
+        else:
+            log.info(f"Using local file loader for: {filename} with content type: {file_content_type}")
+            file_ext = filename.split(".")[-1].lower()
+            with tempfile.NamedTemporaryFile(delete=True, suffix=f".{file_ext}") as tmp_file:
+                tmp_file.write(file_stream.read())
+                tmp_file.flush()
+                tmp_path = tmp_file.name
+                loader = self._get_loader(filename, file_content_type, tmp_path)
+                docs = loader.load()
+
 
         return [
             Document(
@@ -191,26 +230,8 @@ def _is_text_file(self, file_ext: str, file_content_type: str) -> bool:
 
     def _get_loader(self, filename: str, file_content_type: str, file_path: str):
         file_ext = filename.split(".")[-1].lower()
-
-        if self.engine == "tika" and self.kwargs.get("TIKA_SERVER_URL"):
-            if self._is_text_file(file_ext, file_content_type):
-                loader = TextLoader(file_path, autodetect_encoding=True)
-            else:
-                loader = TikaLoader(
-                    url=self.kwargs.get("TIKA_SERVER_URL"),
-                    file_path=file_path,
-                    mime_type=file_content_type,
-                )
-        elif self.engine == "docling" and self.kwargs.get("DOCLING_SERVER_URL"):
-            if self._is_text_file(file_ext, file_content_type):
-                loader = TextLoader(file_path, autodetect_encoding=True)
-            else:
-                loader = DoclingLoader(
-                    url=self.kwargs.get("DOCLING_SERVER_URL"),
-                    file_path=file_path,
-                    mime_type=file_content_type,
-                )
-        elif (
+        
+        if (
             self.engine == "document_intelligence"
             and self.kwargs.get("DOCUMENT_INTELLIGENCE_ENDPOINT") != ""
             and self.kwargs.get("DOCUMENT_INTELLIGENCE_KEY") != ""
@@ -231,53 +252,43 @@ def _get_loader(self, filename: str, file_content_type: str, file_path: str):
                 api_endpoint=self.kwargs.get("DOCUMENT_INTELLIGENCE_ENDPOINT"),
                 api_key=self.kwargs.get("DOCUMENT_INTELLIGENCE_KEY"),
             )
+        elif file_ext == "pdf":
+            loader = PyPDFLoader(
+                file_path, extract_images=self.kwargs.get("PDF_EXTRACT_IMAGES")
+            )
+        elif file_ext == "csv":
+            loader = CSVLoader(file_path, autodetect_encoding=True)
+        elif file_ext == "rst":
+            loader = UnstructuredRSTLoader(file_path, mode="elements")
+        elif file_ext == "xml":
+            loader = UnstructuredXMLLoader(file_path)
+        elif file_ext in ["htm", "html"]:
+            loader = BSHTMLLoader(file_path, open_encoding="unicode_escape")
+        elif file_ext == "md":
+            loader = TextLoader(file_path, autodetect_encoding=True)
+        elif file_content_type == "application/epub+zip":
+            loader = UnstructuredEPubLoader(file_path)
         elif (
-            self.engine == "mistral_ocr"
-            and self.kwargs.get("MISTRAL_OCR_API_KEY") != ""
-            and file_ext
-            in ["pdf"]  # Mistral OCR currently only supports PDF and images
+            file_content_type
+            == "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+            or file_ext == "docx"
         ):
-            loader = MistralLoader(
-                api_key=self.kwargs.get("MISTRAL_OCR_API_KEY"), file_path=file_path
-            )
+            loader = Docx2txtLoader(file_path)
+        elif file_content_type in [
+            "application/vnd.ms-excel",
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        ] or file_ext in ["xls", "xlsx"]:
+            loader = UnstructuredExcelLoader(file_path)
+        elif file_content_type in [
+            "application/vnd.ms-powerpoint",
+            "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        ] or file_ext in ["ppt", "pptx"]:
+            loader = UnstructuredPowerPointLoader(file_path)
+        elif file_ext == "msg":
+            loader = OutlookMessageLoader(file_path)
+        elif self._is_text_file(file_ext, file_content_type):
+            loader = TextLoader(file_path, autodetect_encoding=True)
         else:
-            if file_ext == "pdf":
-                loader = PyPDFLoader(
-                    file_path, extract_images=self.kwargs.get("PDF_EXTRACT_IMAGES")
-                )
-            elif file_ext == "csv":
-                loader = CSVLoader(file_path, autodetect_encoding=True)
-            elif file_ext == "rst":
-                loader = UnstructuredRSTLoader(file_path, mode="elements")
-            elif file_ext == "xml":
-                loader = UnstructuredXMLLoader(file_path)
-            elif file_ext in ["htm", "html"]:
-                loader = BSHTMLLoader(file_path, open_encoding="unicode_escape")
-            elif file_ext == "md":
-                loader = TextLoader(file_path, autodetect_encoding=True)
-            elif file_content_type == "application/epub+zip":
-                loader = UnstructuredEPubLoader(file_path)
-            elif (
-                file_content_type
-                == "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-                or file_ext == "docx"
-            ):
-                loader = Docx2txtLoader(file_path)
-            elif file_content_type in [
-                "application/vnd.ms-excel",
-                "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-            ] or file_ext in ["xls", "xlsx"]:
-                loader = UnstructuredExcelLoader(file_path)
-            elif file_content_type in [
-                "application/vnd.ms-powerpoint",
-                "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-            ] or file_ext in ["ppt", "pptx"]:
-                loader = UnstructuredPowerPointLoader(file_path)
-            elif file_ext == "msg":
-                loader = OutlookMessageLoader(file_path)
-            elif self._is_text_file(file_ext, file_content_type):
-                loader = TextLoader(file_path, autodetect_encoding=True)
-            else:
-                loader = TextLoader(file_path, autodetect_encoding=True)
+            loader = TextLoader(file_path, autodetect_encoding=True)
 
         return loader

backend/open_webui/retrieval/loaders/mistral.py

@@ -2,7 +2,7 @@
 import logging
 import os
 import sys
-from typing import List, Dict, Any
+from typing import List, Dict, Any, BinaryIO
 
 from langchain_core.documents import Document
 from open_webui.env import SRC_LOG_LEVELS, GLOBAL_LOG_LEVEL
@@ -19,21 +19,20 @@ class MistralLoader:
 
     BASE_API_URL = "https://api.mistral.ai/v1"
 
-    def __init__(self, api_key: str, file_path: str):
+    def __init__(self, api_key: str,file_name: str, file_stream: BinaryIO):
         """
         Initializes the loader.
 
         Args:
             api_key: Your Mistral API key.
-            file_path: The local path to the PDF file to process.
+            file_stream: The file stream of the PDF file to process.
         """
         if not api_key:
             raise ValueError("API key cannot be empty.")
-        if not os.path.exists(file_path):
-            raise FileNotFoundError(f"File not found at {file_path}")
 
         self.api_key = api_key
-        self.file_path = file_path
+        self.file_stream = file_stream
+        self.file_name = file_name
         self.headers = {"Authorization": f"Bearer {self.api_key}"}
 
     def _handle_response(self, response: requests.Response) -> Dict[str, Any]:
@@ -58,18 +57,17 @@ def _upload_file(self) -> str:
         """Uploads the file to Mistral for OCR processing."""
         log.info("Uploading file to Mistral API")
         url = f"{self.BASE_API_URL}/files"
-        file_name = os.path.basename(self.file_path)
 
         try:
-            with open(self.file_path, "rb") as f:
-                files = {"file": (file_name, f, "application/pdf")}
-                data = {"purpose": "ocr"}
 
-                upload_headers = self.headers.copy()  # Avoid modifying self.headers
+            files = {"file": (self.file_name, self.file_stream, "application/pdf")}
+            data = {"purpose": "ocr"}
 
-                response = requests.post(
-                    url, headers=upload_headers, files=files, data=data
-                )
+            upload_headers = self.headers.copy()  # Avoid modifying self.headers
+
+            response = requests.post(
+                url, headers=upload_headers, files=files, data=data
+            )
 
             response_data = self._handle_response(response)
             file_id = response_data.get("id")

backend/open_webui/routers/audio.py

@@ -7,7 +7,7 @@
 from pathlib import Path
 from pydub import AudioSegment
 from pydub.silence import split_on_silence
-
+from typing import BinaryIO
 import aiohttp
 import aiofiles
 import requests
@@ -484,6 +484,15 @@ async def speech(request: Request, user=Depends(get_verified_user)):
         return FileResponse(file_path)
 
 
+def transcribe_stream(request: Request, filename: str, file_stream: BinaryIO):
+    file_ext = filename.split(".")[-1].lower()
+    with tempfile.NamedTemporaryFile(delete=True, suffix=f".{file_ext}") as tmp_file:
+        tmp_file.write(file_stream.read())
+        tmp_file.flush()
+        tmp_path = tmp_file.name
+        transcribe(request, tmp_path)
+
+
 def transcribe(request: Request, file_path):
     log.info(f"transcribe: {file_path}")
     filename = os.path.basename(file_path)