WEBVTT

00:00.080 --> 00:03.680
Well, I'm so excited to see you back here for week four.

00:03.720 --> 00:04.680
Day one.

00:04.680 --> 00:06.240
It's already week four.

00:06.280 --> 00:06.800
Here we are.

00:06.840 --> 00:12.600
It is Landgraaf week as we really change things up, Landgraaf thinks about the universe differently.

00:12.640 --> 00:18.200
We're going to have a great old time, but it's going to require some different ways of thinking about

00:18.200 --> 00:18.560
things.

00:18.560 --> 00:19.440
But we're going to have fun.

00:19.680 --> 00:22.720
Uh, the project this week is particularly good.

00:22.720 --> 00:27.280
At the end of it, there's something really fun to show you with real business value that I've actually

00:27.320 --> 00:31.960
I've had business value from this already myself from from this project that we built.

00:32.120 --> 00:37.840
Um, but generally I want to say that this week, week four is actually quite a short week because I

00:37.840 --> 00:44.400
feel like we've got deep into OpenAI agents, SDK and crew, and we've done a lot that's covered familiar

00:44.440 --> 00:44.920
ground.

00:44.920 --> 00:50.040
And now the things that we do both actually with Landgraaf and with Autogen, it's going to have a lot

00:50.080 --> 00:50.480
in common.

00:50.480 --> 00:53.560
We're not going to need to go into quite the same amount of detail.

00:53.560 --> 00:59.080
So we'll be moving a bit more briskly through, but I'll be giving you plenty of the briefing and giving

00:59.080 --> 01:04.620
you the ability to go off and build your own projects with Landgraaf if it if it happens to tick the

01:04.620 --> 01:06.140
right boxes for you.

01:06.180 --> 01:07.620
All right, let's get into it.

01:07.620 --> 01:11.660
But before we even get into Landgraaf, I know what you're thinking.

01:11.900 --> 01:12.980
You're confused.

01:13.140 --> 01:18.460
You're confused about Langshan and Landgraaf and maybe also confused about Lange Smith, if you've heard

01:18.460 --> 01:18.900
of that.

01:18.940 --> 01:25.860
It is a trio of products offered by Lange Chain, and you may be unclear about how Landgraaf fits into

01:25.860 --> 01:26.100
it.

01:26.100 --> 01:28.420
And why aren't we going through Lange Chain?

01:28.420 --> 01:33.300
And it would be a great question, and it's one that I intend to clarify for you right now.

01:33.580 --> 01:39.900
Uh, and this this is the Lange chain ecosystem, and I could think of no better way of showing it than

01:39.940 --> 01:42.940
by taking little, little snapshots from their website.

01:43.260 --> 01:44.940
So Lange chain.

01:44.980 --> 01:46.460
Lange chain is where it began.

01:46.460 --> 01:48.940
It's been around for for many years now.

01:49.060 --> 01:54.500
And it was one of the earliest of the abstraction frameworks that that was there.

01:54.540 --> 02:02.580
And its initial kind of raison d'etre was that if you were building very bespoke integrations with different

02:02.670 --> 02:03.510
APIs.

02:03.710 --> 02:04.830
It was painful.

02:05.030 --> 02:07.910
And if you needed to change, say, from using GPT.

02:08.030 --> 02:11.030
To using Claude, you had to redo a lot of work.

02:11.030 --> 02:13.950
And so they had the idea of building abstractions.

02:14.270 --> 02:19.350
Then when it turned out that a lot of people were writing applications, which involved a call to an

02:19.350 --> 02:24.150
LLM, followed by another, followed by another, it sort of turned into this idea of chaining together

02:24.150 --> 02:24.990
your calls.

02:25.190 --> 02:30.190
Um, and, and, you know, Long Chain really took root and became something that's, that's quite advanced

02:30.190 --> 02:36.590
and supports things like rag uh, for people that do my engineering course, we use lang chain for a

02:36.630 --> 02:37.830
Rag implementation.

02:38.190 --> 02:44.870
Uh, it supports things like prompt templates, a sort of higher level construct built on top of, uh,

02:44.870 --> 02:52.230
prompting and supports memory in a very robust way, allowing you to to build memory that you keep in

02:52.230 --> 02:57.350
memory or that you keep in memory, keep it in Ram, or that you persist in a database.

02:57.590 --> 03:00.030
Uh, and it has various memory models.

03:00.230 --> 03:03.230
Uh, I guess not unlike the things that we saw from Crewe.

03:03.590 --> 03:09.090
Uh, but but there's a bit more, uh, stuff to the a few more abstractions and things to learn about.

03:09.130 --> 03:13.170
They also have their own declarative language, LCL as well.

03:13.290 --> 03:17.770
Uh, so there's, there's a, there's a lot of depth to Lang Chain, and it's really building a kind

03:17.770 --> 03:24.610
of engineering discipline around the, the, the art of working with llms and putting some scaffolding

03:24.610 --> 03:31.970
and some, some templates and some, uh, well, solidified code with things like good prompt practices

03:32.130 --> 03:34.330
around calling llms.

03:34.490 --> 03:38.530
And it's been extremely successful, uh, in that regard.

03:38.730 --> 03:42.810
It, it also it allows you to do things like abstract using tools.

03:42.810 --> 03:47.930
And so from that point of view, it does, in fact support building a genetic infrastructure.

03:47.930 --> 03:54.770
So you can use Lang chain and you can use lang chains workflows to build agent platforms.

03:55.090 --> 04:00.730
But it sort of predates the the recent explosion and excitement with, with agents.

04:00.730 --> 04:03.890
And so it's working in a more simplistic level.

04:03.970 --> 04:07.310
It's not their main agent platform offering.

04:07.350 --> 04:13.270
It's more of their glue code for building any application using LMS.

04:13.510 --> 04:18.790
Now, you probably heard me say that I have something of a love hate relationship with Long Chain.

04:18.910 --> 04:24.950
I definitely appreciate its power and the way that with very little code indeed, you can get up and

04:24.950 --> 04:31.630
running with with a lot of functionality like building a Rag pipeline in like four lines of code.

04:32.150 --> 04:36.230
Having said that, I do also see some drawbacks, and it's very similar to the drawbacks I was talking

04:36.230 --> 04:40.470
about with the more, more opinionated aspects of crew.

04:40.630 --> 04:47.110
It's that by signing up for a lot of the abstractions and a lot of the glue code that comes in the box

04:47.110 --> 04:51.870
with long chain, you're signing up for their way of doing things, and you have a bit less visibility

04:51.870 --> 04:54.390
into the actual prompts going on behind the scenes.

04:54.670 --> 04:59.870
And over time, the API's into LMS has become more and more similar.

04:59.910 --> 05:05.110
Anthropic is a little bit of an odd one out, but everybody else has really converged on OpenAI's endpoints

05:05.110 --> 05:06.360
and on their that structure.

05:06.360 --> 05:11.200
And so it's become extremely simple to interact directly with LMS.

05:11.480 --> 05:16.640
And handling memory is something that is also very simple to do yourself, because memory is really

05:16.640 --> 05:20.920
just the JSON blob of the conversations that you've had with the model.

05:20.920 --> 05:23.400
And so you can handle that JSON yourself.

05:23.400 --> 05:25.040
You can persist it as you want.

05:25.040 --> 05:27.280
You can combine memory in different ways.

05:27.320 --> 05:35.720
And so I see in some projects there's less need to sign up for a big ecosystem around, say persisting

05:35.720 --> 05:36.480
memory.

05:36.480 --> 05:38.960
But again there are pros and cons.

05:39.000 --> 05:42.240
There's definitely strong benefits to working with long chain.

05:42.240 --> 05:48.240
And with all of these significant engineering and problems that have already been solved that comes

05:48.240 --> 05:48.920
with it.

05:48.960 --> 05:52.080
Okay, so that's long chain and my mini rant.

05:52.080 --> 05:53.440
Thank you for putting up with that.

05:53.440 --> 05:56.560
Let's go on to talk about what is graph then.

05:56.760 --> 06:02.280
So on the website this is how it's positioned run at scale with graph platform.

06:02.440 --> 06:08.180
And as we'll talk about in a minute, Landgraf platform is actually one of the parts of Landgraaf,

06:08.180 --> 06:13.300
but Landgraaf itself is a bit bigger than that, so it's confusing on the website that they really push

06:13.340 --> 06:15.740
Landgraaf platform in this way.

06:15.740 --> 06:17.780
But let me tell you what I think Landgraaf is.

06:17.780 --> 06:24.740
Landgraaf is a separate offering from the company Lange chain from the same people it.

06:24.780 --> 06:27.540
It actually is independent from Lange chain.

06:27.540 --> 06:33.620
So whilst when you're working with Landgraaf, you can use Lange chain code to actually call LMS and

06:33.620 --> 06:37.300
to do various things with LMS you can do it's optional.

06:37.300 --> 06:42.940
You can really use any framework or you can just call LMS directly with Landgraaf.

06:43.340 --> 06:52.060
Landgraaf is all about a platform that focuses on stability, resiliency, and repeatability in worlds

06:52.060 --> 06:58.540
where you're solving problems that involve a lot of interconnected processes, like an agentic platform.

06:58.780 --> 07:05.140
So it's an abstraction layer that allows you to organize your thinking around a workflow of different

07:05.140 --> 07:07.460
activities that could have feedback loops.

07:07.460 --> 07:10.520
It could have times when humans need to get involved.

07:10.520 --> 07:16.120
It could have moments when you need to keep memory, and it allows you to organize all of that in a

07:16.160 --> 07:22.600
very repeatable and easily monitored and stable and scalable way.

07:22.920 --> 07:29.280
That's what Landgraf is, and the word graph gives some of it away that it's all built around graphs.

07:29.320 --> 07:33.760
Graphs being kind of tree structures of how to think about your workflow.

07:33.920 --> 07:40.640
So it imagines all workflows, anything that you might have going between agents in the form of a tree,

07:40.680 --> 07:46.720
a tree of nodes which are connected together, which represent different things that can happen at different

07:46.720 --> 07:49.000
points in your agentic workflow.

07:49.200 --> 07:55.360
And by thinking of it in this abstract way, and by putting sort of belts and braces around each point

07:55.360 --> 08:02.240
in this graph, they're able to bring stability and resiliency to a world that is a bit unpredictable

08:02.240 --> 08:06.400
and has has, you know, people have resiliency concerns about agentic AI.

08:06.760 --> 08:08.280
So that's really their approach.

08:08.280 --> 08:10.020
That's the problem they're trying to solve.

08:10.020 --> 08:16.580
And you can see if you if you read the detail there that they're saying you use this to design agent

08:16.580 --> 08:22.620
driven user experiences featuring things like human in the loop, multi-agent collaboration, conversation,

08:22.620 --> 08:28.180
history, memory, and what they call time travel, which is all about being able to checkpoint where

08:28.180 --> 08:33.740
you are in the process of being able to step backwards if you need to, to restore where you were as

08:33.740 --> 08:35.060
of at any point in time.

08:35.820 --> 08:42.100
A deploy with tolerant scalability, fault tolerant scalability, meaning that anything can go down

08:42.100 --> 08:43.220
and it will keep running.

08:43.220 --> 08:45.900
And that's a bit of the Landgraf platform thrown in there.

08:46.300 --> 08:48.660
So that's what Landgraf is all about.

08:48.700 --> 08:49.780
It's not related.

08:49.820 --> 08:52.740
It's not necessarily related to Lange chain.

08:52.820 --> 09:01.500
It is a framework for robustly running complex agent workflows, uh, giving you that kind of stability

09:01.500 --> 09:06.580
and monitoring, although I use the word monitoring there, and that was perhaps the wrong word to use

09:06.780 --> 09:07.100
it.

09:07.140 --> 09:12.350
It gives the ability to monitor, but it doesn't actually do the monitoring itself, because Lang Chain

09:12.350 --> 09:17.710
has a third product called Lang Smith, which is their kind of monitoring tooling.

09:17.870 --> 09:19.790
And Landgraf connects with Lang Smith.

09:19.790 --> 09:24.910
So you can use Lang Smith to monitor what's going on in your Lang graph graph.

09:25.110 --> 09:26.870
But Lang Smith is a separate offering.

09:26.870 --> 09:30.990
And Lang Smith can be used when working with lang chain or with Lang graph.

09:30.990 --> 09:32.990
And we will use Lang Smith.

09:32.990 --> 09:36.270
We will use that so that we can see things going on.

09:36.270 --> 09:42.470
And it gives you, as it says here, visibility into your calls and your reasoning to quickly debug

09:42.510 --> 09:43.350
failures.

09:44.190 --> 09:47.950
So that is how the different products line up.

09:48.310 --> 09:53.030
It is a bit confusing because you can use Lang chain to build agent workflows.

09:53.030 --> 09:58.750
It has an abstraction layer over things like tool calling, but Lang Graph is the core offering.

09:58.750 --> 10:05.110
That's the modern offering that's designed to meet the excitement of today's agent AI.

10:05.270 --> 10:11.590
And the particular thing that they're focused on is the kind of scaling in a resilient, robust, repeatable

10:11.590 --> 10:12.030
way.
