Files

fujie f882997337 feat(github-copilot-sdk): v0.3.0 - unified tool bridge & dynamic MCP discovery

Major enhancements:
- Zero-config OpenWebUI Tool Bridge: automatically converts WebUI Functions to Copilot-compatible tools
- Dynamic MCP Discovery: seamlessly reads MCP servers from Admin Settings -> Connections
- High-performance async engine with optimized event-driven streaming
- Robust interoperability via dynamic Pydantic model generation
- Simplified token acquisition (web-based PAT only, removed CLI method)
- Updated configuration valves (renamed, removed legacy parameters)
- Comprehensive bilingual documentation sync

2026-02-07 12:36:46 +08:00

2.9 KiB

Raw Blame History

Pipe Plugins

Pipe plugins create custom model integrations or transform LLM responses. They appear as selectable models in the OpenWebUI interface.

What are Pipes?

Pipes allow you to:

:material-api: Connect to external AI APIs (Gemini, Claude, etc.)
:material-robot: Create custom model wrappers
:material-cog-transfer: Transform requests and responses
:material-middleware: Implement middleware logic

Available Pipe Plugins

GitHub Copilot SDK (v0.3.0) - Official GitHub Copilot SDK integration. Features zero-config OpenWebUI Tool Bridge and dynamic MCP discovery. Supports streaming, multimodal, and infinite sessions.

How Pipes Work

graph LR
    A[User selects Pipe as Model] --> B[Pipe receives request]
    B --> C[Transform/Route request]
    C --> D[External API / Custom Logic]
    D --> E[Return response]
    E --> F[Display to User]

The `pipes` Method

Defines what models this pipe provides:

def pipes(self):
    return [
        {"id": "my-model", "name": "My Custom Model"},
        {"id": "my-model-fast", "name": "My Custom Model (Fast)"}
    ]

The `pipe` Method

Handles the actual request processing:

def pipe(self, body: dict) -> Generator:
    # Process the request
    messages = body.get("messages", [])
    
    # Call external API or custom logic
    response = call_external_api(messages)
    
    # Return response (can be streaming)
    return response

Quick Installation

Download the desired pipe .py file
Navigate to Admin Panel → Settings → Functions
Upload the file and configure API keys
The pipe will appear as a selectable model

Development Template

"""
title: My Custom Pipe
author: Your Name
version: 1.0.0
description: Description of your pipe plugin
"""

from pydantic import BaseModel, Field
from typing import Generator, Iterator, Union

class Pipe:
    class Valves(BaseModel):
        API_KEY: str = Field(
            default="",
            description="API key for the external service"
        )
        API_URL: str = Field(
            default="https://api.example.com",
            description="API endpoint URL"
        )
    
    def __init__(self):
        self.valves = self.Valves()
    
    def pipes(self) -> list[dict]:
        """Define available models."""
        return [
            {"id": "my-model", "name": "My Custom Model"},
        ]
    
    def pipe(
        self,
        body: dict
    ) -> Union[str, Generator, Iterator]:
        """Process the request and return response."""
        messages = body.get("messages", [])
        model = body.get("model", "")
        
        # Your logic here
        # Can return:
        # - str: Single response
        # - Generator/Iterator: Streaming response
        
        return "Response from custom pipe"

For more details, check our Plugin Development Guide.

2.9 KiB Raw Blame History