Welcome back.
And in this video we're just going to go over a couple of extra pieces of content that we've included
inside of the GitHub repository.
And also in this lesson, I'm not going to go into the specifics of them, because I think they're more
granular topics, and they're probably not going to be used as much when you're building LLM applications,
but it's well worth exploring what these things are.
So there's a concept called advanced branching, which shows you how to do parallel node execution inside
of line graph.
Again, this might be useful for you if you have processes that look a little bit like this.
And you can see in the diagram you've got this node A, which then has the parallelized execution of
steps B and C.
And then those steps get put back into step D.
I do think it's a pretty advanced concept, and I can't really see it being that applicable, but I
thought to include these materials just in case you want to have a look at the other concept that you
may decide to use at some point is building graphs with inside of graphs, and these are called subgraphs.
And you can create subgraphs by basically embedding a graph within another graph.
A common use case for this might be multi-agent teams, where each team tracks its own separate state,
and then you combine those different graphs or teams to create those.
And you can see there's an implementation here where you've got the child graph that's embedded inside
of the parent graph.
But I did want to cover these in granular detail, because if I'm honest with you, I haven't used them
in my day to day consulting work.
And I think you're going to get a lot more value out of the sort of beginner to intermediate line graph
content.
Following on from that, I think the next thing that we need to look at is now that we've covered line
graph extensively, is how we're going to deploy line graph and making sure that we can actually get
this into a suitable product that we can use.