DEV Community: Jérôme Krell

Integrating Langflow into Open WebUI

Jérôme Krell — Thu, 29 May 2025 18:09:22 +0000

Langflow is a brilliant low-code builder that simplifies the creation of AI workflows using any API, model, or database. Open WebUI is a lightweight, extensible interface for working with LLMs like Ollama locally. Combine the two, and you get a supercharged AI assistant that runs your custom workflows through an intuitive chat interface.

This post walks you through a quick proof-of-concept (POC) for connecting Langflow to Open WebUI using its pipeline feature. While it's a basic setup, it’s a solid launchpad for more advanced integrations - and might save others a few hours getting started.

🔗 Tools & References

Langflow – Low-code AI builder
Open WebUI – Chat UI for local LLMs
Open WebUI Pipelines GitHub

1. Docker Setup: All-In-One

Here's the Docker Compose file I used to bring up Langflow, Open WebUI, Pipelines, and PostgreSQL:

services:
  openwebui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    volumes:
      - open-webui:/app/backend/data

  pipelines:
    image: ghcr.io/open-webui/pipelines:main
    ports:
      - "9099:9099"
    volumes:
      - pipelines:/app/pipelines
    restart: always
    environment:
      - PIPELINES_API_KEY=0p3n-w3bu!

  langflow:
    image: langflowai/langflow:latest
    pull_policy: always
    ports:
      - "7860:7860"
    depends_on:
      - postgres
    environment:
      - LANGFLOW_DATABASE_URL=postgresql://langflow:langflow@postgres:5432/langflow
      - LANGFLOW_CONFIG_DIR=app/langflow
    volumes:
      - langflow-data:/app/langflow

  postgres:
    image: postgres:16
    environment:
      POSTGRES_USER: langflow
      POSTGRES_PASSWORD: langflow
      POSTGRES_DB: langflow
    ports:
      - "5432:5432"
    volumes:
      - langflow-postgres:/var/lib/postgresql/data

volumes:
  open-webui: {}
  pipelines: {}
  langflow-postgres: {}
  langflow-data: {}

Once it’s running (docker compose up -d), you can access:

Langflow: http://localhost:7860
Open WebUI: http://localhost:3000

2. Create and Identify Your Workflow in Langflow

Create a basic workflow in Langflow - for example, something that accepts a prompt and outputs a simple chat reply using a model or chain.

📌 Tip: You can grab the workflow_id from Langflow’s deployment example or directly from the UI/project files after creating the flow. This is the ID you’ll reference in the pipeline code.

Example Workflow ID:

b3185asdfb-072e-4easdf-a8aa-31c89f14f073

3. The Pipeline Script

Here’s the quick-and-dirty POC script that connects Open WebUI to your Langflow flow via the Pipelines system. It makes a simple HTTP request to the Langflow API with the user’s prompt.

import os
import time
from datetime import datetime
from logging import getLogger
from typing import Generator, Iterator, List, Union

import httpx
from pydantic import BaseModel, Field

logger = getLogger(__name__)
logger.setLevel("DEBUG")

class Pipeline:
    class Valves(BaseModel):
        LANGFLOW_BASE_URL: str = Field(default="http://host.docker.internal:7860")
        WORKFLOW_ID: str = Field(default="b3185asdfb-072e-4easdf-a8aa-31c89f14f073")
        RATE_LIMIT: int = Field(default=5)

    def __init__(self):
        self.name = "Langflow Pipeline"
        self.valves = self.Valves(**{k: os.getenv(k, v.default) for k, v in self.Valves.model_fields.items()})

    async def on_startup(self): logger.debug(f"on_startup:{self.name}")
    async def on_shutdown(self): logger.debug(f"on_shutdown:{self.name}")

    def rate_check(self, dt_start: datetime):
        diff = (datetime.now() - dt_start).total_seconds()
        buffer = 1 / self.valves.RATE_LIMIT
        if diff < buffer: time.sleep(buffer - diff)

    def pipe(self, user_message: str, model_id: str, messages: List[dict], body: dict) -> Union[str, Generator, Iterator]:
        logger.debug(f"pipe:{self.name}")
        dt_start = datetime.now()
        return "".join([chunk for chunk in self.call_langflow(user_message, dt_start)])

    def call_langflow(self, prompt: str, dt_start: datetime) -> Generator:
        self.rate_check(dt_start)
        url = f"{self.valves.LANGFLOW_BASE_URL}/api/v1/run/{self.valves.WORKFLOW_ID}?stream=false"
        payload = {"input_value": prompt, "output_type": "chat", "input_type": "chat"}
        try:
            with httpx.Client(timeout=30.0) as client:
                response = client.post(url, json=payload)
                response.raise_for_status()
                data = response.json()
                text = (
                    data.get("outputs", [{}])[0]
                        .get("outputs", [{}])[0]
                        .get("results", {})
                        .get("message", {})
                        .get("text", "No text found.")
                )
                yield text
        except Exception as e:
            logger.error(f"Langflow error: {e}")
            yield f"Error: {e}"

4. Hook Up & Restart

Once your pipeline script is in place:

Place it in your mounted pipelines directory.
Edit the environment variables or hardcode your WORKFLOW_ID.
Restart the Pipelines-Container:
Inside Open WebUI make sure your pipelines are connected

5. You should see the "Langflow Pipeline" as selectable model in the new chats.

Results & Takeaways

This pipeline sends any message from the WebUI straight into your Langflow workflow, then relays the response back in the chat - just like a custom plugin would.

⚠️ This is a fast-built POC - basic error handling, no streaming, no caching, and hardcoded workflow IDs. But it's a functional start and can be easily extended.

Final Thoughts

This integration bridges two powerful open-source tools - Langflow and Open WebUI - to create a local-first, highly customizable chatbot with rich workflow logic under the hood.

It’s still early, but if you're experimenting with Langchain-style agents or building LLM-based tooling, this setup is a great sandbox.

The Art of Being an Engineering Manager

Jérôme Krell — Fri, 12 May 2023 19:51:59 +0000

Being an Engineering Manager or a Tech Lead is a strange place to be in. We’re basically trying to smooth out all the roughness against anyone else like CEO, Design, Business, and Users. But most importantly our job is to set up the engineering team for success. I think we all have met some engineering managers who don't think about their way of management at all and much less in a way that is cohesive and conducive towards the growth of their engineers. So let's talk about how management can set up their engineers for success.

Build Trust!

The most important thing you can build as a manager is trust. Almost every decision I make is focused on building trust through the company and with the guys I’m working with. When I’m running a Team it's my job that everyone on the team is bought in and gets what's going on. Everyone needs to feel trusted in the work they’re doing and contributing to.

Reservation of implementation

If anyone on the Team has a strong opinion on how something should be built, this is something we should discuss as a Team. Here it does not matter if you’re a lead developer or a newly hired internal if someone has a strong belief in something that should be done in a different way and they can back it up. Everyone should listen and learn from it. This could go many different ways, they can be right and we all learn from it. They can be wrong and we teach them. Or (and this is underrated) we can know that they’re wrong and fight hard to convince them and…

Let your engineers fail

This is the best thing especially if you know that they’re going to fail and know the consequences of that failure aren’t very big. For example, if you know that some adopted tech from an engineer won't work out early, you can say that but they might not listen. If they don't… let them do it. It shows that you trust them and honestly they might be right and you get to adopt the better solution. Either way, they will build trust and knowledge in that time. So the next time they’re pushing for some new tech or make a recommendation for something to be different, they have that much more experience making decisions around what they push for.

Obviously, I’m not talking here about a guy repeatedly breaking stuff, that's a different conversation.

Freedom to the engineers

Most engineers are not given enough leash, especially when the manager has a technical background. I’m often surprised by how tuned in and dedicated the engineers are which I work with. As managers, we should exactly identify these people and help to build into the people that care more about them, look at these things in their free time, and bring their knowledge to work. These are some of the most valuable ways to grow as an engineer but more importantly, it gives us one of the most valuable resources a Team can have…

Energy

Energy is the single most important thing I’ve seen for every company to thrive. Codebases don't live or die on the Technology choices. They don't live or die on how good the engineers you hire are. It simply boils down to who makes sure that shit moves and whether they have the energy to push through the pain each project goes through.

Sadly it's easy for managers to simply throw all of this away. By just saying no to this energized person because it does not imitate line up with business goals.

There is no business goal, that is not accelerated by a Team that's energized by the work they’re doing. Even if the thing “brings their energy” is going in a different direction from where you want to be. That energy means that you get there, where you want to be way fucking faster. Honestly, I’m thankful that a lot of companies don't get this since this is the only reason why startups can exist in the first place. It's our job as managers to find this person, bringing this energy, and give them everything they need to maintain it and share that with the team. I think everyone should be ready to take some big risks by getting into some fights with the executives in order to keep this energy at all costs.

Wrap up

Even tho I'm still young and a lot of the engineers I work with are more experienced than myself it's important to recognize that. I know that and embrace that to self-improve and keep the grind up. Because feeling dumb for too long actually loses that energy. So keep asking “dumb” questions and maybe force them on any onboarding and be ready to break the onboarding time by a big margin.

I would be really happy to talk more about management and how to improve on being one myself. So if you feel like sharing your know-how and experience either in the comments or directly via Linkedin I’m more than grateful to read them or have a chat.

Bun.sh - A fast all-in-one JavaScript runtime powered by ZIG

Jérôme Krell — Wed, 06 Jul 2022 08:30:16 +0000

Bun is a modern JavaScript runtime like Node or Deno. It was built from scratch to focus on three main things:

Start fast (it has the edge in mind).
New levels of performance (extending JavaScriptCore, the engine).
Being a great and complete tool (bundler, transpiler, package manager).

Bun is designed as a drop-in replacement for your current JavaScript & TypeScript apps or scripts — on your local computer, server or on the edge. Bun natively implements hundreds of Node.js and Web APIs, including ~90% of Node-API functions (native modules), fs, path, Buffer and more.

The goal of Bun is to run most of the worlds JavaScript outside of browsers, bringing performance and complexity enhancements to your future infrastructure, as well as developer productivity through better, simpler tooling.

Also an other cool thing is to see that bun really utilizes Zig. A great place to look at high quality Zig code.

Consume 50% less memory with your Python objects

Jérôme Krell — Mon, 28 Mar 2022 11:11:41 +0000

By default, in Python, objects have a dict attribute.
It's a dictionary used to access the object variables per key.

It is useful to allow dynamic variables' creation.

🚩However this flexibility can lead to creation of new object variables, when misspelled. Python will create a new variable with the given name.

With slots, we can specifically declare data variables.
Then Python will allocate space for them in memory and skip the creation of the dict attribute.

⛔It also forbids the creation of any object's variable which are not declared in the slots attribute.

By using slots, you also decrease the memory used by your class instances.

Slots can also be used in dataclasses if you're using python3.10 or higher. Simply add slots=True to the decorator.

⚡It makes a huge difference if you're creating lots of objects!

from dataclasses import dataclass

# https://pypi.org/project/Pympler/
from pympler.asizeof import asizeof

# Dataclass with slots
@dataclass(frozen=True, slots=True)
class SmallObjectWithDataclass:
    first_name: str
    last_name: str

# Class with slots
class SmallObject:
    __slots__ = ["first_name", "last_name"]

    def __init__(self, first_name, last_name) -> None:
        self.first_name: str = first_name
        self.last_name: str = last_name

# Class with no slots
class BiggerObject:
    def __init__(self, first_name, last_name) -> None:
        self.first_name: str = first_name
        self.last_name: str = last_name


p = SmallObjectWithDataclass("Jerome", "K")
print(asizeof(p))  # Output: 160 Bytes
p2 = SmallObject("Jerome", "K")
print(asizeof(p2))  # Output: 160 Bytes
p3 = BiggerObject("Jerome", "K")
print(asizeof(p3))  # Output: 392 Bytes

🦄Hope this helps and have a great Day
Jerome

Swift 5.3 for Windows

Jérôme Krell — Tue, 15 Dec 2020 12:46:13 +0000

Saleem Abdulrasool released Swift for Windows
https://swift.org/download/

Will you start developing Swift-Projects on Windows?