Every LLM app starts simple. You think

you're building one AI feature and

suddenly you're rebuilding the same

things everyone else does. Prompts rag

tool calls. So the real question isn't

can you build this yourself? It's should

you. Today we're looking at a tool

called Dy and how well it fits with

other LLM tools. Dy isn't trying to beat

Lang Chain at code. It's just playing a

different game. We have videos coming

out all the time. Be sure to subscribe.

Now, this isn't a library like Langchain

or Lambda Index. It's more of like a

platform, but it's open- source for

building apps powered by LLMs. You get a

visual drag and drop canvas to set up

workflows like chaining prompts, doing

rag with custom knowledge bases, and

building agents. And the real reason

people use it is simple. It bundles the

usual platform pieces together in one

place. But the important part isn't what

it has, it's what it stops you from

having to rebuild. The core features

here are you can visually define

multi-step logic, conditionals, tool

calls, branching paths. Then you can

chain steps like flowchart instead of

hand ruling orchestration immediately.

You have rag and knowledge bases. So I

can upload documents and it handles

chunking, indexing and retrieval. Then

you can point the app at your internal

knowledge without building the whole

pipeline first. And this is where

expectations change because the cool

part isn't actually the agents. You can

also swap providers without rewriting

your app logic. It helps you avoid

getting stuck with one provider like

OpenAI, for example. And it's Docker

based. That's a huge part because that

means it's self-hosted. It runs on your

own data. None of this is life-changing

on its own, but the point is it is when

it's bundled together. Now, real quick

before I jump into a demo, you're asking

how is this any different from Lang

Chain or N8N? Well, Langchain and Diifi

both handle LLM chaining agents in Rag.

But here's the differences. With Diifi,

it's visual. You don't need Python

everywhere. But with Langchain, you get

deeper code control for custom memory

and all that other fun stuff. So, the

trade-off basically is speed and visuals

or a more fine grain control. Then with

N8N, this is where people get confused

because they look so similar. I thought

the same. Both are nodebased workflows.

N8N I think has like 600 apps at least

plus a ton of integrations. Both are

free for self-hosting, but the core

difference is the focus. Di is AI first

as it's designed from the ground up for

LLM workflows with a more native support

for advanced rag and advanced agent

patterns like React. So the workflow is

simpler to get down and I found it to be

more friendly. N8N is awesome for

general automations with robust triggers

and integrations, but the AI

capabilities can feel a bit like they're

bolted on, like they were added later,

which is why the setup feels a bit less

userfriendly. So, there's a difference

between these two. Now, in order for

this to work, you will need to get an

API key from the LLM you want to use.

For me, that's OpenAI. So, I went over

to OpenAI's dashboard, got my key, and

then jumped into DIY. From here, I went

to settings and then you choose model

provider. Here you can already see I set

up the config for OpenAI and it has all

these options. Now below is the list of

endless providers you can choose from.

Let's say you want Google Gemini. You

can install it and then you would drop

in the API key here and hit save. We can

then choose this LLM once we are inside

our workflow. All right, quick demo. Now

we're going to build a rag agent to

analyze and summarize different file

types. any type of file. We want to

summarize it. You can get clone their

repo from GitHub and then you're just

going to spin it up with Docker. It's

that simple. This is the main Diifi

dashboard. From here, I'm going to

create from blank. Choose workflow and

name it. I'll choose user input as the

one to start and then I'm going to

configure that and add file as the input

field. Then we can create a branch. If

it's a CSV or PFD, we can extract from

that document. Otherwise, I'm just going

to assume it's an audio file that we can

transcribe. For the documents, we can

add in the document extractor and choose

the file as the input, then link it to

our LLM via OpenAI. I'm going to drop in

some prompt here, give it context to my

text, and then output that. That's the

whole flow. It's that simple. Now, on

the audio side, I can do speech to text

for audio, then pass the text into

another LLM node, then link that to my

output. It's now done. Two different

file types. text files, CSVs or audio.

It's that simple. First, I'm going to

run it on a CSV data set and see what we

get here. See that right here? It

summarizes all the data in the CSV. So,

we know. Then, if I try and upload an

audio file, it's going to summarize and

transcribe that file. I uploaded an MP3

of ML Keys I have a dream speech. This

is the output we get. But here's the

thing. The same thing that makes it fast

can also make it messy. So, while there

are some good pros I like on this, like

self-hosting and mixing and matching

models. That's great. There are some

drawbacks that I didn't like. Now, it

took me longer than I thought to get

this up and running and working. Bit

confusing and it's not as strong as nonI

tasks compared to N8N. There is that

still has the occasional bugs when I was

going through my setup. Got a bunch of

bugs and the self-hosting needs at least

two virtual CPUs and 4 gigs of RAM. So,

what does this mean and should you

automatically use it? Probably not,

maybe not. It depends on what problem

you're trying to solve. Now, if you're a

solo dev or a small team, you can speed

up your MVPs. It's great for that. And

if you're a bigger setup, then you could

save hours of repetitive tasks. Also, a

pretty cool thing here. But boiling it

all down, if you're trying to validate

an idea fast, the difference between

visual flow that works today in custom

platforms that are still halfbuilt next

month, that's everything. Diifi might

fit good when you want visual flows, but

still want hooks for custom integrations

like Forcel or Superbase. This is just a

cool tool that I found useful that I've

been using a bit more of myself, so I

thought it was worth sharing. If you

think this can save you some time or

some dollars, drop a like and give it a

shot. We'll see you in another