.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -11,9 +11,9 @@ body:
 
         ## Important Notes
 
-        - **Before submitting a bug report**: Please check the [Issues](https://github.com/open-webui/open-webui/issues) and [Discussions](https://github.com/open-webui/open-webui/discussions) sections to see if a similar issue has already been reported. If unsure, start a discussion first, as this helps us efficiently focus on improving the project. Duplicates may be closed without notice. **Please search for existing issues AND discussions. No matter open or closed.**
+        - **Before submitting a bug report**: Please check the [Issues](https://github.com/open-webui/open-webui/issues) and [Discussions](https://github.com/open-webui/open-webui/discussions) sections to see if a similar issue has already been reported. If unsure, start a discussion first, as this helps us efficiently focus on improving the project. Duplicates may be closed without notice. **Please search for existing issues and discussions.**
 
-        - Check for opened, **but also for (recently) CLOSED issues** as the issue you are trying to report **might already have been fixed on the dev branch!**
+        - Check for opened, **but also for (recently) CLOSED issues** as the issue you are trying to report **might already have been fixed!**
 
         - **Respectful collaboration**: Open WebUI is a volunteer-driven project with a single maintainer and contributors who also have full-time jobs. Please be constructive and respectful in your communication.
 
@@ -21,8 +21,6 @@ body:
 
         - **Bug Reproducibility**: If a bug cannot be reproduced using a `:main` or `:dev` Docker setup or with `pip install` on Python 3.11, community assistance may be required. In such cases, we will move it to the "[Issues](https://github.com/open-webui/open-webui/discussions/categories/issues)" Discussions section. Your help is appreciated!
 
-        - **Scope**: If you want to report a SECURITY VULNERABILITY, then do so through our [GitHub security page](https://github.com/open-webui/open-webui/security).
-
   - type: checkboxes
     id: issue-check
     attributes:
@@ -33,8 +31,6 @@ body:
           required: true
         - label: I have searched for any existing and/or related discussions.
           required: true
-        - label: I have also searched in the CLOSED issues AND CLOSED discussions and found no related items (your issue might already be addressed on the development branch!).
-          required: true
         - label: I am using the latest version of Open WebUI.
           required: true
 

.github/ISSUE_TEMPLATE/feature_request.yaml

@@ -8,21 +8,11 @@ body:
       value: |
         ## Important Notes
         ### Before submitting
-        
-        Please check the **open AND closed** [Issues](https://github.com/open-webui/open-webui/issues) AND [Discussions](https://github.com/open-webui/open-webui/discussions) to see if a similar request has been posted.
+        Please check the open AND closed [Issues](https://github.com/open-webui/open-webui/issues) AND [Discussions](https://github.com/open-webui/open-webui/discussions) to see if a similar request has been posted.
         It's likely we're already tracking it! If you’re unsure, start a discussion post first.
-
-        #### Scope
-
-        If your feature request is likely to take more than a quick coding session to implement, test and verify, then open it in the **Ideas** section of the [Discussions](https://github.com/open-webui/open-webui/discussions) instead.
-        **We will close and force move your feature request to the Ideas section, if we believe your feature request is not trivial/quick to implement.**
-        This is to ensure the issues tab is used only for issues, quickly addressable feature requests and tracking tickets by the maintainers.
-        Other feature requests belong in the **Ideas** section of the [Discussions](https://github.com/open-webui/open-webui/discussions).
-        
-        If your feature request might impact others in the community, definitely open a discussion instead and evaluate whether and how to implement it.
-        
+        If your feature request might impact others in the community, consider opening a discussion instead and evaluate whether and how to implement it.
         This will help us efficiently focus on improving the project.
-        
+
         ### Collaborate respectfully
         We value a **constructive attitude**, so please be mindful of your communication. If negativity is part of your approach, our capacity to engage may be limited. We're here to help if you're **open to learning** and **communicating positively**.
 
@@ -33,6 +23,7 @@ body:
 
         We appreciate your time and ask that you **respect ours**.
 
+
         ### Contributing
         If you encounter an issue, we highly encourage you to submit a pull request or fork the project. We actively work to prevent contributor burnout to maintain the quality and continuity of Open WebUI.
 
@@ -45,22 +36,14 @@ body:
       label: Check Existing Issues
       description: Please confirm that you've checked for existing similar requests
       options:
-        - label: I have searched for all existing **open AND closed** issues and discussions for similar requests. I have found none that is comparable to my request.
-          required: true
-  - type: checkboxes
-    id: feature-scope
-    attributes:
-      label: Verify Feature Scope
-      description: Please confirm the feature's scope is within the described scope
-      options:
-        - label: I have read through and understood the scope definition for feature requests in the Issues section. I believe my feature request meets the definition and belongs in the Issues section instead of the Discussions.
+        - label: I have searched all existing open AND closed issues and discussions for similar requests. I have found none that is comparable to my request.
           required: true
   - type: textarea
     id: problem-description
     attributes:
       label: Problem Description
       description: Is your feature request related to a problem? Please provide a clear and concise description of what the problem is.
-      placeholder: "Ex. I'm always frustrated when... / Not related to a problem"
+      placeholder: "Ex. I'm always frustrated when..."
     validations:
       required: true
   - type: textarea

.github/pull_request_template.md

@@ -1,18 +1,16 @@
 # Pull Request Checklist
 
-### Note to first-time contributors: Please open a discussion post in [Discussions](https://github.com/open-webui/open-webui/discussions) to discuss your idea/fix with the community before creating a pull request, and describe your changes before submitting a pull request.
-
-This is to ensure large feature PRs are discussed with the community first, before starting work on it. If the community does not want this feature or it is not relevant for Open WebUI as a project, it can be identified in the discussion before working on the feature and submitting the PR.
+### Note to first-time contributors: Please open a discussion post in [Discussions](https://github.com/open-webui/open-webui/discussions) and describe your changes before submitting a pull request.
 
 **Before submitting, make sure you've checked the following:**
 
-- [ ] **Target branch:** Verify that the pull request targets the `dev` branch. **Not targeting the `dev` branch will lead to immediate closure of the PR.**
-- [ ] **Description:** Provide a concise description of the changes made in this pull request down below.
+- [ ] **Target branch:** Verify that the pull request targets the `dev` branch. Not targeting the `dev` branch may lead to immediate closure of the PR.
+- [ ] **Description:** Provide a concise description of the changes made in this pull request.
 - [ ] **Changelog:** Ensure a changelog entry following the format of [Keep a Changelog](https://keepachangelog.com/) is added at the bottom of the PR description.
 - [ ] **Documentation:** If necessary, update relevant documentation [Open WebUI Docs](https://github.com/open-webui/docs) like environment variables, the tutorials, or other documentation sources.
 - [ ] **Dependencies:** Are there any new dependencies? Have you updated the dependency versions in the documentation?
-- [ ] **Testing:** Perform manual tests to **verify the implemented fix/feature works as intended AND does not break any other functionality**. Take this as an opportunity to **make screenshots of the feature/fix and include it in the PR description**.
-- [ ] **Agentic AI Code:** Confirm this Pull Request is **not written by any AI Agent** or has at least **gone through additional human review AND manual testing**. If any AI Agent is the co-author of this PR, it may lead to immediate closure of the PR.
+- [ ] **Testing:** Perform manual tests to verify the implemented fix/feature works as intended AND does not break any other functionality. Take this as an opportunity to make screenshots of the feature/fix and include it in the PR description.
+- [ ] **Agentic AI Code:**: Confirm this Pull Request is **not written by any AI Agent** or has at least gone through additional human review **and** manual testing. If any AI Agent is the co-author of this PR, it may lead to immediate closure of the PR.
 - [ ] **Code review:** Have you performed a self-review of your code, addressing any coding standard issues and ensuring adherence to the project's coding standards?
 - [ ] **Title Prefix:** To clearly categorize this pull request, prefix the pull request title using one of the following:
   - **BREAKING CHANGE**: Significant changes that may affect compatibility
@@ -77,6 +75,3 @@ This is to ensure large feature PRs are discussed with the community first, befo
 ### Contributor License Agreement
 
 By submitting this pull request, I confirm that I have read and fully agree to the [Contributor License Agreement (CLA)](https://github.com/open-webui/open-webui/blob/main/CONTRIBUTOR_LICENSE_AGREEMENT), and I am providing my contributions under its terms.
-
-> [!NOTE]
-> Deleting the CLA section will lead to immediate closure of your PR and it will not be merged in.

.github/workflows/docker-build.yaml

@@ -141,9 +141,6 @@ jobs:
           platform=${{ matrix.platform }}
           echo "PLATFORM_PAIR=${platform//\//-}" >> $GITHUB_ENV
 
-      - name: Delete huge unnecessary tools folder
-        run: rm -rf /opt/hostedtoolcache
-
       - name: Checkout repository
         uses: actions/checkout@v5
 
@@ -246,9 +243,6 @@ jobs:
           platform=${{ matrix.platform }}
           echo "PLATFORM_PAIR=${platform//\//-}" >> $GITHUB_ENV
 
-      - name: Delete huge unnecessary tools folder
-        run: rm -rf /opt/hostedtoolcache
-
       - name: Checkout repository
         uses: actions/checkout@v5
 

CHANGELOG.md

@@ -5,307 +5,6 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.6.41] - 2025-12-02
-
-### Added
-
-- 🚦 Sign-in rate limiting was implemented to protect against brute force attacks, limiting login attempts to 15 per 3-minute window per email address using Redis with automatic fallback to in-memory storage when Redis is unavailable. [Commit](https://github.com/open-webui/open-webui/commit/7b166370432414ce8f186747fb098e0c70fb2d6b)
-- 📂 Administrators can now globally disable the folders feature and control user-level folder permissions through the admin panel, enabling minimalist interface configurations for deployments that don't require workspace organization features. [#19529](https://github.com/open-webui/open-webui/pull/19529), [#19210](https://github.com/open-webui/open-webui/discussions/19210), [#18459](https://github.com/open-webui/open-webui/discussions/18459), [#18299](https://github.com/open-webui/open-webui/discussions/18299)
-- 👥 Group channels were introduced as a new channel type enabling membership-based collaboration spaces where users explicitly join as members rather than accessing through permissions, with support for public or private visibility, automatic member inclusion from specified user groups, member role tracking with invitation metadata, and post-creation member management allowing channel managers to add or remove members through the channel info modal. [Commit](https://github.com/open-webui/open-webui/commit/f589b7c1895a6a77166c047891acfa21bc0936c4), [Commit](https://github.com/open-webui/open-webui/commit/3f1d9ccbf8443a2fa5278f36202bad930a216680)
-- 💬 Direct Message channels were introduced with a dedicated channel type selector and multi-user member selection interface, enabling private conversations between specific users without requiring full channel visibility. [Commit](https://github.com/open-webui/open-webui/commit/64b4d5d9c280b926746584aaf92b447d09deb386)
-- 📨 Direct Message channels now support a complete user-to-user messaging system with member-based access control, automatic deduplication for one-on-one conversations, optional channel naming, and distinct visual presentation using participant avatars instead of channel icons. [Commit](https://github.com/open-webui/open-webui/commit/acccb9afdd557274d6296c70258bb897bbb6652f)
-- 🙈 Users can now hide Direct Message channels from their sidebar while preserving message history, with automatic reactivation when new messages arrive from other participants, providing a cleaner interface for managing active conversations. [Commit](https://github.com/open-webui/open-webui/commit/acccb9afdd557274d6296c70258bb897bbb6652f)
-- ☑️ A comprehensive user selection component was added to the channel creation modal, featuring search functionality, sortable user lists, pagination support, and multi-select checkboxes for building Direct Message participant lists. [Commit](https://github.com/open-webui/open-webui/commit/acccb9afdd557274d6296c70258bb897bbb6652f)
-- 🔴 Channel unread message count tracking was implemented with visual badge indicators in the sidebar, automatically updating counts in real-time and marking messages as read when users view channels, with join/leave functionality to manage membership status. [Commit](https://github.com/open-webui/open-webui/commit/64b4d5d9c280b926746584aaf92b447d09deb386)
-- 📌 Message pinning functionality was added to channels, allowing users to pin important messages for easy reference with visual highlighting, a dedicated pinned messages modal accessible from the navbar, and complete backend support for tracking pinned status, pin timestamp, and the user who pinned each message. [Commit](https://github.com/open-webui/open-webui/commit/64b4d5d9c280b926746584aaf92b447d09deb386), [Commit](https://github.com/open-webui/open-webui/commit/aae2fce17355419d9c29f8100409108037895201)
-- 🟢 Direct Message channels now display an active status indicator for one-on-one conversations, showing a green dot when the other participant is currently online or a gray dot when offline. [Commit](https://github.com/open-webui/open-webui/commit/4b6773885cd7527c5a56b963781dac5e95105eec), [Commit](https://github.com/open-webui/open-webui/commit/39645102d14f34e71b34e5ddce0625790be33f6f)
-- 🆔 Users can now start Direct Message conversations directly from user profile previews by clicking the "Message" button, enabling quick access to private messaging without navigating away from the current channel. [Commit](https://github.com/open-webui/open-webui/commit/a0826ec9fedb56320532616d568fa59dda831d4e)
-- ⚡ Channel messages now appear instantly when sent using optimistic UI rendering, displaying with a pending state while the server confirms delivery, providing a more responsive messaging experience. [Commit](https://github.com/open-webui/open-webui/commit/25994dd3da90600401f53596d4e4fb067c1b8eaa)
-- 👍 Channel message reactions now display the names of users who reacted when hovering over the emoji, showing up to three names with a count for additional reactors. [Commit](https://github.com/open-webui/open-webui/commit/05e79bdd0c7af70b631e958924e3656db1013b80)
-- 🛠️ Channel creators can now edit and delete their own group and DM channels without requiring administrator privileges, enabling users to manage the channels they create independently. [Commit](https://github.com/open-webui/open-webui/commit/f589b7c1895a6a77166c047891acfa21bc0936c4)
-- 🔌 A new API endpoint was added to directly get or create a Direct Message channel with a specific user by their ID, streamlining programmatic DM channel creation for integrations and frontend workflows. [Commit](https://github.com/open-webui/open-webui/commit/f589b7c1895a6a77166c047891acfa21bc0936c4)
-- 💭 Users can now set a custom status with an emoji and message that displays in profile previews, the sidebar user menu, and Direct Message channel items in the sidebar, with the ability to clear status at any time, providing visibility into availability or current focus similar to team communication platforms. [Commit](https://github.com/open-webui/open-webui/commit/51621ba91a982e52da168ce823abffd11ad3e4fa), [Commit](https://github.com/open-webui/open-webui/commit/f5e8d4d5a004115489c35725408b057e24dfe318)
-- 📤 A group export API endpoint was added, enabling administrators to export complete group data including member lists for backup and migration purposes. [Commit](https://github.com/open-webui/open-webui/commit/09b6ea38c579659f8ca43ae5ea3746df3ac561ad)
-- 📡 A new API endpoint was added to retrieve all users belonging to a specific group, enabling programmatic access to group membership information for administrative workflows. [Commit](https://github.com/open-webui/open-webui/commit/01868e856a10f474f74fbd1b4425dafdf949222f)
-- 👁️ The admin user list now displays an active status indicator next to each user, showing a visual green dot for users who have been active within the last three minutes. [Commit](https://github.com/open-webui/open-webui/commit/1b095d12ff2465b83afa94af89ded9593f8a8655)
-- 🔑 The admin user edit modal now displays OAuth identity information with a per-provider breakdown, showing each linked identity provider and its associated subject identifier separately. [#19573](https://github.com/open-webui/open-webui/pull/19573)
-- 🧩 OAuth role claim parsing now respects the "OAUTH_ROLES_SEPARATOR" configuration, enabling proper parsing of roles returned as comma-separated strings and providing consistent behavior with group claim handling. [#19514](https://github.com/open-webui/open-webui/pull/19514)
-- 🎛️ Channel feature access can now be controlled through both the "USER_PERMISSIONS_FEATURES_CHANNELS" environment variable and group permission toggles in the admin panel, allowing administrators to restrict channel functionality for specific users or groups while defaulting to enabled for all users. [Commit](https://github.com/open-webui/open-webui/commit/f589b7c1895a6a77166c047891acfa21bc0936c4)
-- 🎨 The model editor interface was refined with access control settings moved to a dedicated modal, group member counts now displayed when configuring permissions, reorganized layout with improved visual hierarchy, and redesigned prompt suggestions cards with tooltips for field guidance. [Commit](https://github.com/open-webui/open-webui/commit/e65d92fc6f49da5ca059e1c65a729e7973354b99), [Commit](https://github.com/open-webui/open-webui/commit/9d39b9b42c653ee2acf2674b2df343ecbceb4954)
-- 🏗️ Knowledge base file management was rebuilt with a dedicated database table replacing the previous JSON array storage, enabling pagination support for large knowledge bases, significantly faster file listing performance, and more reliable file-knowledge base relationship tracking. [Commit](https://github.com/open-webui/open-webui/commit/d19023288e2ca40f86e2dc3fd9f230540f3e70d7)
-- ☁️ Azure Document Intelligence model selection was added, allowing administrators to specify which model to use for document processing via the "DOCUMENT_INTELLIGENCE_MODEL" environment variable or admin UI setting, with "prebuilt-layout" as the default. [#19692](https://github.com/open-webui/open-webui/pull/19692), [Docs:#872](https://github.com/open-webui/docs/pull/872)
-- 🚀 Milvus multitenancy vector database performance was improved by removing manual flush calls after upsert operations, eliminating rate limit errors and reducing load on etcd and MinIO/S3 storage by allowing Milvus to manage segment persistence automatically via its WAL and auto-flush policies. [#19680](https://github.com/open-webui/open-webui/pull/19680)
-- ✨ Various improvements were implemented across the frontend and backend to enhance performance, stability, and security.
-- 🌍 Translations for German, French, Portuguese (Brazil), Catalan, Simplified Chinese, and Traditional Chinese were enhanced and expanded.
-
-### Fixed
-
-- 🔄 Tool call response token duplication was fixed by removing redundant message history additions in non-native function calling mode, resolving an issue where tool results were included twice in the context and causing 2x token consumption. [#19656](https://github.com/open-webui/open-webui/issues/19656), [Commit](https://github.com/open-webui/open-webui/commit/52ccab8)
-- 🛡️ Web search domain filtering was corrected to properly block results when any resolved hostname or IP address matches a blocked domain, preventing blocked sites from appearing in search results due to permissive hostname resolution logic that previously allowed results through if any single resolved address passed the filter. [#19670](https://github.com/open-webui/open-webui/pull/19670), [#19669](https://github.com/open-webui/open-webui/issues/19669)
-- 🧠 Custom models based on Ollama or OpenAI now properly inherit the connection type from their base model, ensuring they appear correctly in the "Local" or "External" model selection tabs instead of only appearing under "All". [#19183](https://github.com/open-webui/open-webui/issues/19183), [Commit](https://github.com/open-webui/open-webui/commit/39f7575)
-- 🐍 SentenceTransformers embedding initialization was fixed by updating the transformers dependency to version 4.57.3, resolving a regression in v0.6.40 where document ingestion failed with "'NoneType' object has no attribute 'encode'" errors due to a bug in transformers 4.57.2. [#19512](https://github.com/open-webui/open-webui/issues/19512), [#19513](https://github.com/open-webui/open-webui/pull/19513)
-- 📈 Active user count accuracy was significantly improved by replacing the socket-based USER_POOL tracking with a database-backed heartbeat mechanism, resolving long-standing issues where Redis deployments displayed inflated user counts due to stale sessions never being cleaned up on disconnect. [#16074](https://github.com/open-webui/open-webui/discussions/16074), [Commit](https://github.com/open-webui/open-webui/commit/70948f8803e417459d5203839f8077fdbfbbb213)
-- 👥 Default group assignment now applies consistently across all user registration methods including OAuth/SSO, LDAP, and admin-created users, fixing an issue where the "DEFAULT_GROUP_ID" setting was only being applied to users who signed up via the email/password signup form. [#19685](https://github.com/open-webui/open-webui/pull/19685)
-- 🔦 Model list filtering in workspaces was corrected to properly include models shared with user groups, ensuring members can view models they have write access to through group permissions. [#19461](https://github.com/open-webui/open-webui/issues/19461), [Commit](https://github.com/open-webui/open-webui/commit/69722ba973768a5f689f2e2351bf583a8db9bba8)
-- 🖼️ User profile image display in preview contexts was fixed by resolving a Pydantic validation error that prevented proper rendering. [Commit](https://github.com/open-webui/open-webui/commit/c7eb7136893b0ddfdc5d55ffc7a05bd84a00f5d6)
-- 🔒 Redis TLS connection failures were resolved by updating the python-socketio dependency to version 5.15.0, restoring support for the "rediss://" URL schema. [#19480](https://github.com/open-webui/open-webui/issues/19480), [#19488](https://github.com/open-webui/open-webui/pull/19488)
-- 📝 MCP tool server configuration was corrected to properly handle the "Function Name Filter List" as both string and list types, preventing AttributeError when the field is empty and ensuring backward compatibility. [#19486](https://github.com/open-webui/open-webui/issues/19486), [Commit](https://github.com/open-webui/open-webui/commit/c5b73d71843edc024325d4a6e625ec939a747279), [Commit](https://github.com/open-webui/open-webui/commit/477097c2e42985c14892301d0127314629d07df1)
-- 📎 Web page attachment failures causing TypeError on metadata checks were resolved by correcting async threadpool parameter passing in vector database operations. [#19493](https://github.com/open-webui/open-webui/issues/19493), [Commit](https://github.com/open-webui/open-webui/commit/4370dee79e19d77062c03fba81780cb3b779fca3)
-- 💾 Model allowlist persistence in multi-worker deployments was fixed by implementing Redis-based shared state for the internal models dictionary, ensuring configuration changes are consistently visible across all worker processes. [#19395](https://github.com/open-webui/open-webui/issues/19395), [Commit](https://github.com/open-webui/open-webui/commit/b5e5617d7f7ad3e4eec9f15f4cc7f07cb5afc2fa)
-- ⏳ Chat history infinite loading was prevented by enhancing message data structure to properly track parent message relationships, resolving issues where missing parentId fields caused perpetual loading states. [#19225](https://github.com/open-webui/open-webui/issues/19225), [Commit](https://github.com/open-webui/open-webui/commit/ff4b1b9862d15adfa15eac17d2ce066c3d8ae38f)
-- 🩹 Database migration robustness was improved by automatically detecting and correcting missing primary key constraints on the user table, ensuring successful schema upgrades for databases with non-standard configurations. [#19487](https://github.com/open-webui/open-webui/discussions/19487), [Commit](https://github.com/open-webui/open-webui/commit/453ea9b9a167c0b03d86c46e6efd086bf10056ce)
-- 🏷️ OAuth group assignment now updates correctly on first login when users transition from admin to user role, ensuring group memberships reflect immediately when group management is enabled. [#19475](https://github.com/open-webui/open-webui/issues/19475), [#19476](https://github.com/open-webui/open-webui/pull/19476)
-- 💡 Knowledge base file tooltips now properly display the parent collection name when referencing files with the hash symbol, preventing confusion between identically-named files in different collections. [#19491](https://github.com/open-webui/open-webui/issues/19491), [Commit](https://github.com/open-webui/open-webui/commit/3fe5a47b0ff84ac97f8e4ff56a19fa2ec065bf66)
-- 🔐 Knowledge base file access inconsistencies were resolved where authorized non-admin users received "Not found" or permission errors for certain files due to race conditions during upload causing mismatched collection_name values, with file access validation now properly checking against knowledge base file associations. [#18689](https://github.com/open-webui/open-webui/issues/18689), [#19523](https://github.com/open-webui/open-webui/pull/19523), [Commit](https://github.com/open-webui/open-webui/commit/e301d1962e45900ababd3eabb7e9a2ad275a5761)
-- 📦 Knowledge API batch file addition endpoint was corrected to properly handle async operations, resolving 500 Internal Server Error responses when adding multiple files simultaneously. [#19538](https://github.com/open-webui/open-webui/issues/19538), [Commit](https://github.com/open-webui/open-webui/commit/28659f60d94feb4f6a99bb1a5b54d7f45e5ea10f)
-- 🤖 Embedding model auto-update functionality was fixed to properly respect the "RAG_EMBEDDING_MODEL_AUTO_UPDATE" setting by correctly passing the flag to the model path resolver, ensuring models update as expected when the auto-update option is enabled. [#19687](https://github.com/open-webui/open-webui/pull/19687)
-- 📉 API response payload sizes were dramatically reduced by removing base64-encoded profile images from most endpoints, eliminating multi-megabyte responses caused by high-resolution avatars and enabling better browser caching. [#19519](https://github.com/open-webui/open-webui/issues/19519), [Commit](https://github.com/open-webui/open-webui/commit/384753c4c17f62a68d38af4bbcf55a21ee08e0f2)
-- 📞 Redundant API calls on the admin user overview page were eliminated by consolidating reactive statements, reducing four duplicate requests to a single efficient call and significantly improving page load performance. [#19509](https://github.com/open-webui/open-webui/issues/19509), [Commit](https://github.com/open-webui/open-webui/commit/9f89cc5e9f7e1c6c9e2bc91177e08df7c79f66f9)
-- 🧹 Duplicate API calls on the workspace models page were eliminated by removing redundant model list fetching, reducing two identical requests to a single call and improving page responsiveness. [#19517](https://github.com/open-webui/open-webui/issues/19517), [Commit](https://github.com/open-webui/open-webui/commit/d1bbf6be7a4d1d53fa8ad46ca4f62fc4b2e6a8cb)
-- 🔘 The model valves button was corrected to prevent unintended form submission by adding explicit button type attribute, ensuring it no longer triggers message sending when the input area contains text. [#19534](https://github.com/open-webui/open-webui/pull/19534)
-- 🗑️ Ollama model deletion was fixed by correcting the request payload format and ensuring the model selector properly displays the placeholder option. [Commit](https://github.com/open-webui/open-webui/commit/0f3156651c64bc5af188a65fc2908bdcecf30c74)
-- 🎨 Image generation in temporary chats was fixed by correctly handling local chat sessions that are not persisted to the database. [Commit](https://github.com/open-webui/open-webui/commit/a7c7993bbf3a21cb7ba416525b89233cf2ad877f)
-- 🕵️‍♂️ Audit logging was fixed by correctly awaiting the async user authentication call, resolving failures where coroutine objects were passed instead of user data. [#19658](https://github.com/open-webui/open-webui/pull/19658), [Commit](https://github.com/open-webui/open-webui/commit/dba86bc)
-- 🌙 Dark mode select dropdown styling was corrected to use proper background colors, fixing an issue where dropdown borders and hover states appeared white instead of matching the dark theme. [#19693](https://github.com/open-webui/open-webui/pull/19693), [#19442](https://github.com/open-webui/open-webui/issues/19442)
-- 🔍 Milvus vector database query filtering was fixed by correcting string quote handling in filter expressions and using the proper parameter name for queries, resolving false "duplicate content detected" errors that prevented uploading multiple files to knowledge bases. [#19602](https://github.com/open-webui/open-webui/pull/19602), [#18119](https://github.com/open-webui/open-webui/issues/18119), [#16345](https://github.com/open-webui/open-webui/issues/16345), [#17088](https://github.com/open-webui/open-webui/issues/17088), [#18485](https://github.com/open-webui/open-webui/issues/18485)
-- 🆙 Milvus multitenancy vector database was updated to use query_iterator() for improved robustness and consistency with the standard Milvus implementation, fixing the same false duplicate detection errors and improving handling of large result sets in multi-tenant deployments. [#19695](https://github.com/open-webui/open-webui/pull/19695)
-
-### Changed
-
-- ⚠️ **IMPORTANT for Multi-Instance Deployments** — This release includes database schema changes; multi-worker, multi-server, or load-balanced deployments must update all instances simultaneously rather than performing rolling updates, as running mixed versions will cause application failures due to schema incompatibility between old and new instances.
-- 👮 Channel creation is now restricted to administrators only, with the channel add button hidden for regular users to maintain organizational control over communication channels. [Commit](https://github.com/open-webui/open-webui/commit/421aba7cd7cd708168b1f2565026c74525a67905)
-- ➖ The active user count indicator was removed from the bottom-left user menu in the sidebar to streamline the interface. [Commit](https://github.com/open-webui/open-webui/commit/848f3fd4d86ca66656e0ff0335773945af8d7d8d)
-- 🗂️ The user table was restructured with API keys migrated to a dedicated table supporting future multi-key functionality, OAuth data storage converted to a JSON structure enabling multiple identity providers per user account, and internal column types optimized from TEXT to JSON for the "info" and "settings" fields, with automatic migration preserving all existing data and associations. [#19573](https://github.com/open-webui/open-webui/pull/19573)
-- 🔄 The knowledge base API was restructured to support the new file relationship model.
-
-## [0.6.40] - 2025-11-25
-
-### Fixed
-
-- 🗄️ A critical PostgreSQL user listing performance issue was resolved by removing a redundant count operation that caused severe database slowdowns and potential timeouts when viewing user lists in admin panels.
-
-## [0.6.39] - 2025-11-25
-
-### Added
-
-- 💬 A user list modal was added to channels, displaying all users with access and featuring search, sorting, and pagination capabilities. [Commit](https://github.com/open-webui/open-webui/commit/c0e120353824be00a2ef63cbde8be5d625bd6fd0)
-- 💬 Channel navigation now displays the total number of users with access to the channel. [Commit](https://github.com/open-webui/open-webui/commit/3b5710d0cd445cf86423187f5ee7c40472a0df0b)
-- 🔌 Tool servers and MCP connections now support function name filtering, allowing administrators to selectively enable or block specific functions using allow/block lists. [Commit](https://github.com/open-webui/open-webui/commit/743199f2d097ae1458381bce450d9025a0ab3f3d)
-- ⚡ A toggle to disable parallel embedding processing was added via "ENABLE_ASYNC_EMBEDDING", allowing sequential processing for rate-limited or resource-constrained local embedding setups. [#19444](https://github.com/open-webui/open-webui/pull/19444)
-- 🔄 Various improvements were implemented across the frontend and backend to enhance performance, stability, and security.
-- 🌐 Localization improvements were made for German (de-DE) and Portuguese (Brazil) translations.
-
-### Fixed
-
-- 📝 Inline citations now render correctly within markdown lists and nested elements instead of displaying as "undefined" values. [#19452](https://github.com/open-webui/open-webui/issues/19452)
-- 👥 Group member selection now works correctly without randomly selecting other users or causing the user list to jump around. [#19426](https://github.com/open-webui/open-webui/issues/19426)
-- 👥 Admin panel user list now displays the correct total user count and properly paginates 30 items per page after fixing database query issues with group member joins. [#19429](https://github.com/open-webui/open-webui/issues/19429)
-- 🔍 Knowledge base reindexing now works correctly after resolving async execution chain issues by implementing threadpool workers for embedding operations. [#19434](https://github.com/open-webui/open-webui/pull/19434)
-- 🖼️ OpenAI image generation now works correctly after fixing a connection adapter error caused by incorrect URL formatting. [#19435](https://github.com/open-webui/open-webui/pull/19435)
-
-### Changed
-
-- 🔧 BREAKING: Docling configuration has been consolidated from individual environment variables into a single "DOCLING_PARAMS" JSON configuration and now supports API key authentication via "DOCLING_API_KEY", requiring users to migrate existing Docling settings to the new format. [#16841](https://github.com/open-webui/open-webui/issues/16841), [#19427](https://github.com/open-webui/open-webui/pull/19427)
-- 🔧 The environment variable "REPLACE_IMAGE_URLS_IN_CHAT_RESPONSE" has been renamed to "ENABLE_CHAT_RESPONSE_BASE64_IMAGE_URL_CONVERSION" for naming consistency.
-
-## [0.6.38] - 2025-11-24
-
-### Fixed
-
-- 🔍 Hybrid search now works reliably after recent changes.
-- 🛠️ Tool server saving now handles errors gracefully, preventing failed saves from impacting the UI.
-- 🔐 SSO/OIDC code fixed to improve login reliability and better handle edge cases.
-
-## [0.6.37] - 2025-11-24
-
-### Added
-
-- 🔐 Granular sharing permissions are now available with two-tiered control separating group sharing from public sharing, allowing administrators to independently configure whether users can share workspace items with groups or make them publicly accessible, with separate permission toggles for models, knowledge bases, prompts, tools, and notes, configurable via "USER_PERMISSIONS_WORKSPACE_MODELS_ALLOW_SHARING", "USER_PERMISSIONS_WORKSPACE_MODELS_ALLOW_PUBLIC_SHARING", and corresponding environment variables for other workspace item types, while groups can now be configured to opt-out of sharing via the "Allow Group Sharing" setting. [Commit](https://github.com/open-webui/open-webui/commit/7be750bcbb40da91912a0a66b7ab791effdcc3b6), [Commit](https://github.com/open-webui/open-webui/commit/f69e37a8507d6d57382d6670641b367f3127f90a)
-- 🔐 Password policy enforcement is now available with configurable validation rules, allowing administrators to require specific password complexity requirements via "ENABLE_PASSWORD_VALIDATION" and "PASSWORD_VALIDATION_REGEX_PATTERN" environment variables, with default pattern requiring minimum 8 characters including uppercase, lowercase, digit, and special character. [#17794](https://github.com/open-webui/open-webui/pull/17794)
-- 🔐 Granular import and export permissions are now available for workspace items, introducing six separate permission toggles for models, prompts, and tools that are disabled by default for enhanced security. [#19242](https://github.com/open-webui/open-webui/pull/19242)
-- 👥 Default group assignment is now available for new users, allowing administrators to automatically assign newly registered users to a specified group for streamlined access control to models, prompts, and tools, particularly useful for organizations with group-based model access policies. [#19325](https://github.com/open-webui/open-webui/pull/19325), [#17842](https://github.com/open-webui/open-webui/issues/17842)
-- 🔒 Password-based authentication can now be fully disabled via "ENABLE_PASSWORD_AUTH" environment variable, enforcing SSO-only authentication and preventing password login fallback when SSO is configured. [#19113](https://github.com/open-webui/open-webui/pull/19113)
-- 🖼️ Large stream chunk handling was implemented to support models that generate images directly in their output responses, with configurable buffer size via "CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE" environment variable, resolving compatibility issues with models like Gemini 2.5 Flash Image. [#18884](https://github.com/open-webui/open-webui/pull/18884), [#17626](https://github.com/open-webui/open-webui/issues/17626)
-- 🖼️ Streaming response middleware now handles images in delta updates with automatic base64 conversion, enabling proper display of images from models using the "choices[0].delta.images.image_url" format such as Gemini 2.5 Flash Image Preview on OpenRouter. [#19073](https://github.com/open-webui/open-webui/pull/19073), [#19019](https://github.com/open-webui/open-webui/issues/19019)
-- 📈 Model list API performance was optimized by pre-fetching user group memberships and removing profile image URLs from response payloads, significantly reducing both database queries and payload size for instances with large model lists, with profile images now served dynamically via dedicated endpoints. [#19097](https://github.com/open-webui/open-webui/pull/19097), [#18950](https://github.com/open-webui/open-webui/issues/18950)
-- ⏩ Batch file processing performance was improved by reducing database queries by 67% while ensuring data consistency between vector and relational databases. [#18953](https://github.com/open-webui/open-webui/pull/18953)
-- 🚀 Chat import performance was dramatically improved by replacing individual per-chat API requests with a bulk import endpoint, reducing import time by up to 95% for large chat collections and providing user feedback via toast notifications displaying the number of successfully imported chats. [#17861](https://github.com/open-webui/open-webui/pull/17861)
-- ⚡ Socket event broadcasting performance was optimized by implementing user-specific rooms, significantly reducing server overhead particularly for users with multiple concurrent sessions. [#18996](https://github.com/open-webui/open-webui/pull/18996)
-- 🗄️ Weaviate is now supported as a vector database option, providing an additional choice for RAG document storage alongside existing ChromaDB, Milvus, Qdrant, and OpenSearch integrations. [#14747](https://github.com/open-webui/open-webui/pull/14747)
-- 🗄️ PostgreSQL pgvector now supports HNSW index types and large dimensional embeddings exceeding 2000 dimensions through automatic halfvec type selection, with configurable index methods via "PGVECTOR_INDEX_METHOD", "PGVECTOR_HNSW_M", "PGVECTOR_HNSW_EF_CONSTRUCTION", and "PGVECTOR_IVFFLAT_LISTS" environment variables. [#19158](https://github.com/open-webui/open-webui/pull/19158), [#16890](https://github.com/open-webui/open-webui/issues/16890)
-- 🔍 Azure AI Search is now supported as a web search provider, enabling integration with Azure's cognitive search services via "AZURE_AI_SEARCH_API_KEY", "AZURE_AI_SEARCH_ENDPOINT", and "AZURE_AI_SEARCH_INDEX_NAME" configuration. [#19104](https://github.com/open-webui/open-webui/pull/19104)
-- ⚡ External embedding generation now processes API requests in parallel instead of sequential batches, reducing document processing time by 10-50x when using OpenAI, Azure OpenAI, or Ollama embedding providers, with large PDFs now processing in seconds instead of minutes. [#19296](https://github.com/open-webui/open-webui/pull/19296)
-- 💨 Base64 image conversion is now available for markdown content in chat responses, automatically uploading embedded images exceeding 1KB and replacing them with file URLs to reduce payload size and resource consumption, configurable via "REPLACE_IMAGE_URLS_IN_CHAT_RESPONSE" environment variable. [#19076](https://github.com/open-webui/open-webui/pull/19076)
-- 🎨 OpenAI image generation now supports additional API parameters including quality settings for GPT Image 1, configurable via "IMAGES_OPENAI_API_PARAMS" environment variable or through the admin interface, enabling cost-effective image generation with low, medium, or high quality options. [#19228](https://github.com/open-webui/open-webui/issues/19228)
-- 🖼️ Image editing can now be independently enabled or disabled via admin settings, allowing administrators to control whether sequential image prompts trigger image editing or new image generation, configurable via "ENABLE_IMAGE_EDIT" environment variable. [#19284](https://github.com/open-webui/open-webui/issues/19284)
-- 🔐 SSRF protection was implemented with a configurable URL blocklist that prevents access to cloud metadata endpoints and private networks, with default protections for AWS, Google Cloud, Azure, and Alibaba Cloud metadata services, customizable via "WEB_FETCH_FILTER_LIST" environment variable. [#19201](https://github.com/open-webui/open-webui/pull/19201)
-- ⚡ Workspace models page now supports server-side pagination dramatically improving load times and usability for instances with large numbers of workspace models.
-- 🔍 Hybrid search now indexes file metadata including filenames, titles, headings, sources, and snippets alongside document content, enabling keyword queries to surface documents where search terms appear only in metadata, configurable via "ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS" environment variable. [#19095](https://github.com/open-webui/open-webui/pull/19095)
-- 📂 Knowledge base upload page now supports folder drag-and-drop with recursive directory handling, enabling batch uploads of entire directory structures instead of requiring individual file selection. [#19320](https://github.com/open-webui/open-webui/pull/19320)
-- 🤖 Model cloning is now available in admin settings, allowing administrators to quickly create workspace models based on existing base models through a "Clone" option in the model dropdown menu. [#17937](https://github.com/open-webui/open-webui/pull/17937)
-- 🎨 UI scale adjustment is now available in interface settings, allowing users to increase the size of the entire interface from 1.0x to 1.5x for improved accessibility and readability, particularly beneficial for users with visual impairments. [#19186](https://github.com/open-webui/open-webui/pull/19186)
-- 📌 Default pinned models can now be configured by administrators for all new users, mirroring the behavior of default models where admin-configured defaults apply only to users who haven't customized their pinned models, configurable via "DEFAULT_PINNED_MODELS" environment variable. [#19273](https://github.com/open-webui/open-webui/pull/19273)
-- 🎙️ Text-to-Speech and Speech-to-Text services now receive user information headers when "ENABLE_FORWARD_USER_INFO_HEADERS" is enabled, allowing external TTS and STT providers to implement user-specific personalization, rate limiting, and usage tracking. [#19323](https://github.com/open-webui/open-webui/pull/19323), [#19312](https://github.com/open-webui/open-webui/issues/19312)
-- 🎙️ Voice mode now supports custom system prompts via "VOICE_MODE_PROMPT_TEMPLATE" configuration, allowing administrators to control response style and behavior for voice interactions. [#18607](https://github.com/open-webui/open-webui/pull/18607)
-- 🔧 WebSocket and Redis configuration options are now available including debug logging controls, custom ping timeout and interval settings, and arbitrary Redis connection options via "WEBSOCKET_SERVER_LOGGING", "WEBSOCKET_SERVER_ENGINEIO_LOGGING", "WEBSOCKET_SERVER_PING_TIMEOUT", "WEBSOCKET_SERVER_PING_INTERVAL", and "WEBSOCKET_REDIS_OPTIONS" environment variables. [#19091](https://github.com/open-webui/open-webui/pull/19091)
-- 🔧 MCP OAuth dynamic client registration now automatically detects and uses the appropriate token endpoint authentication method from server-supported options, enabling compatibility with OAuth servers that only support "client_secret_basic" instead of "client_secret_post". [#19193](https://github.com/open-webui/open-webui/issues/19193)
-- 🔧 Custom headers can now be configured for remote MCP and OpenAPI tool server connections, enabling integration with services that require additional authentication headers. [#18918](https://github.com/open-webui/open-webui/issues/18918)
-- 🔍 Perplexity Search now supports custom API endpoints via "PERPLEXITY_SEARCH_API_URL" configuration and automatically forwards user information headers to enable personalized search experiences. [#19147](https://github.com/open-webui/open-webui/pull/19147)
-- 🔍 User information headers can now be optionally forwarded to external web search engines when "ENABLE_FORWARD_USER_INFO_HEADERS" is enabled. [#19043](https://github.com/open-webui/open-webui/pull/19043)
-- 📊 Daily active user metric is now available for monitoring, tracking unique users active since midnight UTC via the "webui.users.active.today" Prometheus gauge. [#19236](https://github.com/open-webui/open-webui/pull/19236), [#19234](https://github.com/open-webui/open-webui/issues/19234)
-- 📊 Audit log file path is now configurable via "AUDIT_LOGS_FILE_PATH" environment variable, enabling storage in separate volumes or custom locations. [#19173](https://github.com/open-webui/open-webui/pull/19173)
-- 🎨 Sidebar collapse states for model lists and group information are now persistent across page refreshes, remembering user preferences through browser-based storage. [#19159](https://github.com/open-webui/open-webui/issues/19159)
-- 🎨 Background image display was enhanced with semi-transparent overlays for navbar and sidebar, creating a seamless and visually cohesive design across the entire interface. [#19157](https://github.com/open-webui/open-webui/issues/19157)
-- 📋 Tables in chat messages now include a copy button that appears on hover, enabling quick copying of table content alongside the existing CSV export functionality. [#19162](https://github.com/open-webui/open-webui/issues/19162)
-- 📝 Notes can now be created directly via the "/notes/new" URL endpoint with optional title and content query parameters, enabling faster note creation through bookmarks and shortcuts. [#19195](https://github.com/open-webui/open-webui/issues/19195)
-- 🏷️ Tag suggestions are now context-aware, displaying only relevant tags when creating or editing models versus chat conversations, preventing confusion between model and chat tags. [#19135](https://github.com/open-webui/open-webui/issues/19135)
-- ✍️ Prompt autocompletion is now available independently of the rich text input setting, improving accessibility to the feature. [#19150](https://github.com/open-webui/open-webui/issues/19150)
-- 🔄 Various improvements were implemented across the frontend and backend to enhance performance, stability, and security.
-- 🌐 Translations for Simplified Chinese, Traditional Chinese, Portuguese (Brazil), Catalan, Spanish (Spain), Finnish, Irish, Farsi, Swedish, Danish, German, Korean, and Thai were improved and expanded.
-
-### Fixed
-
-- 🤖 Model update functionality now works correctly, resolving a database parameter binding error that prevented saving changes to model configurations via the Save & Update button. [#19335](https://github.com/open-webui/open-webui/issues/19335)
-- 🖼️ Multiple input images for image editing and generation are now correctly passed as an array using the "image[]" parameter syntax, enabling proper multi-image reference functionality with models like GPT Image 1. [#19339](https://github.com/open-webui/open-webui/issues/19339)
-- 📱 PWA installations on iOS now properly refresh after server container restarts, resolving freezing issues by automatically unregistering service workers when version or deployment changes are detected. [#19316](https://github.com/open-webui/open-webui/pull/19316)
-- 🗄️ S3 Vectors collection detection now correctly handles buckets with more than 2000 indexes by using direct index lookup instead of paginated list scanning, improving performance by approximately 8x and enabling RAG queries to work reliably at scale. [#19238](https://github.com/open-webui/open-webui/pull/19238), [#19233](https://github.com/open-webui/open-webui/issues/19233)
-- 📈 Feedback retrieval performance was optimized by eliminating N+1 query patterns through database joins, adding server-side pagination and sorting, significantly reducing database load for instances with large feedback datasets. [#17976](https://github.com/open-webui/open-webui/pull/17976)
-- 🔍 Chat search now works correctly with PostgreSQL when chat data contains null bytes, with comprehensive sanitization preventing null bytes during data writes, cleaning existing data on read, and stripping null bytes during search queries to ensure reliable search functionality. [#15616](https://github.com/open-webui/open-webui/issues/15616)
-- 🔍 Hybrid search with reranking now correctly handles attribute validation, preventing errors when collection results lack expected structure. [#19025](https://github.com/open-webui/open-webui/pull/19025), [#17046](https://github.com/open-webui/open-webui/issues/17046)
-- 🔎 Reranking functionality now works correctly after recent refactoring, resolving crashes caused by incorrect function argument handling. [#19270](https://github.com/open-webui/open-webui/pull/19270)
-- 🤖 Azure OpenAI models now support the "reasoning_effort" parameter, enabling proper configuration of reasoning capabilities for models like GPT-5.1 which default to no reasoning without this setting. [#19290](https://github.com/open-webui/open-webui/issues/19290)
-- 🤖 Models with very long IDs can now be deleted correctly, resolving URL length limitations that previously prevented management operations on such models. [#18230](https://github.com/open-webui/open-webui/pull/18230)
-- 🤖 Model-level streaming settings now correctly apply to API requests, ensuring "Stream Chat Response" toggle properly controls the streaming parameter. [#19154](https://github.com/open-webui/open-webui/issues/19154)
-- 🖼️ Image editing configuration now correctly preserves independent OpenAI API endpoints and keys, preventing them from being overwritten by image generation settings. [#19003](https://github.com/open-webui/open-webui/issues/19003)
-- 🎨 Gemini image edit settings now display correctly in the admin panel, fixing an incorrect configuration key reference that prevented proper rendering of edit options. [#19200](https://github.com/open-webui/open-webui/pull/19200)
-- 🖌️ Image generation settings menu now loads correctly, resolving validation errors with AUTOMATIC1111 API authentication parameters. [#19187](https://github.com/open-webui/open-webui/issues/19187), [#19246](https://github.com/open-webui/open-webui/issues/19246)
-- 📅 Date formatting in chat search and admin user chat search now correctly respects the "DEFAULT_LOCALE" environment variable, displaying dates according to the configured locale instead of always using MM/DD/YYYY format. [#19305](https://github.com/open-webui/open-webui/pull/19305), [#19020](https://github.com/open-webui/open-webui/issues/19020)
-- 📝 RAG template query placeholder escaping logic was corrected to prevent unintended replacements of context values when query placeholders appear in retrieved content. [#19102](https://github.com/open-webui/open-webui/pull/19102), [#19101](https://github.com/open-webui/open-webui/issues/19101)
-- 📄 RAG template prompt duplication was eliminated by removing redundant user query section from the default template. [#19099](https://github.com/open-webui/open-webui/pull/19099), [#19098](https://github.com/open-webui/open-webui/issues/19098)
-- 📋 MinerU local mode configuration no longer incorrectly requires an API key, allowing proper use of local content extraction without external API credentials. [#19258](https://github.com/open-webui/open-webui/issues/19258)
-- 📊 Excel file uploads now work correctly with the addition of the missing msoffcrypto-tool dependency, resolving import errors introduced by the unstructured package upgrade. [#19153](https://github.com/open-webui/open-webui/issues/19153)
-- 📑 Docling parameters now properly handle JSON serialization, preventing exceptions and ensuring configuration changes are saved correctly. [#19072](https://github.com/open-webui/open-webui/pull/19072)
-- 🛠️ UserValves configuration now correctly isolates settings per tool, preventing configuration contamination when multiple tools with UserValves are used simultaneously. [#19185](https://github.com/open-webui/open-webui/pull/19185), [#15569](https://github.com/open-webui/open-webui/issues/15569)
-- 🔧 Tool selection prompt now correctly handles user messages without duplication, removing redundant query prefixes and improving prompt clarity. [#19122](https://github.com/open-webui/open-webui/pull/19122), [#19121](https://github.com/open-webui/open-webui/issues/19121)
-- 📝 Notes chat feature now correctly submits messages to the completions endpoint, resolving errors that prevented AI model interactions. [#19079](https://github.com/open-webui/open-webui/pull/19079)
-- 📝 Note PDF downloads now sanitize HTML content using DOMPurify before rendering, preventing potential DOM-based XSS attacks from malicious content in notes. [Commit](https://github.com/open-webui/open-webui/commit/03cc6ce8eb5c055115406e2304fbf7e3338b8dce)
-- 📁 Archived chats now have their folder associations automatically removed to prevent unintended deletion when their previous folder is deleted. [#14578](https://github.com/open-webui/open-webui/issues/14578)
-- 🔐 ElevenLabs API key is now properly obfuscated in the admin settings page, preventing plain text exposure of sensitive credentials. [#19262](https://github.com/open-webui/open-webui/pull/19262), [#19260](https://github.com/open-webui/open-webui/issues/19260)
-- 🔧 MCP OAuth server metadata discovery now follows the correct specification order, ensuring proper authentication flow compliance. [#19244](https://github.com/open-webui/open-webui/pull/19244)
-- 🔒 API key endpoint restrictions now properly enforce access controls for all endpoints including SCIM, preventing unintended access when "API_KEY_ALLOWED_ENDPOINTS" is configured. [#19168](https://github.com/open-webui/open-webui/issues/19168)
-- 🔓 OAuth role claim parsing now supports both flat and nested claim structures, enabling compatibility with OAuth providers that deliver claims as direct properties on the user object rather than nested structures. [#19286](https://github.com/open-webui/open-webui/pull/19286)
-- 🔑 OAuth MCP server verification now correctly extracts the access token value for authorization headers instead of sending the entire token dictionary. [#19149](https://github.com/open-webui/open-webui/pull/19149), [#19148](https://github.com/open-webui/open-webui/issues/19148)
-- ⚙️ OAuth dynamic client registration now correctly converts empty strings to None for optional fields, preventing validation failures in MCP package integration. [#19144](https://github.com/open-webui/open-webui/pull/19144), [#19129](https://github.com/open-webui/open-webui/issues/19129)
-- 🔐 OIDC authentication now correctly passes client credentials in access token requests, ensuring compatibility with providers that require these parameters per RFC 6749. [#19132](https://github.com/open-webui/open-webui/pull/19132), [#19131](https://github.com/open-webui/open-webui/issues/19131)
-- 🔗 OAuth client creation now respects configured token endpoint authentication methods instead of defaulting to basic authentication, preventing failures with servers that don't support basic auth. [#19165](https://github.com/open-webui/open-webui/pull/19165)
-- 📋 Text copied from chat responses in Chrome now pastes without background formatting, improving readability when pasting into word processors. [#19083](https://github.com/open-webui/open-webui/issues/19083)
-
-### Changed
-
-- 🗄️ Group membership data storage was refactored from JSON arrays to a dedicated relational database table, significantly improving query performance and scalability for instances with large numbers of users and groups, while API responses now return member counts instead of full user ID arrays. [#19239](https://github.com/open-webui/open-webui/pull/19239)
-- 📄 MinerU parameter handling was refactored to pass parameters directly to the API, improving flexibility and fixing VLM backend configuration. [#19105](https://github.com/open-webui/open-webui/pull/19105), [#18446](https://github.com/open-webui/open-webui/discussions/18446)
-- 🔐 API key creation is now controlled by granular user and group permissions, with the "ENABLE_API_KEY" environment variable renamed to "ENABLE_API_KEYS" and disabled by default, requiring explicit configuration at both the global and user permission levels, while related environment variables "ENABLE_API_KEY_ENDPOINT_RESTRICTIONS" and "API_KEY_ALLOWED_ENDPOINTS" were renamed to "ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS" and "API_KEYS_ALLOWED_ENDPOINTS" respectively. [#18336](https://github.com/open-webui/open-webui/pull/18336)
-
-## [0.6.36] - 2025-11-07
-
-### Added
-
-- 🔐 OAuth group parsing now supports configurable separators via the "OAUTH_GROUPS_SEPARATOR" environment variable, enabling proper handling of semicolon-separated group claims from providers like CILogon. [#18987](https://github.com/open-webui/open-webui/pull/18987), [#18979](https://github.com/open-webui/open-webui/issues/18979)
-
-### Fixed
-
-- 🛠️ Tool calling functionality is restored by correcting asynchronous function handling in tool parameter updates. [#18981](https://github.com/open-webui/open-webui/issues/18981)
-- 🖼️ The ComfyUI image edit workflow editor modal now opens correctly when clicking the Edit button. [#18978](https://github.com/open-webui/open-webui/issues/18978)
-- 🔥 Firecrawl import errors are resolved by implementing lazy loading and using the correct class name. [#18973](https://github.com/open-webui/open-webui/issues/18973)
-- 🔌 Socket.IO CORS warning is resolved by properly configuring CORS origins for Socket.IO connections. [Commit](https://github.com/open-webui/open-webui/commit/639d26252e528c9c37a5f553b11eb94376d8792d)
-
-## [0.6.35] - 2025-11-06
-
-### Added
-
-- 🖼️ Image generation system received a comprehensive overhaul with major new capabilities including full image editing support allowing users to modify existing images using text prompts with OpenAI, Gemini, or ComfyUI engines, adding Gemini 2.5 Flash Image (Nano Banana) support, Qwen Image Edit integration, resolution of base64-encoded image display issues, streamlined AUTOMATIC1111 configuration by consolidating parameters into a flexible JSON parameters field, and enhanced UI with a code editor modal for ComfyUI workflow management. [#17434](https://github.com/open-webui/open-webui/pull/17434), [#16976](https://github.com/open-webui/open-webui/issues/16976), [Commit](https://github.com/open-webui/open-webui/commit/8e5690aab4f632a57027e2acf880b8f89a8717c0), [Commit](https://github.com/open-webui/open-webui/commit/72f8539fd2e679fec0762945f22f4b8a6920afa0), [Commit](https://github.com/open-webui/open-webui/commit/8d34fcb586eeee1fac6da2f991518b8a68b00b72), [Commit](https://github.com/open-webui/open-webui/commit/72900cd686de1fa6be84b5a8a2fc857cff7b91b8)
-- 🔒 CORS origin validation was added to WebSocket connections as a defense-in-depth security measure against cross-site WebSocket hijacking attacks. [#18411](https://github.com/open-webui/open-webui/pull/18411), [#18410](https://github.com/open-webui/open-webui/issues/18410)
-- 🔄 Automatic page refresh now occurs when a version update is detected via WebSocket connection, ensuring users always run the latest version without cache issues. [Commit](https://github.com/open-webui/open-webui/commit/989f192c92d2fe55daa31336e7971e21798b96ae)
-- 🐍 Experimental initial preparations for Python 3.13 compatibility by updating dependencies with security enhancements and cryptographic improvements. [#18430](https://github.com/open-webui/open-webui/pull/18430), [#18424](https://github.com/open-webui/open-webui/pull/18424)
-- ⚡ Image compression now preserves the original image format instead of converting to PNG, significantly reducing file sizes and improving chat loading performance. [#18506](https://github.com/open-webui/open-webui/pull/18506)
-- 🎤 Mistral Voxtral model support was added for text-to-speech, including voxtral-small and voxtral-mini models with both transcription and chat completion API support. [#18934](https://github.com/open-webui/open-webui/pull/18934)
-- 🔊 Text-to-speech now uses a global audio queue system to prevent overlapping playback, ensuring only one TTS instance plays at a time with proper stop/start controls and automatic cleanup when switching between messages. [#16152](https://github.com/open-webui/open-webui/pull/16152), [#18744](https://github.com/open-webui/open-webui/pull/18744), [#16150](https://github.com/open-webui/open-webui/issues/16150)
-- 🔊 ELEVENLABS_API_BASE_URL environment variable now allows configuration of custom ElevenLabs API endpoints, enabling support for EU residency API requirements. [#18402](https://github.com/open-webui/open-webui/issues/18402)
-- 🔐 OAUTH_ROLES_SEPARATOR environment variable now allows custom role separators for OAuth roles that contain commas, useful for roles specified in LDAP syntax. [#18572](https://github.com/open-webui/open-webui/pull/18572)
-- 📄 External document loaders can now optionally forward user information headers when ENABLE_FORWARD_USER_INFO_HEADERS is enabled, enabling cost tracking, audit logs, and usage analytics for external services. [#18731](https://github.com/open-webui/open-webui/pull/18731)
-- 📄 MISTRAL_OCR_API_BASE_URL environment variable now allows configuration of custom Mistral OCR API endpoints for flexible deployment options. [Commit](https://github.com/open-webui/open-webui/commit/415b93c7c35c2e2db4425e6da1b88b3750f496b0)
-- ⌨️ Keyboard shortcut hints are now displayed on sidebar buttons with a refactored shortcuts modal that accurately reflects all available hotkeys across different keyboard layouts. [#18473](https://github.com/open-webui/open-webui/pull/18473)
-- 🛠️ Tooltips now display tool descriptions when hovering over tool names on the model edit page, improving usability and providing immediate context. [#18707](https://github.com/open-webui/open-webui/pull/18707)
-- 📝 "Create a new note" from the search modal now immediately creates a new private note and opens it in the editor instead of navigating to the generic notes page. [#18255](https://github.com/open-webui/open-webui/pull/18255)
-- 🖨️ Code block output now preserves whitespace formatting with monospace font to accurately reflect terminal behavior. [#18352](https://github.com/open-webui/open-webui/pull/18352)
-- ✏️ Edit button is now available in the three-dot menu of models in the workspace section for quick access to model editing, with the menu reorganized for better user experience and Edit, Clone, Copy Link, and Share options logically grouped. [#18574](https://github.com/open-webui/open-webui/pull/18574)
-- 📌 Sidebar models section is now collapsible, allowing users to expand and collapse the pinned models list for better sidebar organization. [Commit](https://github.com/open-webui/open-webui/commit/82c08a3b5d189f81c96b6548cc872198771015b0)
-- 🌙 Dark mode styles for select elements were added using Tailwind CSS classes, improving consistency across the interface. [#18636](https://github.com/open-webui/open-webui/pull/18636)
-- 🔄 Various improvements were implemented across the frontend and backend to enhance performance, stability, and security.
-- 🌐 Translations for Portuguese (Brazil), Greek, German, Traditional Chinese, Simplified Chinese, Spanish, Georgian, Danish, and Estonian were enhanced and expanded.
-
-### Fixed
-
-- 🔒 Server-Sent Event (SSE) code injection vulnerability in Direct Connections is resolved by blocking event emission from untrusted external model servers; event emitters from direct connected model servers are no longer supported, preventing arbitrary JavaScript execution in user browsers. [Commit](https://github.com/open-webui/open-webui/commit/8af6a4cf21b756a66cd58378a01c60f74c39b7ca)
-- 🛡️ DOM XSS vulnerability in "Insert Prompt as Rich Text" is resolved by sanitizing HTML content with DOMPurify before rendering. [Commit](https://github.com/open-webui/open-webui/commit/eb9c4c0e358c274aea35f21c2856c0a20051e5f1)
-- ⚙️ MCP server cancellation scope corruption is prevented by reversing disconnection order to follow LIFO and properly handling exceptions, resolving 100% CPU usage when resuming chats with expired tokens or using multiple streamable MCP servers. [#18537](https://github.com/open-webui/open-webui/pull/18537)
-- 🔧 UI freeze when querying models with knowledge bases containing inconsistent distance metrics is resolved by properly initializing the distances array in citations. [#18585](https://github.com/open-webui/open-webui/pull/18585)
-- 🤖 Duplicate model IDs from multiple OpenAI endpoints are now automatically deduplicated server-side, preventing frontend crashes for users with unified gateway proxies that aggregate multiple providers. [Commit](https://github.com/open-webui/open-webui/commit/fdf7ca11d4f3cc8fe63e81c98dc0d1e48e52ba36)
-- 🔐 Login failures with passwords longer than 72 bytes are resolved by safely truncating oversized passwords for bcrypt compatibility. [#18157](https://github.com/open-webui/open-webui/issues/18157)
-- 🔐 OAuth 2.1 MCP tool connections now automatically re-register clients when stored client IDs become stale, preventing unauthorized_client errors after editing tool endpoints and providing detailed error messages for callback failures. [#18415](https://github.com/open-webui/open-webui/pull/18415), [#18309](https://github.com/open-webui/open-webui/issues/18309)
-- 🔓 OAuth 2.1 discovery, metadata fetching, and dynamic client registration now correctly use HTTP proxy environment variables when trust_env is enabled. [Commit](https://github.com/open-webui/open-webui/commit/bafeb76c411483bd6b135f0edbcdce048120f264)
-- 🔌 MCP server connection failures now display clear error messages in the chat interface instead of silently failing. [#18892](https://github.com/open-webui/open-webui/pull/18892), [#18889](https://github.com/open-webui/open-webui/issues/18889)
-- 💬 Chat titles are now properly generated even when title auto-generation is disabled in interface settings, fixing an issue where chats would remain labeled as "New chat". [#18761](https://github.com/open-webui/open-webui/pull/18761), [#18717](https://github.com/open-webui/open-webui/issues/18717), [#6478](https://github.com/open-webui/open-webui/issues/6478)
-- 🔍 Chat query errors are prevented by properly validating and handling the "order_by" parameter to ensure requested columns exist. [#18400](https://github.com/open-webui/open-webui/pull/18400), [#18452](https://github.com/open-webui/open-webui/pull/18452)
-- 🔧 Root-level max_tokens parameter is no longer dropped when proxying to Ollama, properly converting to num_predict to limit output token length as intended. [#18618](https://github.com/open-webui/open-webui/issues/18618)
-- 🔑 Self-hosted Marker instances can now be used without requiring an API key, while keeping it optional for datalab Marker service users. [#18617](https://github.com/open-webui/open-webui/issues/18617)
-- 🔧 OpenAPI specification endpoint conflict between "/api/v1/models" and "/api/v1/models/" is resolved by changing the models router endpoint to "/list", preventing duplicate operationId errors when generating TypeScript API clients. [#18758](https://github.com/open-webui/open-webui/issues/18758)
-- 🏷️ Model tags are now de-duplicated case-insensitively in both the model selector and workspace models page, preventing duplicate entries with different capitalization from appearing in filter dropdowns. [#18716](https://github.com/open-webui/open-webui/pull/18716), [#18711](https://github.com/open-webui/open-webui/issues/18711)
-- 📄 Docling RAG parameter configuration is now correctly saved in the admin UI by fixing the typo in the "DOCLING_PARAMS" parameter name. [#18390](https://github.com/open-webui/open-webui/pull/18390)
-- 📃 Tika document processing now automatically detects content types instead of relying on potentially incorrect browser-provided mime-types, improving file handling accuracy for formats like RTF. [#18765](https://github.com/open-webui/open-webui/pull/18765), [#18683](https://github.com/open-webui/open-webui/issues/18683)
-- 🖼️ Image and video uploads to knowledge bases now display proper error messages instead of showing an infinite spinner when the content extraction engine does not support these file types. [#18514](https://github.com/open-webui/open-webui/issues/18514)
-- 📝 Notes PDF export now properly detects and applies dark mode styling consistently across both the notes list and individual note pages, with a shared utility function to eliminate code duplication. [#18526](https://github.com/open-webui/open-webui/issues/18526)
-- 💭 Details tags for reasoning content are now correctly identified and rendered even when the same tag is present in user messages. [#18840](https://github.com/open-webui/open-webui/pull/18840), [#18294](https://github.com/open-webui/open-webui/issues/18294)
-- 📊 Mermaid and Vega rendering errors now display inline with the code instead of showing repetitive toast notifications, improving user experience when models generate invalid diagram syntax. [Commit](https://github.com/open-webui/open-webui/commit/fdc0f04a8b7dd0bc9f9dc0e7e30854f7a0eea3e9)
-- 📈 Mermaid diagram rendering errors no longer cause UI unavailability or display error messages below the input box. [#18493](https://github.com/open-webui/open-webui/pull/18493), [#18340](https://github.com/open-webui/open-webui/issues/18340)
-- 🔗 Web search SSL verification is now asynchronous, preventing the website from hanging during web search operations. [#18714](https://github.com/open-webui/open-webui/pull/18714), [#18699](https://github.com/open-webui/open-webui/issues/18699)
-- 🌍 Web search results now correctly use HTTP proxy environment variables when WEB_SEARCH_TRUST_ENV is enabled. [#18667](https://github.com/open-webui/open-webui/pull/18667), [#7008](https://github.com/open-webui/open-webui/discussions/7008)
-- 🔍 Google Programmable Search Engine now properly includes referer headers, enabling API keys with HTTP referrer restrictions configured in Google Cloud Console. [#18871](https://github.com/open-webui/open-webui/pull/18871), [#18870](https://github.com/open-webui/open-webui/issues/18870)
-- ⚡ YouTube video transcript fetching now works correctly when using a proxy connection. [#18419](https://github.com/open-webui/open-webui/pull/18419)
-- 🎙️ Speech-to-text transcription no longer deletes or replaces existing text in the prompt input field, properly preserving any previously entered content. [#18540](https://github.com/open-webui/open-webui/issues/18540)
-- 🎙️ The "Instant Auto-Send After Voice Transcription" setting now functions correctly and automatically sends transcribed text when enabled. [#18466](https://github.com/open-webui/open-webui/issues/18466)
-- ⚙️ Chat settings now load properly when reopening a tab or starting a new session by initializing defaults when sessionStorage is empty. [#18438](https://github.com/open-webui/open-webui/pull/18438)
-- 🔎 Folder tag search in the sidebar now correctly handles folder names with multiple spaces by replacing all spaces with underscores. [Commit](https://github.com/open-webui/open-webui/commit/a8fe979af68e47e4e4bb3eb76e48d93d60cd2a45)
-- 🛠️ Functions page now updates immediately after deleting a function, removing the need for a manual page reload. [#18912](https://github.com/open-webui/open-webui/pull/18912), [#18908](https://github.com/open-webui/open-webui/issues/18908)
-- 🛠️ Native tool calling now properly supports sequential tool calls with shared context, allowing tools to access images and data from previous tool executions in the same conversation. [#18664](https://github.com/open-webui/open-webui/pull/18664)
-- 🎯 Globally enabled actions in the model editor now correctly apply as global instead of being treated as disabled. [#18577](https://github.com/open-webui/open-webui/pull/18577)
-- 📋 Clipboard images pasted via the "{{CLIPBOARD}}" prompt variable are now correctly converted to base64 format before being sent to the backend, resolving base64 encoding errors. [#18432](https://github.com/open-webui/open-webui/pull/18432), [#18425](https://github.com/open-webui/open-webui/issues/18425)
-- 📋 File list is now cleared when switching to models that do not support file uploads, preventing files from being sent to incompatible models. [#18496](https://github.com/open-webui/open-webui/pull/18496)
-- 📂 Move menu no longer displays when folders are empty. [#18484](https://github.com/open-webui/open-webui/pull/18484)
-- 📁 Folder and channel creation now validates that names are not empty, preventing creation of folders or channels with no name and showing an error toast if attempted. [#18564](https://github.com/open-webui/open-webui/pull/18564)
-- 🖊️ Rich text input no longer removes text between equals signs when pasting code with comparison operators. [#18551](https://github.com/open-webui/open-webui/issues/18551)
-- ⌨️ Keyboard shortcuts now display the correct keys for international and non-QWERTY keyboard layouts by detecting the user's layout using the Keyboard API. [#18533](https://github.com/open-webui/open-webui/pull/18533)
-- 🌐 "Attach Webpage" button now displays with correct disabled styling when a model does not support file uploads. [#18483](https://github.com/open-webui/open-webui/pull/18483)
-- 🎚️ Divider no longer displays in the integrations menu when no integrations are enabled. [#18487](https://github.com/open-webui/open-webui/pull/18487)
-- 📱 Chat controls button is now properly hidden on mobile for users without admin or explicit chat control permissions. [#18641](https://github.com/open-webui/open-webui/pull/18641)
-- 📍 User menu, download submenu, and move submenu are now repositioned to prevent overlap with the Chat Controls sidebar when it is open. [Commit](https://github.com/open-webui/open-webui/commit/414ab51cb6df1ab0d6c85ac6c1f2c5c9a5f8e2aa)
-- 🎯 Artifacts button no longer appears in the chat menu when there are no artifacts to display. [Commit](https://github.com/open-webui/open-webui/commit/ed6449d35f84f68dc75ee5c6b3f4748a3fda0096)
-- 🎨 Artifacts view now automatically displays when opening an existing conversation containing artifacts, improving user experience. [#18215](https://github.com/open-webui/open-webui/pull/18215)
-- 🖌️ Formatting toolbar is no longer hidden under images or code blocks in chat and now displays correctly above all message content.
-- 🎨 Layout shift near system instructions is prevented by properly rendering the chat component when system prompts are empty. [#18594](https://github.com/open-webui/open-webui/pull/18594)
-- 📐 Modal layout shift caused by scrollbar appearance is prevented by adding a stable scrollbar gutter. [#18591](https://github.com/open-webui/open-webui/pull/18591)
-- ✨ Spacing between icon and label in the user menu dropdown items is now consistent. [#18595](https://github.com/open-webui/open-webui/pull/18595)
-- 💬 Duplicate prompt suggestions no longer cause the webpage to freeze or throw JavaScript errors by implementing proper key management with composite keys. [#18841](https://github.com/open-webui/open-webui/pull/18841), [#18566](https://github.com/open-webui/open-webui/issues/18566)
-- 🔍 Chat preview loading in the search modal now works correctly for all search results by fixing an index boundary check that previously caused out-of-bounds errors. [#18911](https://github.com/open-webui/open-webui/pull/18911)
-- ♿ Screen reader support was enhanced by wrapping messages in semantic elements with descriptive aria-labels, adding "Assistant is typing" and "Response complete" announcements for improved accessibility. [#18735](https://github.com/open-webui/open-webui/pull/18735)
-- 🔒 Incorrect await call in the OAuth 2.1 flow is removed, eliminating a logged exception during authentication. [#18236](https://github.com/open-webui/open-webui/pull/18236)
-- 🛡️ Duplicate crossorigin attribute in the manifest file was removed. [#18413](https://github.com/open-webui/open-webui/pull/18413)
-
-### Changed
-
-- 🔄 Firecrawl integration was refactored to use the official Firecrawl SDK instead of direct HTTP requests and langchain_community FireCrawlLoader, improving reliability and performance with batch scraping support and enhanced error handling. [#18635](https://github.com/open-webui/open-webui/pull/18635)
-- 📄 MinerU content extraction engine now only supports PDF files following the upstream removal of LibreOffice document conversion in version 2.0.0; users needing to process office documents should convert them to PDF format first. [#18448](https://github.com/open-webui/open-webui/issues/18448)
-
 ## [0.6.34] - 2025-10-16
 
 ### Added

README.md

@@ -17,7 +17,7 @@ Passionate about open-source AI? [Join our team →](https://careers.openwebui.c
 ![Open WebUI Demo](./demo.gif)
 
 > [!TIP]  
-> **Looking for an [Enterprise Plan](https://docs.openwebui.com/enterprise)?** – **[Speak with Our Sales Team Today!](https://docs.openwebui.com/enterprise)**
+> **Looking for an [Enterprise Plan](https://docs.openwebui.com/enterprise)?** – **[Speak with Our Sales Team Today!](mailto:sales@openwebui.com)**
 >
 > Get **enhanced capabilities**, including **custom theming and branding**, **Service Level Agreement (SLA) support**, **Long-Term Support (LTS) versions**, and **more!**
 
@@ -31,44 +31,32 @@ For more information, be sure to check out our [Open WebUI Documentation](https:
 
 - 🛡️ **Granular Permissions and User Groups**: By allowing administrators to create detailed user roles and permissions, we ensure a secure user environment. This granularity not only enhances security but also allows for customized user experiences, fostering a sense of ownership and responsibility amongst users.
 
+- 🔄 **SCIM 2.0 Support**: Enterprise-grade user and group provisioning through SCIM 2.0 protocol, enabling seamless integration with identity providers like Okta, Azure AD, and Google Workspace for automated user lifecycle management.
+
 - 📱 **Responsive Design**: Enjoy a seamless experience across Desktop PC, Laptop, and Mobile devices.
 
 - 📱 **Progressive Web App (PWA) for Mobile**: Enjoy a native app-like experience on your mobile device with our PWA, providing offline access on localhost and a seamless user interface.
 
 - ✒️🔢 **Full Markdown and LaTeX Support**: Elevate your LLM experience with comprehensive Markdown and LaTeX capabilities for enriched interaction.
 
-- 🎤📹 **Hands-Free Voice/Video Call**: Experience seamless communication with integrated hands-free voice and video call features using multiple Speech-to-Text providers (Local Whisper, OpenAI, Deepgram, Azure) and Text-to-Speech engines (Azure, ElevenLabs, OpenAI, Transformers, WebAPI), allowing for dynamic and interactive chat environments.
+- 🎤📹 **Hands-Free Voice/Video Call**: Experience seamless communication with integrated hands-free voice and video call features, allowing for a more dynamic and interactive chat environment.
 
 - 🛠️ **Model Builder**: Easily create Ollama models via the Web UI. Create and add custom characters/agents, customize chat elements, and import models effortlessly through [Open WebUI Community](https://openwebui.com/) integration.
 
 - 🐍 **Native Python Function Calling Tool**: Enhance your LLMs with built-in code editor support in the tools workspace. Bring Your Own Function (BYOF) by simply adding your pure Python functions, enabling seamless integration with LLMs.
 
-- 💾 **Persistent Artifact Storage**: Built-in key-value storage API for artifacts, enabling features like journals, trackers, leaderboards, and collaborative tools with both personal and shared data scopes across sessions.
+- 📚 **Local RAG Integration**: Dive into the future of chat interactions with groundbreaking Retrieval Augmented Generation (RAG) support. This feature seamlessly integrates document interactions into your chat experience. You can load documents directly into the chat or add files to your document library, effortlessly accessing them using the `#` command before a query.
 
-- 📚 **Local RAG Integration**: Dive into the future of chat interactions with groundbreaking Retrieval Augmented Generation (RAG) support using your choice of 9 vector databases and multiple content extraction engines (Tika, Docling, Document Intelligence, Mistral OCR, External loaders). Load documents directly into chat or add files to your document library, effortlessly accessing them using the `#` command before a query.
-
-- 🔍 **Web Search for RAG**: Perform web searches using 15+ providers including `SearXNG`, `Google PSE`, `Brave Search`, `Kagi`, `Mojeek`, `Tavily`, `Perplexity`, `serpstack`, `serper`, `Serply`, `DuckDuckGo`, `SearchApi`, `SerpApi`, `Bing`, `Jina`, `Exa`, `Sougou`, `Azure AI Search`, and `Ollama Cloud`, injecting results directly into your chat experience.
+- 🔍 **Web Search for RAG**: Perform web searches using providers like `SearXNG`, `Google PSE`, `Brave Search`, `serpstack`, `serper`, `Serply`, `DuckDuckGo`, `TavilySearch`, `SearchApi` and `Bing` and inject the results directly into your chat experience.
 
 - 🌐 **Web Browsing Capability**: Seamlessly integrate websites into your chat experience using the `#` command followed by a URL. This feature allows you to incorporate web content directly into your conversations, enhancing the richness and depth of your interactions.
 
-- 🎨 **Image Generation & Editing Integration**: Create and edit images using multiple engines including OpenAI's DALL-E, Gemini, ComfyUI (local), and AUTOMATIC1111 (local), with support for both generation and prompt-based editing workflows.
+- 🎨 **Image Generation Integration**: Seamlessly incorporate image generation capabilities using options such as AUTOMATIC1111 API or ComfyUI (local), and OpenAI's DALL-E (external), enriching your chat experience with dynamic visual content.
 
 - ⚙️ **Many Models Conversations**: Effortlessly engage with various models simultaneously, harnessing their unique strengths for optimal responses. Enhance your experience by leveraging a diverse set of models in parallel.
 
 - 🔐 **Role-Based Access Control (RBAC)**: Ensure secure access with restricted permissions; only authorized individuals can access your Ollama, and exclusive model creation/pulling rights are reserved for administrators.
 
-- 🗄️ **Flexible Database & Storage Options**: Choose from SQLite (with optional encryption), PostgreSQL, or configure cloud storage backends (S3, Google Cloud Storage, Azure Blob Storage) for scalable deployments.
-
-- 🔍 **Advanced Vector Database Support**: Select from 9 vector database options including ChromaDB, PGVector, Qdrant, Milvus, Elasticsearch, OpenSearch, Pinecone, S3Vector, and Oracle 23ai for optimal RAG performance.
-
-- 🔐 **Enterprise Authentication**: Full support for LDAP/Active Directory integration, SCIM 2.0 automated provisioning, and SSO via trusted headers alongside OAuth providers. Enterprise-grade user and group provisioning through SCIM 2.0 protocol, enabling seamless integration with identity providers like Okta, Azure AD, and Google Workspace for automated user lifecycle management.
-
-- ☁️ **Cloud-Native Integration**: Native support for Google Drive and OneDrive/SharePoint file picking, enabling seamless document import from enterprise cloud storage.
-
-- 📊 **Production Observability**: Built-in OpenTelemetry support for traces, metrics, and logs, enabling comprehensive monitoring with your existing observability stack.
-
-- ⚖️ **Horizontal Scalability**: Redis-backed session management and WebSocket support for multi-worker and multi-node deployments behind load balancers.
-
 - 🌐🌍 **Multilingual Support**: Experience Open WebUI in your preferred language with our internationalization (i18n) support. Join us in expanding our supported languages! We're actively seeking contributors!
 
 - 🧩 **Pipelines, Open WebUI Plugin Support**: Seamlessly integrate custom logic and Python libraries into Open WebUI using [Pipelines Plugin Framework](https://github.com/open-webui/pipelines). Launch your Pipelines instance, set the OpenAI URL to the Pipelines URL, and explore endless possibilities. [Examples](https://github.com/open-webui/pipelines/tree/main/examples) include **Function Calling**, User **Rate Limiting** to control access, **Usage Monitoring** with tools like Langfuse, **Live Translation with LibreTranslate** for multilingual support, **Toxic Message Filtering** and much more.
@@ -77,6 +65,43 @@ For more information, be sure to check out our [Open WebUI Documentation](https:
 
 Want to learn more about Open WebUI's features? Check out our [Open WebUI documentation](https://docs.openwebui.com/features) for a comprehensive overview!
 
+## Sponsors 🙌
+
+#### Emerald
+
+<table>
+  <!-- <tr>
+    <td>
+      <a href="https://n8n.io/" target="_blank">
+        <img src="https://docs.openwebui.com/sponsors/logos/n8n.png" alt="n8n" style="width: 8rem; height: 8rem; border-radius: .75rem;" />
+      </a>
+    </td>
+    <td>
+      <a href="https://n8n.io/">n8n</a> • Does your interface have a backend yet?<br>Try <a href="https://n8n.io/">n8n</a>
+    </td>
+  </tr> -->
+  <tr>
+    <td>
+      <a href="https://tailscale.com/blog/self-host-a-local-ai-stack/?utm_source=OpenWebUI&utm_medium=paid-ad-placement&utm_campaign=OpenWebUI-Docs" target="_blank">
+        <img src="https://docs.openwebui.com/sponsors/logos/tailscale.png" alt="Tailscale" style="width: 8rem; height: 8rem; border-radius: .75rem;" />
+      </a>
+    </td>
+    <td>
+      <a href="https://tailscale.com/blog/self-host-a-local-ai-stack/?utm_source=OpenWebUI&utm_medium=paid-ad-placement&utm_campaign=OpenWebUI-Docs">Tailscale</a> • Connect self-hosted AI to any device with Tailscale
+    </td>
+  </tr>
+   <tr>
+    <td>
+      <a href="https://warp.dev/open-webui" target="_blank">
+        <img src="https://docs.openwebui.com/sponsors/logos/warp.png" alt="Warp" style="width: 8rem; height: 8rem; border-radius: .75rem;" />
+      </a>
+    </td>
+    <td>
+      <a href="https://warp.dev/open-webui">Warp</a> • The intelligent terminal for developers
+    </td>
+  </tr>
+</table>
+
 ---
 
 We are incredibly grateful for the generous support of our sponsors. Their contributions help us to maintain and improve our project, ensuring we can continue to deliver quality work to our community. Thank you!

backend/open_webui/config.py

@@ -287,30 +287,25 @@ class AppConfig:
 # WEBUI_AUTH (Required for security)
 ####################################
 
-ENABLE_API_KEYS = PersistentConfig(
-    "ENABLE_API_KEYS",
-    "auth.enable_api_keys",
-    os.environ.get("ENABLE_API_KEYS", "False").lower() == "true",
+ENABLE_API_KEY = PersistentConfig(
+    "ENABLE_API_KEY",
+    "auth.api_key.enable",
+    os.environ.get("ENABLE_API_KEY", "True").lower() == "true",
 )
 
-ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS = PersistentConfig(
-    "ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS",
+ENABLE_API_KEY_ENDPOINT_RESTRICTIONS = PersistentConfig(
+    "ENABLE_API_KEY_ENDPOINT_RESTRICTIONS",
     "auth.api_key.endpoint_restrictions",
-    os.environ.get(
-        "ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS",
-        os.environ.get("ENABLE_API_KEY_ENDPOINT_RESTRICTIONS", "False"),
-    ).lower()
-    == "true",
+    os.environ.get("ENABLE_API_KEY_ENDPOINT_RESTRICTIONS", "False").lower() == "true",
 )
 
-API_KEYS_ALLOWED_ENDPOINTS = PersistentConfig(
-    "API_KEYS_ALLOWED_ENDPOINTS",
+API_KEY_ALLOWED_ENDPOINTS = PersistentConfig(
+    "API_KEY_ALLOWED_ENDPOINTS",
     "auth.api_key.allowed_endpoints",
-    os.environ.get(
-        "API_KEYS_ALLOWED_ENDPOINTS", os.environ.get("API_KEY_ALLOWED_ENDPOINTS", "")
-    ),
+    os.environ.get("API_KEY_ALLOWED_ENDPOINTS", ""),
 )
 
+
 JWT_EXPIRES_IN = PersistentConfig(
     "JWT_EXPIRES_IN", "auth.jwt_expiry", os.environ.get("JWT_EXPIRES_IN", "4w")
 )
@@ -575,38 +570,25 @@ OAUTH_BLOCKED_GROUPS = PersistentConfig(
     os.environ.get("OAUTH_BLOCKED_GROUPS", "[]"),
 )
 
-OAUTH_GROUPS_SEPARATOR = os.environ.get("OAUTH_GROUPS_SEPARATOR", ";")
-
 OAUTH_ROLES_CLAIM = PersistentConfig(
     "OAUTH_ROLES_CLAIM",
     "oauth.roles_claim",
     os.environ.get("OAUTH_ROLES_CLAIM", "roles"),
 )
 
-OAUTH_ROLES_SEPARATOR = os.environ.get("OAUTH_ROLES_SEPARATOR", ",")
-
 OAUTH_ALLOWED_ROLES = PersistentConfig(
     "OAUTH_ALLOWED_ROLES",
     "oauth.allowed_roles",
     [
         role.strip()
-        for role in os.environ.get(
-            "OAUTH_ALLOWED_ROLES", f"user{OAUTH_ROLES_SEPARATOR}admin"
-        ).split(OAUTH_ROLES_SEPARATOR)
-        if role
+        for role in os.environ.get("OAUTH_ALLOWED_ROLES", "user,admin").split(",")
     ],
 )
 
 OAUTH_ADMIN_ROLES = PersistentConfig(
     "OAUTH_ADMIN_ROLES",
     "oauth.admin_roles",
-    [
-        role.strip()
-        for role in os.environ.get("OAUTH_ADMIN_ROLES", "admin").split(
-            OAUTH_ROLES_SEPARATOR
-        )
-        if role
-    ],
+    [role.strip() for role in os.environ.get("OAUTH_ADMIN_ROLES", "admin").split(",")],
 )
 
 OAUTH_ALLOWED_DOMAINS = PersistentConfig(
@@ -624,11 +606,6 @@ OAUTH_UPDATE_PICTURE_ON_LOGIN = PersistentConfig(
     os.environ.get("OAUTH_UPDATE_PICTURE_ON_LOGIN", "False").lower() == "true",
 )
 
-OAUTH_ACCESS_TOKEN_REQUEST_INCLUDE_CLIENT_ID = (
-    os.environ.get("OAUTH_ACCESS_TOKEN_REQUEST_INCLUDE_CLIENT_ID", "False").lower()
-    == "true"
-)
-
 
 def load_oauth_providers():
     OAUTH_PROVIDERS.clear()
@@ -1138,7 +1115,6 @@ ENABLE_LOGIN_FORM = PersistentConfig(
     os.environ.get("ENABLE_LOGIN_FORM", "True").lower() == "true",
 )
 
-ENABLE_PASSWORD_AUTH = os.environ.get("ENABLE_PASSWORD_AUTH", "True").lower() == "true"
 
 DEFAULT_LOCALE = PersistentConfig(
     "DEFAULT_LOCALE",
@@ -1150,12 +1126,6 @@ DEFAULT_MODELS = PersistentConfig(
     "DEFAULT_MODELS", "ui.default_models", os.environ.get("DEFAULT_MODELS", None)
 )
 
-DEFAULT_PINNED_MODELS = PersistentConfig(
-    "DEFAULT_PINNED_MODELS",
-    "ui.default_pinned_models",
-    os.environ.get("DEFAULT_PINNED_MODELS", None),
-)
-
 try:
     default_prompt_suggestions = json.loads(
         os.environ.get("DEFAULT_PROMPT_SUGGESTIONS", "[]")
@@ -1212,12 +1182,6 @@ DEFAULT_USER_ROLE = PersistentConfig(
     os.getenv("DEFAULT_USER_ROLE", "pending"),
 )
 
-DEFAULT_GROUP_ID = PersistentConfig(
-    "DEFAULT_GROUP_ID",
-    "ui.default_group_id",
-    os.environ.get("DEFAULT_GROUP_ID", ""),
-)
-
 PENDING_USER_OVERLAY_TITLE = PersistentConfig(
     "PENDING_USER_OVERLAY_TITLE",
     "ui.pending_user_overlay_title",
@@ -1257,40 +1221,6 @@ USER_PERMISSIONS_WORKSPACE_TOOLS_ACCESS = (
     os.environ.get("USER_PERMISSIONS_WORKSPACE_TOOLS_ACCESS", "False").lower() == "true"
 )
 
-USER_PERMISSIONS_WORKSPACE_MODELS_IMPORT = (
-    os.environ.get("USER_PERMISSIONS_WORKSPACE_MODELS_IMPORT", "False").lower()
-    == "true"
-)
-
-USER_PERMISSIONS_WORKSPACE_MODELS_EXPORT = (
-    os.environ.get("USER_PERMISSIONS_WORKSPACE_MODELS_EXPORT", "False").lower()
-    == "true"
-)
-
-USER_PERMISSIONS_WORKSPACE_PROMPTS_IMPORT = (
-    os.environ.get("USER_PERMISSIONS_WORKSPACE_PROMPTS_IMPORT", "False").lower()
-    == "true"
-)
-
-USER_PERMISSIONS_WORKSPACE_PROMPTS_EXPORT = (
-    os.environ.get("USER_PERMISSIONS_WORKSPACE_PROMPTS_EXPORT", "False").lower()
-    == "true"
-)
-
-USER_PERMISSIONS_WORKSPACE_TOOLS_IMPORT = (
-    os.environ.get("USER_PERMISSIONS_WORKSPACE_TOOLS_IMPORT", "False").lower() == "true"
-)
-
-USER_PERMISSIONS_WORKSPACE_TOOLS_EXPORT = (
-    os.environ.get("USER_PERMISSIONS_WORKSPACE_TOOLS_EXPORT", "False").lower() == "true"
-)
-
-
-USER_PERMISSIONS_WORKSPACE_MODELS_ALLOW_SHARING = (
-    os.environ.get("USER_PERMISSIONS_WORKSPACE_MODELS_ALLOW_SHARING", "False").lower()
-    == "true"
-)
-
 USER_PERMISSIONS_WORKSPACE_MODELS_ALLOW_PUBLIC_SHARING = (
     os.environ.get(
         "USER_PERMISSIONS_WORKSPACE_MODELS_ALLOW_PUBLIC_SHARING", "False"
@@ -1298,10 +1228,8 @@ USER_PERMISSIONS_WORKSPACE_MODELS_ALLOW_PUBLIC_SHARING = (
     == "true"
 )
 
-USER_PERMISSIONS_WORKSPACE_KNOWLEDGE_ALLOW_SHARING = (
-    os.environ.get(
-        "USER_PERMISSIONS_WORKSPACE_KNOWLEDGE_ALLOW_PUBLIC_SHARING", "False"
-    ).lower()
+USER_PERMISSIONS_NOTES_ALLOW_PUBLIC_SHARING = (
+    os.environ.get("USER_PERMISSIONS_NOTES_ALLOW_PUBLIC_SHARING", "False").lower()
     == "true"
 )
 
@@ -1312,11 +1240,6 @@ USER_PERMISSIONS_WORKSPACE_KNOWLEDGE_ALLOW_PUBLIC_SHARING = (
     == "true"
 )
 
-USER_PERMISSIONS_WORKSPACE_PROMPTS_ALLOW_SHARING = (
-    os.environ.get("USER_PERMISSIONS_WORKSPACE_PROMPTS_ALLOW_SHARING", "False").lower()
-    == "true"
-)
-
 USER_PERMISSIONS_WORKSPACE_PROMPTS_ALLOW_PUBLIC_SHARING = (
     os.environ.get(
         "USER_PERMISSIONS_WORKSPACE_PROMPTS_ALLOW_PUBLIC_SHARING", "False"
@@ -1324,12 +1247,6 @@ USER_PERMISSIONS_WORKSPACE_PROMPTS_ALLOW_PUBLIC_SHARING = (
     == "true"
 )
 
-
-USER_PERMISSIONS_WORKSPACE_TOOLS_ALLOW_SHARING = (
-    os.environ.get("USER_PERMISSIONS_WORKSPACE_TOOLS_ALLOW_SHARING", "False").lower()
-    == "true"
-)
-
 USER_PERMISSIONS_WORKSPACE_TOOLS_ALLOW_PUBLIC_SHARING = (
     os.environ.get(
         "USER_PERMISSIONS_WORKSPACE_TOOLS_ALLOW_PUBLIC_SHARING", "False"
@@ -1338,17 +1255,6 @@ USER_PERMISSIONS_WORKSPACE_TOOLS_ALLOW_PUBLIC_SHARING = (
 )
 
 
-USER_PERMISSIONS_NOTES_ALLOW_SHARING = (
-    os.environ.get("USER_PERMISSIONS_NOTES_ALLOW_PUBLIC_SHARING", "False").lower()
-    == "true"
-)
-
-USER_PERMISSIONS_NOTES_ALLOW_PUBLIC_SHARING = (
-    os.environ.get("USER_PERMISSIONS_NOTES_ALLOW_PUBLIC_SHARING", "False").lower()
-    == "true"
-)
-
-
 USER_PERMISSIONS_CHAT_CONTROLS = (
     os.environ.get("USER_PERMISSIONS_CHAT_CONTROLS", "True").lower() == "true"
 )
@@ -1447,22 +1353,10 @@ USER_PERMISSIONS_FEATURES_CODE_INTERPRETER = (
     == "true"
 )
 
-USER_PERMISSIONS_FEATURES_FOLDERS = (
-    os.environ.get("USER_PERMISSIONS_FEATURES_FOLDERS", "True").lower() == "true"
-)
-
 USER_PERMISSIONS_FEATURES_NOTES = (
     os.environ.get("USER_PERMISSIONS_FEATURES_NOTES", "True").lower() == "true"
 )
 
-USER_PERMISSIONS_FEATURES_CHANNELS = (
-    os.environ.get("USER_PERMISSIONS_FEATURES_CHANNELS", "True").lower() == "true"
-)
-
-USER_PERMISSIONS_FEATURES_API_KEYS = (
-    os.environ.get("USER_PERMISSIONS_FEATURES_API_KEYS", "False").lower() == "true"
-)
-
 
 DEFAULT_USER_PERMISSIONS = {
     "workspace": {
@@ -1470,23 +1364,12 @@ DEFAULT_USER_PERMISSIONS = {
         "knowledge": USER_PERMISSIONS_WORKSPACE_KNOWLEDGE_ACCESS,
         "prompts": USER_PERMISSIONS_WORKSPACE_PROMPTS_ACCESS,
         "tools": USER_PERMISSIONS_WORKSPACE_TOOLS_ACCESS,
-        "models_import": USER_PERMISSIONS_WORKSPACE_MODELS_IMPORT,
-        "models_export": USER_PERMISSIONS_WORKSPACE_MODELS_EXPORT,
-        "prompts_import": USER_PERMISSIONS_WORKSPACE_PROMPTS_IMPORT,
-        "prompts_export": USER_PERMISSIONS_WORKSPACE_PROMPTS_EXPORT,
-        "tools_import": USER_PERMISSIONS_WORKSPACE_TOOLS_IMPORT,
-        "tools_export": USER_PERMISSIONS_WORKSPACE_TOOLS_EXPORT,
     },
     "sharing": {
-        "models": USER_PERMISSIONS_WORKSPACE_MODELS_ALLOW_SHARING,
         "public_models": USER_PERMISSIONS_WORKSPACE_MODELS_ALLOW_PUBLIC_SHARING,
-        "knowledge": USER_PERMISSIONS_WORKSPACE_KNOWLEDGE_ALLOW_SHARING,
         "public_knowledge": USER_PERMISSIONS_WORKSPACE_KNOWLEDGE_ALLOW_PUBLIC_SHARING,
-        "prompts": USER_PERMISSIONS_WORKSPACE_PROMPTS_ALLOW_SHARING,
         "public_prompts": USER_PERMISSIONS_WORKSPACE_PROMPTS_ALLOW_PUBLIC_SHARING,
-        "tools": USER_PERMISSIONS_WORKSPACE_TOOLS_ALLOW_SHARING,
         "public_tools": USER_PERMISSIONS_WORKSPACE_TOOLS_ALLOW_PUBLIC_SHARING,
-        "notes": USER_PERMISSIONS_NOTES_ALLOW_SHARING,
         "public_notes": USER_PERMISSIONS_NOTES_ALLOW_PUBLIC_SHARING,
     },
     "chat": {
@@ -1511,16 +1394,11 @@ DEFAULT_USER_PERMISSIONS = {
         "temporary_enforced": USER_PERMISSIONS_CHAT_TEMPORARY_ENFORCED,
     },
     "features": {
-        # General features
-        "api_keys": USER_PERMISSIONS_FEATURES_API_KEYS,
-        "notes": USER_PERMISSIONS_FEATURES_NOTES,
-        "folders": USER_PERMISSIONS_FEATURES_FOLDERS,
-        "channels": USER_PERMISSIONS_FEATURES_CHANNELS,
         "direct_tool_servers": USER_PERMISSIONS_FEATURES_DIRECT_TOOL_SERVERS,
-        # Chat features
         "web_search": USER_PERMISSIONS_FEATURES_WEB_SEARCH,
         "image_generation": USER_PERMISSIONS_FEATURES_IMAGE_GENERATION,
         "code_interpreter": USER_PERMISSIONS_FEATURES_CODE_INTERPRETER,
+        "notes": USER_PERMISSIONS_FEATURES_NOTES,
     },
 }
 
@@ -1530,12 +1408,6 @@ USER_PERMISSIONS = PersistentConfig(
     DEFAULT_USER_PERMISSIONS,
 )
 
-ENABLE_FOLDERS = PersistentConfig(
-    "ENABLE_FOLDERS",
-    "folders.enable",
-    os.environ.get("ENABLE_FOLDERS", "True").lower() == "true",
-)
-
 ENABLE_CHANNELS = PersistentConfig(
     "ENABLE_CHANNELS",
     "channels.enable",
@@ -1935,38 +1807,6 @@ Output:
 #### Output:
 """
 
-
-VOICE_MODE_PROMPT_TEMPLATE = PersistentConfig(
-    "VOICE_MODE_PROMPT_TEMPLATE",
-    "task.voice.prompt_template",
-    os.environ.get("VOICE_MODE_PROMPT_TEMPLATE", ""),
-)
-
-DEFAULT_VOICE_MODE_PROMPT_TEMPLATE = """You are a friendly, concise voice assistant.
-
-Everything you say will be spoken aloud.
-Keep responses short, clear, and natural.
-
-STYLE:
-- Use simple words and short sentences.
-- Sound warm and conversational.
-- Avoid long explanations, lists, or complex phrasing.
-
-BEHAVIOR:
-- Give the quickest helpful answer first.
-- Offer extra detail only if needed.
-- Ask for clarification only when necessary.
-
-VOICE OPTIMIZATION:
-- Break information into small, easy-to-hear chunks.
-- Avoid dense wording or anything that sounds like reading text.
-
-ERROR HANDLING:
-- If unsure, say so briefly and offer options.
-- If something is unsafe or impossible, decline kindly and suggest a safe alternative.
-
-Stay consistent, helpful, and easy to listen to."""
-
 TOOLS_FUNCTION_CALLING_PROMPT_TEMPLATE = PersistentConfig(
     "TOOLS_FUNCTION_CALLING_PROMPT_TEMPLATE",
     "task.tools.prompt_template",
@@ -2207,11 +2047,6 @@ ENABLE_QDRANT_MULTITENANCY_MODE = (
 )
 QDRANT_COLLECTION_PREFIX = os.environ.get("QDRANT_COLLECTION_PREFIX", "open-webui")
 
-WEAVIATE_HTTP_HOST = os.environ.get("WEAVIATE_HTTP_HOST", "")
-WEAVIATE_HTTP_PORT = int(os.environ.get("WEAVIATE_HTTP_PORT", "8080"))
-WEAVIATE_GRPC_PORT = int(os.environ.get("WEAVIATE_GRPC_PORT", "50051"))
-WEAVIATE_API_KEY = os.environ.get("WEAVIATE_API_KEY")
-
 # OpenSearch
 OPENSEARCH_URI = os.environ.get("OPENSEARCH_URI", "https://localhost:9200")
 OPENSEARCH_SSL = os.environ.get("OPENSEARCH_SSL", "true").lower() == "true"
@@ -2242,16 +2077,6 @@ PGVECTOR_INITIALIZE_MAX_VECTOR_LENGTH = int(
     os.environ.get("PGVECTOR_INITIALIZE_MAX_VECTOR_LENGTH", "1536")
 )
 
-PGVECTOR_USE_HALFVEC = os.getenv("PGVECTOR_USE_HALFVEC", "false").lower() == "true"
-
-if PGVECTOR_INITIALIZE_MAX_VECTOR_LENGTH > 2000 and not PGVECTOR_USE_HALFVEC:
-    raise ValueError(
-        "PGVECTOR_INITIALIZE_MAX_VECTOR_LENGTH is set to "
-        f"{PGVECTOR_INITIALIZE_MAX_VECTOR_LENGTH}, which exceeds the 2000 dimension limit of the "
-        "'vector' type. Set PGVECTOR_USE_HALFVEC=true to enable the 'halfvec' "
-        "type required for high-dimensional embeddings."
-    )
-
 PGVECTOR_CREATE_EXTENSION = (
     os.getenv("PGVECTOR_CREATE_EXTENSION", "true").lower() == "true"
 )
@@ -2301,40 +2126,6 @@ else:
     except Exception:
         PGVECTOR_POOL_RECYCLE = 3600
 
-PGVECTOR_INDEX_METHOD = os.getenv("PGVECTOR_INDEX_METHOD", "").strip().lower()
-if PGVECTOR_INDEX_METHOD not in ("ivfflat", "hnsw", ""):
-    PGVECTOR_INDEX_METHOD = ""
-
-PGVECTOR_HNSW_M = os.environ.get("PGVECTOR_HNSW_M", 16)
-
-if PGVECTOR_HNSW_M == "":
-    PGVECTOR_HNSW_M = 16
-else:
-    try:
-        PGVECTOR_HNSW_M = int(PGVECTOR_HNSW_M)
-    except Exception:
-        PGVECTOR_HNSW_M = 16
-
-PGVECTOR_HNSW_EF_CONSTRUCTION = os.environ.get("PGVECTOR_HNSW_EF_CONSTRUCTION", 64)
-
-if PGVECTOR_HNSW_EF_CONSTRUCTION == "":
-    PGVECTOR_HNSW_EF_CONSTRUCTION = 64
-else:
-    try:
-        PGVECTOR_HNSW_EF_CONSTRUCTION = int(PGVECTOR_HNSW_EF_CONSTRUCTION)
-    except Exception:
-        PGVECTOR_HNSW_EF_CONSTRUCTION = 64
-
-PGVECTOR_IVFFLAT_LISTS = os.environ.get("PGVECTOR_IVFFLAT_LISTS", 100)
-
-if PGVECTOR_IVFFLAT_LISTS == "":
-    PGVECTOR_IVFFLAT_LISTS = 100
-else:
-    try:
-        PGVECTOR_IVFFLAT_LISTS = int(PGVECTOR_IVFFLAT_LISTS)
-    except Exception:
-        PGVECTOR_IVFFLAT_LISTS = 100
-
 # Pinecone
 PINECONE_API_KEY = os.environ.get("PINECONE_API_KEY", None)
 PINECONE_ENVIRONMENT = os.environ.get("PINECONE_ENVIRONMENT", None)
@@ -2560,12 +2351,6 @@ DOCLING_SERVER_URL = PersistentConfig(
     os.getenv("DOCLING_SERVER_URL", "http://docling:5001"),
 )
 
-DOCLING_API_KEY = PersistentConfig(
-    "DOCLING_API_KEY",
-    "rag.docling_api_key",
-    os.getenv("DOCLING_API_KEY", ""),
-)
-
 docling_params = os.getenv("DOCLING_PARAMS", "")
 try:
     docling_params = json.loads(docling_params)
@@ -2578,6 +2363,88 @@ DOCLING_PARAMS = PersistentConfig(
     docling_params,
 )
 
+DOCLING_DO_OCR = PersistentConfig(
+    "DOCLING_DO_OCR",
+    "rag.docling_do_ocr",
+    os.getenv("DOCLING_DO_OCR", "True").lower() == "true",
+)
+
+DOCLING_FORCE_OCR = PersistentConfig(
+    "DOCLING_FORCE_OCR",
+    "rag.docling_force_ocr",
+    os.getenv("DOCLING_FORCE_OCR", "False").lower() == "true",
+)
+
+DOCLING_OCR_ENGINE = PersistentConfig(
+    "DOCLING_OCR_ENGINE",
+    "rag.docling_ocr_engine",
+    os.getenv("DOCLING_OCR_ENGINE", "tesseract"),
+)
+
+DOCLING_OCR_LANG = PersistentConfig(
+    "DOCLING_OCR_LANG",
+    "rag.docling_ocr_lang",
+    os.getenv("DOCLING_OCR_LANG", "eng,fra,deu,spa"),
+)
+
+DOCLING_PDF_BACKEND = PersistentConfig(
+    "DOCLING_PDF_BACKEND",
+    "rag.docling_pdf_backend",
+    os.getenv("DOCLING_PDF_BACKEND", "dlparse_v4"),
+)
+
+DOCLING_TABLE_MODE = PersistentConfig(
+    "DOCLING_TABLE_MODE",
+    "rag.docling_table_mode",
+    os.getenv("DOCLING_TABLE_MODE", "accurate"),
+)
+
+DOCLING_PIPELINE = PersistentConfig(
+    "DOCLING_PIPELINE",
+    "rag.docling_pipeline",
+    os.getenv("DOCLING_PIPELINE", "standard"),
+)
+
+DOCLING_DO_PICTURE_DESCRIPTION = PersistentConfig(
+    "DOCLING_DO_PICTURE_DESCRIPTION",
+    "rag.docling_do_picture_description",
+    os.getenv("DOCLING_DO_PICTURE_DESCRIPTION", "False").lower() == "true",
+)
+
+DOCLING_PICTURE_DESCRIPTION_MODE = PersistentConfig(
+    "DOCLING_PICTURE_DESCRIPTION_MODE",
+    "rag.docling_picture_description_mode",
+    os.getenv("DOCLING_PICTURE_DESCRIPTION_MODE", ""),
+)
+
+
+docling_picture_description_local = os.getenv("DOCLING_PICTURE_DESCRIPTION_LOCAL", "")
+try:
+    docling_picture_description_local = json.loads(docling_picture_description_local)
+except json.JSONDecodeError:
+    docling_picture_description_local = {}
+
+
+DOCLING_PICTURE_DESCRIPTION_LOCAL = PersistentConfig(
+    "DOCLING_PICTURE_DESCRIPTION_LOCAL",
+    "rag.docling_picture_description_local",
+    docling_picture_description_local,
+)
+
+docling_picture_description_api = os.getenv("DOCLING_PICTURE_DESCRIPTION_API", "")
+try:
+    docling_picture_description_api = json.loads(docling_picture_description_api)
+except json.JSONDecodeError:
+    docling_picture_description_api = {}
+
+
+DOCLING_PICTURE_DESCRIPTION_API = PersistentConfig(
+    "DOCLING_PICTURE_DESCRIPTION_API",
+    "rag.docling_picture_description_api",
+    docling_picture_description_api,
+)
+
+
 DOCUMENT_INTELLIGENCE_ENDPOINT = PersistentConfig(
     "DOCUMENT_INTELLIGENCE_ENDPOINT",
     "rag.document_intelligence_endpoint",
@@ -2590,18 +2457,6 @@ DOCUMENT_INTELLIGENCE_KEY = PersistentConfig(
     os.getenv("DOCUMENT_INTELLIGENCE_KEY", ""),
 )
 
-DOCUMENT_INTELLIGENCE_MODEL = PersistentConfig(
-    "DOCUMENT_INTELLIGENCE_MODEL",
-    "rag.document_intelligence_model",
-    os.getenv("DOCUMENT_INTELLIGENCE_MODEL", "prebuilt-layout"),
-)
-
-MISTRAL_OCR_API_BASE_URL = PersistentConfig(
-    "MISTRAL_OCR_API_BASE_URL",
-    "rag.MISTRAL_OCR_API_BASE_URL",
-    os.getenv("MISTRAL_OCR_API_BASE_URL", "https://api.mistral.ai/v1"),
-)
-
 MISTRAL_OCR_API_KEY = PersistentConfig(
     "MISTRAL_OCR_API_KEY",
     "rag.mistral_ocr_api_key",
@@ -2640,13 +2495,6 @@ ENABLE_RAG_HYBRID_SEARCH = PersistentConfig(
     os.environ.get("ENABLE_RAG_HYBRID_SEARCH", "").lower() == "true",
 )
 
-ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS = PersistentConfig(
-    "ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS",
-    "rag.enable_hybrid_search_enriched_texts",
-    os.environ.get("ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS", "False").lower()
-    == "true",
-)
-
 RAG_FULL_CONTEXT = PersistentConfig(
     "RAG_FULL_CONTEXT",
     "rag.full_context",
@@ -2741,12 +2589,6 @@ RAG_EMBEDDING_BATCH_SIZE = PersistentConfig(
     ),
 )
 
-ENABLE_ASYNC_EMBEDDING = PersistentConfig(
-    "ENABLE_ASYNC_EMBEDDING",
-    "rag.enable_async_embedding",
-    os.environ.get("ENABLE_ASYNC_EMBEDDING", "True").lower() == "true",
-)
-
 RAG_EMBEDDING_QUERY_PREFIX = os.environ.get("RAG_EMBEDDING_QUERY_PREFIX", None)
 
 RAG_EMBEDDING_CONTENT_PREFIX = os.environ.get("RAG_EMBEDDING_CONTENT_PREFIX", None)
@@ -2840,6 +2682,10 @@ Provide a clear and direct response to the user's query, including inline citati
 <context>
 {{CONTEXT}}
 </context>
+
+<user_query>
+{{QUERY}}
+</user_query>
 """
 
 RAG_TEMPLATE = PersistentConfig(
@@ -2892,26 +2738,6 @@ ENABLE_RAG_LOCAL_WEB_FETCH = (
     os.getenv("ENABLE_RAG_LOCAL_WEB_FETCH", "False").lower() == "true"
 )
 
-
-DEFAULT_WEB_FETCH_FILTER_LIST = [
-    "!169.254.169.254",
-    "!fd00:ec2::254",
-    "!metadata.google.internal",
-    "!metadata.azure.com",
-    "!100.100.100.200",
-]
-
-web_fetch_filter_list = os.getenv("WEB_FETCH_FILTER_LIST", "")
-if web_fetch_filter_list == "":
-    web_fetch_filter_list = []
-else:
-    web_fetch_filter_list = [
-        item.strip() for item in web_fetch_filter_list.split(",") if item.strip()
-    ]
-
-WEB_FETCH_FILTER_LIST = list(set(DEFAULT_WEB_FETCH_FILTER_LIST + web_fetch_filter_list))
-
-
 YOUTUBE_LOADER_LANGUAGE = PersistentConfig(
     "YOUTUBE_LOADER_LANGUAGE",
     "rag.youtube_loader_language",
@@ -2970,7 +2796,6 @@ WEB_SEARCH_DOMAIN_FILTER_LIST = PersistentConfig(
         # "wikipedia.com",
         # "wikimedia.org",
         # "wikidata.org",
-        # "!stackoverflow.com",
     ],
 )
 
@@ -3142,24 +2967,6 @@ BING_SEARCH_V7_SUBSCRIPTION_KEY = PersistentConfig(
     os.environ.get("BING_SEARCH_V7_SUBSCRIPTION_KEY", ""),
 )
 
-AZURE_AI_SEARCH_API_KEY = PersistentConfig(
-    "AZURE_AI_SEARCH_API_KEY",
-    "rag.web.search.azure_ai_search_api_key",
-    os.environ.get("AZURE_AI_SEARCH_API_KEY", ""),
-)
-
-AZURE_AI_SEARCH_ENDPOINT = PersistentConfig(
-    "AZURE_AI_SEARCH_ENDPOINT",
-    "rag.web.search.azure_ai_search_endpoint",
-    os.environ.get("AZURE_AI_SEARCH_ENDPOINT", ""),
-)
-
-AZURE_AI_SEARCH_INDEX_NAME = PersistentConfig(
-    "AZURE_AI_SEARCH_INDEX_NAME",
-    "rag.web.search.azure_ai_search_index_name",
-    os.environ.get("AZURE_AI_SEARCH_INDEX_NAME", ""),
-)
-
 EXA_API_KEY = PersistentConfig(
     "EXA_API_KEY",
     "rag.web.search.exa_api_key",
@@ -3184,12 +2991,6 @@ PERPLEXITY_SEARCH_CONTEXT_USAGE = PersistentConfig(
     os.getenv("PERPLEXITY_SEARCH_CONTEXT_USAGE", "medium"),
 )
 
-PERPLEXITY_SEARCH_API_URL = PersistentConfig(
-    "PERPLEXITY_SEARCH_API_URL",
-    "rag.web.search.perplexity_search_api_url",
-    os.getenv("PERPLEXITY_SEARCH_API_URL", "https://api.perplexity.ai/search"),
-)
-
 SOUGOU_API_SID = PersistentConfig(
     "SOUGOU_API_SID",
     "rag.web.search.sougou_api_sid",
@@ -3266,30 +3067,16 @@ EXTERNAL_WEB_LOADER_API_KEY = PersistentConfig(
 # Images
 ####################################
 
-ENABLE_IMAGE_GENERATION = PersistentConfig(
-    "ENABLE_IMAGE_GENERATION",
-    "image_generation.enable",
-    os.environ.get("ENABLE_IMAGE_GENERATION", "").lower() == "true",
-)
-
 IMAGE_GENERATION_ENGINE = PersistentConfig(
     "IMAGE_GENERATION_ENGINE",
     "image_generation.engine",
     os.getenv("IMAGE_GENERATION_ENGINE", "openai"),
 )
 
-IMAGE_GENERATION_MODEL = PersistentConfig(
-    "IMAGE_GENERATION_MODEL",
-    "image_generation.model",
-    os.getenv("IMAGE_GENERATION_MODEL", ""),
-)
-
-IMAGE_SIZE = PersistentConfig(
-    "IMAGE_SIZE", "image_generation.size", os.getenv("IMAGE_SIZE", "512x512")
-)
-
-IMAGE_STEPS = PersistentConfig(
-    "IMAGE_STEPS", "image_generation.steps", int(os.getenv("IMAGE_STEPS", 50))
+ENABLE_IMAGE_GENERATION = PersistentConfig(
+    "ENABLE_IMAGE_GENERATION",
+    "image_generation.enable",
+    os.environ.get("ENABLE_IMAGE_GENERATION", "").lower() == "true",
 )
 
 ENABLE_IMAGE_PROMPT_GENERATION = PersistentConfig(
@@ -3309,16 +3096,35 @@ AUTOMATIC1111_API_AUTH = PersistentConfig(
     os.getenv("AUTOMATIC1111_API_AUTH", ""),
 )
 
-automatic1111_params = os.getenv("AUTOMATIC1111_PARAMS", "")
-try:
-    automatic1111_params = json.loads(automatic1111_params)
-except json.JSONDecodeError:
-    automatic1111_params = {}
+AUTOMATIC1111_CFG_SCALE = PersistentConfig(
+    "AUTOMATIC1111_CFG_SCALE",
+    "image_generation.automatic1111.cfg_scale",
+    (
+        float(os.environ.get("AUTOMATIC1111_CFG_SCALE"))
+        if os.environ.get("AUTOMATIC1111_CFG_SCALE")
+        else None
+    ),
+)
 
-AUTOMATIC1111_PARAMS = PersistentConfig(
-    "AUTOMATIC1111_PARAMS",
-    "image_generation.automatic1111.api_params",
-    automatic1111_params,
+
+AUTOMATIC1111_SAMPLER = PersistentConfig(
+    "AUTOMATIC1111_SAMPLER",
+    "image_generation.automatic1111.sampler",
+    (
+        os.environ.get("AUTOMATIC1111_SAMPLER")
+        if os.environ.get("AUTOMATIC1111_SAMPLER")
+        else None
+    ),
+)
+
+AUTOMATIC1111_SCHEDULER = PersistentConfig(
+    "AUTOMATIC1111_SCHEDULER",
+    "image_generation.automatic1111.scheduler",
+    (
+        os.environ.get("AUTOMATIC1111_SCHEDULER")
+        if os.environ.get("AUTOMATIC1111_SCHEDULER")
+        else None
+    ),
 )
 
 COMFYUI_BASE_URL = PersistentConfig(
@@ -3473,18 +3279,6 @@ IMAGES_OPENAI_API_KEY = PersistentConfig(
     os.getenv("IMAGES_OPENAI_API_KEY", OPENAI_API_KEY),
 )
 
-images_openai_params = os.getenv("IMAGES_OPENAI_PARAMS", "")
-try:
-    images_openai_params = json.loads(images_openai_params)
-except json.JSONDecodeError:
-    images_openai_params = {}
-
-
-IMAGES_OPENAI_API_PARAMS = PersistentConfig(
-    "IMAGES_OPENAI_API_PARAMS", "image_generation.openai.params", images_openai_params
-)
-
-
 IMAGES_GEMINI_API_BASE_URL = PersistentConfig(
     "IMAGES_GEMINI_API_BASE_URL",
     "image_generation.gemini.api_base_url",
@@ -3496,84 +3290,18 @@ IMAGES_GEMINI_API_KEY = PersistentConfig(
     os.getenv("IMAGES_GEMINI_API_KEY", GEMINI_API_KEY),
 )
 
-IMAGES_GEMINI_ENDPOINT_METHOD = PersistentConfig(
-    "IMAGES_GEMINI_ENDPOINT_METHOD",
-    "image_generation.gemini.endpoint_method",
-    os.getenv("IMAGES_GEMINI_ENDPOINT_METHOD", ""),
+IMAGE_SIZE = PersistentConfig(
+    "IMAGE_SIZE", "image_generation.size", os.getenv("IMAGE_SIZE", "512x512")
 )
 
-ENABLE_IMAGE_EDIT = PersistentConfig(
-    "ENABLE_IMAGE_EDIT",
-    "images.edit.enable",
-    os.environ.get("ENABLE_IMAGE_EDIT", "").lower() == "true",
+IMAGE_STEPS = PersistentConfig(
+    "IMAGE_STEPS", "image_generation.steps", int(os.getenv("IMAGE_STEPS", 50))
 )
 
-IMAGE_EDIT_ENGINE = PersistentConfig(
-    "IMAGE_EDIT_ENGINE",
-    "images.edit.engine",
-    os.getenv("IMAGE_EDIT_ENGINE", "openai"),
-)
-
-IMAGE_EDIT_MODEL = PersistentConfig(
-    "IMAGE_EDIT_MODEL",
-    "images.edit.model",
-    os.getenv("IMAGE_EDIT_MODEL", ""),
-)
-
-IMAGE_EDIT_SIZE = PersistentConfig(
-    "IMAGE_EDIT_SIZE", "images.edit.size", os.getenv("IMAGE_EDIT_SIZE", "")
-)
-
-IMAGES_EDIT_OPENAI_API_BASE_URL = PersistentConfig(
-    "IMAGES_EDIT_OPENAI_API_BASE_URL",
-    "images.edit.openai.api_base_url",
-    os.getenv("IMAGES_EDIT_OPENAI_API_BASE_URL", OPENAI_API_BASE_URL),
-)
-IMAGES_EDIT_OPENAI_API_VERSION = PersistentConfig(
-    "IMAGES_EDIT_OPENAI_API_VERSION",
-    "images.edit.openai.api_version",
-    os.getenv("IMAGES_EDIT_OPENAI_API_VERSION", ""),
-)
-
-IMAGES_EDIT_OPENAI_API_KEY = PersistentConfig(
-    "IMAGES_EDIT_OPENAI_API_KEY",
-    "images.edit.openai.api_key",
-    os.getenv("IMAGES_EDIT_OPENAI_API_KEY", OPENAI_API_KEY),
-)
-
-IMAGES_EDIT_GEMINI_API_BASE_URL = PersistentConfig(
-    "IMAGES_EDIT_GEMINI_API_BASE_URL",
-    "images.edit.gemini.api_base_url",
-    os.getenv("IMAGES_EDIT_GEMINI_API_BASE_URL", GEMINI_API_BASE_URL),
-)
-IMAGES_EDIT_GEMINI_API_KEY = PersistentConfig(
-    "IMAGES_EDIT_GEMINI_API_KEY",
-    "images.edit.gemini.api_key",
-    os.getenv("IMAGES_EDIT_GEMINI_API_KEY", GEMINI_API_KEY),
-)
-
-
-IMAGES_EDIT_COMFYUI_BASE_URL = PersistentConfig(
-    "IMAGES_EDIT_COMFYUI_BASE_URL",
-    "images.edit.comfyui.base_url",
-    os.getenv("IMAGES_EDIT_COMFYUI_BASE_URL", ""),
-)
-IMAGES_EDIT_COMFYUI_API_KEY = PersistentConfig(
-    "IMAGES_EDIT_COMFYUI_API_KEY",
-    "images.edit.comfyui.api_key",
-    os.getenv("IMAGES_EDIT_COMFYUI_API_KEY", ""),
-)
-
-IMAGES_EDIT_COMFYUI_WORKFLOW = PersistentConfig(
-    "IMAGES_EDIT_COMFYUI_WORKFLOW",
-    "images.edit.comfyui.workflow",
-    os.getenv("IMAGES_EDIT_COMFYUI_WORKFLOW", ""),
-)
-
-IMAGES_EDIT_COMFYUI_WORKFLOW_NODES = PersistentConfig(
-    "IMAGES_EDIT_COMFYUI_WORKFLOW_NODES",
-    "images.edit.comfyui.nodes",
-    [],
+IMAGE_GENERATION_MODEL = PersistentConfig(
+    "IMAGE_GENERATION_MODEL",
+    "image_generation.model",
+    os.getenv("IMAGE_GENERATION_MODEL", ""),
 )
 
 ####################################
@@ -3608,10 +3336,6 @@ DEEPGRAM_API_KEY = PersistentConfig(
     os.getenv("DEEPGRAM_API_KEY", ""),
 )
 
-# ElevenLabs configuration
-ELEVENLABS_API_BASE_URL = os.getenv(
-    "ELEVENLABS_API_BASE_URL", "https://api.elevenlabs.io"
-)
 
 AUDIO_STT_OPENAI_API_BASE_URL = PersistentConfig(
     "AUDIO_STT_OPENAI_API_BASE_URL",
@@ -3679,24 +3403,6 @@ AUDIO_STT_AZURE_MAX_SPEAKERS = PersistentConfig(
     os.getenv("AUDIO_STT_AZURE_MAX_SPEAKERS", ""),
 )
 
-AUDIO_STT_MISTRAL_API_KEY = PersistentConfig(
-    "AUDIO_STT_MISTRAL_API_KEY",
-    "audio.stt.mistral.api_key",
-    os.getenv("AUDIO_STT_MISTRAL_API_KEY", ""),
-)
-
-AUDIO_STT_MISTRAL_API_BASE_URL = PersistentConfig(
-    "AUDIO_STT_MISTRAL_API_BASE_URL",
-    "audio.stt.mistral.api_base_url",
-    os.getenv("AUDIO_STT_MISTRAL_API_BASE_URL", "https://api.mistral.ai/v1"),
-)
-
-AUDIO_STT_MISTRAL_USE_CHAT_COMPLETIONS = PersistentConfig(
-    "AUDIO_STT_MISTRAL_USE_CHAT_COMPLETIONS",
-    "audio.stt.mistral.use_chat_completions",
-    os.getenv("AUDIO_STT_MISTRAL_USE_CHAT_COMPLETIONS", "false").lower() == "true",
-)
-
 AUDIO_TTS_OPENAI_API_BASE_URL = PersistentConfig(
     "AUDIO_TTS_OPENAI_API_BASE_URL",
     "audio.tts.openai.api_base_url",

backend/open_webui/constants.py

@@ -45,7 +45,7 @@ class ERROR_MESSAGES(str, Enum):
     )
     INVALID_CRED = "The email or password provided is incorrect. Please check for typos and try logging in again."
     INVALID_EMAIL_FORMAT = "The email format you entered is invalid. Please double-check and make sure you're using a valid email address (e.g., yourname@example.com)."
-    INCORRECT_PASSWORD = (
+    INVALID_PASSWORD = (
         "The password provided is incorrect. Please check for typos and try again."
     )
     INVALID_TRUSTED_HEADER = "Your provider has not provided a trusted header. Please contact your administrator for assistance."
@@ -105,10 +105,6 @@ class ERROR_MESSAGES(str, Enum):
     )
     FILE_NOT_PROCESSED = "Extracted content is not available for this file. Please ensure that the file is processed before proceeding."
 
-    INVALID_PASSWORD = lambda err="": (
-        err if err else "The password does not meet the required validation criteria."
-    )
-
 
 class TASKS(str, Enum):
     def __str__(self) -> str:

backend/open_webui/env.py

@@ -8,8 +8,6 @@ import shutil
 from uuid import uuid4
 from pathlib import Path
 from cryptography.hazmat.primitives import serialization
-import re
-
 
 import markdown
 from bs4 import BeautifulSoup
@@ -137,9 +135,6 @@ else:
         PACKAGE_DATA = {"version": "0.0.0"}
 
 VERSION = PACKAGE_DATA["version"]
-
-
-DEPLOYMENT_ID = os.environ.get("DEPLOYMENT_ID", "")
 INSTANCE_ID = os.environ.get("INSTANCE_ID", str(uuid4()))
 
 
@@ -431,17 +426,6 @@ WEBUI_AUTH_TRUSTED_GROUPS_HEADER = os.environ.get(
 )
 
 
-ENABLE_PASSWORD_VALIDATION = (
-    os.environ.get("ENABLE_PASSWORD_VALIDATION", "False").lower() == "true"
-)
-PASSWORD_VALIDATION_REGEX_PATTERN = os.environ.get(
-    "PASSWORD_VALIDATION_REGEX_PATTERN",
-    "^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\w\s]).{8,}$",
-)
-
-PASSWORD_VALIDATION_REGEX_PATTERN = re.compile(PASSWORD_VALIDATION_REGEX_PATTERN)
-
-
 BYPASS_MODEL_ACCESS_CONTROL = (
     os.environ.get("BYPASS_MODEL_ACCESS_CONTROL", "False").lower() == "true"
 )
@@ -509,10 +493,7 @@ OAUTH_SESSION_TOKEN_ENCRYPTION_KEY = os.environ.get(
 # SCIM Configuration
 ####################################
 
-ENABLE_SCIM = (
-    os.environ.get("ENABLE_SCIM", os.environ.get("SCIM_ENABLED", "False")).lower()
-    == "true"
-)
+SCIM_ENABLED = os.environ.get("SCIM_ENABLED", "False").lower() == "true"
 SCIM_TOKEN = os.environ.get("SCIM_TOKEN", "")
 
 ####################################
@@ -560,11 +541,6 @@ else:
 # CHAT
 ####################################
 
-ENABLE_CHAT_RESPONSE_BASE64_IMAGE_URL_CONVERSION = (
-    os.environ.get("ENABLE_CHAT_RESPONSE_BASE64_IMAGE_URL_CONVERSION", "False").lower()
-    == "true"
-)
-
 CHAT_RESPONSE_STREAM_DELTA_CHUNK_SIZE = os.environ.get(
     "CHAT_RESPONSE_STREAM_DELTA_CHUNK_SIZE", "1"
 )
@@ -593,21 +569,6 @@ else:
         CHAT_RESPONSE_MAX_TOOL_CALL_RETRIES = 30
 
 
-CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE = os.environ.get(
-    "CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE", ""
-)
-
-if CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE == "":
-    CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE = None
-else:
-    try:
-        CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE = int(
-            CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE
-        )
-    except Exception:
-        CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE = None
-
-
 ####################################
 # WEBSOCKET SUPPORT
 ####################################
@@ -619,17 +580,6 @@ ENABLE_WEBSOCKET_SUPPORT = (
 
 WEBSOCKET_MANAGER = os.environ.get("WEBSOCKET_MANAGER", "")
 
-WEBSOCKET_REDIS_OPTIONS = os.environ.get("WEBSOCKET_REDIS_OPTIONS", "")
-if WEBSOCKET_REDIS_OPTIONS == "":
-    log.debug("No WEBSOCKET_REDIS_OPTIONS provided, defaulting to None")
-    WEBSOCKET_REDIS_OPTIONS = None
-else:
-    try:
-        WEBSOCKET_REDIS_OPTIONS = json.loads(WEBSOCKET_REDIS_OPTIONS)
-    except Exception:
-        log.warning("Invalid WEBSOCKET_REDIS_OPTIONS, defaulting to None")
-        WEBSOCKET_REDIS_OPTIONS = None
-
 WEBSOCKET_REDIS_URL = os.environ.get("WEBSOCKET_REDIS_URL", REDIS_URL)
 WEBSOCKET_REDIS_CLUSTER = (
     os.environ.get("WEBSOCKET_REDIS_CLUSTER", str(REDIS_CLUSTER)).lower() == "true"
@@ -644,23 +594,6 @@ except ValueError:
 
 WEBSOCKET_SENTINEL_HOSTS = os.environ.get("WEBSOCKET_SENTINEL_HOSTS", "")
 WEBSOCKET_SENTINEL_PORT = os.environ.get("WEBSOCKET_SENTINEL_PORT", "26379")
-WEBSOCKET_SERVER_LOGGING = (
-    os.environ.get("WEBSOCKET_SERVER_LOGGING", "False").lower() == "true"
-)
-WEBSOCKET_SERVER_ENGINEIO_LOGGING = (
-    os.environ.get("WEBSOCKET_SERVER_LOGGING", "False").lower() == "true"
-)
-WEBSOCKET_SERVER_PING_TIMEOUT = os.environ.get("WEBSOCKET_SERVER_PING_TIMEOUT", "20")
-try:
-    WEBSOCKET_SERVER_PING_TIMEOUT = int(WEBSOCKET_SERVER_PING_TIMEOUT)
-except ValueError:
-    WEBSOCKET_SERVER_PING_TIMEOUT = 20
-
-WEBSOCKET_SERVER_PING_INTERVAL = os.environ.get("WEBSOCKET_SERVER_PING_INTERVAL", "25")
-try:
-    WEBSOCKET_SERVER_PING_INTERVAL = int(WEBSOCKET_SERVER_PING_INTERVAL)
-except ValueError:
-    WEBSOCKET_SERVER_PING_INTERVAL = 25
 
 
 AIOHTTP_CLIENT_TIMEOUT = os.environ.get("AIOHTTP_CLIENT_TIMEOUT", "")
@@ -773,9 +706,7 @@ if OFFLINE_MODE:
 # AUDIT LOGGING
 ####################################
 # Where to store log file
-# Defaults to the DATA_DIR/audit.log. To set AUDIT_LOGS_FILE_PATH you need to
-# provide the whole path, like: /app/audit.log
-AUDIT_LOGS_FILE_PATH = os.getenv("AUDIT_LOGS_FILE_PATH", f"{DATA_DIR}/audit.log")
+AUDIT_LOGS_FILE_PATH = f"{DATA_DIR}/audit.log"
 # Maximum size of a file before rotating into a new log file
 AUDIT_LOG_FILE_ROTATION_SIZE = os.getenv("AUDIT_LOG_FILE_ROTATION_SIZE", "10MB")
 

backend/open_webui/main.py

@@ -61,11 +61,11 @@ from open_webui.utils import logger
 from open_webui.utils.audit import AuditLevel, AuditLoggingMiddleware
 from open_webui.utils.logger import start_logger
 from open_webui.socket.main import (
-    MODELS,
     app as socket_app,
     periodic_usage_pool_cleanup,
     get_event_emitter,
     get_models_in_use,
+    get_active_user_ids,
 )
 from open_webui.routers import (
     audio,
@@ -146,7 +146,9 @@ from open_webui.config import (
     # Image
     AUTOMATIC1111_API_AUTH,
     AUTOMATIC1111_BASE_URL,
-    AUTOMATIC1111_PARAMS,
+    AUTOMATIC1111_CFG_SCALE,
+    AUTOMATIC1111_SAMPLER,
+    AUTOMATIC1111_SCHEDULER,
     COMFYUI_BASE_URL,
     COMFYUI_API_KEY,
     COMFYUI_WORKFLOW,
@@ -160,23 +162,8 @@ from open_webui.config import (
     IMAGES_OPENAI_API_BASE_URL,
     IMAGES_OPENAI_API_VERSION,
     IMAGES_OPENAI_API_KEY,
-    IMAGES_OPENAI_API_PARAMS,
     IMAGES_GEMINI_API_BASE_URL,
     IMAGES_GEMINI_API_KEY,
-    IMAGES_GEMINI_ENDPOINT_METHOD,
-    ENABLE_IMAGE_EDIT,
-    IMAGE_EDIT_ENGINE,
-    IMAGE_EDIT_MODEL,
-    IMAGE_EDIT_SIZE,
-    IMAGES_EDIT_OPENAI_API_BASE_URL,
-    IMAGES_EDIT_OPENAI_API_KEY,
-    IMAGES_EDIT_OPENAI_API_VERSION,
-    IMAGES_EDIT_GEMINI_API_BASE_URL,
-    IMAGES_EDIT_GEMINI_API_KEY,
-    IMAGES_EDIT_COMFYUI_BASE_URL,
-    IMAGES_EDIT_COMFYUI_API_KEY,
-    IMAGES_EDIT_COMFYUI_WORKFLOW,
-    IMAGES_EDIT_COMFYUI_WORKFLOW_NODES,
     # Audio
     AUDIO_STT_ENGINE,
     AUDIO_STT_MODEL,
@@ -188,9 +175,6 @@ from open_webui.config import (
     AUDIO_STT_AZURE_LOCALES,
     AUDIO_STT_AZURE_BASE_URL,
     AUDIO_STT_AZURE_MAX_SPEAKERS,
-    AUDIO_STT_MISTRAL_API_KEY,
-    AUDIO_STT_MISTRAL_API_BASE_URL,
-    AUDIO_STT_MISTRAL_USE_CHAT_COMPLETIONS,
     AUDIO_TTS_ENGINE,
     AUDIO_TTS_MODEL,
     AUDIO_TTS_VOICE,
@@ -230,7 +214,6 @@ from open_webui.config import (
     RAG_RERANKING_MODEL_TRUST_REMOTE_CODE,
     RAG_EMBEDDING_ENGINE,
     RAG_EMBEDDING_BATCH_SIZE,
-    ENABLE_ASYNC_EMBEDDING,
     RAG_TOP_K,
     RAG_TOP_K_RERANKER,
     RAG_RELEVANCE_THRESHOLD,
@@ -269,12 +252,20 @@ from open_webui.config import (
     EXTERNAL_DOCUMENT_LOADER_API_KEY,
     TIKA_SERVER_URL,
     DOCLING_SERVER_URL,
-    DOCLING_API_KEY,
     DOCLING_PARAMS,
+    DOCLING_DO_OCR,
+    DOCLING_FORCE_OCR,
+    DOCLING_OCR_ENGINE,
+    DOCLING_OCR_LANG,
+    DOCLING_PDF_BACKEND,
+    DOCLING_TABLE_MODE,
+    DOCLING_PIPELINE,
+    DOCLING_DO_PICTURE_DESCRIPTION,
+    DOCLING_PICTURE_DESCRIPTION_MODE,
+    DOCLING_PICTURE_DESCRIPTION_LOCAL,
+    DOCLING_PICTURE_DESCRIPTION_API,
     DOCUMENT_INTELLIGENCE_ENDPOINT,
     DOCUMENT_INTELLIGENCE_KEY,
-    DOCUMENT_INTELLIGENCE_MODEL,
-    MISTRAL_OCR_API_BASE_URL,
     MISTRAL_OCR_API_KEY,
     RAG_TEXT_SPLITTER,
     TIKTOKEN_ENCODING_NAME,
@@ -313,7 +304,6 @@ from open_webui.config import (
     PERPLEXITY_API_KEY,
     PERPLEXITY_MODEL,
     PERPLEXITY_SEARCH_CONTEXT_USAGE,
-    PERPLEXITY_SEARCH_API_URL,
     SOUGOU_API_SID,
     SOUGOU_API_SK,
     KAGI_SEARCH_API_KEY,
@@ -331,7 +321,6 @@ from open_webui.config import (
     ENABLE_ONEDRIVE_PERSONAL,
     ENABLE_ONEDRIVE_BUSINESS,
     ENABLE_RAG_HYBRID_SEARCH,
-    ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS,
     ENABLE_RAG_LOCAL_WEB_FETCH,
     ENABLE_WEB_LOADER_SSL_VERIFICATION,
     ENABLE_GOOGLE_DRIVE_INTEGRATION,
@@ -350,10 +339,9 @@ from open_webui.config import (
     JWT_EXPIRES_IN,
     ENABLE_SIGNUP,
     ENABLE_LOGIN_FORM,
-    ENABLE_API_KEYS,
-    ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS,
-    API_KEYS_ALLOWED_ENDPOINTS,
-    ENABLE_FOLDERS,
+    ENABLE_API_KEY,
+    ENABLE_API_KEY_ENDPOINT_RESTRICTIONS,
+    API_KEY_ALLOWED_ENDPOINTS,
     ENABLE_CHANNELS,
     ENABLE_NOTES,
     ENABLE_COMMUNITY_SHARING,
@@ -363,12 +351,10 @@ from open_webui.config import (
     BYPASS_ADMIN_ACCESS_CONTROL,
     USER_PERMISSIONS,
     DEFAULT_USER_ROLE,
-    DEFAULT_GROUP_ID,
     PENDING_USER_OVERLAY_CONTENT,
     PENDING_USER_OVERLAY_TITLE,
     DEFAULT_PROMPT_SUGGESTIONS,
     DEFAULT_MODELS,
-    DEFAULT_PINNED_MODELS,
     DEFAULT_ARENA_MODEL,
     MODEL_ORDER_LIST,
     EVALUATION_ARENA_MODELS,
@@ -427,7 +413,6 @@ from open_webui.config import (
     TAGS_GENERATION_PROMPT_TEMPLATE,
     IMAGE_PROMPT_GENERATION_PROMPT_TEMPLATE,
     TOOLS_FUNCTION_CALLING_PROMPT_TEMPLATE,
-    VOICE_MODE_PROMPT_TEMPLATE,
     QUERY_GENERATION_PROMPT_TEMPLATE,
     AUTOCOMPLETE_GENERATION_PROMPT_TEMPLATE,
     AUTOCOMPLETE_GENERATION_INPUT_MAX_LENGTH,
@@ -449,7 +434,6 @@ from open_webui.env import (
     SAFE_MODE,
     SRC_LOG_LEVELS,
     VERSION,
-    DEPLOYMENT_ID,
     INSTANCE_ID,
     WEBUI_BUILD_HASH,
     WEBUI_SECRET_KEY,
@@ -460,7 +444,7 @@ from open_webui.env import (
     WEBUI_AUTH_TRUSTED_NAME_HEADER,
     WEBUI_AUTH_SIGNOUT_REDIRECT_URL,
     # SCIM
-    ENABLE_SCIM,
+    SCIM_ENABLED,
     SCIM_TOKEN,
     ENABLE_COMPRESSION_MIDDLEWARE,
     ENABLE_WEBSOCKET_SUPPORT,
@@ -498,11 +482,9 @@ from open_webui.utils.auth import (
 )
 from open_webui.utils.plugin import install_tool_and_function_dependencies
 from open_webui.utils.oauth import (
-    get_oauth_client_info_with_dynamic_client_registration,
-    encrypt_data,
-    decrypt_data,
     OAuthManager,
     OAuthClientManager,
+    decrypt_data,
     OAuthClientInformationFull,
 )
 from open_webui.utils.security_headers import SecurityHeadersMiddleware
@@ -716,7 +698,7 @@ app.state.config.ENABLE_DIRECT_CONNECTIONS = ENABLE_DIRECT_CONNECTIONS
 #
 ########################################
 
-app.state.ENABLE_SCIM = ENABLE_SCIM
+app.state.SCIM_ENABLED = SCIM_ENABLED
 app.state.SCIM_TOKEN = SCIM_TOKEN
 
 ########################################
@@ -738,11 +720,11 @@ app.state.config.WEBUI_URL = WEBUI_URL
 app.state.config.ENABLE_SIGNUP = ENABLE_SIGNUP
 app.state.config.ENABLE_LOGIN_FORM = ENABLE_LOGIN_FORM
 
-app.state.config.ENABLE_API_KEYS = ENABLE_API_KEYS
-app.state.config.ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS = (
-    ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS
+app.state.config.ENABLE_API_KEY = ENABLE_API_KEY
+app.state.config.ENABLE_API_KEY_ENDPOINT_RESTRICTIONS = (
+    ENABLE_API_KEY_ENDPOINT_RESTRICTIONS
 )
-app.state.config.API_KEYS_ALLOWED_ENDPOINTS = API_KEYS_ALLOWED_ENDPOINTS
+app.state.config.API_KEY_ALLOWED_ENDPOINTS = API_KEY_ALLOWED_ENDPOINTS
 
 app.state.config.JWT_EXPIRES_IN = JWT_EXPIRES_IN
 
@@ -751,13 +733,8 @@ app.state.config.ADMIN_EMAIL = ADMIN_EMAIL
 
 
 app.state.config.DEFAULT_MODELS = DEFAULT_MODELS
-app.state.config.DEFAULT_PINNED_MODELS = DEFAULT_PINNED_MODELS
-app.state.config.MODEL_ORDER_LIST = MODEL_ORDER_LIST
-
-
 app.state.config.DEFAULT_PROMPT_SUGGESTIONS = DEFAULT_PROMPT_SUGGESTIONS
 app.state.config.DEFAULT_USER_ROLE = DEFAULT_USER_ROLE
-app.state.config.DEFAULT_GROUP_ID = DEFAULT_GROUP_ID
 
 app.state.config.PENDING_USER_OVERLAY_CONTENT = PENDING_USER_OVERLAY_CONTENT
 app.state.config.PENDING_USER_OVERLAY_TITLE = PENDING_USER_OVERLAY_TITLE
@@ -767,9 +744,9 @@ app.state.config.RESPONSE_WATERMARK = RESPONSE_WATERMARK
 app.state.config.USER_PERMISSIONS = USER_PERMISSIONS
 app.state.config.WEBHOOK_URL = WEBHOOK_URL
 app.state.config.BANNERS = WEBUI_BANNERS
+app.state.config.MODEL_ORDER_LIST = MODEL_ORDER_LIST
 
 
-app.state.config.ENABLE_FOLDERS = ENABLE_FOLDERS
 app.state.config.ENABLE_CHANNELS = ENABLE_CHANNELS
 app.state.config.ENABLE_NOTES = ENABLE_NOTES
 app.state.config.ENABLE_COMMUNITY_SHARING = ENABLE_COMMUNITY_SHARING
@@ -845,9 +822,6 @@ app.state.config.FILE_IMAGE_COMPRESSION_HEIGHT = FILE_IMAGE_COMPRESSION_HEIGHT
 app.state.config.RAG_FULL_CONTEXT = RAG_FULL_CONTEXT
 app.state.config.BYPASS_EMBEDDING_AND_RETRIEVAL = BYPASS_EMBEDDING_AND_RETRIEVAL
 app.state.config.ENABLE_RAG_HYBRID_SEARCH = ENABLE_RAG_HYBRID_SEARCH
-app.state.config.ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS = (
-    ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS
-)
 app.state.config.ENABLE_WEB_LOADER_SSL_VERIFICATION = ENABLE_WEB_LOADER_SSL_VERIFICATION
 
 app.state.config.CONTENT_EXTRACTION_ENGINE = CONTENT_EXTRACTION_ENGINE
@@ -868,12 +842,20 @@ app.state.config.EXTERNAL_DOCUMENT_LOADER_URL = EXTERNAL_DOCUMENT_LOADER_URL
 app.state.config.EXTERNAL_DOCUMENT_LOADER_API_KEY = EXTERNAL_DOCUMENT_LOADER_API_KEY
 app.state.config.TIKA_SERVER_URL = TIKA_SERVER_URL
 app.state.config.DOCLING_SERVER_URL = DOCLING_SERVER_URL
-app.state.config.DOCLING_API_KEY = DOCLING_API_KEY
 app.state.config.DOCLING_PARAMS = DOCLING_PARAMS
+app.state.config.DOCLING_DO_OCR = DOCLING_DO_OCR
+app.state.config.DOCLING_FORCE_OCR = DOCLING_FORCE_OCR
+app.state.config.DOCLING_OCR_ENGINE = DOCLING_OCR_ENGINE
+app.state.config.DOCLING_OCR_LANG = DOCLING_OCR_LANG
+app.state.config.DOCLING_PDF_BACKEND = DOCLING_PDF_BACKEND
+app.state.config.DOCLING_TABLE_MODE = DOCLING_TABLE_MODE
+app.state.config.DOCLING_PIPELINE = DOCLING_PIPELINE
+app.state.config.DOCLING_DO_PICTURE_DESCRIPTION = DOCLING_DO_PICTURE_DESCRIPTION
+app.state.config.DOCLING_PICTURE_DESCRIPTION_MODE = DOCLING_PICTURE_DESCRIPTION_MODE
+app.state.config.DOCLING_PICTURE_DESCRIPTION_LOCAL = DOCLING_PICTURE_DESCRIPTION_LOCAL
+app.state.config.DOCLING_PICTURE_DESCRIPTION_API = DOCLING_PICTURE_DESCRIPTION_API
 app.state.config.DOCUMENT_INTELLIGENCE_ENDPOINT = DOCUMENT_INTELLIGENCE_ENDPOINT
 app.state.config.DOCUMENT_INTELLIGENCE_KEY = DOCUMENT_INTELLIGENCE_KEY
-app.state.config.DOCUMENT_INTELLIGENCE_MODEL = DOCUMENT_INTELLIGENCE_MODEL
-app.state.config.MISTRAL_OCR_API_BASE_URL = MISTRAL_OCR_API_BASE_URL
 app.state.config.MISTRAL_OCR_API_KEY = MISTRAL_OCR_API_KEY
 app.state.config.MINERU_API_MODE = MINERU_API_MODE
 app.state.config.MINERU_API_URL = MINERU_API_URL
@@ -889,7 +871,6 @@ app.state.config.CHUNK_OVERLAP = CHUNK_OVERLAP
 app.state.config.RAG_EMBEDDING_ENGINE = RAG_EMBEDDING_ENGINE
 app.state.config.RAG_EMBEDDING_MODEL = RAG_EMBEDDING_MODEL
 app.state.config.RAG_EMBEDDING_BATCH_SIZE = RAG_EMBEDDING_BATCH_SIZE
-app.state.config.ENABLE_ASYNC_EMBEDDING = ENABLE_ASYNC_EMBEDDING
 
 app.state.config.RAG_RERANKING_ENGINE = RAG_RERANKING_ENGINE
 app.state.config.RAG_RERANKING_MODEL = RAG_RERANKING_MODEL
@@ -959,7 +940,6 @@ app.state.config.EXA_API_KEY = EXA_API_KEY
 app.state.config.PERPLEXITY_API_KEY = PERPLEXITY_API_KEY
 app.state.config.PERPLEXITY_MODEL = PERPLEXITY_MODEL
 app.state.config.PERPLEXITY_SEARCH_CONTEXT_USAGE = PERPLEXITY_SEARCH_CONTEXT_USAGE
-app.state.config.PERPLEXITY_SEARCH_API_URL = PERPLEXITY_SEARCH_API_URL
 app.state.config.SOUGOU_API_SID = SOUGOU_API_SID
 app.state.config.SOUGOU_API_SK = SOUGOU_API_SK
 app.state.config.EXTERNAL_WEB_SEARCH_URL = EXTERNAL_WEB_SEARCH_URL
@@ -984,7 +964,9 @@ app.state.YOUTUBE_LOADER_TRANSLATION = None
 
 try:
     app.state.ef = get_ef(
-        app.state.config.RAG_EMBEDDING_ENGINE, app.state.config.RAG_EMBEDDING_MODEL
+        app.state.config.RAG_EMBEDDING_ENGINE,
+        app.state.config.RAG_EMBEDDING_MODEL,
+        RAG_EMBEDDING_MODEL_AUTO_UPDATE,
     )
     if (
         app.state.config.ENABLE_RAG_HYBRID_SEARCH
@@ -995,6 +977,7 @@ try:
             app.state.config.RAG_RERANKING_MODEL,
             app.state.config.RAG_EXTERNAL_RERANKER_URL,
             app.state.config.RAG_EXTERNAL_RERANKER_API_KEY,
+            RAG_RERANKING_MODEL_AUTO_UPDATE,
         )
     else:
         app.state.rf = None
@@ -1079,42 +1062,27 @@ app.state.config.IMAGE_GENERATION_ENGINE = IMAGE_GENERATION_ENGINE
 app.state.config.ENABLE_IMAGE_GENERATION = ENABLE_IMAGE_GENERATION
 app.state.config.ENABLE_IMAGE_PROMPT_GENERATION = ENABLE_IMAGE_PROMPT_GENERATION
 
-app.state.config.IMAGE_GENERATION_MODEL = IMAGE_GENERATION_MODEL
-app.state.config.IMAGE_SIZE = IMAGE_SIZE
-app.state.config.IMAGE_STEPS = IMAGE_STEPS
-
 app.state.config.IMAGES_OPENAI_API_BASE_URL = IMAGES_OPENAI_API_BASE_URL
 app.state.config.IMAGES_OPENAI_API_VERSION = IMAGES_OPENAI_API_VERSION
 app.state.config.IMAGES_OPENAI_API_KEY = IMAGES_OPENAI_API_KEY
-app.state.config.IMAGES_OPENAI_API_PARAMS = IMAGES_OPENAI_API_PARAMS
 
 app.state.config.IMAGES_GEMINI_API_BASE_URL = IMAGES_GEMINI_API_BASE_URL
 app.state.config.IMAGES_GEMINI_API_KEY = IMAGES_GEMINI_API_KEY
-app.state.config.IMAGES_GEMINI_ENDPOINT_METHOD = IMAGES_GEMINI_ENDPOINT_METHOD
+
+app.state.config.IMAGE_GENERATION_MODEL = IMAGE_GENERATION_MODEL
 
 app.state.config.AUTOMATIC1111_BASE_URL = AUTOMATIC1111_BASE_URL
 app.state.config.AUTOMATIC1111_API_AUTH = AUTOMATIC1111_API_AUTH
-app.state.config.AUTOMATIC1111_PARAMS = AUTOMATIC1111_PARAMS
-
+app.state.config.AUTOMATIC1111_CFG_SCALE = AUTOMATIC1111_CFG_SCALE
+app.state.config.AUTOMATIC1111_SAMPLER = AUTOMATIC1111_SAMPLER
+app.state.config.AUTOMATIC1111_SCHEDULER = AUTOMATIC1111_SCHEDULER
 app.state.config.COMFYUI_BASE_URL = COMFYUI_BASE_URL
 app.state.config.COMFYUI_API_KEY = COMFYUI_API_KEY
 app.state.config.COMFYUI_WORKFLOW = COMFYUI_WORKFLOW
 app.state.config.COMFYUI_WORKFLOW_NODES = COMFYUI_WORKFLOW_NODES
 
-
-app.state.config.ENABLE_IMAGE_EDIT = ENABLE_IMAGE_EDIT
-app.state.config.IMAGE_EDIT_ENGINE = IMAGE_EDIT_ENGINE
-app.state.config.IMAGE_EDIT_MODEL = IMAGE_EDIT_MODEL
-app.state.config.IMAGE_EDIT_SIZE = IMAGE_EDIT_SIZE
-app.state.config.IMAGES_EDIT_OPENAI_API_BASE_URL = IMAGES_EDIT_OPENAI_API_BASE_URL
-app.state.config.IMAGES_EDIT_OPENAI_API_KEY = IMAGES_EDIT_OPENAI_API_KEY
-app.state.config.IMAGES_EDIT_OPENAI_API_VERSION = IMAGES_EDIT_OPENAI_API_VERSION
-app.state.config.IMAGES_EDIT_GEMINI_API_BASE_URL = IMAGES_EDIT_GEMINI_API_BASE_URL
-app.state.config.IMAGES_EDIT_GEMINI_API_KEY = IMAGES_EDIT_GEMINI_API_KEY
-app.state.config.IMAGES_EDIT_COMFYUI_BASE_URL = IMAGES_EDIT_COMFYUI_BASE_URL
-app.state.config.IMAGES_EDIT_COMFYUI_API_KEY = IMAGES_EDIT_COMFYUI_API_KEY
-app.state.config.IMAGES_EDIT_COMFYUI_WORKFLOW = IMAGES_EDIT_COMFYUI_WORKFLOW
-app.state.config.IMAGES_EDIT_COMFYUI_WORKFLOW_NODES = IMAGES_EDIT_COMFYUI_WORKFLOW_NODES
+app.state.config.IMAGE_SIZE = IMAGE_SIZE
+app.state.config.IMAGE_STEPS = IMAGE_STEPS
 
 
 ########################################
@@ -1140,12 +1108,6 @@ app.state.config.AUDIO_STT_AZURE_LOCALES = AUDIO_STT_AZURE_LOCALES
 app.state.config.AUDIO_STT_AZURE_BASE_URL = AUDIO_STT_AZURE_BASE_URL
 app.state.config.AUDIO_STT_AZURE_MAX_SPEAKERS = AUDIO_STT_AZURE_MAX_SPEAKERS
 
-app.state.config.AUDIO_STT_MISTRAL_API_KEY = AUDIO_STT_MISTRAL_API_KEY
-app.state.config.AUDIO_STT_MISTRAL_API_BASE_URL = AUDIO_STT_MISTRAL_API_BASE_URL
-app.state.config.AUDIO_STT_MISTRAL_USE_CHAT_COMPLETIONS = (
-    AUDIO_STT_MISTRAL_USE_CHAT_COMPLETIONS
-)
-
 app.state.config.TTS_ENGINE = AUDIO_TTS_ENGINE
 
 app.state.config.TTS_MODEL = AUDIO_TTS_MODEL
@@ -1207,7 +1169,6 @@ app.state.config.AUTOCOMPLETE_GENERATION_PROMPT_TEMPLATE = (
 app.state.config.AUTOCOMPLETE_GENERATION_INPUT_MAX_LENGTH = (
     AUTOCOMPLETE_GENERATION_INPUT_MAX_LENGTH
 )
-app.state.config.VOICE_MODE_PROMPT_TEMPLATE = VOICE_MODE_PROMPT_TEMPLATE
 
 
 ########################################
@@ -1216,11 +1177,7 @@ app.state.config.VOICE_MODE_PROMPT_TEMPLATE = VOICE_MODE_PROMPT_TEMPLATE
 #
 ########################################
 
-app.state.MODELS = MODELS
-
-# Add the middleware to the app
-if ENABLE_COMPRESSION_MIDDLEWARE:
-    app.add_middleware(CompressMiddleware)
+app.state.MODELS = {}
 
 
 class RedirectMiddleware(BaseHTTPMiddleware):
@@ -1263,53 +1220,14 @@ class RedirectMiddleware(BaseHTTPMiddleware):
         return response
 
 
+# Add the middleware to the app
+if ENABLE_COMPRESSION_MIDDLEWARE:
+    app.add_middleware(CompressMiddleware)
+
 app.add_middleware(RedirectMiddleware)
 app.add_middleware(SecurityHeadersMiddleware)
 
 
-class APIKeyRestrictionMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next):
-        auth_header = request.headers.get("Authorization")
-        token = None
-
-        if auth_header:
-            scheme, token = auth_header.split(" ")
-
-        # Only apply restrictions if an sk- API key is used
-        if token and token.startswith("sk-"):
-            # Check if restrictions are enabled
-            if request.app.state.config.ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS:
-                allowed_paths = [
-                    path.strip()
-                    for path in str(
-                        request.app.state.config.API_KEYS_ALLOWED_ENDPOINTS
-                    ).split(",")
-                    if path.strip()
-                ]
-
-                request_path = request.url.path
-
-                # Match exact path or prefix path
-                is_allowed = any(
-                    request_path == allowed or request_path.startswith(allowed + "/")
-                    for allowed in allowed_paths
-                )
-
-                if not is_allowed:
-                    return JSONResponse(
-                        status_code=status.HTTP_403_FORBIDDEN,
-                        content={
-                            "detail": "API key not allowed to access this endpoint."
-                        },
-                    )
-
-        response = await call_next(request)
-        return response
-
-
-app.add_middleware(APIKeyRestrictionMiddleware)
-
-
 @app.middleware("http")
 async def commit_session_after_request(request: Request, call_next):
     response = await call_next(request)
@@ -1325,7 +1243,7 @@ async def check_url(request: Request, call_next):
         request.headers.get("Authorization")
     )
 
-    request.state.enable_api_keys = app.state.config.ENABLE_API_KEYS
+    request.state.enable_api_key = app.state.config.ENABLE_API_KEY
     response = await call_next(request)
     process_time = int(time.time()) - start_time
     response.headers["X-Process-Time"] = str(process_time)
@@ -1400,7 +1318,7 @@ app.include_router(
 app.include_router(utils.router, prefix="/api/v1/utils", tags=["utils"])
 
 # SCIM 2.0 API for identity management
-if ENABLE_SCIM:
+if SCIM_ENABLED:
     app.include_router(scim.router, prefix="/api/v1/scim/v2", tags=["scim"])
 
 
@@ -1437,10 +1355,6 @@ async def get_models(
         if "pipeline" in model and model["pipeline"].get("type", None) == "filter":
             continue
 
-        # Remove profile image URL to reduce payload size
-        if model.get("info", {}).get("meta", {}).get("profile_image_url"):
-            model["info"]["meta"].pop("profile_image_url", None)
-
         try:
             model_tags = [
                 tag.get("name")
@@ -1563,9 +1477,6 @@ async def chat_completion(
         reasoning_tags = form_data.get("params", {}).get("reasoning_tags")
 
         # Model Params
-        if model_info_params.get("stream_response") is not None:
-            form_data["stream"] = model_info_params.get("stream_response")
-
         if model_info_params.get("stream_delta_chunk_size"):
             stream_delta_chunk_size = model_info_params.get("stream_delta_chunk_size")
 
@@ -1576,7 +1487,6 @@ async def chat_completion(
             "user_id": user.id,
             "chat_id": form_data.pop("chat_id", None),
             "message_id": form_data.pop("id", None),
-            "parent_message_id": form_data.pop("parent_id", None),
             "session_id": form_data.pop("session_id", None),
             "filter_ids": form_data.pop("filter_ids", []),
             "tool_ids": form_data.get("tool_ids", None),
@@ -1633,7 +1543,6 @@ async def chat_completion(
                             metadata["chat_id"],
                             metadata["message_id"],
                             {
-                                "parentId": metadata.get("parent_message_id", None),
                                 "model": model_id,
                             },
                         )
@@ -1647,15 +1556,11 @@ async def chat_completion(
             log.info("Chat processing was cancelled")
             try:
                 event_emitter = get_event_emitter(metadata)
-                await asyncio.shield(
-                    event_emitter(
-                        {"type": "chat:tasks:cancel"},
-                    )
+                await event_emitter(
+                    {"type": "chat:tasks:cancel"},
                 )
             except Exception as e:
                 pass
-            finally:
-                raise  # re-raise to ensure proper task cancellation handling
         except Exception as e:
             log.debug(f"Error processing chat payload: {e}")
             if metadata.get("chat_id") and metadata.get("message_id"):
@@ -1666,7 +1571,6 @@ async def chat_completion(
                             metadata["chat_id"],
                             metadata["message_id"],
                             {
-                                "parentId": metadata.get("parent_message_id", None),
                                 "error": {"content": str(e)},
                             },
                         )
@@ -1687,7 +1591,7 @@ async def chat_completion(
         finally:
             try:
                 if mcp_clients := metadata.get("mcp_clients"):
-                    for client in reversed(mcp_clients.values()):
+                    for client in mcp_clients.values():
                         await client.disconnect()
             except Exception as e:
                 log.debug(f"Error cleaning up: {e}")
@@ -1838,7 +1742,7 @@ async def get_app_config(request: Request):
             "auth_trusted_header": bool(app.state.AUTH_TRUSTED_EMAIL_HEADER),
             "enable_signup_password_confirmation": ENABLE_SIGNUP_PASSWORD_CONFIRMATION,
             "enable_ldap": app.state.config.ENABLE_LDAP,
-            "enable_api_keys": app.state.config.ENABLE_API_KEYS,
+            "enable_api_key": app.state.config.ENABLE_API_KEY,
             "enable_signup": app.state.config.ENABLE_SIGNUP,
             "enable_login_form": app.state.config.ENABLE_LOGIN_FORM,
             "enable_websocket": ENABLE_WEBSOCKET_SUPPORT,
@@ -1846,7 +1750,6 @@ async def get_app_config(request: Request):
             **(
                 {
                     "enable_direct_connections": app.state.config.ENABLE_DIRECT_CONNECTIONS,
-                    "enable_folders": app.state.config.ENABLE_FOLDERS,
                     "enable_channels": app.state.config.ENABLE_CHANNELS,
                     "enable_notes": app.state.config.ENABLE_NOTES,
                     "enable_web_search": app.state.config.ENABLE_WEB_SEARCH,
@@ -1877,7 +1780,6 @@ async def get_app_config(request: Request):
         **(
             {
                 "default_models": app.state.config.DEFAULT_MODELS,
-                "default_pinned_models": app.state.config.DEFAULT_PINNED_MODELS,
                 "default_prompt_suggestions": app.state.config.DEFAULT_PROMPT_SUGGESTIONS,
                 "user_count": user_count,
                 "code": {
@@ -1979,7 +1881,6 @@ async def update_webhook_url(form_data: UrlForm, user=Depends(get_admin_user)):
 async def get_app_version():
     return {
         "version": VERSION,
-        "deployment_id": DEPLOYMENT_ID,
     }
 
 
@@ -2019,10 +1920,7 @@ async def get_current_usage(user=Depends(get_verified_user)):
     This is an experimental endpoint and subject to change.
     """
     try:
-        return {
-            "model_ids": get_models_in_use(),
-            "user_count": Users.get_active_user_count(),
-        }
+        return {"model_ids": get_models_in_use(), "user_ids": get_active_user_ids()}
     except Exception as e:
         log.error(f"Error getting usage statistics: {e}")
         raise HTTPException(status_code=500, detail="Internal Server Error")
@@ -2039,7 +1937,6 @@ if len(app.state.config.TOOL_SERVER_CONNECTIONS) > 0:
         if tool_server_connection.get("type", "openapi") == "mcp":
             server_id = tool_server_connection.get("info", {}).get("id")
             auth_type = tool_server_connection.get("auth_type", "none")
-
             if server_id and auth_type == "oauth_2.1":
                 oauth_client_info = tool_server_connection.get("info", {}).get(
                     "oauth_client_info", ""
@@ -2085,64 +1982,6 @@ except Exception as e:
     )
 
 
-async def register_client(request, client_id: str) -> bool:
-    server_type, server_id = client_id.split(":", 1)
-
-    connection = None
-    connection_idx = None
-
-    for idx, conn in enumerate(request.app.state.config.TOOL_SERVER_CONNECTIONS or []):
-        if conn.get("type", "openapi") == server_type:
-            info = conn.get("info", {})
-            if info.get("id") == server_id:
-                connection = conn
-                connection_idx = idx
-                break
-
-    if connection is None or connection_idx is None:
-        log.warning(
-            f"Unable to locate MCP tool server configuration for client {client_id} during re-registration"
-        )
-        return False
-
-    server_url = connection.get("url")
-    oauth_server_key = (connection.get("config") or {}).get("oauth_server_key")
-
-    try:
-        oauth_client_info = (
-            await get_oauth_client_info_with_dynamic_client_registration(
-                request,
-                client_id,
-                server_url,
-                oauth_server_key,
-            )
-        )
-    except Exception as e:
-        log.error(f"Dynamic client re-registration failed for {client_id}: {e}")
-        return False
-
-    try:
-        request.app.state.config.TOOL_SERVER_CONNECTIONS[connection_idx] = {
-            **connection,
-            "info": {
-                **connection.get("info", {}),
-                "oauth_client_info": encrypt_data(
-                    oauth_client_info.model_dump(mode="json")
-                ),
-            },
-        }
-    except Exception as e:
-        log.error(
-            f"Failed to persist updated OAuth client info for tool server {client_id}: {e}"
-        )
-        return False
-
-    oauth_client_manager.remove_client(client_id)
-    oauth_client_manager.add_client(client_id, oauth_client_info)
-    log.info(f"Re-registered OAuth client {client_id} for tool server")
-    return True
-
-
 @app.get("/oauth/clients/{client_id}/authorize")
 async def oauth_client_authorize(
     client_id: str,
@@ -2150,41 +1989,6 @@ async def oauth_client_authorize(
     response: Response,
     user=Depends(get_verified_user),
 ):
-    # ensure_valid_client_registration
-    client = oauth_client_manager.get_client(client_id)
-    client_info = oauth_client_manager.get_client_info(client_id)
-    if client is None or client_info is None:
-        raise HTTPException(status.HTTP_404_NOT_FOUND)
-
-    if not await oauth_client_manager._preflight_authorization_url(client, client_info):
-        log.info(
-            "Detected invalid OAuth client %s; attempting re-registration",
-            client_id,
-        )
-
-        registered = await register_client(request, client_id)
-        if not registered:
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="Failed to re-register OAuth client",
-            )
-
-        client = oauth_client_manager.get_client(client_id)
-        client_info = oauth_client_manager.get_client_info(client_id)
-        if client is None or client_info is None:
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="OAuth client unavailable after re-registration",
-            )
-
-        if not await oauth_client_manager._preflight_authorization_url(
-            client, client_info
-        ):
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="OAuth client registration is still invalid after re-registration",
-            )
-
     return await oauth_client_manager.handle_authorize(request, client_id=client_id)
 
 

backend/open_webui/migrations/versions/2f1211949ecc_update_message_and_channel_member_table.py

@@ -1,103 +0,0 @@
-"""Update messages and channel member table
-
-Revision ID: 2f1211949ecc
-Revises: 37f288994c47
-Create Date: 2025-11-27 03:07:56.200231
-
-"""
-
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-import open_webui.internal.db
-
-
-# revision identifiers, used by Alembic.
-revision: str = "2f1211949ecc"
-down_revision: Union[str, None] = "37f288994c47"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # New columns to be added to channel_member table
-    op.add_column("channel_member", sa.Column("status", sa.Text(), nullable=True))
-    op.add_column(
-        "channel_member",
-        sa.Column(
-            "is_active",
-            sa.Boolean(),
-            nullable=False,
-            default=True,
-            server_default=sa.sql.expression.true(),
-        ),
-    )
-
-    op.add_column(
-        "channel_member",
-        sa.Column(
-            "is_channel_muted",
-            sa.Boolean(),
-            nullable=False,
-            default=False,
-            server_default=sa.sql.expression.false(),
-        ),
-    )
-    op.add_column(
-        "channel_member",
-        sa.Column(
-            "is_channel_pinned",
-            sa.Boolean(),
-            nullable=False,
-            default=False,
-            server_default=sa.sql.expression.false(),
-        ),
-    )
-
-    op.add_column("channel_member", sa.Column("data", sa.JSON(), nullable=True))
-    op.add_column("channel_member", sa.Column("meta", sa.JSON(), nullable=True))
-
-    op.add_column(
-        "channel_member", sa.Column("joined_at", sa.BigInteger(), nullable=False)
-    )
-    op.add_column(
-        "channel_member", sa.Column("left_at", sa.BigInteger(), nullable=True)
-    )
-
-    op.add_column(
-        "channel_member", sa.Column("last_read_at", sa.BigInteger(), nullable=True)
-    )
-
-    op.add_column(
-        "channel_member", sa.Column("updated_at", sa.BigInteger(), nullable=True)
-    )
-
-    # New columns to be added to message table
-    op.add_column(
-        "message",
-        sa.Column(
-            "is_pinned",
-            sa.Boolean(),
-            nullable=False,
-            default=False,
-            server_default=sa.sql.expression.false(),
-        ),
-    )
-    op.add_column("message", sa.Column("pinned_at", sa.BigInteger(), nullable=True))
-    op.add_column("message", sa.Column("pinned_by", sa.Text(), nullable=True))
-
-
-def downgrade() -> None:
-    op.drop_column("channel_member", "updated_at")
-    op.drop_column("channel_member", "last_read_at")
-
-    op.drop_column("channel_member", "meta")
-    op.drop_column("channel_member", "data")
-
-    op.drop_column("channel_member", "is_channel_pinned")
-    op.drop_column("channel_member", "is_channel_muted")
-
-    op.drop_column("message", "pinned_by")
-    op.drop_column("message", "pinned_at")
-    op.drop_column("message", "is_pinned")

backend/open_webui/migrations/versions/37f288994c47_add_group_member_table.py

@@ -1,146 +0,0 @@
-"""add_group_member_table
-
-Revision ID: 37f288994c47
-Revises: a5c220713937
-Create Date: 2025-11-17 03:45:25.123939
-
-"""
-
-import uuid
-import time
-import json
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = "37f288994c47"
-down_revision: Union[str, None] = "a5c220713937"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # 1. Create new table
-    op.create_table(
-        "group_member",
-        sa.Column("id", sa.Text(), primary_key=True, unique=True, nullable=False),
-        sa.Column(
-            "group_id",
-            sa.Text(),
-            sa.ForeignKey("group.id", ondelete="CASCADE"),
-            nullable=False,
-        ),
-        sa.Column(
-            "user_id",
-            sa.Text(),
-            sa.ForeignKey("user.id", ondelete="CASCADE"),
-            nullable=False,
-        ),
-        sa.Column("created_at", sa.BigInteger(), nullable=True),
-        sa.Column("updated_at", sa.BigInteger(), nullable=True),
-        sa.UniqueConstraint("group_id", "user_id", name="uq_group_member_group_user"),
-    )
-
-    connection = op.get_bind()
-
-    # 2. Read existing group with user_ids JSON column
-    group_table = sa.Table(
-        "group",
-        sa.MetaData(),
-        sa.Column("id", sa.Text()),
-        sa.Column("user_ids", sa.JSON()),  # JSON stored as text in SQLite + PG
-    )
-
-    results = connection.execute(
-        sa.select(group_table.c.id, group_table.c.user_ids)
-    ).fetchall()
-
-    print(results)
-
-    # 3. Insert members into group_member table
-    gm_table = sa.Table(
-        "group_member",
-        sa.MetaData(),
-        sa.Column("id", sa.Text()),
-        sa.Column("group_id", sa.Text()),
-        sa.Column("user_id", sa.Text()),
-        sa.Column("created_at", sa.BigInteger()),
-        sa.Column("updated_at", sa.BigInteger()),
-    )
-
-    now = int(time.time())
-    for group_id, user_ids in results:
-        if not user_ids:
-            continue
-
-        if isinstance(user_ids, str):
-            try:
-                user_ids = json.loads(user_ids)
-            except Exception:
-                continue  # skip invalid JSON
-
-        if not isinstance(user_ids, list):
-            continue
-
-        rows = [
-            {
-                "id": str(uuid.uuid4()),
-                "group_id": group_id,
-                "user_id": uid,
-                "created_at": now,
-                "updated_at": now,
-            }
-            for uid in user_ids
-        ]
-
-        if rows:
-            connection.execute(gm_table.insert(), rows)
-
-    # 4. Optionally drop the old column
-    with op.batch_alter_table("group") as batch:
-        batch.drop_column("user_ids")
-
-
-def downgrade():
-    # Reverse: restore user_ids column
-    with op.batch_alter_table("group") as batch:
-        batch.add_column(sa.Column("user_ids", sa.JSON()))
-
-    connection = op.get_bind()
-    gm_table = sa.Table(
-        "group_member",
-        sa.MetaData(),
-        sa.Column("group_id", sa.Text()),
-        sa.Column("user_id", sa.Text()),
-        sa.Column("created_at", sa.BigInteger()),
-        sa.Column("updated_at", sa.BigInteger()),
-    )
-
-    group_table = sa.Table(
-        "group",
-        sa.MetaData(),
-        sa.Column("id", sa.Text()),
-        sa.Column("user_ids", sa.JSON()),
-    )
-
-    # Build JSON arrays again
-    results = connection.execute(sa.select(group_table.c.id)).fetchall()
-
-    for (group_id,) in results:
-        members = connection.execute(
-            sa.select(gm_table.c.user_id).where(gm_table.c.group_id == group_id)
-        ).fetchall()
-
-        member_ids = [m[0] for m in members]
-
-        connection.execute(
-            group_table.update()
-            .where(group_table.c.id == group_id)
-            .values(user_ids=member_ids)
-        )
-
-    # Drop the new table
-    op.drop_table("group_member")

backend/open_webui/migrations/versions/38d63c18f30f_add_oauth_session_table.py

@@ -20,46 +20,18 @@ depends_on: Union[str, Sequence[str], None] = None
 
 
 def upgrade() -> None:
-    # Ensure 'id' column in 'user' table is unique and primary key (ForeignKey constraint)
-    inspector = sa.inspect(op.get_bind())
-    columns = inspector.get_columns("user")
-
-    pk_columns = inspector.get_pk_constraint("user")["constrained_columns"]
-    id_column = next((col for col in columns if col["name"] == "id"), None)
-
-    if id_column and not id_column.get("unique", False):
-        unique_constraints = inspector.get_unique_constraints("user")
-        unique_columns = {tuple(u["column_names"]) for u in unique_constraints}
-
-        with op.batch_alter_table("user") as batch_op:
-            # If primary key is wrong, drop it
-            if pk_columns and pk_columns != ["id"]:
-                batch_op.drop_constraint(
-                    inspector.get_pk_constraint("user")["name"], type_="primary"
-                )
-
-            # Add unique constraint if missing
-            if ("id",) not in unique_columns:
-                batch_op.create_unique_constraint("uq_user_id", ["id"])
-
-            # Re-create correct primary key
-            batch_op.create_primary_key("pk_user_id", ["id"])
-
     # Create oauth_session table
     op.create_table(
         "oauth_session",
-        sa.Column("id", sa.Text(), primary_key=True, nullable=False, unique=True),
-        sa.Column(
-            "user_id",
-            sa.Text(),
-            sa.ForeignKey("user.id", ondelete="CASCADE"),
-            nullable=False,
-        ),
+        sa.Column("id", sa.Text(), nullable=False),
+        sa.Column("user_id", sa.Text(), nullable=False),
         sa.Column("provider", sa.Text(), nullable=False),
         sa.Column("token", sa.Text(), nullable=False),
         sa.Column("expires_at", sa.BigInteger(), nullable=False),
         sa.Column("created_at", sa.BigInteger(), nullable=False),
         sa.Column("updated_at", sa.BigInteger(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+        sa.ForeignKeyConstraint(["user_id"], ["user.id"], ondelete="CASCADE"),
     )
 
     # Create indexes for better performance

backend/open_webui/migrations/versions/3e0e00844bb0_add_knowledge_file_table.py

@@ -1,169 +0,0 @@
-"""Add knowledge_file table
-
-Revision ID: 3e0e00844bb0
-Revises: 90ef40d4714e
-Create Date: 2025-12-02 06:54:19.401334
-
-"""
-
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy import inspect
-import open_webui.internal.db
-
-import time
-import json
-import uuid
-
-# revision identifiers, used by Alembic.
-revision: str = "3e0e00844bb0"
-down_revision: Union[str, None] = "90ef40d4714e"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    op.create_table(
-        "knowledge_file",
-        sa.Column("id", sa.Text(), primary_key=True),
-        sa.Column("user_id", sa.Text(), nullable=False),
-        sa.Column(
-            "knowledge_id",
-            sa.Text(),
-            sa.ForeignKey("knowledge.id", ondelete="CASCADE"),
-            nullable=False,
-        ),
-        sa.Column(
-            "file_id",
-            sa.Text(),
-            sa.ForeignKey("file.id", ondelete="CASCADE"),
-            nullable=False,
-        ),
-        sa.Column("created_at", sa.BigInteger(), nullable=False),
-        sa.Column("updated_at", sa.BigInteger(), nullable=False),
-        # indexes
-        sa.Index("ix_knowledge_file_knowledge_id", "knowledge_id"),
-        sa.Index("ix_knowledge_file_file_id", "file_id"),
-        sa.Index("ix_knowledge_file_user_id", "user_id"),
-        # unique constraints
-        sa.UniqueConstraint(
-            "knowledge_id", "file_id", name="uq_knowledge_file_knowledge_file"
-        ),  # prevent duplicate entries
-    )
-
-    connection = op.get_bind()
-
-    # 2. Read existing group with user_ids JSON column
-    knowledge_table = sa.Table(
-        "knowledge",
-        sa.MetaData(),
-        sa.Column("id", sa.Text()),
-        sa.Column("user_id", sa.Text()),
-        sa.Column("data", sa.JSON()),  # JSON stored as text in SQLite + PG
-    )
-
-    results = connection.execute(
-        sa.select(
-            knowledge_table.c.id, knowledge_table.c.user_id, knowledge_table.c.data
-        )
-    ).fetchall()
-
-    # 3. Insert members into group_member table
-    kf_table = sa.Table(
-        "knowledge_file",
-        sa.MetaData(),
-        sa.Column("id", sa.Text()),
-        sa.Column("user_id", sa.Text()),
-        sa.Column("knowledge_id", sa.Text()),
-        sa.Column("file_id", sa.Text()),
-        sa.Column("created_at", sa.BigInteger()),
-        sa.Column("updated_at", sa.BigInteger()),
-    )
-
-    file_table = sa.Table(
-        "file",
-        sa.MetaData(),
-        sa.Column("id", sa.Text()),
-    )
-
-    now = int(time.time())
-    for knowledge_id, user_id, data in results:
-        if not data:
-            continue
-
-        if isinstance(data, str):
-            try:
-                data = json.loads(data)
-            except Exception:
-                continue  # skip invalid JSON
-
-        if not isinstance(data, dict):
-            continue
-
-        file_ids = data.get("file_ids", [])
-
-        for file_id in file_ids:
-            file_exists = connection.execute(
-                sa.select(file_table.c.id).where(file_table.c.id == file_id)
-            ).fetchone()
-
-            if not file_exists:
-                continue  # skip non-existing files
-
-            row = {
-                "id": str(uuid.uuid4()),
-                "user_id": user_id,
-                "knowledge_id": knowledge_id,
-                "file_id": file_id,
-                "created_at": now,
-                "updated_at": now,
-            }
-            connection.execute(kf_table.insert().values(**row))
-
-    with op.batch_alter_table("knowledge") as batch:
-        batch.drop_column("data")
-
-
-def downgrade() -> None:
-    # 1. Add back the old data column
-    op.add_column("knowledge", sa.Column("data", sa.JSON(), nullable=True))
-
-    connection = op.get_bind()
-
-    # 2. Read knowledge_file entries and reconstruct data JSON
-    knowledge_table = sa.Table(
-        "knowledge",
-        sa.MetaData(),
-        sa.Column("id", sa.Text()),
-        sa.Column("data", sa.JSON()),
-    )
-
-    kf_table = sa.Table(
-        "knowledge_file",
-        sa.MetaData(),
-        sa.Column("id", sa.Text()),
-        sa.Column("knowledge_id", sa.Text()),
-        sa.Column("file_id", sa.Text()),
-    )
-
-    results = connection.execute(sa.select(knowledge_table.c.id)).fetchall()
-
-    for (knowledge_id,) in results:
-        file_ids = connection.execute(
-            sa.select(kf_table.c.file_id).where(kf_table.c.knowledge_id == knowledge_id)
-        ).fetchall()
-
-        file_ids_list = [fid for (fid,) in file_ids]
-
-        data_json = {"file_ids": file_ids_list}
-
-        connection.execute(
-            knowledge_table.update()
-            .where(knowledge_table.c.id == knowledge_id)
-            .values(data=data_json)
-        )
-
-    # 3. Drop the knowledge_file table
-    op.drop_table("knowledge_file")

backend/open_webui/migrations/versions/90ef40d4714e_update_channel_and_channel_members_table.py

@@ -1,81 +0,0 @@
-"""Update channel and channel members table
-
-Revision ID: 90ef40d4714e
-Revises: b10670c03dd5
-Create Date: 2025-11-30 06:33:38.790341
-
-"""
-
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-import open_webui.internal.db
-
-
-# revision identifiers, used by Alembic.
-revision: str = "90ef40d4714e"
-down_revision: Union[str, None] = "b10670c03dd5"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # Update 'channel' table
-    op.add_column("channel", sa.Column("is_private", sa.Boolean(), nullable=True))
-
-    op.add_column("channel", sa.Column("archived_at", sa.BigInteger(), nullable=True))
-    op.add_column("channel", sa.Column("archived_by", sa.Text(), nullable=True))
-
-    op.add_column("channel", sa.Column("deleted_at", sa.BigInteger(), nullable=True))
-    op.add_column("channel", sa.Column("deleted_by", sa.Text(), nullable=True))
-
-    op.add_column("channel", sa.Column("updated_by", sa.Text(), nullable=True))
-
-    # Update 'channel_member' table
-    op.add_column("channel_member", sa.Column("role", sa.Text(), nullable=True))
-    op.add_column("channel_member", sa.Column("invited_by", sa.Text(), nullable=True))
-    op.add_column(
-        "channel_member", sa.Column("invited_at", sa.BigInteger(), nullable=True)
-    )
-
-    #  Create 'channel_webhook' table
-    op.create_table(
-        "channel_webhook",
-        sa.Column("id", sa.Text(), primary_key=True, unique=True, nullable=False),
-        sa.Column("user_id", sa.Text(), nullable=False),
-        sa.Column(
-            "channel_id",
-            sa.Text(),
-            sa.ForeignKey("channel.id", ondelete="CASCADE"),
-            nullable=False,
-        ),
-        sa.Column("name", sa.Text(), nullable=False),
-        sa.Column("profile_image_url", sa.Text(), nullable=True),
-        sa.Column("token", sa.Text(), nullable=False),
-        sa.Column("last_used_at", sa.BigInteger(), nullable=True),
-        sa.Column("created_at", sa.BigInteger(), nullable=False),
-        sa.Column("updated_at", sa.BigInteger(), nullable=False),
-    )
-
-    pass
-
-
-def downgrade() -> None:
-    # Downgrade 'channel' table
-    op.drop_column("channel", "is_private")
-    op.drop_column("channel", "archived_at")
-    op.drop_column("channel", "archived_by")
-    op.drop_column("channel", "deleted_at")
-    op.drop_column("channel", "deleted_by")
-    op.drop_column("channel", "updated_by")
-
-    # Downgrade 'channel_member' table
-    op.drop_column("channel_member", "role")
-    op.drop_column("channel_member", "invited_by")
-    op.drop_column("channel_member", "invited_at")
-
-    # Drop 'channel_webhook' table
-    op.drop_table("channel_webhook")
-
-    pass

backend/open_webui/migrations/versions/b10670c03dd5_update_user_table.py

@@ -1,251 +0,0 @@
-"""Update user table
-
-Revision ID: b10670c03dd5
-Revises: 2f1211949ecc
-Create Date: 2025-11-28 04:55:31.737538
-
-"""
-
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-import open_webui.internal.db
-import json
-import time
-
-# revision identifiers, used by Alembic.
-revision: str = "b10670c03dd5"
-down_revision: Union[str, None] = "2f1211949ecc"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def _drop_sqlite_indexes_for_column(table_name, column_name, conn):
-    """
-    SQLite requires manual removal of any indexes referencing a column
-    before ALTER TABLE ... DROP COLUMN can succeed.
-    """
-    indexes = conn.execute(sa.text(f"PRAGMA index_list('{table_name}')")).fetchall()
-
-    for idx in indexes:
-        index_name = idx[1]  # index name
-        # Get indexed columns
-        idx_info = conn.execute(
-            sa.text(f"PRAGMA index_info('{index_name}')")
-        ).fetchall()
-
-        indexed_cols = [row[2] for row in idx_info]  # col names
-        if column_name in indexed_cols:
-            conn.execute(sa.text(f"DROP INDEX IF EXISTS {index_name}"))
-
-
-def _convert_column_to_json(table: str, column: str):
-    conn = op.get_bind()
-    dialect = conn.dialect.name
-
-    # SQLite cannot ALTER COLUMN → must recreate column
-    if dialect == "sqlite":
-        # 1. Add temporary column
-        op.add_column(table, sa.Column(f"{column}_json", sa.JSON(), nullable=True))
-
-        # 2. Load old data
-        rows = conn.execute(sa.text(f'SELECT id, {column} FROM "{table}"')).fetchall()
-
-        for row in rows:
-            uid, raw = row
-            if raw is None:
-                parsed = None
-            else:
-                try:
-                    parsed = json.loads(raw)
-                except Exception:
-                    parsed = None  # fallback safe behavior
-
-            conn.execute(
-                sa.text(f'UPDATE "{table}" SET {column}_json = :val WHERE id = :id'),
-                {"val": json.dumps(parsed) if parsed else None, "id": uid},
-            )
-
-        # 3. Drop old TEXT column
-        op.drop_column(table, column)
-
-        # 4. Rename new JSON column → original name
-        op.alter_column(table, f"{column}_json", new_column_name=column)
-
-    else:
-        # PostgreSQL supports direct CAST
-        op.alter_column(
-            table,
-            column,
-            type_=sa.JSON(),
-            postgresql_using=f"{column}::json",
-        )
-
-
-def _convert_column_to_text(table: str, column: str):
-    conn = op.get_bind()
-    dialect = conn.dialect.name
-
-    if dialect == "sqlite":
-        op.add_column(table, sa.Column(f"{column}_text", sa.Text(), nullable=True))
-
-        rows = conn.execute(sa.text(f'SELECT id, {column} FROM "{table}"')).fetchall()
-
-        for uid, raw in rows:
-            conn.execute(
-                sa.text(f'UPDATE "{table}" SET {column}_text = :val WHERE id = :id'),
-                {"val": json.dumps(raw) if raw else None, "id": uid},
-            )
-
-        op.drop_column(table, column)
-        op.alter_column(table, f"{column}_text", new_column_name=column)
-
-    else:
-        op.alter_column(
-            table,
-            column,
-            type_=sa.Text(),
-            postgresql_using=f"to_json({column})::text",
-        )
-
-
-def upgrade() -> None:
-    op.add_column(
-        "user", sa.Column("profile_banner_image_url", sa.Text(), nullable=True)
-    )
-    op.add_column("user", sa.Column("timezone", sa.String(), nullable=True))
-
-    op.add_column("user", sa.Column("presence_state", sa.String(), nullable=True))
-    op.add_column("user", sa.Column("status_emoji", sa.String(), nullable=True))
-    op.add_column("user", sa.Column("status_message", sa.Text(), nullable=True))
-    op.add_column(
-        "user", sa.Column("status_expires_at", sa.BigInteger(), nullable=True)
-    )
-
-    op.add_column("user", sa.Column("oauth", sa.JSON(), nullable=True))
-
-    # Convert info (TEXT/JSONField) → JSON
-    _convert_column_to_json("user", "info")
-    # Convert settings (TEXT/JSONField) → JSON
-    _convert_column_to_json("user", "settings")
-
-    op.create_table(
-        "api_key",
-        sa.Column("id", sa.Text(), primary_key=True, unique=True),
-        sa.Column("user_id", sa.Text(), sa.ForeignKey("user.id", ondelete="CASCADE")),
-        sa.Column("key", sa.Text(), unique=True, nullable=False),
-        sa.Column("data", sa.JSON(), nullable=True),
-        sa.Column("expires_at", sa.BigInteger(), nullable=True),
-        sa.Column("last_used_at", sa.BigInteger(), nullable=True),
-        sa.Column("created_at", sa.BigInteger(), nullable=False),
-        sa.Column("updated_at", sa.BigInteger(), nullable=False),
-    )
-
-    conn = op.get_bind()
-    users = conn.execute(
-        sa.text('SELECT id, oauth_sub FROM "user" WHERE oauth_sub IS NOT NULL')
-    ).fetchall()
-
-    for uid, oauth_sub in users:
-        if oauth_sub:
-            # Example formats supported:
-            #   provider@sub
-            #   plain sub (stored as {"oidc": {"sub": sub}})
-            if "@" in oauth_sub:
-                provider, sub = oauth_sub.split("@", 1)
-            else:
-                provider, sub = "oidc", oauth_sub
-
-            oauth_json = json.dumps({provider: {"sub": sub}})
-            conn.execute(
-                sa.text('UPDATE "user" SET oauth = :oauth WHERE id = :id'),
-                {"oauth": oauth_json, "id": uid},
-            )
-
-    users_with_keys = conn.execute(
-        sa.text('SELECT id, api_key FROM "user" WHERE api_key IS NOT NULL')
-    ).fetchall()
-    now = int(time.time())
-
-    for uid, api_key in users_with_keys:
-        if api_key:
-            conn.execute(
-                sa.text(
-                    """
-                    INSERT INTO api_key (id, user_id, key, created_at, updated_at)
-                    VALUES (:id, :user_id, :key, :created_at, :updated_at)
-                """
-                ),
-                {
-                    "id": f"key_{uid}",
-                    "user_id": uid,
-                    "key": api_key,
-                    "created_at": now,
-                    "updated_at": now,
-                },
-            )
-
-    if conn.dialect.name == "sqlite":
-        _drop_sqlite_indexes_for_column("user", "api_key", conn)
-        _drop_sqlite_indexes_for_column("user", "oauth_sub", conn)
-
-    with op.batch_alter_table("user") as batch_op:
-        batch_op.drop_column("api_key")
-        batch_op.drop_column("oauth_sub")
-
-
-def downgrade() -> None:
-    # --- 1. Restore old oauth_sub column ---
-    op.add_column("user", sa.Column("oauth_sub", sa.Text(), nullable=True))
-
-    conn = op.get_bind()
-    users = conn.execute(
-        sa.text('SELECT id, oauth FROM "user" WHERE oauth IS NOT NULL')
-    ).fetchall()
-
-    for uid, oauth in users:
-        try:
-            data = json.loads(oauth)
-            provider = list(data.keys())[0]
-            sub = data[provider].get("sub")
-            oauth_sub = f"{provider}@{sub}"
-        except Exception:
-            oauth_sub = None
-
-        conn.execute(
-            sa.text('UPDATE "user" SET oauth_sub = :oauth_sub WHERE id = :id'),
-            {"oauth_sub": oauth_sub, "id": uid},
-        )
-
-    op.drop_column("user", "oauth")
-
-    # --- 2. Restore api_key field ---
-    op.add_column("user", sa.Column("api_key", sa.String(), nullable=True))
-
-    # Restore values from api_key
-    keys = conn.execute(sa.text("SELECT user_id, key FROM api_key")).fetchall()
-    for uid, key in keys:
-        conn.execute(
-            sa.text('UPDATE "user" SET api_key = :key WHERE id = :id'),
-            {"key": key, "id": uid},
-        )
-
-    # Drop new table
-    op.drop_table("api_key")
-
-    with op.batch_alter_table("user") as batch_op:
-        batch_op.drop_column("profile_banner_image_url")
-        batch_op.drop_column("timezone")
-
-        batch_op.drop_column("presence_state")
-        batch_op.drop_column("status_emoji")
-        batch_op.drop_column("status_message")
-        batch_op.drop_column("status_expires_at")
-
-    # Convert info (JSON) → TEXT
-    _convert_column_to_text("user", "info")
-    # Convert settings (JSON) → TEXT
-    _convert_column_to_text("user", "settings")

backend/open_webui/models/auths.py

@@ -3,10 +3,11 @@ import uuid
 from typing import Optional
 
 from open_webui.internal.db import Base, get_db
-from open_webui.models.users import UserModel, UserProfileImageResponse, Users
+from open_webui.models.users import UserModel, Users
 from open_webui.env import SRC_LOG_LEVELS
 from pydantic import BaseModel
 from sqlalchemy import Boolean, Column, String, Text
+from open_webui.utils.auth import verify_password
 
 log = logging.getLogger(__name__)
 log.setLevel(SRC_LOG_LEVELS["MODELS"])
@@ -19,7 +20,7 @@ log.setLevel(SRC_LOG_LEVELS["MODELS"])
 class Auth(Base):
     __tablename__ = "auth"
 
-    id = Column(String, primary_key=True, unique=True)
+    id = Column(String, primary_key=True)
     email = Column(String)
     password = Column(Text)
     active = Column(Boolean)
@@ -46,7 +47,15 @@ class ApiKey(BaseModel):
     api_key: Optional[str] = None
 
 
-class SigninResponse(Token, UserProfileImageResponse):
+class UserResponse(BaseModel):
+    id: str
+    email: str
+    name: str
+    role: str
+    profile_image_url: str
+
+
+class SigninResponse(Token, UserResponse):
     pass
 
 
@@ -88,7 +97,7 @@ class AuthsTable:
         name: str,
         profile_image_url: str = "/user.png",
         role: str = "pending",
-        oauth: Optional[dict] = None,
+        oauth_sub: Optional[str] = None,
     ) -> Optional[UserModel]:
         with get_db() as db:
             log.info("insert_new_auth")
@@ -102,7 +111,7 @@ class AuthsTable:
             db.add(result)
 
             user = Users.insert_new_user(
-                id, name, email, profile_image_url, role, oauth=oauth
+                id, name, email, profile_image_url, role, oauth_sub
             )
 
             db.commit()
@@ -113,9 +122,7 @@ class AuthsTable:
             else:
                 return None
 
-    def authenticate_user(
-        self, email: str, verify_password: callable
-    ) -> Optional[UserModel]:
+    def authenticate_user(self, email: str, password: str) -> Optional[UserModel]:
         log.info(f"authenticate_user: {email}")
 
         user = Users.get_user_by_email(email)
@@ -126,7 +133,7 @@ class AuthsTable:
             with get_db() as db:
                 auth = db.query(Auth).filter_by(id=user.id, active=True).first()
                 if auth:
-                    if verify_password(auth.password):
+                    if verify_password(password, auth.password):
                         return user
                     else:
                         return None

backend/open_webui/models/channels.py

@@ -4,13 +4,10 @@ import uuid
 from typing import Optional
 
 from open_webui.internal.db import Base, get_db
-from open_webui.models.groups import Groups
+from open_webui.utils.access_control import has_access
 
 from pydantic import BaseModel, ConfigDict
-from sqlalchemy.dialects.postgresql import JSONB
-
-
-from sqlalchemy import BigInteger, Boolean, Column, String, Text, JSON, case, cast
+from sqlalchemy import BigInteger, Boolean, Column, String, Text, JSON
 from sqlalchemy import or_, func, select, and_, text
 from sqlalchemy.sql import exists
 
@@ -22,30 +19,19 @@ from sqlalchemy.sql import exists
 class Channel(Base):
     __tablename__ = "channel"
 
-    id = Column(Text, primary_key=True, unique=True)
+    id = Column(Text, primary_key=True)
     user_id = Column(Text)
     type = Column(Text, nullable=True)
 
     name = Column(Text)
     description = Column(Text, nullable=True)
 
-    # Used to indicate if the channel is private (for 'group' type channels)
-    is_private = Column(Boolean, nullable=True)
-
     data = Column(JSON, nullable=True)
     meta = Column(JSON, nullable=True)
     access_control = Column(JSON, nullable=True)
 
     created_at = Column(BigInteger)
-
     updated_at = Column(BigInteger)
-    updated_by = Column(Text, nullable=True)
-
-    archived_at = Column(BigInteger, nullable=True)
-    archived_by = Column(Text, nullable=True)
-
-    deleted_at = Column(BigInteger, nullable=True)
-    deleted_by = Column(Text, nullable=True)
 
 
 class ChannelModel(BaseModel):
@@ -53,122 +39,17 @@ class ChannelModel(BaseModel):
 
     id: str
     user_id: str
-
     type: Optional[str] = None
 
     name: str
     description: Optional[str] = None
 
-    is_private: Optional[bool] = None
-
     data: Optional[dict] = None
     meta: Optional[dict] = None
     access_control: Optional[dict] = None
 
-    created_at: int  # timestamp in epoch (time_ns)
-
-    updated_at: int  # timestamp in epoch (time_ns)
-    updated_by: Optional[str] = None
-
-    archived_at: Optional[int] = None  # timestamp in epoch (time_ns)
-    archived_by: Optional[str] = None
-
-    deleted_at: Optional[int] = None  # timestamp in epoch (time_ns)
-    deleted_by: Optional[str] = None
-
-
-class ChannelMember(Base):
-    __tablename__ = "channel_member"
-
-    id = Column(Text, primary_key=True, unique=True)
-    channel_id = Column(Text, nullable=False)
-    user_id = Column(Text, nullable=False)
-
-    role = Column(Text, nullable=True)
-    status = Column(Text, nullable=True)
-
-    is_active = Column(Boolean, nullable=False, default=True)
-
-    is_channel_muted = Column(Boolean, nullable=False, default=False)
-    is_channel_pinned = Column(Boolean, nullable=False, default=False)
-
-    data = Column(JSON, nullable=True)
-    meta = Column(JSON, nullable=True)
-
-    invited_at = Column(BigInteger, nullable=True)
-    invited_by = Column(Text, nullable=True)
-
-    joined_at = Column(BigInteger)
-    left_at = Column(BigInteger, nullable=True)
-
-    last_read_at = Column(BigInteger, nullable=True)
-
-    created_at = Column(BigInteger)
-    updated_at = Column(BigInteger)
-
-
-class ChannelMemberModel(BaseModel):
-    model_config = ConfigDict(from_attributes=True)
-
-    id: str
-    channel_id: str
-    user_id: str
-
-    role: Optional[str] = None
-    status: Optional[str] = None
-
-    is_active: bool = True
-
-    is_channel_muted: bool = False
-    is_channel_pinned: bool = False
-
-    data: Optional[dict] = None
-    meta: Optional[dict] = None
-
-    invited_at: Optional[int] = None  # timestamp in epoch (time_ns)
-    invited_by: Optional[str] = None
-
-    joined_at: Optional[int] = None  # timestamp in epoch (time_ns)
-    left_at: Optional[int] = None  # timestamp in epoch (time_ns)
-
-    last_read_at: Optional[int] = None  # timestamp in epoch (time_ns)
-
-    created_at: Optional[int] = None  # timestamp in epoch (time_ns)
-    updated_at: Optional[int] = None  # timestamp in epoch (time_ns)
-
-
-class ChannelWebhook(Base):
-    __tablename__ = "channel_webhook"
-
-    id = Column(Text, primary_key=True, unique=True)
-    channel_id = Column(Text, nullable=False)
-    user_id = Column(Text, nullable=False)
-
-    name = Column(Text, nullable=False)
-    profile_image_url = Column(Text, nullable=True)
-
-    token = Column(Text, nullable=False)
-    last_used_at = Column(BigInteger, nullable=True)
-
-    created_at = Column(BigInteger, nullable=False)
-    updated_at = Column(BigInteger, nullable=False)
-
-
-class ChannelWebhookModel(BaseModel):
-    model_config = ConfigDict(from_attributes=True)
-
-    id: str
-    channel_id: str
-    user_id: str
-
-    name: str
-    profile_image_url: Optional[str] = None
-
-    token: str
-    last_used_at: Optional[int] = None  # timestamp in epoch (time_ns)
-
-    created_at: int  # timestamp in epoch (time_ns)
-    updated_at: int  # timestamp in epoch (time_ns)
+    created_at: int  # timestamp in epoch
+    updated_at: int  # timestamp in epoch
 
 
 ####################
@@ -177,94 +58,26 @@ class ChannelWebhookModel(BaseModel):
 
 
 class ChannelResponse(ChannelModel):
-    is_manager: bool = False
     write_access: bool = False
 
-    user_count: Optional[int] = None
-
 
 class ChannelForm(BaseModel):
-    name: str = ""
+    name: str
     description: Optional[str] = None
-    is_private: Optional[bool] = None
     data: Optional[dict] = None
     meta: Optional[dict] = None
     access_control: Optional[dict] = None
-    group_ids: Optional[list[str]] = None
-    user_ids: Optional[list[str]] = None
-
-
-class CreateChannelForm(ChannelForm):
-    type: Optional[str] = None
 
 
 class ChannelTable:
-
-    def _collect_unique_user_ids(
-        self,
-        invited_by: str,
-        user_ids: Optional[list[str]] = None,
-        group_ids: Optional[list[str]] = None,
-    ) -> set[str]:
-        """
-        Collect unique user ids from:
-        - invited_by
-        - user_ids
-        - each group in group_ids
-        Returns a set for efficient SQL diffing.
-        """
-        users = set(user_ids or [])
-        users.add(invited_by)
-
-        for group_id in group_ids or []:
-            users.update(Groups.get_group_user_ids_by_id(group_id))
-
-        return users
-
-    def _create_membership_models(
-        self,
-        channel_id: str,
-        invited_by: str,
-        user_ids: set[str],
-    ) -> list[ChannelMember]:
-        """
-        Takes a set of NEW user IDs (already filtered to exclude existing members).
-        Returns ORM ChannelMember objects to be added.
-        """
-        now = int(time.time_ns())
-        memberships = []
-
-        for uid in user_ids:
-            model = ChannelMemberModel(
-                **{
-                    "id": str(uuid.uuid4()),
-                    "channel_id": channel_id,
-                    "user_id": uid,
-                    "status": "joined",
-                    "is_active": True,
-                    "is_channel_muted": False,
-                    "is_channel_pinned": False,
-                    "invited_at": now,
-                    "invited_by": invited_by,
-                    "joined_at": now,
-                    "left_at": None,
-                    "last_read_at": now,
-                    "created_at": now,
-                    "updated_at": now,
-                }
-            )
-            memberships.append(ChannelMember(**model.model_dump()))
-
-        return memberships
-
     def insert_new_channel(
-        self, form_data: CreateChannelForm, user_id: str
+        self, type: Optional[str], form_data: ChannelForm, user_id: str
     ) -> Optional[ChannelModel]:
         with get_db() as db:
             channel = ChannelModel(
                 **{
                     **form_data.model_dump(),
-                    "type": form_data.type if form_data.type else None,
+                    "type": type,
                     "name": form_data.name.lower(),
                     "id": str(uuid.uuid4()),
                     "user_id": user_id,
@@ -272,21 +85,9 @@ class ChannelTable:
                     "updated_at": int(time.time_ns()),
                 }
             )
+
             new_channel = Channel(**channel.model_dump())
 
-            if form_data.type in ["group", "dm"]:
-                users = self._collect_unique_user_ids(
-                    invited_by=user_id,
-                    user_ids=form_data.user_ids,
-                    group_ids=form_data.group_ids,
-                )
-                memberships = self._create_membership_models(
-                    channel_id=new_channel.id,
-                    invited_by=user_id,
-                    user_ids=users,
-                )
-
-                db.add_all(memberships)
             db.add(new_channel)
             db.commit()
             return channel
@@ -296,346 +97,16 @@ class ChannelTable:
             channels = db.query(Channel).all()
             return [ChannelModel.model_validate(channel) for channel in channels]
 
-    def _has_permission(self, db, query, filter: dict, permission: str = "read"):
-        group_ids = filter.get("group_ids", [])
-        user_id = filter.get("user_id")
-
-        dialect_name = db.bind.dialect.name
-
-        # Public access
-        conditions = []
-        if group_ids or user_id:
-            conditions.extend(
-                [
-                    Channel.access_control.is_(None),
-                    cast(Channel.access_control, String) == "null",
-                ]
-            )
-
-        # User-level permission
-        if user_id:
-            conditions.append(Channel.user_id == user_id)
-
-        # Group-level permission
-        if group_ids:
-            group_conditions = []
-            for gid in group_ids:
-                if dialect_name == "sqlite":
-                    group_conditions.append(
-                        Channel.access_control[permission]["group_ids"].contains([gid])
-                    )
-                elif dialect_name == "postgresql":
-                    group_conditions.append(
-                        cast(
-                            Channel.access_control[permission]["group_ids"],
-                            JSONB,
-                        ).contains([gid])
-                    )
-            conditions.append(or_(*group_conditions))
-
-        if conditions:
-            query = query.filter(or_(*conditions))
-
-        return query
-
-    def get_channels_by_user_id(self, user_id: str) -> list[ChannelModel]:
-        with get_db() as db:
-            user_group_ids = [
-                group.id for group in Groups.get_groups_by_member_id(user_id)
-            ]
-
-            membership_channels = (
-                db.query(Channel)
-                .join(ChannelMember, Channel.id == ChannelMember.channel_id)
-                .filter(
-                    Channel.deleted_at.is_(None),
-                    Channel.archived_at.is_(None),
-                    Channel.type.in_(["group", "dm"]),
-                    ChannelMember.user_id == user_id,
-                    ChannelMember.is_active.is_(True),
-                )
-                .all()
-            )
-
-            query = db.query(Channel).filter(
-                Channel.deleted_at.is_(None),
-                Channel.archived_at.is_(None),
-                or_(
-                    Channel.type.is_(None),  # True NULL/None
-                    Channel.type == "",  # Empty string
-                    and_(Channel.type != "group", Channel.type != "dm"),
-                ),
-            )
-            query = self._has_permission(
-                db, query, {"user_id": user_id, "group_ids": user_group_ids}
-            )
-
-            standard_channels = query.all()
-
-            all_channels = membership_channels + standard_channels
-            return [ChannelModel.model_validate(c) for c in all_channels]
-
-    def get_dm_channel_by_user_ids(self, user_ids: list[str]) -> Optional[ChannelModel]:
-        with get_db() as db:
-            # Ensure uniqueness in case a list with duplicates is passed
-            unique_user_ids = list(set(user_ids))
-
-            match_count = func.sum(
-                case(
-                    (ChannelMember.user_id.in_(unique_user_ids), 1),
-                    else_=0,
-                )
-            )
-
-            subquery = (
-                db.query(ChannelMember.channel_id)
-                .group_by(ChannelMember.channel_id)
-                # 1. Channel must have exactly len(user_ids) members
-                .having(func.count(ChannelMember.user_id) == len(unique_user_ids))
-                # 2. All those members must be in unique_user_ids
-                .having(match_count == len(unique_user_ids))
-                .subquery()
-            )
-
-            channel = (
-                db.query(Channel)
-                .filter(
-                    Channel.id.in_(subquery),
-                    Channel.type == "dm",
-                )
-                .first()
-            )
-
-            return ChannelModel.model_validate(channel) if channel else None
-
-    def add_members_to_channel(
-        self,
-        channel_id: str,
-        invited_by: str,
-        user_ids: Optional[list[str]] = None,
-        group_ids: Optional[list[str]] = None,
-    ) -> list[ChannelMemberModel]:
-        with get_db() as db:
-            # 1. Collect all user_ids including groups + inviter
-            requested_users = self._collect_unique_user_ids(
-                invited_by, user_ids, group_ids
-            )
-
-            existing_users = {
-                row.user_id
-                for row in db.query(ChannelMember.user_id)
-                .filter(ChannelMember.channel_id == channel_id)
-                .all()
-            }
-
-            new_user_ids = requested_users - existing_users
-            if not new_user_ids:
-                return []  # Nothing to add
-
-            new_memberships = self._create_membership_models(
-                channel_id, invited_by, new_user_ids
-            )
-
-            db.add_all(new_memberships)
-            db.commit()
-
-            return [
-                ChannelMemberModel.model_validate(membership)
-                for membership in new_memberships
-            ]
-
-    def remove_members_from_channel(
-        self,
-        channel_id: str,
-        user_ids: list[str],
-    ) -> int:
-        with get_db() as db:
-            result = (
-                db.query(ChannelMember)
-                .filter(
-                    ChannelMember.channel_id == channel_id,
-                    ChannelMember.user_id.in_(user_ids),
-                )
-                .delete(synchronize_session=False)
-            )
-            db.commit()
-            return result  # number of rows deleted
-
-    def is_user_channel_manager(self, channel_id: str, user_id: str) -> bool:
-        with get_db() as db:
-            # Check if the user is the creator of the channel
-            # or has a 'manager' role in ChannelMember
-            channel = db.query(Channel).filter(Channel.id == channel_id).first()
-            if channel and channel.user_id == user_id:
-                return True
-
-            membership = (
-                db.query(ChannelMember)
-                .filter(
-                    ChannelMember.channel_id == channel_id,
-                    ChannelMember.user_id == user_id,
-                    ChannelMember.role == "manager",
-                )
-                .first()
-            )
-            return membership is not None
-
-    def join_channel(
-        self, channel_id: str, user_id: str
-    ) -> Optional[ChannelMemberModel]:
-        with get_db() as db:
-            # Check if the membership already exists
-            existing_membership = (
-                db.query(ChannelMember)
-                .filter(
-                    ChannelMember.channel_id == channel_id,
-                    ChannelMember.user_id == user_id,
-                )
-                .first()
-            )
-            if existing_membership:
-                return ChannelMemberModel.model_validate(existing_membership)
-
-            # Create new membership
-            channel_member = ChannelMemberModel(
-                **{
-                    "id": str(uuid.uuid4()),
-                    "channel_id": channel_id,
-                    "user_id": user_id,
-                    "status": "joined",
-                    "is_active": True,
-                    "is_channel_muted": False,
-                    "is_channel_pinned": False,
-                    "joined_at": int(time.time_ns()),
-                    "left_at": None,
-                    "last_read_at": int(time.time_ns()),
-                    "created_at": int(time.time_ns()),
-                    "updated_at": int(time.time_ns()),
-                }
-            )
-            new_membership = ChannelMember(**channel_member.model_dump())
-
-            db.add(new_membership)
-            db.commit()
-            return channel_member
-
-    def leave_channel(self, channel_id: str, user_id: str) -> bool:
-        with get_db() as db:
-            membership = (
-                db.query(ChannelMember)
-                .filter(
-                    ChannelMember.channel_id == channel_id,
-                    ChannelMember.user_id == user_id,
-                )
-                .first()
-            )
-            if not membership:
-                return False
-
-            membership.status = "left"
-            membership.is_active = False
-            membership.left_at = int(time.time_ns())
-            membership.updated_at = int(time.time_ns())
-
-            db.commit()
-            return True
-
-    def get_member_by_channel_and_user_id(
-        self, channel_id: str, user_id: str
-    ) -> Optional[ChannelMemberModel]:
-        with get_db() as db:
-            membership = (
-                db.query(ChannelMember)
-                .filter(
-                    ChannelMember.channel_id == channel_id,
-                    ChannelMember.user_id == user_id,
-                )
-                .first()
-            )
-            return ChannelMemberModel.model_validate(membership) if membership else None
-
-    def get_members_by_channel_id(self, channel_id: str) -> list[ChannelMemberModel]:
-        with get_db() as db:
-            memberships = (
-                db.query(ChannelMember)
-                .filter(ChannelMember.channel_id == channel_id)
-                .all()
-            )
-            return [
-                ChannelMemberModel.model_validate(membership)
-                for membership in memberships
-            ]
-
-    def pin_channel(self, channel_id: str, user_id: str, is_pinned: bool) -> bool:
-        with get_db() as db:
-            membership = (
-                db.query(ChannelMember)
-                .filter(
-                    ChannelMember.channel_id == channel_id,
-                    ChannelMember.user_id == user_id,
-                )
-                .first()
-            )
-            if not membership:
-                return False
-
-            membership.is_channel_pinned = is_pinned
-            membership.updated_at = int(time.time_ns())
-
-            db.commit()
-            return True
-
-    def update_member_last_read_at(self, channel_id: str, user_id: str) -> bool:
-        with get_db() as db:
-            membership = (
-                db.query(ChannelMember)
-                .filter(
-                    ChannelMember.channel_id == channel_id,
-                    ChannelMember.user_id == user_id,
-                )
-                .first()
-            )
-            if not membership:
-                return False
-
-            membership.last_read_at = int(time.time_ns())
-            membership.updated_at = int(time.time_ns())
-
-            db.commit()
-            return True
-
-    def update_member_active_status(
-        self, channel_id: str, user_id: str, is_active: bool
-    ) -> bool:
-        with get_db() as db:
-            membership = (
-                db.query(ChannelMember)
-                .filter(
-                    ChannelMember.channel_id == channel_id,
-                    ChannelMember.user_id == user_id,
-                )
-                .first()
-            )
-            if not membership:
-                return False
-
-            membership.is_active = is_active
-            membership.updated_at = int(time.time_ns())
-
-            db.commit()
-            return True
-
-    def is_user_channel_member(self, channel_id: str, user_id: str) -> bool:
-        with get_db() as db:
-            membership = (
-                db.query(ChannelMember)
-                .filter(
-                    ChannelMember.channel_id == channel_id,
-                    ChannelMember.user_id == user_id,
-                )
-                .first()
-            )
-            return membership is not None
+    def get_channels_by_user_id(
+        self, user_id: str, permission: str = "read"
+    ) -> list[ChannelModel]:
+        channels = self.get_channels()
+        return [
+            channel
+            for channel in channels
+            if channel.user_id == user_id
+            or has_access(user_id, permission, channel.access_control)
+        ]
 
     def get_channel_by_id(self, id: str) -> Optional[ChannelModel]:
         with get_db() as db:
@@ -651,12 +122,8 @@ class ChannelTable:
                 return None
 
             channel.name = form_data.name
-            channel.description = form_data.description
-            channel.is_private = form_data.is_private
-
             channel.data = form_data.data
             channel.meta = form_data.meta
-
             channel.access_control = form_data.access_control
             channel.updated_at = int(time.time_ns())
 

backend/open_webui/models/chats.py

@@ -26,7 +26,7 @@ log.setLevel(SRC_LOG_LEVELS["MODELS"])
 class Chat(Base):
     __tablename__ = "chat"
 
-    id = Column(String, primary_key=True, unique=True)
+    id = Column(String, primary_key=True)
     user_id = Column(String)
     title = Column(Text)
     chat = Column(JSON)
@@ -92,10 +92,6 @@ class ChatImportForm(ChatForm):
     updated_at: Optional[int] = None
 
 
-class ChatsImportForm(BaseModel):
-    chats: list[ChatImportForm]
-
-
 class ChatTitleMessagesForm(BaseModel):
     title: str
     messages: list[dict]
@@ -127,43 +123,6 @@ class ChatTitleIdResponse(BaseModel):
 
 
 class ChatTable:
-    def _clean_null_bytes(self, obj):
-        """
-        Recursively remove actual null bytes (\x00) and unicode escape \\u0000
-        from strings inside dict/list structures.
-        Safe for JSON objects.
-        """
-        if isinstance(obj, str):
-            return obj.replace("\x00", "").replace("\u0000", "")
-        elif isinstance(obj, dict):
-            return {k: self._clean_null_bytes(v) for k, v in obj.items()}
-        elif isinstance(obj, list):
-            return [self._clean_null_bytes(v) for v in obj]
-        return obj
-
-    def _sanitize_chat_row(self, chat_item):
-        """
-        Clean a Chat SQLAlchemy model's title + chat JSON,
-        and return True if anything changed.
-        """
-        changed = False
-
-        # Clean title
-        if chat_item.title:
-            cleaned = self._clean_null_bytes(chat_item.title)
-            if cleaned != chat_item.title:
-                chat_item.title = cleaned
-                changed = True
-
-        # Clean JSON
-        if chat_item.chat:
-            cleaned = self._clean_null_bytes(chat_item.chat)
-            if cleaned != chat_item.chat:
-                chat_item.chat = cleaned
-                changed = True
-
-        return changed
-
     def insert_new_chat(self, user_id: str, form_data: ChatForm) -> Optional[ChatModel]:
         with get_db() as db:
             id = str(uuid.uuid4())
@@ -171,76 +130,68 @@ class ChatTable:
                 **{
                     "id": id,
                     "user_id": user_id,
-                    "title": self._clean_null_bytes(
+                    "title": (
                         form_data.chat["title"]
                         if "title" in form_data.chat
                         else "New Chat"
                     ),
-                    "chat": self._clean_null_bytes(form_data.chat),
+                    "chat": form_data.chat,
                     "folder_id": form_data.folder_id,
                     "created_at": int(time.time()),
                     "updated_at": int(time.time()),
                 }
             )
 
-            chat_item = Chat(**chat.model_dump())
-            db.add(chat_item)
+            result = Chat(**chat.model_dump())
+            db.add(result)
             db.commit()
-            db.refresh(chat_item)
-            return ChatModel.model_validate(chat_item) if chat_item else None
+            db.refresh(result)
+            return ChatModel.model_validate(result) if result else None
 
-    def _chat_import_form_to_chat_model(
+    def import_chat(
         self, user_id: str, form_data: ChatImportForm
-    ) -> ChatModel:
-        id = str(uuid.uuid4())
-        chat = ChatModel(
-            **{
-                "id": id,
-                "user_id": user_id,
-                "title": self._clean_null_bytes(
-                    form_data.chat["title"] if "title" in form_data.chat else "New Chat"
-                ),
-                "chat": self._clean_null_bytes(form_data.chat),
-                "meta": form_data.meta,
-                "pinned": form_data.pinned,
-                "folder_id": form_data.folder_id,
-                "created_at": (
-                    form_data.created_at if form_data.created_at else int(time.time())
-                ),
-                "updated_at": (
-                    form_data.updated_at if form_data.updated_at else int(time.time())
-                ),
-            }
-        )
-        return chat
-
-    def import_chats(
-        self, user_id: str, chat_import_forms: list[ChatImportForm]
-    ) -> list[ChatModel]:
+    ) -> Optional[ChatModel]:
         with get_db() as db:
-            chats = []
+            id = str(uuid.uuid4())
+            chat = ChatModel(
+                **{
+                    "id": id,
+                    "user_id": user_id,
+                    "title": (
+                        form_data.chat["title"]
+                        if "title" in form_data.chat
+                        else "New Chat"
+                    ),
+                    "chat": form_data.chat,
+                    "meta": form_data.meta,
+                    "pinned": form_data.pinned,
+                    "folder_id": form_data.folder_id,
+                    "created_at": (
+                        form_data.created_at
+                        if form_data.created_at
+                        else int(time.time())
+                    ),
+                    "updated_at": (
+                        form_data.updated_at
+                        if form_data.updated_at
+                        else int(time.time())
+                    ),
+                }
+            )
 
-            for form_data in chat_import_forms:
-                chat = self._chat_import_form_to_chat_model(user_id, form_data)
-                chats.append(Chat(**chat.model_dump()))
-
-            db.add_all(chats)
+            result = Chat(**chat.model_dump())
+            db.add(result)
             db.commit()
-            return [ChatModel.model_validate(chat) for chat in chats]
+            db.refresh(result)
+            return ChatModel.model_validate(result) if result else None
 
     def update_chat_by_id(self, id: str, chat: dict) -> Optional[ChatModel]:
         try:
             with get_db() as db:
                 chat_item = db.get(Chat, id)
-                chat_item.chat = self._clean_null_bytes(chat)
-                chat_item.title = (
-                    self._clean_null_bytes(chat["title"])
-                    if "title" in chat
-                    else "New Chat"
-                )
-
+                chat_item.chat = chat
+                chat_item.title = chat["title"] if "title" in chat else "New Chat"
                 chat_item.updated_at = int(time.time())
-
                 db.commit()
                 db.refresh(chat_item)
 
@@ -346,27 +297,6 @@ class ChatTable:
         chat["history"] = history
         return self.update_chat_by_id(id, chat)
 
-    def add_message_files_by_id_and_message_id(
-        self, id: str, message_id: str, files: list[dict]
-    ) -> list[dict]:
-        chat = self.get_chat_by_id(id)
-        if chat is None:
-            return None
-
-        chat = chat.chat
-        history = chat.get("history", {})
-
-        message_files = []
-
-        if message_id in history.get("messages", {}):
-            message_files = history["messages"][message_id].get("files", [])
-            message_files = message_files + files
-            history["messages"][message_id]["files"] = message_files
-
-        chat["history"] = history
-        self.update_chat_by_id(id, chat)
-        return message_files
-
     def insert_shared_chat_by_chat_id(self, chat_id: str) -> Optional[ChatModel]:
         with get_db() as db:
             # Get the existing chat to share
@@ -475,7 +405,6 @@ class ChatTable:
             with get_db() as db:
                 chat = db.get(Chat, id)
                 chat.archived = not chat.archived
-                chat.folder_id = None
                 chat.updated_at = int(time.time())
                 db.commit()
                 db.refresh(chat)
@@ -511,10 +440,7 @@ class ChatTable:
                 order_by = filter.get("order_by")
                 direction = filter.get("direction")
 
-                if order_by and direction:
-                    if not getattr(Chat, order_by, None):
-                        raise ValueError("Invalid order_by field")
-
+                if order_by and direction and getattr(Chat, order_by):
                     if direction.lower() == "asc":
                         query = query.order_by(getattr(Chat, order_by).asc())
                     elif direction.lower() == "desc":
@@ -632,15 +558,8 @@ class ChatTable:
     def get_chat_by_id(self, id: str) -> Optional[ChatModel]:
         try:
             with get_db() as db:
-                chat_item = db.get(Chat, id)
-                if chat_item is None:
-                    return None
-
-                if self._sanitize_chat_row(chat_item):
-                    db.commit()
-                    db.refresh(chat_item)
-
-                return ChatModel.model_validate(chat_item)
+                chat = db.get(Chat, id)
+                return ChatModel.model_validate(chat)
         except Exception:
             return None
 
@@ -843,32 +762,21 @@ class ChatTable:
                     )
 
             elif dialect_name == "postgresql":
-                # PostgreSQL doesn't allow null bytes in text. We filter those out by checking
-                # the JSON representation for \u0000 before attempting text extraction
-
-                # Safety filter: JSON field must not contain \u0000
-                query = query.filter(text("Chat.chat::text NOT LIKE '%\\\\u0000%'"))
-
-                # Safety filter: title must not contain actual null bytes
-                query = query.filter(text("Chat.title::text NOT LIKE '%\\x00%'"))
-
-                postgres_content_sql = """
-                EXISTS (
-                    SELECT 1
-                    FROM json_array_elements(Chat.chat->'messages') AS message
-                    WHERE json_typeof(message->'content') = 'string'
-                    AND LOWER(message->>'content') LIKE '%' || :content_key || '%'
+                # PostgreSQL relies on proper JSON query for search
+                postgres_content_sql = (
+                    "EXISTS ("
+                    "    SELECT 1 "
+                    "    FROM json_array_elements(Chat.chat->'messages') AS message "
+                    "    WHERE LOWER(message->>'content') LIKE '%' || :content_key || '%'"
+                    ")"
                 )
-                """
-
                 postgres_content_clause = text(postgres_content_sql)
-
                 query = query.filter(
                     or_(
                         Chat.title.ilike(bindparam("title_key")),
                         postgres_content_clause,
-                    )
-                ).params(title_key=f"%{search_text}%", content_key=search_text.lower())
+                    ).params(title_key=f"%{search_text}%", content_key=search_text)
+                )
 
                 # Check if there are any tags to filter, it should have all the tags
                 if "none" in tag_ids:
@@ -1143,20 +1051,6 @@ class ChatTable:
         except Exception:
             return False
 
-    def move_chats_by_user_id_and_folder_id(
-        self, user_id: str, folder_id: str, new_folder_id: Optional[str]
-    ) -> bool:
-        try:
-            with get_db() as db:
-                db.query(Chat).filter_by(user_id=user_id, folder_id=folder_id).update(
-                    {"folder_id": new_folder_id}
-                )
-                db.commit()
-
-                return True
-        except Exception:
-            return False
-
     def delete_shared_chats_by_user_id(self, user_id: str) -> bool:
         try:
             with get_db() as db:

backend/open_webui/models/feedbacks.py

@@ -4,7 +4,7 @@ import uuid
 from typing import Optional
 
 from open_webui.internal.db import Base, get_db
-from open_webui.models.users import User
+from open_webui.models.chats import Chats
 
 from open_webui.env import SRC_LOG_LEVELS
 from pydantic import BaseModel, ConfigDict
@@ -21,7 +21,7 @@ log.setLevel(SRC_LOG_LEVELS["MODELS"])
 
 class Feedback(Base):
     __tablename__ = "feedback"
-    id = Column(Text, primary_key=True, unique=True)
+    id = Column(Text, primary_key=True)
     user_id = Column(Text)
     version = Column(BigInteger, default=0)
     type = Column(Text)
@@ -92,28 +92,6 @@ class FeedbackForm(BaseModel):
     model_config = ConfigDict(extra="allow")
 
 
-class UserResponse(BaseModel):
-    id: str
-    name: str
-    email: str
-    role: str = "pending"
-
-    last_active_at: int  # timestamp in epoch
-    updated_at: int  # timestamp in epoch
-    created_at: int  # timestamp in epoch
-
-    model_config = ConfigDict(from_attributes=True)
-
-
-class FeedbackUserResponse(FeedbackResponse):
-    user: Optional[UserResponse] = None
-
-
-class FeedbackListResponse(BaseModel):
-    items: list[FeedbackUserResponse]
-    total: int
-
-
 class FeedbackTable:
     def insert_new_feedback(
         self, user_id: str, form_data: FeedbackForm
@@ -165,70 +143,6 @@ class FeedbackTable:
         except Exception:
             return None
 
-    def get_feedback_items(
-        self, filter: dict = {}, skip: int = 0, limit: int = 30
-    ) -> FeedbackListResponse:
-        with get_db() as db:
-            query = db.query(Feedback, User).join(User, Feedback.user_id == User.id)
-
-            if filter:
-                order_by = filter.get("order_by")
-                direction = filter.get("direction")
-
-                if order_by == "username":
-                    if direction == "asc":
-                        query = query.order_by(User.name.asc())
-                    else:
-                        query = query.order_by(User.name.desc())
-                elif order_by == "model_id":
-                    # it's stored in feedback.data['model_id']
-                    if direction == "asc":
-                        query = query.order_by(
-                            Feedback.data["model_id"].as_string().asc()
-                        )
-                    else:
-                        query = query.order_by(
-                            Feedback.data["model_id"].as_string().desc()
-                        )
-                elif order_by == "rating":
-                    # it's stored in feedback.data['rating']
-                    if direction == "asc":
-                        query = query.order_by(
-                            Feedback.data["rating"].as_string().asc()
-                        )
-                    else:
-                        query = query.order_by(
-                            Feedback.data["rating"].as_string().desc()
-                        )
-                elif order_by == "updated_at":
-                    if direction == "asc":
-                        query = query.order_by(Feedback.updated_at.asc())
-                    else:
-                        query = query.order_by(Feedback.updated_at.desc())
-
-            else:
-                query = query.order_by(Feedback.created_at.desc())
-
-            # Count BEFORE pagination
-            total = query.count()
-
-            if skip:
-                query = query.offset(skip)
-            if limit:
-                query = query.limit(limit)
-
-            items = query.all()
-
-            feedbacks = []
-            for feedback, user in items:
-                feedback_model = FeedbackModel.model_validate(feedback)
-                user_model = UserResponse.model_validate(user)
-                feedbacks.append(
-                    FeedbackUserResponse(**feedback_model.model_dump(), user=user_model)
-                )
-
-            return FeedbackListResponse(items=feedbacks, total=total)
-
     def get_all_feedbacks(self) -> list[FeedbackModel]:
         with get_db() as db:
             return [

backend/open_webui/models/files.py

@@ -17,7 +17,7 @@ log.setLevel(SRC_LOG_LEVELS["MODELS"])
 
 class File(Base):
     __tablename__ = "file"
-    id = Column(String, primary_key=True, unique=True)
+    id = Column(String, primary_key=True)
     user_id = Column(String)
     hash = Column(Text, nullable=True)
 
@@ -98,12 +98,6 @@ class FileForm(BaseModel):
     access_control: Optional[dict] = None
 
 
-class FileUpdateForm(BaseModel):
-    hash: Optional[str] = None
-    data: Optional[dict] = None
-    meta: Optional[dict] = None
-
-
 class FilesTable:
     def insert_new_file(self, user_id: str, form_data: FileForm) -> Optional[FileModel]:
         with get_db() as db:
@@ -210,29 +204,6 @@ class FilesTable:
                 for file in db.query(File).filter_by(user_id=user_id).all()
             ]
 
-    def update_file_by_id(
-        self, id: str, form_data: FileUpdateForm
-    ) -> Optional[FileModel]:
-        with get_db() as db:
-            try:
-                file = db.query(File).filter_by(id=id).first()
-
-                if form_data.hash is not None:
-                    file.hash = form_data.hash
-
-                if form_data.data is not None:
-                    file.data = {**(file.data if file.data else {}), **form_data.data}
-
-                if form_data.meta is not None:
-                    file.meta = {**(file.meta if file.meta else {}), **form_data.meta}
-
-                file.updated_at = int(time.time())
-                db.commit()
-                return FileModel.model_validate(file)
-            except Exception as e:
-                log.exception(f"Error updating file completely by id: {e}")
-                return None
-
     def update_file_hash_by_id(self, id: str, hash: str) -> Optional[FileModel]:
         with get_db() as db:
             try:

backend/open_webui/models/folders.py

@@ -23,7 +23,7 @@ log.setLevel(SRC_LOG_LEVELS["MODELS"])
 
 class Folder(Base):
     __tablename__ = "folder"
-    id = Column(Text, primary_key=True, unique=True)
+    id = Column(Text, primary_key=True)
     parent_id = Column(Text, nullable=True)
     user_id = Column(Text)
     name = Column(Text)

backend/open_webui/models/functions.py

@@ -19,7 +19,7 @@ log.setLevel(SRC_LOG_LEVELS["MODELS"])
 class Function(Base):
     __tablename__ = "function"
 
-    id = Column(String, primary_key=True, unique=True)
+    id = Column(String, primary_key=True)
     user_id = Column(String)
     name = Column(Text)
     type = Column(Text)

backend/open_webui/models/groups.py

@@ -11,18 +11,7 @@ from open_webui.models.files import FileMetadataResponse
 
 
 from pydantic import BaseModel, ConfigDict
-from sqlalchemy import (
-    BigInteger,
-    Column,
-    String,
-    Text,
-    JSON,
-    and_,
-    func,
-    ForeignKey,
-    cast,
-    or_,
-)
+from sqlalchemy import BigInteger, Column, String, Text, JSON, func
 
 
 log = logging.getLogger(__name__)
@@ -46,12 +35,14 @@ class Group(Base):
     meta = Column(JSON, nullable=True)
 
     permissions = Column(JSON, nullable=True)
+    user_ids = Column(JSON, nullable=True)
 
     created_at = Column(BigInteger)
     updated_at = Column(BigInteger)
 
 
 class GroupModel(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
     id: str
     user_id: str
 
@@ -62,64 +53,44 @@ class GroupModel(BaseModel):
     meta: Optional[dict] = None
 
     permissions: Optional[dict] = None
+    user_ids: list[str] = []
 
     created_at: int  # timestamp in epoch
     updated_at: int  # timestamp in epoch
 
-    model_config = ConfigDict(from_attributes=True)
-
-
-class GroupMember(Base):
-    __tablename__ = "group_member"
-
-    id = Column(Text, unique=True, primary_key=True)
-    group_id = Column(
-        Text,
-        ForeignKey("group.id", ondelete="CASCADE"),
-        nullable=False,
-    )
-    user_id = Column(Text, nullable=False)
-    created_at = Column(BigInteger, nullable=True)
-    updated_at = Column(BigInteger, nullable=True)
-
-
-class GroupMemberModel(BaseModel):
-    id: str
-    group_id: str
-    user_id: str
-    created_at: Optional[int] = None  # timestamp in epoch
-    updated_at: Optional[int] = None  # timestamp in epoch
-
 
 ####################
 # Forms
 ####################
 
 
-class GroupResponse(GroupModel):
-    member_count: Optional[int] = None
+class GroupResponse(BaseModel):
+    id: str
+    user_id: str
+    name: str
+    description: str
+    permissions: Optional[dict] = None
+    data: Optional[dict] = None
+    meta: Optional[dict] = None
+    user_ids: list[str] = []
+    created_at: int  # timestamp in epoch
+    updated_at: int  # timestamp in epoch
 
 
 class GroupForm(BaseModel):
     name: str
     description: str
     permissions: Optional[dict] = None
-    data: Optional[dict] = None
 
 
 class UserIdsForm(BaseModel):
     user_ids: Optional[list[str]] = None
 
 
-class GroupUpdateForm(GroupForm):
+class GroupUpdateForm(GroupForm, UserIdsForm):
     pass
 
 
-class GroupListResponse(BaseModel):
-    items: list[GroupResponse] = []
-    total: int = 0
-
-
 class GroupTable:
     def insert_new_group(
         self, user_id: str, form_data: GroupForm
@@ -148,94 +119,24 @@ class GroupTable:
             except Exception:
                 return None
 
-    def get_all_groups(self) -> list[GroupModel]:
+    def get_groups(self) -> list[GroupModel]:
         with get_db() as db:
-            groups = db.query(Group).order_by(Group.updated_at.desc()).all()
-            return [GroupModel.model_validate(group) for group in groups]
-
-    def get_groups(self, filter) -> list[GroupResponse]:
-        with get_db() as db:
-            query = db.query(Group)
-
-            if filter:
-                if "query" in filter:
-                    query = query.filter(Group.name.ilike(f"%{filter['query']}%"))
-                if "member_id" in filter:
-                    query = query.join(
-                        GroupMember, GroupMember.group_id == Group.id
-                    ).filter(GroupMember.user_id == filter["member_id"])
-
-                if "share" in filter:
-                    share_value = filter["share"]
-                    json_share = Group.data["config"]["share"].as_boolean()
-
-                    if share_value:
-                        query = query.filter(
-                            or_(
-                                Group.data.is_(None),
-                                json_share.is_(None),
-                                json_share == True,
-                            )
-                        )
-                    else:
-                        query = query.filter(
-                            and_(Group.data.isnot(None), json_share == False)
-                        )
-            groups = query.order_by(Group.updated_at.desc()).all()
             return [
-                GroupResponse.model_validate(
-                    {
-                        **GroupModel.model_validate(group).model_dump(),
-                        "member_count": self.get_group_member_count_by_id(group.id),
-                    }
-                )
-                for group in groups
+                GroupModel.model_validate(group)
+                for group in db.query(Group).order_by(Group.updated_at.desc()).all()
             ]
 
-    def search_groups(
-        self, filter: Optional[dict] = None, skip: int = 0, limit: int = 30
-    ) -> GroupListResponse:
-        with get_db() as db:
-            query = db.query(Group)
-
-            if filter:
-                if "query" in filter:
-                    query = query.filter(Group.name.ilike(f"%{filter['query']}%"))
-                if "member_id" in filter:
-                    query = query.join(
-                        GroupMember, GroupMember.group_id == Group.id
-                    ).filter(GroupMember.user_id == filter["member_id"])
-
-                if "share" in filter:
-                    #  'share' is stored in data JSON, support both sqlite and postgres
-                    share_value = filter["share"]
-                    print("Filtering by share:", share_value)
-                    query = query.filter(
-                        Group.data.op("->>")("share") == str(share_value)
-                    )
-
-            total = query.count()
-            query = query.order_by(Group.updated_at.desc())
-            groups = query.offset(skip).limit(limit).all()
-
-            return {
-                "items": [
-                    GroupResponse.model_validate(
-                        **GroupModel.model_validate(group).model_dump(),
-                        member_count=self.get_group_member_count_by_id(group.id),
-                    )
-                    for group in groups
-                ],
-                "total": total,
-            }
-
     def get_groups_by_member_id(self, user_id: str) -> list[GroupModel]:
         with get_db() as db:
             return [
                 GroupModel.model_validate(group)
                 for group in db.query(Group)
-                .join(GroupMember, GroupMember.group_id == Group.id)
-                .filter(GroupMember.user_id == user_id)
+                .filter(
+                    func.json_array_length(Group.user_ids) > 0
+                )  # Ensure array exists
+                .filter(
+                    Group.user_ids.cast(String).like(f'%"{user_id}"%')
+                )  # String-based check
                 .order_by(Group.updated_at.desc())
                 .all()
             ]
@@ -248,63 +149,12 @@ class GroupTable:
         except Exception:
             return None
 
-    def get_group_user_ids_by_id(self, id: str) -> Optional[list[str]]:
-        with get_db() as db:
-            members = (
-                db.query(GroupMember.user_id).filter(GroupMember.group_id == id).all()
-            )
-
-            if not members:
-                return None
-
-            return [m[0] for m in members]
-
-    def get_group_user_ids_by_ids(self, group_ids: list[str]) -> dict[str, list[str]]:
-        with get_db() as db:
-            members = (
-                db.query(GroupMember.group_id, GroupMember.user_id)
-                .filter(GroupMember.group_id.in_(group_ids))
-                .all()
-            )
-
-            group_user_ids: dict[str, list[str]] = {
-                group_id: [] for group_id in group_ids
-            }
-
-            for group_id, user_id in members:
-                group_user_ids[group_id].append(user_id)
-
-            return group_user_ids
-
-    def set_group_user_ids_by_id(self, group_id: str, user_ids: list[str]) -> None:
-        with get_db() as db:
-            # Delete existing members
-            db.query(GroupMember).filter(GroupMember.group_id == group_id).delete()
-
-            # Insert new members
-            now = int(time.time())
-            new_members = [
-                GroupMember(
-                    id=str(uuid.uuid4()),
-                    group_id=group_id,
-                    user_id=user_id,
-                    created_at=now,
-                    updated_at=now,
-                )
-                for user_id in user_ids
-            ]
-
-            db.add_all(new_members)
-            db.commit()
-
-    def get_group_member_count_by_id(self, id: str) -> int:
-        with get_db() as db:
-            count = (
-                db.query(func.count(GroupMember.user_id))
-                .filter(GroupMember.group_id == id)
-                .scalar()
-            )
-            return count if count else 0
+    def get_group_user_ids_by_id(self, id: str) -> Optional[str]:
+        group = self.get_group_by_id(id)
+        if group:
+            return group.user_ids
+        else:
+            return None
 
     def update_group_by_id(
         self, id: str, form_data: GroupUpdateForm, overwrite: bool = False
@@ -345,29 +195,20 @@ class GroupTable:
     def remove_user_from_all_groups(self, user_id: str) -> bool:
         with get_db() as db:
             try:
-                # Find all groups the user belongs to
-                groups = (
-                    db.query(Group)
-                    .join(GroupMember, GroupMember.group_id == Group.id)
-                    .filter(GroupMember.user_id == user_id)
-                    .all()
-                )
+                groups = self.get_groups_by_member_id(user_id)
 
-                # Remove the user from each group
                 for group in groups:
-                    db.query(GroupMember).filter(
-                        GroupMember.group_id == group.id, GroupMember.user_id == user_id
-                    ).delete()
-
+                    group.user_ids.remove(user_id)
                     db.query(Group).filter_by(id=group.id).update(
-                        {"updated_at": int(time.time())}
+                        {
+                            "user_ids": group.user_ids,
+                            "updated_at": int(time.time()),
+                        }
                     )
+                    db.commit()
 
-                db.commit()
                 return True
-
             except Exception:
-                db.rollback()
                 return False
 
     def create_groups_by_group_names(
@@ -375,7 +216,7 @@ class GroupTable:
     ) -> list[GroupModel]:
 
         # check for existing groups
-        existing_groups = self.get_all_groups()
+        existing_groups = self.get_groups()
         existing_group_names = {group.name for group in existing_groups}
 
         new_groups = []
@@ -405,61 +246,37 @@ class GroupTable:
     def sync_groups_by_group_names(self, user_id: str, group_names: list[str]) -> bool:
         with get_db() as db:
             try:
-                now = int(time.time())
+                groups = db.query(Group).filter(Group.name.in_(group_names)).all()
+                group_ids = [group.id for group in groups]
 
-                # 1. Groups that SHOULD contain the user
-                target_groups = (
-                    db.query(Group).filter(Group.name.in_(group_names)).all()
-                )
-                target_group_ids = {g.id for g in target_groups}
+                # Remove user from groups not in the new list
+                existing_groups = self.get_groups_by_member_id(user_id)
 
-                # 2. Groups the user is CURRENTLY in
-                existing_group_ids = {
-                    g.id
-                    for g in db.query(Group)
-                    .join(GroupMember, GroupMember.group_id == Group.id)
-                    .filter(GroupMember.user_id == user_id)
-                    .all()
-                }
-
-                # 3. Determine adds + removals
-                groups_to_add = target_group_ids - existing_group_ids
-                groups_to_remove = existing_group_ids - target_group_ids
-
-                # 4. Remove in one bulk delete
-                if groups_to_remove:
-                    db.query(GroupMember).filter(
-                        GroupMember.user_id == user_id,
-                        GroupMember.group_id.in_(groups_to_remove),
-                    ).delete(synchronize_session=False)
-
-                    db.query(Group).filter(Group.id.in_(groups_to_remove)).update(
-                        {"updated_at": now}, synchronize_session=False
-                    )
-
-                # 5. Bulk insert missing memberships
-                for group_id in groups_to_add:
-                    db.add(
-                        GroupMember(
-                            id=str(uuid.uuid4()),
-                            group_id=group_id,
-                            user_id=user_id,
-                            created_at=now,
-                            updated_at=now,
+                for group in existing_groups:
+                    if group.id not in group_ids:
+                        group.user_ids.remove(user_id)
+                        db.query(Group).filter_by(id=group.id).update(
+                            {
+                                "user_ids": group.user_ids,
+                                "updated_at": int(time.time()),
+                            }
                         )
-                    )
 
-                if groups_to_add:
-                    db.query(Group).filter(Group.id.in_(groups_to_add)).update(
-                        {"updated_at": now}, synchronize_session=False
-                    )
+                # Add user to new groups
+                for group in groups:
+                    if user_id not in group.user_ids:
+                        group.user_ids.append(user_id)
+                        db.query(Group).filter_by(id=group.id).update(
+                            {
+                                "user_ids": group.user_ids,
+                                "updated_at": int(time.time()),
+                            }
+                        )
 
                 db.commit()
                 return True
-
             except Exception as e:
                 log.exception(e)
-                db.rollback()
                 return False
 
     def add_users_to_group(
@@ -471,31 +288,21 @@ class GroupTable:
                 if not group:
                     return None
 
-                now = int(time.time())
+                group_user_ids = group.user_ids
+                if not group_user_ids or not isinstance(group_user_ids, list):
+                    group_user_ids = []
 
-                for user_id in user_ids or []:
-                    try:
-                        db.add(
-                            GroupMember(
-                                id=str(uuid.uuid4()),
-                                group_id=id,
-                                user_id=user_id,
-                                created_at=now,
-                                updated_at=now,
-                            )
-                        )
-                        db.flush()  # Detect unique constraint violation early
-                    except Exception:
-                        db.rollback()  # Clear failed INSERT
-                        db.begin()  # Start a new transaction
-                        continue  # Duplicate → ignore
+                group_user_ids = list(set(group_user_ids))  # Deduplicate
 
-                group.updated_at = now
+                for user_id in user_ids:
+                    if user_id not in group_user_ids:
+                        group_user_ids.append(user_id)
+
+                group.user_ids = group_user_ids
+                group.updated_at = int(time.time())
                 db.commit()
                 db.refresh(group)
-
                 return GroupModel.model_validate(group)
-
         except Exception as e:
             log.exception(e)
             return None
@@ -509,22 +316,23 @@ class GroupTable:
                 if not group:
                     return None
 
-                if not user_ids:
+                group_user_ids = group.user_ids
+
+                if not group_user_ids or not isinstance(group_user_ids, list):
                     return GroupModel.model_validate(group)
 
-                # Remove each user from group_member
-                for user_id in user_ids:
-                    db.query(GroupMember).filter(
-                        GroupMember.group_id == id, GroupMember.user_id == user_id
-                    ).delete()
+                group_user_ids = list(set(group_user_ids))  # Deduplicate
 
-                # Update group timestamp
+                for user_id in user_ids:
+                    if user_id in group_user_ids:
+                        group_user_ids.remove(user_id)
+
+                group.user_ids = group_user_ids
                 group.updated_at = int(time.time())
 
                 db.commit()
                 db.refresh(group)
                 return GroupModel.model_validate(group)
-
         except Exception as e:
             log.exception(e)
             return None

backend/open_webui/models/knowledge.py

@@ -7,21 +7,13 @@ import uuid
 from open_webui.internal.db import Base, get_db
 from open_webui.env import SRC_LOG_LEVELS
 
-from open_webui.models.files import File, FileModel, FileMetadataResponse
+from open_webui.models.files import FileMetadataResponse
 from open_webui.models.groups import Groups
 from open_webui.models.users import Users, UserResponse
 
 
 from pydantic import BaseModel, ConfigDict
-from sqlalchemy import (
-    BigInteger,
-    Column,
-    ForeignKey,
-    String,
-    Text,
-    JSON,
-    UniqueConstraint,
-)
+from sqlalchemy import BigInteger, Column, String, Text, JSON
 
 from open_webui.utils.access_control import has_access
 
@@ -42,7 +34,9 @@ class Knowledge(Base):
     name = Column(Text)
     description = Column(Text)
 
+    data = Column(JSON, nullable=True)
     meta = Column(JSON, nullable=True)
+
     access_control = Column(JSON, nullable=True)  # Controls data access levels.
     # Defines access control rules for this entry.
     # - `None`: Public access, available to all users with the "user" role.
@@ -73,6 +67,7 @@ class KnowledgeModel(BaseModel):
     name: str
     description: str
 
+    data: Optional[dict] = None
     meta: Optional[dict] = None
 
     access_control: Optional[dict] = None
@@ -81,42 +76,11 @@ class KnowledgeModel(BaseModel):
     updated_at: int  # timestamp in epoch
 
 
-class KnowledgeFile(Base):
-    __tablename__ = "knowledge_file"
-
-    id = Column(Text, unique=True, primary_key=True)
-
-    knowledge_id = Column(
-        Text, ForeignKey("knowledge.id", ondelete="CASCADE"), nullable=False
-    )
-    file_id = Column(Text, ForeignKey("file.id", ondelete="CASCADE"), nullable=False)
-    user_id = Column(Text, nullable=False)
-
-    created_at = Column(BigInteger, nullable=False)
-    updated_at = Column(BigInteger, nullable=False)
-
-    __table_args__ = (
-        UniqueConstraint(
-            "knowledge_id", "file_id", name="uq_knowledge_file_knowledge_file"
-        ),
-    )
-
-
-class KnowledgeFileModel(BaseModel):
-    id: str
-    knowledge_id: str
-    file_id: str
-    user_id: str
-
-    created_at: int  # timestamp in epoch
-    updated_at: int  # timestamp in epoch
-
-    model_config = ConfigDict(from_attributes=True)
-
-
 ####################
 # Forms
 ####################
+
+
 class KnowledgeUserModel(KnowledgeModel):
     user: Optional[UserResponse] = None
 
@@ -132,6 +96,7 @@ class KnowledgeUserResponse(KnowledgeUserModel):
 class KnowledgeForm(BaseModel):
     name: str
     description: str
+    data: Optional[dict] = None
     access_control: Optional[dict] = None
 
 
@@ -217,100 +182,6 @@ class KnowledgeTable:
         except Exception:
             return None
 
-    def get_knowledges_by_file_id(self, file_id: str) -> list[KnowledgeModel]:
-        try:
-            with get_db() as db:
-                knowledges = (
-                    db.query(Knowledge)
-                    .join(KnowledgeFile, Knowledge.id == KnowledgeFile.knowledge_id)
-                    .filter(KnowledgeFile.file_id == file_id)
-                    .all()
-                )
-                return [
-                    KnowledgeModel.model_validate(knowledge) for knowledge in knowledges
-                ]
-        except Exception:
-            return []
-
-    def get_files_by_id(self, knowledge_id: str) -> list[FileModel]:
-        try:
-            with get_db() as db:
-                files = (
-                    db.query(File)
-                    .join(KnowledgeFile, File.id == KnowledgeFile.file_id)
-                    .filter(KnowledgeFile.knowledge_id == knowledge_id)
-                    .all()
-                )
-                return [FileModel.model_validate(file) for file in files]
-        except Exception:
-            return []
-
-    def get_file_metadatas_by_id(self, knowledge_id: str) -> list[FileMetadataResponse]:
-        try:
-            with get_db() as db:
-                files = self.get_files_by_id(knowledge_id)
-                return [FileMetadataResponse(**file.model_dump()) for file in files]
-        except Exception:
-            return []
-
-    def add_file_to_knowledge_by_id(
-        self, knowledge_id: str, file_id: str, user_id: str
-    ) -> Optional[KnowledgeFileModel]:
-        with get_db() as db:
-            knowledge_file = KnowledgeFileModel(
-                **{
-                    "id": str(uuid.uuid4()),
-                    "knowledge_id": knowledge_id,
-                    "file_id": file_id,
-                    "user_id": user_id,
-                    "created_at": int(time.time()),
-                    "updated_at": int(time.time()),
-                }
-            )
-
-            try:
-                result = KnowledgeFile(**knowledge_file.model_dump())
-                db.add(result)
-                db.commit()
-                db.refresh(result)
-                if result:
-                    return KnowledgeFileModel.model_validate(result)
-                else:
-                    return None
-            except Exception:
-                return None
-
-    def remove_file_from_knowledge_by_id(self, knowledge_id: str, file_id: str) -> bool:
-        try:
-            with get_db() as db:
-                db.query(KnowledgeFile).filter_by(
-                    knowledge_id=knowledge_id, file_id=file_id
-                ).delete()
-                db.commit()
-                return True
-        except Exception:
-            return False
-
-    def reset_knowledge_by_id(self, id: str) -> Optional[KnowledgeModel]:
-        try:
-            with get_db() as db:
-                # Delete all knowledge_file entries for this knowledge_id
-                db.query(KnowledgeFile).filter_by(knowledge_id=id).delete()
-                db.commit()
-
-                # Update the knowledge entry's updated_at timestamp
-                db.query(Knowledge).filter_by(id=id).update(
-                    {
-                        "updated_at": int(time.time()),
-                    }
-                )
-                db.commit()
-
-                return self.get_knowledge_by_id(id=id)
-        except Exception as e:
-            log.exception(e)
-            return None
-
     def update_knowledge_by_id(
         self, id: str, form_data: KnowledgeForm, overwrite: bool = False
     ) -> Optional[KnowledgeModel]:

backend/open_webui/models/memories.py

@@ -14,7 +14,7 @@ from sqlalchemy import BigInteger, Column, String, Text
 class Memory(Base):
     __tablename__ = "memory"
 
-    id = Column(String, primary_key=True, unique=True)
+    id = Column(String, primary_key=True)
     user_id = Column(String)
     content = Column(Text)
     updated_at = Column(BigInteger)

backend/open_webui/models/messages.py

@@ -5,8 +5,7 @@ from typing import Optional
 
 from open_webui.internal.db import Base, get_db
 from open_webui.models.tags import TagModel, Tag, Tags
-from open_webui.models.users import Users, User, UserNameResponse
-from open_webui.models.channels import Channels, ChannelMember
+from open_webui.models.users import Users, UserNameResponse
 
 
 from pydantic import BaseModel, ConfigDict
@@ -21,7 +20,7 @@ from sqlalchemy.sql import exists
 
 class MessageReaction(Base):
     __tablename__ = "message_reaction"
-    id = Column(Text, primary_key=True, unique=True)
+    id = Column(Text, primary_key=True)
     user_id = Column(Text)
     message_id = Column(Text)
     name = Column(Text)
@@ -40,7 +39,7 @@ class MessageReactionModel(BaseModel):
 
 class Message(Base):
     __tablename__ = "message"
-    id = Column(Text, primary_key=True, unique=True)
+    id = Column(Text, primary_key=True)
 
     user_id = Column(Text)
     channel_id = Column(Text, nullable=True)
@@ -48,11 +47,6 @@ class Message(Base):
     reply_to_id = Column(Text, nullable=True)
     parent_id = Column(Text, nullable=True)
 
-    # Pins
-    is_pinned = Column(Boolean, nullable=False, default=False)
-    pinned_at = Column(BigInteger, nullable=True)
-    pinned_by = Column(Text, nullable=True)
-
     content = Column(Text)
     data = Column(JSON, nullable=True)
     meta = Column(JSON, nullable=True)
@@ -71,17 +65,12 @@ class MessageModel(BaseModel):
     reply_to_id: Optional[str] = None
     parent_id: Optional[str] = None
 
-    # Pins
-    is_pinned: bool = False
-    pinned_by: Optional[str] = None
-    pinned_at: Optional[int] = None  # timestamp in epoch (time_ns)
-
     content: str
     data: Optional[dict] = None
     meta: Optional[dict] = None
 
-    created_at: int  # timestamp in epoch (time_ns)
-    updated_at: int  # timestamp in epoch (time_ns)
+    created_at: int  # timestamp in epoch
+    updated_at: int  # timestamp in epoch
 
 
 ####################
@@ -90,7 +79,6 @@ class MessageModel(BaseModel):
 
 
 class MessageForm(BaseModel):
-    temp_id: Optional[str] = None
     content: str
     reply_to_id: Optional[str] = None
     parent_id: Optional[str] = None
@@ -100,7 +88,7 @@ class MessageForm(BaseModel):
 
 class Reactions(BaseModel):
     name: str
-    users: list[dict]
+    user_ids: list[str]
     count: int
 
 
@@ -112,10 +100,6 @@ class MessageReplyToResponse(MessageUserResponse):
     reply_to_message: Optional[MessageUserResponse] = None
 
 
-class MessageWithReactionsResponse(MessageUserResponse):
-    reactions: list[Reactions]
-
-
 class MessageResponse(MessageReplyToResponse):
     latest_reply_at: Optional[int]
     reply_count: int
@@ -127,11 +111,9 @@ class MessageTable:
         self, form_data: MessageForm, channel_id: str, user_id: str
     ) -> Optional[MessageModel]:
         with get_db() as db:
-            channel_member = Channels.join_channel(channel_id, user_id)
-
             id = str(uuid.uuid4())
-            ts = int(time.time_ns())
 
+            ts = int(time.time_ns())
             message = MessageModel(
                 **{
                     "id": id,
@@ -139,9 +121,6 @@ class MessageTable:
                     "channel_id": channel_id,
                     "reply_to_id": form_data.reply_to_id,
                     "parent_id": form_data.parent_id,
-                    "is_pinned": False,
-                    "pinned_at": None,
-                    "pinned_by": None,
                     "content": form_data.content,
                     "data": form_data.data,
                     "meta": form_data.meta,
@@ -149,8 +128,8 @@ class MessageTable:
                     "updated_at": ts,
                 }
             )
-            result = Message(**message.model_dump())
 
+            result = Message(**message.model_dump())
             db.add(result)
             db.commit()
             db.refresh(result)
@@ -301,30 +280,6 @@ class MessageTable:
                 )
             return messages
 
-    def get_last_message_by_channel_id(self, channel_id: str) -> Optional[MessageModel]:
-        with get_db() as db:
-            message = (
-                db.query(Message)
-                .filter_by(channel_id=channel_id)
-                .order_by(Message.created_at.desc())
-                .first()
-            )
-            return MessageModel.model_validate(message) if message else None
-
-    def get_pinned_messages_by_channel_id(
-        self, channel_id: str, skip: int = 0, limit: int = 50
-    ) -> list[MessageModel]:
-        with get_db() as db:
-            all_messages = (
-                db.query(Message)
-                .filter_by(channel_id=channel_id, is_pinned=True)
-                .order_by(Message.pinned_at.desc())
-                .offset(skip)
-                .limit(limit)
-                .all()
-            )
-            return [MessageModel.model_validate(message) for message in all_messages]
-
     def update_message_by_id(
         self, id: str, form_data: MessageForm
     ) -> Optional[MessageModel]:
@@ -344,44 +299,10 @@ class MessageTable:
             db.refresh(message)
             return MessageModel.model_validate(message) if message else None
 
-    def update_is_pinned_by_id(
-        self, id: str, is_pinned: bool, pinned_by: Optional[str] = None
-    ) -> Optional[MessageModel]:
-        with get_db() as db:
-            message = db.get(Message, id)
-            message.is_pinned = is_pinned
-            message.pinned_at = int(time.time_ns()) if is_pinned else None
-            message.pinned_by = pinned_by if is_pinned else None
-            db.commit()
-            db.refresh(message)
-            return MessageModel.model_validate(message) if message else None
-
-    def get_unread_message_count(
-        self, channel_id: str, user_id: str, last_read_at: Optional[int] = None
-    ) -> int:
-        with get_db() as db:
-            query = db.query(Message).filter(
-                Message.channel_id == channel_id,
-                Message.parent_id == None,  # only count top-level messages
-                Message.created_at > (last_read_at if last_read_at else 0),
-            )
-            if user_id:
-                query = query.filter(Message.user_id != user_id)
-            return query.count()
-
     def add_reaction_to_message(
         self, id: str, user_id: str, name: str
     ) -> Optional[MessageReactionModel]:
         with get_db() as db:
-            # check for existing reaction
-            existing_reaction = (
-                db.query(MessageReaction)
-                .filter_by(message_id=id, user_id=user_id, name=name)
-                .first()
-            )
-            if existing_reaction:
-                return MessageReactionModel.model_validate(existing_reaction)
-
             reaction_id = str(uuid.uuid4())
             reaction = MessageReactionModel(
                 id=reaction_id,
@@ -398,30 +319,17 @@ class MessageTable:
 
     def get_reactions_by_message_id(self, id: str) -> list[Reactions]:
         with get_db() as db:
-            # JOIN User so all user info is fetched in one query
-            results = (
-                db.query(MessageReaction, User)
-                .join(User, MessageReaction.user_id == User.id)
-                .filter(MessageReaction.message_id == id)
-                .all()
-            )
+            all_reactions = db.query(MessageReaction).filter_by(message_id=id).all()
 
             reactions = {}
-
-            for reaction, user in results:
+            for reaction in all_reactions:
                 if reaction.name not in reactions:
                     reactions[reaction.name] = {
                         "name": reaction.name,
-                        "users": [],
+                        "user_ids": [],
                         "count": 0,
                     }
-
-                reactions[reaction.name]["users"].append(
-                    {
-                        "id": user.id,
-                        "name": user.name,
-                    }
-                )
+                reactions[reaction.name]["user_ids"].append(reaction.user_id)
                 reactions[reaction.name]["count"] += 1
 
             return [Reactions(**reaction) for reaction in reactions.values()]

backend/open_webui/models/models.py

@@ -6,15 +6,13 @@ from open_webui.internal.db import Base, JSONField, get_db
 from open_webui.env import SRC_LOG_LEVELS
 
 from open_webui.models.groups import Groups
-from open_webui.models.users import User, UserModel, Users, UserResponse
+from open_webui.models.users import Users, UserResponse
 
 
 from pydantic import BaseModel, ConfigDict
 
-from sqlalchemy import String, cast, or_, and_, func
+from sqlalchemy import or_, and_, func
 from sqlalchemy.dialects import postgresql, sqlite
-
-from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy import BigInteger, Column, Text, JSON, Boolean
 
 
@@ -55,7 +53,7 @@ class ModelMeta(BaseModel):
 class Model(Base):
     __tablename__ = "model"
 
-    id = Column(Text, primary_key=True, unique=True)
+    id = Column(Text, primary_key=True)
     """
         The model's id as used in the API. If set to an existing model, it will override the model.
     """
@@ -135,11 +133,6 @@ class ModelResponse(ModelModel):
     pass
 
 
-class ModelListResponse(BaseModel):
-    items: list[ModelUserResponse]
-    total: int
-
-
 class ModelForm(BaseModel):
     id: str
     base_model_id: Optional[str] = None
@@ -222,135 +215,6 @@ class ModelsTable:
             or has_access(user_id, permission, model.access_control, user_group_ids)
         ]
 
-    def _has_permission(self, db, query, filter: dict, permission: str = "read"):
-        group_ids = filter.get("group_ids", [])
-        user_id = filter.get("user_id")
-
-        dialect_name = db.bind.dialect.name
-
-        # Public access
-        conditions = []
-        if group_ids or user_id:
-            conditions.extend(
-                [
-                    Model.access_control.is_(None),
-                    cast(Model.access_control, String) == "null",
-                ]
-            )
-
-        # User-level permission
-        if user_id:
-            conditions.append(Model.user_id == user_id)
-
-        # Group-level permission
-        if group_ids:
-            group_conditions = []
-            for gid in group_ids:
-                if dialect_name == "sqlite":
-                    group_conditions.append(
-                        Model.access_control[permission]["group_ids"].contains([gid])
-                    )
-                elif dialect_name == "postgresql":
-                    group_conditions.append(
-                        cast(
-                            Model.access_control[permission]["group_ids"],
-                            JSONB,
-                        ).contains([gid])
-                    )
-            conditions.append(or_(*group_conditions))
-
-        if conditions:
-            query = query.filter(or_(*conditions))
-
-        return query
-
-    def search_models(
-        self, user_id: str, filter: dict = {}, skip: int = 0, limit: int = 30
-    ) -> ModelListResponse:
-        with get_db() as db:
-            # Join GroupMember so we can order by group_id when requested
-            query = db.query(Model, User).outerjoin(User, User.id == Model.user_id)
-            query = query.filter(Model.base_model_id != None)
-
-            if filter:
-                query_key = filter.get("query")
-                if query_key:
-                    query = query.filter(
-                        or_(
-                            Model.name.ilike(f"%{query_key}%"),
-                            Model.base_model_id.ilike(f"%{query_key}%"),
-                        )
-                    )
-
-                view_option = filter.get("view_option")
-                if view_option == "created":
-                    query = query.filter(Model.user_id == user_id)
-                elif view_option == "shared":
-                    query = query.filter(Model.user_id != user_id)
-
-                # Apply access control filtering
-                query = self._has_permission(
-                    db,
-                    query,
-                    filter,
-                    permission="write",
-                )
-
-                tag = filter.get("tag")
-                if tag:
-                    # TODO: This is a simple implementation and should be improved for performance
-                    like_pattern = f'%"{tag.lower()}"%'  # `"tag"` inside JSON array
-                    meta_text = func.lower(cast(Model.meta, String))
-
-                    query = query.filter(meta_text.like(like_pattern))
-
-                order_by = filter.get("order_by")
-                direction = filter.get("direction")
-
-                if order_by == "name":
-                    if direction == "asc":
-                        query = query.order_by(Model.name.asc())
-                    else:
-                        query = query.order_by(Model.name.desc())
-                elif order_by == "created_at":
-                    if direction == "asc":
-                        query = query.order_by(Model.created_at.asc())
-                    else:
-                        query = query.order_by(Model.created_at.desc())
-                elif order_by == "updated_at":
-                    if direction == "asc":
-                        query = query.order_by(Model.updated_at.asc())
-                    else:
-                        query = query.order_by(Model.updated_at.desc())
-
-            else:
-                query = query.order_by(Model.created_at.desc())
-
-            # Count BEFORE pagination
-            total = query.count()
-
-            if skip:
-                query = query.offset(skip)
-            if limit:
-                query = query.limit(limit)
-
-            items = query.all()
-
-            models = []
-            for model, user in items:
-                models.append(
-                    ModelUserResponse(
-                        **ModelModel.model_validate(model).model_dump(),
-                        user=(
-                            UserResponse(**UserModel.model_validate(user).model_dump())
-                            if user
-                            else None
-                        ),
-                    )
-                )
-
-            return ModelListResponse(items=models, total=total)
-
     def get_model_by_id(self, id: str) -> Optional[ModelModel]:
         try:
             with get_db() as db:
@@ -380,9 +244,11 @@ class ModelsTable:
         try:
             with get_db() as db:
                 # update only the fields that are present in the model
-                data = model.model_dump(exclude={"id"})
-                result = db.query(Model).filter_by(id=id).update(data)
-
+                result = (
+                    db.query(Model)
+                    .filter_by(id=id)
+                    .update(model.model_dump(exclude={"id"}))
+                )
                 db.commit()
 
                 model = db.get(Model, id)

backend/open_webui/models/notes.py

@@ -23,7 +23,7 @@ from sqlalchemy.sql import exists
 class Note(Base):
     __tablename__ = "note"
 
-    id = Column(Text, primary_key=True, unique=True)
+    id = Column(Text, primary_key=True)
     user_id = Column(Text)
 
     title = Column(Text)

backend/open_webui/models/oauth_sessions.py

@@ -25,7 +25,7 @@ log.setLevel(SRC_LOG_LEVELS["MODELS"])
 class OAuthSession(Base):
     __tablename__ = "oauth_session"
 
-    id = Column(Text, primary_key=True, unique=True)
+    id = Column(Text, primary_key=True)
     user_id = Column(Text, nullable=False)
     provider = Column(Text, nullable=False)
     token = Column(
@@ -262,16 +262,5 @@ class OAuthSessionTable:
             log.error(f"Error deleting OAuth sessions by user ID: {e}")
             return False
 
-    def delete_sessions_by_provider(self, provider: str) -> bool:
-        """Delete all OAuth sessions for a provider"""
-        try:
-            with get_db() as db:
-                db.query(OAuthSession).filter_by(provider=provider).delete()
-                db.commit()
-                return True
-        except Exception as e:
-            log.error(f"Error deleting OAuth sessions by provider {provider}: {e}")
-            return False
-
 
 OAuthSessions = OAuthSessionTable()

backend/open_webui/models/tools.py

@@ -24,7 +24,7 @@ log.setLevel(SRC_LOG_LEVELS["MODELS"])
 class Tool(Base):
     __tablename__ = "tool"
 
-    id = Column(String, primary_key=True, unique=True)
+    id = Column(String, primary_key=True)
     user_id = Column(String)
     name = Column(Text)
     content = Column(Text)

backend/open_webui/models/users.py

@@ -6,28 +6,13 @@ from open_webui.internal.db import Base, JSONField, get_db
 
 from open_webui.env import DATABASE_USER_ACTIVE_STATUS_UPDATE_INTERVAL
 from open_webui.models.chats import Chats
-from open_webui.models.groups import Groups, GroupMember
-from open_webui.models.channels import ChannelMember
-
-
+from open_webui.models.groups import Groups
 from open_webui.utils.misc import throttle
 
 
 from pydantic import BaseModel, ConfigDict
-from sqlalchemy import (
-    BigInteger,
-    JSON,
-    Column,
-    String,
-    Boolean,
-    Text,
-    Date,
-    exists,
-    select,
-    cast,
-)
-from sqlalchemy import or_, case
-from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy import BigInteger, Column, String, Text, Date
+from sqlalchemy import or_
 
 import datetime
 
@@ -36,71 +21,59 @@ import datetime
 ####################
 
 
+class User(Base):
+    __tablename__ = "user"
+
+    id = Column(String, primary_key=True)
+    name = Column(String)
+
+    email = Column(String)
+    username = Column(String(50), nullable=True)
+
+    role = Column(String)
+    profile_image_url = Column(Text)
+
+    bio = Column(Text, nullable=True)
+    gender = Column(Text, nullable=True)
+    date_of_birth = Column(Date, nullable=True)
+
+    info = Column(JSONField, nullable=True)
+    settings = Column(JSONField, nullable=True)
+
+    api_key = Column(String, nullable=True, unique=True)
+    oauth_sub = Column(Text, unique=True)
+
+    last_active_at = Column(BigInteger)
+
+    updated_at = Column(BigInteger)
+    created_at = Column(BigInteger)
+
+
 class UserSettings(BaseModel):
     ui: Optional[dict] = {}
     model_config = ConfigDict(extra="allow")
     pass
 
 
-class User(Base):
-    __tablename__ = "user"
-
-    id = Column(String, primary_key=True, unique=True)
-    email = Column(String)
-    username = Column(String(50), nullable=True)
-    role = Column(String)
-
-    name = Column(String)
-
-    profile_image_url = Column(Text)
-    profile_banner_image_url = Column(Text, nullable=True)
-
-    bio = Column(Text, nullable=True)
-    gender = Column(Text, nullable=True)
-    date_of_birth = Column(Date, nullable=True)
-    timezone = Column(String, nullable=True)
-
-    presence_state = Column(String, nullable=True)
-    status_emoji = Column(String, nullable=True)
-    status_message = Column(Text, nullable=True)
-    status_expires_at = Column(BigInteger, nullable=True)
-
-    info = Column(JSON, nullable=True)
-    settings = Column(JSON, nullable=True)
-
-    oauth = Column(JSON, nullable=True)
-
-    last_active_at = Column(BigInteger)
-    updated_at = Column(BigInteger)
-    created_at = Column(BigInteger)
-
-
 class UserModel(BaseModel):
     id: str
+    name: str
 
     email: str
     username: Optional[str] = None
+
     role: str = "pending"
-
-    name: str
-
     profile_image_url: str
-    profile_banner_image_url: Optional[str] = None
 
     bio: Optional[str] = None
     gender: Optional[str] = None
     date_of_birth: Optional[datetime.date] = None
-    timezone: Optional[str] = None
-
-    presence_state: Optional[str] = None
-    status_emoji: Optional[str] = None
-    status_message: Optional[str] = None
-    status_expires_at: Optional[int] = None
 
     info: Optional[dict] = None
     settings: Optional[UserSettings] = None
 
-    oauth: Optional[dict] = None
+    api_key: Optional[str] = None
+    oauth_sub: Optional[str] = None
 
     last_active_at: int  # timestamp in epoch
     updated_at: int  # timestamp in epoch
@@ -109,38 +82,6 @@ class UserModel(BaseModel):
     model_config = ConfigDict(from_attributes=True)
 
 
-class UserStatusModel(UserModel):
-    is_active: bool = False
-
-    model_config = ConfigDict(from_attributes=True)
-
-
-class ApiKey(Base):
-    __tablename__ = "api_key"
-
-    id = Column(Text, primary_key=True, unique=True)
-    user_id = Column(Text, nullable=False)
-    key = Column(Text, unique=True, nullable=False)
-    data = Column(JSON, nullable=True)
-    expires_at = Column(BigInteger, nullable=True)
-    last_used_at = Column(BigInteger, nullable=True)
-    created_at = Column(BigInteger, nullable=False)
-    updated_at = Column(BigInteger, nullable=False)
-
-
-class ApiKeyModel(BaseModel):
-    id: str
-    user_id: str
-    key: str
-    data: Optional[dict] = None
-    expires_at: Optional[int] = None
-    last_used_at: Optional[int] = None
-    created_at: int  # timestamp in epoch
-    updated_at: int  # timestamp in epoch
-
-    model_config = ConfigDict(from_attributes=True)
-
-
 ####################
 # Forms
 ####################
@@ -154,31 +95,12 @@ class UpdateProfileForm(BaseModel):
     date_of_birth: Optional[datetime.date] = None
 
 
-class UserGroupIdsModel(UserModel):
-    group_ids: list[str] = []
-
-
-class UserModelResponse(UserModel):
-    model_config = ConfigDict(extra="allow")
-
-
 class UserListResponse(BaseModel):
-    users: list[UserModelResponse]
+    users: list[UserModel]
     total: int
 
 
-class UserGroupIdsListResponse(BaseModel):
-    users: list[UserGroupIdsModel]
-    total: int
-
-
-class UserStatus(BaseModel):
-    status_emoji: Optional[str] = None
-    status_message: Optional[str] = None
-    status_expires_at: Optional[int] = None
-
-
-class UserInfoResponse(UserStatus):
+class UserInfoResponse(BaseModel):
     id: str
     name: str
     email: str
@@ -190,12 +112,6 @@ class UserIdNameResponse(BaseModel):
     name: str
 
 
-class UserIdNameStatusResponse(UserStatus):
-    id: str
-    name: str
-    is_active: Optional[bool] = None
-
-
 class UserInfoListResponse(BaseModel):
     users: list[UserInfoResponse]
     total: int
@@ -206,18 +122,18 @@ class UserIdNameListResponse(BaseModel):
     total: int
 
 
+class UserResponse(BaseModel):
+    id: str
+    name: str
+    email: str
+    role: str
+    profile_image_url: str
+
+
 class UserNameResponse(BaseModel):
     id: str
     name: str
     role: str
-
-
-class UserResponse(UserNameResponse):
-    email: str
-
-
-class UserProfileImageResponse(UserNameResponse):
-    email: str
     profile_image_url: str
 
 
@@ -242,20 +158,20 @@ class UsersTable:
         email: str,
         profile_image_url: str = "/user.png",
         role: str = "pending",
-        oauth: Optional[dict] = None,
+        oauth_sub: Optional[str] = None,
     ) -> Optional[UserModel]:
         with get_db() as db:
             user = UserModel(
                 **{
                     "id": id,
-                    "email": email,
                     "name": name,
+                    "email": email,
                     "role": role,
                     "profile_image_url": profile_image_url,
                     "last_active_at": int(time.time()),
                     "created_at": int(time.time()),
                     "updated_at": int(time.time()),
-                    "oauth": oauth,
+                    "oauth_sub": oauth_sub,
                 }
             )
             result = User(**user.model_dump())
@@ -278,13 +194,8 @@ class UsersTable:
     def get_user_by_api_key(self, api_key: str) -> Optional[UserModel]:
         try:
             with get_db() as db:
-                user = (
-                    db.query(User)
-                    .join(ApiKey, User.id == ApiKey.user_id)
-                    .filter(ApiKey.key == api_key)
-                    .first()
-                )
-                return UserModel.model_validate(user) if user else None
+                user = db.query(User).filter_by(api_key=api_key).first()
+                return UserModel.model_validate(user)
         except Exception:
             return None
 
@@ -296,23 +207,12 @@ class UsersTable:
         except Exception:
             return None
 
-    def get_user_by_oauth_sub(self, provider: str, sub: str) -> Optional[UserModel]:
+    def get_user_by_oauth_sub(self, sub: str) -> Optional[UserModel]:
         try:
-            with get_db() as db:  # type: Session
-                dialect_name = db.bind.dialect.name
-
-                query = db.query(User)
-                if dialect_name == "sqlite":
-                    query = query.filter(User.oauth.contains({provider: {"sub": sub}}))
-                elif dialect_name == "postgresql":
-                    query = query.filter(
-                        User.oauth[provider].cast(JSONB)["sub"].astext == sub
-                    )
-
-                user = query.first()
-                return UserModel.model_validate(user) if user else None
-        except Exception as e:
-            # You may want to log the exception here
+            with get_db() as db:
+                user = db.query(User).filter_by(oauth_sub=sub).first()
+                return UserModel.model_validate(user)
+        except Exception:
             return None
 
     def get_users(
@@ -322,7 +222,6 @@ class UsersTable:
         limit: Optional[int] = None,
     ) -> dict:
         with get_db() as db:
-            # Join GroupMember so we can order by group_id when requested
             query = db.query(User)
 
             if filter:
@@ -335,76 +234,14 @@ class UsersTable:
                         )
                     )
 
-                channel_id = filter.get("channel_id")
-                if channel_id:
-                    query = query.filter(
-                        exists(
-                            select(ChannelMember.id).where(
-                                ChannelMember.user_id == User.id,
-                                ChannelMember.channel_id == channel_id,
-                            )
-                        )
-                    )
-
-                user_ids = filter.get("user_ids")
-                group_ids = filter.get("group_ids")
-
-                if isinstance(user_ids, list) and isinstance(group_ids, list):
-                    # If both are empty lists, return no users
-                    if not user_ids and not group_ids:
-                        return {"users": [], "total": 0}
-
-                if user_ids:
-                    query = query.filter(User.id.in_(user_ids))
-
-                if group_ids:
-                    query = query.filter(
-                        exists(
-                            select(GroupMember.id).where(
-                                GroupMember.user_id == User.id,
-                                GroupMember.group_id.in_(group_ids),
-                            )
-                        )
-                    )
-
-                roles = filter.get("roles")
-                if roles:
-                    include_roles = [role for role in roles if not role.startswith("!")]
-                    exclude_roles = [role[1:] for role in roles if role.startswith("!")]
-
-                    if include_roles:
-                        query = query.filter(User.role.in_(include_roles))
-                    if exclude_roles:
-                        query = query.filter(~User.role.in_(exclude_roles))
-
                 order_by = filter.get("order_by")
                 direction = filter.get("direction")
 
-                if order_by and order_by.startswith("group_id:"):
-                    group_id = order_by.split(":", 1)[1]
-
-                    # Subquery that checks if the user belongs to the group
-                    membership_exists = exists(
-                        select(GroupMember.id).where(
-                            GroupMember.user_id == User.id,
-                            GroupMember.group_id == group_id,
-                        )
-                    )
-
-                    # CASE: user in group → 1, user not in group → 0
-                    group_sort = case((membership_exists, 1), else_=0)
-
-                    if direction == "asc":
-                        query = query.order_by(group_sort.asc(), User.name.asc())
-                    else:
-                        query = query.order_by(group_sort.desc(), User.name.asc())
-
-                elif order_by == "name":
+                if order_by == "name":
                     if direction == "asc":
                         query = query.order_by(User.name.asc())
                     else:
                         query = query.order_by(User.name.desc())
-
                 elif order_by == "email":
                     if direction == "asc":
                         query = query.order_by(User.email.asc())
@@ -437,32 +274,18 @@ class UsersTable:
             else:
                 query = query.order_by(User.created_at.desc())
 
-            # Count BEFORE pagination
-            total = query.count()
-
-            # correct pagination logic
-            if skip is not None:
+            if skip:
                 query = query.offset(skip)
-            if limit is not None:
+            if limit:
                 query = query.limit(limit)
 
             users = query.all()
             return {
                 "users": [UserModel.model_validate(user) for user in users],
-                "total": total,
+                "total": db.query(User).count(),
             }
 
-    def get_users_by_group_id(self, group_id: str) -> list[UserModel]:
-        with get_db() as db:
-            users = (
-                db.query(User)
-                .join(GroupMember, User.id == GroupMember.user_id)
-                .filter(GroupMember.group_id == group_id)
-                .all()
-            )
-            return [UserModel.model_validate(user) for user in users]
-
-    def get_users_by_user_ids(self, user_ids: list[str]) -> list[UserStatusModel]:
+    def get_users_by_user_ids(self, user_ids: list[str]) -> list[UserModel]:
         with get_db() as db:
             users = db.query(User).filter(User.id.in_(user_ids)).all()
             return [UserModel.model_validate(user) for user in users]
@@ -499,15 +322,6 @@ class UsersTable:
         except Exception:
             return None
 
-    def get_num_users_active_today(self) -> Optional[int]:
-        with get_db() as db:
-            current_timestamp = int(datetime.datetime.now().timestamp())
-            today_midnight_timestamp = current_timestamp - (current_timestamp % 86400)
-            query = db.query(User).filter(
-                User.last_active_at > today_midnight_timestamp
-            )
-            return query.count()
-
     def update_user_role_by_id(self, id: str, role: str) -> Optional[UserModel]:
         try:
             with get_db() as db:
@@ -518,21 +332,6 @@ class UsersTable:
         except Exception:
             return None
 
-    def update_user_status_by_id(
-        self, id: str, form_data: UserStatus
-    ) -> Optional[UserModel]:
-        try:
-            with get_db() as db:
-                db.query(User).filter_by(id=id).update(
-                    {**form_data.model_dump(exclude_none=True)}
-                )
-                db.commit()
-
-                user = db.query(User).filter_by(id=id).first()
-                return UserModel.model_validate(user)
-        except Exception:
-            return None
-
     def update_user_profile_image_url_by_id(
         self, id: str, profile_image_url: str
     ) -> Optional[UserModel]:
@@ -549,7 +348,7 @@ class UsersTable:
             return None
 
     @throttle(DATABASE_USER_ACTIVE_STATUS_UPDATE_INTERVAL)
-    def update_last_active_by_id(self, id: str) -> Optional[UserModel]:
+    def update_user_last_active_by_id(self, id: str) -> Optional[UserModel]:
         try:
             with get_db() as db:
                 db.query(User).filter_by(id=id).update(
@@ -562,35 +361,16 @@ class UsersTable:
         except Exception:
             return None
 
-    def update_user_oauth_by_id(
-        self, id: str, provider: str, sub: str
+    def update_user_oauth_sub_by_id(
+        self, id: str, oauth_sub: str
     ) -> Optional[UserModel]:
-        """
-        Update or insert an OAuth provider/sub pair into the user's oauth JSON field.
-        Example resulting structure:
-            {
-                "google": { "sub": "123" },
-                "github": { "sub": "abc" }
-            }
-        """
         try:
             with get_db() as db:
-                user = db.query(User).filter_by(id=id).first()
-                if not user:
-                    return None
-
-                # Load existing oauth JSON or create empty
-                oauth = user.oauth or {}
-
-                # Update or insert provider entry
-                oauth[provider] = {"sub": sub}
-
-                # Persist updated JSON
-                db.query(User).filter_by(id=id).update({"oauth": oauth})
+                db.query(User).filter_by(id=id).update({"oauth_sub": oauth_sub})
                 db.commit()
 
+                user = db.query(User).filter_by(id=id).first()
                 return UserModel.model_validate(user)
-
         except Exception:
             return None
 
@@ -644,44 +424,22 @@ class UsersTable:
         except Exception:
             return False
 
-    def get_user_api_key_by_id(self, id: str) -> Optional[str]:
-        try:
-            with get_db() as db:
-                api_key = db.query(ApiKey).filter_by(user_id=id).first()
-                return api_key.key if api_key else None
-        except Exception:
-            return None
-
     def update_user_api_key_by_id(self, id: str, api_key: str) -> bool:
         try:
             with get_db() as db:
-                db.query(ApiKey).filter_by(user_id=id).delete()
+                result = db.query(User).filter_by(id=id).update({"api_key": api_key})
                 db.commit()
-
-                now = int(time.time())
-                new_api_key = ApiKey(
-                    id=f"key_{id}",
-                    user_id=id,
-                    key=api_key,
-                    created_at=now,
-                    updated_at=now,
-                )
-                db.add(new_api_key)
-                db.commit()
-
-                return True
-
+                return True if result == 1 else False
         except Exception:
             return False
 
-    def delete_user_api_key_by_id(self, id: str) -> bool:
+    def get_user_api_key_by_id(self, id: str) -> Optional[str]:
         try:
             with get_db() as db:
-                db.query(ApiKey).filter_by(user_id=id).delete()
-                db.commit()
-                return True
+                user = db.query(User).filter_by(id=id).first()
+                return user.api_key
         except Exception:
-            return False
+            return None
 
     def get_valid_user_ids(self, user_ids: list[str]) -> list[str]:
         with get_db() as db:
@@ -696,23 +454,5 @@ class UsersTable:
             else:
                 return None
 
-    def get_active_user_count(self) -> int:
-        with get_db() as db:
-            # Consider user active if last_active_at within the last 3 minutes
-            three_minutes_ago = int(time.time()) - 180
-            count = (
-                db.query(User).filter(User.last_active_at >= three_minutes_ago).count()
-            )
-            return count
-
-    def is_user_active(self, user_id: str) -> bool:
-        with get_db() as db:
-            user = db.query(User).filter_by(id=user_id).first()
-            if user and user.last_active_at:
-                # Consider user active if last_active_at within the last 3 minutes
-                three_minutes_ago = int(time.time()) - 180
-                return user.last_active_at >= three_minutes_ago
-            return False
-
 
 Users = UsersTable()

backend/open_webui/retrieval/loaders/external_document.py

@@ -5,7 +5,6 @@ from urllib.parse import quote
 
 from langchain_core.document_loaders import BaseLoader
 from langchain_core.documents import Document
-from open_webui.utils.headers import include_user_info_headers
 from open_webui.env import SRC_LOG_LEVELS
 
 log = logging.getLogger(__name__)
@@ -19,7 +18,6 @@ class ExternalDocumentLoader(BaseLoader):
         url: str,
         api_key: str,
         mime_type=None,
-        user=None,
         **kwargs,
     ) -> None:
         self.url = url
@@ -28,8 +26,6 @@ class ExternalDocumentLoader(BaseLoader):
         self.file_path = file_path
         self.mime_type = mime_type
 
-        self.user = user
-
     def load(self) -> List[Document]:
         with open(self.file_path, "rb") as f:
             data = f.read()
@@ -46,9 +42,6 @@ class ExternalDocumentLoader(BaseLoader):
         except:
             pass
 
-        if self.user is not None:
-            headers = include_user_info_headers(headers, self.user)
-
         url = self.url
         if url.endswith("/"):
             url = url[:-1]

backend/open_webui/retrieval/loaders/main.py

@@ -132,9 +132,8 @@ class TikaLoader:
 
 
 class DoclingLoader:
-    def __init__(self, url, api_key=None, file_path=None, mime_type=None, params=None):
+    def __init__(self, url, file_path=None, mime_type=None, params=None):
         self.url = url.rstrip("/")
-        self.api_key = api_key
         self.file_path = file_path
         self.mime_type = mime_type
 
@@ -142,10 +141,6 @@ class DoclingLoader:
 
     def load(self) -> list[Document]:
         with open(self.file_path, "rb") as f:
-            headers = {}
-            if self.api_key:
-                headers["Authorization"] = f"Bearer {self.api_key}"
-
             files = {
                 "files": (
                     self.file_path,
@@ -154,15 +149,60 @@ class DoclingLoader:
                 )
             }
 
-            r = requests.post(
-                f"{self.url}/v1/convert/file",
-                files=files,
-                data={
-                    "image_export_mode": "placeholder",
-                    **self.params,
-                },
-                headers=headers,
-            )
+            params = {"image_export_mode": "placeholder"}
+
+            if self.params:
+                if self.params.get("do_picture_description"):
+                    params["do_picture_description"] = self.params.get(
+                        "do_picture_description"
+                    )
+
+                    picture_description_mode = self.params.get(
+                        "picture_description_mode", ""
+                    ).lower()
+
+                    if picture_description_mode == "local" and self.params.get(
+                        "picture_description_local", {}
+                    ):
+                        params["picture_description_local"] = json.dumps(
+                            self.params.get("picture_description_local", {})
+                        )
+
+                    elif picture_description_mode == "api" and self.params.get(
+                        "picture_description_api", {}
+                    ):
+                        params["picture_description_api"] = json.dumps(
+                            self.params.get("picture_description_api", {})
+                        )
+
+                params["do_ocr"] = self.params.get("do_ocr")
+
+                params["force_ocr"] = self.params.get("force_ocr")
+
+                if (
+                    self.params.get("do_ocr")
+                    and self.params.get("ocr_engine")
+                    and self.params.get("ocr_lang")
+                ):
+                    params["ocr_engine"] = self.params.get("ocr_engine")
+                    params["ocr_lang"] = [
+                        lang.strip()
+                        for lang in self.params.get("ocr_lang").split(",")
+                        if lang.strip()
+                    ]
+
+                if self.params.get("pdf_backend"):
+                    params["pdf_backend"] = self.params.get("pdf_backend")
+
+                if self.params.get("table_mode"):
+                    params["table_mode"] = self.params.get("table_mode")
+
+                if self.params.get("pipeline"):
+                    params["pipeline"] = self.params.get("pipeline")
+
+            endpoint = f"{self.url}/v1/convert/file"
+            r = requests.post(endpoint, files=files, data=params)
+
         if r.ok:
             result = r.json()
             document_data = result.get("document", {})
@@ -171,6 +211,7 @@ class DoclingLoader:
             metadata = {"Content-Type": self.mime_type} if self.mime_type else {}
 
             log.debug("Docling extracted text: %s", text)
+
             return [Document(page_content=text, metadata=metadata)]
         else:
             error_msg = f"Error calling Docling API: {r.reason}"
@@ -187,7 +228,6 @@ class DoclingLoader:
 class Loader:
     def __init__(self, engine: str = "", **kwargs):
         self.engine = engine
-        self.user = kwargs.get("user", None)
         self.kwargs = kwargs
 
     def load(
@@ -224,7 +264,6 @@ class Loader:
                 url=self.kwargs.get("EXTERNAL_DOCUMENT_LOADER_URL"),
                 api_key=self.kwargs.get("EXTERNAL_DOCUMENT_LOADER_API_KEY"),
                 mime_type=file_content_type,
-                user=self.user,
             )
         elif self.engine == "tika" and self.kwargs.get("TIKA_SERVER_URL"):
             if self._is_text_file(file_ext, file_content_type):
@@ -233,6 +272,7 @@ class Loader:
                 loader = TikaLoader(
                     url=self.kwargs.get("TIKA_SERVER_URL"),
                     file_path=file_path,
+                    mime_type=file_content_type,
                     extract_images=self.kwargs.get("PDF_EXTRACT_IMAGES"),
                 )
         elif (
@@ -299,7 +339,6 @@ class Loader:
 
                 loader = DoclingLoader(
                     url=self.kwargs.get("DOCLING_SERVER_URL"),
-                    api_key=self.kwargs.get("DOCLING_API_KEY", None),
                     file_path=file_path,
                     mime_type=file_content_type,
                     params=params,
@@ -322,18 +361,22 @@ class Loader:
                     file_path=file_path,
                     api_endpoint=self.kwargs.get("DOCUMENT_INTELLIGENCE_ENDPOINT"),
                     api_key=self.kwargs.get("DOCUMENT_INTELLIGENCE_KEY"),
-                    api_model=self.kwargs.get("DOCUMENT_INTELLIGENCE_MODEL"),
                 )
             else:
                 loader = AzureAIDocumentIntelligenceLoader(
                     file_path=file_path,
                     api_endpoint=self.kwargs.get("DOCUMENT_INTELLIGENCE_ENDPOINT"),
                     azure_credential=DefaultAzureCredential(),
-                    api_model=self.kwargs.get("DOCUMENT_INTELLIGENCE_MODEL"),
                 )
         elif self.engine == "mineru" and file_ext in [
-            "pdf"
-        ]:  # MinerU currently only supports PDF
+            "pdf",
+            "doc",
+            "docx",
+            "ppt",
+            "pptx",
+            "xls",
+            "xlsx",
+        ]:
             loader = MinerULoader(
                 file_path=file_path,
                 api_mode=self.kwargs.get("MINERU_API_MODE", "local"),
@@ -348,9 +391,16 @@ class Loader:
             in ["pdf"]  # Mistral OCR currently only supports PDF and images
         ):
             loader = MistralLoader(
-                base_url=self.kwargs.get("MISTRAL_OCR_API_BASE_URL"),
-                api_key=self.kwargs.get("MISTRAL_OCR_API_KEY"),
-                file_path=file_path,
+                api_key=self.kwargs.get("MISTRAL_OCR_API_KEY"), file_path=file_path
+            )
+        elif (
+            self.engine == "external"
+            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_path=file_path
             )
         else:
             if file_ext == "pdf":

backend/open_webui/retrieval/loaders/mineru.py

@@ -33,14 +33,13 @@ class MinerULoader:
         self.api_key = api_key
 
         # Parse params dict with defaults
-        self.params = params or {}
+        params = params or {}
         self.enable_ocr = params.get("enable_ocr", False)
         self.enable_formula = params.get("enable_formula", True)
         self.enable_table = params.get("enable_table", True)
         self.language = params.get("language", "en")
         self.model_version = params.get("model_version", "pipeline")
-
-        self.page_ranges = self.params.pop("page_ranges", "")
+        self.page_ranges = params.get("page_ranges", "")
 
         # Validate API mode
         if self.api_mode not in ["local", "cloud"]:
@@ -77,10 +76,27 @@ class MinerULoader:
 
         # Build form data for Local API
         form_data = {
-            **self.params,
             "return_md": "true",
+            "formula_enable": str(self.enable_formula).lower(),
+            "table_enable": str(self.enable_table).lower(),
         }
 
+        # Parse method based on OCR setting
+        if self.enable_ocr:
+            form_data["parse_method"] = "ocr"
+        else:
+            form_data["parse_method"] = "auto"
+
+        # Language configuration (Local API uses lang_list array)
+        if self.language:
+            form_data["lang_list"] = self.language
+
+        # Backend/model version (Local API uses "backend" parameter)
+        if self.model_version == "vlm":
+            form_data["backend"] = "vlm-vllm-engine"
+        else:
+            form_data["backend"] = "pipeline"
+
         # Page ranges (Local API uses start_page_id and end_page_id)
         if self.page_ranges:
             # For simplicity, if page_ranges is specified, log a warning
@@ -220,7 +236,10 @@ class MinerULoader:
 
         # Build request body
         request_body = {
-            **self.params,
+            "enable_formula": self.enable_formula,
+            "enable_table": self.enable_table,
+            "language": self.language,
+            "model_version": self.model_version,
             "files": [
                 {
                     "name": filename,

backend/open_webui/retrieval/loaders/mistral.py

@@ -30,9 +30,10 @@ class MistralLoader:
     - Enhanced error handling with retryable error classification
     """
 
+    BASE_API_URL = "https://api.mistral.ai/v1"
+
     def __init__(
         self,
-        base_url: str,
         api_key: str,
         file_path: str,
         timeout: int = 300,  # 5 minutes default
@@ -54,9 +55,6 @@ class MistralLoader:
         if not os.path.exists(file_path):
             raise FileNotFoundError(f"File not found at {file_path}")
 
-        self.base_url = (
-            base_url.rstrip("/") if base_url else "https://api.mistral.ai/v1"
-        )
         self.api_key = api_key
         self.file_path = file_path
         self.timeout = timeout
@@ -242,7 +240,7 @@ class MistralLoader:
         in a context manager to minimize memory usage duration.
         """
         log.info("Uploading file to Mistral API")
-        url = f"{self.base_url}/files"
+        url = f"{self.BASE_API_URL}/files"
 
         def upload_request():
             # MEMORY OPTIMIZATION: Use context manager to minimize file handle lifetime
@@ -277,7 +275,7 @@ class MistralLoader:
 
     async def _upload_file_async(self, session: aiohttp.ClientSession) -> str:
         """Async file upload with streaming for better memory efficiency."""
-        url = f"{self.base_url}/files"
+        url = f"{self.BASE_API_URL}/files"
 
         async def upload_request():
             # Create multipart writer for streaming upload
@@ -323,7 +321,7 @@ class MistralLoader:
     def _get_signed_url(self, file_id: str) -> str:
         """Retrieves a temporary signed URL for the uploaded file (sync version)."""
         log.info(f"Getting signed URL for file ID: {file_id}")
-        url = f"{self.base_url}/files/{file_id}/url"
+        url = f"{self.BASE_API_URL}/files/{file_id}/url"
         params = {"expiry": 1}
         signed_url_headers = {**self.headers, "Accept": "application/json"}
 
@@ -348,7 +346,7 @@ class MistralLoader:
         self, session: aiohttp.ClientSession, file_id: str
     ) -> str:
         """Async signed URL retrieval."""
-        url = f"{self.base_url}/files/{file_id}/url"
+        url = f"{self.BASE_API_URL}/files/{file_id}/url"
         params = {"expiry": 1}
 
         headers = {**self.headers, "Accept": "application/json"}
@@ -375,7 +373,7 @@ class MistralLoader:
     def _process_ocr(self, signed_url: str) -> Dict[str, Any]:
         """Sends the signed URL to the OCR endpoint for processing (sync version)."""
         log.info("Processing OCR via Mistral API")
-        url = f"{self.base_url}/ocr"
+        url = f"{self.BASE_API_URL}/ocr"
         ocr_headers = {
             **self.headers,
             "Content-Type": "application/json",
@@ -409,7 +407,7 @@ class MistralLoader:
         self, session: aiohttp.ClientSession, signed_url: str
     ) -> Dict[str, Any]:
         """Async OCR processing with timing metrics."""
-        url = f"{self.base_url}/ocr"
+        url = f"{self.BASE_API_URL}/ocr"
 
         headers = {
             **self.headers,
@@ -448,7 +446,7 @@ class MistralLoader:
     def _delete_file(self, file_id: str) -> None:
         """Deletes the file from Mistral storage (sync version)."""
         log.info(f"Deleting uploaded file ID: {file_id}")
-        url = f"{self.base_url}/files/{file_id}"
+        url = f"{self.BASE_API_URL}/files/{file_id}"
 
         try:
             response = requests.delete(
@@ -469,7 +467,7 @@ class MistralLoader:
             async def delete_request():
                 self._debug_log(f"Deleting file ID: {file_id}")
                 async with session.delete(
-                    url=f"{self.base_url}/files/{file_id}",
+                    url=f"{self.BASE_API_URL}/files/{file_id}",
                     headers=self.headers,
                     timeout=aiohttp.ClientTimeout(
                         total=self.cleanup_timeout

backend/open_webui/retrieval/loaders/youtube.py

@@ -83,7 +83,6 @@ class YoutubeLoader:
                 TranscriptsDisabled,
                 YouTubeTranscriptApi,
             )
-            from youtube_transcript_api.proxies import GenericProxyConfig
         except ImportError:
             raise ImportError(
                 'Could not import "youtube_transcript_api" Python package. '
@@ -91,9 +90,10 @@ class YoutubeLoader:
             )
 
         if self.proxy_url:
-            youtube_proxies = GenericProxyConfig(
-                http_url=self.proxy_url, https_url=self.proxy_url
-            )
+            youtube_proxies = {
+                "http": self.proxy_url,
+                "https": self.proxy_url,
+            }
             log.debug(f"Using proxy URL: {self.proxy_url[:14]}...")
         else:
             youtube_proxies = None

backend/open_webui/retrieval/models/external.py

@@ -6,7 +6,6 @@ from urllib.parse import quote
 
 from open_webui.env import ENABLE_FORWARD_USER_INFO_HEADERS, SRC_LOG_LEVELS
 from open_webui.retrieval.models.base_reranker import BaseReranker
-from open_webui.utils.headers import include_user_info_headers
 
 
 log = logging.getLogger(__name__)
@@ -41,17 +40,22 @@ class ExternalReranker(BaseReranker):
             log.info(f"ExternalReranker:predict:model {self.model}")
             log.info(f"ExternalReranker:predict:query {query}")
 
-            headers = {
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {self.api_key}",
-            }
-
-            if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-                headers = include_user_info_headers(headers, user)
-
             r = requests.post(
                 f"{self.url}",
-                headers=headers,
+                headers={
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {self.api_key}",
+                    **(
+                        {
+                            "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
+                            "X-OpenWebUI-User-Id": user.id,
+                            "X-OpenWebUI-User-Email": user.email,
+                            "X-OpenWebUI-User-Role": user.role,
+                        }
+                        if ENABLE_FORWARD_USER_INFO_HEADERS and user
+                        else {}
+                    ),
+                },
                 json=payload,
             )
 

backend/open_webui/retrieval/utils.py

@@ -1,10 +1,8 @@
 import logging
 import os
-from typing import Awaitable, Optional, Union
+from typing import Optional, Union
 
 import requests
-import aiohttp
-import asyncio
 import hashlib
 from concurrent.futures import ThreadPoolExecutor
 import time
@@ -29,7 +27,6 @@ from open_webui.models.notes import Notes
 
 from open_webui.retrieval.vector.main import GetResult
 from open_webui.utils.access_control import has_access
-from open_webui.utils.headers import include_user_info_headers
 from open_webui.utils.misc import get_message_list
 
 from open_webui.retrieval.web.utils import get_web_loader
@@ -74,7 +71,6 @@ def get_loader(request, url: str):
             url,
             verify_ssl=request.app.state.config.ENABLE_WEB_LOADER_SSL_VERIFICATION,
             requests_per_second=request.app.state.config.WEB_LOADER_CONCURRENT_REQUESTS,
-            trust_env=request.app.state.config.WEB_SEARCH_TRUST_ENV,
         )
 
 
@@ -91,29 +87,14 @@ class VectorSearchRetriever(BaseRetriever):
     top_k: int
 
     def _get_relevant_documents(
-        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
-    ) -> list[Document]:
-        """Get documents relevant to a query.
-
-        Args:
-            query: String to find relevant documents for.
-            run_manager: The callback handler to use.
-
-        Returns:
-            List of relevant documents.
-        """
-        return []
-
-    async def _aget_relevant_documents(
         self,
         query: str,
         *,
         run_manager: CallbackManagerForRetrieverRun,
     ) -> list[Document]:
-        embedding = await self.embedding_function(query, RAG_EMBEDDING_QUERY_PREFIX)
         result = VECTOR_DB_CLIENT.search(
             collection_name=self.collection_name,
-            vectors=[embedding],
+            vectors=[self.embedding_function(query, RAG_EMBEDDING_QUERY_PREFIX)],
             limit=self.top_k,
         )
 
@@ -166,45 +147,7 @@ def get_doc(collection_name: str, user: UserModel = None):
         raise e
 
 
-def get_enriched_texts(collection_result: GetResult) -> list[str]:
-    enriched_texts = []
-    for idx, text in enumerate(collection_result.documents[0]):
-        metadata = collection_result.metadatas[0][idx]
-        metadata_parts = [text]
-
-        # Add filename (repeat twice for extra weight in BM25 scoring)
-        if metadata.get("name"):
-            filename = metadata["name"]
-            filename_tokens = (
-                filename.replace("_", " ").replace("-", " ").replace(".", " ")
-            )
-            metadata_parts.append(
-                f"Filename: {filename} {filename_tokens} {filename_tokens}"
-            )
-
-        # Add title if available
-        if metadata.get("title"):
-            metadata_parts.append(f"Title: {metadata['title']}")
-
-        # Add document section headings if available (from markdown splitter)
-        if metadata.get("headings") and isinstance(metadata["headings"], list):
-            headings = " > ".join(str(h) for h in metadata["headings"])
-            metadata_parts.append(f"Section: {headings}")
-
-        # Add source URL/path if available
-        if metadata.get("source"):
-            metadata_parts.append(f"Source: {metadata['source']}")
-
-        # Add snippet for web search results
-        if metadata.get("snippet"):
-            metadata_parts.append(f"Snippet: {metadata['snippet']}")
-
-        enriched_texts.append(" ".join(metadata_parts))
-
-    return enriched_texts
-
-
-async def query_doc_with_hybrid_search(
+def query_doc_with_hybrid_search(
     collection_name: str,
     collection_result: GetResult,
     query: str,
@@ -214,21 +157,12 @@ async def query_doc_with_hybrid_search(
     k_reranker: int,
     r: float,
     hybrid_bm25_weight: float,
-    enable_enriched_texts: bool = False,
 ) -> dict:
     try:
-        # First check if collection_result has the required attributes
         if (
             not collection_result
             or not hasattr(collection_result, "documents")
-            or not hasattr(collection_result, "metadatas")
-        ):
-            log.warning(f"query_doc_with_hybrid_search:no_docs {collection_name}")
-            return {"documents": [], "metadatas": [], "distances": []}
-
-        # Now safely check the documents content after confirming attributes exist
-        if (
-            not collection_result.documents
+            or not collection_result.documents
             or len(collection_result.documents) == 0
             or not collection_result.documents[0]
         ):
@@ -237,14 +171,8 @@ async def query_doc_with_hybrid_search(
 
         log.debug(f"query_doc_with_hybrid_search:doc {collection_name}")
 
-        bm25_texts = (
-            get_enriched_texts(collection_result)
-            if enable_enriched_texts
-            else collection_result.documents[0]
-        )
-
         bm25_retriever = BM25Retriever.from_texts(
-            texts=bm25_texts,
+            texts=collection_result.documents[0],
             metadatas=collection_result.metadatas[0],
         )
         bm25_retriever.k = k
@@ -280,7 +208,7 @@ async def query_doc_with_hybrid_search(
             base_compressor=compressor, base_retriever=ensemble_retriever
         )
 
-        result = await compression_retriever.ainvoke(query)
+        result = compression_retriever.invoke(query)
 
         distances = [d.metadata.get("score") for d in result]
         documents = [d.page_content for d in result]
@@ -399,7 +327,7 @@ def get_all_items_from_collections(collection_names: list[str]) -> dict:
     return merge_get_results(results)
 
 
-async def query_collection(
+def query_collection(
     collection_names: list[str],
     queries: list[str],
     embedding_function,
@@ -424,9 +352,7 @@ async def query_collection(
             return None, e
 
     # Generate all query embeddings (in one call)
-    query_embeddings = await embedding_function(
-        queries, prefix=RAG_EMBEDDING_QUERY_PREFIX
-    )
+    query_embeddings = embedding_function(queries, prefix=RAG_EMBEDDING_QUERY_PREFIX)
     log.debug(
         f"query_collection: processing {len(queries)} queries across {len(collection_names)} collections"
     )
@@ -453,7 +379,7 @@ async def query_collection(
     return merge_and_sort_query_results(results, k=k)
 
 
-async def query_collection_with_hybrid_search(
+def query_collection_with_hybrid_search(
     collection_names: list[str],
     queries: list[str],
     embedding_function,
@@ -462,7 +388,6 @@ async def query_collection_with_hybrid_search(
     k_reranker: int,
     r: float,
     hybrid_bm25_weight: float,
-    enable_enriched_texts: bool = False,
 ) -> dict:
     results = []
     error = False
@@ -485,9 +410,9 @@ async def query_collection_with_hybrid_search(
         f"Starting hybrid search for {len(queries)} queries in {len(collection_names)} collections..."
     )
 
-    async def process_query(collection_name, query):
+    def process_query(collection_name, query):
         try:
-            result = await query_doc_with_hybrid_search(
+            result = query_doc_with_hybrid_search(
                 collection_name=collection_name,
                 collection_result=collection_results[collection_name],
                 query=query,
@@ -497,7 +422,6 @@ async def query_collection_with_hybrid_search(
                 k_reranker=k_reranker,
                 r=r,
                 hybrid_bm25_weight=hybrid_bm25_weight,
-                enable_enriched_texts=enable_enriched_texts,
             )
             return result, None
         except Exception as e:
@@ -507,16 +431,15 @@ async def query_collection_with_hybrid_search(
     # Prepare tasks for all collections and queries
     # Avoid running any tasks for collections that failed to fetch data (have assigned None)
     tasks = [
-        (collection_name, query)
-        for collection_name in collection_names
-        if collection_results[collection_name] is not None
-        for query in queries
+        (cn, q)
+        for cn in collection_names
+        if collection_results[cn] is not None
+        for q in queries
     ]
 
-    # Run all queries in parallel using asyncio.gather
-    task_results = await asyncio.gather(
-        *[process_query(collection_name, query) for collection_name, query in tasks]
-    )
+    with ThreadPoolExecutor() as executor:
+        future_results = [executor.submit(process_query, cn, q) for cn, q in tasks]
+        task_results = [future.result() for future in future_results]
 
     for result, err in task_results:
         if err is not None:
@@ -532,248 +455,6 @@ async def query_collection_with_hybrid_search(
     return merge_and_sort_query_results(results, k=k)
 
 
-def generate_openai_batch_embeddings(
-    model: str,
-    texts: list[str],
-    url: str = "https://api.openai.com/v1",
-    key: str = "",
-    prefix: str = None,
-    user: UserModel = None,
-) -> Optional[list[list[float]]]:
-    try:
-        log.debug(
-            f"generate_openai_batch_embeddings:model {model} batch size: {len(texts)}"
-        )
-        json_data = {"input": texts, "model": model}
-        if isinstance(RAG_EMBEDDING_PREFIX_FIELD_NAME, str) and isinstance(prefix, str):
-            json_data[RAG_EMBEDDING_PREFIX_FIELD_NAME] = prefix
-
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {key}",
-        }
-        if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-            headers = include_user_info_headers(headers, user)
-
-        r = requests.post(
-            f"{url}/embeddings",
-            headers=headers,
-            json=json_data,
-        )
-        r.raise_for_status()
-        data = r.json()
-        if "data" in data:
-            return [elem["embedding"] for elem in data["data"]]
-        else:
-            raise "Something went wrong :/"
-    except Exception as e:
-        log.exception(f"Error generating openai batch embeddings: {e}")
-        return None
-
-
-async def agenerate_openai_batch_embeddings(
-    model: str,
-    texts: list[str],
-    url: str = "https://api.openai.com/v1",
-    key: str = "",
-    prefix: str = None,
-    user: UserModel = None,
-) -> Optional[list[list[float]]]:
-    try:
-        log.debug(
-            f"agenerate_openai_batch_embeddings:model {model} batch size: {len(texts)}"
-        )
-        form_data = {"input": texts, "model": model}
-        if isinstance(RAG_EMBEDDING_PREFIX_FIELD_NAME, str) and isinstance(prefix, str):
-            form_data[RAG_EMBEDDING_PREFIX_FIELD_NAME] = prefix
-
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {key}",
-        }
-        if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-            headers = include_user_info_headers(headers, user)
-
-        async with aiohttp.ClientSession(trust_env=True) as session:
-            async with session.post(
-                f"{url}/embeddings", headers=headers, json=form_data
-            ) as r:
-                r.raise_for_status()
-                data = await r.json()
-                if "data" in data:
-                    return [item["embedding"] for item in data["data"]]
-                else:
-                    raise Exception("Something went wrong :/")
-    except Exception as e:
-        log.exception(f"Error generating openai batch embeddings: {e}")
-        return None
-
-
-def generate_azure_openai_batch_embeddings(
-    model: str,
-    texts: list[str],
-    url: str,
-    key: str = "",
-    version: str = "",
-    prefix: str = None,
-    user: UserModel = None,
-) -> Optional[list[list[float]]]:
-    try:
-        log.debug(
-            f"generate_azure_openai_batch_embeddings:deployment {model} batch size: {len(texts)}"
-        )
-        json_data = {"input": texts}
-        if isinstance(RAG_EMBEDDING_PREFIX_FIELD_NAME, str) and isinstance(prefix, str):
-            json_data[RAG_EMBEDDING_PREFIX_FIELD_NAME] = prefix
-
-        url = f"{url}/openai/deployments/{model}/embeddings?api-version={version}"
-
-        for _ in range(5):
-            headers = {
-                "Content-Type": "application/json",
-                "api-key": key,
-            }
-            if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-                headers = include_user_info_headers(headers, user)
-
-            r = requests.post(
-                url,
-                headers=headers,
-                json=json_data,
-            )
-            if r.status_code == 429:
-                retry = float(r.headers.get("Retry-After", "1"))
-                time.sleep(retry)
-                continue
-            r.raise_for_status()
-            data = r.json()
-            if "data" in data:
-                return [elem["embedding"] for elem in data["data"]]
-            else:
-                raise Exception("Something went wrong :/")
-        return None
-    except Exception as e:
-        log.exception(f"Error generating azure openai batch embeddings: {e}")
-        return None
-
-
-async def agenerate_azure_openai_batch_embeddings(
-    model: str,
-    texts: list[str],
-    url: str,
-    key: str = "",
-    version: str = "",
-    prefix: str = None,
-    user: UserModel = None,
-) -> Optional[list[list[float]]]:
-    try:
-        log.debug(
-            f"agenerate_azure_openai_batch_embeddings:deployment {model} batch size: {len(texts)}"
-        )
-        form_data = {"input": texts}
-        if isinstance(RAG_EMBEDDING_PREFIX_FIELD_NAME, str) and isinstance(prefix, str):
-            form_data[RAG_EMBEDDING_PREFIX_FIELD_NAME] = prefix
-
-        full_url = f"{url}/openai/deployments/{model}/embeddings?api-version={version}"
-
-        headers = {
-            "Content-Type": "application/json",
-            "api-key": key,
-        }
-        if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-            headers = include_user_info_headers(headers, user)
-
-        async with aiohttp.ClientSession(trust_env=True) as session:
-            async with session.post(full_url, headers=headers, json=form_data) as r:
-                r.raise_for_status()
-                data = await r.json()
-                if "data" in data:
-                    return [item["embedding"] for item in data["data"]]
-                else:
-                    raise Exception("Something went wrong :/")
-    except Exception as e:
-        log.exception(f"Error generating azure openai batch embeddings: {e}")
-        return None
-
-
-def generate_ollama_batch_embeddings(
-    model: str,
-    texts: list[str],
-    url: str,
-    key: str = "",
-    prefix: str = None,
-    user: UserModel = None,
-) -> Optional[list[list[float]]]:
-    try:
-        log.debug(
-            f"generate_ollama_batch_embeddings:model {model} batch size: {len(texts)}"
-        )
-        json_data = {"input": texts, "model": model}
-        if isinstance(RAG_EMBEDDING_PREFIX_FIELD_NAME, str) and isinstance(prefix, str):
-            json_data[RAG_EMBEDDING_PREFIX_FIELD_NAME] = prefix
-
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {key}",
-        }
-        if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-            headers = include_user_info_headers(headers, user)
-
-        r = requests.post(
-            f"{url}/api/embed",
-            headers=headers,
-            json=json_data,
-        )
-        r.raise_for_status()
-        data = r.json()
-
-        if "embeddings" in data:
-            return data["embeddings"]
-        else:
-            raise "Something went wrong :/"
-    except Exception as e:
-        log.exception(f"Error generating ollama batch embeddings: {e}")
-        return None
-
-
-async def agenerate_ollama_batch_embeddings(
-    model: str,
-    texts: list[str],
-    url: str,
-    key: str = "",
-    prefix: str = None,
-    user: UserModel = None,
-) -> Optional[list[list[float]]]:
-    try:
-        log.debug(
-            f"agenerate_ollama_batch_embeddings:model {model} batch size: {len(texts)}"
-        )
-        form_data = {"input": texts, "model": model}
-        if isinstance(RAG_EMBEDDING_PREFIX_FIELD_NAME, str) and isinstance(prefix, str):
-            form_data[RAG_EMBEDDING_PREFIX_FIELD_NAME] = prefix
-
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {key}",
-        }
-        if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-            headers = include_user_info_headers(headers, user)
-
-        async with aiohttp.ClientSession(trust_env=True) as session:
-            async with session.post(
-                f"{url}/api/embed", headers=headers, json=form_data
-            ) as r:
-                r.raise_for_status()
-                data = await r.json()
-                if "embeddings" in data:
-                    return data["embeddings"]
-                else:
-                    raise Exception("Something went wrong :/")
-    except Exception as e:
-        log.exception(f"Error generating ollama batch embeddings: {e}")
-        return None
-
-
 def get_embedding_function(
     embedding_engine,
     embedding_model,
@@ -782,24 +463,13 @@ def get_embedding_function(
     key,
     embedding_batch_size,
     azure_api_version=None,
-    enable_async=True,
-) -> Awaitable:
+):
     if embedding_engine == "":
-        # Sentence transformers: CPU-bound sync operation
-        async def async_embedding_function(query, prefix=None, user=None):
-            return await asyncio.to_thread(
-                (
-                    lambda query, prefix=None: embedding_function.encode(
-                        query, **({"prompt": prefix} if prefix else {})
-                    ).tolist()
-                ),
-                query,
-                prefix,
-            )
-
-        return async_embedding_function
+        return lambda query, prefix=None, user=None: embedding_function.encode(
+            query, **({"prompt": prefix} if prefix else {})
+        ).tolist()
     elif embedding_engine in ["ollama", "openai", "azure_openai"]:
-        embedding_function = lambda query, prefix=None, user=None: generate_embeddings(
+        func = lambda query, prefix=None, user=None: generate_embeddings(
             engine=embedding_engine,
             model=embedding_model,
             text=query,
@@ -810,114 +480,41 @@ def get_embedding_function(
             azure_api_version=azure_api_version,
         )
 
-        async def async_embedding_function(query, prefix=None, user=None):
+        def generate_multiple(query, prefix, user, func):
             if isinstance(query, list):
-                # Create batches
-                batches = [
-                    query[i : i + embedding_batch_size]
-                    for i in range(0, len(query), embedding_batch_size)
-                ]
-
-                if enable_async:
-                    log.debug(
-                        f"generate_multiple_async: Processing {len(batches)} batches in parallel"
-                    )
-                    # Execute all batches in parallel
-                    tasks = [
-                        embedding_function(batch, prefix=prefix, user=user)
-                        for batch in batches
-                    ]
-                    batch_results = await asyncio.gather(*tasks)
-                else:
-                    log.debug(
-                        f"generate_multiple_async: Processing {len(batches)} batches sequentially"
-                    )
-                    batch_results = []
-                    for batch in batches:
-                        batch_results.append(
-                            await embedding_function(batch, prefix=prefix, user=user)
-                        )
-
-                # Flatten results
                 embeddings = []
-                for batch_embeddings in batch_results:
+                for i in range(0, len(query), embedding_batch_size):
+                    batch_embeddings = func(
+                        query[i : i + embedding_batch_size],
+                        prefix=prefix,
+                        user=user,
+                    )
+
                     if isinstance(batch_embeddings, list):
                         embeddings.extend(batch_embeddings)
-
-                log.debug(
-                    f"generate_multiple_async: Generated {len(embeddings)} embeddings from {len(batches)} parallel batches"
-                )
                 return embeddings
             else:
-                return await embedding_function(query, prefix, user)
+                return func(query, prefix, user)
 
-        return async_embedding_function
+        return lambda query, prefix=None, user=None: generate_multiple(
+            query, prefix, user, func
+        )
     else:
         raise ValueError(f"Unknown embedding engine: {embedding_engine}")
 
 
-async def generate_embeddings(
-    engine: str,
-    model: str,
-    text: Union[str, list[str]],
-    prefix: Union[str, None] = None,
-    **kwargs,
-):
-    url = kwargs.get("url", "")
-    key = kwargs.get("key", "")
-    user = kwargs.get("user")
-
-    if prefix is not None and RAG_EMBEDDING_PREFIX_FIELD_NAME is None:
-        if isinstance(text, list):
-            text = [f"{prefix}{text_element}" for text_element in text]
-        else:
-            text = f"{prefix}{text}"
-
-    if engine == "ollama":
-        embeddings = await agenerate_ollama_batch_embeddings(
-            **{
-                "model": model,
-                "texts": text if isinstance(text, list) else [text],
-                "url": url,
-                "key": key,
-                "prefix": prefix,
-                "user": user,
-            }
-        )
-        return embeddings[0] if isinstance(text, str) else embeddings
-    elif engine == "openai":
-        embeddings = await agenerate_openai_batch_embeddings(
-            model, text if isinstance(text, list) else [text], url, key, prefix, user
-        )
-        return embeddings[0] if isinstance(text, str) else embeddings
-    elif engine == "azure_openai":
-        azure_api_version = kwargs.get("azure_api_version", "")
-        embeddings = await agenerate_azure_openai_batch_embeddings(
-            model,
-            text if isinstance(text, list) else [text],
-            url,
-            key,
-            azure_api_version,
-            prefix,
-            user,
-        )
-        return embeddings[0] if isinstance(text, str) else embeddings
-
-
 def get_reranking_function(reranking_engine, reranking_model, reranking_function):
     if reranking_function is None:
         return None
     if reranking_engine == "external":
-        return lambda query, documents, user=None: reranking_function.predict(
-            [(query, doc.page_content) for doc in documents], user=user
+        return lambda sentences, user=None: reranking_function.predict(
+            sentences, user=user
         )
     else:
-        return lambda query, documents, user=None: reranking_function.predict(
-            [(query, doc.page_content) for doc in documents]
-        )
+        return lambda sentences, user=None: reranking_function.predict(sentences)
 
 
-async def get_sources_from_items(
+def get_sources_from_items(
     request,
     items,
     queries,
@@ -1071,47 +668,46 @@ async def get_sources_from_items(
                     collection_names.append(f"file-{item['id']}")
 
         elif item.get("type") == "collection":
-            # Manual Full Mode Toggle for Collection
-            knowledge_base = Knowledges.get_knowledge_by_id(item.get("id"))
-
-            if knowledge_base and (
-                user.role == "admin"
-                or knowledge_base.user_id == user.id
-                or has_access(user.id, "read", knowledge_base.access_control)
+            if (
+                item.get("context") == "full"
+                or request.app.state.config.BYPASS_EMBEDDING_AND_RETRIEVAL
             ):
-                if (
-                    item.get("context") == "full"
-                    or request.app.state.config.BYPASS_EMBEDDING_AND_RETRIEVAL
-                ):
-                    if knowledge_base and (
-                        user.role == "admin"
-                        or knowledge_base.user_id == user.id
-                        or has_access(user.id, "read", knowledge_base.access_control)
-                    ):
-                        files = Knowledges.get_files_by_id(knowledge_base.id)
+                # Manual Full Mode Toggle for Collection
+                knowledge_base = Knowledges.get_knowledge_by_id(item.get("id"))
 
-                        documents = []
-                        metadatas = []
-                        for file in files:
-                            documents.append(file.data.get("content", ""))
+                if knowledge_base and (
+                    user.role == "admin"
+                    or knowledge_base.user_id == user.id
+                    or has_access(user.id, "read", knowledge_base.access_control)
+                ):
+
+                    file_ids = knowledge_base.data.get("file_ids", [])
+
+                    documents = []
+                    metadatas = []
+                    for file_id in file_ids:
+                        file_object = Files.get_file_by_id(file_id)
+
+                        if file_object:
+                            documents.append(file_object.data.get("content", ""))
                             metadatas.append(
                                 {
-                                    "file_id": file.id,
-                                    "name": file.filename,
-                                    "source": file.filename,
+                                    "file_id": file_id,
+                                    "name": file_object.filename,
+                                    "source": file_object.filename,
                                 }
                             )
 
-                        query_result = {
-                            "documents": [documents],
-                            "metadatas": [metadatas],
-                        }
+                    query_result = {
+                        "documents": [documents],
+                        "metadatas": [metadatas],
+                    }
+            else:
+                # Fallback to collection names
+                if item.get("legacy"):
+                    collection_names = item.get("collection_names", [])
                 else:
-                    # Fallback to collection names
-                    if item.get("legacy"):
-                        collection_names = item.get("collection_names", [])
-                    else:
-                        collection_names.append(item["id"])
+                    collection_names.append(item["id"])
 
         elif item.get("docs"):
             # BYPASS_WEB_SEARCH_EMBEDDING_AND_RETRIEVAL
@@ -1141,7 +737,7 @@ async def get_sources_from_items(
                     query_result = None  # Initialize to None
                     if hybrid_search:
                         try:
-                            query_result = await query_collection_with_hybrid_search(
+                            query_result = query_collection_with_hybrid_search(
                                 collection_names=collection_names,
                                 queries=queries,
                                 embedding_function=embedding_function,
@@ -1150,7 +746,6 @@ async def get_sources_from_items(
                                 k_reranker=k_reranker,
                                 r=r,
                                 hybrid_bm25_weight=hybrid_bm25_weight,
-                                enable_enriched_texts=request.app.state.config.ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS,
                             )
                         except Exception as e:
                             log.debug(
@@ -1159,7 +754,7 @@ async def get_sources_from_items(
 
                     # fallback to non-hybrid search
                     if not hybrid_search and query_result is None:
-                        query_result = await query_collection(
+                        query_result = query_collection(
                             collection_names=collection_names,
                             queries=queries,
                             embedding_function=embedding_function,
@@ -1235,6 +830,199 @@ def get_model_path(model: str, update_model: bool = False):
         return model
 
 
+def generate_openai_batch_embeddings(
+    model: str,
+    texts: list[str],
+    url: str = "https://api.openai.com/v1",
+    key: str = "",
+    prefix: str = None,
+    user: UserModel = None,
+) -> Optional[list[list[float]]]:
+    try:
+        log.debug(
+            f"generate_openai_batch_embeddings:model {model} batch size: {len(texts)}"
+        )
+        json_data = {"input": texts, "model": model}
+        if isinstance(RAG_EMBEDDING_PREFIX_FIELD_NAME, str) and isinstance(prefix, str):
+            json_data[RAG_EMBEDDING_PREFIX_FIELD_NAME] = prefix
+
+        r = requests.post(
+            f"{url}/embeddings",
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {key}",
+                **(
+                    {
+                        "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
+                        "X-OpenWebUI-User-Id": user.id,
+                        "X-OpenWebUI-User-Email": user.email,
+                        "X-OpenWebUI-User-Role": user.role,
+                    }
+                    if ENABLE_FORWARD_USER_INFO_HEADERS and user
+                    else {}
+                ),
+            },
+            json=json_data,
+        )
+        r.raise_for_status()
+        data = r.json()
+        if "data" in data:
+            return [elem["embedding"] for elem in data["data"]]
+        else:
+            raise "Something went wrong :/"
+    except Exception as e:
+        log.exception(f"Error generating openai batch embeddings: {e}")
+        return None
+
+
+def generate_azure_openai_batch_embeddings(
+    model: str,
+    texts: list[str],
+    url: str,
+    key: str = "",
+    version: str = "",
+    prefix: str = None,
+    user: UserModel = None,
+) -> Optional[list[list[float]]]:
+    try:
+        log.debug(
+            f"generate_azure_openai_batch_embeddings:deployment {model} batch size: {len(texts)}"
+        )
+        json_data = {"input": texts}
+        if isinstance(RAG_EMBEDDING_PREFIX_FIELD_NAME, str) and isinstance(prefix, str):
+            json_data[RAG_EMBEDDING_PREFIX_FIELD_NAME] = prefix
+
+        url = f"{url}/openai/deployments/{model}/embeddings?api-version={version}"
+
+        for _ in range(5):
+            r = requests.post(
+                url,
+                headers={
+                    "Content-Type": "application/json",
+                    "api-key": key,
+                    **(
+                        {
+                            "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
+                            "X-OpenWebUI-User-Id": user.id,
+                            "X-OpenWebUI-User-Email": user.email,
+                            "X-OpenWebUI-User-Role": user.role,
+                        }
+                        if ENABLE_FORWARD_USER_INFO_HEADERS and user
+                        else {}
+                    ),
+                },
+                json=json_data,
+            )
+            if r.status_code == 429:
+                retry = float(r.headers.get("Retry-After", "1"))
+                time.sleep(retry)
+                continue
+            r.raise_for_status()
+            data = r.json()
+            if "data" in data:
+                return [elem["embedding"] for elem in data["data"]]
+            else:
+                raise Exception("Something went wrong :/")
+        return None
+    except Exception as e:
+        log.exception(f"Error generating azure openai batch embeddings: {e}")
+        return None
+
+
+def generate_ollama_batch_embeddings(
+    model: str,
+    texts: list[str],
+    url: str,
+    key: str = "",
+    prefix: str = None,
+    user: UserModel = None,
+) -> Optional[list[list[float]]]:
+    try:
+        log.debug(
+            f"generate_ollama_batch_embeddings:model {model} batch size: {len(texts)}"
+        )
+        json_data = {"input": texts, "model": model}
+        if isinstance(RAG_EMBEDDING_PREFIX_FIELD_NAME, str) and isinstance(prefix, str):
+            json_data[RAG_EMBEDDING_PREFIX_FIELD_NAME] = prefix
+
+        r = requests.post(
+            f"{url}/api/embed",
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {key}",
+                **(
+                    {
+                        "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
+                        "X-OpenWebUI-User-Id": user.id,
+                        "X-OpenWebUI-User-Email": user.email,
+                        "X-OpenWebUI-User-Role": user.role,
+                    }
+                    if ENABLE_FORWARD_USER_INFO_HEADERS
+                    else {}
+                ),
+            },
+            json=json_data,
+        )
+        r.raise_for_status()
+        data = r.json()
+
+        if "embeddings" in data:
+            return data["embeddings"]
+        else:
+            raise "Something went wrong :/"
+    except Exception as e:
+        log.exception(f"Error generating ollama batch embeddings: {e}")
+        return None
+
+
+def generate_embeddings(
+    engine: str,
+    model: str,
+    text: Union[str, list[str]],
+    prefix: Union[str, None] = None,
+    **kwargs,
+):
+    url = kwargs.get("url", "")
+    key = kwargs.get("key", "")
+    user = kwargs.get("user")
+
+    if prefix is not None and RAG_EMBEDDING_PREFIX_FIELD_NAME is None:
+        if isinstance(text, list):
+            text = [f"{prefix}{text_element}" for text_element in text]
+        else:
+            text = f"{prefix}{text}"
+
+    if engine == "ollama":
+        embeddings = generate_ollama_batch_embeddings(
+            **{
+                "model": model,
+                "texts": text if isinstance(text, list) else [text],
+                "url": url,
+                "key": key,
+                "prefix": prefix,
+                "user": user,
+            }
+        )
+        return embeddings[0] if isinstance(text, str) else embeddings
+    elif engine == "openai":
+        embeddings = generate_openai_batch_embeddings(
+            model, text if isinstance(text, list) else [text], url, key, prefix, user
+        )
+        return embeddings[0] if isinstance(text, str) else embeddings
+    elif engine == "azure_openai":
+        azure_api_version = kwargs.get("azure_api_version", "")
+        embeddings = generate_azure_openai_batch_embeddings(
+            model,
+            text if isinstance(text, list) else [text],
+            url,
+            key,
+            azure_api_version,
+            prefix,
+            user,
+        )
+        return embeddings[0] if isinstance(text, str) else embeddings
+
+
 import operator
 from typing import Optional, Sequence
 
@@ -1257,38 +1045,19 @@ class RerankCompressor(BaseDocumentCompressor):
         documents: Sequence[Document],
         query: str,
         callbacks: Optional[Callbacks] = None,
-    ) -> Sequence[Document]:
-        """Compress retrieved documents given the query context.
-
-        Args:
-            documents: The retrieved documents.
-            query: The query context.
-            callbacks: Optional callbacks to run during compression.
-
-        Returns:
-            The compressed documents.
-
-        """
-        return []
-
-    async def acompress_documents(
-        self,
-        documents: Sequence[Document],
-        query: str,
-        callbacks: Optional[Callbacks] = None,
     ) -> Sequence[Document]:
         reranking = self.reranking_function is not None
 
         scores = None
         if reranking:
-            scores = self.reranking_function(query, documents)
+            scores = self.reranking_function(
+                [(query, doc.page_content) for doc in documents]
+            )
         else:
             from sentence_transformers import util
 
-            query_embedding = await self.embedding_function(
-                query, RAG_EMBEDDING_QUERY_PREFIX
-            )
-            document_embedding = await self.embedding_function(
+            query_embedding = self.embedding_function(query, RAG_EMBEDDING_QUERY_PREFIX)
+            document_embedding = self.embedding_function(
                 [doc.page_content for doc in documents], RAG_EMBEDDING_CONTENT_PREFIX
             )
             scores = util.cos_sim(query_embedding, document_embedding)[0]

backend/open_webui/retrieval/vector/dbs/milvus.py

@@ -200,24 +200,23 @@ class MilvusClient(VectorDBBase):
     def query(self, collection_name: str, filter: dict, limit: int = -1):
         connections.connect(uri=MILVUS_URI, token=MILVUS_TOKEN, db_name=MILVUS_DB)
 
+        # Construct the filter string for querying
         collection_name = collection_name.replace("-", "_")
         if not self.has_collection(collection_name):
             log.warning(
                 f"Query attempted on non-existent collection: {self.collection_prefix}_{collection_name}"
             )
             return None
-
-        filter_expressions = []
-        for key, value in filter.items():
-            if isinstance(value, str):
-                filter_expressions.append(f'metadata["{key}"] == "{value}"')
-            else:
-                filter_expressions.append(f'metadata["{key}"] == {value}')
-
-        filter_string = " && ".join(filter_expressions)
+        filter_string = " && ".join(
+            [
+                f'metadata["{key}"] == {json.dumps(value)}'
+                for key, value in filter.items()
+            ]
+        )
 
         collection = Collection(f"{self.collection_prefix}_{collection_name}")
         collection.load()
+        all_results = []
 
         try:
             log.info(
@@ -225,25 +224,24 @@ class MilvusClient(VectorDBBase):
             )
 
             iterator = collection.query_iterator(
-                expr=filter_string,
+                filter=filter_string,
                 output_fields=[
                     "id",
                     "data",
                     "metadata",
                 ],
-                limit=limit if limit > 0 else -1,
+                limit=limit,  # Pass the limit directly; -1 means no limit.
             )
 
-            all_results = []
             while True:
-                batch = iterator.next()
-                if not batch:
+                result = iterator.next()
+                if not result:
                     iterator.close()
                     break
-                all_results.extend(batch)
+                all_results += result
 
-            log.debug(f"Total results from query: {len(all_results)}")
-            return self._result_to_get_result([all_results] if all_results else [[]])
+            log.info(f"Total results from query: {len(all_results)}")
+            return self._result_to_get_result([all_results])
 
         except Exception as e:
             log.exception(

backend/open_webui/retrieval/vector/dbs/milvus_multitenancy.py

@@ -157,6 +157,7 @@ class MilvusClient(VectorDBBase):
             for item in items
         ]
         collection.insert(entities)
+        collection.flush()
 
     def search(
         self, collection_name: str, vectors: List[List[float]], limit: int
@@ -262,23 +263,15 @@ class MilvusClient(VectorDBBase):
                 else:
                     expr.append(f"metadata['{key}'] == {value}")
 
-        iterator = collection.query_iterator(
+        results = collection.query(
             expr=" and ".join(expr),
             output_fields=["id", "text", "metadata"],
-            limit=limit if limit else -1,
+            limit=limit,
         )
 
-        all_results = []
-        while True:
-            batch = iterator.next()
-            if not batch:
-                iterator.close()
-                break
-            all_results.extend(batch)
-
-        ids = [res["id"] for res in all_results]
-        documents = [res["text"] for res in all_results]
-        metadatas = [res["metadata"] for res in all_results]
+        ids = [res["id"] for res in results]
+        documents = [res["text"] for res in results]
+        metadatas = [res["metadata"] for res in results]
 
         return GetResult(ids=[ids], documents=[documents], metadatas=[metadatas])
 

backend/open_webui/retrieval/vector/dbs/pgvector.py

@@ -1,4 +1,4 @@
-from typing import Optional, List, Dict, Any, Tuple
+from typing import Optional, List, Dict, Any
 import logging
 import json
 from sqlalchemy import (
@@ -22,7 +22,7 @@ from sqlalchemy.pool import NullPool, QueuePool
 
 from sqlalchemy.orm import declarative_base, scoped_session, sessionmaker
 from sqlalchemy.dialects.postgresql import JSONB, array
-from pgvector.sqlalchemy import Vector, HALFVEC
+from pgvector.sqlalchemy import Vector
 from sqlalchemy.ext.mutable import MutableDict
 from sqlalchemy.exc import NoSuchTableError
 
@@ -44,20 +44,11 @@ from open_webui.config import (
     PGVECTOR_POOL_MAX_OVERFLOW,
     PGVECTOR_POOL_TIMEOUT,
     PGVECTOR_POOL_RECYCLE,
-    PGVECTOR_INDEX_METHOD,
-    PGVECTOR_HNSW_M,
-    PGVECTOR_HNSW_EF_CONSTRUCTION,
-    PGVECTOR_IVFFLAT_LISTS,
-    PGVECTOR_USE_HALFVEC,
 )
 
 from open_webui.env import SRC_LOG_LEVELS
 
 VECTOR_LENGTH = PGVECTOR_INITIALIZE_MAX_VECTOR_LENGTH
-USE_HALFVEC = PGVECTOR_USE_HALFVEC
-
-VECTOR_TYPE_FACTORY = HALFVEC if USE_HALFVEC else Vector
-VECTOR_OPCLASS = "halfvec_cosine_ops" if USE_HALFVEC else "vector_cosine_ops"
 Base = declarative_base()
 
 log = logging.getLogger(__name__)
@@ -76,7 +67,7 @@ class DocumentChunk(Base):
     __tablename__ = "document_chunk"
 
     id = Column(Text, primary_key=True)
-    vector = Column(VECTOR_TYPE_FACTORY(dim=VECTOR_LENGTH), nullable=True)
+    vector = Column(Vector(dim=VECTOR_LENGTH), nullable=True)
     collection_name = Column(Text, nullable=False)
 
     if PGVECTOR_PGCRYPTO:
@@ -166,9 +157,13 @@ class PgvectorClient(VectorDBBase):
             connection = self.session.connection()
             Base.metadata.create_all(bind=connection)
 
-            index_method, index_options = self._vector_index_configuration()
-            self._ensure_vector_index(index_method, index_options)
-
+            # Create an index on the vector column if it doesn't exist
+            self.session.execute(
+                text(
+                    "CREATE INDEX IF NOT EXISTS idx_document_chunk_vector "
+                    "ON document_chunk USING ivfflat (vector vector_cosine_ops) WITH (lists = 100);"
+                )
+            )
             self.session.execute(
                 text(
                     "CREATE INDEX IF NOT EXISTS idx_document_chunk_collection_name "
@@ -182,78 +177,6 @@ class PgvectorClient(VectorDBBase):
             log.exception(f"Error during initialization: {e}")
             raise
 
-    @staticmethod
-    def _extract_index_method(index_def: Optional[str]) -> Optional[str]:
-        if not index_def:
-            return None
-        try:
-            after_using = index_def.lower().split("using ", 1)[1]
-            return after_using.split()[0]
-        except (IndexError, AttributeError):
-            return None
-
-    def _vector_index_configuration(self) -> Tuple[str, str]:
-        if PGVECTOR_INDEX_METHOD:
-            index_method = PGVECTOR_INDEX_METHOD
-            log.info(
-                "Using vector index method '%s' from PGVECTOR_INDEX_METHOD.",
-                index_method,
-            )
-        elif USE_HALFVEC:
-            index_method = "hnsw"
-            log.info(
-                "VECTOR_LENGTH=%s exceeds 2000; using halfvec column type with hnsw index.",
-                VECTOR_LENGTH,
-            )
-        else:
-            index_method = "ivfflat"
-
-        if index_method == "hnsw":
-            index_options = f"WITH (m = {PGVECTOR_HNSW_M}, ef_construction = {PGVECTOR_HNSW_EF_CONSTRUCTION})"
-        else:
-            index_options = f"WITH (lists = {PGVECTOR_IVFFLAT_LISTS})"
-
-        return index_method, index_options
-
-    def _ensure_vector_index(self, index_method: str, index_options: str) -> None:
-        index_name = "idx_document_chunk_vector"
-        existing_index_def = self.session.execute(
-            text(
-                """
-                SELECT indexdef
-                FROM pg_indexes
-                WHERE schemaname = current_schema()
-                  AND tablename = 'document_chunk'
-                  AND indexname = :index_name
-                """
-            ),
-            {"index_name": index_name},
-        ).scalar()
-
-        existing_method = self._extract_index_method(existing_index_def)
-        if existing_method and existing_method != index_method:
-            raise RuntimeError(
-                f"Existing pgvector index '{index_name}' uses method '{existing_method}' but configuration now "
-                f"requires '{index_method}'. Automatic rebuild is disabled to prevent long-running maintenance. "
-                "Drop the index manually (optionally after tuning maintenance_work_mem/max_parallel_maintenance_workers) "
-                "and recreate it with the new method before restarting Open WebUI."
-            )
-
-        if not existing_index_def:
-            index_sql = (
-                f"CREATE INDEX IF NOT EXISTS {index_name} "
-                f"ON document_chunk USING {index_method} (vector {VECTOR_OPCLASS})"
-            )
-            if index_options:
-                index_sql = f"{index_sql} {index_options}"
-            self.session.execute(text(index_sql))
-            log.info(
-                "Ensured vector index '%s' using %s%s.",
-                index_name,
-                index_method,
-                f" {index_options}" if index_options else "",
-            )
-
     def check_vector_length(self) -> None:
         """
         Check if the VECTOR_LENGTH matches the existing vector column dimension in the database.
@@ -273,19 +196,16 @@ class PgvectorClient(VectorDBBase):
         if "vector" in document_chunk_table.columns:
             vector_column = document_chunk_table.columns["vector"]
             vector_type = vector_column.type
-            expected_type = HALFVEC if USE_HALFVEC else Vector
-
-            if not isinstance(vector_type, expected_type):
+            if isinstance(vector_type, Vector):
+                db_vector_length = vector_type.dim
+                if db_vector_length != VECTOR_LENGTH:
+                    raise Exception(
+                        f"VECTOR_LENGTH {VECTOR_LENGTH} does not match existing vector column dimension {db_vector_length}. "
+                        "Cannot change vector size after initialization without migrating the data."
+                    )
+            else:
                 raise Exception(
-                    "The 'vector' column type does not match the expected type "
-                    f"('{expected_type.__name__}') for VECTOR_LENGTH {VECTOR_LENGTH}."
-                )
-
-            db_vector_length = getattr(vector_type, "dim", None)
-            if db_vector_length is not None and db_vector_length != VECTOR_LENGTH:
-                raise Exception(
-                    f"VECTOR_LENGTH {VECTOR_LENGTH} does not match existing vector column dimension {db_vector_length}. "
-                    "Cannot change vector size after initialization without migrating the data."
+                    "The 'vector' column exists but is not of type 'Vector'."
                 )
         else:
             raise Exception(
@@ -440,11 +360,11 @@ class PgvectorClient(VectorDBBase):
             num_queries = len(vectors)
 
             def vector_expr(vector):
-                return cast(array(vector), VECTOR_TYPE_FACTORY(VECTOR_LENGTH))
+                return cast(array(vector), Vector(VECTOR_LENGTH))
 
             # Create the values for query vectors
             qid_col = column("qid", Integer)
-            q_vector_col = column("q_vector", VECTOR_TYPE_FACTORY(VECTOR_LENGTH))
+            q_vector_col = column("q_vector", Vector(VECTOR_LENGTH))
             query_vectors = (
                 values(qid_col, q_vector_col)
                 .data(

backend/open_webui/retrieval/vector/dbs/s3vector.py

@@ -117,16 +117,15 @@ class S3VectorClient(VectorDBBase):
 
     def has_collection(self, collection_name: str) -> bool:
         """
-        Check if a vector index exists using direct lookup.
-        This avoids pagination issues with list_indexes() and is significantly faster.
+        Check if a vector index (collection) exists in the S3 vector bucket.
         """
+
         try:
-            self.client.get_index(
-                vectorBucketName=self.bucket_name, indexName=collection_name
-            )
-            return True
+            response = self.client.list_indexes(vectorBucketName=self.bucket_name)
+            indexes = response.get("indexes", [])
+            return any(idx.get("indexName") == collection_name for idx in indexes)
         except Exception as e:
-            log.error(f"Error checking if index '{collection_name}' exists: {e}")
+            log.error(f"Error listing indexes: {e}")
             return False
 
     def delete_collection(self, collection_name: str) -> None:

backend/open_webui/retrieval/vector/dbs/weaviate.py

@@ -1,340 +0,0 @@
-import weaviate
-import re
-import uuid
-from typing import Any, Dict, List, Optional, Union
-
-from open_webui.retrieval.vector.main import (
-    VectorDBBase,
-    VectorItem,
-    SearchResult,
-    GetResult,
-)
-from open_webui.retrieval.vector.utils import process_metadata
-from open_webui.config import (
-    WEAVIATE_HTTP_HOST,
-    WEAVIATE_HTTP_PORT,
-    WEAVIATE_GRPC_PORT,
-    WEAVIATE_API_KEY,
-)
-
-
-def _convert_uuids_to_strings(obj: Any) -> Any:
-    """
-    Recursively convert UUID objects to strings in nested data structures.
-
-    This function handles:
-    - UUID objects -> string
-    - Dictionaries with UUID values
-    - Lists/Tuples with UUID values
-    - Nested combinations of the above
-
-    Args:
-        obj: Any object that might contain UUIDs
-
-    Returns:
-        The same object structure with UUIDs converted to strings
-    """
-    if isinstance(obj, uuid.UUID):
-        return str(obj)
-    elif isinstance(obj, dict):
-        return {key: _convert_uuids_to_strings(value) for key, value in obj.items()}
-    elif isinstance(obj, (list, tuple)):
-        return type(obj)(_convert_uuids_to_strings(item) for item in obj)
-    elif isinstance(obj, (str, int, float, bool, type(None))):
-        return obj
-    else:
-        return obj
-
-
-class WeaviateClient(VectorDBBase):
-    def __init__(self):
-        self.url = WEAVIATE_HTTP_HOST
-        try:
-            # Build connection parameters
-            connection_params = {
-                "host": WEAVIATE_HTTP_HOST,
-                "port": WEAVIATE_HTTP_PORT,
-                "grpc_port": WEAVIATE_GRPC_PORT,
-            }
-
-            # Only add auth_credentials if WEAVIATE_API_KEY exists and is not empty
-            if WEAVIATE_API_KEY:
-                connection_params["auth_credentials"] = (
-                    weaviate.classes.init.Auth.api_key(WEAVIATE_API_KEY)
-                )
-
-            self.client = weaviate.connect_to_local(**connection_params)
-            self.client.connect()
-        except Exception as e:
-            raise ConnectionError(f"Failed to connect to Weaviate: {e}") from e
-
-    def _sanitize_collection_name(self, collection_name: str) -> str:
-        """Sanitize collection name to be a valid Weaviate class name."""
-        if not isinstance(collection_name, str) or not collection_name.strip():
-            raise ValueError("Collection name must be a non-empty string")
-
-        # Requirements for a valid Weaviate class name:
-        # The collection name must begin with a capital letter.
-        # The name can only contain letters, numbers, and the underscore (_) character. Spaces are not allowed.
-
-        # Replace hyphens with underscores and keep only alphanumeric characters
-        name = re.sub(r"[^a-zA-Z0-9_]", "", collection_name.replace("-", "_"))
-        name = name.strip("_")
-
-        if not name:
-            raise ValueError(
-                "Could not sanitize collection name to be a valid Weaviate class name"
-            )
-
-        # Ensure it starts with a letter and is capitalized
-        if not name[0].isalpha():
-            name = "C" + name
-
-        return name[0].upper() + name[1:]
-
-    def has_collection(self, collection_name: str) -> bool:
-        sane_collection_name = self._sanitize_collection_name(collection_name)
-        return self.client.collections.exists(sane_collection_name)
-
-    def delete_collection(self, collection_name: str) -> None:
-        sane_collection_name = self._sanitize_collection_name(collection_name)
-        if self.client.collections.exists(sane_collection_name):
-            self.client.collections.delete(sane_collection_name)
-
-    def _create_collection(self, collection_name: str) -> None:
-        self.client.collections.create(
-            name=collection_name,
-            vector_config=weaviate.classes.config.Configure.Vectors.self_provided(),
-            properties=[
-                weaviate.classes.config.Property(
-                    name="text", data_type=weaviate.classes.config.DataType.TEXT
-                ),
-            ],
-        )
-
-    def insert(self, collection_name: str, items: List[VectorItem]) -> None:
-        sane_collection_name = self._sanitize_collection_name(collection_name)
-        if not self.client.collections.exists(sane_collection_name):
-            self._create_collection(sane_collection_name)
-
-        collection = self.client.collections.get(sane_collection_name)
-
-        with collection.batch.fixed_size(batch_size=100) as batch:
-            for item in items:
-                item_uuid = str(uuid.uuid4()) if not item["id"] else str(item["id"])
-
-                properties = {"text": item["text"]}
-                if item["metadata"]:
-                    clean_metadata = _convert_uuids_to_strings(
-                        process_metadata(item["metadata"])
-                    )
-                    clean_metadata.pop("text", None)
-                    properties.update(clean_metadata)
-
-                batch.add_object(
-                    properties=properties, uuid=item_uuid, vector=item["vector"]
-                )
-
-    def upsert(self, collection_name: str, items: List[VectorItem]) -> None:
-        sane_collection_name = self._sanitize_collection_name(collection_name)
-        if not self.client.collections.exists(sane_collection_name):
-            self._create_collection(sane_collection_name)
-
-        collection = self.client.collections.get(sane_collection_name)
-
-        with collection.batch.fixed_size(batch_size=100) as batch:
-            for item in items:
-                item_uuid = str(item["id"]) if item["id"] else None
-
-                properties = {"text": item["text"]}
-                if item["metadata"]:
-                    clean_metadata = _convert_uuids_to_strings(
-                        process_metadata(item["metadata"])
-                    )
-                    clean_metadata.pop("text", None)
-                    properties.update(clean_metadata)
-
-                batch.add_object(
-                    properties=properties, uuid=item_uuid, vector=item["vector"]
-                )
-
-    def search(
-        self, collection_name: str, vectors: List[List[Union[float, int]]], limit: int
-    ) -> Optional[SearchResult]:
-        sane_collection_name = self._sanitize_collection_name(collection_name)
-        if not self.client.collections.exists(sane_collection_name):
-            return None
-
-        collection = self.client.collections.get(sane_collection_name)
-
-        result_ids, result_documents, result_metadatas, result_distances = (
-            [],
-            [],
-            [],
-            [],
-        )
-
-        for vector_embedding in vectors:
-            try:
-                response = collection.query.near_vector(
-                    near_vector=vector_embedding,
-                    limit=limit,
-                    return_metadata=weaviate.classes.query.MetadataQuery(distance=True),
-                )
-
-                ids = [str(obj.uuid) for obj in response.objects]
-                documents = []
-                metadatas = []
-                distances = []
-
-                for obj in response.objects:
-                    properties = dict(obj.properties) if obj.properties else {}
-                    documents.append(properties.pop("text", ""))
-                    metadatas.append(_convert_uuids_to_strings(properties))
-
-                # Weaviate has cosine distance, 2 (worst) -> 0 (best). Re-ordering to 0 -> 1
-                raw_distances = [
-                    (
-                        obj.metadata.distance
-                        if obj.metadata and obj.metadata.distance
-                        else 2.0
-                    )
-                    for obj in response.objects
-                ]
-                distances = [(2 - dist) / 2 for dist in raw_distances]
-
-                result_ids.append(ids)
-                result_documents.append(documents)
-                result_metadatas.append(metadatas)
-                result_distances.append(distances)
-            except Exception:
-                result_ids.append([])
-                result_documents.append([])
-                result_metadatas.append([])
-                result_distances.append([])
-
-        return SearchResult(
-            **{
-                "ids": result_ids,
-                "documents": result_documents,
-                "metadatas": result_metadatas,
-                "distances": result_distances,
-            }
-        )
-
-    def query(
-        self, collection_name: str, filter: Dict, limit: Optional[int] = None
-    ) -> Optional[GetResult]:
-        sane_collection_name = self._sanitize_collection_name(collection_name)
-        if not self.client.collections.exists(sane_collection_name):
-            return None
-
-        collection = self.client.collections.get(sane_collection_name)
-
-        weaviate_filter = None
-        if filter:
-            for key, value in filter.items():
-                prop_filter = weaviate.classes.query.Filter.by_property(name=key).equal(
-                    value
-                )
-                weaviate_filter = (
-                    prop_filter
-                    if weaviate_filter is None
-                    else weaviate.classes.query.Filter.all_of(
-                        [weaviate_filter, prop_filter]
-                    )
-                )
-
-        try:
-            response = collection.query.fetch_objects(
-                filters=weaviate_filter, limit=limit
-            )
-
-            ids = [str(obj.uuid) for obj in response.objects]
-            documents = []
-            metadatas = []
-
-            for obj in response.objects:
-                properties = dict(obj.properties) if obj.properties else {}
-                documents.append(properties.pop("text", ""))
-                metadatas.append(_convert_uuids_to_strings(properties))
-
-            return GetResult(
-                **{
-                    "ids": [ids],
-                    "documents": [documents],
-                    "metadatas": [metadatas],
-                }
-            )
-        except Exception:
-            return None
-
-    def get(self, collection_name: str) -> Optional[GetResult]:
-        sane_collection_name = self._sanitize_collection_name(collection_name)
-        if not self.client.collections.exists(sane_collection_name):
-            return None
-
-        collection = self.client.collections.get(sane_collection_name)
-        ids, documents, metadatas = [], [], []
-
-        try:
-            for item in collection.iterator():
-                ids.append(str(item.uuid))
-                properties = dict(item.properties) if item.properties else {}
-                documents.append(properties.pop("text", ""))
-                metadatas.append(_convert_uuids_to_strings(properties))
-
-            if not ids:
-                return None
-
-            return GetResult(
-                **{
-                    "ids": [ids],
-                    "documents": [documents],
-                    "metadatas": [metadatas],
-                }
-            )
-        except Exception:
-            return None
-
-    def delete(
-        self,
-        collection_name: str,
-        ids: Optional[List[str]] = None,
-        filter: Optional[Dict] = None,
-    ) -> None:
-        sane_collection_name = self._sanitize_collection_name(collection_name)
-        if not self.client.collections.exists(sane_collection_name):
-            return
-
-        collection = self.client.collections.get(sane_collection_name)
-
-        try:
-            if ids:
-                for item_id in ids:
-                    collection.data.delete_by_id(uuid=item_id)
-            elif filter:
-                weaviate_filter = None
-                for key, value in filter.items():
-                    prop_filter = weaviate.classes.query.Filter.by_property(
-                        name=key
-                    ).equal(value)
-                    weaviate_filter = (
-                        prop_filter
-                        if weaviate_filter is None
-                        else weaviate.classes.query.Filter.all_of(
-                            [weaviate_filter, prop_filter]
-                        )
-                    )
-
-                if weaviate_filter:
-                    collection.data.delete_many(where=weaviate_filter)
-        except Exception:
-            pass
-
-    def reset(self) -> None:
-        try:
-            for collection_name in self.client.collections.list_all().keys():
-                self.client.collections.delete(collection_name)
-        except Exception:
-            pass

backend/open_webui/retrieval/vector/factory.py

@@ -67,10 +67,6 @@ class Vector:
                 from open_webui.retrieval.vector.dbs.oracle23ai import Oracle23aiClient
 
                 return Oracle23aiClient()
-            case VectorType.WEAVIATE:
-                from open_webui.retrieval.vector.dbs.weaviate import WeaviateClient
-
-                return WeaviateClient()
             case _:
                 raise ValueError(f"Unsupported vector type: {vector_type}")
 

backend/open_webui/retrieval/vector/type.py

@@ -11,4 +11,3 @@ class VectorType(StrEnum):
     PGVECTOR = "pgvector"
     ORACLE23AI = "oracle23ai"
     S3VECTOR = "s3vector"
-    WEAVIATE = "weaviate"

backend/open_webui/retrieval/web/azure.py

@@ -1,128 +0,0 @@
-import logging
-from typing import Optional
-from open_webui.retrieval.web.main import SearchResult, get_filtered_results
-from open_webui.env import SRC_LOG_LEVELS
-
-log = logging.getLogger(__name__)
-log.setLevel(SRC_LOG_LEVELS["RAG"])
-
-"""
-Azure AI Search integration for Open WebUI.
-Documentation: https://learn.microsoft.com/en-us/python/api/overview/azure/search-documents-readme?view=azure-python
-
-Required package: azure-search-documents
-Install: pip install azure-search-documents
-"""
-
-
-def search_azure(
-    api_key: str,
-    endpoint: str,
-    index_name: str,
-    query: str,
-    count: int,
-    filter_list: Optional[list[str]] = None,
-) -> list[SearchResult]:
-    """
-    Search using Azure AI Search.
-
-    Args:
-        api_key: Azure Search API key (query key or admin key)
-        endpoint: Azure Search service endpoint (e.g., https://myservice.search.windows.net)
-        index_name: Name of the search index to query
-        query: Search query string
-        count: Number of results to return
-        filter_list: Optional list of domains to filter results
-
-    Returns:
-        List of SearchResult objects with link, title, and snippet
-    """
-    try:
-        from azure.core.credentials import AzureKeyCredential
-        from azure.search.documents import SearchClient
-    except ImportError:
-        log.error(
-            "azure-search-documents package is not installed. "
-            "Install it with: pip install azure-search-documents"
-        )
-        raise ImportError(
-            "azure-search-documents is required for Azure AI Search. "
-            "Install it with: pip install azure-search-documents"
-        )
-
-    try:
-        # Create search client with API key authentication
-        credential = AzureKeyCredential(api_key)
-        search_client = SearchClient(
-            endpoint=endpoint, index_name=index_name, credential=credential
-        )
-
-        # Perform the search
-        results = search_client.search(search_text=query, top=count)
-
-        # Convert results to list and extract fields
-        search_results = []
-        for result in results:
-            # Azure AI Search returns documents with custom schemas
-            # We need to extract common fields that might represent URL, title, and content
-            # Common field names to look for:
-            result_dict = dict(result)
-
-            # Try to find URL field (common names)
-            link = (
-                result_dict.get("url")
-                or result_dict.get("link")
-                or result_dict.get("uri")
-                or result_dict.get("metadata_storage_path")
-                or ""
-            )
-
-            # Try to find title field (common names)
-            title = (
-                result_dict.get("title")
-                or result_dict.get("name")
-                or result_dict.get("metadata_title")
-                or result_dict.get("metadata_storage_name")
-                or None
-            )
-
-            # Try to find content/snippet field (common names)
-            snippet = (
-                result_dict.get("content")
-                or result_dict.get("snippet")
-                or result_dict.get("description")
-                or result_dict.get("summary")
-                or result_dict.get("text")
-                or None
-            )
-
-            # Truncate snippet if too long
-            if snippet and len(snippet) > 500:
-                snippet = snippet[:497] + "..."
-
-            if link:  # Only add if we found a valid link
-                search_results.append(
-                    {
-                        "link": link,
-                        "title": title,
-                        "snippet": snippet,
-                    }
-                )
-
-        # Apply domain filtering if specified
-        if filter_list:
-            search_results = get_filtered_results(search_results, filter_list)
-
-        # Convert to SearchResult objects
-        return [
-            SearchResult(
-                link=result["link"],
-                title=result.get("title"),
-                snippet=result.get("snippet"),
-            )
-            for result in search_results
-        ]
-
-    except Exception as ex:
-        log.error(f"Azure AI Search error: {ex}")
-        raise ex

backend/open_webui/retrieval/web/external.py

@@ -2,42 +2,27 @@ import logging
 from typing import Optional, List
 
 import requests
-
-from fastapi import Request
-
-from open_webui.env import SRC_LOG_LEVELS
-
 from open_webui.retrieval.web.main import SearchResult, get_filtered_results
-from open_webui.utils.headers import include_user_info_headers
-
+from open_webui.env import SRC_LOG_LEVELS
 
 log = logging.getLogger(__name__)
 log.setLevel(SRC_LOG_LEVELS["RAG"])
 
 
 def search_external(
-    request: Request,
     external_url: str,
     external_api_key: str,
     query: str,
     count: int,
     filter_list: Optional[List[str]] = None,
-    user=None,
 ) -> List[SearchResult]:
     try:
-        headers = {
-            "User-Agent": "Open WebUI (https://github.com/open-webui/open-webui) RAG Bot",
-            "Authorization": f"Bearer {external_api_key}",
-        }
-        headers = include_user_info_headers(headers, user)
-
-        chat_id = getattr(request.state, "chat_id", None)
-        if chat_id:
-            headers["X-OpenWebUI-Chat-Id"] = str(chat_id)
-
         response = requests.post(
             external_url,
-            headers=headers,
+            headers={
+                "User-Agent": "Open WebUI (https://github.com/open-webui/open-webui) RAG Bot",
+                "Authorization": f"Bearer {external_api_key}",
+            },
             json={
                 "query": query,
                 "count": count,

backend/open_webui/retrieval/web/firecrawl.py

@@ -1,10 +1,11 @@
 import logging
 from typing import Optional, List
+from urllib.parse import urljoin
 
+import requests
 from open_webui.retrieval.web.main import SearchResult, get_filtered_results
 from open_webui.env import SRC_LOG_LEVELS
 
-
 log = logging.getLogger(__name__)
 log.setLevel(SRC_LOG_LEVELS["RAG"])
 
@@ -17,20 +18,27 @@ def search_firecrawl(
     filter_list: Optional[List[str]] = None,
 ) -> List[SearchResult]:
     try:
-        from firecrawl import FirecrawlApp
-
-        firecrawl = FirecrawlApp(api_key=firecrawl_api_key, api_url=firecrawl_url)
-        response = firecrawl.search(
-            query=query, limit=count, ignore_invalid_urls=True, timeout=count * 3
+        firecrawl_search_url = urljoin(firecrawl_url, "/v1/search")
+        response = requests.post(
+            firecrawl_search_url,
+            headers={
+                "User-Agent": "Open WebUI (https://github.com/open-webui/open-webui) RAG Bot",
+                "Authorization": f"Bearer {firecrawl_api_key}",
+            },
+            json={
+                "query": query,
+                "limit": count,
+            },
         )
-        results = response.web
+        response.raise_for_status()
+        results = response.json().get("data", [])
         if filter_list:
             results = get_filtered_results(results, filter_list)
         results = [
             SearchResult(
-                link=result.url,
-                title=result.title,
-                snippet=result.description,
+                link=result.get("url"),
+                title=result.get("title"),
+                snippet=result.get("description"),
             )
             for result in results[:count]
         ]

backend/open_webui/retrieval/web/google_pse.py

@@ -15,7 +15,6 @@ def search_google_pse(
     query: str,
     count: int,
     filter_list: Optional[list[str]] = None,
-    referer: Optional[str] = None,
 ) -> list[SearchResult]:
     """Search using Google's Programmable Search Engine API and return the results as a list of SearchResult objects.
     Handles pagination for counts greater than 10.
@@ -31,11 +30,7 @@ def search_google_pse(
         list[SearchResult]: A list of SearchResult objects.
     """
     url = "https://www.googleapis.com/customsearch/v1"
-
     headers = {"Content-Type": "application/json"}
-    if referer:
-        headers["Referer"] = referer
-
     all_results = []
     start_index = 1  # Google PSE start parameter is 1-based
 

backend/open_webui/retrieval/web/main.py

@@ -5,38 +5,18 @@ from urllib.parse import urlparse
 
 from pydantic import BaseModel
 
-from open_webui.retrieval.web.utils import resolve_hostname
-from open_webui.utils.misc import is_string_allowed
-
 
 def get_filtered_results(results, filter_list):
     if not filter_list:
         return results
-
     filtered_results = []
-
     for result in results:
         url = result.get("url") or result.get("link", "") or result.get("href", "")
         if not validators.url(url):
             continue
-
         domain = urlparse(url).netloc
-        if not domain:
-            continue
-
-        hostnames = [domain]
-
-        try:
-            ipv4_addresses, ipv6_addresses = resolve_hostname(domain)
-            hostnames.extend(ipv4_addresses)
-            hostnames.extend(ipv6_addresses)
-        except Exception:
-            pass
-
-        if is_string_allowed(hostnames, filter_list):
+        if any(domain.endswith(filtered_domain) for filtered_domain in filter_list):
             filtered_results.append(result)
-            continue
-
     return filtered_results
 
 

backend/open_webui/retrieval/web/perplexity_search.py

@@ -3,7 +3,6 @@ from typing import Optional, Literal
 import requests
 
 from open_webui.retrieval.web.main import SearchResult, get_filtered_results
-from open_webui.utils.headers import include_user_info_headers
 from open_webui.env import SRC_LOG_LEVELS
 
 
@@ -16,8 +15,6 @@ def search_perplexity_search(
     query: str,
     count: int,
     filter_list: Optional[list[str]] = None,
-    api_url: str = "https://api.perplexity.ai/search",
-    user=None,
 ) -> list[SearchResult]:
     """Search using Perplexity API and return the results as a list of SearchResult objects.
 
@@ -26,8 +23,6 @@ def search_perplexity_search(
       query (str): The query to search for
       count (int): Maximum number of results to return
       filter_list (Optional[list[str]]): List of domains to filter results
-      api_url (str): Custom API URL (defaults to https://api.perplexity.ai/search)
-      user: Optional user object for forwarding user info headers
 
     """
 
@@ -35,11 +30,8 @@ def search_perplexity_search(
     if hasattr(api_key, "__str__"):
         api_key = str(api_key)
 
-    if hasattr(api_url, "__str__"):
-        api_url = str(api_url)
-
     try:
-        url = api_url
+        url = "https://api.perplexity.ai/search"
 
         # Create payload for the API call
         payload = {
@@ -52,10 +44,6 @@ def search_perplexity_search(
             "Content-Type": "application/json",
         }
 
-        # Forward user info headers if user is provided
-        if user is not None:
-            headers = include_user_info_headers(headers, user)
-
         # Make the API request
         response = requests.request("POST", url, json=payload, headers=headers)
         # Parse the JSON response

backend/open_webui/retrieval/web/utils.py

@@ -4,6 +4,7 @@ import socket
 import ssl
 import urllib.parse
 import urllib.request
+from collections import defaultdict
 from datetime import datetime, time, timedelta
 from typing import (
     Any,
@@ -16,15 +17,13 @@ from typing import (
     Union,
     Literal,
 )
-
-from fastapi.concurrency import run_in_threadpool
 import aiohttp
 import certifi
 import validators
 from langchain_community.document_loaders import PlaywrightURLLoader, WebBaseLoader
+from langchain_community.document_loaders.firecrawl import FireCrawlLoader
 from langchain_community.document_loaders.base import BaseLoader
 from langchain_core.documents import Document
-
 from open_webui.retrieval.loaders.tavily import TavilyLoader
 from open_webui.retrieval.loaders.external_web import ExternalWebLoader
 from open_webui.constants import ERROR_MESSAGES
@@ -39,46 +38,17 @@ from open_webui.config import (
     TAVILY_EXTRACT_DEPTH,
     EXTERNAL_WEB_LOADER_URL,
     EXTERNAL_WEB_LOADER_API_KEY,
-    WEB_FETCH_FILTER_LIST,
 )
-from open_webui.env import SRC_LOG_LEVELS
-from open_webui.utils.misc import is_string_allowed
+from open_webui.env import SRC_LOG_LEVELS, AIOHTTP_CLIENT_SESSION_SSL
 
 log = logging.getLogger(__name__)
 log.setLevel(SRC_LOG_LEVELS["RAG"])
 
 
-def resolve_hostname(hostname):
-    # Get address information
-    addr_info = socket.getaddrinfo(hostname, None)
-
-    # Extract IP addresses from address information
-    ipv4_addresses = [info[4][0] for info in addr_info if info[0] == socket.AF_INET]
-    ipv6_addresses = [info[4][0] for info in addr_info if info[0] == socket.AF_INET6]
-
-    return ipv4_addresses, ipv6_addresses
-
-
 def validate_url(url: Union[str, Sequence[str]]):
     if isinstance(url, str):
         if isinstance(validators.url(url), validators.ValidationError):
             raise ValueError(ERROR_MESSAGES.INVALID_URL)
-
-        parsed_url = urllib.parse.urlparse(url)
-
-        # Protocol validation - only allow http/https
-        if parsed_url.scheme not in ["http", "https"]:
-            log.warning(
-                f"Blocked non-HTTP(S) protocol: {parsed_url.scheme} in URL: {url}"
-            )
-            raise ValueError(ERROR_MESSAGES.INVALID_URL)
-
-        # Blocklist check using unified filtering logic
-        if WEB_FETCH_FILTER_LIST:
-            if not is_string_allowed(url, WEB_FETCH_FILTER_LIST):
-                log.warning(f"URL blocked by filter list: {url}")
-                raise ValueError(ERROR_MESSAGES.INVALID_URL)
-
         if not ENABLE_RAG_LOCAL_WEB_FETCH:
             # Local web fetch is disabled, filter out any URLs that resolve to private IP addresses
             parsed_url = urllib.parse.urlparse(url)
@@ -111,6 +81,17 @@ def safe_validate_urls(url: Sequence[str]) -> Sequence[str]:
     return valid_urls
 
 
+def resolve_hostname(hostname):
+    # Get address information
+    addr_info = socket.getaddrinfo(hostname, None)
+
+    # Extract IP addresses from address information
+    ipv4_addresses = [info[4][0] for info in addr_info if info[0] == socket.AF_INET]
+    ipv6_addresses = [info[4][0] for info in addr_info if info[0] == socket.AF_INET6]
+
+    return ipv4_addresses, ipv6_addresses
+
+
 def extract_metadata(soup, url):
     metadata = {"source": url}
     if title := soup.find("title"):
@@ -161,13 +142,13 @@ class RateLimitMixin:
 
 
 class URLProcessingMixin:
-    async def _verify_ssl_cert(self, url: str) -> bool:
+    def _verify_ssl_cert(self, url: str) -> bool:
         """Verify SSL certificate for a URL."""
-        return await run_in_threadpool(verify_ssl_cert, url)
+        return verify_ssl_cert(url)
 
     async def _safe_process_url(self, url: str) -> bool:
         """Perform safety checks before processing a URL."""
-        if self.verify_ssl and not await self._verify_ssl_cert(url):
+        if self.verify_ssl and not self._verify_ssl_cert(url):
             raise ValueError(f"SSL certificate verification failed for {url}")
         await self._wait_for_rate_limit()
         return True
@@ -208,12 +189,13 @@ class SafeFireCrawlLoader(BaseLoader, RateLimitMixin, URLProcessingMixin):
                 (uses FIRE_CRAWL_API_KEY environment variable if not provided).
             api_url: Base URL for FireCrawl API. Defaults to official API endpoint.
             mode: Operation mode selection:
-                - 'crawl': Website crawling mode
-                - 'scrape': Direct page scraping (default)
+                - 'crawl': Website crawling mode (default)
+                - 'scrape': Direct page scraping
                 - 'map': Site map generation
             proxy: Proxy override settings for the FireCrawl API.
             params: The parameters to pass to the Firecrawl API.
-                For more details, visit: https://docs.firecrawl.dev/sdks/python#batch-scrape
+                Examples include crawlerOptions.
+                For more details, visit: https://github.com/mendableai/firecrawl-py
         """
         proxy_server = proxy.get("server") if proxy else None
         if trust_env and not proxy_server:
@@ -233,88 +215,50 @@ class SafeFireCrawlLoader(BaseLoader, RateLimitMixin, URLProcessingMixin):
         self.api_key = api_key
         self.api_url = api_url
         self.mode = mode
-        self.params = params or {}
+        self.params = params
 
     def lazy_load(self) -> Iterator[Document]:
-        """Load documents using FireCrawl batch_scrape."""
-        log.debug(
-            "Starting FireCrawl batch scrape for %d URLs, mode: %s, params: %s",
-            len(self.web_paths),
-            self.mode,
-            self.params,
-        )
-        try:
-            from firecrawl import FirecrawlApp
-
-            firecrawl = FirecrawlApp(api_key=self.api_key, api_url=self.api_url)
-            result = firecrawl.batch_scrape(
-                self.web_paths,
-                formats=["markdown"],
-                skip_tls_verification=not self.verify_ssl,
-                ignore_invalid_urls=True,
-                remove_base64_images=True,
-                max_age=300000,  # 5 minutes https://docs.firecrawl.dev/features/fast-scraping#common-maxage-values
-                wait_timeout=len(self.web_paths) * 3,
-                **self.params,
-            )
-
-            if result.status != "completed":
-                raise RuntimeError(
-                    f"FireCrawl batch scrape did not complete successfully. result: {result}"
+        """Load documents concurrently using FireCrawl."""
+        for url in self.web_paths:
+            try:
+                self._safe_process_url_sync(url)
+                loader = FireCrawlLoader(
+                    url=url,
+                    api_key=self.api_key,
+                    api_url=self.api_url,
+                    mode=self.mode,
+                    params=self.params,
                 )
-
-            for data in result.data:
-                metadata = data.metadata or {}
-                yield Document(
-                    page_content=data.markdown or "",
-                    metadata={"source": metadata.url or metadata.source_url or ""},
-                )
-
-        except Exception as e:
-            if self.continue_on_failure:
-                log.exception(f"Error extracting content from URLs: {e}")
-            else:
+                for document in loader.lazy_load():
+                    if not document.metadata.get("source"):
+                        document.metadata["source"] = document.metadata.get("sourceURL")
+                    yield document
+            except Exception as e:
+                if self.continue_on_failure:
+                    log.exception(f"Error loading {url}: {e}")
+                    continue
                 raise e
 
     async def alazy_load(self):
         """Async version of lazy_load."""
-        log.debug(
-            "Starting FireCrawl batch scrape for %d URLs, mode: %s, params: %s",
-            len(self.web_paths),
-            self.mode,
-            self.params,
-        )
-        try:
-            from firecrawl import FirecrawlApp
-
-            firecrawl = FirecrawlApp(api_key=self.api_key, api_url=self.api_url)
-            result = firecrawl.batch_scrape(
-                self.web_paths,
-                formats=["markdown"],
-                skip_tls_verification=not self.verify_ssl,
-                ignore_invalid_urls=True,
-                remove_base64_images=True,
-                max_age=300000,  # 5 minutes https://docs.firecrawl.dev/features/fast-scraping#common-maxage-values
-                wait_timeout=len(self.web_paths) * 3,
-                **self.params,
-            )
-
-            if result.status != "completed":
-                raise RuntimeError(
-                    f"FireCrawl batch scrape did not complete successfully. result: {result}"
+        for url in self.web_paths:
+            try:
+                await self._safe_process_url(url)
+                loader = FireCrawlLoader(
+                    url=url,
+                    api_key=self.api_key,
+                    api_url=self.api_url,
+                    mode=self.mode,
+                    params=self.params,
                 )
-
-            for data in result.data:
-                metadata = data.metadata or {}
-                yield Document(
-                    page_content=data.markdown or "",
-                    metadata={"source": metadata.url or metadata.source_url or ""},
-                )
-
-        except Exception as e:
-            if self.continue_on_failure:
-                log.exception(f"Error extracting content from URLs: {e}")
-            else:
+                async for document in loader.alazy_load():
+                    if not document.metadata.get("source"):
+                        document.metadata["source"] = document.metadata.get("sourceURL")
+                    yield document
+            except Exception as e:
+                if self.continue_on_failure:
+                    log.exception(f"Error loading {url}: {e}")
+                    continue
                 raise e
 
 
@@ -660,10 +604,6 @@ def get_web_loader(
     # Check if the URLs are valid
     safe_urls = safe_validate_urls([urls] if isinstance(urls, str) else urls)
 
-    if not safe_urls:
-        log.warning(f"All provided URLs were blocked or invalid: {urls}")
-        raise ValueError(ERROR_MESSAGES.INVALID_URL)
-
     web_loader_args = {
         "web_paths": safe_urls,
         "verify_ssl": verify_ssl,

backend/open_webui/routers/audio.py

@@ -4,7 +4,6 @@ import logging
 import os
 import uuid
 import html
-import base64
 from functools import lru_cache
 from pydub import AudioSegment
 from pydub.silence import split_on_silence
@@ -16,6 +15,7 @@ import aiohttp
 import aiofiles
 import requests
 import mimetypes
+from urllib.parse import urljoin, quote
 
 from fastapi import (
     Depends,
@@ -34,20 +34,18 @@ from pydantic import BaseModel
 
 
 from open_webui.utils.auth import get_admin_user, get_verified_user
-from open_webui.utils.headers import include_user_info_headers
 from open_webui.config import (
     WHISPER_MODEL_AUTO_UPDATE,
     WHISPER_MODEL_DIR,
     CACHE_DIR,
     WHISPER_LANGUAGE,
-    ELEVENLABS_API_BASE_URL,
 )
 
 from open_webui.constants import ERROR_MESSAGES
 from open_webui.env import (
-    ENV,
     AIOHTTP_CLIENT_SESSION_SSL,
     AIOHTTP_CLIENT_TIMEOUT,
+    ENV,
     SRC_LOG_LEVELS,
     DEVICE_TYPE,
     ENABLE_FORWARD_USER_INFO_HEADERS,
@@ -180,9 +178,6 @@ class STTConfigForm(BaseModel):
     AZURE_LOCALES: str
     AZURE_BASE_URL: str
     AZURE_MAX_SPEAKERS: str
-    MISTRAL_API_KEY: str
-    MISTRAL_API_BASE_URL: str
-    MISTRAL_USE_CHAT_COMPLETIONS: bool
 
 
 class AudioConfigUpdateForm(BaseModel):
@@ -219,9 +214,6 @@ async def get_audio_config(request: Request, user=Depends(get_admin_user)):
             "AZURE_LOCALES": request.app.state.config.AUDIO_STT_AZURE_LOCALES,
             "AZURE_BASE_URL": request.app.state.config.AUDIO_STT_AZURE_BASE_URL,
             "AZURE_MAX_SPEAKERS": request.app.state.config.AUDIO_STT_AZURE_MAX_SPEAKERS,
-            "MISTRAL_API_KEY": request.app.state.config.AUDIO_STT_MISTRAL_API_KEY,
-            "MISTRAL_API_BASE_URL": request.app.state.config.AUDIO_STT_MISTRAL_API_BASE_URL,
-            "MISTRAL_USE_CHAT_COMPLETIONS": request.app.state.config.AUDIO_STT_MISTRAL_USE_CHAT_COMPLETIONS,
         },
     }
 
@@ -263,13 +255,6 @@ async def update_audio_config(
     request.app.state.config.AUDIO_STT_AZURE_MAX_SPEAKERS = (
         form_data.stt.AZURE_MAX_SPEAKERS
     )
-    request.app.state.config.AUDIO_STT_MISTRAL_API_KEY = form_data.stt.MISTRAL_API_KEY
-    request.app.state.config.AUDIO_STT_MISTRAL_API_BASE_URL = (
-        form_data.stt.MISTRAL_API_BASE_URL
-    )
-    request.app.state.config.AUDIO_STT_MISTRAL_USE_CHAT_COMPLETIONS = (
-        form_data.stt.MISTRAL_USE_CHAT_COMPLETIONS
-    )
 
     if request.app.state.config.STT_ENGINE == "":
         request.app.state.faster_whisper_model = set_faster_whisper_model(
@@ -305,9 +290,6 @@ async def update_audio_config(
             "AZURE_LOCALES": request.app.state.config.AUDIO_STT_AZURE_LOCALES,
             "AZURE_BASE_URL": request.app.state.config.AUDIO_STT_AZURE_BASE_URL,
             "AZURE_MAX_SPEAKERS": request.app.state.config.AUDIO_STT_AZURE_MAX_SPEAKERS,
-            "MISTRAL_API_KEY": request.app.state.config.AUDIO_STT_MISTRAL_API_KEY,
-            "MISTRAL_API_BASE_URL": request.app.state.config.AUDIO_STT_MISTRAL_API_BASE_URL,
-            "MISTRAL_USE_CHAT_COMPLETIONS": request.app.state.config.AUDIO_STT_MISTRAL_USE_CHAT_COMPLETIONS,
         },
     }
 
@@ -364,17 +346,23 @@ async def speech(request: Request, user=Depends(get_verified_user)):
                     **(request.app.state.config.TTS_OPENAI_PARAMS or {}),
                 }
 
-                headers = {
-                    "Content-Type": "application/json",
-                    "Authorization": f"Bearer {request.app.state.config.TTS_OPENAI_API_KEY}",
-                }
-                if ENABLE_FORWARD_USER_INFO_HEADERS:
-                    headers = include_user_info_headers(headers, user)
-
                 r = await session.post(
                     url=f"{request.app.state.config.TTS_OPENAI_API_BASE_URL}/audio/speech",
                     json=payload,
-                    headers=headers,
+                    headers={
+                        "Content-Type": "application/json",
+                        "Authorization": f"Bearer {request.app.state.config.TTS_OPENAI_API_KEY}",
+                        **(
+                            {
+                                "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
+                                "X-OpenWebUI-User-Id": user.id,
+                                "X-OpenWebUI-User-Email": user.email,
+                                "X-OpenWebUI-User-Role": user.role,
+                            }
+                            if ENABLE_FORWARD_USER_INFO_HEADERS
+                            else {}
+                        ),
+                    },
                     ssl=AIOHTTP_CLIENT_SESSION_SSL,
                 )
 
@@ -425,7 +413,7 @@ async def speech(request: Request, user=Depends(get_verified_user)):
                 timeout=timeout, trust_env=True
             ) as session:
                 async with session.post(
-                    f"{ELEVENLABS_API_BASE_URL}/v1/text-to-speech/{voice_id}",
+                    f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}",
                     json={
                         "text": payload["input"],
                         "model_id": request.app.state.config.TTS_MODEL,
@@ -564,7 +552,7 @@ async def speech(request: Request, user=Depends(get_verified_user)):
         return FileResponse(file_path)
 
 
-def transcription_handler(request, file_path, metadata, user=None):
+def transcription_handler(request, file_path, metadata):
     filename = os.path.basename(file_path)
     file_dir = os.path.dirname(file_path)
     id = filename.split(".")[0]
@@ -615,15 +603,11 @@ def transcription_handler(request, file_path, metadata, user=None):
                 if language:
                     payload["language"] = language
 
-                headers = {
-                    "Authorization": f"Bearer {request.app.state.config.STT_OPENAI_API_KEY}"
-                }
-                if user and ENABLE_FORWARD_USER_INFO_HEADERS:
-                    headers = include_user_info_headers(headers, user)
-
                 r = requests.post(
                     url=f"{request.app.state.config.STT_OPENAI_API_BASE_URL}/audio/transcriptions",
-                    headers=headers,
+                    headers={
+                        "Authorization": f"Bearer {request.app.state.config.STT_OPENAI_API_KEY}"
+                    },
                     files={"file": (filename, open(file_path, "rb"))},
                     data=payload,
                 )
@@ -844,190 +828,8 @@ def transcription_handler(request, file_path, metadata, user=None):
                 detail=detail if detail else "Open WebUI: Server Connection Error",
             )
 
-    elif request.app.state.config.STT_ENGINE == "mistral":
-        # Check file exists
-        if not os.path.exists(file_path):
-            raise HTTPException(status_code=400, detail="Audio file not found")
 
-        # Check file size
-        file_size = os.path.getsize(file_path)
-        if file_size > MAX_FILE_SIZE:
-            raise HTTPException(
-                status_code=400,
-                detail=f"File size exceeds limit of {MAX_FILE_SIZE_MB}MB",
-            )
-
-        api_key = request.app.state.config.AUDIO_STT_MISTRAL_API_KEY
-        api_base_url = (
-            request.app.state.config.AUDIO_STT_MISTRAL_API_BASE_URL
-            or "https://api.mistral.ai/v1"
-        )
-        use_chat_completions = (
-            request.app.state.config.AUDIO_STT_MISTRAL_USE_CHAT_COMPLETIONS
-        )
-
-        if not api_key:
-            raise HTTPException(
-                status_code=400,
-                detail="Mistral API key is required for Mistral STT",
-            )
-
-        r = None
-        try:
-            # Use voxtral-mini-latest as the default model for transcription
-            model = request.app.state.config.STT_MODEL or "voxtral-mini-latest"
-
-            log.info(
-                f"Mistral STT - model: {model}, "
-                f"method: {'chat_completions' if use_chat_completions else 'transcriptions'}"
-            )
-
-            if use_chat_completions:
-                # Use chat completions API with audio input
-                # This method requires mp3 or wav format
-                audio_file_to_use = file_path
-
-                if is_audio_conversion_required(file_path):
-                    log.debug("Converting audio to mp3 for chat completions API")
-                    converted_path = convert_audio_to_mp3(file_path)
-                    if converted_path:
-                        audio_file_to_use = converted_path
-                    else:
-                        log.error("Audio conversion failed")
-                        raise HTTPException(
-                            status_code=500,
-                            detail="Audio conversion failed. Chat completions API requires mp3 or wav format.",
-                        )
-
-                # Read and encode audio file as base64
-                with open(audio_file_to_use, "rb") as audio_file:
-                    audio_base64 = base64.b64encode(audio_file.read()).decode("utf-8")
-
-                # Prepare chat completions request
-                url = f"{api_base_url}/chat/completions"
-
-                # Add language instruction if specified
-                language = metadata.get("language", None) if metadata else None
-                if language:
-                    text_instruction = f"Transcribe this audio exactly as spoken in {language}. Do not translate it."
-                else:
-                    text_instruction = "Transcribe this audio exactly as spoken in its original language. Do not translate it to another language."
-
-                payload = {
-                    "model": model,
-                    "messages": [
-                        {
-                            "role": "user",
-                            "content": [
-                                {
-                                    "type": "input_audio",
-                                    "input_audio": audio_base64,
-                                },
-                                {"type": "text", "text": text_instruction},
-                            ],
-                        }
-                    ],
-                }
-
-                r = requests.post(
-                    url=url,
-                    json=payload,
-                    headers={
-                        "Authorization": f"Bearer {api_key}",
-                        "Content-Type": "application/json",
-                    },
-                )
-
-                r.raise_for_status()
-                response = r.json()
-
-                # Extract transcript from chat completion response
-                transcript = (
-                    response.get("choices", [{}])[0]
-                    .get("message", {})
-                    .get("content", "")
-                    .strip()
-                )
-                if not transcript:
-                    raise ValueError("Empty transcript in response")
-
-                data = {"text": transcript}
-
-            else:
-                # Use dedicated transcriptions API
-                url = f"{api_base_url}/audio/transcriptions"
-
-                # Determine the MIME type
-                mime_type, _ = mimetypes.guess_type(file_path)
-                if not mime_type:
-                    mime_type = "audio/webm"
-
-                # Use context manager to ensure file is properly closed
-                with open(file_path, "rb") as audio_file:
-                    files = {"file": (filename, audio_file, mime_type)}
-                    data_form = {"model": model}
-
-                    # Add language if specified in metadata
-                    language = metadata.get("language", None) if metadata else None
-                    if language:
-                        data_form["language"] = language
-
-                    r = requests.post(
-                        url=url,
-                        files=files,
-                        data=data_form,
-                        headers={
-                            "Authorization": f"Bearer {api_key}",
-                        },
-                    )
-
-                r.raise_for_status()
-                response = r.json()
-
-                # Extract transcript from response
-                transcript = response.get("text", "").strip()
-                if not transcript:
-                    raise ValueError("Empty transcript in response")
-
-                data = {"text": transcript}
-
-            # Save transcript to json file (consistent with other providers)
-            transcript_file = f"{file_dir}/{id}.json"
-            with open(transcript_file, "w") as f:
-                json.dump(data, f)
-
-            log.debug(data)
-            return data
-
-        except ValueError as e:
-            log.exception("Error parsing Mistral response")
-            raise HTTPException(
-                status_code=500,
-                detail=f"Failed to parse Mistral response: {str(e)}",
-            )
-        except requests.exceptions.RequestException as e:
-            log.exception(e)
-            detail = None
-
-            try:
-                if r is not None and r.status_code != 200:
-                    res = r.json()
-                    if "error" in res:
-                        detail = f"External: {res['error'].get('message', '')}"
-                    else:
-                        detail = f"External: {r.text}"
-            except Exception:
-                detail = f"External: {e}"
-
-            raise HTTPException(
-                status_code=getattr(r, "status_code", 500) if r else 500,
-                detail=detail if detail else "Open WebUI: Server Connection Error",
-            )
-
-
-def transcribe(
-    request: Request, file_path: str, metadata: Optional[dict] = None, user=None
-):
+def transcribe(request: Request, file_path: str, metadata: Optional[dict] = None):
     log.info(f"transcribe: {file_path} {metadata}")
 
     if is_audio_conversion_required(file_path):
@@ -1054,9 +856,7 @@ def transcribe(
         with ThreadPoolExecutor() as executor:
             # Submit tasks for each chunk_path
             futures = [
-                executor.submit(
-                    transcription_handler, request, chunk_path, metadata, user
-                )
+                executor.submit(transcription_handler, request, chunk_path, metadata)
                 for chunk_path in chunk_paths
             ]
             # Gather results as they complete
@@ -1191,7 +991,7 @@ def transcription(
             if language:
                 metadata = {"language": language}
 
-            result = transcribe(request, file_path, metadata, user)
+            result = transcribe(request, file_path, metadata)
 
             return {
                 **result,
@@ -1237,7 +1037,7 @@ def get_available_models(request: Request) -> list[dict]:
     elif request.app.state.config.TTS_ENGINE == "elevenlabs":
         try:
             response = requests.get(
-                f"{ELEVENLABS_API_BASE_URL}/v1/models",
+                "https://api.elevenlabs.io/v1/models",
                 headers={
                     "xi-api-key": request.app.state.config.TTS_API_KEY,
                     "Content-Type": "application/json",
@@ -1341,7 +1141,7 @@ def get_elevenlabs_voices(api_key: str) -> dict:
     try:
         # TODO: Add retries
         response = requests.get(
-            f"{ELEVENLABS_API_BASE_URL}/v1/voices",
+            "https://api.elevenlabs.io/v1/voices",
             headers={
                 "xi-api-key": api_key,
                 "Content-Type": "application/json",

backend/open_webui/routers/auths.py

@@ -4,8 +4,6 @@ import time
 import datetime
 import logging
 from aiohttp import ClientSession
-import urllib
-
 
 from open_webui.models.auths import (
     AddUserForm,
@@ -17,13 +15,9 @@ from open_webui.models.auths import (
     SigninResponse,
     SignupForm,
     UpdatePasswordForm,
+    UserResponse,
 )
-from open_webui.models.users import (
-    UserProfileImageResponse,
-    Users,
-    UpdateProfileForm,
-    UserStatus,
-)
+from open_webui.models.users import Users, UpdateProfileForm
 from open_webui.models.groups import Groups
 from open_webui.models.oauth_sessions import OAuthSessions
 
@@ -41,20 +35,12 @@ from open_webui.env import (
 )
 from fastapi import APIRouter, Depends, HTTPException, Request, status
 from fastapi.responses import RedirectResponse, Response, JSONResponse
-from open_webui.config import (
-    OPENID_PROVIDER_URL,
-    ENABLE_OAUTH_SIGNUP,
-    ENABLE_LDAP,
-    ENABLE_PASSWORD_AUTH,
-)
+from open_webui.config import OPENID_PROVIDER_URL, ENABLE_OAUTH_SIGNUP, ENABLE_LDAP
 from pydantic import BaseModel
 
 from open_webui.utils.misc import parse_duration, validate_email_format
 from open_webui.utils.auth import (
-    validate_password,
-    verify_password,
     decode_token,
-    invalidate_token,
     create_api_key,
     create_token,
     get_admin_user,
@@ -64,12 +50,7 @@ from open_webui.utils.auth import (
     get_http_authorization_cred,
 )
 from open_webui.utils.webhook import post_webhook
-from open_webui.utils.access_control import get_permissions, has_permission
-from open_webui.utils.groups import apply_default_group_assignment
-
-from open_webui.utils.redis import get_redis_client
-from open_webui.utils.rate_limit import RateLimiter
-
+from open_webui.utils.access_control import get_permissions
 
 from typing import Optional, List
 
@@ -83,21 +64,17 @@ router = APIRouter()
 log = logging.getLogger(__name__)
 log.setLevel(SRC_LOG_LEVELS["MAIN"])
 
-signin_rate_limiter = RateLimiter(
-    redis_client=get_redis_client(), limit=5 * 3, window=60 * 3
-)
-
 ############################
 # GetSessionUser
 ############################
 
 
-class SessionUserResponse(Token, UserProfileImageResponse):
+class SessionUserResponse(Token, UserResponse):
     expires_at: Optional[int] = None
     permissions: Optional[dict] = None
 
 
-class SessionUserInfoResponse(SessionUserResponse, UserStatus):
+class SessionUserInfoResponse(SessionUserResponse):
     bio: Optional[str] = None
     gender: Optional[str] = None
     date_of_birth: Optional[datetime.date] = None
@@ -154,9 +131,6 @@ async def get_session_user(
         "bio": user.bio,
         "gender": user.gender,
         "date_of_birth": user.date_of_birth,
-        "status_emoji": user.status_emoji,
-        "status_message": user.status_message,
-        "status_expires_at": user.status_expires_at,
         "permissions": user_permissions,
     }
 
@@ -166,7 +140,7 @@ async def get_session_user(
 ############################
 
 
-@router.post("/update/profile", response_model=UserProfileImageResponse)
+@router.post("/update/profile", response_model=UserResponse)
 async def update_profile(
     form_data: UpdateProfileForm, session_user=Depends(get_verified_user)
 ):
@@ -195,19 +169,13 @@ async def update_password(
     if WEBUI_AUTH_TRUSTED_EMAIL_HEADER:
         raise HTTPException(400, detail=ERROR_MESSAGES.ACTION_PROHIBITED)
     if session_user:
-        user = Auths.authenticate_user(
-            session_user.email, lambda pw: verify_password(form_data.password, pw)
-        )
+        user = Auths.authenticate_user(session_user.email, form_data.password)
 
         if user:
-            try:
-                validate_password(form_data.password)
-            except Exception as e:
-                raise HTTPException(400, detail=str(e))
             hashed = get_password_hash(form_data.new_password)
             return Auths.update_user_password_by_id(user.id, hashed)
         else:
-            raise HTTPException(400, detail=ERROR_MESSAGES.INCORRECT_PASSWORD)
+            raise HTTPException(400, detail=ERROR_MESSAGES.INVALID_PASSWORD)
     else:
         raise HTTPException(400, detail=ERROR_MESSAGES.INVALID_CRED)
 
@@ -217,17 +185,7 @@ async def update_password(
 ############################
 @router.post("/ldap", response_model=SessionUserResponse)
 async def ldap_auth(request: Request, response: Response, form_data: LdapForm):
-    # Security checks FIRST - before loading any config
-    if not request.app.state.config.ENABLE_LDAP:
-        raise HTTPException(400, detail="LDAP authentication is not enabled")
-
-    if not ENABLE_PASSWORD_AUTH:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail=ERROR_MESSAGES.ACTION_PROHIBITED,
-        )
-
-    # NOW load LDAP config variables
+    ENABLE_LDAP = request.app.state.config.ENABLE_LDAP
     LDAP_SERVER_LABEL = request.app.state.config.LDAP_SERVER_LABEL
     LDAP_SERVER_HOST = request.app.state.config.LDAP_SERVER_HOST
     LDAP_SERVER_PORT = request.app.state.config.LDAP_SERVER_PORT
@@ -248,6 +206,9 @@ async def ldap_auth(request: Request, response: Response, form_data: LdapForm):
         else "ALL"
     )
 
+    if not ENABLE_LDAP:
+        raise HTTPException(400, detail="LDAP authentication is not enabled")
+
     try:
         tls = Tls(
             validate=LDAP_VALIDATE_CERT,
@@ -418,11 +379,6 @@ async def ldap_auth(request: Request, response: Response, form_data: LdapForm):
                             500, detail=ERROR_MESSAGES.CREATE_USER_ERROR
                         )
 
-                    apply_default_group_assignment(
-                        request.app.state.config.DEFAULT_GROUP_ID,
-                        user.id,
-                    )
-
                 except HTTPException:
                     raise
                 except Exception as err:
@@ -471,6 +427,7 @@ async def ldap_auth(request: Request, response: Response, form_data: LdapForm):
                 ):
                     if ENABLE_LDAP_GROUP_CREATION:
                         Groups.create_groups_by_group_names(user.id, user_groups)
+
                     try:
                         Groups.sync_groups_by_group_names(user.id, user_groups)
                         log.info(
@@ -506,12 +463,6 @@ async def ldap_auth(request: Request, response: Response, form_data: LdapForm):
 
 @router.post("/signin", response_model=SessionUserResponse)
 async def signin(request: Request, response: Response, form_data: SigninForm):
-    if not ENABLE_PASSWORD_AUTH:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail=ERROR_MESSAGES.ACTION_PROHIBITED,
-        )
-
     if WEBUI_AUTH_TRUSTED_EMAIL_HEADER:
         if WEBUI_AUTH_TRUSTED_EMAIL_HEADER not in request.headers:
             raise HTTPException(400, detail=ERROR_MESSAGES.INVALID_TRUSTED_HEADER)
@@ -521,10 +472,6 @@ async def signin(request: Request, response: Response, form_data: SigninForm):
 
         if WEBUI_AUTH_TRUSTED_NAME_HEADER:
             name = request.headers.get(WEBUI_AUTH_TRUSTED_NAME_HEADER, email)
-            try:
-                name = urllib.parse.unquote(name, encoding="utf-8")
-            except Exception as e:
-                pass
 
         if not Users.get_user_by_email(email.lower()):
             await signup(
@@ -548,9 +495,7 @@ async def signin(request: Request, response: Response, form_data: SigninForm):
         admin_password = "admin"
 
         if Users.get_user_by_email(admin_email.lower()):
-            user = Auths.authenticate_user(
-                admin_email.lower(), lambda pw: verify_password(admin_password, pw)
-            )
+            user = Auths.authenticate_user(admin_email.lower(), admin_password)
         else:
             if Users.has_users():
                 raise HTTPException(400, detail=ERROR_MESSAGES.EXISTING_USERS)
@@ -561,28 +506,9 @@ async def signin(request: Request, response: Response, form_data: SigninForm):
                 SignupForm(email=admin_email, password=admin_password, name="User"),
             )
 
-            user = Auths.authenticate_user(
-                admin_email.lower(), lambda pw: verify_password(admin_password, pw)
-            )
+            user = Auths.authenticate_user(admin_email.lower(), admin_password)
     else:
-        if signin_rate_limiter.is_limited(form_data.email.lower()):
-            raise HTTPException(
-                status_code=status.HTTP_429_TOO_MANY_REQUESTS,
-                detail=ERROR_MESSAGES.RATE_LIMIT_EXCEEDED,
-            )
-
-        password_bytes = form_data.password.encode("utf-8")
-        if len(password_bytes) > 72:
-            # TODO: Implement other hashing algorithms that support longer passwords
-            log.info("Password too long, truncating to 72 bytes for bcrypt")
-            password_bytes = password_bytes[:72]
-
-            # decode safely — ignore incomplete UTF-8 sequences
-            form_data.password = password_bytes.decode("utf-8", errors="ignore")
-
-        user = Auths.authenticate_user(
-            form_data.email.lower(), lambda pw: verify_password(form_data.password, pw)
-        )
+        user = Auths.authenticate_user(form_data.email.lower(), form_data.password)
 
     if user:
 
@@ -664,14 +590,16 @@ async def signup(request: Request, response: Response, form_data: SignupForm):
         raise HTTPException(400, detail=ERROR_MESSAGES.EMAIL_TAKEN)
 
     try:
-        try:
-            validate_password(form_data.password)
-        except Exception as e:
-            raise HTTPException(400, detail=str(e))
+        role = "admin" if not has_users else request.app.state.config.DEFAULT_USER_ROLE
+
+        # The password passed to bcrypt must be 72 bytes or fewer. If it is longer, it will be truncated before hashing.
+        if len(form_data.password.encode("utf-8")) > 72:
+            raise HTTPException(
+                status.HTTP_400_BAD_REQUEST,
+                detail=ERROR_MESSAGES.PASSWORD_TOO_LONG,
+            )
 
         hashed = get_password_hash(form_data.password)
-
-        role = "admin" if not has_users else request.app.state.config.DEFAULT_USER_ROLE
         user = Auths.insert_new_auth(
             form_data.email.lower(),
             hashed,
@@ -727,11 +655,6 @@ async def signup(request: Request, response: Response, form_data: SignupForm):
                 # Disable signup after the first user is created
                 request.app.state.config.ENABLE_SIGNUP = False
 
-            apply_default_group_assignment(
-                request.app.state.config.DEFAULT_GROUP_ID,
-                user.id,
-            )
-
             return {
                 "token": token,
                 "token_type": "Bearer",
@@ -752,19 +675,6 @@ async def signup(request: Request, response: Response, form_data: SignupForm):
 
 @router.get("/signout")
 async def signout(request: Request, response: Response):
-
-    # get auth token from headers or cookies
-    token = None
-    auth_header = request.headers.get("Authorization")
-    if auth_header:
-        auth_cred = get_http_authorization_cred(auth_header)
-        token = auth_cred.credentials
-    else:
-        token = request.cookies.get("token")
-
-    if token:
-        await invalidate_token(request, token)
-
     response.delete_cookie("token")
     response.delete_cookie("oui-session")
     response.delete_cookie("oauth_id_token")
@@ -835,9 +745,7 @@ async def signout(request: Request, response: Response):
 
 
 @router.post("/add", response_model=SigninResponse)
-async def add_user(
-    request: Request, form_data: AddUserForm, user=Depends(get_admin_user)
-):
+async def add_user(form_data: AddUserForm, user=Depends(get_admin_user)):
     if not validate_email_format(form_data.email.lower()):
         raise HTTPException(
             status.HTTP_400_BAD_REQUEST, detail=ERROR_MESSAGES.INVALID_EMAIL_FORMAT
@@ -847,11 +755,6 @@ async def add_user(
         raise HTTPException(400, detail=ERROR_MESSAGES.EMAIL_TAKEN)
 
     try:
-        try:
-            validate_password(form_data.password)
-        except Exception as e:
-            raise HTTPException(400, detail=str(e))
-
         hashed = get_password_hash(form_data.password)
         user = Auths.insert_new_auth(
             form_data.email.lower(),
@@ -862,11 +765,6 @@ async def add_user(
         )
 
         if user:
-            apply_default_group_assignment(
-                request.app.state.config.DEFAULT_GROUP_ID,
-                user.id,
-            )
-
             token = create_token(data={"id": user.id})
             return {
                 "token": token,
@@ -928,15 +826,13 @@ async def get_admin_config(request: Request, user=Depends(get_admin_user)):
         "SHOW_ADMIN_DETAILS": request.app.state.config.SHOW_ADMIN_DETAILS,
         "WEBUI_URL": request.app.state.config.WEBUI_URL,
         "ENABLE_SIGNUP": request.app.state.config.ENABLE_SIGNUP,
-        "ENABLE_API_KEYS": request.app.state.config.ENABLE_API_KEYS,
-        "ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS": request.app.state.config.ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS,
-        "API_KEYS_ALLOWED_ENDPOINTS": request.app.state.config.API_KEYS_ALLOWED_ENDPOINTS,
+        "ENABLE_API_KEY": request.app.state.config.ENABLE_API_KEY,
+        "ENABLE_API_KEY_ENDPOINT_RESTRICTIONS": request.app.state.config.ENABLE_API_KEY_ENDPOINT_RESTRICTIONS,
+        "API_KEY_ALLOWED_ENDPOINTS": request.app.state.config.API_KEY_ALLOWED_ENDPOINTS,
         "DEFAULT_USER_ROLE": request.app.state.config.DEFAULT_USER_ROLE,
-        "DEFAULT_GROUP_ID": request.app.state.config.DEFAULT_GROUP_ID,
         "JWT_EXPIRES_IN": request.app.state.config.JWT_EXPIRES_IN,
         "ENABLE_COMMUNITY_SHARING": request.app.state.config.ENABLE_COMMUNITY_SHARING,
         "ENABLE_MESSAGE_RATING": request.app.state.config.ENABLE_MESSAGE_RATING,
-        "ENABLE_FOLDERS": request.app.state.config.ENABLE_FOLDERS,
         "ENABLE_CHANNELS": request.app.state.config.ENABLE_CHANNELS,
         "ENABLE_NOTES": request.app.state.config.ENABLE_NOTES,
         "ENABLE_USER_WEBHOOKS": request.app.state.config.ENABLE_USER_WEBHOOKS,
@@ -950,15 +846,13 @@ class AdminConfig(BaseModel):
     SHOW_ADMIN_DETAILS: bool
     WEBUI_URL: str
     ENABLE_SIGNUP: bool
-    ENABLE_API_KEYS: bool
-    ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS: bool
-    API_KEYS_ALLOWED_ENDPOINTS: str
+    ENABLE_API_KEY: bool
+    ENABLE_API_KEY_ENDPOINT_RESTRICTIONS: bool
+    API_KEY_ALLOWED_ENDPOINTS: str
     DEFAULT_USER_ROLE: str
-    DEFAULT_GROUP_ID: str
     JWT_EXPIRES_IN: str
     ENABLE_COMMUNITY_SHARING: bool
     ENABLE_MESSAGE_RATING: bool
-    ENABLE_FOLDERS: bool
     ENABLE_CHANNELS: bool
     ENABLE_NOTES: bool
     ENABLE_USER_WEBHOOKS: bool
@@ -975,23 +869,20 @@ async def update_admin_config(
     request.app.state.config.WEBUI_URL = form_data.WEBUI_URL
     request.app.state.config.ENABLE_SIGNUP = form_data.ENABLE_SIGNUP
 
-    request.app.state.config.ENABLE_API_KEYS = form_data.ENABLE_API_KEYS
-    request.app.state.config.ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS = (
-        form_data.ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS
+    request.app.state.config.ENABLE_API_KEY = form_data.ENABLE_API_KEY
+    request.app.state.config.ENABLE_API_KEY_ENDPOINT_RESTRICTIONS = (
+        form_data.ENABLE_API_KEY_ENDPOINT_RESTRICTIONS
     )
-    request.app.state.config.API_KEYS_ALLOWED_ENDPOINTS = (
-        form_data.API_KEYS_ALLOWED_ENDPOINTS
+    request.app.state.config.API_KEY_ALLOWED_ENDPOINTS = (
+        form_data.API_KEY_ALLOWED_ENDPOINTS
     )
 
-    request.app.state.config.ENABLE_FOLDERS = form_data.ENABLE_FOLDERS
     request.app.state.config.ENABLE_CHANNELS = form_data.ENABLE_CHANNELS
     request.app.state.config.ENABLE_NOTES = form_data.ENABLE_NOTES
 
     if form_data.DEFAULT_USER_ROLE in ["pending", "user", "admin"]:
         request.app.state.config.DEFAULT_USER_ROLE = form_data.DEFAULT_USER_ROLE
 
-    request.app.state.config.DEFAULT_GROUP_ID = form_data.DEFAULT_GROUP_ID
-
     pattern = r"^(-1|0|(-?\d+(\.\d+)?)(ms|s|m|h|d|w))$"
 
     # Check if the input string matches the pattern
@@ -1018,15 +909,13 @@ async def update_admin_config(
         "SHOW_ADMIN_DETAILS": request.app.state.config.SHOW_ADMIN_DETAILS,
         "WEBUI_URL": request.app.state.config.WEBUI_URL,
         "ENABLE_SIGNUP": request.app.state.config.ENABLE_SIGNUP,
-        "ENABLE_API_KEYS": request.app.state.config.ENABLE_API_KEYS,
-        "ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS": request.app.state.config.ENABLE_API_KEYS_ENDPOINT_RESTRICTIONS,
-        "API_KEYS_ALLOWED_ENDPOINTS": request.app.state.config.API_KEYS_ALLOWED_ENDPOINTS,
+        "ENABLE_API_KEY": request.app.state.config.ENABLE_API_KEY,
+        "ENABLE_API_KEY_ENDPOINT_RESTRICTIONS": request.app.state.config.ENABLE_API_KEY_ENDPOINT_RESTRICTIONS,
+        "API_KEY_ALLOWED_ENDPOINTS": request.app.state.config.API_KEY_ALLOWED_ENDPOINTS,
         "DEFAULT_USER_ROLE": request.app.state.config.DEFAULT_USER_ROLE,
-        "DEFAULT_GROUP_ID": request.app.state.config.DEFAULT_GROUP_ID,
         "JWT_EXPIRES_IN": request.app.state.config.JWT_EXPIRES_IN,
         "ENABLE_COMMUNITY_SHARING": request.app.state.config.ENABLE_COMMUNITY_SHARING,
         "ENABLE_MESSAGE_RATING": request.app.state.config.ENABLE_MESSAGE_RATING,
-        "ENABLE_FOLDERS": request.app.state.config.ENABLE_FOLDERS,
         "ENABLE_CHANNELS": request.app.state.config.ENABLE_CHANNELS,
         "ENABLE_NOTES": request.app.state.config.ENABLE_NOTES,
         "ENABLE_USER_WEBHOOKS": request.app.state.config.ENABLE_USER_WEBHOOKS,
@@ -1147,11 +1036,9 @@ async def update_ldap_config(
 # create api key
 @router.post("/api_key", response_model=ApiKey)
 async def generate_api_key(request: Request, user=Depends(get_current_user)):
-    if not request.app.state.config.ENABLE_API_KEYS or not has_permission(
-        user.id, "features.api_keys", request.app.state.config.USER_PERMISSIONS
-    ):
+    if not request.app.state.config.ENABLE_API_KEY:
         raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
+            status.HTTP_403_FORBIDDEN,
             detail=ERROR_MESSAGES.API_KEY_CREATION_NOT_ALLOWED,
         )
 
@@ -1169,7 +1056,8 @@ async def generate_api_key(request: Request, user=Depends(get_current_user)):
 # delete api key
 @router.delete("/api_key", response_model=bool)
 async def delete_api_key(user=Depends(get_current_user)):
-    return Users.delete_user_api_key_by_id(user.id)
+    success = Users.update_user_api_key_by_id(user.id, None)
+    return success
 
 
 # get api key

backend/open_webui/routers/chats.py

@@ -7,7 +7,6 @@ from open_webui.socket.main import get_event_emitter
 from open_webui.models.chats import (
     ChatForm,
     ChatImportForm,
-    ChatsImportForm,
     ChatResponse,
     Chats,
     ChatTitleIdResponse,
@@ -143,15 +142,26 @@ async def create_new_chat(form_data: ChatForm, user=Depends(get_verified_user)):
 
 
 ############################
-# ImportChats
+# ImportChat
 ############################
 
 
-@router.post("/import", response_model=list[ChatResponse])
-async def import_chats(form_data: ChatsImportForm, user=Depends(get_verified_user)):
+@router.post("/import", response_model=Optional[ChatResponse])
+async def import_chat(form_data: ChatImportForm, user=Depends(get_verified_user)):
     try:
-        chats = Chats.import_chats(user.id, form_data.chats)
-        return chats
+        chat = Chats.import_chat(user.id, form_data)
+        if chat:
+            tags = chat.meta.get("tags", [])
+            for tag_id in tags:
+                tag_id = tag_id.replace(" ", "_").lower()
+                tag_name = " ".join([word.capitalize() for word in tag_id.split("_")])
+                if (
+                    tag_id != "none"
+                    and Tags.get_tag_by_name_and_user_id(tag_name, user.id) is None
+                ):
+                    Tags.insert_new_tag(tag_name, user.id)
+
+        return ChatResponse(**chat.model_dump())
     except Exception as e:
         log.exception(e)
         raise HTTPException(
@@ -218,7 +228,7 @@ async def get_chat_list_by_folder_id(
     folder_id: str, page: Optional[int] = 1, user=Depends(get_verified_user)
 ):
     try:
-        limit = 10
+        limit = 60
         skip = (page - 1) * limit
 
         return [
@@ -648,28 +658,19 @@ async def clone_chat_by_id(
             "title": form_data.title if form_data.title else f"Clone of {chat.title}",
         }
 
-        chats = Chats.import_chats(
+        chat = Chats.import_chat(
             user.id,
-            [
-                ChatImportForm(
-                    **{
-                        "chat": updated_chat,
-                        "meta": chat.meta,
-                        "pinned": chat.pinned,
-                        "folder_id": chat.folder_id,
-                    }
-                )
-            ],
+            ChatImportForm(
+                **{
+                    "chat": updated_chat,
+                    "meta": chat.meta,
+                    "pinned": chat.pinned,
+                    "folder_id": chat.folder_id,
+                }
+            ),
         )
 
-        if chats:
-            chat = chats[0]
-            return ChatResponse(**chat.model_dump())
-        else:
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail=ERROR_MESSAGES.DEFAULT(),
-            )
+        return ChatResponse(**chat.model_dump())
     else:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED, detail=ERROR_MESSAGES.DEFAULT()
@@ -697,28 +698,18 @@ async def clone_shared_chat_by_id(id: str, user=Depends(get_verified_user)):
             "title": f"Clone of {chat.title}",
         }
 
-        chats = Chats.import_chats(
+        chat = Chats.import_chat(
             user.id,
-            [
-                ChatImportForm(
-                    **{
-                        "chat": updated_chat,
-                        "meta": chat.meta,
-                        "pinned": chat.pinned,
-                        "folder_id": chat.folder_id,
-                    }
-                )
-            ],
+            ChatImportForm(
+                **{
+                    "chat": updated_chat,
+                    "meta": chat.meta,
+                    "pinned": chat.pinned,
+                    "folder_id": chat.folder_id,
+                }
+            ),
         )
-
-        if chats:
-            chat = chats[0]
-            return ChatResponse(**chat.model_dump())
-        else:
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail=ERROR_MESSAGES.DEFAULT(),
-            )
+        return ChatResponse(**chat.model_dump())
     else:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED, detail=ERROR_MESSAGES.DEFAULT()

backend/open_webui/routers/configs.py

@@ -1,5 +1,4 @@
 import logging
-import copy
 from fastapi import APIRouter, Depends, Request, HTTPException
 from pydantic import BaseModel, ConfigDict
 import aiohttp
@@ -16,7 +15,6 @@ from open_webui.utils.tools import (
     set_tool_servers,
 )
 from open_webui.utils.mcp.client import MCPClient
-from open_webui.models.oauth_sessions import OAuthSessions
 
 from open_webui.env import SRC_LOG_LEVELS
 
@@ -144,7 +142,6 @@ class ToolServerConnection(BaseModel):
     path: str
     type: Optional[str] = "openapi"  # openapi, mcp
     auth_type: Optional[str]
-    headers: Optional[dict | str] = None
     key: Optional[str]
     config: Optional[dict]
 
@@ -168,21 +165,6 @@ async def set_tool_servers_config(
     form_data: ToolServersConfigForm,
     user=Depends(get_admin_user),
 ):
-    for connection in request.app.state.config.TOOL_SERVER_CONNECTIONS:
-        server_type = connection.get("type", "openapi")
-        auth_type = connection.get("auth_type", "none")
-
-        if auth_type == "oauth_2.1":
-            # Remove existing OAuth clients for tool servers
-            server_id = connection.get("info", {}).get("id")
-            client_key = f"{server_type}:{server_id}"
-
-            try:
-                request.app.state.oauth_client_manager.remove_client(client_key)
-            except:
-                pass
-
-    # Set new tool server connections
     request.app.state.config.TOOL_SERVER_CONNECTIONS = [
         connection.model_dump() for connection in form_data.TOOL_SERVER_CONNECTIONS
     ]
@@ -194,7 +176,6 @@ async def set_tool_servers_config(
         if server_type == "mcp":
             server_id = connection.get("info", {}).get("id")
             auth_type = connection.get("auth_type", "none")
-
             if auth_type == "oauth_2.1" and server_id:
                 try:
                     oauth_client_info = connection.get("info", {}).get(
@@ -230,7 +211,7 @@ async def verify_tool_servers_config(
                     log.debug(
                         f"Trying to fetch OAuth 2.1 discovery document from {discovery_url}"
                     )
-                    async with aiohttp.ClientSession(trust_env=True) as session:
+                    async with aiohttp.ClientSession() as session:
                         async with session.get(
                             discovery_url
                         ) as oauth_server_metadata_response:
@@ -271,26 +252,18 @@ async def verify_tool_servers_config(
                     elif form_data.auth_type == "session":
                         token = request.state.token.credentials
                     elif form_data.auth_type == "system_oauth":
-                        oauth_token = None
                         try:
                             if request.cookies.get("oauth_session_id", None):
-                                oauth_token = await request.app.state.oauth_manager.get_oauth_token(
+                                token = await request.app.state.oauth_manager.get_oauth_token(
                                     user.id,
                                     request.cookies.get("oauth_session_id", None),
                                 )
-
-                                if oauth_token:
-                                    token = oauth_token.get("access_token", "")
                         except Exception as e:
                             pass
+
                     if token:
                         headers = {"Authorization": f"Bearer {token}"}
 
-                    if form_data.headers and isinstance(form_data.headers, dict):
-                        if headers is None:
-                            headers = {}
-                        headers.update(form_data.headers)
-
                     await client.connect(form_data.url, headers=headers)
                     specs = await client.list_tool_specs()
                     return {
@@ -308,7 +281,6 @@ async def verify_tool_servers_config(
                         await client.disconnect()
         else:  # openapi
             token = None
-            headers = None
             if form_data.auth_type == "bearer":
                 token = form_data.key
             elif form_data.auth_type == "session":
@@ -316,29 +288,15 @@ async def verify_tool_servers_config(
             elif form_data.auth_type == "system_oauth":
                 try:
                     if request.cookies.get("oauth_session_id", None):
-                        oauth_token = (
-                            await request.app.state.oauth_manager.get_oauth_token(
-                                user.id,
-                                request.cookies.get("oauth_session_id", None),
-                            )
+                        token = await request.app.state.oauth_manager.get_oauth_token(
+                            user.id,
+                            request.cookies.get("oauth_session_id", None),
                         )
-
-                        if oauth_token:
-                            token = oauth_token.get("access_token", "")
-
                 except Exception as e:
                     pass
 
-            if token:
-                headers = {"Authorization": f"Bearer {token}"}
-
-            if form_data.headers and isinstance(form_data.headers, dict):
-                if headers is None:
-                    headers = {}
-                headers.update(form_data.headers)
-
             url = get_tool_server_url(form_data.url, form_data.path)
-            return await get_tool_server_data(url, headers=headers)
+            return await get_tool_server_data(token, url)
     except HTTPException as e:
         raise e
     except Exception as e:
@@ -463,7 +421,6 @@ async def set_code_execution_config(
 ############################
 class ModelsConfigForm(BaseModel):
     DEFAULT_MODELS: Optional[str]
-    DEFAULT_PINNED_MODELS: Optional[str]
     MODEL_ORDER_LIST: Optional[list[str]]
 
 
@@ -471,7 +428,6 @@ class ModelsConfigForm(BaseModel):
 async def get_models_config(request: Request, user=Depends(get_admin_user)):
     return {
         "DEFAULT_MODELS": request.app.state.config.DEFAULT_MODELS,
-        "DEFAULT_PINNED_MODELS": request.app.state.config.DEFAULT_PINNED_MODELS,
         "MODEL_ORDER_LIST": request.app.state.config.MODEL_ORDER_LIST,
     }
 
@@ -481,11 +437,9 @@ async def set_models_config(
     request: Request, form_data: ModelsConfigForm, user=Depends(get_admin_user)
 ):
     request.app.state.config.DEFAULT_MODELS = form_data.DEFAULT_MODELS
-    request.app.state.config.DEFAULT_PINNED_MODELS = form_data.DEFAULT_PINNED_MODELS
     request.app.state.config.MODEL_ORDER_LIST = form_data.MODEL_ORDER_LIST
     return {
         "DEFAULT_MODELS": request.app.state.config.DEFAULT_MODELS,
-        "DEFAULT_PINNED_MODELS": request.app.state.config.DEFAULT_PINNED_MODELS,
         "MODEL_ORDER_LIST": request.app.state.config.MODEL_ORDER_LIST,
     }
 

backend/open_webui/routers/evaluations.py

@@ -7,8 +7,6 @@ from open_webui.models.feedbacks import (
     FeedbackModel,
     FeedbackResponse,
     FeedbackForm,
-    FeedbackUserResponse,
-    FeedbackListResponse,
     Feedbacks,
 )
 
@@ -58,10 +56,35 @@ async def update_config(
     }
 
 
-@router.get("/feedbacks/all", response_model=list[FeedbackResponse])
+class UserResponse(BaseModel):
+    id: str
+    name: str
+    email: str
+    role: str = "pending"
+
+    last_active_at: int  # timestamp in epoch
+    updated_at: int  # timestamp in epoch
+    created_at: int  # timestamp in epoch
+
+
+class FeedbackUserResponse(FeedbackResponse):
+    user: Optional[UserResponse] = None
+
+
+@router.get("/feedbacks/all", response_model=list[FeedbackUserResponse])
 async def get_all_feedbacks(user=Depends(get_admin_user)):
     feedbacks = Feedbacks.get_all_feedbacks()
-    return feedbacks
+
+    feedback_list = []
+    for feedback in feedbacks:
+        user = Users.get_user_by_id(feedback.user_id)
+        feedback_list.append(
+            FeedbackUserResponse(
+                **feedback.model_dump(),
+                user=UserResponse(**user.model_dump()) if user else None,
+            )
+        )
+    return feedback_list
 
 
 @router.delete("/feedbacks/all")
@@ -88,31 +111,6 @@ async def delete_feedbacks(user=Depends(get_verified_user)):
     return success
 
 
-PAGE_ITEM_COUNT = 30
-
-
-@router.get("/feedbacks/list", response_model=FeedbackListResponse)
-async def get_feedbacks(
-    order_by: Optional[str] = None,
-    direction: Optional[str] = None,
-    page: Optional[int] = 1,
-    user=Depends(get_admin_user),
-):
-    limit = PAGE_ITEM_COUNT
-
-    page = max(1, page)
-    skip = (page - 1) * limit
-
-    filter = {}
-    if order_by:
-        filter["order_by"] = order_by
-    if direction:
-        filter["direction"] = direction
-
-    result = Feedbacks.get_feedback_items(filter=filter, skip=skip, limit=limit)
-    return result
-
-
 @router.post("/feedback", response_model=FeedbackModel)
 async def create_feedback(
     request: Request,

backend/open_webui/routers/files.py

@@ -22,7 +22,6 @@ from fastapi import (
 )
 
 from fastapi.responses import FileResponse, StreamingResponse
-
 from open_webui.constants import ERROR_MESSAGES
 from open_webui.env import SRC_LOG_LEVELS
 from open_webui.retrieval.vector.factory import VECTOR_DB_CLIENT
@@ -35,19 +34,12 @@ from open_webui.models.files import (
     Files,
 )
 from open_webui.models.knowledge import Knowledges
-from open_webui.models.groups import Groups
-
 
 from open_webui.routers.knowledge import get_knowledge, get_knowledge_list
 from open_webui.routers.retrieval import ProcessFileForm, process_file
 from open_webui.routers.audio import transcribe
-
 from open_webui.storage.provider import Storage
-
-
 from open_webui.utils.auth import get_admin_user, get_verified_user
-from open_webui.utils.access_control import has_access
-
 from pydantic import BaseModel
 
 log = logging.getLogger(__name__)
@@ -61,37 +53,31 @@ router = APIRouter()
 ############################
 
 
-# TODO: Optimize this function to use the knowledge_file table for faster lookups.
 def has_access_to_file(
     file_id: Optional[str], access_type: str, user=Depends(get_verified_user)
 ) -> bool:
     file = Files.get_file_by_id(file_id)
     log.debug(f"Checking if user has {access_type} access to file")
+
     if not file:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
             detail=ERROR_MESSAGES.NOT_FOUND,
         )
 
-    knowledge_bases = Knowledges.get_knowledges_by_file_id(file_id)
-    user_group_ids = {group.id for group in Groups.get_groups_by_member_id(user.id)}
-
-    for knowledge_base in knowledge_bases:
-        if knowledge_base.user_id == user.id or has_access(
-            user.id, access_type, knowledge_base.access_control, user_group_ids
-        ):
-            return True
-
+    has_access = False
     knowledge_base_id = file.meta.get("collection_name") if file.meta else None
+
     if knowledge_base_id:
         knowledge_bases = Knowledges.get_knowledge_bases_by_user_id(
             user.id, access_type
         )
         for knowledge_base in knowledge_bases:
             if knowledge_base.id == knowledge_base_id:
-                return True
+                has_access = True
+                break
 
-    return False
+    return has_access
 
 
 ############################
@@ -116,7 +102,7 @@ def process_uploaded_file(request, file, file_path, file_item, file_metadata, us
                 )
             ):
                 file_path = Storage.get_file(file_path)
-                result = transcribe(request, file_path, file_metadata, user)
+                result = transcribe(request, file_path, file_metadata)
 
                 process_file(
                     request,
@@ -129,10 +115,6 @@ def process_uploaded_file(request, file, file_path, file_item, file_metadata, us
                 request.app.state.config.CONTENT_EXTRACTION_ENGINE == "external"
             ):
                 process_file(request, ProcessFileForm(file_id=file_item.id), user=user)
-            else:
-                raise Exception(
-                    f"File type {file.content_type} is not supported for processing"
-                )
         else:
             log.info(
                 f"File type {file.content_type} is not provided, but trying to process anyway"

backend/open_webui/routers/folders.py

@@ -46,23 +46,7 @@ router = APIRouter()
 
 
 @router.get("/", response_model=list[FolderNameIdResponse])
-async def get_folders(request: Request, user=Depends(get_verified_user)):
-    if request.app.state.config.ENABLE_FOLDERS is False:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail=ERROR_MESSAGES.ACCESS_PROHIBITED,
-        )
-
-    if user.role != "admin" and not has_permission(
-        user.id,
-        "features.folders",
-        request.app.state.config.USER_PERMISSIONS,
-    ):
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail=ERROR_MESSAGES.ACCESS_PROHIBITED,
-        )
-
+async def get_folders(user=Depends(get_verified_user)):
     folders = Folders.get_folders_by_user_id(user.id)
 
     # Verify folder data integrity
@@ -274,10 +258,7 @@ async def update_folder_is_expanded_by_id(
 
 @router.delete("/{id}")
 async def delete_folder_by_id(
-    request: Request,
-    id: str,
-    delete_contents: Optional[bool] = True,
-    user=Depends(get_verified_user),
+    request: Request, id: str, user=Depends(get_verified_user)
 ):
     if Chats.count_chats_by_folder_id_and_user_id(id, user.id):
         chat_delete_permission = has_permission(
@@ -296,14 +277,8 @@ async def delete_folder_by_id(
         if folder:
             try:
                 folder_ids = Folders.delete_folder_by_id_and_user_id(id, user.id)
-
                 for folder_id in folder_ids:
-                    if delete_contents:
-                        Chats.delete_chats_by_user_id_and_folder_id(user.id, folder_id)
-                    else:
-                        Chats.move_chats_by_user_id_and_folder_id(
-                            user.id, folder_id, None
-                        )
+                    Chats.delete_chats_by_user_id_and_folder_id(user.id, folder_id)
 
                 return True
             except Exception as e:

backend/open_webui/routers/groups.py

@@ -3,7 +3,7 @@ from pathlib import Path
 from typing import Optional
 import logging
 
-from open_webui.models.users import Users, UserInfoResponse
+from open_webui.models.users import Users
 from open_webui.models.groups import (
     Groups,
     GroupForm,
@@ -31,18 +31,11 @@ router = APIRouter()
 
 
 @router.get("/", response_model=list[GroupResponse])
-async def get_groups(share: Optional[bool] = None, user=Depends(get_verified_user)):
-
-    filter = {}
-    if user.role != "admin":
-        filter["member_id"] = user.id
-
-    if share is not None:
-        filter["share"] = share
-
-    groups = Groups.get_groups(filter=filter)
-
-    return groups
+async def get_groups(user=Depends(get_verified_user)):
+    if user.role == "admin":
+        return Groups.get_groups()
+    else:
+        return Groups.get_groups_by_member_id(user.id)
 
 
 ############################
@@ -55,10 +48,7 @@ async def create_new_group(form_data: GroupForm, user=Depends(get_admin_user)):
     try:
         group = Groups.insert_new_group(user.id, form_data)
         if group:
-            return GroupResponse(
-                **group.model_dump(),
-                member_count=Groups.get_group_member_count_by_id(group.id),
-            )
+            return group
         else:
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
@@ -81,10 +71,7 @@ async def create_new_group(form_data: GroupForm, user=Depends(get_admin_user)):
 async def get_group_by_id(id: str, user=Depends(get_admin_user)):
     group = Groups.get_group_by_id(id)
     if group:
-        return GroupResponse(
-            **group.model_dump(),
-            member_count=Groups.get_group_member_count_by_id(group.id),
-        )
+        return group
     else:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
@@ -92,50 +79,6 @@ async def get_group_by_id(id: str, user=Depends(get_admin_user)):
         )
 
 
-############################
-# ExportGroupById
-############################
-
-
-class GroupExportResponse(GroupResponse):
-    user_ids: list[str] = []
-    pass
-
-
-@router.get("/id/{id}/export", response_model=Optional[GroupExportResponse])
-async def export_group_by_id(id: str, user=Depends(get_admin_user)):
-    group = Groups.get_group_by_id(id)
-    if group:
-        return GroupExportResponse(
-            **group.model_dump(),
-            member_count=Groups.get_group_member_count_by_id(group.id),
-            user_ids=Groups.get_group_user_ids_by_id(group.id),
-        )
-    else:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=ERROR_MESSAGES.NOT_FOUND,
-        )
-
-
-############################
-# GetUsersInGroupById
-############################
-
-
-@router.post("/id/{id}/users", response_model=list[UserInfoResponse])
-async def get_users_in_group(id: str, user=Depends(get_admin_user)):
-    try:
-        users = Users.get_users_by_group_id(id)
-        return users
-    except Exception as e:
-        log.exception(f"Error adding users to group {id}: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=ERROR_MESSAGES.DEFAULT(e),
-        )
-
-
 ############################
 # UpdateGroupById
 ############################
@@ -146,12 +89,12 @@ async def update_group_by_id(
     id: str, form_data: GroupUpdateForm, user=Depends(get_admin_user)
 ):
     try:
+        if form_data.user_ids:
+            form_data.user_ids = Users.get_valid_user_ids(form_data.user_ids)
+
         group = Groups.update_group_by_id(id, form_data)
         if group:
-            return GroupResponse(
-                **group.model_dump(),
-                member_count=Groups.get_group_member_count_by_id(group.id),
-            )
+            return group
         else:
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
@@ -180,10 +123,7 @@ async def add_user_to_group(
 
         group = Groups.add_users_to_group(id, form_data.user_ids)
         if group:
-            return GroupResponse(
-                **group.model_dump(),
-                member_count=Groups.get_group_member_count_by_id(group.id),
-            )
+            return group
         else:
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
@@ -204,10 +144,7 @@ async def remove_users_from_group(
     try:
         group = Groups.remove_users_from_group(id, form_data.user_ids)
         if group:
-            return GroupResponse(
-                **group.model_dump(),
-                member_count=Groups.get_group_member_count_by_id(group.id),
-            )
+            return group
         else:
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,

backend/open_webui/routers/knowledge.py

@@ -1,7 +1,6 @@
 from typing import List, Optional
 from pydantic import BaseModel
 from fastapi import APIRouter, Depends, HTTPException, status, Request, Query
-from fastapi.concurrency import run_in_threadpool
 import logging
 
 from open_webui.models.knowledge import (
@@ -42,38 +41,97 @@ router = APIRouter()
 
 @router.get("/", response_model=list[KnowledgeUserResponse])
 async def get_knowledge(user=Depends(get_verified_user)):
-    # Return knowledge bases with read access
     knowledge_bases = []
+
     if user.role == "admin" and BYPASS_ADMIN_ACCESS_CONTROL:
         knowledge_bases = Knowledges.get_knowledge_bases()
     else:
         knowledge_bases = Knowledges.get_knowledge_bases_by_user_id(user.id, "read")
 
-    return [
-        KnowledgeUserResponse(
-            **knowledge_base.model_dump(),
-            files=Knowledges.get_file_metadatas_by_id(knowledge_base.id),
+    # Get files for each knowledge base
+    knowledge_with_files = []
+    for knowledge_base in knowledge_bases:
+        files = []
+        if knowledge_base.data:
+            files = Files.get_file_metadatas_by_ids(
+                knowledge_base.data.get("file_ids", [])
+            )
+
+            # Check if all files exist
+            if len(files) != len(knowledge_base.data.get("file_ids", [])):
+                missing_files = list(
+                    set(knowledge_base.data.get("file_ids", []))
+                    - set([file.id for file in files])
+                )
+                if missing_files:
+                    data = knowledge_base.data or {}
+                    file_ids = data.get("file_ids", [])
+
+                    for missing_file in missing_files:
+                        file_ids.remove(missing_file)
+
+                    data["file_ids"] = file_ids
+                    Knowledges.update_knowledge_data_by_id(
+                        id=knowledge_base.id, data=data
+                    )
+
+                    files = Files.get_file_metadatas_by_ids(file_ids)
+
+        knowledge_with_files.append(
+            KnowledgeUserResponse(
+                **knowledge_base.model_dump(),
+                files=files,
+            )
         )
-        for knowledge_base in knowledge_bases
-    ]
+
+    return knowledge_with_files
 
 
 @router.get("/list", response_model=list[KnowledgeUserResponse])
 async def get_knowledge_list(user=Depends(get_verified_user)):
-    # Return knowledge bases with write access
     knowledge_bases = []
+
     if user.role == "admin" and BYPASS_ADMIN_ACCESS_CONTROL:
         knowledge_bases = Knowledges.get_knowledge_bases()
     else:
         knowledge_bases = Knowledges.get_knowledge_bases_by_user_id(user.id, "write")
 
-    return [
-        KnowledgeUserResponse(
-            **knowledge_base.model_dump(),
-            files=Knowledges.get_file_metadatas_by_id(knowledge_base.id),
+    # Get files for each knowledge base
+    knowledge_with_files = []
+    for knowledge_base in knowledge_bases:
+        files = []
+        if knowledge_base.data:
+            files = Files.get_file_metadatas_by_ids(
+                knowledge_base.data.get("file_ids", [])
+            )
+
+            # Check if all files exist
+            if len(files) != len(knowledge_base.data.get("file_ids", [])):
+                missing_files = list(
+                    set(knowledge_base.data.get("file_ids", []))
+                    - set([file.id for file in files])
+                )
+                if missing_files:
+                    data = knowledge_base.data or {}
+                    file_ids = data.get("file_ids", [])
+
+                    for missing_file in missing_files:
+                        file_ids.remove(missing_file)
+
+                    data["file_ids"] = file_ids
+                    Knowledges.update_knowledge_data_by_id(
+                        id=knowledge_base.id, data=data
+                    )
+
+                    files = Files.get_file_metadatas_by_ids(file_ids)
+
+        knowledge_with_files.append(
+            KnowledgeUserResponse(
+                **knowledge_base.model_dump(),
+                files=files,
+            )
         )
-        for knowledge_base in knowledge_bases
-    ]
+    return knowledge_with_files
 
 
 ############################
@@ -133,9 +191,26 @@ async def reindex_knowledge_files(request: Request, user=Depends(get_verified_us
 
     log.info(f"Starting reindexing for {len(knowledge_bases)} knowledge bases")
 
+    deleted_knowledge_bases = []
+
     for knowledge_base in knowledge_bases:
+        # -- Robust error handling for missing or invalid data
+        if not knowledge_base.data or not isinstance(knowledge_base.data, dict):
+            log.warning(
+                f"Knowledge base {knowledge_base.id} has no data or invalid data ({knowledge_base.data!r}). Deleting."
+            )
+            try:
+                Knowledges.delete_knowledge_by_id(id=knowledge_base.id)
+                deleted_knowledge_bases.append(knowledge_base.id)
+            except Exception as e:
+                log.error(
+                    f"Failed to delete invalid knowledge base {knowledge_base.id}: {e}"
+                )
+            continue
+
         try:
-            files = Knowledges.get_files_by_id(knowledge_base.id)
+            file_ids = knowledge_base.data.get("file_ids", [])
+            files = Files.get_files_by_ids(file_ids)
             try:
                 if VECTOR_DB_CLIENT.has_collection(collection_name=knowledge_base.id):
                     VECTOR_DB_CLIENT.delete_collection(
@@ -148,8 +223,7 @@ async def reindex_knowledge_files(request: Request, user=Depends(get_verified_us
             failed_files = []
             for file in files:
                 try:
-                    await run_in_threadpool(
-                        process_file,
+                    process_file(
                         request,
                         ProcessFileForm(
                             file_id=file.id, collection_name=knowledge_base.id
@@ -175,7 +249,9 @@ async def reindex_knowledge_files(request: Request, user=Depends(get_verified_us
             for failed in failed_files:
                 log.warning(f"File ID: {failed['file_id']}, Error: {failed['error']}")
 
-    log.info(f"Reindexing completed.")
+    log.info(
+        f"Reindexing completed. Deleted {len(deleted_knowledge_bases)} invalid knowledge bases: {deleted_knowledge_bases}"
+    )
     return True
 
 
@@ -193,15 +269,19 @@ async def get_knowledge_by_id(id: str, user=Depends(get_verified_user)):
     knowledge = Knowledges.get_knowledge_by_id(id=id)
 
     if knowledge:
+
         if (
             user.role == "admin"
             or knowledge.user_id == user.id
             or has_access(user.id, "read", knowledge.access_control)
         ):
 
+            file_ids = knowledge.data.get("file_ids", []) if knowledge.data else []
+            files = Files.get_file_metadatas_by_ids(file_ids)
+
             return KnowledgeFilesResponse(
                 **knowledge.model_dump(),
-                files=Knowledges.get_file_metadatas_by_id(knowledge.id),
+                files=files,
             )
     else:
         raise HTTPException(
@@ -253,9 +333,12 @@ async def update_knowledge_by_id(
 
     knowledge = Knowledges.update_knowledge_by_id(id=id, form_data=form_data)
     if knowledge:
+        file_ids = knowledge.data.get("file_ids", []) if knowledge.data else []
+        files = Files.get_file_metadatas_by_ids(file_ids)
+
         return KnowledgeFilesResponse(
             **knowledge.model_dump(),
-            files=Knowledges.get_file_metadatas_by_id(knowledge.id),
+            files=files,
         )
     else:
         raise HTTPException(
@@ -281,6 +364,7 @@ def add_file_to_knowledge_by_id(
     user=Depends(get_verified_user),
 ):
     knowledge = Knowledges.get_knowledge_by_id(id=id)
+
     if not knowledge:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
@@ -309,11 +393,6 @@ def add_file_to_knowledge_by_id(
             detail=ERROR_MESSAGES.FILE_NOT_PROCESSED,
         )
 
-    # Add file to knowledge base
-    Knowledges.add_file_to_knowledge_by_id(
-        knowledge_id=id, file_id=form_data.file_id, user_id=user.id
-    )
-
     # Add content to the vector database
     try:
         process_file(
@@ -329,10 +408,32 @@ def add_file_to_knowledge_by_id(
         )
 
     if knowledge:
-        return KnowledgeFilesResponse(
-            **knowledge.model_dump(),
-            files=Knowledges.get_file_metadatas_by_id(knowledge.id),
-        )
+        data = knowledge.data or {}
+        file_ids = data.get("file_ids", [])
+
+        if form_data.file_id not in file_ids:
+            file_ids.append(form_data.file_id)
+            data["file_ids"] = file_ids
+
+            knowledge = Knowledges.update_knowledge_data_by_id(id=id, data=data)
+
+            if knowledge:
+                files = Files.get_file_metadatas_by_ids(file_ids)
+
+                return KnowledgeFilesResponse(
+                    **knowledge.model_dump(),
+                    files=files,
+                )
+            else:
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=ERROR_MESSAGES.DEFAULT("knowledge"),
+                )
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=ERROR_MESSAGES.DEFAULT("file_id"),
+            )
     else:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
@@ -391,9 +492,14 @@ def update_file_from_knowledge_by_id(
         )
 
     if knowledge:
+        data = knowledge.data or {}
+        file_ids = data.get("file_ids", [])
+
+        files = Files.get_file_metadatas_by_ids(file_ids)
+
         return KnowledgeFilesResponse(
             **knowledge.model_dump(),
-            files=Knowledges.get_file_metadatas_by_id(knowledge.id),
+            files=files,
         )
     else:
         raise HTTPException(
@@ -438,19 +544,11 @@ def remove_file_from_knowledge_by_id(
             detail=ERROR_MESSAGES.NOT_FOUND,
         )
 
-    Knowledges.remove_file_from_knowledge_by_id(
-        knowledge_id=id, file_id=form_data.file_id
-    )
-
     # Remove content from the vector database
     try:
         VECTOR_DB_CLIENT.delete(
             collection_name=knowledge.id, filter={"file_id": form_data.file_id}
-        )  # Remove by file_id first
-
-        VECTOR_DB_CLIENT.delete(
-            collection_name=knowledge.id, filter={"hash": file.hash}
-        )  # Remove by hash as well in case of duplicates
+        )
     except Exception as e:
         log.debug("This was most likely caused by bypassing embedding processing")
         log.debug(e)
@@ -471,10 +569,32 @@ def remove_file_from_knowledge_by_id(
         Files.delete_file_by_id(form_data.file_id)
 
     if knowledge:
-        return KnowledgeFilesResponse(
-            **knowledge.model_dump(),
-            files=Knowledges.get_file_metadatas_by_id(knowledge.id),
-        )
+        data = knowledge.data or {}
+        file_ids = data.get("file_ids", [])
+
+        if form_data.file_id in file_ids:
+            file_ids.remove(form_data.file_id)
+            data["file_ids"] = file_ids
+
+            knowledge = Knowledges.update_knowledge_data_by_id(id=id, data=data)
+
+            if knowledge:
+                files = Files.get_file_metadatas_by_ids(file_ids)
+
+                return KnowledgeFilesResponse(
+                    **knowledge.model_dump(),
+                    files=files,
+                )
+            else:
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=ERROR_MESSAGES.DEFAULT("knowledge"),
+                )
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=ERROR_MESSAGES.DEFAULT("file_id"),
+            )
     else:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
@@ -575,7 +695,8 @@ async def reset_knowledge_by_id(id: str, user=Depends(get_verified_user)):
         log.debug(e)
         pass
 
-    knowledge = Knowledges.reset_knowledge_by_id(id=id)
+    knowledge = Knowledges.update_knowledge_data_by_id(id=id, data={"file_ids": []})
+
     return knowledge
 
 
@@ -585,7 +706,7 @@ async def reset_knowledge_by_id(id: str, user=Depends(get_verified_user)):
 
 
 @router.post("/{id}/files/batch/add", response_model=Optional[KnowledgeFilesResponse])
-async def add_files_to_knowledge_batch(
+def add_files_to_knowledge_batch(
     request: Request,
     id: str,
     form_data: list[KnowledgeFileIdForm],
@@ -625,7 +746,7 @@ async def add_files_to_knowledge_batch(
 
     # Process files
     try:
-        result = await process_files_batch(
+        result = process_files_batch(
             request=request,
             form_data=BatchProcessFilesForm(files=files, collection_name=id),
             user=user,
@@ -636,19 +757,25 @@ async def add_files_to_knowledge_batch(
         )
         raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
 
+    # Add successful files to knowledge base
+    data = knowledge.data or {}
+    existing_file_ids = data.get("file_ids", [])
+
     # Only add files that were successfully processed
     successful_file_ids = [r.file_id for r in result.results if r.status == "completed"]
     for file_id in successful_file_ids:
-        Knowledges.add_file_to_knowledge_by_id(
-            knowledge_id=id, file_id=file_id, user_id=user.id
-        )
+        if file_id not in existing_file_ids:
+            existing_file_ids.append(file_id)
+
+    data["file_ids"] = existing_file_ids
+    knowledge = Knowledges.update_knowledge_data_by_id(id=id, data=data)
 
     # If there were any errors, include them in the response
     if result.errors:
         error_details = [f"{err.file_id}: {err.error}" for err in result.errors]
         return KnowledgeFilesResponse(
             **knowledge.model_dump(),
-            files=Knowledges.get_file_metadatas_by_id(knowledge.id),
+            files=Files.get_file_metadatas_by_ids(existing_file_ids),
             warnings={
                 "message": "Some files failed to process",
                 "errors": error_details,
@@ -657,5 +784,5 @@ async def add_files_to_knowledge_batch(
 
     return KnowledgeFilesResponse(
         **knowledge.model_dump(),
-        files=Knowledges.get_file_metadatas_by_id(knowledge.id),
+        files=Files.get_file_metadatas_by_ids(existing_file_ids),
     )

backend/open_webui/routers/memories.py

@@ -1,7 +1,6 @@
 from fastapi import APIRouter, Depends, HTTPException, Request
 from pydantic import BaseModel
 import logging
-import asyncio
 from typing import Optional
 
 from open_webui.models.memories import Memories, MemoryModel
@@ -18,7 +17,7 @@ router = APIRouter()
 
 @router.get("/ef")
 async def get_embeddings(request: Request):
-    return {"result": await request.app.state.EMBEDDING_FUNCTION("hello world")}
+    return {"result": request.app.state.EMBEDDING_FUNCTION("hello world")}
 
 
 ############################
@@ -52,15 +51,15 @@ async def add_memory(
 ):
     memory = Memories.insert_new_memory(user.id, form_data.content)
 
-    vector = await request.app.state.EMBEDDING_FUNCTION(memory.content, user=user)
-
     VECTOR_DB_CLIENT.upsert(
         collection_name=f"user-memory-{user.id}",
         items=[
             {
                 "id": memory.id,
                 "text": memory.content,
-                "vector": vector,
+                "vector": request.app.state.EMBEDDING_FUNCTION(
+                    memory.content, user=user
+                ),
                 "metadata": {"created_at": memory.created_at},
             }
         ],
@@ -87,11 +86,9 @@ async def query_memory(
     if not memories:
         raise HTTPException(status_code=404, detail="No memories found for user")
 
-    vector = await request.app.state.EMBEDDING_FUNCTION(form_data.content, user=user)
-
     results = VECTOR_DB_CLIENT.search(
         collection_name=f"user-memory-{user.id}",
-        vectors=[vector],
+        vectors=[request.app.state.EMBEDDING_FUNCTION(form_data.content, user=user)],
         limit=form_data.k,
     )
 
@@ -108,28 +105,21 @@ async def reset_memory_from_vector_db(
     VECTOR_DB_CLIENT.delete_collection(f"user-memory-{user.id}")
 
     memories = Memories.get_memories_by_user_id(user.id)
-
-    # Generate vectors in parallel
-    vectors = await asyncio.gather(
-        *[
-            request.app.state.EMBEDDING_FUNCTION(memory.content, user=user)
-            for memory in memories
-        ]
-    )
-
     VECTOR_DB_CLIENT.upsert(
         collection_name=f"user-memory-{user.id}",
         items=[
             {
                 "id": memory.id,
                 "text": memory.content,
-                "vector": vectors[idx],
+                "vector": request.app.state.EMBEDDING_FUNCTION(
+                    memory.content, user=user
+                ),
                 "metadata": {
                     "created_at": memory.created_at,
                     "updated_at": memory.updated_at,
                 },
             }
-            for idx, memory in enumerate(memories)
+            for memory in memories
         ],
     )
 
@@ -174,15 +164,15 @@ async def update_memory_by_id(
         raise HTTPException(status_code=404, detail="Memory not found")
 
     if form_data.content is not None:
-        vector = await request.app.state.EMBEDDING_FUNCTION(memory.content, user=user)
-
         VECTOR_DB_CLIENT.upsert(
             collection_name=f"user-memory-{user.id}",
             items=[
                 {
                     "id": memory.id,
                     "text": memory.content,
-                    "vector": vector,
+                    "vector": request.app.state.EMBEDDING_FUNCTION(
+                        memory.content, user=user
+                    ),
                     "metadata": {
                         "created_at": memory.created_at,
                         "updated_at": memory.updated_at,

backend/open_webui/routers/models.py

@@ -5,12 +5,11 @@ import json
 import asyncio
 import logging
 
-from open_webui.models.groups import Groups
 from open_webui.models.models import (
     ModelForm,
     ModelModel,
     ModelResponse,
-    ModelListResponse,
+    ModelUserResponse,
     Models,
 )
 
@@ -36,7 +35,7 @@ log = logging.getLogger(__name__)
 router = APIRouter()
 
 
-def is_valid_model_id(model_id: str) -> bool:
+def validate_model_id(model_id: str) -> bool:
     return model_id and len(model_id) <= 256
 
 
@@ -45,47 +44,12 @@ def is_valid_model_id(model_id: str) -> bool:
 ###########################
 
 
-PAGE_ITEM_COUNT = 30
-
-
-@router.get(
-    "/list", response_model=ModelListResponse
-)  # do NOT use "/" as path, conflicts with main.py
-async def get_models(
-    query: Optional[str] = None,
-    view_option: Optional[str] = None,
-    tag: Optional[str] = None,
-    order_by: Optional[str] = None,
-    direction: Optional[str] = None,
-    page: Optional[int] = 1,
-    user=Depends(get_verified_user),
-):
-
-    limit = PAGE_ITEM_COUNT
-
-    page = max(1, page)
-    skip = (page - 1) * limit
-
-    filter = {}
-    if query:
-        filter["query"] = query
-    if view_option:
-        filter["view_option"] = view_option
-    if tag:
-        filter["tag"] = tag
-    if order_by:
-        filter["order_by"] = order_by
-    if direction:
-        filter["direction"] = direction
-
-    if not user.role == "admin" or not BYPASS_ADMIN_ACCESS_CONTROL:
-        groups = Groups.get_groups_by_member_id(user.id)
-        if groups:
-            filter["group_ids"] = [group.id for group in groups]
-
-        filter["user_id"] = user.id
-
-    return Models.search_models(user.id, filter=filter, skip=skip, limit=limit)
+@router.get("/", response_model=list[ModelUserResponse])
+async def get_models(id: Optional[str] = None, user=Depends(get_verified_user)):
+    if user.role == "admin" and BYPASS_ADMIN_ACCESS_CONTROL:
+        return Models.get_models()
+    else:
+        return Models.get_models_by_user_id(user.id)
 
 
 ###########################
@@ -98,30 +62,6 @@ async def get_base_models(user=Depends(get_admin_user)):
     return Models.get_base_models()
 
 
-###########################
-# GetModelTags
-###########################
-
-
-@router.get("/tags", response_model=list[str])
-async def get_model_tags(user=Depends(get_verified_user)):
-    if user.role == "admin" and BYPASS_ADMIN_ACCESS_CONTROL:
-        models = Models.get_models()
-    else:
-        models = Models.get_models_by_user_id(user.id)
-
-    tags_set = set()
-    for model in models:
-        if model.meta:
-            meta = model.meta.model_dump()
-            for tag in meta.get("tags", []):
-                tags_set.add((tag.get("name")))
-
-    tags = [tag for tag in tags_set]
-    tags.sort()
-    return tags
-
-
 ############################
 # CreateNewModel
 ############################
@@ -148,7 +88,7 @@ async def create_new_model(
             detail=ERROR_MESSAGES.MODEL_ID_TAKEN,
         )
 
-    if not is_valid_model_id(form_data.id):
+    if not validate_model_id(form_data.id):
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail=ERROR_MESSAGES.MODEL_ID_TOO_LONG,
@@ -171,19 +111,8 @@ async def create_new_model(
 
 
 @router.get("/export", response_model=list[ModelModel])
-async def export_models(request: Request, user=Depends(get_verified_user)):
-    if user.role != "admin" and not has_permission(
-        user.id, "workspace.models_export", request.app.state.config.USER_PERMISSIONS
-    ):
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=ERROR_MESSAGES.UNAUTHORIZED,
-        )
-
-    if user.role == "admin" and BYPASS_ADMIN_ACCESS_CONTROL:
-        return Models.get_models()
-    else:
-        return Models.get_models_by_user_id(user.id)
+async def export_models(user=Depends(get_admin_user)):
+    return Models.get_models()
 
 
 ############################
@@ -197,17 +126,8 @@ class ModelsImportForm(BaseModel):
 
 @router.post("/import", response_model=bool)
 async def import_models(
-    request: Request,
-    user=Depends(get_verified_user),
-    form_data: ModelsImportForm = (...),
+    user: str = Depends(get_admin_user), form_data: ModelsImportForm = (...)
 ):
-    if user.role != "admin" and not has_permission(
-        user.id, "workspace.models_import", request.app.state.config.USER_PERMISSIONS
-    ):
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=ERROR_MESSAGES.UNAUTHORIZED,
-        )
     try:
         data = form_data.models
         if isinstance(data, list):
@@ -215,7 +135,7 @@ async def import_models(
                 # Here, you can add logic to validate model_data if needed
                 model_id = model_data.get("id")
 
-                if model_id and is_valid_model_id(model_id):
+                if model_id and validate_model_id(model_id):
                     existing_model = Models.get_model_by_id(model_id)
                     if existing_model:
                         # Update existing model
@@ -261,10 +181,6 @@ async def sync_models(
 ###########################
 
 
-class ModelIdForm(BaseModel):
-    id: str
-
-
 # Note: We're not using the typical url path param here, but instead using a query parameter to allow '/' in the id
 @router.get("/model", response_model=Optional[ModelResponse])
 async def get_model_by_id(id: str, user=Depends(get_verified_user)):
@@ -311,7 +227,6 @@ async def get_model_profile_image(id: str, user=Depends(get_verified_user)):
                     )
                 except Exception as e:
                     pass
-
         return FileResponse(f"{STATIC_DIR}/favicon.png")
     else:
         return FileResponse(f"{STATIC_DIR}/favicon.png")
@@ -359,10 +274,12 @@ async def toggle_model_by_id(id: str, user=Depends(get_verified_user)):
 
 @router.post("/model/update", response_model=Optional[ModelModel])
 async def update_model_by_id(
+    id: str,
     form_data: ModelForm,
     user=Depends(get_verified_user),
 ):
-    model = Models.get_model_by_id(form_data.id)
+    model = Models.get_model_by_id(id)
+
     if not model:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
@@ -379,7 +296,7 @@ async def update_model_by_id(
             detail=ERROR_MESSAGES.ACCESS_PROHIBITED,
         )
 
-    model = Models.update_model_by_id(form_data.id, ModelForm(**form_data.model_dump()))
+    model = Models.update_model_by_id(id, form_data)
     return model
 
 
@@ -388,9 +305,9 @@ async def update_model_by_id(
 ############################
 
 
-@router.post("/model/delete", response_model=bool)
-async def delete_model_by_id(form_data: ModelIdForm, user=Depends(get_verified_user)):
-    model = Models.get_model_by_id(form_data.id)
+@router.delete("/model/delete", response_model=bool)
+async def delete_model_by_id(id: str, user=Depends(get_verified_user)):
+    model = Models.get_model_by_id(id)
     if not model:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
@@ -407,7 +324,7 @@ async def delete_model_by_id(form_data: ModelIdForm, user=Depends(get_verified_u
             detail=ERROR_MESSAGES.UNAUTHORIZED,
         )
 
-    result = Models.delete_model_by_id(form_data.id)
+    result = Models.delete_model_by_id(id)
     return result
 
 

backend/open_webui/routers/ollama.py

@@ -16,8 +16,8 @@ from urllib.parse import urlparse
 import aiohttp
 from aiocache import cached
 import requests
+from urllib.parse import quote
 
-from open_webui.utils.headers import include_user_info_headers
 from open_webui.models.chats import Chats
 from open_webui.models.users import UserModel
 
@@ -82,17 +82,22 @@ async def send_get_request(url, key=None, user: UserModel = None):
     timeout = aiohttp.ClientTimeout(total=AIOHTTP_CLIENT_TIMEOUT_MODEL_LIST)
     try:
         async with aiohttp.ClientSession(timeout=timeout, trust_env=True) as session:
-            headers = {
-                "Content-Type": "application/json",
-                **({"Authorization": f"Bearer {key}"} if key else {}),
-            }
-
-            if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-                headers = include_user_info_headers(headers, user)
-
             async with session.get(
                 url,
-                headers=headers,
+                headers={
+                    "Content-Type": "application/json",
+                    **({"Authorization": f"Bearer {key}"} if key else {}),
+                    **(
+                        {
+                            "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
+                            "X-OpenWebUI-User-Id": user.id,
+                            "X-OpenWebUI-User-Email": user.email,
+                            "X-OpenWebUI-User-Role": user.role,
+                        }
+                        if ENABLE_FORWARD_USER_INFO_HEADERS and user
+                        else {}
+                    ),
+                },
                 ssl=AIOHTTP_CLIENT_SESSION_SSL,
             ) as response:
                 return await response.json()
@@ -128,20 +133,28 @@ async def send_post_request(
             trust_env=True, timeout=aiohttp.ClientTimeout(total=AIOHTTP_CLIENT_TIMEOUT)
         )
 
-        headers = {
-            "Content-Type": "application/json",
-            **({"Authorization": f"Bearer {key}"} if key else {}),
-        }
-
-        if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-            headers = include_user_info_headers(headers, user)
-            if metadata and metadata.get("chat_id"):
-                headers["X-OpenWebUI-Chat-Id"] = metadata.get("chat_id")
-
         r = await session.post(
             url,
             data=payload,
-            headers=headers,
+            headers={
+                "Content-Type": "application/json",
+                **({"Authorization": f"Bearer {key}"} if key else {}),
+                **(
+                    {
+                        "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
+                        "X-OpenWebUI-User-Id": user.id,
+                        "X-OpenWebUI-User-Email": user.email,
+                        "X-OpenWebUI-User-Role": user.role,
+                        **(
+                            {"X-OpenWebUI-Chat-Id": metadata.get("chat_id")}
+                            if metadata and metadata.get("chat_id")
+                            else {}
+                        ),
+                    }
+                    if ENABLE_FORWARD_USER_INFO_HEADERS and user
+                    else {}
+                ),
+            },
             ssl=AIOHTTP_CLIENT_SESSION_SSL,
         )
 
@@ -233,16 +246,21 @@ async def verify_connection(
         timeout=aiohttp.ClientTimeout(total=AIOHTTP_CLIENT_TIMEOUT_MODEL_LIST),
     ) as session:
         try:
-            headers = {
-                **({"Authorization": f"Bearer {key}"} if key else {}),
-            }
-
-            if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-                headers = include_user_info_headers(headers, user)
-
             async with session.get(
                 f"{url}/api/version",
-                headers=headers,
+                headers={
+                    **({"Authorization": f"Bearer {key}"} if key else {}),
+                    **(
+                        {
+                            "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
+                            "X-OpenWebUI-User-Id": user.id,
+                            "X-OpenWebUI-User-Email": user.email,
+                            "X-OpenWebUI-User-Role": user.role,
+                        }
+                        if ENABLE_FORWARD_USER_INFO_HEADERS and user
+                        else {}
+                    ),
+                },
                 ssl=AIOHTTP_CLIENT_SESSION_SSL,
             ) as r:
                 if r.status != 200:
@@ -451,17 +469,22 @@ async def get_ollama_tags(
 
         r = None
         try:
-            headers = {
-                **({"Authorization": f"Bearer {key}"} if key else {}),
-            }
-
-            if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-                headers = include_user_info_headers(headers, user)
-
             r = requests.request(
                 method="GET",
                 url=f"{url}/api/tags",
-                headers=headers,
+                headers={
+                    **({"Authorization": f"Bearer {key}"} if key else {}),
+                    **(
+                        {
+                            "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
+                            "X-OpenWebUI-User-Id": user.id,
+                            "X-OpenWebUI-User-Email": user.email,
+                            "X-OpenWebUI-User-Role": user.role,
+                        }
+                        if ENABLE_FORWARD_USER_INFO_HEADERS and user
+                        else {}
+                    ),
+                },
             )
             r.raise_for_status()
 
@@ -815,18 +838,23 @@ async def copy_model(
     key = get_api_key(url_idx, url, request.app.state.config.OLLAMA_API_CONFIGS)
 
     try:
-        headers = {
-            "Content-Type": "application/json",
-            **({"Authorization": f"Bearer {key}"} if key else {}),
-        }
-
-        if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-            headers = include_user_info_headers(headers, user)
-
         r = requests.request(
             method="POST",
             url=f"{url}/api/copy",
-            headers=headers,
+            headers={
+                "Content-Type": "application/json",
+                **({"Authorization": f"Bearer {key}"} if key else {}),
+                **(
+                    {
+                        "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
+                        "X-OpenWebUI-User-Id": user.id,
+                        "X-OpenWebUI-User-Email": user.email,
+                        "X-OpenWebUI-User-Role": user.role,
+                    }
+                    if ENABLE_FORWARD_USER_INFO_HEADERS and user
+                    else {}
+                ),
+            },
             data=form_data.model_dump_json(exclude_none=True).encode(),
         )
         r.raise_for_status()
@@ -879,21 +907,25 @@ async def delete_model(
     url = request.app.state.config.OLLAMA_BASE_URLS[url_idx]
     key = get_api_key(url_idx, url, request.app.state.config.OLLAMA_API_CONFIGS)
 
-    r = None
     try:
-        headers = {
-            "Content-Type": "application/json",
-            **({"Authorization": f"Bearer {key}"} if key else {}),
-        }
-
-        if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-            headers = include_user_info_headers(headers, user)
-
         r = requests.request(
             method="DELETE",
             url=f"{url}/api/delete",
-            headers=headers,
-            json=form_data,
+            data=json.dumps(form_data).encode(),
+            headers={
+                "Content-Type": "application/json",
+                **({"Authorization": f"Bearer {key}"} if key else {}),
+                **(
+                    {
+                        "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
+                        "X-OpenWebUI-User-Id": user.id,
+                        "X-OpenWebUI-User-Email": user.email,
+                        "X-OpenWebUI-User-Role": user.role,
+                    }
+                    if ENABLE_FORWARD_USER_INFO_HEADERS and user
+                    else {}
+                ),
+            },
         )
         r.raise_for_status()
 
@@ -941,16 +973,24 @@ async def show_model_info(
     key = get_api_key(url_idx, url, request.app.state.config.OLLAMA_API_CONFIGS)
 
     try:
-        headers = {
-            "Content-Type": "application/json",
-            **({"Authorization": f"Bearer {key}"} if key else {}),
-        }
-
-        if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-            headers = include_user_info_headers(headers, user)
-
         r = requests.request(
-            method="POST", url=f"{url}/api/show", headers=headers, json=form_data
+            method="POST",
+            url=f"{url}/api/show",
+            headers={
+                "Content-Type": "application/json",
+                **({"Authorization": f"Bearer {key}"} if key else {}),
+                **(
+                    {
+                        "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
+                        "X-OpenWebUI-User-Id": user.id,
+                        "X-OpenWebUI-User-Email": user.email,
+                        "X-OpenWebUI-User-Role": user.role,
+                    }
+                    if ENABLE_FORWARD_USER_INFO_HEADERS and user
+                    else {}
+                ),
+            },
+            data=json.dumps(form_data).encode(),
         )
         r.raise_for_status()
 
@@ -1024,18 +1064,23 @@ async def embed(
         form_data.model = form_data.model.replace(f"{prefix_id}.", "")
 
     try:
-        headers = {
-            "Content-Type": "application/json",
-            **({"Authorization": f"Bearer {key}"} if key else {}),
-        }
-
-        if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-            headers = include_user_info_headers(headers, user)
-
         r = requests.request(
             method="POST",
             url=f"{url}/api/embed",
-            headers=headers,
+            headers={
+                "Content-Type": "application/json",
+                **({"Authorization": f"Bearer {key}"} if key else {}),
+                **(
+                    {
+                        "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
+                        "X-OpenWebUI-User-Id": user.id,
+                        "X-OpenWebUI-User-Email": user.email,
+                        "X-OpenWebUI-User-Role": user.role,
+                    }
+                    if ENABLE_FORWARD_USER_INFO_HEADERS and user
+                    else {}
+                ),
+            },
             data=form_data.model_dump_json(exclude_none=True).encode(),
         )
         r.raise_for_status()
@@ -1106,18 +1151,23 @@ async def embeddings(
         form_data.model = form_data.model.replace(f"{prefix_id}.", "")
 
     try:
-        headers = {
-            "Content-Type": "application/json",
-            **({"Authorization": f"Bearer {key}"} if key else {}),
-        }
-
-        if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-            headers = include_user_info_headers(headers, user)
-
         r = requests.request(
             method="POST",
             url=f"{url}/api/embeddings",
-            headers=headers,
+            headers={
+                "Content-Type": "application/json",
+                **({"Authorization": f"Bearer {key}"} if key else {}),
+                **(
+                    {
+                        "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
+                        "X-OpenWebUI-User-Id": user.id,
+                        "X-OpenWebUI-User-Email": user.email,
+                        "X-OpenWebUI-User-Role": user.role,
+                    }
+                    if ENABLE_FORWARD_USER_INFO_HEADERS and user
+                    else {}
+                ),
+            },
             data=form_data.model_dump_json(exclude_none=True).encode(),
         )
         r.raise_for_status()

backend/open_webui/routers/openai.py

@@ -7,6 +7,7 @@ from typing import Optional
 import aiohttp
 from aiocache import cached
 import requests
+from urllib.parse import quote
 
 from azure.identity import DefaultAzureCredential, get_bearer_token_provider
 
@@ -44,12 +45,10 @@ from open_webui.utils.payload import (
 )
 from open_webui.utils.misc import (
     convert_logit_bias_input_to_json,
-    stream_chunks_handler,
 )
 
 from open_webui.utils.auth import get_admin_user, get_verified_user
 from open_webui.utils.access_control import has_access
-from open_webui.utils.headers import include_user_info_headers
 
 
 log = logging.getLogger(__name__)
@@ -67,16 +66,21 @@ async def send_get_request(url, key=None, user: UserModel = None):
     timeout = aiohttp.ClientTimeout(total=AIOHTTP_CLIENT_TIMEOUT_MODEL_LIST)
     try:
         async with aiohttp.ClientSession(timeout=timeout, trust_env=True) as session:
-            headers = {
-                **({"Authorization": f"Bearer {key}"} if key else {}),
-            }
-
-            if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-                headers = include_user_info_headers(headers, user)
-
             async with session.get(
                 url,
-                headers=headers,
+                headers={
+                    **({"Authorization": f"Bearer {key}"} if key else {}),
+                    **(
+                        {
+                            "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
+                            "X-OpenWebUI-User-Id": user.id,
+                            "X-OpenWebUI-User-Email": user.email,
+                            "X-OpenWebUI-User-Role": user.role,
+                        }
+                        if ENABLE_FORWARD_USER_INFO_HEADERS and user
+                        else {}
+                    ),
+                },
                 ssl=AIOHTTP_CLIENT_SESSION_SSL,
             ) as response:
                 return await response.json()
@@ -136,13 +140,23 @@ async def get_headers_and_cookies(
             if "openrouter.ai" in url
             else {}
         ),
+        **(
+            {
+                "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
+                "X-OpenWebUI-User-Id": user.id,
+                "X-OpenWebUI-User-Email": user.email,
+                "X-OpenWebUI-User-Role": user.role,
+                **(
+                    {"X-OpenWebUI-Chat-Id": metadata.get("chat_id")}
+                    if metadata and metadata.get("chat_id")
+                    else {}
+                ),
+            }
+            if ENABLE_FORWARD_USER_INFO_HEADERS
+            else {}
+        ),
     }
 
-    if ENABLE_FORWARD_USER_INFO_HEADERS and user:
-        headers = include_user_info_headers(headers, user)
-        if metadata and metadata.get("chat_id"):
-            headers["X-OpenWebUI-Chat-Id"] = metadata.get("chat_id")
-
     token = None
     auth_type = config.get("auth_type")
 
@@ -487,55 +501,50 @@ async def get_all_models(request: Request, user: UserModel) -> dict[str, list]:
             return response
         return None
 
-    def is_supported_openai_models(model_id):
-        if any(
-            name in model_id
-            for name in [
-                "babbage",
-                "dall-e",
-                "davinci",
-                "embedding",
-                "tts",
-                "whisper",
-            ]
-        ):
-            return False
-        return True
-
-    def get_merged_models(model_lists):
+    def merge_models_lists(model_lists):
         log.debug(f"merge_models_lists {model_lists}")
-        models = {}
+        merged_list = []
 
-        for idx, model_list in enumerate(model_lists):
-            if model_list is not None and "error" not in model_list:
-                for model in model_list:
-                    model_id = model.get("id") or model.get("name")
+        for idx, models in enumerate(model_lists):
+            if models is not None and "error" not in models:
 
-                    if (
-                        "api.openai.com"
-                        in request.app.state.config.OPENAI_API_BASE_URLS[idx]
-                        and not is_supported_openai_models(model_id)
-                    ):
-                        # Skip unwanted OpenAI models
-                        continue
-
-                    if model_id and model_id not in models:
-                        models[model_id] = {
+                merged_list.extend(
+                    [
+                        {
                             **model,
-                            "name": model.get("name", model_id),
+                            "name": model.get("name", model["id"]),
                             "owned_by": "openai",
                             "openai": model,
                             "connection_type": model.get("connection_type", "external"),
                             "urlIdx": idx,
                         }
+                        for model in models
+                        if (model.get("id") or model.get("name"))
+                        and (
+                            "api.openai.com"
+                            not in request.app.state.config.OPENAI_API_BASE_URLS[idx]
+                            or not any(
+                                name in model["id"]
+                                for name in [
+                                    "babbage",
+                                    "dall-e",
+                                    "davinci",
+                                    "embedding",
+                                    "tts",
+                                    "whisper",
+                                ]
+                            )
+                        )
+                    ]
+                )
 
-        return models
+        return merged_list
 
-    models = get_merged_models(map(extract_data, responses))
+    models = {"data": merge_models_lists(map(extract_data, responses))}
     log.debug(f"models: {models}")
 
-    request.app.state.OPENAI_MODELS = models
-    return {"data": list(models.values())}
+    request.app.state.OPENAI_MODELS = {model["id"]: model for model in models["data"]}
+    return models
 
 
 @router.get("/models")
@@ -748,7 +757,6 @@ def get_azure_allowed_params(api_version: str) -> set[str]:
         "response_format",
         "seed",
         "max_completion_tokens",
-        "reasoning_effort",
     }
 
     try:
@@ -939,7 +947,7 @@ async def generate_chat_completion(
         if "text/event-stream" in r.headers.get("Content-Type", ""):
             streaming = True
             return StreamingResponse(
-                stream_chunks_handler(r.content),
+                r.content,
                 status_code=r.status,
                 headers=dict(r.headers),
                 background=BackgroundTask(

backend/open_webui/routers/prompts.py

@@ -48,15 +48,8 @@ async def get_prompt_list(user=Depends(get_verified_user)):
 async def create_new_prompt(
     request: Request, form_data: PromptForm, user=Depends(get_verified_user)
 ):
-    if user.role != "admin" and not (
-        has_permission(
-            user.id, "workspace.prompts", request.app.state.config.USER_PERMISSIONS
-        )
-        or has_permission(
-            user.id,
-            "workspace.prompts_import",
-            request.app.state.config.USER_PERMISSIONS,
-        )
+    if user.role != "admin" and not has_permission(
+        user.id, "workspace.prompts", request.app.state.config.USER_PERMISSIONS
     ):
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,

backend/open_webui/routers/retrieval.py

@@ -32,7 +32,7 @@ from langchain.text_splitter import RecursiveCharacterTextSplitter, TokenTextSpl
 from langchain_text_splitters import MarkdownHeaderTextSplitter
 from langchain_core.documents import Document
 
-from open_webui.models.files import FileModel, FileUpdateForm, Files
+from open_webui.models.files import FileModel, Files
 from open_webui.models.knowledge import Knowledges
 from open_webui.storage.provider import Storage
 
@@ -64,7 +64,6 @@ from open_webui.retrieval.web.serply import search_serply
 from open_webui.retrieval.web.serpstack import search_serpstack
 from open_webui.retrieval.web.tavily import search_tavily
 from open_webui.retrieval.web.bing import search_bing
-from open_webui.retrieval.web.azure import search_azure
 from open_webui.retrieval.web.exa import search_exa
 from open_webui.retrieval.web.perplexity import search_perplexity
 from open_webui.retrieval.web.sougou import search_sougou
@@ -123,7 +122,7 @@ log.setLevel(SRC_LOG_LEVELS["RAG"])
 def get_ef(
     engine: str,
     embedding_model: str,
-    auto_update: bool = RAG_EMBEDDING_MODEL_AUTO_UPDATE,
+    auto_update: bool = False,
 ):
     ef = None
     if embedding_model and engine == "":
@@ -148,7 +147,7 @@ def get_rf(
     reranking_model: Optional[str] = None,
     external_reranker_url: str = "",
     external_reranker_api_key: str = "",
-    auto_update: bool = RAG_RERANKING_MODEL_AUTO_UPDATE,
+    auto_update: bool = False,
 ):
     rf = None
     if reranking_model:
@@ -241,14 +240,13 @@ class SearchForm(BaseModel):
 async def get_status(request: Request):
     return {
         "status": True,
-        "CHUNK_SIZE": request.app.state.config.CHUNK_SIZE,
-        "CHUNK_OVERLAP": request.app.state.config.CHUNK_OVERLAP,
-        "RAG_TEMPLATE": request.app.state.config.RAG_TEMPLATE,
-        "RAG_EMBEDDING_ENGINE": request.app.state.config.RAG_EMBEDDING_ENGINE,
-        "RAG_EMBEDDING_MODEL": request.app.state.config.RAG_EMBEDDING_MODEL,
-        "RAG_RERANKING_MODEL": request.app.state.config.RAG_RERANKING_MODEL,
-        "RAG_EMBEDDING_BATCH_SIZE": request.app.state.config.RAG_EMBEDDING_BATCH_SIZE,
-        "ENABLE_ASYNC_EMBEDDING": request.app.state.config.ENABLE_ASYNC_EMBEDDING,
+        "chunk_size": request.app.state.config.CHUNK_SIZE,
+        "chunk_overlap": request.app.state.config.CHUNK_OVERLAP,
+        "template": request.app.state.config.RAG_TEMPLATE,
+        "embedding_engine": request.app.state.config.RAG_EMBEDDING_ENGINE,
+        "embedding_model": request.app.state.config.RAG_EMBEDDING_MODEL,
+        "reranking_model": request.app.state.config.RAG_RERANKING_MODEL,
+        "embedding_batch_size": request.app.state.config.RAG_EMBEDDING_BATCH_SIZE,
     }
 
 
@@ -256,10 +254,9 @@ async def get_status(request: Request):
 async def get_embedding_config(request: Request, user=Depends(get_admin_user)):
     return {
         "status": True,
-        "RAG_EMBEDDING_ENGINE": request.app.state.config.RAG_EMBEDDING_ENGINE,
-        "RAG_EMBEDDING_MODEL": request.app.state.config.RAG_EMBEDDING_MODEL,
-        "RAG_EMBEDDING_BATCH_SIZE": request.app.state.config.RAG_EMBEDDING_BATCH_SIZE,
-        "ENABLE_ASYNC_EMBEDDING": request.app.state.config.ENABLE_ASYNC_EMBEDDING,
+        "embedding_engine": request.app.state.config.RAG_EMBEDDING_ENGINE,
+        "embedding_model": request.app.state.config.RAG_EMBEDDING_MODEL,
+        "embedding_batch_size": request.app.state.config.RAG_EMBEDDING_BATCH_SIZE,
         "openai_config": {
             "url": request.app.state.config.RAG_OPENAI_API_BASE_URL,
             "key": request.app.state.config.RAG_OPENAI_API_KEY,
@@ -296,13 +293,18 @@ class EmbeddingModelUpdateForm(BaseModel):
     openai_config: Optional[OpenAIConfigForm] = None
     ollama_config: Optional[OllamaConfigForm] = None
     azure_openai_config: Optional[AzureOpenAIConfigForm] = None
-    RAG_EMBEDDING_ENGINE: str
-    RAG_EMBEDDING_MODEL: str
-    RAG_EMBEDDING_BATCH_SIZE: Optional[int] = 1
-    ENABLE_ASYNC_EMBEDDING: Optional[bool] = True
+    embedding_engine: str
+    embedding_model: str
+    embedding_batch_size: Optional[int] = 1
 
 
-def unload_embedding_model(request: Request):
+@router.post("/embedding/update")
+async def update_embedding_config(
+    request: Request, form_data: EmbeddingModelUpdateForm, user=Depends(get_admin_user)
+):
+    log.info(
+        f"Updating embedding model: {request.app.state.config.RAG_EMBEDDING_MODEL} to {form_data.embedding_model}"
+    )
     if request.app.state.config.RAG_EMBEDDING_ENGINE == "":
         # unloads current internal embedding model and clears VRAM cache
         request.app.state.ef = None
@@ -315,25 +317,9 @@ def unload_embedding_model(request: Request):
 
             if torch.cuda.is_available():
                 torch.cuda.empty_cache()
-
-
-@router.post("/embedding/update")
-async def update_embedding_config(
-    request: Request, form_data: EmbeddingModelUpdateForm, user=Depends(get_admin_user)
-):
-    log.info(
-        f"Updating embedding model: {request.app.state.config.RAG_EMBEDDING_MODEL} to {form_data.RAG_EMBEDDING_MODEL}"
-    )
-    unload_embedding_model(request)
     try:
-        request.app.state.config.RAG_EMBEDDING_ENGINE = form_data.RAG_EMBEDDING_ENGINE
-        request.app.state.config.RAG_EMBEDDING_MODEL = form_data.RAG_EMBEDDING_MODEL
-        request.app.state.config.RAG_EMBEDDING_BATCH_SIZE = (
-            form_data.RAG_EMBEDDING_BATCH_SIZE
-        )
-        request.app.state.config.ENABLE_ASYNC_EMBEDDING = (
-            form_data.ENABLE_ASYNC_EMBEDDING
-        )
+        request.app.state.config.RAG_EMBEDDING_ENGINE = form_data.embedding_engine
+        request.app.state.config.RAG_EMBEDDING_MODEL = form_data.embedding_model
 
         if request.app.state.config.RAG_EMBEDDING_ENGINE in [
             "ollama",
@@ -367,6 +353,10 @@ async def update_embedding_config(
                     form_data.azure_openai_config.version
                 )
 
+            request.app.state.config.RAG_EMBEDDING_BATCH_SIZE = (
+                form_data.embedding_batch_size
+            )
+
         request.app.state.ef = get_ef(
             request.app.state.config.RAG_EMBEDDING_ENGINE,
             request.app.state.config.RAG_EMBEDDING_MODEL,
@@ -400,15 +390,13 @@ async def update_embedding_config(
                 if request.app.state.config.RAG_EMBEDDING_ENGINE == "azure_openai"
                 else None
             ),
-            enable_async=request.app.state.config.ENABLE_ASYNC_EMBEDDING,
         )
 
         return {
             "status": True,
-            "RAG_EMBEDDING_ENGINE": request.app.state.config.RAG_EMBEDDING_ENGINE,
-            "RAG_EMBEDDING_MODEL": request.app.state.config.RAG_EMBEDDING_MODEL,
-            "RAG_EMBEDDING_BATCH_SIZE": request.app.state.config.RAG_EMBEDDING_BATCH_SIZE,
-            "ENABLE_ASYNC_EMBEDDING": request.app.state.config.ENABLE_ASYNC_EMBEDDING,
+            "embedding_engine": request.app.state.config.RAG_EMBEDDING_ENGINE,
+            "embedding_model": request.app.state.config.RAG_EMBEDDING_MODEL,
+            "embedding_batch_size": request.app.state.config.RAG_EMBEDDING_BATCH_SIZE,
             "openai_config": {
                 "url": request.app.state.config.RAG_OPENAI_API_BASE_URL,
                 "key": request.app.state.config.RAG_OPENAI_API_KEY,
@@ -442,7 +430,6 @@ async def get_rag_config(request: Request, user=Depends(get_admin_user)):
         "RAG_FULL_CONTEXT": request.app.state.config.RAG_FULL_CONTEXT,
         # Hybrid search settings
         "ENABLE_RAG_HYBRID_SEARCH": request.app.state.config.ENABLE_RAG_HYBRID_SEARCH,
-        "ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS": request.app.state.config.ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS,
         "TOP_K_RERANKER": request.app.state.config.TOP_K_RERANKER,
         "RELEVANCE_THRESHOLD": request.app.state.config.RELEVANCE_THRESHOLD,
         "HYBRID_BM25_WEIGHT": request.app.state.config.HYBRID_BM25_WEIGHT,
@@ -464,12 +451,20 @@ async def get_rag_config(request: Request, user=Depends(get_admin_user)):
         "EXTERNAL_DOCUMENT_LOADER_API_KEY": request.app.state.config.EXTERNAL_DOCUMENT_LOADER_API_KEY,
         "TIKA_SERVER_URL": request.app.state.config.TIKA_SERVER_URL,
         "DOCLING_SERVER_URL": request.app.state.config.DOCLING_SERVER_URL,
-        "DOCLING_API_KEY": request.app.state.config.DOCLING_API_KEY,
         "DOCLING_PARAMS": request.app.state.config.DOCLING_PARAMS,
+        "DOCLING_DO_OCR": request.app.state.config.DOCLING_DO_OCR,
+        "DOCLING_FORCE_OCR": request.app.state.config.DOCLING_FORCE_OCR,
+        "DOCLING_OCR_ENGINE": request.app.state.config.DOCLING_OCR_ENGINE,
+        "DOCLING_OCR_LANG": request.app.state.config.DOCLING_OCR_LANG,
+        "DOCLING_PDF_BACKEND": request.app.state.config.DOCLING_PDF_BACKEND,
+        "DOCLING_TABLE_MODE": request.app.state.config.DOCLING_TABLE_MODE,
+        "DOCLING_PIPELINE": request.app.state.config.DOCLING_PIPELINE,
+        "DOCLING_DO_PICTURE_DESCRIPTION": request.app.state.config.DOCLING_DO_PICTURE_DESCRIPTION,
+        "DOCLING_PICTURE_DESCRIPTION_MODE": request.app.state.config.DOCLING_PICTURE_DESCRIPTION_MODE,
+        "DOCLING_PICTURE_DESCRIPTION_LOCAL": request.app.state.config.DOCLING_PICTURE_DESCRIPTION_LOCAL,
+        "DOCLING_PICTURE_DESCRIPTION_API": request.app.state.config.DOCLING_PICTURE_DESCRIPTION_API,
         "DOCUMENT_INTELLIGENCE_ENDPOINT": request.app.state.config.DOCUMENT_INTELLIGENCE_ENDPOINT,
         "DOCUMENT_INTELLIGENCE_KEY": request.app.state.config.DOCUMENT_INTELLIGENCE_KEY,
-        "DOCUMENT_INTELLIGENCE_MODEL": request.app.state.config.DOCUMENT_INTELLIGENCE_MODEL,
-        "MISTRAL_OCR_API_BASE_URL": request.app.state.config.MISTRAL_OCR_API_BASE_URL,
         "MISTRAL_OCR_API_KEY": request.app.state.config.MISTRAL_OCR_API_KEY,
         # MinerU settings
         "MINERU_API_MODE": request.app.state.config.MINERU_API_MODE,
@@ -532,7 +527,6 @@ async def get_rag_config(request: Request, user=Depends(get_admin_user)):
             "PERPLEXITY_API_KEY": request.app.state.config.PERPLEXITY_API_KEY,
             "PERPLEXITY_MODEL": request.app.state.config.PERPLEXITY_MODEL,
             "PERPLEXITY_SEARCH_CONTEXT_USAGE": request.app.state.config.PERPLEXITY_SEARCH_CONTEXT_USAGE,
-            "PERPLEXITY_SEARCH_API_URL": request.app.state.config.PERPLEXITY_SEARCH_API_URL,
             "SOUGOU_API_SID": request.app.state.config.SOUGOU_API_SID,
             "SOUGOU_API_SK": request.app.state.config.SOUGOU_API_SK,
             "WEB_LOADER_ENGINE": request.app.state.config.WEB_LOADER_ENGINE,
@@ -590,7 +584,6 @@ class WebConfig(BaseModel):
     PERPLEXITY_API_KEY: Optional[str] = None
     PERPLEXITY_MODEL: Optional[str] = None
     PERPLEXITY_SEARCH_CONTEXT_USAGE: Optional[str] = None
-    PERPLEXITY_SEARCH_API_URL: Optional[str] = None
     SOUGOU_API_SID: Optional[str] = None
     SOUGOU_API_SK: Optional[str] = None
     WEB_LOADER_ENGINE: Optional[str] = None
@@ -618,7 +611,6 @@ class ConfigForm(BaseModel):
 
     # Hybrid search settings
     ENABLE_RAG_HYBRID_SEARCH: Optional[bool] = None
-    ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS: Optional[bool] = None
     TOP_K_RERANKER: Optional[int] = None
     RELEVANCE_THRESHOLD: Optional[float] = None
     HYBRID_BM25_WEIGHT: Optional[float] = None
@@ -644,12 +636,20 @@ class ConfigForm(BaseModel):
 
     TIKA_SERVER_URL: Optional[str] = None
     DOCLING_SERVER_URL: Optional[str] = None
-    DOCLING_API_KEY: Optional[str] = None
     DOCLING_PARAMS: Optional[dict] = None
+    DOCLING_DO_OCR: Optional[bool] = None
+    DOCLING_FORCE_OCR: Optional[bool] = None
+    DOCLING_OCR_ENGINE: Optional[str] = None
+    DOCLING_OCR_LANG: Optional[str] = None
+    DOCLING_PDF_BACKEND: Optional[str] = None
+    DOCLING_TABLE_MODE: Optional[str] = None
+    DOCLING_PIPELINE: Optional[str] = None
+    DOCLING_DO_PICTURE_DESCRIPTION: Optional[bool] = None
+    DOCLING_PICTURE_DESCRIPTION_MODE: Optional[str] = None
+    DOCLING_PICTURE_DESCRIPTION_LOCAL: Optional[dict] = None
+    DOCLING_PICTURE_DESCRIPTION_API: Optional[dict] = None
     DOCUMENT_INTELLIGENCE_ENDPOINT: Optional[str] = None
     DOCUMENT_INTELLIGENCE_KEY: Optional[str] = None
-    DOCUMENT_INTELLIGENCE_MODEL: Optional[str] = None
-    MISTRAL_OCR_API_BASE_URL: Optional[str] = None
     MISTRAL_OCR_API_KEY: Optional[str] = None
 
     # MinerU settings
@@ -716,11 +716,6 @@ async def update_rag_config(
         if form_data.ENABLE_RAG_HYBRID_SEARCH is not None
         else request.app.state.config.ENABLE_RAG_HYBRID_SEARCH
     )
-    request.app.state.config.ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS = (
-        form_data.ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS
-        if form_data.ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS is not None
-        else request.app.state.config.ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS
-    )
 
     request.app.state.config.TOP_K_RERANKER = (
         form_data.TOP_K_RERANKER
@@ -824,16 +819,68 @@ async def update_rag_config(
         if form_data.DOCLING_SERVER_URL is not None
         else request.app.state.config.DOCLING_SERVER_URL
     )
-    request.app.state.config.DOCLING_API_KEY = (
-        form_data.DOCLING_API_KEY
-        if form_data.DOCLING_API_KEY is not None
-        else request.app.state.config.DOCLING_API_KEY
-    )
     request.app.state.config.DOCLING_PARAMS = (
         form_data.DOCLING_PARAMS
         if form_data.DOCLING_PARAMS is not None
         else request.app.state.config.DOCLING_PARAMS
     )
+    request.app.state.config.DOCLING_DO_OCR = (
+        form_data.DOCLING_DO_OCR
+        if form_data.DOCLING_DO_OCR is not None
+        else request.app.state.config.DOCLING_DO_OCR
+    )
+    request.app.state.config.DOCLING_FORCE_OCR = (
+        form_data.DOCLING_FORCE_OCR
+        if form_data.DOCLING_FORCE_OCR is not None
+        else request.app.state.config.DOCLING_FORCE_OCR
+    )
+    request.app.state.config.DOCLING_OCR_ENGINE = (
+        form_data.DOCLING_OCR_ENGINE
+        if form_data.DOCLING_OCR_ENGINE is not None
+        else request.app.state.config.DOCLING_OCR_ENGINE
+    )
+    request.app.state.config.DOCLING_OCR_LANG = (
+        form_data.DOCLING_OCR_LANG
+        if form_data.DOCLING_OCR_LANG is not None
+        else request.app.state.config.DOCLING_OCR_LANG
+    )
+    request.app.state.config.DOCLING_PDF_BACKEND = (
+        form_data.DOCLING_PDF_BACKEND
+        if form_data.DOCLING_PDF_BACKEND is not None
+        else request.app.state.config.DOCLING_PDF_BACKEND
+    )
+    request.app.state.config.DOCLING_TABLE_MODE = (
+        form_data.DOCLING_TABLE_MODE
+        if form_data.DOCLING_TABLE_MODE is not None
+        else request.app.state.config.DOCLING_TABLE_MODE
+    )
+    request.app.state.config.DOCLING_PIPELINE = (
+        form_data.DOCLING_PIPELINE
+        if form_data.DOCLING_PIPELINE is not None
+        else request.app.state.config.DOCLING_PIPELINE
+    )
+    request.app.state.config.DOCLING_DO_PICTURE_DESCRIPTION = (
+        form_data.DOCLING_DO_PICTURE_DESCRIPTION
+        if form_data.DOCLING_DO_PICTURE_DESCRIPTION is not None
+        else request.app.state.config.DOCLING_DO_PICTURE_DESCRIPTION
+    )
+
+    request.app.state.config.DOCLING_PICTURE_DESCRIPTION_MODE = (
+        form_data.DOCLING_PICTURE_DESCRIPTION_MODE
+        if form_data.DOCLING_PICTURE_DESCRIPTION_MODE is not None
+        else request.app.state.config.DOCLING_PICTURE_DESCRIPTION_MODE
+    )
+    request.app.state.config.DOCLING_PICTURE_DESCRIPTION_LOCAL = (
+        form_data.DOCLING_PICTURE_DESCRIPTION_LOCAL
+        if form_data.DOCLING_PICTURE_DESCRIPTION_LOCAL is not None
+        else request.app.state.config.DOCLING_PICTURE_DESCRIPTION_LOCAL
+    )
+    request.app.state.config.DOCLING_PICTURE_DESCRIPTION_API = (
+        form_data.DOCLING_PICTURE_DESCRIPTION_API
+        if form_data.DOCLING_PICTURE_DESCRIPTION_API is not None
+        else request.app.state.config.DOCLING_PICTURE_DESCRIPTION_API
+    )
+
     request.app.state.config.DOCUMENT_INTELLIGENCE_ENDPOINT = (
         form_data.DOCUMENT_INTELLIGENCE_ENDPOINT
         if form_data.DOCUMENT_INTELLIGENCE_ENDPOINT is not None
@@ -844,17 +891,6 @@ async def update_rag_config(
         if form_data.DOCUMENT_INTELLIGENCE_KEY is not None
         else request.app.state.config.DOCUMENT_INTELLIGENCE_KEY
     )
-    request.app.state.config.DOCUMENT_INTELLIGENCE_MODEL = (
-        form_data.DOCUMENT_INTELLIGENCE_MODEL
-        if form_data.DOCUMENT_INTELLIGENCE_MODEL is not None
-        else request.app.state.config.DOCUMENT_INTELLIGENCE_MODEL
-    )
-
-    request.app.state.config.MISTRAL_OCR_API_BASE_URL = (
-        form_data.MISTRAL_OCR_API_BASE_URL
-        if form_data.MISTRAL_OCR_API_BASE_URL is not None
-        else request.app.state.config.MISTRAL_OCR_API_BASE_URL
-    )
     request.app.state.config.MISTRAL_OCR_API_KEY = (
         form_data.MISTRAL_OCR_API_KEY
         if form_data.MISTRAL_OCR_API_KEY is not None
@@ -934,6 +970,7 @@ async def update_rag_config(
                     request.app.state.config.RAG_RERANKING_MODEL,
                     request.app.state.config.RAG_EXTERNAL_RERANKER_URL,
                     request.app.state.config.RAG_EXTERNAL_RERANKER_API_KEY,
+                    True,
                 )
 
                 request.app.state.RERANKING_FUNCTION = get_reranking_function(
@@ -1063,9 +1100,6 @@ async def update_rag_config(
         request.app.state.config.PERPLEXITY_SEARCH_CONTEXT_USAGE = (
             form_data.web.PERPLEXITY_SEARCH_CONTEXT_USAGE
         )
-        request.app.state.config.PERPLEXITY_SEARCH_API_URL = (
-            form_data.web.PERPLEXITY_SEARCH_API_URL
-        )
         request.app.state.config.SOUGOU_API_SID = form_data.web.SOUGOU_API_SID
         request.app.state.config.SOUGOU_API_SK = form_data.web.SOUGOU_API_SK
 
@@ -1134,12 +1168,20 @@ async def update_rag_config(
         "EXTERNAL_DOCUMENT_LOADER_API_KEY": request.app.state.config.EXTERNAL_DOCUMENT_LOADER_API_KEY,
         "TIKA_SERVER_URL": request.app.state.config.TIKA_SERVER_URL,
         "DOCLING_SERVER_URL": request.app.state.config.DOCLING_SERVER_URL,
-        "DOCLING_API_KEY": request.app.state.config.DOCLING_API_KEY,
         "DOCLING_PARAMS": request.app.state.config.DOCLING_PARAMS,
+        "DOCLING_DO_OCR": request.app.state.config.DOCLING_DO_OCR,
+        "DOCLING_FORCE_OCR": request.app.state.config.DOCLING_FORCE_OCR,
+        "DOCLING_OCR_ENGINE": request.app.state.config.DOCLING_OCR_ENGINE,
+        "DOCLING_OCR_LANG": request.app.state.config.DOCLING_OCR_LANG,
+        "DOCLING_PDF_BACKEND": request.app.state.config.DOCLING_PDF_BACKEND,
+        "DOCLING_TABLE_MODE": request.app.state.config.DOCLING_TABLE_MODE,
+        "DOCLING_PIPELINE": request.app.state.config.DOCLING_PIPELINE,
+        "DOCLING_DO_PICTURE_DESCRIPTION": request.app.state.config.DOCLING_DO_PICTURE_DESCRIPTION,
+        "DOCLING_PICTURE_DESCRIPTION_MODE": request.app.state.config.DOCLING_PICTURE_DESCRIPTION_MODE,
+        "DOCLING_PICTURE_DESCRIPTION_LOCAL": request.app.state.config.DOCLING_PICTURE_DESCRIPTION_LOCAL,
+        "DOCLING_PICTURE_DESCRIPTION_API": request.app.state.config.DOCLING_PICTURE_DESCRIPTION_API,
         "DOCUMENT_INTELLIGENCE_ENDPOINT": request.app.state.config.DOCUMENT_INTELLIGENCE_ENDPOINT,
         "DOCUMENT_INTELLIGENCE_KEY": request.app.state.config.DOCUMENT_INTELLIGENCE_KEY,
-        "DOCUMENT_INTELLIGENCE_MODEL": request.app.state.config.DOCUMENT_INTELLIGENCE_MODEL,
-        "MISTRAL_OCR_API_BASE_URL": request.app.state.config.MISTRAL_OCR_API_BASE_URL,
         "MISTRAL_OCR_API_KEY": request.app.state.config.MISTRAL_OCR_API_KEY,
         # MinerU settings
         "MINERU_API_MODE": request.app.state.config.MINERU_API_MODE,
@@ -1202,7 +1244,6 @@ async def update_rag_config(
             "PERPLEXITY_API_KEY": request.app.state.config.PERPLEXITY_API_KEY,
             "PERPLEXITY_MODEL": request.app.state.config.PERPLEXITY_MODEL,
             "PERPLEXITY_SEARCH_CONTEXT_USAGE": request.app.state.config.PERPLEXITY_SEARCH_CONTEXT_USAGE,
-            "PERPLEXITY_SEARCH_API_URL": request.app.state.config.PERPLEXITY_SEARCH_API_URL,
             "SOUGOU_API_SID": request.app.state.config.SOUGOU_API_SID,
             "SOUGOU_API_SK": request.app.state.config.SOUGOU_API_SK,
             "WEB_LOADER_ENGINE": request.app.state.config.WEB_LOADER_ENGINE,
@@ -1256,7 +1297,7 @@ def save_docs_to_vector_db(
 
         return ", ".join(docs_info)
 
-    log.debug(
+    log.info(
         f"save_docs_to_vector_db: document {_get_docs_info(docs)} {collection_name}"
     )
 
@@ -1403,13 +1444,10 @@ def save_docs_to_vector_db(
             ),
         )
 
-        # Run async embedding in sync context
-        embeddings = asyncio.run(
-            embedding_function(
-                list(map(lambda x: x.replace("\n", " "), texts)),
-                prefix=RAG_EMBEDDING_CONTENT_PREFIX,
-                user=user,
-            )
+        embeddings = embedding_function(
+            list(map(lambda x: x.replace("\n", " "), texts)),
+            prefix=RAG_EMBEDDING_CONTENT_PREFIX,
+            user=user,
         )
         log.info(f"embeddings generated {len(embeddings)} for {len(texts)} items")
 
@@ -1448,9 +1486,6 @@ def process_file(
     form_data: ProcessFileForm,
     user=Depends(get_verified_user),
 ):
-    """
-    Process a file and save its content to the vector database.
-    """
     if user.role == "admin":
         file = Files.get_file_by_id(form_data.file_id)
     else:
@@ -1530,7 +1565,6 @@ def process_file(
                     file_path = Storage.get_file(file_path)
                     loader = Loader(
                         engine=request.app.state.config.CONTENT_EXTRACTION_ENGINE,
-                        user=user,
                         DATALAB_MARKER_API_KEY=request.app.state.config.DATALAB_MARKER_API_KEY,
                         DATALAB_MARKER_API_BASE_URL=request.app.state.config.DATALAB_MARKER_API_BASE_URL,
                         DATALAB_MARKER_ADDITIONAL_CONFIG=request.app.state.config.DATALAB_MARKER_ADDITIONAL_CONFIG,
@@ -1546,13 +1580,23 @@ def process_file(
                         EXTERNAL_DOCUMENT_LOADER_API_KEY=request.app.state.config.EXTERNAL_DOCUMENT_LOADER_API_KEY,
                         TIKA_SERVER_URL=request.app.state.config.TIKA_SERVER_URL,
                         DOCLING_SERVER_URL=request.app.state.config.DOCLING_SERVER_URL,
-                        DOCLING_API_KEY=request.app.state.config.DOCLING_API_KEY,
-                        DOCLING_PARAMS=request.app.state.config.DOCLING_PARAMS,
+                        DOCLING_PARAMS={
+                            "do_ocr": request.app.state.config.DOCLING_DO_OCR,
+                            "force_ocr": request.app.state.config.DOCLING_FORCE_OCR,
+                            "ocr_engine": request.app.state.config.DOCLING_OCR_ENGINE,
+                            "ocr_lang": request.app.state.config.DOCLING_OCR_LANG,
+                            "pdf_backend": request.app.state.config.DOCLING_PDF_BACKEND,
+                            "table_mode": request.app.state.config.DOCLING_TABLE_MODE,
+                            "pipeline": request.app.state.config.DOCLING_PIPELINE,
+                            "do_picture_description": request.app.state.config.DOCLING_DO_PICTURE_DESCRIPTION,
+                            "picture_description_mode": request.app.state.config.DOCLING_PICTURE_DESCRIPTION_MODE,
+                            "picture_description_local": request.app.state.config.DOCLING_PICTURE_DESCRIPTION_LOCAL,
+                            "picture_description_api": request.app.state.config.DOCLING_PICTURE_DESCRIPTION_API,
+                            **request.app.state.config.DOCLING_PARAMS,
+                        },
                         PDF_EXTRACT_IMAGES=request.app.state.config.PDF_EXTRACT_IMAGES,
                         DOCUMENT_INTELLIGENCE_ENDPOINT=request.app.state.config.DOCUMENT_INTELLIGENCE_ENDPOINT,
                         DOCUMENT_INTELLIGENCE_KEY=request.app.state.config.DOCUMENT_INTELLIGENCE_KEY,
-                        DOCUMENT_INTELLIGENCE_MODEL=request.app.state.config.DOCUMENT_INTELLIGENCE_MODEL,
-                        MISTRAL_OCR_API_BASE_URL=request.app.state.config.MISTRAL_OCR_API_BASE_URL,
                         MISTRAL_OCR_API_KEY=request.app.state.config.MISTRAL_OCR_API_KEY,
                         MINERU_API_MODE=request.app.state.config.MINERU_API_MODE,
                         MINERU_API_URL=request.app.state.config.MINERU_API_URL,
@@ -1678,7 +1722,7 @@ class ProcessTextForm(BaseModel):
 
 
 @router.post("/process/text")
-async def process_text(
+def process_text(
     request: Request,
     form_data: ProcessTextForm,
     user=Depends(get_verified_user),
@@ -1696,9 +1740,7 @@ async def process_text(
     text_content = form_data.content
     log.debug(f"text_content: {text_content}")
 
-    result = await run_in_threadpool(
-        save_docs_to_vector_db, request, docs, collection_name, user=user
-    )
+    result = save_docs_to_vector_db(request, docs, collection_name, user=user)
     if result:
         return {
             "status": True,
@@ -1714,7 +1756,7 @@ async def process_text(
 
 @router.post("/process/youtube")
 @router.post("/process/web")
-async def process_web(
+def process_web(
     request: Request, form_data: ProcessUrlForm, user=Depends(get_verified_user)
 ):
     try:
@@ -1722,14 +1764,11 @@ async def process_web(
         if not collection_name:
             collection_name = calculate_sha256_string(form_data.url)[:63]
 
-        content, docs = await run_in_threadpool(
-            get_content_from_url, request, form_data.url
-        )
+        content, docs = get_content_from_url(request, form_data.url)
         log.debug(f"text_content: {content}")
 
         if not request.app.state.config.BYPASS_WEB_SEARCH_EMBEDDING_AND_RETRIEVAL:
-            await run_in_threadpool(
-                save_docs_to_vector_db,
+            save_docs_to_vector_db(
                 request,
                 docs,
                 collection_name,
@@ -1761,9 +1800,7 @@ async def process_web(
         )
 
 
-def search_web(
-    request: Request, engine: str, query: str, user=None
-) -> list[SearchResult]:
+def search_web(request: Request, engine: str, query: str) -> list[SearchResult]:
     """Search the web using a search engine and return the results as a list of SearchResult objects.
     Will look for a search engine API key in environment variables in the following order:
     - SEARXNG_QUERY_URL
@@ -1802,8 +1839,6 @@ def search_web(
                 query,
                 request.app.state.config.WEB_SEARCH_RESULT_COUNT,
                 request.app.state.config.WEB_SEARCH_DOMAIN_FILTER_LIST,
-                request.app.state.config.PERPLEXITY_SEARCH_API_URL,
-                user,
             )
         else:
             raise Exception("No PERPLEXITY_API_KEY found in environment variables")
@@ -1840,7 +1875,6 @@ def search_web(
                 query,
                 request.app.state.config.WEB_SEARCH_RESULT_COUNT,
                 request.app.state.config.WEB_SEARCH_DOMAIN_FILTER_LIST,
-                referer=request.app.state.config.WEBUI_URL,
             )
         else:
             raise Exception(
@@ -1981,24 +2015,6 @@ def search_web(
             request.app.state.config.WEB_SEARCH_RESULT_COUNT,
             request.app.state.config.WEB_SEARCH_DOMAIN_FILTER_LIST,
         )
-    elif engine == "azure":
-        if (
-            request.app.state.config.AZURE_AI_SEARCH_API_KEY
-            and request.app.state.config.AZURE_AI_SEARCH_ENDPOINT
-            and request.app.state.config.AZURE_AI_SEARCH_INDEX_NAME
-        ):
-            return search_azure(
-                request.app.state.config.AZURE_AI_SEARCH_API_KEY,
-                request.app.state.config.AZURE_AI_SEARCH_ENDPOINT,
-                request.app.state.config.AZURE_AI_SEARCH_INDEX_NAME,
-                query,
-                request.app.state.config.WEB_SEARCH_RESULT_COUNT,
-                request.app.state.config.WEB_SEARCH_DOMAIN_FILTER_LIST,
-            )
-        else:
-            raise Exception(
-                "AZURE_AI_SEARCH_API_KEY, AZURE_AI_SEARCH_ENDPOINT, and AZURE_AI_SEARCH_INDEX_NAME are required for Azure AI Search"
-            )
     elif engine == "exa":
         return search_exa(
             request.app.state.config.EXA_API_KEY,
@@ -2041,13 +2057,11 @@ def search_web(
         )
     elif engine == "external":
         return search_external(
-            request,
             request.app.state.config.EXTERNAL_WEB_SEARCH_URL,
             request.app.state.config.EXTERNAL_WEB_SEARCH_API_KEY,
             query,
             request.app.state.config.WEB_SEARCH_RESULT_COUNT,
             request.app.state.config.WEB_SEARCH_DOMAIN_FILTER_LIST,
-            user=user,
         )
     else:
         raise Exception("No search engine API key found in environment variables")
@@ -2072,7 +2086,6 @@ async def process_web_search(
                 request,
                 request.app.state.config.WEB_SEARCH_ENGINE,
                 query,
-                user,
             )
             for query in form_data.queries
         ]
@@ -2198,7 +2211,7 @@ class QueryDocForm(BaseModel):
 
 
 @router.post("/query/doc")
-async def query_doc_handler(
+def query_doc_handler(
     request: Request,
     form_data: QueryDocForm,
     user=Depends(get_verified_user),
@@ -2211,7 +2224,7 @@ async def query_doc_handler(
             collection_results[form_data.collection_name] = VECTOR_DB_CLIENT.get(
                 collection_name=form_data.collection_name
             )
-            return await query_doc_with_hybrid_search(
+            return query_doc_with_hybrid_search(
                 collection_name=form_data.collection_name,
                 collection_result=collection_results[form_data.collection_name],
                 query=form_data.query,
@@ -2221,8 +2234,8 @@ async def query_doc_handler(
                 k=form_data.k if form_data.k else request.app.state.config.TOP_K,
                 reranking_function=(
                     (
-                        lambda query, documents: request.app.state.RERANKING_FUNCTION(
-                            query, documents, user=user
+                        lambda sentences: request.app.state.RERANKING_FUNCTION(
+                            sentences, user=user
                         )
                     )
                     if request.app.state.RERANKING_FUNCTION
@@ -2243,12 +2256,11 @@ async def query_doc_handler(
                 user=user,
             )
         else:
-            query_embedding = await request.app.state.EMBEDDING_FUNCTION(
-                form_data.query, prefix=RAG_EMBEDDING_QUERY_PREFIX, user=user
-            )
             return query_doc(
                 collection_name=form_data.collection_name,
-                query_embedding=query_embedding,
+                query_embedding=request.app.state.EMBEDDING_FUNCTION(
+                    form_data.query, prefix=RAG_EMBEDDING_QUERY_PREFIX, user=user
+                ),
                 k=form_data.k if form_data.k else request.app.state.config.TOP_K,
                 user=user,
             )
@@ -2268,11 +2280,10 @@ class QueryCollectionsForm(BaseModel):
     r: Optional[float] = None
     hybrid: Optional[bool] = None
     hybrid_bm25_weight: Optional[float] = None
-    enable_enriched_texts: Optional[bool] = None
 
 
 @router.post("/query/collection")
-async def query_collection_handler(
+def query_collection_handler(
     request: Request,
     form_data: QueryCollectionsForm,
     user=Depends(get_verified_user),
@@ -2281,7 +2292,7 @@ async def query_collection_handler(
         if request.app.state.config.ENABLE_RAG_HYBRID_SEARCH and (
             form_data.hybrid is None or form_data.hybrid
         ):
-            return await query_collection_with_hybrid_search(
+            return query_collection_with_hybrid_search(
                 collection_names=form_data.collection_names,
                 queries=[form_data.query],
                 embedding_function=lambda query, prefix: request.app.state.EMBEDDING_FUNCTION(
@@ -2290,8 +2301,8 @@ async def query_collection_handler(
                 k=form_data.k if form_data.k else request.app.state.config.TOP_K,
                 reranking_function=(
                     (
-                        lambda query, documents: request.app.state.RERANKING_FUNCTION(
-                            query, documents, user=user
+                        lambda sentences: request.app.state.RERANKING_FUNCTION(
+                            sentences, user=user
                         )
                     )
                     if request.app.state.RERANKING_FUNCTION
@@ -2309,14 +2320,9 @@ async def query_collection_handler(
                     if form_data.hybrid_bm25_weight
                     else request.app.state.config.HYBRID_BM25_WEIGHT
                 ),
-                enable_enriched_texts=(
-                    form_data.enable_enriched_texts
-                    if form_data.enable_enriched_texts is not None
-                    else request.app.state.config.ENABLE_RAG_HYBRID_SEARCH_ENRICHED_TEXTS
-                ),
             )
         else:
-            return await query_collection(
+            return query_collection(
                 collection_names=form_data.collection_names,
                 queries=[form_data.query],
                 embedding_function=lambda query, prefix: request.app.state.EMBEDDING_FUNCTION(
@@ -2398,7 +2404,7 @@ if ENV == "dev":
     @router.get("/ef/{text}")
     async def get_embeddings(request: Request, text: Optional[str] = "Hello World!"):
         return {
-            "result": await request.app.state.EMBEDDING_FUNCTION(
+            "result": request.app.state.EMBEDDING_FUNCTION(
                 text, prefix=RAG_EMBEDDING_QUERY_PREFIX
             )
         }
@@ -2421,7 +2427,7 @@ class BatchProcessFilesResponse(BaseModel):
 
 
 @router.post("/process/files/batch")
-async def process_files_batch(
+def process_files_batch(
     request: Request,
     form_data: BatchProcessFilesForm,
     user=Depends(get_verified_user),
@@ -2429,19 +2435,16 @@ async def process_files_batch(
     """
     Process a batch of files and save them to the vector database.
     """
-
+    results: List[BatchProcessFilesResult] = []
+    errors: List[BatchProcessFilesResult] = []
     collection_name = form_data.collection_name
 
-    file_results: List[BatchProcessFilesResult] = []
-    file_errors: List[BatchProcessFilesResult] = []
-    file_updates: List[FileUpdateForm] = []
-
     # Prepare all documents first
     all_docs: List[Document] = []
-
     for file in form_data.files:
         try:
             text_content = file.data.get("content", "")
+
             docs: List[Document] = [
                 Document(
                     page_content=text_content.replace("<br/>", "\n"),
@@ -2455,49 +2458,45 @@ async def process_files_batch(
                 )
             ]
 
-            all_docs.extend(docs)
+            hash = calculate_sha256_string(text_content)
+            Files.update_file_hash_by_id(file.id, hash)
+            Files.update_file_data_by_id(file.id, {"content": text_content})
 
-            file_updates.append(
-                FileUpdateForm(
-                    hash=calculate_sha256_string(text_content),
-                    data={"content": text_content},
-                )
-            )
-            file_results.append(
-                BatchProcessFilesResult(file_id=file.id, status="prepared")
-            )
+            all_docs.extend(docs)
+            results.append(BatchProcessFilesResult(file_id=file.id, status="prepared"))
 
         except Exception as e:
             log.error(f"process_files_batch: Error processing file {file.id}: {str(e)}")
-            file_errors.append(
+            errors.append(
                 BatchProcessFilesResult(file_id=file.id, status="failed", error=str(e))
             )
 
     # Save all documents in one batch
     if all_docs:
         try:
-            await run_in_threadpool(
-                save_docs_to_vector_db,
-                request,
-                all_docs,
-                collection_name,
+            save_docs_to_vector_db(
+                request=request,
+                docs=all_docs,
+                collection_name=collection_name,
                 add=True,
                 user=user,
             )
 
             # Update all files with collection name
-            for file_update, file_result in zip(file_updates, file_results):
-                Files.update_file_by_id(id=file_result.file_id, form_data=file_update)
-                file_result.status = "completed"
+            for result in results:
+                Files.update_file_metadata_by_id(
+                    result.file_id, {"collection_name": collection_name}
+                )
+                result.status = "completed"
 
         except Exception as e:
             log.error(
                 f"process_files_batch: Error saving documents to vector DB: {str(e)}"
             )
-            for file_result in file_results:
-                file_result.status = "failed"
-                file_errors.append(
-                    BatchProcessFilesResult(file_id=file_result.file_id, error=str(e))
+            for result in results:
+                result.status = "failed"
+                errors.append(
+                    BatchProcessFilesResult(file_id=result.file_id, error=str(e))
                 )
 
-    return BatchProcessFilesResponse(results=file_results, errors=file_errors)
+    return BatchProcessFilesResponse(results=results, errors=errors)

backend/open_webui/routers/scim.py

@@ -256,16 +256,15 @@ def get_scim_auth(
             )
 
         # Check if SCIM is enabled
-        enable_scim = getattr(request.app.state, "ENABLE_SCIM", False)
+        scim_enabled = getattr(request.app.state, "SCIM_ENABLED", False)
         log.info(
-            f"SCIM auth check - raw ENABLE_SCIM: {enable_scim}, type: {type(enable_scim)}"
+            f"SCIM auth check - raw SCIM_ENABLED: {scim_enabled}, type: {type(scim_enabled)}"
         )
-
         # Handle both PersistentConfig and direct value
-        if hasattr(enable_scim, "value"):
-            enable_scim = enable_scim.value
-
-        if not enable_scim:
+        if hasattr(scim_enabled, "value"):
+            scim_enabled = scim_enabled.value
+        log.info(f"SCIM enabled status after conversion: {scim_enabled}")
+        if not scim_enabled:
             raise HTTPException(
                 status_code=status.HTTP_403_FORBIDDEN,
                 detail="SCIM is not enabled",
@@ -349,10 +348,8 @@ def user_to_scim(user: UserModel, request: Request) -> SCIMUser:
 
 def group_to_scim(group: GroupModel, request: Request) -> SCIMGroup:
     """Convert internal Group model to SCIM Group"""
-    member_ids = Groups.get_group_user_ids_by_id(group.id)
     members = []
-
-    for user_id in member_ids:
+    for user_id in group.user_ids:
         user = Users.get_user_by_id(user_id)
         if user:
             members.append(
@@ -719,7 +716,7 @@ async def get_groups(
 ):
     """List SCIM Groups"""
     # Get all groups
-    groups_list = Groups.get_all_groups()
+    groups_list = Groups.get_groups()
 
     # Apply pagination
     total = len(groups_list)
@@ -798,11 +795,9 @@ async def create_group(
         update_form = GroupUpdateForm(
             name=new_group.name,
             description=new_group.description,
+            user_ids=member_ids,
         )
-
         Groups.update_group_by_id(new_group.id, update_form)
-        Groups.set_group_user_ids_by_id(new_group.id, member_ids)
-
         new_group = Groups.get_group_by_id(new_group.id)
 
     return group_to_scim(new_group, request)
@@ -834,7 +829,7 @@ async def update_group(
     # Handle members if provided
     if group_data.members is not None:
         member_ids = [member.value for member in group_data.members]
-        Groups.set_group_user_ids_by_id(group_id, member_ids)
+        update_form.user_ids = member_ids
 
     # Update group
     updated_group = Groups.update_group_by_id(group_id, update_form)
@@ -867,6 +862,7 @@ async def patch_group(
     update_form = GroupUpdateForm(
         name=group.name,
         description=group.description,
+        user_ids=group.user_ids.copy() if group.user_ids else [],
     )
 
     for operation in patch_data.Operations:
@@ -879,22 +875,21 @@ async def patch_group(
                 update_form.name = value
             elif path == "members":
                 # Replace all members
-                Groups.set_group_user_ids_by_id(
-                    group_id, [member["value"] for member in value]
-                )
-
+                update_form.user_ids = [member["value"] for member in value]
         elif op == "add":
             if path == "members":
                 # Add members
                 if isinstance(value, list):
                     for member in value:
                         if isinstance(member, dict) and "value" in member:
-                            Groups.add_users_to_group(group_id, [member["value"]])
+                            if member["value"] not in update_form.user_ids:
+                                update_form.user_ids.append(member["value"])
         elif op == "remove":
             if path and path.startswith("members[value eq"):
                 # Remove specific member
                 member_id = path.split('"')[1]
-                Groups.remove_users_from_group(group_id, [member_id])
+                if member_id in update_form.user_ids:
+                    update_form.user_ids.remove(member_id)
 
     # Update group
     updated_group = Groups.update_group_by_id(group_id, update_form)

backend/open_webui/routers/tasks.py

@@ -33,7 +33,6 @@ from open_webui.config import (
     DEFAULT_AUTOCOMPLETE_GENERATION_PROMPT_TEMPLATE,
     DEFAULT_EMOJI_GENERATION_PROMPT_TEMPLATE,
     DEFAULT_MOA_GENERATION_PROMPT_TEMPLATE,
-    DEFAULT_VOICE_MODE_PROMPT_TEMPLATE,
 )
 from open_webui.env import SRC_LOG_LEVELS
 
@@ -69,7 +68,6 @@ async def get_task_config(request: Request, user=Depends(get_verified_user)):
         "ENABLE_RETRIEVAL_QUERY_GENERATION": request.app.state.config.ENABLE_RETRIEVAL_QUERY_GENERATION,
         "QUERY_GENERATION_PROMPT_TEMPLATE": request.app.state.config.QUERY_GENERATION_PROMPT_TEMPLATE,
         "TOOLS_FUNCTION_CALLING_PROMPT_TEMPLATE": request.app.state.config.TOOLS_FUNCTION_CALLING_PROMPT_TEMPLATE,
-        "VOICE_MODE_PROMPT_TEMPLATE": request.app.state.config.VOICE_MODE_PROMPT_TEMPLATE,
     }
 
 
@@ -89,7 +87,6 @@ class TaskConfigForm(BaseModel):
     ENABLE_RETRIEVAL_QUERY_GENERATION: bool
     QUERY_GENERATION_PROMPT_TEMPLATE: str
     TOOLS_FUNCTION_CALLING_PROMPT_TEMPLATE: str
-    VOICE_MODE_PROMPT_TEMPLATE: Optional[str]
 
 
 @router.post("/config/update")
@@ -139,10 +136,6 @@ async def update_task_config(
         form_data.TOOLS_FUNCTION_CALLING_PROMPT_TEMPLATE
     )
 
-    request.app.state.config.VOICE_MODE_PROMPT_TEMPLATE = (
-        form_data.VOICE_MODE_PROMPT_TEMPLATE
-    )
-
     return {
         "TASK_MODEL": request.app.state.config.TASK_MODEL,
         "TASK_MODEL_EXTERNAL": request.app.state.config.TASK_MODEL_EXTERNAL,
@@ -159,7 +152,6 @@ async def update_task_config(
         "ENABLE_RETRIEVAL_QUERY_GENERATION": request.app.state.config.ENABLE_RETRIEVAL_QUERY_GENERATION,
         "QUERY_GENERATION_PROMPT_TEMPLATE": request.app.state.config.QUERY_GENERATION_PROMPT_TEMPLATE,
         "TOOLS_FUNCTION_CALLING_PROMPT_TEMPLATE": request.app.state.config.TOOLS_FUNCTION_CALLING_PROMPT_TEMPLATE,
-        "VOICE_MODE_PROMPT_TEMPLATE": request.app.state.config.VOICE_MODE_PROMPT_TEMPLATE,
     }
 
 

backend/open_webui/routers/tools.py

@@ -247,19 +247,9 @@ async def load_tool_from_url(
 
 
 @router.get("/export", response_model=list[ToolModel])
-async def export_tools(request: Request, user=Depends(get_verified_user)):
-    if user.role != "admin" and not has_permission(
-        user.id, "workspace.tools_export", request.app.state.config.USER_PERMISSIONS
-    ):
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=ERROR_MESSAGES.UNAUTHORIZED,
-        )
-
-    if user.role == "admin" and BYPASS_ADMIN_ACCESS_CONTROL:
-        return Tools.get_tools()
-    else:
-        return Tools.get_tools_by_user_id(user.id, "read")
+async def export_tools(user=Depends(get_admin_user)):
+    tools = Tools.get_tools()
+    return tools
 
 
 ############################
@@ -273,13 +263,8 @@ async def create_new_tools(
     form_data: ToolForm,
     user=Depends(get_verified_user),
 ):
-    if user.role != "admin" and not (
-        has_permission(
-            user.id, "workspace.tools", request.app.state.config.USER_PERMISSIONS
-        )
-        or has_permission(
-            user.id, "workspace.tools_import", request.app.state.config.USER_PERMISSIONS
-        )
+    if user.role != "admin" and not has_permission(
+        user.id, "workspace.tools", request.app.state.config.USER_PERMISSIONS
     ):
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,

backend/open_webui/routers/users.py

@@ -6,7 +6,7 @@ import io
 
 from fastapi import APIRouter, Depends, HTTPException, Request, status
 from fastapi.responses import Response, StreamingResponse, FileResponse
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel
 
 
 from open_webui.models.auths import Auths
@@ -16,27 +16,26 @@ from open_webui.models.groups import Groups
 from open_webui.models.chats import Chats
 from open_webui.models.users import (
     UserModel,
-    UserGroupIdsModel,
-    UserGroupIdsListResponse,
-    UserInfoListResponse,
+    UserListResponse,
     UserInfoListResponse,
+    UserIdNameListResponse,
     UserRoleUpdateForm,
-    UserStatus,
     Users,
     UserSettings,
     UserUpdateForm,
 )
 
+
+from open_webui.socket.main import (
+    get_active_status_by_user_id,
+    get_active_user_ids,
+    get_user_active_status,
+)
 from open_webui.constants import ERROR_MESSAGES
 from open_webui.env import SRC_LOG_LEVELS, STATIC_DIR
 
 
-from open_webui.utils.auth import (
-    get_admin_user,
-    get_password_hash,
-    get_verified_user,
-    validate_password,
-)
+from open_webui.utils.auth import get_admin_user, get_password_hash, get_verified_user
 from open_webui.utils.access_control import get_permissions, has_permission
 
 
@@ -46,6 +45,23 @@ log.setLevel(SRC_LOG_LEVELS["MODELS"])
 router = APIRouter()
 
 
+############################
+# GetActiveUsers
+############################
+
+
+@router.get("/active")
+async def get_active_users(
+    user=Depends(get_verified_user),
+):
+    """
+    Get a list of active users.
+    """
+    return {
+        "user_ids": get_active_user_ids(),
+    }
+
+
 ############################
 # GetUsers
 ############################
@@ -54,7 +70,7 @@ router = APIRouter()
 PAGE_ITEM_COUNT = 30
 
 
-@router.get("/", response_model=UserGroupIdsListResponse)
+@router.get("/", response_model=UserListResponse)
 async def get_users(
     query: Optional[str] = None,
     order_by: Optional[str] = None,
@@ -75,25 +91,7 @@ async def get_users(
     if direction:
         filter["direction"] = direction
 
-    result = Users.get_users(filter=filter, skip=skip, limit=limit)
-
-    users = result["users"]
-    total = result["total"]
-
-    return {
-        "users": [
-            UserGroupIdsModel(
-                **{
-                    **user.model_dump(),
-                    "group_ids": [
-                        group.id for group in Groups.get_groups_by_member_id(user.id)
-                    ],
-                }
-            )
-            for user in users
-        ],
-        "total": total,
-    }
+    return Users.get_users(filter=filter, skip=skip, limit=limit)
 
 
 @router.get("/all", response_model=UserInfoListResponse)
@@ -103,31 +101,20 @@ async def get_all_users(
     return Users.get_users()
 
 
-@router.get("/search", response_model=UserInfoListResponse)
+@router.get("/search", response_model=UserIdNameListResponse)
 async def search_users(
     query: Optional[str] = None,
-    order_by: Optional[str] = None,
-    direction: Optional[str] = None,
-    page: Optional[int] = 1,
     user=Depends(get_verified_user),
 ):
     limit = PAGE_ITEM_COUNT
 
-    page = max(1, page)
+    page = 1  # Always return the first page for search
     skip = (page - 1) * limit
 
     filter = {}
     if query:
         filter["query"] = query
 
-    filter = {}
-    if query:
-        filter["query"] = query
-    if order_by:
-        filter["order_by"] = order_by
-    if direction:
-        filter["direction"] = direction
-
     return Users.get_users(filter=filter, skip=skip, limit=limit)
 
 
@@ -163,24 +150,13 @@ class WorkspacePermissions(BaseModel):
     knowledge: bool = False
     prompts: bool = False
     tools: bool = False
-    models_import: bool = False
-    models_export: bool = False
-    prompts_import: bool = False
-    prompts_export: bool = False
-    tools_import: bool = False
-    tools_export: bool = False
 
 
 class SharingPermissions(BaseModel):
-    models: bool = False
-    public_models: bool = False
-    knowledge: bool = False
-    public_knowledge: bool = False
-    prompts: bool = False
-    public_prompts: bool = False
-    tools: bool = False
+    public_models: bool = True
+    public_knowledge: bool = True
+    public_prompts: bool = True
     public_tools: bool = True
-    notes: bool = False
     public_notes: bool = True
 
 
@@ -207,15 +183,11 @@ class ChatPermissions(BaseModel):
 
 
 class FeaturesPermissions(BaseModel):
-    api_keys: bool = False
-    notes: bool = True
-    channels: bool = True
-    folders: bool = True
     direct_tool_servers: bool = False
-
     web_search: bool = True
     image_generation: bool = True
     code_interpreter: bool = True
+    notes: bool = True
 
 
 class UserPermissions(BaseModel):
@@ -300,43 +272,6 @@ async def update_user_settings_by_session_user(
         )
 
 
-############################
-# GetUserStatusBySessionUser
-############################
-
-
-@router.get("/user/status")
-async def get_user_status_by_session_user(user=Depends(get_verified_user)):
-    user = Users.get_user_by_id(user.id)
-    if user:
-        return user
-    else:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=ERROR_MESSAGES.USER_NOT_FOUND,
-        )
-
-
-############################
-# UpdateUserStatusBySessionUser
-############################
-
-
-@router.post("/user/status/update")
-async def update_user_status_by_session_user(
-    form_data: UserStatus, user=Depends(get_verified_user)
-):
-    user = Users.get_user_by_id(user.id)
-    if user:
-        user = Users.update_user_status_by_id(user.id, form_data)
-        return user
-    else:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=ERROR_MESSAGES.USER_NOT_FOUND,
-        )
-
-
 ############################
 # GetUserInfoBySessionUser
 ############################
@@ -388,15 +323,13 @@ async def update_user_info_by_session_user(
 ############################
 
 
-class UserActiveResponse(UserStatus):
+class UserResponse(BaseModel):
     name: str
-    profile_image_url: Optional[str] = None
-
-    is_active: bool
-    model_config = ConfigDict(extra="allow")
+    profile_image_url: str
+    active: Optional[bool] = None
 
 
-@router.get("/{user_id}", response_model=UserActiveResponse)
+@router.get("/{user_id}", response_model=UserResponse)
 async def get_user_by_id(user_id: str, user=Depends(get_verified_user)):
     # Check if user_id is a shared chat
     # If it is, get the user_id from the chat
@@ -414,10 +347,11 @@ async def get_user_by_id(user_id: str, user=Depends(get_verified_user)):
     user = Users.get_user_by_id(user_id)
 
     if user:
-        return UserActiveResponse(
+        return UserResponse(
             **{
-                **user.model_dump(),
-                "is_active": Users.is_user_active(user_id),
+                "name": user.name,
+                "profile_image_url": user.profile_image_url,
+                "active": get_active_status_by_user_id(user_id),
             }
         )
     else:
@@ -427,7 +361,7 @@ async def get_user_by_id(user_id: str, user=Depends(get_verified_user)):
         )
 
 
-@router.get("/{user_id}/oauth/sessions")
+@router.get("/{user_id}/oauth/sessions", response_model=Optional[dict])
 async def get_user_oauth_sessions_by_id(user_id: str, user=Depends(get_admin_user)):
     sessions = OAuthSessions.get_sessions_by_user_id(user_id)
     if sessions and len(sessions) > 0:
@@ -484,7 +418,7 @@ async def get_user_profile_image_by_id(user_id: str, user=Depends(get_verified_u
 @router.get("/{user_id}/active", response_model=dict)
 async def get_user_active_status_by_id(user_id: str, user=Depends(get_verified_user)):
     return {
-        "active": Users.is_user_active(user_id),
+        "active": get_user_active_status(user_id),
     }
 
 
@@ -537,12 +471,8 @@ async def update_user_by_id(
                 )
 
         if form_data.password:
-            try:
-                validate_password(form_data.password)
-            except Exception as e:
-                raise HTTPException(400, detail=str(e))
-
             hashed = get_password_hash(form_data.password)
+            log.debug(f"hashed: {hashed}")
             Auths.update_user_password_by_id(user_id, hashed)
 
         Auths.update_email_by_id(user_id, form_data.email.lower())

backend/open_webui/routers/utils.py

@@ -124,3 +124,12 @@ async def download_db(user=Depends(get_admin_user)):
         media_type="application/octet-stream",
         filename="webui.db",
     )
+
+
+@router.get("/litellm/config")
+async def download_litellm_config_yaml(user=Depends(get_admin_user)):
+    return FileResponse(
+        f"{DATA_DIR}/litellm/config.yaml",
+        media_type="application/octet-stream",
+        filename="config.yaml",
+    )

backend/open_webui/socket/main.py

@@ -18,12 +18,7 @@ from open_webui.utils.redis import (
     get_sentinel_url_from_env,
 )
 
-from open_webui.config import (
-    CORS_ALLOW_ORIGIN,
-)
-
 from open_webui.env import (
-    VERSION,
     ENABLE_WEBSOCKET_SUPPORT,
     WEBSOCKET_MANAGER,
     WEBSOCKET_REDIS_URL,
@@ -32,11 +27,6 @@ from open_webui.env import (
     WEBSOCKET_SENTINEL_PORT,
     WEBSOCKET_SENTINEL_HOSTS,
     REDIS_KEY_PREFIX,
-    WEBSOCKET_REDIS_OPTIONS,
-    WEBSOCKET_SERVER_PING_TIMEOUT,
-    WEBSOCKET_SERVER_PING_INTERVAL,
-    WEBSOCKET_SERVER_LOGGING,
-    WEBSOCKET_SERVER_ENGINEIO_LOGGING,
 )
 from open_webui.utils.auth import decode_token
 from open_webui.socket.utils import RedisDict, RedisLock, YdocManager
@@ -58,44 +48,30 @@ log.setLevel(SRC_LOG_LEVELS["SOCKET"])
 
 REDIS = None
 
-# Configure CORS for Socket.IO
-SOCKETIO_CORS_ORIGINS = "*" if CORS_ALLOW_ORIGIN == ["*"] else CORS_ALLOW_ORIGIN
-
 if WEBSOCKET_MANAGER == "redis":
     if WEBSOCKET_SENTINEL_HOSTS:
         mgr = socketio.AsyncRedisManager(
             get_sentinel_url_from_env(
                 WEBSOCKET_REDIS_URL, WEBSOCKET_SENTINEL_HOSTS, WEBSOCKET_SENTINEL_PORT
-            ),
-            redis_options=WEBSOCKET_REDIS_OPTIONS,
+            )
         )
     else:
-        mgr = socketio.AsyncRedisManager(
-            WEBSOCKET_REDIS_URL, redis_options=WEBSOCKET_REDIS_OPTIONS
-        )
+        mgr = socketio.AsyncRedisManager(WEBSOCKET_REDIS_URL)
     sio = socketio.AsyncServer(
-        cors_allowed_origins=SOCKETIO_CORS_ORIGINS,
+        cors_allowed_origins=[],
         async_mode="asgi",
         transports=(["websocket"] if ENABLE_WEBSOCKET_SUPPORT else ["polling"]),
         allow_upgrades=ENABLE_WEBSOCKET_SUPPORT,
         always_connect=True,
         client_manager=mgr,
-        logger=WEBSOCKET_SERVER_LOGGING,
-        ping_interval=WEBSOCKET_SERVER_PING_INTERVAL,
-        ping_timeout=WEBSOCKET_SERVER_PING_TIMEOUT,
-        engineio_logger=WEBSOCKET_SERVER_ENGINEIO_LOGGING,
     )
 else:
     sio = socketio.AsyncServer(
-        cors_allowed_origins=SOCKETIO_CORS_ORIGINS,
+        cors_allowed_origins=[],
         async_mode="asgi",
         transports=(["websocket"] if ENABLE_WEBSOCKET_SUPPORT else ["polling"]),
         allow_upgrades=ENABLE_WEBSOCKET_SUPPORT,
         always_connect=True,
-        logger=WEBSOCKET_SERVER_LOGGING,
-        ping_interval=WEBSOCKET_SERVER_PING_INTERVAL,
-        ping_timeout=WEBSOCKET_SERVER_PING_TIMEOUT,
-        engineio_logger=WEBSOCKET_SERVER_ENGINEIO_LOGGING,
     )
 
 
@@ -118,16 +94,14 @@ if WEBSOCKET_MANAGER == "redis":
     redis_sentinels = get_sentinels_from_env(
         WEBSOCKET_SENTINEL_HOSTS, WEBSOCKET_SENTINEL_PORT
     )
-
-    MODELS = RedisDict(
-        f"{REDIS_KEY_PREFIX}:models",
+    SESSION_POOL = RedisDict(
+        f"{REDIS_KEY_PREFIX}:session_pool",
         redis_url=WEBSOCKET_REDIS_URL,
         redis_sentinels=redis_sentinels,
         redis_cluster=WEBSOCKET_REDIS_CLUSTER,
     )
-
-    SESSION_POOL = RedisDict(
-        f"{REDIS_KEY_PREFIX}:session_pool",
+    USER_POOL = RedisDict(
+        f"{REDIS_KEY_PREFIX}:user_pool",
         redis_url=WEBSOCKET_REDIS_URL,
         redis_sentinels=redis_sentinels,
         redis_cluster=WEBSOCKET_REDIS_CLUSTER,
@@ -150,9 +124,8 @@ if WEBSOCKET_MANAGER == "redis":
     renew_func = clean_up_lock.renew_lock
     release_func = clean_up_lock.release_lock
 else:
-    MODELS = {}
-
     SESSION_POOL = {}
+    USER_POOL = {}
     USAGE_POOL = {}
 
     aquire_func = release_func = renew_func = lambda: True
@@ -228,6 +201,16 @@ def get_models_in_use():
     return models_in_use
 
 
+def get_active_user_ids():
+    """Get the list of active user IDs."""
+    return list(USER_POOL.keys())
+
+
+def get_user_active_status(user_id):
+    """Check if a user is currently active."""
+    return user_id in USER_POOL
+
+
 def get_user_id_from_session_pool(sid):
     user = SESSION_POOL.get(sid)
     if user:
@@ -253,36 +236,10 @@ def get_user_ids_from_room(room):
     return active_user_ids
 
 
-async def emit_to_users(event: str, data: dict, user_ids: list[str]):
-    """
-    Send a message to specific users using their user:{id} rooms.
-
-    Args:
-        event (str): The event name to emit.
-        data (dict): The payload/data to send.
-        user_ids (list[str]): The target users' IDs.
-    """
-    try:
-        for user_id in user_ids:
-            await sio.emit(event, data, room=f"user:{user_id}")
-    except Exception as e:
-        log.debug(f"Failed to emit event {event} to users {user_ids}: {e}")
-
-
-async def enter_room_for_users(room: str, user_ids: list[str]):
-    """
-    Make all sessions of a user join a specific room.
-    Args:
-        room (str): The room to join.
-        user_ids (list[str]): The target user's IDs.
-    """
-    try:
-        for user_id in user_ids:
-            session_ids = get_session_ids_from_room(f"user:{user_id}")
-            for sid in session_ids:
-                await sio.enter_room(sid, room)
-    except Exception as e:
-        log.debug(f"Failed to make users {user_ids} join room {room}: {e}")
+def get_active_status_by_user_id(user_id):
+    if user_id in USER_POOL:
+        return True
+    return False
 
 
 @sio.on("usage")
@@ -312,7 +269,10 @@ async def connect(sid, environ, auth):
             SESSION_POOL[sid] = user.model_dump(
                 exclude=["date_of_birth", "bio", "gender"]
             )
-            await sio.enter_room(sid, f"user:{user.id}")
+            if user.id in USER_POOL:
+                USER_POOL[user.id] = USER_POOL[user.id] + [sid]
+            else:
+                USER_POOL[user.id] = [sid]
 
 
 @sio.on("user-join")
@@ -330,34 +290,20 @@ async def user_join(sid, data):
     if not user:
         return
 
-    SESSION_POOL[sid] = user.model_dump(
-        exclude=[
-            "profile_image_url",
-            "profile_banner_image_url",
-            "date_of_birth",
-            "bio",
-            "gender",
-        ]
-    )
-
-    await sio.enter_room(sid, f"user:{user.id}")
+    SESSION_POOL[sid] = user.model_dump(exclude=["date_of_birth", "bio", "gender"])
+    if user.id in USER_POOL:
+        USER_POOL[user.id] = USER_POOL[user.id] + [sid]
+    else:
+        USER_POOL[user.id] = [sid]
 
     # Join all the channels
     channels = Channels.get_channels_by_user_id(user.id)
     log.debug(f"{channels=}")
     for channel in channels:
         await sio.enter_room(sid, f"channel:{channel.id}")
-
     return {"id": user.id, "name": user.name}
 
 
-@sio.on("heartbeat")
-async def heartbeat(sid, data):
-    user = SESSION_POOL.get(sid)
-    if user:
-        Users.update_last_active_by_id(user["id"])
-
-
 @sio.on("join-channels")
 async def join_channel(sid, data):
     auth = data["auth"] if "auth" in data else None
@@ -425,11 +371,6 @@ async def channel_events(sid, data):
     event_data = data["data"]
     event_type = event_data["type"]
 
-    user = SESSION_POOL.get(sid)
-
-    if not user:
-        return
-
     if event_type == "typing":
         await sio.emit(
             "events:channel",
@@ -437,12 +378,10 @@ async def channel_events(sid, data):
                 "channel_id": data["channel_id"],
                 "message_id": data.get("message_id", None),
                 "data": event_data,
-                "user": UserNameResponse(**user).model_dump(),
+                "user": UserNameResponse(**SESSION_POOL[sid]).model_dump(),
             },
             room=room,
         )
-    elif event_type == "last_read_at":
-        Channels.update_member_last_read_at(data["channel_id"], user["id"])
 
 
 @sio.on("ydoc:document:join")
@@ -686,6 +625,13 @@ async def disconnect(sid):
     if sid in SESSION_POOL:
         user = SESSION_POOL[sid]
         del SESSION_POOL[sid]
+
+        user_id = user["id"]
+        USER_POOL[user_id] = [_sid for _sid in USER_POOL[user_id] if _sid != sid]
+
+        if len(USER_POOL[user_id]) == 0:
+            del USER_POOL[user_id]
+
         await YDOC_MANAGER.remove_user_from_all_documents(sid)
     else:
         pass
@@ -695,24 +641,40 @@ async def disconnect(sid):
 def get_event_emitter(request_info, update_db=True):
     async def __event_emitter__(event_data):
         user_id = request_info["user_id"]
-        chat_id = request_info["chat_id"]
-        message_id = request_info["message_id"]
 
-        await sio.emit(
-            "events",
-            {
-                "chat_id": chat_id,
-                "message_id": message_id,
-                "data": event_data,
-            },
-            room=f"user:{user_id}",
+        session_ids = list(
+            set(
+                USER_POOL.get(user_id, [])
+                + (
+                    [request_info.get("session_id")]
+                    if request_info.get("session_id")
+                    else []
+                )
+            )
         )
+
+        chat_id = request_info.get("chat_id", None)
+        message_id = request_info.get("message_id", None)
+
+        emit_tasks = [
+            sio.emit(
+                "events",
+                {
+                    "chat_id": chat_id,
+                    "message_id": message_id,
+                    "data": event_data,
+                },
+                to=session_id,
+            )
+            for session_id in session_ids
+        ]
+
+        await asyncio.gather(*emit_tasks)
         if (
             update_db
             and message_id
             and not request_info.get("chat_id", "").startswith("local:")
         ):
-
             if "type" in event_data and event_data["type"] == "status":
                 Chats.add_message_status_to_chat_by_id_and_message_id(
                     request_info["chat_id"],
@@ -802,14 +764,7 @@ def get_event_emitter(request_info, update_db=True):
                         },
                     )
 
-    if (
-        "user_id" in request_info
-        and "chat_id" in request_info
-        and "message_id" in request_info
-    ):
-        return __event_emitter__
-    else:
-        return None
+    return __event_emitter__
 
 
 def get_event_call(request_info):
@@ -825,14 +780,7 @@ def get_event_call(request_info):
         )
         return response
 
-    if (
-        "session_id" in request_info
-        and "chat_id" in request_info
-        and "message_id" in request_info
-    ):
-        return __event_caller__
-    else:
-        return None
+    return __event_caller__
 
 
 get_event_caller = get_event_call

backend/open_webui/socket/utils.py

@@ -86,15 +86,6 @@ class RedisDict:
     def items(self):
         return [(k, json.loads(v)) for k, v in self.redis.hgetall(self.name).items()]
 
-    def set(self, mapping: dict):
-        pipe = self.redis.pipeline()
-
-        pipe.delete(self.name)
-        if mapping:
-            pipe.hset(self.name, mapping={k: json.dumps(v) for k, v in mapping.items()})
-
-        pipe.execute()
-
     def get(self, key, default=None):
         try:
             return self[key]

backend/open_webui/utils/access_control.py

@@ -105,22 +105,6 @@ def has_permission(
     return get_permission(default_permissions, permission_hierarchy)
 
 
-def get_permitted_group_and_user_ids(
-    type: str = "write", access_control: Optional[dict] = None
-) -> Union[Dict[str, List[str]], None]:
-    if access_control is None:
-        return None
-
-    permission_access = access_control.get(type, {})
-    permitted_group_ids = permission_access.get("group_ids", [])
-    permitted_user_ids = permission_access.get("user_ids", [])
-
-    return {
-        "group_ids": permitted_group_ids,
-        "user_ids": permitted_user_ids,
-    }
-
-
 def has_access(
     user_id: str,
     type: str = "write",
@@ -138,12 +122,9 @@ def has_access(
         user_groups = Groups.get_groups_by_member_id(user_id)
         user_group_ids = {group.id for group in user_groups}
 
-    permitted_ids = get_permitted_group_and_user_ids(type, access_control)
-    if permitted_ids is None:
-        return False
-
-    permitted_group_ids = permitted_ids.get("group_ids", [])
-    permitted_user_ids = permitted_ids.get("user_ids", [])
+    permission_access = access_control.get(type, {})
+    permitted_group_ids = permission_access.get("group_ids", [])
+    permitted_user_ids = permission_access.get("user_ids", [])
 
     return user_id in permitted_user_ids or any(
         group_id in permitted_group_ids for group_id in user_group_ids
@@ -155,20 +136,18 @@ def get_users_with_access(
     type: str = "write", access_control: Optional[dict] = None
 ) -> list[UserModel]:
     if access_control is None:
-        result = Users.get_users(filter={"roles": ["!pending"]})
+        result = Users.get_users()
         return result.get("users", [])
 
-    permitted_ids = get_permitted_group_and_user_ids(type, access_control)
-    if permitted_ids is None:
-        return []
-
-    permitted_group_ids = permitted_ids.get("group_ids", [])
-    permitted_user_ids = permitted_ids.get("user_ids", [])
+    permission_access = access_control.get(type, {})
+    permitted_group_ids = permission_access.get("group_ids", [])
+    permitted_user_ids = permission_access.get("user_ids", [])
 
     user_ids_with_access = set(permitted_user_ids)
 
-    group_user_ids_map = Groups.get_group_user_ids_by_ids(permitted_group_ids)
-    for user_ids in group_user_ids_map.values():
-        user_ids_with_access.update(user_ids)
+    for group_id in permitted_group_ids:
+        group_user_ids = Groups.get_group_user_ids_by_id(group_id)
+        if group_user_ids:
+            user_ids_with_access.update(group_user_ids)
 
     return Users.get_users_by_user_ids(list(user_ids_with_access))

backend/open_webui/utils/audit.py

@@ -194,7 +194,7 @@ class AuditLoggingMiddleware:
         auth_header = request.headers.get("Authorization")
 
         try:
-            user = await get_current_user(
+            user = get_current_user(
                 request, None, None, get_http_authorization_cred(auth_header)
             )
             return user

backend/open_webui/utils/auth.py

@@ -21,18 +21,13 @@ from typing import Optional, Union, List, Dict
 
 from opentelemetry import trace
 
-
-from open_webui.utils.access_control import has_permission
 from open_webui.models.users import Users
 
 from open_webui.constants import ERROR_MESSAGES
 
 from open_webui.env import (
-    ENABLE_PASSWORD_VALIDATION,
     OFFLINE_MODE,
     LICENSE_BLOB,
-    PASSWORD_VALIDATION_REGEX_PATTERN,
-    REDIS_KEY_PREFIX,
     pk,
     WEBUI_SECRET_KEY,
     TRUSTED_SIGNATURE_KEY,
@@ -164,20 +159,6 @@ def get_password_hash(password: str) -> str:
     return bcrypt.hashpw(password.encode("utf-8"), bcrypt.gensalt()).decode("utf-8")
 
 
-def validate_password(password: str) -> bool:
-    # The password passed to bcrypt must be 72 bytes or fewer. If it is longer, it will be truncated before hashing.
-    if len(password.encode("utf-8")) > 72:
-        raise Exception(
-            ERROR_MESSAGES.PASSWORD_TOO_LONG,
-        )
-
-    if ENABLE_PASSWORD_VALIDATION:
-        if not PASSWORD_VALIDATION_REGEX_PATTERN.match(password):
-            raise Exception(ERROR_MESSAGES.INVALID_PASSWORD())
-
-    return True
-
-
 def verify_password(plain_password: str, hashed_password: str) -> bool:
     """Verify a password against its hash"""
     return (
@@ -197,9 +178,6 @@ def create_token(data: dict, expires_delta: Union[timedelta, None] = None) -> st
         expire = datetime.now(UTC) + expires_delta
         payload.update({"exp": expire})
 
-    jti = str(uuid.uuid4())
-    payload.update({"jti": jti})
-
     encoded_jwt = jwt.encode(payload, SESSION_SECRET, algorithm=ALGORITHM)
     return encoded_jwt
 
@@ -212,43 +190,6 @@ def decode_token(token: str) -> Optional[dict]:
         return None
 
 
-async def is_valid_token(request, decoded) -> bool:
-    # Require Redis to check revoked tokens
-    if request.app.state.redis:
-        jti = decoded.get("jti")
-
-        if jti:
-            revoked = await request.app.state.redis.get(
-                f"{REDIS_KEY_PREFIX}:auth:token:{jti}:revoked"
-            )
-            if revoked:
-                return False
-
-    return True
-
-
-async def invalidate_token(request, token):
-    decoded = decode_token(token)
-
-    # Require Redis to store revoked tokens
-    if request.app.state.redis:
-        jti = decoded.get("jti")
-        exp = decoded.get("exp")
-
-        if jti and exp:
-            ttl = exp - int(
-                datetime.now(UTC).timestamp()
-            )  # Calculate time-to-live for the token
-
-            if ttl > 0:
-                # Store the revoked token in Redis with an expiration time
-                await request.app.state.redis.set(
-                    f"{REDIS_KEY_PREFIX}:auth:token:{jti}:revoked",
-                    "1",
-                    ex=ttl,
-                )
-
-
 def extract_token_from_auth_header(auth_header: str):
     return auth_header[len("Bearer ") :]
 
@@ -268,7 +209,7 @@ def get_http_authorization_cred(auth_header: Optional[str]):
         return None
 
 
-async def get_current_user(
+def get_current_user(
     request: Request,
     response: Response,
     background_tasks: BackgroundTasks,
@@ -287,7 +228,30 @@ async def get_current_user(
 
     # auth by api key
     if token.startswith("sk-"):
-        user = get_current_user_by_api_key(request, token)
+        if not request.state.enable_api_key:
+            raise HTTPException(
+                status.HTTP_403_FORBIDDEN, detail=ERROR_MESSAGES.API_KEY_NOT_ALLOWED
+            )
+
+        if request.app.state.config.ENABLE_API_KEY_ENDPOINT_RESTRICTIONS:
+            allowed_paths = [
+                path.strip()
+                for path in str(
+                    request.app.state.config.API_KEY_ALLOWED_ENDPOINTS
+                ).split(",")
+            ]
+
+            # Check if the request path matches any allowed endpoint.
+            if not any(
+                request.url.path == allowed
+                or request.url.path.startswith(allowed + "/")
+                for allowed in allowed_paths
+            ):
+                raise HTTPException(
+                    status.HTTP_403_FORBIDDEN, detail=ERROR_MESSAGES.API_KEY_NOT_ALLOWED
+                )
+
+        user = get_current_user_by_api_key(token)
 
         # Add user info to current span
         current_span = trace.get_current_span()
@@ -300,6 +264,7 @@ async def get_current_user(
         return user
 
     # auth by jwt token
+
     try:
         try:
             data = decode_token(token)
@@ -310,12 +275,6 @@ async def get_current_user(
             )
 
         if data is not None and "id" in data:
-            if data.get("jti") and not await is_valid_token(request, data):
-                raise HTTPException(
-                    status_code=status.HTTP_401_UNAUTHORIZED,
-                    detail="Invalid token",
-                )
-
             user = Users.get_user_by_id(data["id"])
             if user is None:
                 raise HTTPException(
@@ -344,7 +303,9 @@ async def get_current_user(
                 # Refresh the user's last active timestamp asynchronously
                 # to prevent blocking the request
                 if background_tasks:
-                    background_tasks.add_task(Users.update_last_active_by_id, user.id)
+                    background_tasks.add_task(
+                        Users.update_user_last_active_by_id, user.id
+                    )
             return user
         else:
             raise HTTPException(
@@ -366,7 +327,7 @@ async def get_current_user(
         raise e
 
 
-def get_current_user_by_api_key(request, api_key: str):
+def get_current_user_by_api_key(api_key: str):
     user = Users.get_user_by_api_key(api_key)
 
     if user is None:
@@ -374,28 +335,17 @@ def get_current_user_by_api_key(request, api_key: str):
             status_code=status.HTTP_401_UNAUTHORIZED,
             detail=ERROR_MESSAGES.INVALID_TOKEN,
         )
+    else:
+        # Add user info to current span
+        current_span = trace.get_current_span()
+        if current_span:
+            current_span.set_attribute("client.user.id", user.id)
+            current_span.set_attribute("client.user.email", user.email)
+            current_span.set_attribute("client.user.role", user.role)
+            current_span.set_attribute("client.auth.type", "api_key")
 
-    if not request.state.enable_api_keys or (
-        user.role != "admin"
-        and not has_permission(
-            user.id,
-            "features.api_keys",
-            request.app.state.config.USER_PERMISSIONS,
-        )
-    ):
-        raise HTTPException(
-            status.HTTP_403_FORBIDDEN, detail=ERROR_MESSAGES.API_KEY_NOT_ALLOWED
-        )
+        Users.update_user_last_active_by_id(user.id)
 
-    # Add user info to current span
-    current_span = trace.get_current_span()
-    if current_span:
-        current_span.set_attribute("client.user.id", user.id)
-        current_span.set_attribute("client.user.email", user.email)
-        current_span.set_attribute("client.user.role", user.role)
-        current_span.set_attribute("client.auth.type", "api_key")
-
-    Users.update_last_active_by_id(user.id)
     return user
 
 

backend/open_webui/utils/files.py

@@ -1,5 +1,5 @@
 from open_webui.routers.images import (
-    get_image_data,
+    load_b64_image_data,
     upload_image,
 )
 
@@ -16,18 +16,13 @@ from open_webui.routers.files import upload_file_handler
 import mimetypes
 import base64
 import io
-import re
-
-
-BASE64_IMAGE_URL_PREFIX = re.compile(r"data:image/\w+;base64,", re.IGNORECASE)
-MARKDOWN_IMAGE_URL_PATTERN = re.compile(r"!\[(.*?)\]\((.+?)\)", re.IGNORECASE)
 
 
 def get_image_url_from_base64(request, base64_image_string, metadata, user):
-    if BASE64_IMAGE_URL_PREFIX.match(base64_image_string):
+    if "data:image/png;base64" in base64_image_string:
         image_url = ""
         # Extract base64 image data from the line
-        image_data, content_type = get_image_data(base64_image_string)
+        image_data, content_type = load_b64_image_data(base64_image_string)
         if image_data is not None:
             image_url = upload_image(
                 request,
@@ -40,19 +35,6 @@ def get_image_url_from_base64(request, base64_image_string, metadata, user):
     return None
 
 
-def convert_markdown_base64_images(request, content: str, metadata, user):
-    def replace(match):
-        base64_string = match.group(2)
-        MIN_REPLACEMENT_URL_LENGTH = 1024
-        if len(base64_string) > MIN_REPLACEMENT_URL_LENGTH:
-            url = get_image_url_from_base64(request, base64_string, metadata, user)
-            if url:
-                return f"![{match.group(1)}]({url})"
-        return match.group(0)
-
-    return MARKDOWN_IMAGE_URL_PATTERN.sub(replace, content)
-
-
 def load_b64_audio_data(b64_str):
     try:
         if "," in b64_str:

backend/open_webui/utils/groups.py

@@ -1,24 +0,0 @@
-import logging
-from open_webui.models.groups import Groups
-
-log = logging.getLogger(__name__)
-
-
-def apply_default_group_assignment(
-    default_group_id: str,
-    user_id: str,
-) -> None:
-    """
-    Apply default group assignment to a user if default_group_id is provided.
-
-    Args:
-        default_group_id: ID of the default group to add the user to
-        user_id: ID of the user to add to the default group
-    """
-    if default_group_id:
-        try:
-            Groups.add_users_to_group(default_group_id, [user_id])
-        except Exception as e:
-            log.error(
-                f"Failed to add user {user_id} to default group {default_group_id}: {e}"
-            )

backend/open_webui/utils/headers.py

@@ -1,11 +0,0 @@
-from urllib.parse import quote
-
-
-def include_user_info_headers(headers, user):
-    return {
-        **headers,
-        "X-OpenWebUI-User-Name": quote(user.name, safe=" "),
-        "X-OpenWebUI-User-Id": user.id,
-        "X-OpenWebUI-User-Email": user.email,
-        "X-OpenWebUI-User-Role": user.role,
-    }

backend/open_webui/utils/images/comfyui.py

@@ -2,8 +2,6 @@ import asyncio
 import json
 import logging
 import random
-import requests
-import aiohttp
 import urllib.parse
 import urllib.request
 from typing import Optional
@@ -93,25 +91,6 @@ def get_images(ws, prompt, client_id, base_url, api_key):
     return {"data": output_images}
 
 
-async def comfyui_upload_image(image_file_item, base_url, api_key):
-    url = f"{base_url}/api/upload/image"
-    headers = {}
-
-    if api_key:
-        headers["Authorization"] = f"Bearer {api_key}"
-
-    _, (filename, file_bytes, mime_type) = image_file_item
-
-    form = aiohttp.FormData()
-    form.add_field("image", file_bytes, filename=filename, content_type=mime_type)
-    form.add_field("type", "input")  # required by ComfyUI
-
-    async with aiohttp.ClientSession() as session:
-        async with session.post(url, data=form, headers=headers) as resp:
-            resp.raise_for_status()
-            return await resp.json()
-
-
 class ComfyUINodeInput(BaseModel):
     type: Optional[str] = None
     node_ids: list[str] = []
@@ -124,7 +103,7 @@ class ComfyUIWorkflow(BaseModel):
     nodes: list[ComfyUINodeInput]
 
 
-class ComfyUICreateImageForm(BaseModel):
+class ComfyUIGenerateImageForm(BaseModel):
     workflow: ComfyUIWorkflow
 
     prompt: str
@@ -137,8 +116,8 @@ class ComfyUICreateImageForm(BaseModel):
     seed: Optional[int] = None
 
 
-async def comfyui_create_image(
-    model: str, payload: ComfyUICreateImageForm, client_id, base_url, api_key
+async def comfyui_generate_image(
+    model: str, payload: ComfyUIGenerateImageForm, client_id, base_url, api_key
 ):
     ws_url = base_url.replace("http://", "ws://").replace("https://", "wss://")
     workflow = json.loads(payload.workflow.workflow)
@@ -212,102 +191,3 @@ async def comfyui_create_image(
     ws.close()
 
     return images
-
-
-class ComfyUIEditImageForm(BaseModel):
-    workflow: ComfyUIWorkflow
-
-    image: str | list[str]
-    prompt: str
-    width: Optional[int] = None
-    height: Optional[int] = None
-    n: Optional[int] = None
-
-    steps: Optional[int] = None
-    seed: Optional[int] = None
-
-
-async def comfyui_edit_image(
-    model: str, payload: ComfyUIEditImageForm, client_id, base_url, api_key
-):
-    ws_url = base_url.replace("http://", "ws://").replace("https://", "wss://")
-    workflow = json.loads(payload.workflow.workflow)
-
-    for node in payload.workflow.nodes:
-        if node.type:
-            if node.type == "model":
-                for node_id in node.node_ids:
-                    workflow[node_id]["inputs"][node.key] = model
-            elif node.type == "image":
-                if isinstance(payload.image, list):
-                    # check if multiple images are provided
-                    for idx, node_id in enumerate(node.node_ids):
-                        if idx < len(payload.image):
-                            workflow[node_id]["inputs"][node.key] = payload.image[idx]
-                else:
-                    for node_id in node.node_ids:
-                        workflow[node_id]["inputs"][node.key] = payload.image
-            elif node.type == "prompt":
-                for node_id in node.node_ids:
-                    workflow[node_id]["inputs"][
-                        node.key if node.key else "text"
-                    ] = payload.prompt
-            elif node.type == "negative_prompt":
-                for node_id in node.node_ids:
-                    workflow[node_id]["inputs"][
-                        node.key if node.key else "text"
-                    ] = payload.negative_prompt
-            elif node.type == "width":
-                for node_id in node.node_ids:
-                    workflow[node_id]["inputs"][
-                        node.key if node.key else "width"
-                    ] = payload.width
-            elif node.type == "height":
-                for node_id in node.node_ids:
-                    workflow[node_id]["inputs"][
-                        node.key if node.key else "height"
-                    ] = payload.height
-            elif node.type == "n":
-                for node_id in node.node_ids:
-                    workflow[node_id]["inputs"][
-                        node.key if node.key else "batch_size"
-                    ] = payload.n
-            elif node.type == "steps":
-                for node_id in node.node_ids:
-                    workflow[node_id]["inputs"][
-                        node.key if node.key else "steps"
-                    ] = payload.steps
-            elif node.type == "seed":
-                seed = (
-                    payload.seed
-                    if payload.seed
-                    else random.randint(0, 1125899906842624)
-                )
-                for node_id in node.node_ids:
-                    workflow[node_id]["inputs"][node.key] = seed
-        else:
-            for node_id in node.node_ids:
-                workflow[node_id]["inputs"][node.key] = node.value
-
-    try:
-        ws = websocket.WebSocket()
-        headers = {"Authorization": f"Bearer {api_key}"}
-        ws.connect(f"{ws_url}/ws?clientId={client_id}", header=headers)
-        log.info("WebSocket connection established.")
-    except Exception as e:
-        log.exception(f"Failed to connect to WebSocket server: {e}")
-        return None
-
-    try:
-        log.info("Sending workflow to WebSocket server.")
-        log.info(f"Workflow: {workflow}")
-        images = await asyncio.to_thread(
-            get_images, ws, workflow, client_id, base_url, api_key
-        )
-    except Exception as e:
-        log.exception(f"Error while receiving images: {e}")
-        images = None
-
-    ws.close()
-
-    return images

backend/open_webui/utils/mcp/client.py

@@ -2,8 +2,6 @@ import asyncio
 from typing import Optional
 from contextlib import AsyncExitStack
 
-import anyio
-
 from mcp import ClientSession
 from mcp.client.auth import OAuthClientProvider, TokenStorage
 from mcp.client.streamable_http import streamablehttp_client
@@ -13,29 +11,26 @@ from mcp.shared.auth import OAuthClientInformationFull, OAuthClientMetadata, OAu
 class MCPClient:
     def __init__(self):
         self.session: Optional[ClientSession] = None
-        self.exit_stack = None
+        self.exit_stack = AsyncExitStack()
 
     async def connect(self, url: str, headers: Optional[dict] = None):
-        async with AsyncExitStack() as exit_stack:
-            try:
-                self._streams_context = streamablehttp_client(url, headers=headers)
+        try:
+            self._streams_context = streamablehttp_client(url, headers=headers)
 
-                transport = await exit_stack.enter_async_context(self._streams_context)
-                read_stream, write_stream, _ = transport
+            transport = await self.exit_stack.enter_async_context(self._streams_context)
+            read_stream, write_stream, _ = transport
 
-                self._session_context = ClientSession(
-                    read_stream, write_stream
-                )  # pylint: disable=W0201
+            self._session_context = ClientSession(
+                read_stream, write_stream
+            )  # pylint: disable=W0201
 
-                self.session = await exit_stack.enter_async_context(
-                    self._session_context
-                )
-                with anyio.fail_after(10):
-                    await self.session.initialize()
-                self.exit_stack = exit_stack.pop_all()
-            except Exception as e:
-                await asyncio.shield(self.disconnect())
-                raise e
+            self.session = await self.exit_stack.enter_async_context(
+                self._session_context
+            )
+            await self.session.initialize()
+        except Exception as e:
+            await self.disconnect()
+            raise e
 
     async def list_tool_specs(self) -> Optional[dict]:
         if not self.session:

backend/open_webui/utils/middleware.py

@@ -24,7 +24,6 @@ from fastapi.responses import HTMLResponse
 from starlette.responses import Response, StreamingResponse, JSONResponse
 
 
-from open_webui.utils.misc import is_string_allowed
 from open_webui.models.oauth_sessions import OAuthSessions
 from open_webui.models.chats import Chats
 from open_webui.models.folders import Folders
@@ -32,6 +31,7 @@ from open_webui.models.users import Users
 from open_webui.socket.main import (
     get_event_call,
     get_event_emitter,
+    get_active_status_by_user_id,
 )
 from open_webui.routers.tasks import (
     generate_queries,
@@ -45,10 +45,10 @@ from open_webui.routers.retrieval import (
     SearchForm,
 )
 from open_webui.routers.images import (
+    load_b64_image_data,
     image_generations,
-    CreateImageForm,
-    image_edits,
-    EditImageForm,
+    GenerateImageForm,
+    upload_image,
 )
 from open_webui.routers.pipelines import (
     process_pipeline_inlet_filter,
@@ -58,7 +58,7 @@ from open_webui.routers.memories import query_memory, QueryMemoryForm
 
 from open_webui.utils.webhook import post_webhook
 from open_webui.utils.files import (
-    convert_markdown_base64_images,
+    get_audio_url_from_base64,
     get_file_url_from_base64,
     get_image_url_from_base64,
 )
@@ -91,7 +91,7 @@ from open_webui.utils.misc import (
     convert_logit_bias_input_to_json,
     get_content_from_message,
 )
-from open_webui.utils.tools import get_tools, get_updated_tool_function
+from open_webui.utils.tools import get_tools
 from open_webui.utils.plugin import load_function_module_by_id
 from open_webui.utils.filter import (
     get_sorted_filter_ids,
@@ -104,7 +104,6 @@ from open_webui.utils.mcp.client import MCPClient
 
 from open_webui.config import (
     CACHE_DIR,
-    DEFAULT_VOICE_MODE_PROMPT_TEMPLATE,
     DEFAULT_TOOLS_FUNCTION_CALLING_PROMPT_TEMPLATE,
     DEFAULT_CODE_INTERPRETER_PROMPT,
     CODE_INTERPRETER_BLOCKED_MODULES,
@@ -112,7 +111,6 @@ from open_webui.config import (
 from open_webui.env import (
     SRC_LOG_LEVELS,
     GLOBAL_LOG_LEVEL,
-    ENABLE_CHAT_RESPONSE_BASE64_IMAGE_URL_CONVERSION,
     CHAT_RESPONSE_STREAM_DELTA_CHUNK_SIZE,
     CHAT_RESPONSE_MAX_TOOL_CALL_RETRIES,
     BYPASS_MODEL_ACCESS_CONTROL,
@@ -304,27 +302,19 @@ async def chat_completion_tools_handler(
     def get_tools_function_calling_payload(messages, task_model_id, content):
         user_message = get_last_user_message(messages)
 
-        if user_message and messages and messages[-1]["role"] == "user":
-            # Remove the last user message to avoid duplication
-            messages = messages[:-1]
-
         recent_messages = messages[-4:] if len(messages) > 4 else messages
         chat_history = "\n".join(
             f"{message['role'].upper()}: \"\"\"{get_content_from_message(message)}\"\"\""
             for message in recent_messages
         )
 
-        prompt = (
-            f"History:\n{chat_history}\nQuery: {user_message}"
-            if chat_history
-            else f"Query: {user_message}"
-        )
+        prompt = f"History:\n{chat_history}\nQuery: {user_message}"
 
         return {
             "model": task_model_id,
             "messages": [
                 {"role": "system", "content": content},
-                {"role": "user", "content": prompt},
+                {"role": "user", "content": f"Query: {prompt}"},
             ],
             "stream": False,
             "metadata": {"task": str(TASKS.FUNCTION_CALLING)},
@@ -458,6 +448,12 @@ async def chat_completion_tools_handler(
                             }
                         )
 
+                print(
+                    f"Tool {tool_function_name} result: {tool_result}",
+                    tool_result_files,
+                    tool_result_embeds,
+                )
+
                 if tool_result:
                     tool = tools[tool_function_name]
                     tool_id = tool.get("tool_id", "")
@@ -485,6 +481,12 @@ async def chat_completion_tools_handler(
                         }
                     )
 
+                    # Citation is not enabled for this tool
+                    body["messages"] = add_or_update_user_message(
+                        f"\nTool `{tool_name}` Output: {tool_result}",
+                        body["messages"],
+                    )
+
                     if (
                         tools[tool_function_name]
                         .get("metadata", {})
@@ -716,211 +718,98 @@ async def chat_web_search_handler(
     return form_data
 
 
-def get_last_images(message_list):
-    images = []
-    for message in reversed(message_list):
-        images_flag = False
-        for file in message.get("files", []):
-            if file.get("type") == "image":
-                images.append(file.get("url"))
-                images_flag = True
-
-        if images_flag:
-            break
-
-    return images
-
-
-def get_image_urls(delta_images, request, metadata, user) -> list[str]:
-    if not isinstance(delta_images, list):
-        return []
-
-    image_urls = []
-    for img in delta_images:
-        if not isinstance(img, dict) or img.get("type") != "image_url":
-            continue
-
-        url = img.get("image_url", {}).get("url")
-        if not url:
-            continue
-
-        if url.startswith("data:image/png;base64"):
-            url = get_image_url_from_base64(request, url, metadata, user)
-
-        image_urls.append(url)
-
-    return image_urls
-
-
 async def chat_image_generation_handler(
     request: Request, form_data: dict, extra_params: dict, user
 ):
-    metadata = extra_params.get("__metadata__", {})
-    chat_id = metadata.get("chat_id", None)
-    if not chat_id:
-        return form_data
-
     __event_emitter__ = extra_params["__event_emitter__"]
+    await __event_emitter__(
+        {
+            "type": "status",
+            "data": {"description": "Creating image", "done": False},
+        }
+    )
 
-    if chat_id.startswith("local:"):
-        message_list = form_data.get("messages", [])
-    else:
-        chat = Chats.get_chat_by_id_and_user_id(chat_id, user.id)
-        await __event_emitter__(
-            {
-                "type": "status",
-                "data": {"description": "Creating image", "done": False},
-            }
-        )
-
-        messages_map = chat.chat.get("history", {}).get("messages", {})
-        message_id = chat.chat.get("history", {}).get("currentId")
-        message_list = get_message_list(messages_map, message_id)
-
-    user_message = get_last_user_message(message_list)
+    messages = form_data["messages"]
+    user_message = get_last_user_message(messages)
 
     prompt = user_message
-    input_images = get_last_images(message_list)
+    negative_prompt = ""
+
+    if request.app.state.config.ENABLE_IMAGE_PROMPT_GENERATION:
+        try:
+            res = await generate_image_prompt(
+                request,
+                {
+                    "model": form_data["model"],
+                    "messages": messages,
+                },
+                user,
+            )
+
+            response = res["choices"][0]["message"]["content"]
+
+            try:
+                bracket_start = response.find("{")
+                bracket_end = response.rfind("}") + 1
+
+                if bracket_start == -1 or bracket_end == -1:
+                    raise Exception("No JSON object found in the response")
+
+                response = response[bracket_start:bracket_end]
+                response = json.loads(response)
+                prompt = response.get("prompt", [])
+            except Exception as e:
+                prompt = user_message
+
+        except Exception as e:
+            log.exception(e)
+            prompt = user_message
 
     system_message_content = ""
 
-    if len(input_images) > 0 and request.app.state.config.ENABLE_IMAGE_EDIT:
-        # Edit image(s)
-        try:
-            images = await image_edits(
-                request=request,
-                form_data=EditImageForm(**{"prompt": prompt, "image": input_images}),
-                user=user,
-            )
+    try:
+        images = await image_generations(
+            request=request,
+            form_data=GenerateImageForm(**{"prompt": prompt}),
+            user=user,
+        )
 
-            await __event_emitter__(
-                {
-                    "type": "status",
-                    "data": {"description": "Image created", "done": True},
-                }
-            )
+        await __event_emitter__(
+            {
+                "type": "status",
+                "data": {"description": "Image created", "done": True},
+            }
+        )
 
-            await __event_emitter__(
-                {
-                    "type": "files",
-                    "data": {
-                        "files": [
-                            {
-                                "type": "image",
-                                "url": image["url"],
-                            }
-                            for image in images
-                        ]
-                    },
-                }
-            )
+        await __event_emitter__(
+            {
+                "type": "files",
+                "data": {
+                    "files": [
+                        {
+                            "type": "image",
+                            "url": image["url"],
+                        }
+                        for image in images
+                    ]
+                },
+            }
+        )
 
-            system_message_content = "<context>The requested image has been created and is now being shown to the user. Let them know that it has been generated.</context>"
-        except Exception as e:
-            log.debug(e)
+        system_message_content = "<context>User is shown the generated image, tell the user that the image has been generated</context>"
+    except Exception as e:
+        log.exception(e)
+        await __event_emitter__(
+            {
+                "type": "status",
+                "data": {
+                    "description": f"An error occurred while generating an image",
+                    "done": True,
+                },
+            }
+        )
 
-            error_message = ""
-            if isinstance(e, HTTPException):
-                if e.detail and isinstance(e.detail, dict):
-                    error_message = e.detail.get("message", str(e.detail))
-                else:
-                    error_message = str(e.detail)
-
-            await __event_emitter__(
-                {
-                    "type": "status",
-                    "data": {
-                        "description": f"An error occurred while generating an image",
-                        "done": True,
-                    },
-                }
-            )
-
-            system_message_content = f"<context>Image generation was attempted but failed. The system is currently unable to generate the image. Tell the user that the following error occurred: {error_message}</context>"
-
-    else:
-        # Create image(s)
-        if request.app.state.config.ENABLE_IMAGE_PROMPT_GENERATION:
-            try:
-                res = await generate_image_prompt(
-                    request,
-                    {
-                        "model": form_data["model"],
-                        "messages": form_data["messages"],
-                    },
-                    user,
-                )
-
-                response = res["choices"][0]["message"]["content"]
-
-                try:
-                    bracket_start = response.find("{")
-                    bracket_end = response.rfind("}") + 1
-
-                    if bracket_start == -1 or bracket_end == -1:
-                        raise Exception("No JSON object found in the response")
-
-                    response = response[bracket_start:bracket_end]
-                    response = json.loads(response)
-                    prompt = response.get("prompt", [])
-                except Exception as e:
-                    prompt = user_message
-
-            except Exception as e:
-                log.exception(e)
-                prompt = user_message
-
-        try:
-            images = await image_generations(
-                request=request,
-                form_data=CreateImageForm(**{"prompt": prompt}),
-                user=user,
-            )
-
-            await __event_emitter__(
-                {
-                    "type": "status",
-                    "data": {"description": "Image created", "done": True},
-                }
-            )
-
-            await __event_emitter__(
-                {
-                    "type": "files",
-                    "data": {
-                        "files": [
-                            {
-                                "type": "image",
-                                "url": image["url"],
-                            }
-                            for image in images
-                        ]
-                    },
-                }
-            )
-
-            system_message_content = "<context>The requested image has been created by the system successfully and is now being shown to the user. Let the user know that the image they requested has been generated and is now shown in the chat.</context>"
-        except Exception as e:
-            log.debug(e)
-
-            error_message = ""
-            if isinstance(e, HTTPException):
-                if e.detail and isinstance(e.detail, dict):
-                    error_message = e.detail.get("message", str(e.detail))
-                else:
-                    error_message = str(e.detail)
-
-            await __event_emitter__(
-                {
-                    "type": "status",
-                    "data": {
-                        "description": f"An error occurred while generating an image",
-                        "done": True,
-                    },
-                }
-            )
-
-            system_message_content = f"<context>Image generation was attempted but failed because of an error. The system is currently unable to generate the image. Tell the user that the following error occurred: {error_message}</context>"
+        system_message_content = "<context>Unable to generate an image, tell the user that an error occurred</context>"
 
     if system_message_content:
         form_data["messages"] = add_or_update_system_message(
@@ -985,32 +874,37 @@ async def chat_completion_files_handler(
             queries = [get_last_user_message(body["messages"])]
 
         try:
-            # Directly await async get_sources_from_items (no thread needed - fully async now)
-            sources = await get_sources_from_items(
-                request=request,
-                items=files,
-                queries=queries,
-                embedding_function=lambda query, prefix: request.app.state.EMBEDDING_FUNCTION(
-                    query, prefix=prefix, user=user
-                ),
-                k=request.app.state.config.TOP_K,
-                reranking_function=(
-                    (
-                        lambda query, documents: request.app.state.RERANKING_FUNCTION(
-                            query, documents, user=user
-                        )
-                    )
-                    if request.app.state.RERANKING_FUNCTION
-                    else None
-                ),
-                k_reranker=request.app.state.config.TOP_K_RERANKER,
-                r=request.app.state.config.RELEVANCE_THRESHOLD,
-                hybrid_bm25_weight=request.app.state.config.HYBRID_BM25_WEIGHT,
-                hybrid_search=request.app.state.config.ENABLE_RAG_HYBRID_SEARCH,
-                full_context=all_full_context
-                or request.app.state.config.RAG_FULL_CONTEXT,
-                user=user,
-            )
+            # Offload get_sources_from_items to a separate thread
+            loop = asyncio.get_running_loop()
+            with ThreadPoolExecutor() as executor:
+                sources = await loop.run_in_executor(
+                    executor,
+                    lambda: get_sources_from_items(
+                        request=request,
+                        items=files,
+                        queries=queries,
+                        embedding_function=lambda query, prefix: request.app.state.EMBEDDING_FUNCTION(
+                            query, prefix=prefix, user=user
+                        ),
+                        k=request.app.state.config.TOP_K,
+                        reranking_function=(
+                            (
+                                lambda sentences: request.app.state.RERANKING_FUNCTION(
+                                    sentences, user=user
+                                )
+                            )
+                            if request.app.state.RERANKING_FUNCTION
+                            else None
+                        ),
+                        k_reranker=request.app.state.config.TOP_K_RERANKER,
+                        r=request.app.state.config.RELEVANCE_THRESHOLD,
+                        hybrid_bm25_weight=request.app.state.config.HYBRID_BM25_WEIGHT,
+                        hybrid_search=request.app.state.config.ENABLE_RAG_HYBRID_SEARCH,
+                        full_context=all_full_context
+                        or request.app.state.config.RAG_FULL_CONTEXT,
+                        user=user,
+                    ),
+                )
         except Exception as e:
             log.exception(e)
 
@@ -1117,7 +1011,7 @@ async def process_chat_payload(request, form_data, user, metadata, model):
             pass
 
     event_emitter = get_event_emitter(metadata)
-    event_caller = get_event_call(metadata)
+    event_call = get_event_call(metadata)
 
     oauth_token = None
     try:
@@ -1131,13 +1025,14 @@ async def process_chat_payload(request, form_data, user, metadata, model):
 
     extra_params = {
         "__event_emitter__": event_emitter,
-        "__event_call__": event_caller,
+        "__event_call__": event_call,
         "__user__": user.model_dump() if isinstance(user, UserModel) else {},
         "__metadata__": metadata,
-        "__oauth_token__": oauth_token,
         "__request__": request,
         "__model__": model,
+        "__oauth_token__": oauth_token,
     }
+
     # Initialize events to store additional event to be sent to the client
     # Initialize contexts and citation
     if getattr(request.state, "direct", False) and hasattr(request.state, "model"):
@@ -1248,18 +1143,6 @@ async def process_chat_payload(request, form_data, user, metadata, model):
 
     features = form_data.pop("features", None)
     if features:
-        if "voice" in features and features["voice"]:
-            if request.app.state.config.VOICE_MODE_PROMPT_TEMPLATE != None:
-                if request.app.state.config.VOICE_MODE_PROMPT_TEMPLATE != "":
-                    template = request.app.state.config.VOICE_MODE_PROMPT_TEMPLATE
-                else:
-                    template = DEFAULT_VOICE_MODE_PROMPT_TEMPLATE
-
-                form_data["messages"] = add_or_update_system_message(
-                    template,
-                    form_data["messages"],
-                )
-
         if "memory" in features and features["memory"]:
             form_data = await chat_memory_handler(
                 request, form_data, extra_params, user
@@ -1354,6 +1237,7 @@ async def process_chat_payload(request, form_data, user, metadata, model):
                         continue
 
                     auth_type = mcp_server_connection.get("auth_type", "")
+
                     headers = {}
                     if auth_type == "bearer":
                         headers["Authorization"] = (
@@ -1389,24 +1273,12 @@ async def process_chat_payload(request, form_data, user, metadata, model):
                             log.error(f"Error getting OAuth token: {e}")
                             oauth_token = None
 
-                    connection_headers = mcp_server_connection.get("headers", None)
-                    if connection_headers and isinstance(connection_headers, dict):
-                        for key, value in connection_headers.items():
-                            headers[key] = value
-
                     mcp_clients[server_id] = MCPClient()
                     await mcp_clients[server_id].connect(
                         url=mcp_server_connection.get("url", ""),
                         headers=headers if headers else None,
                     )
 
-                    function_name_filter_list = mcp_server_connection.get(
-                        "config", {}
-                    ).get("function_name_filter_list", "")
-
-                    if isinstance(function_name_filter_list, str):
-                        function_name_filter_list = function_name_filter_list.split(",")
-
                     tool_specs = await mcp_clients[server_id].list_tool_specs()
                     for tool_spec in tool_specs:
 
@@ -1419,13 +1291,6 @@ async def process_chat_payload(request, form_data, user, metadata, model):
 
                             return tool_function
 
-                        if function_name_filter_list:
-                            if not is_string_allowed(
-                                tool_spec["name"], function_name_filter_list
-                            ):
-                                # Skip this function
-                                continue
-
                         tool_function = make_tool_function(
                             mcp_clients[server_id], tool_spec["name"]
                         )
@@ -1442,17 +1307,6 @@ async def process_chat_payload(request, form_data, user, metadata, model):
                         }
                 except Exception as e:
                     log.debug(e)
-                    if event_emitter:
-                        await event_emitter(
-                            {
-                                "type": "chat:message:error",
-                                "data": {
-                                    "error": {
-                                        "content": f"Failed to connect to MCP server '{server_id}'"
-                                    }
-                                },
-                            }
-                        )
                     continue
 
         tools_dict = await get_tools(
@@ -1466,7 +1320,6 @@ async def process_chat_payload(request, form_data, user, metadata, model):
                 "__files__": metadata.get("files", []),
             },
         )
-
         if mcp_tools_dict:
             tools_dict = {**tools_dict, **mcp_tools_dict}
 
@@ -1690,13 +1543,16 @@ async def process_chat_response(
                 if not metadata.get("chat_id", "").startswith(
                     "local:"
                 ):  # Only update titles and tags for non-temp chats
-                    if TASKS.TITLE_GENERATION in tasks:
+                    if (
+                        TASKS.TITLE_GENERATION in tasks
+                        and tasks[TASKS.TITLE_GENERATION]
+                    ):
                         user_message = get_last_user_message(messages)
                         if user_message and len(user_message) > 100:
                             user_message = user_message[:100] + "..."
 
-                        title = None
                         if tasks[TASKS.TITLE_GENERATION]:
+
                             res = await generate_title(
                                 request,
                                 {
@@ -1747,8 +1603,7 @@ async def process_chat_response(
                                         "data": title,
                                     }
                                 )
-
-                        if title == None and len(messages) == 2:
+                        elif len(messages) == 2:
                             title = messages[0].get("content", user_message)
 
                             Chats.update_chat_title_by_id(metadata["chat_id"], title)
@@ -1906,7 +1761,7 @@ async def process_chat_response(
                             )
 
                             # Send a webhook notification if the user is not active
-                            if not Users.is_user_active(user.id):
+                            if not get_active_status_by_user_id(user.id):
                                 webhook_url = Users.get_user_webhook_url_by_id(user.id)
                                 if webhook_url:
                                     await post_webhook(
@@ -2084,11 +1939,9 @@ async def process_chat_response(
                                 content = f"{content}{tool_calls_display_content}"
 
                     elif block["type"] == "reasoning":
-                        reasoning_display_content = html.escape(
-                            "\n".join(
-                                (f"> {line}" if not line.startswith(">") else line)
-                                for line in block["content"].splitlines()
-                            )
+                        reasoning_display_content = "\n".join(
+                            (f"> {line}" if not line.startswith(">") else line)
+                            for line in block["content"].splitlines()
                         )
 
                         reasoning_duration = block.get("duration", None)
@@ -2496,9 +2349,7 @@ async def process_chat_response(
                             )
 
                             if data:
-                                if "event" in data and not getattr(
-                                    request.state, "direct", False
-                                ):
+                                if "event" in data:
                                     await event_emitter(data.get("event", {}))
 
                                 if "selected_model_id" in data:
@@ -2606,26 +2457,6 @@ async def process_chat_response(
                                                             "arguments"
                                                         ] += delta_arguments
 
-                                    image_urls = get_image_urls(
-                                        delta.get("images", []), request, metadata, user
-                                    )
-                                    if image_urls:
-                                        message_files = Chats.add_message_files_by_id_and_message_id(
-                                            metadata["chat_id"],
-                                            metadata["message_id"],
-                                            [
-                                                {"type": "image", "url": url}
-                                                for url in image_urls
-                                            ],
-                                        )
-
-                                        await event_emitter(
-                                            {
-                                                "type": "files",
-                                                "data": {"files": message_files},
-                                            }
-                                        )
-
                                     value = delta.get("content")
 
                                     reasoning_content = (
@@ -2684,11 +2515,6 @@ async def process_chat_response(
                                                 }
                                             )
 
-                                        if ENABLE_CHAT_RESPONSE_BASE64_IMAGE_URL_CONVERSION:
-                                            value = convert_markdown_base64_images(
-                                                request, value, metadata, user
-                                            )
-
                                         content = f"{content}{value}"
                                         if not content_blocks:
                                             content_blocks.append(
@@ -2914,16 +2740,7 @@ async def process_chat_response(
                                     )
 
                                 else:
-                                    tool_function = get_updated_tool_function(
-                                        function=tool["callable"],
-                                        extra_params={
-                                            "__messages__": form_data.get(
-                                                "messages", []
-                                            ),
-                                            "__files__": metadata.get("files", []),
-                                        },
-                                    )
-
+                                    tool_function = tool["callable"]
                                     tool_result = await tool_function(
                                         **tool_function_params
                                     )
@@ -3201,7 +3018,7 @@ async def process_chat_response(
                     )
 
                 # Send a webhook notification if the user is not active
-                if not Users.is_user_active(user.id):
+                if not get_active_status_by_user_id(user.id):
                     webhook_url = Users.get_user_webhook_url_by_id(user.id)
                     if webhook_url:
                         await post_webhook(

backend/open_webui/utils/misc.py

@@ -6,13 +6,12 @@ import uuid
 import logging
 from datetime import timedelta
 from pathlib import Path
-from typing import Callable, Optional, Sequence, Union
+from typing import Callable, Optional
 import json
-import aiohttp
 
 
 import collections.abc
-from open_webui.env import SRC_LOG_LEVELS, CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE
+from open_webui.env import SRC_LOG_LEVELS
 
 log = logging.getLogger(__name__)
 log.setLevel(SRC_LOG_LEVELS["MAIN"])
@@ -27,49 +26,6 @@ def deep_update(d, u):
     return d
 
 
-def get_allow_block_lists(filter_list):
-    allow_list = []
-    block_list = []
-
-    if filter_list:
-        for d in filter_list:
-            if d.startswith("!"):
-                # Domains starting with "!" → blocked
-                block_list.append(d[1:].strip())
-            else:
-                # Domains starting without "!" → allowed
-                allow_list.append(d.strip())
-
-    return allow_list, block_list
-
-
-def is_string_allowed(
-    string: Union[str, Sequence[str]], filter_list: Optional[list[str]] = None
-) -> bool:
-    """
-    Checks if a string is allowed based on the provided filter list.
-    :param string: The string or sequence of strings to check (e.g., domain or hostname).
-    :param filter_list: List of allowed/blocked strings. Strings starting with "!" are blocked.
-    :return: True if the string or sequence of strings is allowed, False otherwise.
-    """
-    if not filter_list:
-        return True
-
-    allow_list, block_list = get_allow_block_lists(filter_list)
-    strings = [string] if isinstance(string, str) else list(string)
-
-    # If allow list is non-empty, require domain to match one of them
-    if allow_list:
-        if not any(s.endswith(allowed) for s in strings for allowed in allow_list):
-            return False
-
-    # Block list always removes matches
-    if any(s.endswith(blocked) for s in strings for blocked in block_list):
-        return False
-
-    return True
-
-
 def get_message_list(messages_map, message_id):
     """
     Reconstructs a list of messages in order up to the specified message_id.
@@ -583,68 +539,3 @@ def extract_urls(text: str) -> list[str]:
         r"(https?://[^\s]+)", re.IGNORECASE
     )  # Matches http and https URLs
     return url_pattern.findall(text)
-
-
-def stream_chunks_handler(stream: aiohttp.StreamReader):
-    """
-    Handle stream response chunks, supporting large data chunks that exceed the original 16kb limit.
-    When a single line exceeds max_buffer_size, returns an empty JSON string {} and skips subsequent data
-    until encountering normally sized data.
-
-    :param stream: The stream reader to handle.
-    :return: An async generator that yields the stream data.
-    """
-
-    max_buffer_size = CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE
-    if max_buffer_size is None or max_buffer_size <= 0:
-        return stream
-
-    async def yield_safe_stream_chunks():
-        buffer = b""
-        skip_mode = False
-
-        async for data, _ in stream.iter_chunks():
-            if not data:
-                continue
-
-            # In skip_mode, if buffer already exceeds the limit, clear it (it's part of an oversized line)
-            if skip_mode and len(buffer) > max_buffer_size:
-                buffer = b""
-
-            lines = (buffer + data).split(b"\n")
-
-            # Process complete lines (except the last possibly incomplete fragment)
-            for i in range(len(lines) - 1):
-                line = lines[i]
-
-                if skip_mode:
-                    # Skip mode: check if current line is small enough to exit skip mode
-                    if len(line) <= max_buffer_size:
-                        skip_mode = False
-                        yield line
-                    else:
-                        yield b"data: {}"
-                else:
-                    # Normal mode: check if line exceeds limit
-                    if len(line) > max_buffer_size:
-                        skip_mode = True
-                        yield b"data: {}"
-                        log.info(f"Skip mode triggered, line size: {len(line)}")
-                    else:
-                        yield line
-
-            # Save the last incomplete fragment
-            buffer = lines[-1]
-
-            # Check if buffer exceeds limit
-            if not skip_mode and len(buffer) > max_buffer_size:
-                skip_mode = True
-                log.info(f"Skip mode triggered, buffer size: {len(buffer)}")
-                # Clear oversized buffer to prevent unlimited growth
-                buffer = b""
-
-        # Process remaining buffer data
-        if buffer and not skip_mode:
-            yield buffer
-
-    return yield_safe_stream_chunks()

backend/open_webui/utils/models.py

@@ -6,14 +6,12 @@ import sys
 from aiocache import cached
 from fastapi import Request
 
-from open_webui.socket.utils import RedisDict
 from open_webui.routers import openai, ollama
 from open_webui.functions import get_function_models
 
 
 from open_webui.models.functions import Functions
 from open_webui.models.models import Models
-from open_webui.models.groups import Groups
 
 
 from open_webui.utils.plugin import (
@@ -168,18 +166,13 @@ async def get_all_models(request, refresh: bool = False, user: UserModel = None)
                         action_ids = []
                         filter_ids = []
 
-                        if "info" in model:
-                            if "meta" in model["info"]:
-                                action_ids.extend(
-                                    model["info"]["meta"].get("actionIds", [])
-                                )
-                                filter_ids.extend(
-                                    model["info"]["meta"].get("filterIds", [])
-                                )
-
-                            if "params" in model["info"]:
-                                # Remove params to avoid exposing sensitive info
-                                del model["info"]["params"]
+                        if "info" in model and "meta" in model["info"]:
+                            action_ids.extend(
+                                model["info"]["meta"].get("actionIds", [])
+                            )
+                            filter_ids.extend(
+                                model["info"]["meta"].get("filterIds", [])
+                            )
 
                         model["action_ids"] = action_ids
                         model["filter_ids"] = filter_ids
@@ -189,45 +182,22 @@ async def get_all_models(request, refresh: bool = False, user: UserModel = None)
         elif custom_model.is_active and (
             custom_model.id not in [model["id"] for model in models]
         ):
-            # Custom model based on a base model
             owned_by = "openai"
-            connection_type = None
-
             pipe = None
 
-            for m in models:
-                if (
-                    custom_model.base_model_id == m["id"]
-                    or custom_model.base_model_id == m["id"].split(":")[0]
-                ):
-                    owned_by = m.get("owned_by", "unknown")
-                    if "pipe" in m:
-                        pipe = m["pipe"]
-
-                    connection_type = m.get("connection_type", None)
-                    break
-
-            model = {
-                "id": f"{custom_model.id}",
-                "name": custom_model.name,
-                "object": "model",
-                "created": custom_model.created_at,
-                "owned_by": owned_by,
-                "connection_type": connection_type,
-                "preset": True,
-                **({"pipe": pipe} if pipe is not None else {}),
-            }
-
-            info = custom_model.model_dump()
-            if "params" in info:
-                # Remove params to avoid exposing sensitive info
-                del info["params"]
-
-            model["info"] = info
-
             action_ids = []
             filter_ids = []
 
+            for model in models:
+                if (
+                    custom_model.base_model_id == model["id"]
+                    or custom_model.base_model_id == model["id"].split(":")[0]
+                ):
+                    owned_by = model.get("owned_by", "unknown owner")
+                    if "pipe" in model:
+                        pipe = model["pipe"]
+                    break
+
             if custom_model.meta:
                 meta = custom_model.meta.model_dump()
 
@@ -237,10 +207,20 @@ async def get_all_models(request, refresh: bool = False, user: UserModel = None)
                 if "filterIds" in meta:
                     filter_ids.extend(meta["filterIds"])
 
-            model["action_ids"] = action_ids
-            model["filter_ids"] = filter_ids
-
-            models.append(model)
+            models.append(
+                {
+                    "id": f"{custom_model.id}",
+                    "name": custom_model.name,
+                    "object": "model",
+                    "created": custom_model.created_at,
+                    "owned_by": owned_by,
+                    "info": custom_model.model_dump(),
+                    "preset": True,
+                    **({"pipe": pipe} if pipe is not None else {}),
+                    "action_ids": action_ids,
+                    "filter_ids": filter_ids,
+                }
+            )
 
     # Process action_ids to get the actions
     def get_action_items_from_module(function, module):
@@ -329,12 +309,7 @@ async def get_all_models(request, refresh: bool = False, user: UserModel = None)
 
     log.debug(f"get_all_models() returned {len(models)} models")
 
-    models_dict = {model["id"]: model for model in models}
-    if isinstance(request.app.state.MODELS, RedisDict):
-        request.app.state.MODELS.set(models_dict)
-    else:
-        request.app.state.MODELS = models_dict
-
+    request.app.state.MODELS = {model["id"]: model for model in models}
     return models
 
 
@@ -368,7 +343,6 @@ def get_filtered_models(models, user):
         or (user.role == "admin" and not BYPASS_ADMIN_ACCESS_CONTROL)
     ) and not BYPASS_MODEL_ACCESS_CONTROL:
         filtered_models = []
-        user_group_ids = {group.id for group in Groups.get_groups_by_member_id(user.id)}
         for model in models:
             if model.get("arena"):
                 if has_access(
@@ -377,7 +351,6 @@ def get_filtered_models(models, user):
                     access_control=model.get("info", {})
                     .get("meta", {})
                     .get("access_control", {}),
-                    user_group_ids=user_group_ids,
                 ):
                     filtered_models.append(model)
                 continue
@@ -391,7 +364,6 @@ def get_filtered_models(models, user):
                         user.id,
                         type="read",
                         access_control=model_info.access_control,
-                        user_group_ids=user_group_ids,
                     )
                 ):
                     filtered_models.append(model)

backend/open_webui/utils/oauth.py

@@ -1,5 +1,4 @@
 import base64
-import copy
 import hashlib
 import logging
 import mimetypes
@@ -14,7 +13,7 @@ import fnmatch
 import time
 import secrets
 from cryptography.fernet import Fernet
-from typing import Literal
+
 
 import aiohttp
 from authlib.integrations.starlette_client import OAuth
@@ -42,8 +41,6 @@ from open_webui.config import (
     ENABLE_OAUTH_GROUP_MANAGEMENT,
     ENABLE_OAUTH_GROUP_CREATION,
     OAUTH_BLOCKED_GROUPS,
-    OAUTH_GROUPS_SEPARATOR,
-    OAUTH_ROLES_SEPARATOR,
     OAUTH_ROLES_CLAIM,
     OAUTH_SUB_CLAIM,
     OAUTH_GROUPS_CLAIM,
@@ -54,7 +51,6 @@ from open_webui.config import (
     OAUTH_ADMIN_ROLES,
     OAUTH_ALLOWED_DOMAINS,
     OAUTH_UPDATE_PICTURE_ON_LOGIN,
-    OAUTH_ACCESS_TOKEN_REQUEST_INCLUDE_CLIENT_ID,
     WEBHOOK_URL,
     JWT_EXPIRES_IN,
     AppConfig,
@@ -72,22 +68,12 @@ from open_webui.env import (
 from open_webui.utils.misc import parse_duration
 from open_webui.utils.auth import get_password_hash, create_token
 from open_webui.utils.webhook import post_webhook
-from open_webui.utils.groups import apply_default_group_assignment
 
 from mcp.shared.auth import (
-    OAuthClientMetadata as MCPOAuthClientMetadata,
+    OAuthClientMetadata,
     OAuthMetadata,
 )
 
-from authlib.oauth2.rfc6749.errors import OAuth2Error
-
-
-class OAuthClientMetadata(MCPOAuthClientMetadata):
-    token_endpoint_auth_method: Literal[
-        "none", "client_secret_basic", "client_secret_post"
-    ] = "client_secret_post"
-    pass
-
 
 class OAuthClientInformationFull(OAuthClientMetadata):
     issuer: Optional[str] = None  # URL of the OAuth server that issued this client
@@ -164,37 +150,6 @@ def decrypt_data(data: str):
         raise
 
 
-def _build_oauth_callback_error_message(e: Exception) -> str:
-    """
-    Produce a user-facing callback error string with actionable context.
-    Keeps the message short and strips newlines for safe redirect usage.
-    """
-    if isinstance(e, OAuth2Error):
-        parts = [p for p in [e.error, e.description] if p]
-        detail = " - ".join(parts)
-    elif isinstance(e, HTTPException):
-        detail = e.detail if isinstance(e.detail, str) else str(e.detail)
-    elif isinstance(e, aiohttp.ClientResponseError):
-        detail = f"Upstream provider returned {e.status}: {e.message}"
-    elif isinstance(e, aiohttp.ClientError):
-        detail = str(e)
-    elif isinstance(e, KeyError):
-        missing = str(e).strip("'")
-        if missing.lower() == "state":
-            detail = "Missing state parameter in callback (session may have expired)"
-        else:
-            detail = f"Missing expected key '{missing}' in OAuth response"
-    else:
-        detail = str(e)
-
-    detail = detail.replace("\n", " ").strip()
-    if not detail:
-        detail = e.__class__.__name__
-
-    message = f"OAuth callback failed: {detail}"
-    return message[:197] + "..." if len(message) > 200 else message
-
-
 def is_in_blocked_groups(group_name: str, groups: list) -> bool:
     """
     Check if a group name matches any blocked pattern.
@@ -248,32 +203,23 @@ def get_parsed_and_base_url(server_url) -> tuple[urllib.parse.ParseResult, str]:
 def get_discovery_urls(server_url) -> list[str]:
     parsed, base_url = get_parsed_and_base_url(server_url)
 
-    urls = []
+    urls = [
+        urllib.parse.urljoin(base_url, "/.well-known/oauth-authorization-server"),
+        urllib.parse.urljoin(base_url, "/.well-known/openid-configuration"),
+    ]
 
     if parsed.path and parsed.path != "/":
-        # Generate discovery URLs based on https://modelcontextprotocol.io/specification/draft/basic/authorization#authorization-server-metadata-discovery
-        tenant = parsed.path.rstrip("/")
-        urls.extend(
-            [
-                urllib.parse.urljoin(
-                    base_url,
-                    f"/.well-known/oauth-authorization-server{tenant}",
-                ),
-                urllib.parse.urljoin(
-                    base_url, f"/.well-known/openid-configuration{tenant}"
-                ),
-                urllib.parse.urljoin(
-                    base_url, f"{tenant}/.well-known/openid-configuration"
-                ),
-            ]
+        urls.append(
+            urllib.parse.urljoin(
+                base_url,
+                f"/.well-known/oauth-authorization-server{parsed.path.rstrip('/')}",
+            )
+        )
+        urls.append(
+            urllib.parse.urljoin(
+                base_url, f"/.well-known/openid-configuration{parsed.path.rstrip('/')}"
+            )
         )
-
-    urls.extend(
-        [
-            urllib.parse.urljoin(base_url, "/.well-known/oauth-authorization-server"),
-            urllib.parse.urljoin(base_url, "/.well-known/openid-configuration"),
-        ]
-    )
 
     return urls
 
@@ -299,12 +245,13 @@ async def get_oauth_client_info_with_dynamic_client_registration(
             redirect_uris=[f"{redirect_base_url}/oauth/clients/{client_id}/callback"],
             grant_types=["authorization_code", "refresh_token"],
             response_types=["code"],
+            token_endpoint_auth_method="client_secret_post",
         )
 
         # Attempt to fetch OAuth server metadata to get registration endpoint & scopes
         discovery_urls = get_discovery_urls(oauth_server_url)
         for url in discovery_urls:
-            async with aiohttp.ClientSession(trust_env=True) as session:
+            async with aiohttp.ClientSession() as session:
                 async with session.get(
                     url, ssl=AIOHTTP_CLIENT_SESSION_SSL
                 ) as oauth_server_metadata_response:
@@ -321,17 +268,6 @@ async def get_oauth_client_info_with_dynamic_client_registration(
                                 oauth_client_metadata.scope = " ".join(
                                     oauth_server_metadata.scopes_supported
                                 )
-
-                            if (
-                                oauth_server_metadata.token_endpoint_auth_methods_supported
-                                and oauth_client_metadata.token_endpoint_auth_method
-                                not in oauth_server_metadata.token_endpoint_auth_methods_supported
-                            ):
-                                # Pick the first supported method from the server
-                                oauth_client_metadata.token_endpoint_auth_method = oauth_server_metadata.token_endpoint_auth_methods_supported[
-                                    0
-                                ]
-
                             break
                         except Exception as e:
                             log.error(f"Error parsing OAuth metadata from {url}: {e}")
@@ -351,7 +287,7 @@ async def get_oauth_client_info_with_dynamic_client_registration(
         )
 
         # Perform dynamic client registration and return client info
-        async with aiohttp.ClientSession(trust_env=True) as session:
+        async with aiohttp.ClientSession() as session:
             async with session.post(
                 registration_url, json=registration_data, ssl=AIOHTTP_CLIENT_SESSION_SSL
             ) as oauth_client_registration_response:
@@ -359,13 +295,6 @@ async def get_oauth_client_info_with_dynamic_client_registration(
                     registration_response_json = (
                         await oauth_client_registration_response.json()
                     )
-
-                    # The mcp package requires optional unset values to be None. If an empty string is passed, it gets validated and fails.
-                    # This replaces all empty strings with None.
-                    registration_response_json = {
-                        k: (None if v == "" else v)
-                        for k, v in registration_response_json.items()
-                    }
                     oauth_client_info = OAuthClientInformationFull.model_validate(
                         {
                             **registration_response_json,
@@ -410,20 +339,9 @@ class OAuthClientManager:
             "name": client_id,
             "client_id": oauth_client_info.client_id,
             "client_secret": oauth_client_info.client_secret,
-            "client_kwargs": {
-                **(
-                    {"scope": oauth_client_info.scope}
-                    if oauth_client_info.scope
-                    else {}
-                ),
-                **(
-                    {
-                        "token_endpoint_auth_method": oauth_client_info.token_endpoint_auth_method
-                    }
-                    if oauth_client_info.token_endpoint_auth_method
-                    else {}
-                ),
-            },
+            "client_kwargs": (
+                {"scope": oauth_client_info.scope} if oauth_client_info.scope else {}
+            ),
             "server_metadata_url": (
                 oauth_client_info.issuer if oauth_client_info.issuer else None
             ),
@@ -453,82 +371,6 @@ class OAuthClientManager:
         if client_id in self.clients:
             del self.clients[client_id]
             log.info(f"Removed OAuth client {client_id}")
-
-        if hasattr(self.oauth, "_clients"):
-            if client_id in self.oauth._clients:
-                self.oauth._clients.pop(client_id, None)
-
-        if hasattr(self.oauth, "_registry"):
-            if client_id in self.oauth._registry:
-                self.oauth._registry.pop(client_id, None)
-
-        return True
-
-    async def _preflight_authorization_url(
-        self, client, client_info: OAuthClientInformationFull
-    ) -> bool:
-        # TODO: Replace this logic with a more robust OAuth client registration validation
-        # Only perform preflight checks for Starlette OAuth clients
-        if not hasattr(client, "create_authorization_url"):
-            return True
-
-        redirect_uri = None
-        if client_info.redirect_uris:
-            redirect_uri = str(client_info.redirect_uris[0])
-
-        try:
-            auth_data = await client.create_authorization_url(redirect_uri=redirect_uri)
-            authorization_url = auth_data.get("url")
-
-            if not authorization_url:
-                return True
-        except Exception as e:
-            log.debug(
-                f"Skipping OAuth preflight for client {client_info.client_id}: {e}",
-            )
-            return True
-
-        try:
-            async with aiohttp.ClientSession(trust_env=True) as session:
-                async with session.get(
-                    authorization_url,
-                    allow_redirects=False,
-                    ssl=AIOHTTP_CLIENT_SESSION_SSL,
-                ) as resp:
-                    if resp.status < 400:
-                        return True
-                    response_text = await resp.text()
-
-                    error = None
-                    error_description = ""
-
-                    content_type = resp.headers.get("content-type", "")
-                    if "application/json" in content_type:
-                        try:
-                            payload = json.loads(response_text)
-                            error = payload.get("error")
-                            error_description = payload.get("error_description", "")
-                        except:
-                            pass
-                    else:
-                        error_description = response_text
-
-                    error_message = f"{error or ''} {error_description or ''}".lower()
-
-                    if any(
-                        keyword in error_message
-                        for keyword in ("invalid_client", "invalid client", "client id")
-                    ):
-                        log.warning(
-                            f"OAuth client preflight detected invalid registration for {client_info.client_id}: {error} {error_description}"
-                        )
-
-                        return False
-        except Exception as e:
-            log.debug(
-                f"Skipping OAuth preflight network check for client {client_info.client_id}: {e}"
-            )
-
         return True
 
     def get_client(self, client_id):
@@ -719,6 +561,7 @@ class OAuthClientManager:
         client = self.get_client(client_id)
         if client is None:
             raise HTTPException(404)
+
         client_info = self.get_client_info(client_id)
         if client_info is None:
             raise HTTPException(404)
@@ -726,8 +569,7 @@ class OAuthClientManager:
         redirect_uri = (
             client_info.redirect_uris[0] if client_info.redirect_uris else None
         )
-        redirect_uri_str = str(redirect_uri) if redirect_uri else None
-        return await client.authorize_redirect(request, redirect_uri_str)
+        return await client.authorize_redirect(request, str(redirect_uri))
 
     async def handle_callback(self, request, client_id: str, user_id: str, response):
         client = self.get_client(client_id)
@@ -737,17 +579,16 @@ class OAuthClientManager:
         error_message = None
         try:
             client_info = self.get_client_info(client_id)
-
-            auth_params = {}
+            token_params = {}
             if (
                 client_info
                 and hasattr(client_info, "client_id")
                 and hasattr(client_info, "client_secret")
             ):
-                auth_params["client_id"] = client_info.client_id
-                auth_params["client_secret"] = client_info.client_secret
+                token_params["client_id"] = client_info.client_id
+                token_params["client_secret"] = client_info.client_secret
 
-            token = await client.authorize_access_token(request, **auth_params)
+            token = await client.authorize_access_token(request, **token_params)
             if token:
                 try:
                     # Add timestamp for tracking
@@ -780,14 +621,8 @@ class OAuthClientManager:
                 error_message = "Failed to obtain OAuth token"
                 log.warning(error_message)
         except Exception as e:
-            error_message = _build_oauth_callback_error_message(e)
-            log.warning(
-                "OAuth callback error for user_id=%s client_id=%s: %s",
-                user_id,
-                client_id,
-                error_message,
-                exc_info=True,
-            )
+            error_message = "OAuth callback error"
+            log.warning(f"OAuth callback error: {e}")
 
         redirect_url = (
             str(request.app.state.config.WEBUI_URL or request.base_url)
@@ -795,9 +630,7 @@ class OAuthClientManager:
 
         if error_message:
             log.debug(error_message)
-            redirect_url = (
-                f"{redirect_url}/?error={urllib.parse.quote_plus(error_message)}"
-            )
+            redirect_url = f"{redirect_url}/?error={error_message}"
             return RedirectResponse(url=redirect_url, headers=response.headers)
 
         response = RedirectResponse(url=redirect_url, headers=response.headers)
@@ -1026,21 +859,11 @@ class OAuthManager:
                 for nested_claim in nested_claims:
                     claim_data = claim_data.get(nested_claim, {})
 
-                # Try flat claim structure as alternative
-                if not claim_data:
-                    claim_data = user_data.get(oauth_claim, {})
-
                 oauth_roles = []
 
                 if isinstance(claim_data, list):
                     oauth_roles = claim_data
-                elif isinstance(claim_data, str):
-                    # Split by the configured separator if present
-                    if OAUTH_ROLES_SEPARATOR and OAUTH_ROLES_SEPARATOR in claim_data:
-                        oauth_roles = claim_data.split(OAUTH_ROLES_SEPARATOR)
-                    else:
-                        oauth_roles = [claim_data]
-                elif isinstance(claim_data, int):
+                if isinstance(claim_data, str) or isinstance(claim_data, int):
                     oauth_roles = [str(claim_data)]
 
             log.debug(f"Oauth Roles claim: {oauth_claim}")
@@ -1094,16 +917,12 @@ class OAuthManager:
             if isinstance(claim_data, list):
                 user_oauth_groups = claim_data
             elif isinstance(claim_data, str):
-                # Split by the configured separator if present
-                if OAUTH_GROUPS_SEPARATOR in claim_data:
-                    user_oauth_groups = claim_data.split(OAUTH_GROUPS_SEPARATOR)
-                else:
-                    user_oauth_groups = [claim_data]
+                user_oauth_groups = [claim_data]
             else:
                 user_oauth_groups = []
 
         user_current_groups: list[GroupModel] = Groups.get_groups_by_member_id(user.id)
-        all_available_groups: list[GroupModel] = Groups.get_all_groups()
+        all_available_groups: list[GroupModel] = Groups.get_groups()
 
         # Create groups if they don't exist and creation is enabled
         if auth_manager_config.ENABLE_OAUTH_GROUP_CREATION:
@@ -1147,7 +966,7 @@ class OAuthManager:
 
             # Refresh the list of all available groups if any were created
             if groups_created:
-                all_available_groups = Groups.get_all_groups()
+                all_available_groups = Groups.get_groups()
                 log.debug("Refreshed list of all available groups after creation.")
 
         log.debug(f"Oauth Groups claim: {oauth_claim}")
@@ -1168,21 +987,23 @@ class OAuthManager:
                 log.debug(
                     f"Removing user from group {group_model.name} as it is no longer in their oauth groups"
                 )
-                Groups.remove_users_from_group(group_model.id, [user.id])
+
+                user_ids = group_model.user_ids
+                user_ids = [i for i in user_ids if i != user.id]
 
                 # In case a group is created, but perms are never assigned to the group by hitting "save"
                 group_permissions = group_model.permissions
                 if not group_permissions:
                     group_permissions = default_permissions
 
+                update_form = GroupUpdateForm(
+                    name=group_model.name,
+                    description=group_model.description,
+                    permissions=group_permissions,
+                    user_ids=user_ids,
+                )
                 Groups.update_group_by_id(
-                    id=group_model.id,
-                    form_data=GroupUpdateForm(
-                        name=group_model.name,
-                        description=group_model.description,
-                        permissions=group_permissions,
-                    ),
-                    overwrite=False,
+                    id=group_model.id, form_data=update_form, overwrite=False
                 )
 
         # Add user to new groups
@@ -1198,21 +1019,22 @@ class OAuthManager:
                     f"Adding user to group {group_model.name} as it was found in their oauth groups"
                 )
 
-                Groups.add_users_to_group(group_model.id, [user.id])
+                user_ids = group_model.user_ids
+                user_ids.append(user.id)
 
                 # In case a group is created, but perms are never assigned to the group by hitting "save"
                 group_permissions = group_model.permissions
                 if not group_permissions:
                     group_permissions = default_permissions
 
+                update_form = GroupUpdateForm(
+                    name=group_model.name,
+                    description=group_model.description,
+                    permissions=group_permissions,
+                    user_ids=user_ids,
+                )
                 Groups.update_group_by_id(
-                    id=group_model.id,
-                    form_data=GroupUpdateForm(
-                        name=group_model.name,
-                        description=group_model.description,
-                        permissions=group_permissions,
-                    ),
-                    overwrite=False,
+                    id=group_model.id, form_data=update_form, overwrite=False
                 )
 
     async def _process_picture_url(
@@ -1279,26 +1101,10 @@ class OAuthManager:
         error_message = None
         try:
             client = self.get_client(provider)
-
-            auth_params = {}
-
-            if client:
-                if (
-                    hasattr(client, "client_id")
-                    and OAUTH_ACCESS_TOKEN_REQUEST_INCLUDE_CLIENT_ID
-                ):
-                    auth_params["client_id"] = client.client_id
-
             try:
-                token = await client.authorize_access_token(request, **auth_params)
+                token = await client.authorize_access_token(request)
             except Exception as e:
-                detailed_error = _build_oauth_callback_error_message(e)
-                log.warning(
-                    "OAuth callback error during authorize_access_token for provider %s: %s",
-                    provider,
-                    detailed_error,
-                    exc_info=True,
-                )
+                log.warning(f"OAuth callback error: {e}")
                 raise HTTPException(400, detail=ERROR_MESSAGES.INVALID_CRED)
 
             # Try to get userinfo from the token first, some providers include it there
@@ -1329,10 +1135,7 @@ class OAuthManager:
                 log.warning(f"OAuth callback failed, sub is missing: {user_data}")
                 raise HTTPException(400, detail=ERROR_MESSAGES.INVALID_CRED)
 
-            oauth_data = {}
-            oauth_data[provider] = {
-                "sub": sub,
-            }
+            provider_sub = f"{provider}@{sub}"
 
             # Email extraction
             email_claim = auth_manager_config.OAUTH_EMAIL_CLAIM
@@ -1379,12 +1182,12 @@ class OAuthManager:
                         log.warning(f"Error fetching GitHub email: {e}")
                         raise HTTPException(400, detail=ERROR_MESSAGES.INVALID_CRED)
                 elif ENABLE_OAUTH_EMAIL_FALLBACK:
-                    email = f"{provider}@{sub}.local"
+                    email = f"{provider_sub}.local"
                 else:
                     log.warning(f"OAuth callback failed, email is missing: {user_data}")
                     raise HTTPException(400, detail=ERROR_MESSAGES.INVALID_CRED)
-
             email = email.lower()
+
             # If allowed domains are configured, check if the email domain is in the list
             if (
                 "*" not in auth_manager_config.OAUTH_ALLOWED_DOMAINS
@@ -1397,7 +1200,7 @@ class OAuthManager:
                 raise HTTPException(400, detail=ERROR_MESSAGES.INVALID_CRED)
 
             # Check if the user exists
-            user = Users.get_user_by_oauth_sub(provider, sub)
+            user = Users.get_user_by_oauth_sub(provider_sub)
             if not user:
                 # If the user does not exist, check if merging is enabled
                 if auth_manager_config.OAUTH_MERGE_ACCOUNTS_BY_EMAIL:
@@ -1405,15 +1208,12 @@ class OAuthManager:
                     user = Users.get_user_by_email(email)
                     if user:
                         # Update the user with the new oauth sub
-                        Users.update_user_oauth_by_id(user.id, provider, sub)
+                        Users.update_user_oauth_sub_by_id(user.id, provider_sub)
 
             if user:
                 determined_role = self.get_user_role(user, user_data)
                 if user.role != determined_role:
                     Users.update_user_role_by_id(user.id, determined_role)
-                    # Update the user object in memory as well,
-                    # to avoid problems with the ENABLE_OAUTH_GROUP_MANAGEMENT check below
-                    user.role = determined_role
                 # Update profile picture if enabled and different from current
                 if auth_manager_config.OAUTH_UPDATE_PICTURE_ON_LOGIN:
                     picture_claim = auth_manager_config.OAUTH_PICTURE_CLAIM
@@ -1464,7 +1264,7 @@ class OAuthManager:
                         name=name,
                         profile_image_url=picture_url,
                         role=self.get_user_role(None, user_data),
-                        oauth=oauth_data,
+                        oauth_sub=provider_sub,
                     )
 
                     if auth_manager_config.WEBHOOK_URL:
@@ -1478,12 +1278,6 @@ class OAuthManager:
                                 "user": user.model_dump_json(exclude_none=True),
                             },
                         )
-
-                    apply_default_group_assignment(
-                        request.app.state.config.DEFAULT_GROUP_ID,
-                        user.id,
-                    )
-
                 else:
                     raise HTTPException(
                         status.HTTP_403_FORBIDDEN,

backend/open_webui/utils/payload.py

@@ -297,10 +297,6 @@ def convert_payload_openai_to_ollama(openai_payload: dict) -> dict:
     if "tools" in openai_payload:
         ollama_payload["tools"] = openai_payload["tools"]
 
-    if "max_tokens" in openai_payload:
-        ollama_payload["num_predict"] = openai_payload["max_tokens"]
-        del openai_payload["max_tokens"]
-
     # If there are advanced parameters in the payload, format them in Ollama's options field
     if openai_payload.get("options"):
         ollama_payload["options"] = openai_payload["options"]

backend/open_webui/utils/rate_limit.py

@@ -1,139 +0,0 @@
-import time
-from typing import Optional, Dict
-from open_webui.env import REDIS_KEY_PREFIX
-
-
-class RateLimiter:
-    """
-    General-purpose rate limiter using Redis with a rolling window strategy.
-    Falls back to in-memory storage if Redis is not available.
-    """
-
-    # In-memory fallback storage
-    _memory_store: Dict[str, Dict[int, int]] = {}
-
-    def __init__(
-        self,
-        redis_client,
-        limit: int,
-        window: int,
-        bucket_size: int = 60,
-        enabled: bool = True,
-    ):
-        """
-        :param redis_client: Redis client instance or None
-        :param limit: Max allowed events in the window
-        :param window: Time window in seconds
-        :param bucket_size: Bucket resolution
-        :param enabled: Turn on/off rate limiting globally
-        """
-        self.r = redis_client
-        self.limit = limit
-        self.window = window
-        self.bucket_size = bucket_size
-        self.num_buckets = window // bucket_size
-        self.enabled = enabled
-
-    def _bucket_key(self, key: str, bucket_index: int) -> str:
-        return f"{REDIS_KEY_PREFIX}:ratelimit:{key.lower()}:{bucket_index}"
-
-    def _current_bucket(self) -> int:
-        return int(time.time()) // self.bucket_size
-
-    def _redis_available(self) -> bool:
-        return self.r is not None
-
-    def is_limited(self, key: str) -> bool:
-        """
-        Main rate-limit check.
-        Gracefully handles missing or failing Redis.
-        """
-        if not self.enabled:
-            return False
-
-        if self._redis_available():
-            try:
-                return self._is_limited_redis(key)
-            except Exception:
-                return self._is_limited_memory(key)
-        else:
-            return self._is_limited_memory(key)
-
-    def get_count(self, key: str) -> int:
-        if not self.enabled:
-            return 0
-
-        if self._redis_available():
-            try:
-                return self._get_count_redis(key)
-            except Exception:
-                return self._get_count_memory(key)
-        else:
-            return self._get_count_memory(key)
-
-    def remaining(self, key: str) -> int:
-        used = self.get_count(key)
-        return max(0, self.limit - used)
-
-    def _is_limited_redis(self, key: str) -> bool:
-        now_bucket = self._current_bucket()
-        bucket_key = self._bucket_key(key, now_bucket)
-
-        attempts = self.r.incr(bucket_key)
-        if attempts == 1:
-            self.r.expire(bucket_key, self.window + self.bucket_size)
-
-        # Collect buckets
-        buckets = [
-            self._bucket_key(key, now_bucket - i) for i in range(self.num_buckets + 1)
-        ]
-
-        counts = self.r.mget(buckets)
-        total = sum(int(c) for c in counts if c)
-
-        return total > self.limit
-
-    def _get_count_redis(self, key: str) -> int:
-        now_bucket = self._current_bucket()
-        buckets = [
-            self._bucket_key(key, now_bucket - i) for i in range(self.num_buckets + 1)
-        ]
-        counts = self.r.mget(buckets)
-        return sum(int(c) for c in counts if c)
-
-    def _is_limited_memory(self, key: str) -> bool:
-        now_bucket = self._current_bucket()
-
-        # Init storage
-        if key not in self._memory_store:
-            self._memory_store[key] = {}
-
-        store = self._memory_store[key]
-
-        # Increment bucket
-        store[now_bucket] = store.get(now_bucket, 0) + 1
-
-        # Drop expired buckets
-        min_bucket = now_bucket - self.num_buckets
-        expired = [b for b in store if b < min_bucket]
-        for b in expired:
-            del store[b]
-
-        # Count totals
-        total = sum(store.values())
-        return total > self.limit
-
-    def _get_count_memory(self, key: str) -> int:
-        now_bucket = self._current_bucket()
-        if key not in self._memory_store:
-            return 0
-
-        store = self._memory_store[key]
-        min_bucket = now_bucket - self.num_buckets
-
-        # Remove expired
-        expired = [b for b in store if b < min_bucket]
-        for b in expired:
-            del store[b]
-
-        return sum(store.values())

backend/open_webui/utils/redis.py

@@ -5,13 +5,7 @@ import logging
 
 import redis
 
-from open_webui.env import (
-    REDIS_CLUSTER,
-    REDIS_SENTINEL_HOSTS,
-    REDIS_SENTINEL_MAX_RETRY_COUNT,
-    REDIS_SENTINEL_PORT,
-    REDIS_URL,
-)
+from open_webui.env import REDIS_SENTINEL_MAX_RETRY_COUNT
 
 log = logging.getLogger(__name__)
 
@@ -114,21 +108,6 @@ def parse_redis_service_url(redis_url):
     }
 
 
-def get_redis_client(async_mode=False):
-    try:
-        return get_redis_connection(
-            redis_url=REDIS_URL,
-            redis_sentinels=get_sentinels_from_env(
-                REDIS_SENTINEL_HOSTS, REDIS_SENTINEL_PORT
-            ),
-            redis_cluster=REDIS_CLUSTER,
-            async_mode=async_mode,
-        )
-    except Exception as e:
-        log.debug(f"Failed to get Redis client: {e}")
-        return None
-
-
 def get_redis_connection(
     redis_url,
     redis_sentinels,

backend/open_webui/utils/task.py

@@ -208,21 +208,20 @@ def rag_template(template: str, context: str, query: str):
     if "[query]" in context:
         query_placeholder = "{{QUERY" + str(uuid.uuid4()) + "}}"
         template = template.replace("[query]", query_placeholder)
-        query_placeholders.append((query_placeholder, "[query]"))
+        query_placeholders.append(query_placeholder)
 
     if "{{QUERY}}" in context:
         query_placeholder = "{{QUERY" + str(uuid.uuid4()) + "}}"
         template = template.replace("{{QUERY}}", query_placeholder)
-        query_placeholders.append((query_placeholder, "{{QUERY}}"))
+        query_placeholders.append(query_placeholder)
 
     template = template.replace("[context]", context)
     template = template.replace("{{CONTEXT}}", context)
-
     template = template.replace("[query]", query)
     template = template.replace("{{QUERY}}", query)
 
-    for query_placeholder, original_placeholder in query_placeholders:
-        template = template.replace(query_placeholder, original_placeholder)
+    for query_placeholder in query_placeholders:
+        template = template.replace(query_placeholder, query)
 
     return template
 

backend/open_webui/utils/telemetry/metrics.py

@@ -45,6 +45,7 @@ from open_webui.env import (
     OTEL_METRICS_OTLP_SPAN_EXPORTER,
     OTEL_METRICS_EXPORTER_OTLP_INSECURE,
 )
+from open_webui.socket.main import get_active_user_ids
 from open_webui.models.users import Users
 
 _EXPORT_INTERVAL_MILLIS = 10_000  # 10 seconds
@@ -98,9 +99,6 @@ def _build_meter_provider(resource: Resource) -> MeterProvider:
         View(
             instrument_name="webui.users.active",
         ),
-        View(
-            instrument_name="webui.users.active.today",
-        ),
     ]
 
     provider = MeterProvider(
@@ -134,7 +132,7 @@ def setup_metrics(app: FastAPI, resource: Resource) -> None:
     ) -> Sequence[metrics.Observation]:
         return [
             metrics.Observation(
-                value=Users.get_active_user_count(),
+                value=len(get_active_user_ids()),
             )
         ]
 
@@ -161,18 +159,6 @@ def setup_metrics(app: FastAPI, resource: Resource) -> None:
         callbacks=[observe_active_users],
     )
 
-    def observe_users_active_today(
-        options: metrics.CallbackOptions,
-    ) -> Sequence[metrics.Observation]:
-        return [metrics.Observation(value=Users.get_num_users_active_today())]
-
-    meter.create_observable_gauge(
-        name="webui.users.active.today",
-        description="Number of users active since midnight today",
-        unit="users",
-        callbacks=[observe_users_active_today],
-    )
-
     # FastAPI middleware
     @app.middleware("http")
     async def _metrics_middleware(request: Request, call_next):

backend/open_webui/utils/tools.py

@@ -34,7 +34,6 @@ from langchain_core.utils.function_calling import (
 )
 
 
-from open_webui.utils.misc import is_string_allowed
 from open_webui.models.tools import Tools
 from open_webui.models.users import UserModel
 from open_webui.utils.plugin import load_tool_module_by_id
@@ -86,26 +85,9 @@ def get_async_tool_function_and_apply_extra_params(
     update_wrapper(new_function, function)
     new_function.__signature__ = new_sig
 
-    new_function.__function__ = function  # type: ignore
-    new_function.__extra_params__ = extra_params  # type: ignore
-
     return new_function
 
 
-def get_updated_tool_function(function: Callable, extra_params: dict):
-    # Get the original function and merge updated params
-    __function__ = getattr(function, "__function__", None)
-    __extra_params__ = getattr(function, "__extra_params__", None)
-
-    if __function__ is not None and __extra_params__ is not None:
-        return get_async_tool_function_and_apply_extra_params(
-            __function__,
-            {**__extra_params__, **extra_params},
-        )
-
-    return function
-
-
 async def get_tools(
     request: Request, tool_ids: list[str], user: UserModel, extra_params: dict
 ) -> dict[str, dict]:
@@ -150,28 +132,13 @@ async def get_tools(
                     )
 
                     specs = tool_server_data.get("specs", [])
-                    function_name_filter_list = tool_server_connection.get(
-                        "config", {}
-                    ).get("function_name_filter_list", "")
-
-                    if isinstance(function_name_filter_list, str):
-                        function_name_filter_list = function_name_filter_list.split(",")
-
                     for spec in specs:
                         function_name = spec["name"]
-                        if function_name_filter_list:
-                            if not is_string_allowed(
-                                function_name, function_name_filter_list
-                            ):
-                                # Skip this function
-                                continue
 
                         auth_type = tool_server_connection.get("auth_type", "bearer")
 
                         cookies = {}
-                        headers = {
-                            "Content-Type": "application/json",
-                        }
+                        headers = {}
 
                         if auth_type == "bearer":
                             headers["Authorization"] = (
@@ -193,10 +160,7 @@ async def get_tools(
                                     f"Bearer {oauth_token.get('access_token', '')}"
                                 )
 
-                        connection_headers = tool_server_connection.get("headers", None)
-                        if connection_headers and isinstance(connection_headers, dict):
-                            for key, value in connection_headers.items():
-                                headers[key] = value
+                        headers["Content-Type"] = "application/json"
 
                         def make_tool_function(
                             function_name, tool_server_data, headers
@@ -251,16 +215,14 @@ async def get_tools(
                 module, _ = load_tool_module_by_id(tool_id)
                 request.app.state.TOOLS[tool_id] = module
 
-            __user__ = {
-                **extra_params["__user__"],
-            }
+            extra_params["__id__"] = tool_id
 
             # Set valves for the tool
             if hasattr(module, "valves") and hasattr(module, "Valves"):
                 valves = Tools.get_tool_valves_by_id(tool_id) or {}
                 module.valves = module.Valves(**valves)
             if hasattr(module, "UserValves"):
-                __user__["valves"] = module.UserValves(  # type: ignore
+                extra_params["__user__"]["valves"] = module.UserValves(  # type: ignore
                     **Tools.get_user_valves_by_id_and_user_id(tool_id, user.id)
                 )
 
@@ -282,12 +244,7 @@ async def get_tools(
                 function_name = spec["name"]
                 tool_function = getattr(module, function_name)
                 callable = get_async_tool_function_and_apply_extra_params(
-                    tool_function,
-                    {
-                        **extra_params,
-                        "__id__": tool_id,
-                        "__user__": __user__,
-                    },
+                    tool_function, extra_params
                 )
 
                 # TODO: Support Pydantic models as parameters
@@ -587,21 +544,20 @@ async def get_tool_servers(request: Request):
     return tool_servers
 
 
-async def get_tool_server_data(url: str, headers: Optional[dict]) -> Dict[str, Any]:
-    _headers = {
+async def get_tool_server_data(token: str, url: str) -> Dict[str, Any]:
+    headers = {
         "Accept": "application/json",
         "Content-Type": "application/json",
     }
-
-    if headers:
-        _headers.update(headers)
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
 
     error = None
     try:
         timeout = aiohttp.ClientTimeout(total=AIOHTTP_CLIENT_TIMEOUT_TOOL_SERVER_DATA)
         async with aiohttp.ClientSession(timeout=timeout, trust_env=True) as session:
             async with session.get(
-                url, headers=_headers, ssl=AIOHTTP_CLIENT_SESSION_TOOL_SERVER_SSL
+                url, headers=headers, ssl=AIOHTTP_CLIENT_SESSION_TOOL_SERVER_SSL
             ) as response:
                 if response.status != 200:
                     error_body = await response.json()
@@ -671,10 +627,7 @@ async def get_tool_servers_data(servers: List[Dict[str, Any]]) -> List[Dict[str,
                 openapi_path = server.get("path", "openapi.json")
                 spec_url = get_tool_server_url(server_url, openapi_path)
                 # Fetch from URL
-                task = get_tool_server_data(
-                    spec_url,
-                    {"Authorization": f"Bearer {token}"} if token else None,
-                )
+                task = get_tool_server_data(token, spec_url)
             elif spec_type == "json" and server.get("spec", ""):
                 # Use provided JSON spec
                 spec_json = None

backend/open_webui/utils/webhook.py

@@ -51,7 +51,7 @@ async def post_webhook(name: str, url: str, message: str, event_data: dict) -> b
             payload = {**event_data}
 
         log.debug(f"payload: {payload}")
-        async with aiohttp.ClientSession(trust_env=True) as session:
+        async with aiohttp.ClientSession() as session:
             async with session.post(url, json=payload) as r:
                 r_text = await r.text()
                 r.raise_for_status()

backend/requirements-min.txt

@@ -1,51 +0,0 @@
-# Minimal requirements for backend to run
-# WIP: use this as a reference to build a minimal docker image
-
-fastapi==0.123.0
-uvicorn[standard]==0.37.0
-pydantic==2.12.5
-python-multipart==0.0.20
-itsdangerous==2.2.0
-
-python-socketio==5.15.0
-python-jose==3.5.0
-cryptography
-bcrypt==5.0.0
-argon2-cffi==25.1.0
-PyJWT[crypto]==2.10.1
-authlib==1.6.5
-
-requests==2.32.5
-aiohttp==3.12.15
-async-timeout
-aiocache
-aiofiles
-starlette-compress==1.6.1
-httpx[socks,http2,zstd,cli,brotli]==0.28.1
-starsessions[redis]==2.2.1
-
-sqlalchemy==2.0.38
-alembic==1.17.2
-peewee==3.18.3
-peewee-migrate==1.14.3
-
-pycrdt==0.12.25
-redis
-
-APScheduler==3.10.4
-RestrictedPython==8.0
-
-loguru==0.7.3
-asgiref==3.11.0
-
-mcp==1.22.0
-openai
-
-langchain==0.3.27
-langchain-community==0.3.29
-fake-useragent==2.2.0
-
-chromadb==1.1.0
-black==25.11.0
-pydub
-chardet==5.2.0

backend/requirements.txt

@@ -1,11 +1,11 @@
-fastapi==0.123.0
+fastapi==0.118.0
 uvicorn[standard]==0.37.0
-pydantic==2.12.5
+pydantic==2.11.9
 python-multipart==0.0.20
 itsdangerous==2.2.0
 
-python-socketio==5.15.0
-python-jose==3.5.0
+python-socketio==5.13.0
+python-jose==3.4.0
 cryptography
 bcrypt==5.0.0
 argon2-cffi==25.1.0
@@ -17,14 +17,14 @@ aiohttp==3.12.15
 async-timeout
 aiocache
 aiofiles
-starlette-compress==1.6.1
+starlette-compress==1.6.0
 httpx[socks,http2,zstd,cli,brotli]==0.28.1
 starsessions[redis]==2.2.1
 
 sqlalchemy==2.0.38
-alembic==1.17.2
-peewee==3.18.3
-peewee-migrate==1.14.3
+alembic==1.14.0
+peewee==3.18.1
+peewee-migrate==1.12.2
 
 pycrdt==0.12.25
 redis
@@ -33,15 +33,15 @@ APScheduler==3.10.4
 RestrictedPython==8.0
 
 loguru==0.7.3
-asgiref==3.11.0
+asgiref==3.8.1
 
 # AI libraries
 tiktoken
-mcp==1.22.0
+mcp==1.14.1
 
 openai
 anthropic
-google-genai==1.52.0
+google-genai==1.38.0
 google-generativeai==0.8.5
 
 langchain==0.3.27
@@ -49,27 +49,24 @@ langchain-community==0.3.29
 
 fake-useragent==2.2.0
 chromadb==1.1.0
-weaviate-client==4.17.0
 opensearch-py==2.8.0
 
-transformers==4.57.3
-sentence-transformers==5.1.2
+transformers
+sentence-transformers==5.1.1
 accelerate
 pyarrow==20.0.0 # fix: pin pyarrow version to 20 for rpi compatibility #15897
 einops==0.8.1 
 
-ftfy==6.3.1
-chardet==5.2.0
-pypdf==6.4.0
+ftfy==6.2.3
+pypdf==6.0.0
 fpdf2==2.8.2
-pymdown-extensions==10.17.2
+pymdown-extensions==10.14.2
 docx2txt==0.8
 python-pptx==1.0.2
-unstructured==0.18.21
-msoffcrypto-tool==5.4.2
+unstructured==0.16.17
 nltk==3.9.1
-Markdown==3.10
-pypandoc==1.16.2
+Markdown==3.9
+pypandoc==1.15
 pandas==2.2.3
 openpyxl==3.1.5
 pyxlsb==1.0.10
@@ -78,6 +75,7 @@ validators==0.35.0
 psutil
 sentencepiece
 soundfile==0.13.1
+azure-ai-documentintelligence==1.0.2
 
 pillow==11.3.0
 opencv-python-headless==4.11.0.86
@@ -87,37 +85,36 @@ rank-bm25==0.2.2
 onnxruntime==1.20.1
 faster-whisper==1.1.1
 
-black==25.11.0
+
+black==25.9.0
 youtube-transcript-api==1.2.2
 pytube==15.0.0
 
 pydub
-ddgs==9.9.2
-
-azure-ai-documentintelligence==1.0.2
-azure-identity==1.25.0
-azure-storage-blob==12.24.1
-azure-search-documents==11.6.0
+ddgs==9.0.0
 
 ## Google Drive
 google-api-python-client
 google-auth-httplib2
 google-auth-oauthlib
 
-googleapis-common-protos==1.72.0
+googleapis-common-protos==1.70.0
 google-cloud-storage==2.19.0
 
-## Databases
+azure-identity==1.25.0
+azure-storage-blob==12.24.1
+
+
 pymongo
 psycopg2-binary==2.9.10
 pgvector==0.4.1
 
 PyMySQL==1.1.1
-boto3==1.41.5
+boto3==1.40.5
 
-pymilvus==2.6.4
+pymilvus==2.6.2
 qdrant-client==1.14.3
-playwright==1.56.0 # Caution: version must match docker-compose.playwright.yaml
+playwright==1.49.1 # Caution: version must match docker-compose.playwright.yaml
 elasticsearch==9.1.0
 pinecone==6.0.2
 oracledb==3.2.0
@@ -130,23 +127,23 @@ colbert-ai==0.2.21
 ## Tests
 docker~=7.1.0
 pytest~=8.4.1
-pytest-docker~=3.2.5
+pytest-docker~=3.1.1
 
 ## LDAP
 ldap3==2.9.1
 
 ## Firecrawl
-firecrawl-py==4.10.0
+firecrawl-py==1.12.0
 
 ## Trace
-opentelemetry-api==1.38.0
-opentelemetry-sdk==1.38.0
-opentelemetry-exporter-otlp==1.38.0
-opentelemetry-instrumentation==0.59b0
-opentelemetry-instrumentation-fastapi==0.59b0
-opentelemetry-instrumentation-sqlalchemy==0.59b0
-opentelemetry-instrumentation-redis==0.59b0
-opentelemetry-instrumentation-requests==0.59b0
-opentelemetry-instrumentation-logging==0.59b0
-opentelemetry-instrumentation-httpx==0.59b0
-opentelemetry-instrumentation-aiohttp-client==0.59b0
+opentelemetry-api==1.37.0
+opentelemetry-sdk==1.37.0
+opentelemetry-exporter-otlp==1.37.0
+opentelemetry-instrumentation==0.58b0
+opentelemetry-instrumentation-fastapi==0.58b0
+opentelemetry-instrumentation-sqlalchemy==0.58b0
+opentelemetry-instrumentation-redis==0.58b0
+opentelemetry-instrumentation-requests==0.58b0
+opentelemetry-instrumentation-logging==0.58b0
+opentelemetry-instrumentation-httpx==0.58b0
+opentelemetry-instrumentation-aiohttp-client==0.58b0

docker-compose.yaml

@@ -11,6 +11,8 @@ services:
   open-webui:
     build:
       context: .
+      args:
+        OLLAMA_BASE_URL: '/ollama'
       dockerfile: Dockerfile
     image: ghcr.io/open-webui/open-webui:${WEBUI_DOCKER_TAG-main}
     container_name: open-webui

docs/CONTRIBUTING.md

@@ -24,10 +24,6 @@ Noticed something off? Have an idea? Check our [Issues tab](https://github.com/o
 > - **Template Compliance:** Please be aware that failure to follow the provided issue template, or not providing the requested information at all, will likely result in your issue being closed without further consideration. This approach is critical for maintaining the manageability and integrity of issue tracking.
 > - **Detail is Key:** To ensure your issue is understood and can be effectively addressed, it's imperative to include comprehensive details. Descriptions should be clear, including steps to reproduce, expected outcomes, and actual results. Lack of sufficient detail may hinder our ability to resolve your issue.
 
-> [!WARNING]
-> Reporting vulnerabilities is not wanted through Issues!
-> Instead, [use the security reporting functionality](https://github.com/open-webui/open-webui/security) and ensure you comply with the outlined requirements.
-
 ### 🧭 Scope of Support
 
 We've noticed an uptick in issues not directly related to Open WebUI but rather to the environment it's run in, especially Docker setups. While we strive to support Docker deployment, understanding Docker fundamentals is crucial for a smooth experience.
@@ -36,8 +32,6 @@ We've noticed an uptick in issues not directly related to Open WebUI but rather
 
 - **Advanced Configurations**: Setting up reverse proxies for HTTPS and managing Docker deployments requires foundational knowledge. There are numerous online resources available to learn these skills. Ensuring you have this knowledge will greatly enhance your experience with Open WebUI and similar projects.
 
-- **Check the documentation and help improve it**: [Our documentation](https://docs.openwebui.com) has ever growing troubleshooting guides and detailed installation tutorials. Please verify if it is of help to your issue and help expand it by submitting issues and PRs on our [Docs Repository](https://github.com/open-webui/docs).
-
 ## 💡 Contributing
 
 Looking to contribute? Great! Here's how you can help:
@@ -52,15 +46,9 @@ We welcome pull requests. Before submitting one, please:
 4. Write clear, descriptive commit messages.
 5. It's essential to complete your pull request in a timely manner. We move fast, and having PRs hang around too long is not feasible. If you can't get it done within a reasonable time frame, we may have to close it to keep the project moving forward.
 
-> [!NOTE]
-> The Pull Request Template has various requirements outlined. Go through the PR-checklist one by one and ensure you completed all steps before submitting your PR for review (you can open it as draft otherwise!).
-
 ### 📚 Documentation & Tutorials
 
-Help us make Open WebUI more accessible by improving the documentation, writing tutorials, or creating guides on setting up and optimizing the Web UI.
-
-Help expand our documentation by submitting issues and PRs on our [Docs Repository](https://github.com/open-webui/docs).
-We welcome tutorials, guides and other documentation improvements!
+Help us make Open WebUI more accessible by improving documentation, writing tutorials, or creating guides on setting up and optimizing the web UI.
 
 ### 🌐 Translations and Internationalization
 
@@ -74,12 +62,9 @@ To add a new language:
 - Copy the American English translation file(s) (from `en-US` directory in `src/lib/i18n/locale`) to this new directory and update the string values in JSON format according to your language. Make sure to preserve the structure of the JSON object.
 - Add the language code and its respective title to languages file at `src/lib/i18n/locales/languages.json`.
 
-> [!NOTE]
-> When adding new translations, do so in a standalone PR! Feature PRs or PRs fixing a bug should not contain translation updates. Always keep the scope of a PR narrow.
-
 ### 🤔 Questions & Feedback
 
-Got questions or feedback? Join our [Discord community](https://discord.gg/5rJgQTnV4s) or open an issue or discussion. We're here to help!
+Got questions or feedback? Join our [Discord community](https://discord.gg/5rJgQTnV4s) or open an issue. We're here to help!
 
 ## 🙏 Thank You!