Open WebUI Pipelines

Because Pipelines function as a plugin system with arbitrary code execution capabilities, you should follow these security best practices to mitigate risks:

1. Use Trusted Sources: Only fetch and execute Pipelines from sources you trust. Avoid running Pipelines from unknown or untrusted origins.
2. Use Fixed Versions: Rather than always pulling the latest version of a Pipeline, use a specific, audited version to ensure you are running code that has been verified for stability and security.
3. Leverage Sandboxing: Pipelines are executed within a sandboxed environment designed to limit access to system resources and prevent harm to the host system.
4. Code Review: Ensure any custom Pipelines you implement undergo a thorough code review process.
5. Monitor Execution: Continuously monitor Pipeline execution for any suspicious or malicious activity.

If you discover a security issue within the Pipelines system, notify the maintainers immediately. You can report vulnerabilities via:

• A Pull Request to the repository.
• Contacting the team on Discord.

This integration allows you to use LangGraph's stream writer and custom streaming modes within an Open WebUI pipeline. It specifically supports the display of <think> blocks.

To use this integration, you must have the Open WebUI Pipelines environment installed (refer to the official quickstart).

Follow these steps to deploy the LangGraph integration:

1. Upload the pipeline file: Upload langgraph_stream_pipeline.py to your Open WebUI Pipelines instance.
2. Configure the URL: Set up your LangGraph API URL in the pipeline settings.
3. Select the model: In the Open WebUI interface, choose "LangGraph stream" as your model.
4. Install Python dependencies: Navigate to the pipeline directory and install the required packages:

   pip install -r requirements.txt

5. Start the LangGraph API server: Run the example application using uvicorn:

   uvicorn langgraph_example:app --reload

Pipelines of type filter can intercept and modify request/response bodies using inlet and outlet methods.

• inlet: Called before the main processing. It receives the request body and user information, allowing you to modify the input.
• outlet: Called after the main processing. It receives the processed body and user information, allowing you to modify the output.

These are exposed via the following endpoints:

• POST /v1/{pipeline_id}/filter/inlet
• POST /v1/{pipeline_id}/filter/outlet

The start.sh script automatically detects and installs Python dependencies defined within the pipeline files themselves. It looks for a requirements: key inside the first triple-quoted block (""" ... """) of any .py file located in the PIPELINES_DIR.

Example of a compatible pipeline file structure:

"""
requirements: requests, numpy, pandas
"""

class MyPipeline:
    ... 

Pipelines are Python modules loaded from the PIPELINES_DIR. To support dependencies, you can include a requirements string in the module's docstring frontmatter. The loader will automatically install these using pip before loading the module.

Example module structure with requirements:

"""
requirements: requests, numpy
"""

class Pipeline:
    def __init__(self):
        self.valves = MyValves()
    # ... other methods
"""

The PIPELINES_URLS environment variable allows you to automate the retrieval of pipeline files. The script supports three types of URLs:

1. GitHub Blob URLs: (e.g., https://github.com/owner/repo/blob/main/file.py) The script downloads the raw file content.
2. GitHub Tree URLs: (e.g., https://github.com/owner/repo/tree/main/subdir) The script performs a sparse git clone to download only the specified subdirectory.
3. Direct Python Files: (e.g., https://example.com/pipeline.py) The script downloads the file via curl.

URLs should be separated by a semicolon (;).