All right, so let me now run everything and let me go and run it in debug mode.
So we got a result.
Let's go and check it so we can see.
Now we extracted from structured response.
This is um this is the key here in the results.
And we have here by the way all the messages.
So we have here all the information of of what happened.
So we can really see the flow here.
So first we send the message.
Then the iMessage returned us with a tool call so we can check it out.
We can have here here in the content box we can have here a tool call.
And here interestingly enough we have three tool calls to be made here.
So we invoked the um search for a bunch of times here three times.
Then we go and we have three tool messages.
So we have three tool results.
And we finally go aggregate everything.
And this is what I returned here, which is going to be the structured response.
So we have here the answer.
So this is going to be a string with all the job postings.
Let me show you the sources here.
Right.
So we can see now those are the sources.
Those are the LinkedIn URLs.
Let me go now and continue the run.
And here we simply printed everything.
All right.
So now let me go to transmit here.
And here we have the search agent.
And here we can see now the flow here of the run.
And notice here that here we have lane graph.
So lane graph here is going to be our engine which is going to be running everything.
So it's going to be replacing the agent executor that that we saw here with lane graph primitives.
And we'll be diving very deep into this later in this course.
And because it's going to be using graph now under the hood, it's going to give us the ability to use
the graph debugger, which I'm going to show you in the next video, let's quickly skim the trace.
Now, in contrast to traces that we've seen before, this trace is actually a line graph trace.
So this means it runs in the graph runtime.
Now I'm not going to dive deep into explain any of the graph components here, because we have enough
room to do it later in this course.
I am just wanting to show you what we've already saw in the previous implementation.
I just want to show you the flow here.
And this is a quick introduction and a quick glimpse into the graph trace and the function calling trace
trace which we're going to elaborate on this course in later sections.
So the first call was to open AI.
And notice here we have two tools.
The first tool is the search.
And the second tool is the agent response schema.
So we can see here that the model selected with function calling the tool to be executed to be, to
really search.
And we can see that the output was a bunch of search queries.
So we can see that it wanted to invoke the search.
And it had a bunch of different queries.
The models to tool step here is simply land graph orchestration here, where land Graph now is going
to take every search query and it's going to send it to execute in land graph into different nodes.
Those are primitives in land graphs.
And we're going to be covering that later in this course here.
At this point of the course, I'm not expecting you to know exactly what's happening here.
In each step here of the trace.
You are going to know that later in this course.
Anyways, now we can see that we have here three invocations of the tools.
So those are invocations that are going to run in parallel.
And each one is going to run a different query into villi.
And lastly we have the final call to the model after we have the two results, and the model is going
to decide that it has enough information and it can output us an answer.
And that answer is going to be an agent response object.
So we're going to see that.
Now this is being called as a tool.
And don't worry I will be explaining how everything here is working.
But the tldr of it is that the final response that we're going to be getting is the same agent response
that we got from earlier, but this time it's going to be using function calling under the hood to call
the tool, and also to format us the output as the agent response object.
All right.
So the answer here is going to be here under the structured response here.
And this is going to be an object of agent response that we defined earlier in here popping out.
And I know I'm being pretty vague here in this trace.
And we're not going over it fully.
So we're not going over into every part of this race.
And this is simply because at this point of this course, I think it would be a bit overwhelming introducing
a bunch of landgraaf primitives.
We have plenty of time to learn about landgraaf and diving deep into landgraaf, but before we do that,
we really need to understand how the react algorithm is working underneath the hood.
And this is what we're going to be doing in future sections.
After that, we'll be reviewing function calling, and then it would be the correct time to go and move
into Landgraaf.
So we have a bit of a way to go through here.
And trust me, I know what I'm doing here.
So if you want, you can maybe put a bookmark here on this video and on this trace specifically.
And I promise you that in a couple of sections you will be able to fully read it and understand every
part that's going on here.
So I will be publishing this trace and sharing it in the videos.
Resources.