🚀 A modular collection of tools, function pipes, and filters to supercharge your Open WebUI experience.
Transform your Open WebUI instance into a powerful AI workstation with this comprehensive toolkit. From academic research and image generation to music creation and autonomous agents, this collection provides everything you need to extend your AI capabilities.
✨ What’s Inside
This repository contains 20+ specialized tools and functions designed to enhance your Open WebUI experience:
- arXiv Search - Academic paper discovery (no API key required!)
- Perplexica Search - Web search using Perplexica API with citations
- SerpBase Google Search - Google web search with organic results, featured snippets, and AI Overviews (no self-hosted instance needed)
- Serply Web Search - Google web search results with titles, links, and descriptions via the Serply API
- Pexels Media Search - High-quality photos and videos from Pexels API
- YouTube Search & Embed - Search YouTube and play videos in embedded player
- Xquik X Data Tool - Search and look up X posts, users, timelines, and trends
- OutageDeck Provider Status - Check provider health and incident timelines without an API key
- Native Image Generator - Direct Open WebUI image generation with Ollama model management
- Hugging Face Image Generator - AI-powered image creation
- ComfyUI Image-to-Image (Qwen Edit 2509) - Advanced image editing with multi-image support
- ComfyUI ACE Step 1.5 Audio - Advanced music generation (New)
- ComfyUI ACE Step Audio (Legacy) - Advanced music generation
- ComfyUI Text-to-Video - Generate short videos from text using ComfyUI (default WAN 2.2 workflow)
- Atlas Cloud Media Generator - Multi-modal image generation, image editing, and text/image/audio-to-video using Atlas Cloud AI
- MuAPI Media Generator - Generate images and text/image-to-video outputs through MuAPI
- Flux Kontext ComfyUI - Professional image editing
- OpenWeatherMap Forecast Tool - Interactive weather widget with current conditions and forecasts
- Knowledge Base Manager - Manage knowledge bases, directories, and files directly from chat with nested paths and safe deletions
- 3D Model Viewer - View GLB / glTF models already in Open WebUI in an interactive inline 3D viewer
🔄 Function Pipes
- Planner Agent v3 - Advanced autonomous agent with agentic planning, multi-agent delegation, and real-time visual execution tracking
- arXiv Research MCTS - Advanced research with Monte Carlo Tree Search
- Multi Model Conversations v2 - Multi-agent discussions with interactive UI, tool support, and improved reasoning handling
- Resume Analyzer - Professional resume analysis
- Mopidy Music Controller - Music server management
- Letta Agent - Autonomous agent integration
- Perplexica Pipe - AI-powered web search with streaming responses and citations
- Google Veo Text-to-Video & Image-to-Video - Generate videos from text or a single image using Google Veo (only one image supported as input)
- MiniMax LLM Pipe - Route chat completions to MiniMax’s OpenAI-compatible API with M3.1 Flash (default) and M3 (1M context, image/video input)
🔧 Filters
- Doodle Paint - Toggleable filter that opens a paint canvas before sending each message
- Prompt Enhancer - Automatic prompt improvement
- Semantic Router - Intelligent model selection
- Full Document - File processing capabilities
- Clean Thinking Tags - Conversation cleanup
- OpenRouter WebSearch Citations - Enable web search for OpenRouter models with citation handling
🚀 Quick Start
Option 1: Open WebUI Hub (Recommended)
- Visit https://openwebui.com/u/Haervwe
- Browse the collection and click “Get” for desired tools
- Follow the installation prompts in your Open WebUI instance
Option 2: Manual Installation
- Copy
.py files from tools/, functions/, or filters/ directories
- Navigate to Open WebUI Workspace > Tools/Functions/Filters
- Paste the code, provide a name and description, then save
🎯 Key Features
- 🔌 Plug-and-Play: Most tools work out of the box with minimal configuration
- 🎨 Visual Integration: Seamless integration with ComfyUI workflows
- 🤖 AI-Powered: Advanced features like MCTS research and autonomous planning
- 📚 Academic Focus: arXiv integration for research and academic work
- 🎵 Creative Tools: Music generation and image editing capabilities
- 🔍 Smart Routing: Intelligent model selection and conversation management
- 📄 Document Processing: Full document analysis and resume processing
📋 Prerequisites
- Open WebUI: Version 0.6.0+ recommended
- Python: 3.8 or higher
- Optional Dependencies:
- ComfyUI (for image/music generation tools)
- Mopidy (for music controller)
- Various API keys (Hugging Face, Tavily, etc.)
🔧 Configuration
Most tools are designed to work with minimal configuration. Key configuration areas:
- API Keys: Required for some tools (Hugging Face, Tavily, etc.)
- ComfyUI Integration: For image and music generation tools
- Model Selection: Choose appropriate models for your use case
- Filter Setup: Enable filters in your model configuration
📖 Detailed Documentation
Table of Contents
- arXiv Search Tool
- Perplexica Search Tool
- Pexels Media Search Tool
- YouTube Search & Embed Tool
- Native Image Generator
- Hugging Face Image Generator
- Cloudflare Workers AI Image Generator
- SearxNG Image Search Tool
- ComfyUI Image-to-Image Tool (Qwen Image Edit 2509)
- ComfyUI ACE Step 1.5 Audio Tool
- ComfyUI ACE Step Audio Tool (Legacy)
- ComfyUI Text-to-Video Tool
- Atlas Cloud Media Generator
- MuAPI Media Generator
- OpenWeatherMap Forecast Tool
- Xquik X Data Tool
- OutageDeck Provider Status
- Flux Kontext ComfyUI Pipe
- Google Veo Text-to-Video & Image-to-Video Pipe
- MiniMax LLM Pipe
- Planner Agent v3
- arXiv Research MCTS Pipe
- Multi Model Conversations v2 Pipe
- Resume Analyzer Pipe
- Mopidy Music Controller
- Letta Agent Pipe
- Perplexica Pipe
- OpenRouter Image Pipe
- OpenRouter WebSearch Citations Filter
- Doodle Paint Filter
- Prompt Enhancer Filter
- Semantic Router Filter
- Full Document Filter
- Clean Thinking Tags Filter
- Using the Provided ComfyUI Workflows
- Installation
- Contributing
- License
- Credits
- Support
- SerpBase Google Search Tool
- Serply Web Search Tool
- 3D Model Viewer
Description
Search arXiv.org for relevant academic papers on any topic. No API key required!
Configuration
- No configuration required. Works out of the box.
Usage
-
Example:
Search for recent papers about "tree of thought"
-
Returns up to 5 most relevant papers, sorted by most recent.
Example arXiv search result in Open WebUI
Description
Search the web for factual information, current events, or specific topics using the Perplexica API. This tool provides comprehensive search results with citations and sources, making it ideal for research and information gathering. Perplexica is an open-source AI-powered search engine and alternative to Perplexity AI that must be self-hosted locally. It uses advanced language models to provide accurate, contextual answers with proper source attribution.
Configuration
BASE_URL (str): Base URL for the Perplexica API (default: http://host.docker.internal:3001)OPTIMIZATION_MODE (str): Search optimization mode - “speed” or “balanced” (default: balanced)CHAT_MODEL (str): Default chat model for search processing (default: llama3.1:latest)EMBEDDING_MODEL (str): Default embedding model for search (default: bge-m3:latest)OLLAMA_BASE_URL (str): Base URL for Ollama API (default: http://host.docker.internal:11434)
Prerequisites: You must have Perplexica installed and running locally at the configured URL. Perplexica is a self-hosted open-source search engine that requires Ollama with the specified chat and embedding models. Follow the installation instructions in the Perplexica repository to set up your local instance.
Usage
-
Example:
Search for "latest developments in AI safety research 2024"
-
Returns comprehensive search results with proper citations
-
Automatically emits citations for source tracking in Open WebUI
-
Provides both summary and individual source links
Features
- Web Search Integration: Direct access to current web information
- Citation Support: Automatic citation generation for Open WebUI
- Model Flexibility: Configurable chat and embedding models
- Real-time Status: Progress updates during search execution
- Source Tracking: Individual source citations with metadata
Description
Search and retrieve high-quality photos and videos from the Pexels API. This tool provides access to Pexels’ extensive collection of free stock photos and videos, with comprehensive search capabilities, automatic citation generation, and direct image display in chat. Perfect for finding professional-quality media for presentations, content creation, or creative projects.
Configuration
PEXELS_API_KEY (str): Free Pexels API key from https://www.pexels.com/api/ (required)DEFAULT_PER_PAGE (int): Default number of results per search (default: 5, recommended for LLMs)MAX_RESULTS_PER_PAGE (int): Maximum allowed results per page (default: 15, prevents overwhelming LLMs)DEFAULT_ORIENTATION (str): Default photo orientation - “all”, “landscape”, “portrait”, or “square” (default: “all”)DEFAULT_SIZE (str): Default minimum photo size - “all”, “large” (24MP), “medium” (12MP), or “small” (4MP) (default: “all”)
Prerequisites: Get a free API key from Pexels API and configure it in the tool’s Valves settings.
Usage
-
Photo Search Example:
Search for photos of "modern office workspace"
-
Video Search Example:
Search for videos of "ocean waves at sunset"
-
Curated Photos Example:
Get curated photos from Pexels
Features
- Three Search Functions:
search_photos, search_videos, and get_curated_photos
- Direct Image Display: Images are automatically formatted with markdown for immediate display in chat
- Advanced Filtering: Filter by orientation, size, color, and quality
- Attribution Support: Automatic citation generation with photographer credits
- Rate Limit Handling: Built-in error handling for API limits and invalid keys
- LLM Optimized: Results are limited and formatted to prevent overwhelming language models
- Real-time Status: Progress updates during search execution
Description
Search YouTube for videos and display them in a beautiful embedded player directly in your Open WebUI chat. This tool provides comprehensive YouTube search capabilities with automatic citation generation, detailed video information, and a custom-styled embedded player. Perfect for finding tutorials, music videos, educational content, or any video content you need.
Configuration
YOUTUBE_API_KEY (str): YouTube Data API v3 key from https://console.cloud.google.com/apis/credentials (required)MAX_RESULTS (int): Maximum number of search results to return (default: 5, range: 1-10)SHOW_EMBEDDED_PLAYER (bool): Show embedded YouTube player for the first result (default: True)REGION_CODE (str): Region code for search results, e.g., “US”, “GB”, “JP” (default: “US”)SAFE_SEARCH (str): Safe search filter - “none”, “moderate”, or “strict” (default: “moderate”)
Prerequisites: Get a free YouTube Data API v3 key from Google Cloud Console and enable the YouTube Data API v3 in your project.
Usage
-
Search for Videos:
Search YouTube for "python tutorial for beginners"
-
Play Specific Video:
Play YouTube video dQw4w9WgXcQ
-
Search with Custom Results:
Search YouTube for "cooking recipes" with 10 results
Features
- Two Main Functions:
search_youtube for searching and play_video for playing specific video IDs
- Embedded Player: Beautiful custom-styled YouTube player embedded directly in chat with responsive design
- Safe Search: Built-in content filtering options
- Region Support: Localized search results based on region code
- Direct Links: Provides YouTube links and “Watch on YouTube” buttons
- Rate Limit Handling: Proper error handling for API quota limits
- Real-time Status: Progress updates during search and loading
Getting Started
-
Get a YouTube API Key:
- Visit Google Cloud Console
- Create a new project or select an existing one
- Enable the “YouTube Data API v3”
- Create credentials (API Key)
- Copy the API key
-
Configure the Tool:
- Open the tool’s Valves settings in Open WebUI
- Paste your API key into the
YOUTUBE_API_KEY field
- Adjust other settings as desired (region, max results, etc.)
-
Start Searching:
- Use natural language: “Search YouTube for [topic]”
- Or use the function directly:
search_youtube("topic")
Example of YouTube video embedded in Open WebUI chat
Native Image Generator
Description
Generate images using Open WebUI’s native image generation middleware configured in admin settings. This tool leverages whatever image generation backend you have configured (such as AUTOMATIC1111, ComfyUI, or OpenAI DALL-E) through Open WebUI’s built-in image generation system, with optional Ollama model management to free up VRAM when needed.
Configuration
unload_ollama_models (bool): Whether to unload all Ollama models from VRAM before generating images (default: False)ollama_url (str): Ollama API URL for model management (default: http://host.docker.internal:11434)emit_embeds (bool): Whether to emit HTML image embeds via the embeds event so generated images are displayed inline in the chat (default: True). When False, the tool will skip emitting embeds and only return bare download URLs. If emit_embeds is True but no event emitter is available, images cannot be displayed inline and only the URLs will be returned.
Prerequisites: You must have image generation configured in Open WebUI’s admin settings under Settings > Images. This tool works with any image generation backend you have set up (AUTOMATIC1111, ComfyUI, OpenAI, etc.).
Usage
-
Example:
Generate an image of "a serene mountain landscape at sunset"
-
Uses whatever image generation backend is configured in Open WebUI admin settings
-
Automatically manages model resources if Ollama unloading is enabled
-
Returns markdown-formatted image links for immediate display
Features
- Native Integration: Uses Open WebUI’s native image generation middleware without external dependencies
- Backend Agnostic: Works with any image generation backend configured in admin settings (AUTOMATIC1111, ComfyUI, OpenAI, etc.)
- Memory Management: Optional Ollama model unloading to optimize VRAM usage
- Flexible Model Support: You can prompt de agent to change the image generation model, providing the name is given to it.
- Real-time Status: Provides generation progress updates via event emitter
- Error Handling: Comprehensive error reporting and recovery
Hugging Face Image Generator
Description
Generate high-quality images from text descriptions using Hugging Face’s Stable Diffusion models.
Configuration
- API Key (Required): Obtain a Hugging Face API key from your HuggingFace account and set it in the tool’s configuration in Open WebUI.
- API URL (Optional): Uses Stability AI’s SD 3.5 Turbo model as default. Can be customized to use other HF text-to-image model endpoints.
Usage
-
Example:
Create an image of "beautiful horse running free"
-
Multiple image format options: Square, Landscape, Portrait, etc.
Example image generated with Hugging Face tool
Cloudflare Workers AI Image Generator
Description
Generate images using Cloudflare Workers AI text-to-image models, including FLUX, Stable Diffusion XL, SDXL Lightning, and DreamShaper LCM. This tool provides model-specific prompt preprocessing, parameter optimization, and direct image display in chat. It supports fast and high-quality image generation with minimal configuration.
Configuration
cloudflare_api_token (str): Your Cloudflare API Token (required)cloudflare_account_id (str): Your Cloudflare Account ID (required)default_model (str): Default model to use (e.g., @cf/black-forest-labs/flux-1-schnell)
Prerequisites: Obtain a Cloudflare API Token and Account ID from your Cloudflare dashboard. No additional dependencies beyond requests.
Usage
-
Example:
# Generate an image with a prompt
await tools.generate_image(prompt="A futuristic cityscape at sunset, vibrant colors")
-
Returns a markdown-formatted image link for immediate display in chat.
Features
- Multiple Models: Supports FLUX, SDXL, SDXL Lightning, DreamShaper LCM
- Prompt Optimization: Automatic prompt enhancement for best results per model
- Parameter Handling: Smart handling of steps, guidance, negative prompts, and size
- Direct Image Display: Returns markdown image links for chat
- Error Handling: Comprehensive error and status reporting
- Real-time Status: Progress updates via event emitter
Description
Search and retrieve images from the web using a self-hosted SearxNG instance. This tool provides privacy-respecting, multi-engine image search with direct image display in chat. Ideal for finding diverse images from multiple sources without tracking or ads.
Configuration
SEARXNG_ENGINE_API_BASE_URL (str): The base URL for the SearxNG search engine API (default: http://searxng:4000/search)MAX_RESULTS (int): Maximum number of images to return per search (default: 5)
Prerequisites: You must have a running SearxNG instance. See SearxNG documentation for setup instructions.
Usage
-
Example:
# Search for images of cats
await tools.search_images(query="cats", max_results=3)
-
Returns a list of markdown-formatted image links for immediate display in chat.
Features
- Privacy-Respecting: No tracking, ads, or profiling
- Multi-Engine: Aggregates results from multiple search engines
- Direct Image Display: Images are formatted for chat display
- Customizable: Choose engines, result count, and more
- Error Handling: Handles connection and search errors gracefully
MiniMax Speech Generator
Generate speech from text and play or download the resulting MP3 in chat.
- Copy
tools/minimax_tts_tool.py into Workspace > Tools.
- Set
MINIMAX_API_KEY in the tool valves and select the matching REGION
(global_en or cn_zh).
- Enable the tool in chat and ask it to speak your text (fewer than 10,000 characters).
MODEL defaults to speech-2.8-hd. Set VOICE_ID to a MiniMax voice ID and
adjust SPEED between 0.5 and 2.0 as needed. Users can override the voice and
speed in their own tool settings (UserValves). Requests use synchronous speech
synthesis; the MP3 is saved to Open WebUI file storage (linked to the chat, so it
also plays in shared chats) and shown in an audio player with a download button.
Requires Open WebUI 0.9.0 or newer.
See the MiniMax speech API documentation for supported voices and models.
🔄 Function Pipes
Perplexica Pipe
Description
AI-powered web search using Perplexica with streaming responses, intelligent citations, and comprehensive source tracking. This function pipe integrates with your self-hosted Perplexica instance to provide real-time web search capabilities with proper source attribution, making it perfect for research, fact-checking, and staying up-to-date with current events.
Configuration
enable_perplexica (bool): Enable or disable Perplexica search (default: True)perplexica_api_url (str): Perplexica API endpoint (default: http://localhost:3001/api/search)perplexica_chat_provider (str): Provider ID for chat model (default: 550e8400-e29b-41d4-a716-446655440000)perplexica_chat_model (str): Chat model to use (default: gpt-4o-mini)perplexica_embedding_provider (str): Provider ID for embeddings (default: 550e8400-e29b-41d4-a716-446655440000)perplexica_embedding_model (str): Embedding model to use (default: text-embedding-3-large)perplexica_focus_mode (str): Search focus mode (default: webSearch)perplexica_optimization_mode (str): Optimization mode - “speed” or “balanced” (default: balanced)task_model (str): Model for non-search tasks (default: gpt-4o-mini)max_history_pairs (int): Maximum conversation history pairs to include (default: 12)perplexica_timeout_ms (int): HTTP socket read timeout in milliseconds (default: 1500)
Prerequisites: You must have Perplexica installed and running locally. Perplexica is an open-source AI-powered search engine that requires setup with Ollama or OpenAI-compatible providers.
Usage
-
Example:
Investigate the latest news on AI regulation for different areas US europe , china, etc, do only one tool call
-
Automatically routes search queries to Perplexica
-
Provides streaming responses with real-time updates
-
Emits citations with source metadata for each result
-
Handles conversation history for contextual searches
Features
- Streaming Support: Real-time streaming responses for faster interaction
- Smart Citations: Automatic citation generation with metadata (title, URL, content)
- Conversation History: Maintains context from previous messages (configurable)
- Multiple Focus Modes: webSearch, academicSearch, youtubeSearch, and more
- Status Updates: Real-time progress updates during search
- Source Tracking: Comprehensive source metadata with URLs and snippets
- Task Routing: Intelligent routing between search and non-search tasks
- Error Handling: Robust error handling with user-friendly messages
Getting Started
-
Install Perplexica:
-
Configure the Pipe:
- Open the pipe’s Valves settings in Open WebUI
- Set
perplexica_api_url to your Perplexica instance URL
- Configure your chat and embedding providers/models
- Adjust focus mode and optimization settings as needed
-
Start Searching:
- Select the “Perplexica Pipe” model in Open WebUI
- Ask questions or request web searches
- View results with automatic citations and source links
Example of Perplexica pipe search results with citations in Open WebUI
Description
Edit and transform images using ComfyUI workflows with AI-powered image editing. Features the Qwen Image Edit 2509 model as default, supporting up to 3 images for advanced editing with context, style transfer, and multi-image blending. Also includes Flux Kontext workflow for artistic transformations. Images are automatically extracted from message attachments and rendered as beautiful HTML embeds.
Configuration
comfyui_api_url (str): ComfyUI HTTP API endpoint (default: http://localhost:8188)workflow_type (str): Choose your workflow—“Flux_Kontext”, “QWen_Edit”, or “Custom” (default: QWen_Edit)custom_workflow (Dict): Custom ComfyUI workflow JSON (only used when workflow_type=‘Custom’)max_wait_time (int): Maximum wait time in seconds for job completion (default: 600)unload_ollama_models (bool): Automatically unload Ollama models from VRAM before generating images (default: False)ollama_api_url (str): Ollama API URL for model management (default: http://localhost:11434)return_html_embed (bool): Return a beautiful HTML image embed with comparison view (default: True)
Prerequisites: You must have ComfyUI installed and running with the required models and custom nodes:
- For Flux Kontext: Flux Dev model, Flux Kontext LoRA, and required ComfyUI nodes
- For Qwen Edit 2509: Qwen Image Edit 2509 model, Qwen CLIP, VAE, and ETN_LoadImageBase64 custom node
- See the Extras folder for workflow JSON files:
flux_context_owui_api_v1.json and image_qwen_image_edit_2509_api_owui.json
Usage
Features
- Qwen Edit 2509 (Default): State-of-the-art image editing with precise control and instruction-following
- Multi-Image Support: Qwen Edit workflow accepts 1-3 images for advanced editing with context and style transfer
- Dual Workflow Support: Switch to Flux Kontext for artistic transformations and creative reimagining
- Automatic Image Handling: Images are extracted from messages and passed to the AI automatically
- VRAM Management: Optional Ollama model unloading to free GPU memory before generation
- Beautiful HTML Embeds: Displays results with elegant before/after comparison view
- OpenWebUI Integration: Automatically uploads generated images to OpenWebUI storage
- Flexible Workflows: Use built-in workflows or provide your own custom ComfyUI JSON
Workflow Details
Qwen Edit 2509 (Default):
- Supports 1-3 images with multi-image context and style transfer
- Lightning-fast 4-step generation
- Best for: precise edits, object manipulation, style transfer
Flux Kontext (Alternative):
- Single image input (multi-image support planned)
- 20-step high-quality generation
- Best for: artistic transformations, creative reimagining
Custom Workflow:
- Bring your own ComfyUI workflow JSON
- Full flexibility for advanced users
Getting Started
-
Set up ComfyUI:
- Install ComfyUI
- Download required models (Flux Dev, Qwen Edit 2509, etc.)
- Install necessary custom nodes (especially
ETN_LoadImageBase64 for Qwen workflow)
-
Import workflows:
- Load
Extras/flux_context_owui_api_v1.json or Extras/image_qwen_image_edit_2509_api_owui.json in ComfyUI
- Verify all nodes are recognized (install missing custom nodes if needed)
-
Configure the tool:
- Set
comfyui_api_url to your ComfyUI server address
- Choose your preferred workflow type
- Optionally enable Ollama model unloading if you have limited VRAM
-
Start editing:
- Attach an image (or up to 3 for multi-image editing) to your message
- Describe your desired transformation in natural language
- Watch the magic happen!
Note for Custom Workflows: If you’re using a custom workflow with different capabilities (e.g., single-image only or different prompting requirements), you should modify the edit_image function’s docstring in the tool code. The docstring instructs the AI on how to use the tool and what prompting strategies work best. Adjust it to match your workflow’s specific capabilities and requirements.
Multi-Image Support Status:
- Qwen Edit 2509: Full support for 1-3 images (default workflow)
- Flux Kontext: Single image currently; multi-image support planned for future release
- Custom workflows: Depends on your workflow implementation
Example of Qwen Image Edit 2509 transforming a cyberpunk dolphin into a natural mountain scene
Description
Generate high-quality music using the improved ACE Step 1.5 model via ComfyUI. This tool builds upon the legacy version with enhanced control over musical elements like key, time signature, BPM, and language. It features the same beautiful embedded player and supports batch generation.
Configuration
comfyui_api_url (str): ComfyUI API endpoint (default: http://localhost:8188)model_name (str): ACE Step 1.5 checkpoint name (default: ace_step_1.5_turbo_aio.safetensors)batch_size (int): Number of tracks to generate per request (default: 1)max_duration (int): Maximum song duration in seconds (default: 180)max_number_of_steps (int): Maximum allowed sampling steps (default: 50)max_wait_time (int): Max wait time for generation in seconds (default: 600)workflow_json (str): ComfyUI Workflow JSON (default: ace_step_1.5_workflow)checkpoint_node (str): Node ID for CheckpointLoaderSimple (default: "97")text_encoder_node (str): Node ID for TextEncodeAceStepAudio1.5 (default: "94")empty_latent_node (str): Node ID for EmptyAceStep1.5LatentAudio (default: "98")sampler_node (str): Node ID for KSampler (default: "3")save_node (str): Node ID for SaveAudioMP3 (default: "104")vae_decode_node (str): Node ID for VAEDecodeAudio (default: "18")unload_node (str): Node ID for UnloadAllModels (default: "105")owui_base_url (str): Open WebUI base URL (default: http://localhost:3000)save_local (bool): Save generated audio to local storage (default: True)show_player_embed (bool): Show the embedded audio player (default: True)unload_comfyui_models (bool): Unload models after generation using ComfyUI-Unload-Model node (default: False)
Prerequisites
User Configuration (Per-User Valves)
Users can customize these settings for their individual sessions by clicking the “Valves” icon in the chat interface:
generate_audio_codes (bool): Enable/disable audio code generation. Disabling it (Fast Mode) speeds up generation but may reduce quality (default: True)steps (int): Number of sampling steps for generation. Higher values may improve quality but take longer (default: 8, capped by Admin max_number_of_steps)seed (int): Random seed for generation. Set to -1 for random, or a specific number for reproducible results (default: -1)
Usage
ACE Step 1.5 Audio Player
- Control Key Scale (e.g., “C Major”, “F# Minor”)
- Set Time Signature (e.g., 4/4, 3/4)
- Choose Language (e.g., “en”, “ja”, “zh”)
Features
- New in 1.5: Key scale, time signature, language support, and improved audio quality
- Batch Generation: Generate multiple variations at once
- Embedded Player: Sleek, transparent player with lyrics and waveform visualization
- Customizable: Full control over generation parameters
Description
Generate music using the ACE Step AI model via ComfyUI. This tool lets you create songs from tags and lyrics, with full control over the workflow JSON and node numbers. Features a beautiful, transparent custom audio player with play/pause controls, progress tracking, volume adjustment, and a clean scrollable lyrics display. Designed for advanced music generation and can be customized for different genres and moods.
Configuration
comfyui_api_url (str): ComfyUI API endpoint (e.g., http://localhost:8188)model_name (str): Model checkpoint to use (default: ACE_STEP/ace_step_v1_3.5b.safetensors)workflow_json (str): Full ACE Step workflow JSON as a string. Use {tags}, {lyrics}, and {model_name} as placeholders.tags_node (str): Node number for the tags input (default: "14")lyrics_node (str): Node number for the lyrics input (default: "14")model_node (str): Node number for the model checkpoint input (default: "40")save_local (bool): Copy the generated song to Open WebUI storage backend (default: True)owui_base_url (str): Your Open WebUI base URL (default: http://localhost:3000)show_player_embed (bool): Show the embedded audio player. If false, only returns download link (default: True)
Usage
- Import the ACE Step workflow:
- In ComfyUI, go to the workflow import section and load
extras/ace_step_api.json.
- Adjust nodes as needed for your setup.
- Configure the tool in Open WebUI:
- Set the
comfyui_api_url to your ComfyUI backend.
- Paste the workflow JSON (from the file or your own) into
workflow_json.
- Set the correct node numbers if you modified the workflow.
- Generate music:
- Provide a song title, tags, and (optionally) lyrics.
- The tool will return either an embedded audio player or a download link based on your configuration.
The sleek, transparent audio player embedded in Open WebUI chat
Features
- Custom Audio Player: Beautiful, semi-transparent player with blur effects
- Full Playback Controls: Play/pause, seek, volume control with SVG icons
- Song Title Display: User-defined song titles prominently shown
- Scrollable Lyrics: Clean lyrics display with custom scrollbar (max 120px height)
- Transparent UI: Integrates seamlessly with any Open WebUI theme
- Toggle Player: Option to show/hide player embed and just return download links
- Local Storage: Optionally saves songs to Open WebUI cache for persistence
Returns an embedded audio player with download link or just the link, depending on configuration. Advanced users can fully customize the workflow for different genres, moods, or creative experiments.
ComfyUI Text-to-Video Tool
Description
Generate short videos from text prompts using a ComfyUI workflow that defaults to the WAN 2.2 text-to-video models. This tool wraps the ComfyUI HTTP + WebSocket API, waits for the job to complete, extracts the produced video, and (optionally) uploads it to Open WebUI storage so it can be embedded in chat.
The default workflow file included in this repository is extras/video_wan2_2_14B_t2v.json and the tool implementation lives at tools/text_to_video_comfyui_tool.py.
Configuration
comfyui_api_url (str): ComfyUI HTTP API endpoint (default: http://localhost:8188)prompt_node_id (str): Node ID in the workflow that receives the text prompt (default: "89")workflow (json/dict): ComfyUI workflow JSON; if empty the bundled WAN 2.2 workflow is usedmax_wait_time (int): Maximum seconds to wait for the ComfyUI run (default: 600)unload_ollama_models (bool): Whether to unload Ollama models from VRAM before running (default: False)ollama_api_url (str): Ollama API URL used when unloading models (default: http://localhost:11434)
Usage
- Import the workflow
- In ComfyUI, import the workflow JSON
extras/video_wan2_2_14B_t2v.json if you want to inspect or modify nodes.
- Install / Configure the tool
- Copy
tools/text_to_video_comfyui_tool.py into your Open WebUI tools and set the comfyui_api_url and other valves as needed in the tool settings.
- Generate a video
- Call the tool with a prompt (e.g. “A cyberpunk panda skating through neon streets, 3s shot”) and wait for the job to complete. The tool emits progress events and will provide an embedded HTML player or a direct ComfyUI URL.
Example:
Generate a 3 second shot of "a cyberpunk panda skating through neon city streets" using the default WAN 2.2 workflow
Example short video generated via ComfyUI WAN 2.2 workflow (thumbnail).
Features
- Uses WAN 2.2 text-to-video model workflow by default (
video_wan2_2_14B_t2v.json)
- Submits workflow to ComfyUI and listens on WebSocket for completion
- Extracts produced video files and optionally uploads them to Open WebUI storage for inline embedding
- Optional Ollama VRAM unloading to free memory before runs
- Configurable prompt node and wait timeout
Description
Generate high-quality images, edit images (image-to-image), create videos (text-to-video, image-to-video, audio-to-video) and 3D models (text-to-3D, image-to-3D) directly within Open WebUI chat using Atlas Cloud’s unified API platform. Supports ByteDance’s Seedream (image generation/editing) and Seedance (video generation) model suites, Hunyuan3D / Tripo / Meshy 3D models, inline HTML <video> player and interactive 3D viewer embeds, and user-level model customization.
The implementation lives at tools/atlascloud_media_tool.py.
Configuration
ATLASCLOUD_API_KEY (str): Atlas Cloud API key (Supports per-user override via User Valves)API_BASE_URL (str): Media API Base URL (default: https://api.atlascloud.ai/api/v1)IMAGE_MODEL (str): Default text-to-image model ID (default: bytedance/seedream-v5.0-pro/text-to-image)IMAGE_EDIT_MODEL (str): Default image-editing model ID (default: bytedance/seedream-v5.0-pro/image-to-image)VIDEO_MODEL (str): Default text-to-video model ID (default: bytedance/seedance-2.0-fast/text-to-video)IMAGE_TO_VIDEO_MODEL (str): Default image-to-video model ID (default: bytedance/seedance-2.5/image-to-video)AUDIO_TO_VIDEO_MODEL (str): Default audio-to-video model ID (default: bytedance/seedance-2.5/reference-to-video)TEXT_TO_3D_MODEL (str): Default text-to-3D model ID (default: tencent/hunyuan3d-rapid/text-to-3d)IMAGE_TO_3D_MODEL (str): Default image-to-3D model ID (default: tencent/hunyuan3d-rapid/image-to-3d)ENABLE_PBR_3D (bool): Request PBR materials for 3D models (default: True)FACE_LIMIT_3D (int, optional): Target face count for 3D meshes; clamped to the provider range (Tripo face_limit, Hunyuan3D Pro face_count). Empty = provider defaultMAX_WAIT_3D_SECONDS (float): Maximum seconds to wait for a 3D generation (default: 900.0)POLL_INTERVAL_SECONDS (float): Polling interval for task completion (default: 3.0)GENERATION_TIMEOUT_SECONDS (float): Maximum seconds to wait for generation (default: 600.0)RETURN_HTML_EMBED (bool): Embed the inline image viewer / video player / 3D viewer in chat upon completion (default: True)
User Valves can override the API key and every model ID, including TEXT_TO_3D_MODEL and IMAGE_TO_3D_MODEL.
Supported 3D models
| Family |
Text-to-3D |
Image-to-3D |
Cost tier |
| Hunyuan3D Rapid (default) |
tencent/hunyuan3d-rapid/text-to-3d |
tencent/hunyuan3d-rapid/image-to-3d |
~$0.02 |
| Hunyuan3D Pro |
tencent/hunyuan3d-pro/text-to-3d |
tencent/hunyuan3d-pro/image-to-3d |
~$0.02 |
| Tripo H3.1 |
tripo-h3.1/text-to-3d |
tripo-h3.1/image-to-3d |
~$0.10 |
| Meshy v7 |
meshy-v7/text-to-3d |
meshy-v7/image-to-3d |
~$0.02 |
Other model IDs are rejected. The tool always asks for a GLB mesh and fails clearly if the model returns no GLB.
Text-to-3D on Meshy v7 is sent with mode: "full", which gives a textured mesh; preview would give an untextured one. Atlas Cloud does not document Meshy’s output layout, so the tool picks the GLB defensively from files[] or outputs. Brief status-check failures while polling (HTTP 429/5xx, non-JSON bodies, dropped connections) are retried on the next poll, up to 4 in a row. A long 3D job is not lost to a single gateway hiccup. If polling gives up or times out, the error includes the prediction ID.
Usage
- Install & Configure the Tool
- Copy
tools/atlascloud_media_tool.py into Open WebUI Workspace > Tools.
- Enter your
ATLASCLOUD_API_KEY in the tool Valves.
- Generate Images & Videos in Chat
- Text-to-Image: “Generate an image of a cyberpunk street in rain”
- Image Editing: Attach an image (or use a generated image) and ask “Edit this image to add falling snow”
- Text-to-Video: “Generate a 5-second video of ocean waves crashing at sunset”
- Image-to-Video: Attach an image and ask “Animate this image into a video”
- Audio-to-Video: Attach an audio clip and ask “Create a video matching this music track”
- Text-to-3D: “Make a 3D model of a weathered bronze knight helmet”
- Image-to-3D: Attach an image (or reference a generated one) and ask “Turn this into a 3D model”. Only an image attached to the latest message (or passed as
image_url) switches to image-to-3D; older chat images are ignored. 3D generations take a few minutes.
Text-to-3D with Hunyuan3D Rapid, shown in the inline 3D viewer:
Atlas Cloud video generated from reference image with inline HTML video player in Open WebUI chat
Features
- Multi-modal generation: Text-to-Image, Image Editing, Text-to-Video, Image-to-Video, Audio-to-Video
- Seamless OWUI backend image interoperability (automatically uploads local OWUI backend files or base64 images to Atlas Cloud via
/model/uploadMedia)
- Inline HTML
<video> player embed for immediate video playback in chat
- Interactive 3D viewer for generated GLB models (Google
<model-viewer> 4.4.0, Apache-2.0, loaded from jsDelivr with a pinned version and SRI hash): orbit/zoom camera controls, auto-rotate toggle, shadows and environment lighting, preview-image poster, loading progress bar, fullscreen and GLB download. The GLB and its preview render are stored in Open WebUI (model/gltf-binary, linked to the chat), so provider URLs never reach the chat. When the viewer script or the model cannot load (offline, CSP, or iframe Sandbox Allow Same Origin disabled), the embed shows the preview image and an open/download link instead.
- User Valves support for per-user model customization and personal API keys
- Deduplicated status emissions during polling loop to keep chat notifications clean
Description
Generate images and videos directly in Open WebUI chat through MuAPI’s asynchronous API. The tool supports text-to-image generation with nano-banana, text-to-video generation with seedance-2.5-text-to-video, and image-to-video generation with seedance-2.5-image-to-video.
The implementation lives at tools/muapi_media_tool.py.
Configuration
MUAPI_API_KEY (str): MuAPI API key. It can also be supplied as a per-user User Valve.API_BASE_URL (str): MuAPI API base URL (default: https://api.muapi.ai/api/v1).IMAGE_MODEL (str): Text-to-image endpoint slug (default: nano-banana). Set this to nano-banana-pro to use the Pro image endpoint.VIDEO_MODEL (str): Text-to-video endpoint slug (default: seedance-2.5-text-to-video).IMAGE_TO_VIDEO_MODEL (str): Image-to-video endpoint slug (default: seedance-2.5-image-to-video).POLL_INTERVAL_SECONDS (float): Seconds between result checks (default: 3.0).GENERATION_TIMEOUT_SECONDS (float): Maximum wait for a generation (default: 600.0).RETURN_HTML_EMBED (bool): Return an inline HTML viewer for image and video results (default: True).MAX_DOWNLOAD_MB (int): Maximum size of a single output downloaded into Open WebUI storage (default: 200).ALLOW_PROVIDER_URL_FALLBACK (bool): If saving an output to Open WebUI storage fails, show the MuAPI URL instead of an error (default: False). MuAPI URLs may expire.
Usage
- Install and configure the tool
- Copy
tools/muapi_media_tool.py into Open WebUI Workspace > Tools.
- Enter
MUAPI_API_KEY in the tool Valves.
- Generate media in chat
- Text-to-image: “Generate an image of a quiet mountain lake at sunrise”
- Text-to-video: “Generate a 5-second video of ocean waves at sunset”
- Image-to-video: Attach an image or provide an
image_url, then ask “Animate this image into a video”
Every generated image and video is downloaded into Open WebUI file storage and shown from /api/v1/files/{id}/content, so results stay available after MuAPI’s links expire and they follow Open WebUI access control, including shared chats. MuAPI URLs are not passed to the model. Large videos must fit within Open WebUI’s maximum upload size (rag.file.max_size).
For image-to-video, an image attached in the chat (Open WebUI passes it as a data: URI or an Open WebUI file) is uploaded to MuAPI through its /upload_file endpoint (10 MB limit) and the hosted URL is used. A public HTTP(S) image_url is passed to MuAPI as-is.
Features
- Async submission and polling with status updates in the chat
- Text-to-image, text-to-video, and image-to-video operations
- Per-user API key and model overrides through User Valves
- Outputs stored in Open WebUI and shown in an inline image/video viewer, or as plain file links
- No live request is required during installation; configure the key only when you are ready to generate
API references
Description
Tool that fetches weather forecasts using the OpenWeatherMap API and displays an interactive HTML weather widget with current conditions, hourly, and daily forecasts. Supports both the free 2.5 API and the premium One Call 3.0 API.
Configuration
openweathermap_api_key (str): Your OpenWeatherMap API key (required)api_version (str): API version: ‘2.5’ (free, includes current + 5-day/3h forecast) or ‘3.0’ (One Call API, requires separate subscription) (default: 2.5)units (str): Units of measurement: ‘metric’, ‘imperial’, or ‘standard’ (default: metric)language (str): Language code for weather descriptions (default: en)show_weather_embed (bool): Show the embedded weather widget (default: True)
Usage
-
Example:
What is the weather like in Tokyo, JP?
-
Fetches current conditions, hourly forecast, and multi-day daily forecast
-
Displays an interactive weather widget and returns a text summary for the LLM
Example OpenWeatherMap Forecast Tool widget
Description
Search and look up X posts, users, timelines, and trends through the Xquik API. This tool is read-only and returns structured JSON so Open WebUI models can inspect source text, authors, metrics, pagination fields, and trend metadata.
Configuration
XQUIK_API_KEY (str): Xquik API key for authenticated read requestsBASE_URL (str): Xquik API base URL (default: https://xquik.com/api/v1)DEFAULT_LIMIT (int): Default result limit for list endpoints (default: 10)REQUEST_TIMEOUT_SECONDS (int): Request timeout in seconds (default: 30)
Prerequisites: Create a Xquik API key at xquik.com for authenticated read requests.
Usage
Features
- Post Search: Uses X search operators with Latest or Top ordering
- Post Lookup: Fetches a single post by numeric ID
- User Search: Searches X users by name or username
- User Lookup: Fetches user profile details by ID or username
- User Timelines: Lists recent user posts with optional replies and parent posts
- Trends: Fetches regional X trends by WOEID
- Structured Output: Returns JSON responses for reliable model analysis
OutageDeck Provider Status
Description
Check current provider and service health, find active incidents, and inspect incident update timelines through the public OutageDeck API. The tool is read-only, requires no API key, and includes source freshness in provider responses so models can qualify what they report.
Install: Get OutageDeck Provider Status from Open WebUI Community, or copy the tool file into Workspace > Tools.
Configuration
REQUEST_TIMEOUT_SECONDS (int): Request timeout from 5 to 60 seconds (default: 15)MAX_PROVIDER_RESULTS (int): Maximum providers returned by one search (default: 20)MAX_TIMELINE_UPDATES (int): Maximum updates returned for one incident (default: 20)
Prerequisites: None. Public status lookups work without an OutageDeck account or API key.
Usage
-
Check a Provider:
Is GitHub having an outage? Check its services and source freshness.
-
Find Active Incidents:
List active major incidents across the providers OutageDeck monitors.
-
Inspect a Timeline:
Get the update timeline for this OutageDeck incident slug.
Features
- Zero-Key Setup: Uses OutageDeck’s public read-only API without credentials
- Provider Discovery: Searches monitored vendors by name, health, or category
- Component Status: Checks individual services such as GitHub Actions
- Incident Triage: Filters active or resolved incidents by provider and severity
- Update Timelines: Returns bounded incident histories for root-cause context
- Safe Requests: Uses a fixed HTTPS origin, strict slug validation, timeouts, and no redirects
- Bounded Output: Selects the operational fields models need instead of returning oversized payloads
🔄 Function Pipes
Flux Kontext ComfyUI Pipe
Description
A pipe that connects Open WebUI to the Flux Kontext image-to-image editing model through ComfyUI. This integration allows for advanced image editing, style transfers, and other creative transformations using the Flux Kontext workflow. Features an interactive /setup command system for easy configuration by administrators.
Configuration
The pipe includes an interactive setup system that allows administrators to configure all settings through chat commands. Most configuration can be done using the /setup command, which provides an interactive form for easy adjustment of parameters.
Key Configuration Options:
- COMFYUI_ADDRESS: Address of the running ComfyUI server (default:
http://127.0.0.1:8188)
- COMFYUI_WORKFLOW_JSON: The entire ComfyUI workflow in JSON format
- PROMPT_NODE_ID: Node ID for text prompt input (default:
"6")
- IMAGE_NODE_ID: Node ID for Base64 image input (default:
"196")
- KSAMPLER_NODE_ID: Node ID for the sampler node (default:
"194")
- ENHANCE_PROMPT: Enable vision model-based prompt enhancement (default:
False)
- VISION_MODEL_ID: Vision model to use for prompt enhancement
- UNLOAD_OLLAMA_MODELS: Free RAM by unloading Ollama models before generation (default:
False)
- MAX_WAIT_TIME: Maximum wait time for generation in seconds (default:
1200)
- AUTO_CHECK_MODEL_LOADER: Auto-detect model loader type for .safetensors or .gguf (default:
False)
Usage
Initial Setup
-
Import the workflow:
- In ComfyUI, import
extras/flux_context_owui_api_v1.json as a workflow
- Adjust node IDs if you modify the workflow
-
Configure using /setup command (Admin only):
- Type
/setup in the chat to launch the interactive configuration form
- The form will display all current settings with input fields
- Adjust any settings you need to change
- Submit the form to apply and optionally save the configuration
- Settings can be persisted to a backend config file for permanent storage
-
Alternative: Manual configuration:
- Access the pipe’s Valves in Open WebUI’s admin panel
- Set
COMFYUI_ADDRESS to your ComfyUI backend
- Paste the workflow JSON into
COMFYUI_WORKFLOW_JSON
- Configure node IDs and other parameters as needed
Using the Pipe
-
Basic image editing:
- Upload an image to the chat
- Provide a text prompt describing the desired changes
- The pipe processes the image through ComfyUI and returns the edited result
-
Enhanced prompts (optional):
- Enable
ENHANCE_PROMPT in settings
- Set a
VISION_MODEL_ID (e.g., a multimodal model like LLaVA or GPT-4V)
- The vision model will analyze the input image and automatically refine your prompt for better results
-
Memory management:
- Enable
UNLOAD_OLLAMA_MODELS to free RAM before generation
- The default workflow includes a
Clean VRAM node for VRAM management in ComfyUI
Example - Image editing:
Prompt: "Edit this image to look like a medieval fantasy king, preserving facial features."
[Upload image]
Example of Flux Kontext /setup command interface
Example of Flux Kontext image editing output
MiniMax LLM Pipe
Description
Route chat completions to MiniMax’s OpenAI-compatible API (api.minimax.io/v1) directly from Open WebUI. New configurations expose MiniMax-M3.1-Flash first, followed by MiniMax-M3. Both have 1M context and support image and video input. Flash always uses adaptive thinking with configurable effort; M3 supports adaptive or disabled thinking.
Saved ENABLED_MODELS settings and explicit legacy/custom model IDs are preserved. To enable Flash in an existing installation, add MiniMax-M3.1-Flash to ENABLED_MODELS. API availability of legacy/custom IDs depends on your account.
Configuration
MINIMAX_API_KEY (str): Your MiniMax API key (required, get one at https://platform.minimaxi.com)ENABLED_MODELS (list): Which MiniMax models to expose (default: MiniMax-M3.1-Flash, MiniMax-M3); explicitly configured legacy/custom IDs remain selectableSTRIP_THINKING (bool): Strip <think>…</think> blocks from responses (default: True)DEFAULT_TEMPERATURE (float): Default temperature when none is specified, 0.01–1.0 (default: 0.7)THINKING_MODE (str): adaptive or disabled for M3 (default: adaptive); Flash always uses adaptive, and legacy models omit this fieldREASONING_EFFORT (str): Flash thinking depth, low, medium, high, xhigh, or max (default: max); a supported request reasoning_effort overrides the valve. Invalid values fall back to the valve or max
Prerequisites: Get a MiniMax API key from MiniMax Platform.
Usage
- Install the pipe: Copy
functions/minimax_pipe.py into Open WebUI via Workspace > Functions
- Configure: Set your
MINIMAX_API_KEY in the pipe’s Valves settings
- Select model: Choose “MiniMax M3.1 Flash” or “MiniMax M3” from the model dropdown
- Start chatting: The pipe streams responses directly from the MiniMax API
Features
- OpenAI-Compatible Routing: Uses MiniMax’s
/v1/chat/completions endpoint
- Current Models: MiniMax-M3.1-Flash first, followed by MiniMax-M3, both with 1M context
- Multimodal Input: Forwards inline image and video attachments to both current models as
image_url/video_url content parts
- Thinking Controls: Sends the API’s
thinking.type object, with adaptive-only thinking and tunable effort for Flash, and adaptive/disabled thinking for M3
- Streaming: Real-time streamed responses via
chat:message:delta events
- Temperature Clamping: Automatically clamps temperature to MiniMax’s accepted range (0.01–1.0)
- Think-Tag Stripping: Strips
<think>…</think> reasoning blocks from output (configurable)
- Parameter Forwarding: Passes
max_tokens, top_p, and other parameters to the API
Google Veo Text-to-Video & Image-to-Video Pipe
Description
Generate high-quality videos from text prompts or a single image using Google Veo via the Gemini API. This pipe enables advanced video generation capabilities directly from Open WebUI, supporting creative and professional use cases. It supports both text-to-video and image-to-video generation.
Note: Only one image is supported as input at this time. Multi-image input is not available.
Configuration
GOOGLE_API_KEY (str): Google API key for Gemini API access (required)MODEL (str): The Veo model to use for video generation (default: “veo-3.1-generate-preview”)ENHANCE_PROMPT (bool): Use vision model to enhance prompt (default: False)VISION_MODEL_ID (str): Vision model to be used as prompt enhancerENHANCER_SYSTEM_PROMPT (str): System prompt for prompt enhancement processMAX_WAIT_TIME (int): Max wait time for video generation in seconds (default: 1200)
Prerequisites:
- You must have access to the Google Gemini API and a valid API key.
- Only one image is supported as input for image-to-video generation (Gemini API limitation).
Usage
Features
- Text-to-Video: Generate videos from descriptive text prompts
- Image-to-Video: Animate a single image into a video sequence
- High Quality: Leverages Google Veo’s advanced video generation models
- Direct Embedding: Returns markdown-formatted video links for display in chat
- Status Updates: Progress and error reporting during generation
Limitations
- Only one image is supported as input for image-to-video generation (Gemini API limitation)
- Multi-image or video editing features are not available
Example Output
Example of Google Veo video generation output in Open WebUI
Planner Agent v3
Advanced autonomous agent with agentic planning, multi-agent delegation, and real-time visual execution tracking.
The Planner Agent v3 is a state-of-the-art autonomous system designed for Open WebUI. It transforms complex user requests into structured, executable plans, delegating specialized tasks to a fleet of subagents while providing interactive feedback and visual progress updates.
🚀 Key Features
- 🧠 Agentic Planning & Self-Correction: Automatically decomposes high-level goals into a dependency-aware task tree with user-in-the-loop approval and adaptive rescheduling.
- ⚡ Parallel Execution (v15+): Blazing fast performance via concurrent execution of tool calls and subagent tasks using
asyncio.gather. This allows multiple independent tasks to be performed simultaneously.
- 📂 Robust State Persistence: Automatically saves and recovers task states, results, and subagent histories across chat turns via attached JSON files.
- 🔌 Native OWUI Integration:
- User Skills: Automatically resolves and injects available skills for the model (Planner and Custom Workspace models) for it to query them.
- Knowledge Bases & RAG: Direct integration with OWUI knowledge bases, notes, and user memory via the
knowledge_agent.
- Custom Functions & Tools: Full support for user-created Python tools, imported tools, and external OpenAPI/DB tools.
- MCP Servers: Extended support for Model Context Protocol (MCP) servers with connection deduplication and resilience.
- Terminal Integration: Full interactive terminal access for shell-based tasks and file management (requires
terminal_agent).
- Native Tool Parity: Intelligently inherits built-in tool capabilities (Web Search, Image Gen, etc.) when specialized subagents are disabled.
- 🌐 Specialized Built-in Subagents:
- Web Search Agent: Autonomous research with source synthesis and citation handling.
- Image Gen Agent: High-quality creation using OWUI’s native image middleware.
- Knowledge Agent: Context-aware RAG from your documents and user memory.
- Code Interpreter Agent: Secure Python execution for data science and automation.
- Terminal Agent: Direct system access for technical task execution.
- 🛠️ MCP Resilience System: Full Model Context Protocol (MCP) support with built-in parallelism patches and connection deduplication to prevent deadlocks.
- 🎭 Interactive UI Modals: Native UI components for
ask_user, give_options, and plan_approval allow the agent to request clarification or confirmation.
- 📊 Visual Execution Tracker: Real-time HTML interface showing live task status (Pending, In-Progress, Completed, Failed).
⚙️ Configuration (Valves)
Model ID & Feature Configuration
- Base Models: Found in Admin Panel > Settings > Models. These are the raw model IDs (e.g.,
qwen2.5:7b, gpt-4o).
- Essential for:
PLANNER_MODEL (Mandatory).
- Fallback Support:
REVIEW_MODEL, TERMINAL_AGENT_MODEL, and all Virtual Agent Models will fallback to the PLANNER_MODEL if left blank. However, if specified, they must be Base Models (not workspace presets).
- Workspace Models (Presets): Found in Workspace > Models. These are custom presets with specific personas and settings.
- Used for:
SUBAGENT_MODELS. This is where you configure specific Knowledge Base access, custom tool features, skills, and specialized system prompts for your subagents.
Parallel Execution (New)
Planner Agent v3 supports parallel execution of tool calls and subagent calls
README 内容过长，已截取前 64 KB。完整内容请前往 GitHub 仓库查看。
评论