Build a real Multi-Agent Wedding Planner with LangChain, Python, OpenAI, Tavily, and Streamlit.
In this video, you'll learn how multi-agent AI systems actually work by building a practical portfolio-ready project step by step; not just theory, not just copy-paste code.
We'll build an AI wedding planning assistant that takes a couple's preferences, budget, location, guest count, style direction, constraints, planning priorities, and cultural details, then turns everything into a client-ready wedding plan.
The project uses a main wedding planner agent that coordinates two research subagents. Those subagents use Tavily web search to collect current venue, vendor, logistics, budget, and market information. Then the main agent synthesizes everything into a complete planning strategy with recommendations, timelines, risks, tradeoffs, and open questions.
By the end, you'll have a full LangChain portfolio project with both a Streamlit app and a CLI version.
🚀 What you'll learn What multi-agent systems are and why they matter How to build agents with LangChain How to connect OpenAI models to LangChain How to create a main agent that delegates work to subagents How to expose subagents as tools How to use Tavily search for live web research How to structure prompts for a real AI planning workflow How to build a Streamlit interface for an AI agent app How to handle API keys with .env, Streamlit secrets, and sidebar inputs How to save generated runs in Streamlit session state How to export AI-generated output as Markdown How to organize a clean AI backend portfolio project
🧠 Project features Multi-Agent Wedding Planner built with LangChain MainWeddingPlannerAgent for final planning and synthesis SubAgent1 and SubAgent2 for delegated web research Tavily search tool for current vendor, venue, logistics, and market data OpenAI model integration through LangChain Streamlit browser app with a polished planning workflow CLI version for testing the agent flow from the terminal Structured wedding brief form Sample brief loader for quick demos OpenAI and Tavily API-key readiness panel Agent-client refresh button Saved-run history Generated plan tab Input brief tab Architecture tab Markdown download button
🧩 What the final plan includes Executive summary Planning concept Venue and vendor research recommendations Budget allocation by category Timeline from now through wedding day Guest experience considerations Risks and tradeoffs Open questions for the couple
⚡ Why this project matters Most AI tutorials stop at one simple chatbot.
This project shows how to build a real agent workflow where one AI agent coordinates other agents, uses tools, performs live research, and produces a structured business-style output.
This is the kind of project you can add to your AI engineering portfolio because it demonstrates: Agent orchestration Tool calling Multi-agent delegation Prompt structuring External API integration Streamlit app development CLI workflow design Environment configuration Practical AI product thinking
If you're learning LangChain, AI agents, backend engineering, or how to build real AI applications in Python, this project is a strong next step after your first beginner agent.
After this project, you can move into more advanced AI engineering topics like MCP, memory, state, context engineering, long-running conversations, human-in-the-loop workflows, specialized subagents, dynamic agent routing, and production-ready agent systems.
Look at this diagram, this is what we will be building today.
But not only that, we will not just be building an amazing AI multi-agent
system that is basically our wedding planner,
but also we will be understanding how agents and sub-agents work together in
linkchain to create an amazing project. By the end of this project not only you
will be having an amazing project to put on your portfolio
that is basically gonna make you stand out on other engineers,
but also you will be understanding how to create different other
projects relying on this blueprint. You're not convinced yet? Let me show
you what we will be building today. This is the application that we will be
building. This is a multi-agent wedding planner.
We can see a lot of information here. All this information basically are
we are gathering data points that our groom and our bride would like to have
in their wedding, including their names, how many guests,
the budget, the currency, and a lot of other details that we will see in this
project. All we have to do then is generate our
wedding plan. And once we hit the button, we will see
multiple agents coming together, working together,
searching the web, doing all the research, and we will see this in detail step by
step to accomplish one goal and one goal only,
the goal that we are giving it, and this goal is to create the
perfect wedding. Let me show you what will happen. I've
skipped a bit just for you to understand because it took
140 seconds, 39 seconds to do this work. Why? Because this is a complete research.
We are doing a complete research, all the agents coming together.
We, for example, set our example what we would like to do,
and here we have a complete step by step on everything that our bride and groom
would like to have. The budget, the scenarios,
the timeline, etc. This is, guys, a perfect, perfect project for you to have on your
portfolio, and if you are new to creating a multi-agent
applications, this is the right place to start.
I hope you are excited to build this project because now we are going to see
the full roadmap to go from zero to hero on this project.
In this project, not only we are going to be copy pasting code now, but we will
also be going into the details. We will be understanding how to study,
what is length chain, project setup, prompt preparation, tool preparation,
agent preparation. We will be making sure that we will see
everything in the CLI, and then at the end we also will be adding UI.
And once everything is done, congratulations, the project is done,
you can add it now to your portfolio and stand out between millions of other
people. If you like what you're seeing here,
welcome to AI Career Lab, the place where we build the future AI
engineers that companies are willing to pay top dollars for.
So make sure to subscribe and not miss any of my videos.
One more thing, if you like what you are seeing here and you would like to
see even more complex projects, please leave a like.
It's the only way for me to know that these topics are interesting for you
guys. With that being said, let's start to
create this amazing project. To study effectively, you need to
understand and go and work with three main important points.
First, I would like to tell you and advise you not to use AI when you are
studying. Guys, you have to think for yourself.
You have to go and it has to be hard for you to find information.
You have to try your best to be able to do something.
If you do not find information directly, please, it's okay, work a little bit
harder, but you will be able to remember that later on. It's the only way.
Do not rely on AI and coding tools to be able to generate your code.
It will not help you and you will not be able to advance and become better AI
engineers. Don't get me wrong, AI tools are really
good and they will come in handy later on once you really
are capable of doing it yourself. Second thing I would like to say,
studying is like a marathon. It's not like a, it's not a sprint.
So take your time and study bit by bit and don't try to rush your studying
process. Go slowly but steady, which means it's
better for you to do one hour a day than doing five hours one day and then
stop. Okay, one tool I would like to suggest
is this tool. This tool basically it's a simple,
I use it in my work, it's a simple timer that basically
you work for 25 minutes and after 25 minutes it will give you a five minute
short break and it will repeat the cycle and after
three or four times it will give you a long break of 15 minutes.
This is a really good tool because it allows you to focus on what you are
doing because if you, if there's something, if your phone
rang you can tell yourself it's okay, I will be catching up with this
notification in 25 minutes. It's okay, it's not the end of the
world. So you can keep up, you can keep your focus
and you can continue working. Great, one more thing I would like to add and it's
the last thing before we start to understand a bit more about the
project. I would like to also tell you
when we are working together, look at what I'm doing.
Understand first what I'm doing and then stop the video, do it yourself and then
do this over and over and over. Why am I
saying this? Do not just copy and paste without thinking.
You need to be thinking, you need to be understanding and you need to be
implementing things that we are doing together on your own.
So you can do this while we are doing it step by step,
you see what I do and then you try to do it for yourself.
If you fail, re-watch and then re-apply. It is important, just don't just copy
paste, copy paste without really understanding.
So understand first and then try to do it yourself
and then obviously sometimes you will have some mistakes but this is the right
thing, this is the good thing, this is the right approach to do it.
Do not just copy paste for no reason and make sure
by the end of this project that you are 100% capable of recreating this project
from scratch on your own. Great, let's start with
understanding what is Lankchain. If you really want to go into the
details of Lankchain, I would suggest for you to watch this
video right here. I have put together a
complete ultimate crash course on Lankchain that will allow you to
understand what we are doing today, going into the details of Lankchain,
going into what is agents, what is models, what is
creating, what is initializing, what is prompting,
all these kind of things are in that Lankchain crash course. I would
highly recommend for you to study it before
moving on this project but if you already have
a bit of the initialization of Lankchain, you have a little bit of knowledge then
it's perfect, you don't really have to go through
that crash course but I would still recommend it if
you think that your knowledge is a bit shaky and once you're done
please come back here because we have an amazing project, you must
finish this one, you will really really like it.
Now that we finished, let's start with setting up our project.
We will start by opening our VS Code. Once we have done
once we opened our VS Code, we are going to go
and actually create our folder. I've created a folder that is called
multi-agent ACL. Once we created our folder, this is
basically the folder where we are going to
put a lot of, basically all of our projects.
We are going to go back to our VS Code and then
a lot of you guys asked me if I can make the VS Code bigger, I hope this
helps and then we are going to go to the folder
and then we are going to select our multi-agent
ACL. ACL stands for AI Career Lab. We are going to close our AI tool
because we don't need it and then we are going to open our
terminal. The first thing we need to do in our
terminal is actually to make sure that we have Python. Perfect, we do have
Python. Next, we will be checking if we have
the pip which is our packet manager and also we will be
checking if we have uv which is the packet manager that I prefer
and we do have it. Once we have it and if you guys don't have it, please just
run this command and you will be able to use the uv as well.
Just make sure that you run this command after that
to see if it's good. Now that it's good, we
are going to initialize our project. Perfect, I just initialized our
project. We have our gitignore Python version, we have our main
project.tom and the readme file. Okay, very good.
I will be also adding our .env and we will also be are going to be
adding this is where we are going to put
our keys, our special keys. We are going to put them here
and then let's put .env here so we make sure that it will never be
added to our github. We need to also create our
virtual environment just like that and then we created our
virtual environment. Perfect, and now we need to
basically activate our virtual environment
and just like that we can see that we are actually now in our activation
virtual environment which is perfect. Now I will be adding
some of the few libraries that we will be using. Of course
there are more that we are going to add
on the way but that's completely fine. It's not a big
deal, it happened. So let's start with
linkchain, openai and
yeah so .env we need to add. Okay, perfect.
The packet manager is making sure that we have the right things.
Now we are going to run uvsync. Very good and our main is here.
It's okay for now, we can just run it to make sure that
our main is running well and hello for multi-agent acr.
Okay, very good. This is a good start. Let's go to our to see openai. Okay, now
let's add the keys. We need the keys so let's do that and we are
going to go to our .env file and inside our .env file
we are going to add two important keys. The first key is going to be openai
api key and the second thing we are putting
taveli. I will explain what is that in a second.
If you watched my previous videos you would understand but if you didn't I
will explain it so don't worry. Openai key is basically the key that
our agents are going to rely on in terms of the model that we are going
to be using and taveli openai key is going to be
the api that allows our agents to use multiple tools
such as the search functionality to the internet.
So we know that we have our model which is our smart model
like openai and we have our agent which is
also going to be relying on our
model but also if the agent would like to do some search
it needs a way to do that and it's going to be
using taveli and the reason why I'm choosing taveli you will see
in a second why I'm choosing that. We are going to go
and we are going to open our openai dashboard and we are going to
create a new key. I'm going to call it
multi-agent I'm going to call it multi-agent ACL
and then I'm going to create our secret key. I'm going to copy this key and make
sure to never share this key with anyone because
this is very important for the sake of this video I'm putting it
but by the end well by the end of this video I'm going to
delete it as well so there's no need for you there's no
need for you guys to try to have it because you're not going to have it
so this is one we did openai key and the second thing we're going to have
sorry API key we are going here as you can see I already use it for other
things and we are going to call it also
multi-agent ACL and if you guys don't have
if you guys don't have any of a dashboard
or the ACL make sure to create accounts it's very very straightforward
just create accounts and then create the API keys
and make sure that you do have money included
for the openai for tavli is a 100% free for the first credit and you
will not use more than that for the things that you need so don't
worry about that for for example for the openai dashboard
I do have I think three dollars or five dollars on
my API key just for the sake of actually
doing my personal project okay this is perfect
and now we are going to add the tavli key okay
now we have the two keys here we do have our environment
okay very good we do have our sync we can see our lock
we can see our project it's very good okay perfect
and now that we finished this part let me just remove this one
I'm gonna go back to my
I'm gonna go back to here and with that being done I'm going to
make sure that we finished this part in a very good way very nice
now let's move to our prompt preparation to move to our prompt preparation we
will come to our project and we will create
prompt.py this is basically where we are going to
so we can use them later on in the future
okay I hope you guys are keeping up with everything I'm making sure
okay I hope you can see very well and also make sure
to like and subscribe once again guys now
let's start by we are going to add two prompts here the first prompt is
going to be wedding planner
agent prompt and the second one is going to be
our user prompt and the the reason why I'm starting with the prompts guys is
because it's the easiest the easiest part and it's good to start
I like to start things from easiest to
hardest because when you do that you accomplish a
lot more than when you do the opposite and you're going to be demotivated
so now I'm going to give it actually
I'm gonna give my agent what I want it to be so I'm gonna tell
it you are an expert in
wedding planning I have prepared the I've actually prepared the
I have actually prepared this prompt so I'm going to
copy paste it here and then explain it to you
and then I also have done the same thing
for here so for the sake of not losing a lot of time
I'm going to read it for you so what are what are we doing we are saying you are
an expert in wedding planning your task is to assist the user in
planning their wedding by providing a recommendation and
suggestion based on their preference and requirements
these are this is this these are the requirements and then we
have put requirements between between two brackets and not brackets
sorry I forgot the name of these and the reason why we did that because
later on we are going to actually be injecting the requirement
inside of our prompt to be able to get what we want because don't forget every
couple is going to have different set of requirements
and then we also are telling our agent that hey you have actually two subagents
that can help you with your task subagent one and subagent two
they are experts in searching the web for information providing relevant
results so we are also telling our agent that
it has two subagents so like two employees
under the agent that will help you in search
and they are an expert in search for information
okay and we will see how these subagents will come to live in a bit
and at the same time we have our user prompt that is basically just telling
our telling our agent please can you help
me with my wedding these are the requirements I provided
okay perfect and just like that we are
really starting to get into the project we have our agent prompt we have our
user prompt very good now we are going to start by
actually having some very interesting things
so let's start by the heart of our project
we have moved now to tool preparation to be able to make sure that our tool is
going to work perfectly and that our agent later on is going to
work also perfectly we need to actually start by making sure
that our model which which we just put the api for which
is our open ai model is working in a very good condition to do that we
are actually going to create models.py so
this is the model basically this is where we are going to actually give
I'm going to call it models that's just in case I add another model later on
and this is basically where we are going to give all our other
files the models so we only need to change the model in one place instead of
changing it multiple times and this is a really good
way of working because we don't have to repeat yourself
it's a very important thing in coding to try not to repeat yourself
to be able to start and make sure our model is working and that
our openai dashboard and account is working
let's start by creating our model so to do that we will start by
getting from linkchain and we are going to do chat models
and then we are going to initializing the chat model
and if you feel that these this information are a bit weird for you
please make sure to check our my linkchain crash course that is
basically going to details and what is this exactly and then we are
going to get from that and we are going to get our load
once we did our load we are going to run our load to be able to get our key that
we just did and then i'm gonna call it openai
model and then i'm gonna run the init chat model and i'm gonna make
sure that i would like to pick gpt5
nano which is an extremely cheap model to work with
once we do that let's print and then i'm going to actually
do openai model dot invoke and then what is the color
of the sky just to make sure that our model is working
and everything's fine and then i'm gonna call models and then
we'll see if it's gonna be fine it's taking a
little bit of time i hope it's going in the right direction
there's only one way to know it's by getting the response
and we did have a response which is amazing
however the the content that we got back is a bit
there's a lot of information so i'm just going to
put that content here to show you guys uh the actual response that we got and
basically it's just for me i'm just actually selecting the response instead
of having everything and as you can see here it
depends on the time and the condition but usually during the day
it's sky blue orange pink gray and white
etc very good now we know that actually our model
is working we are going to save this and we are moving next to our
tool now that we have our model working we can actually start by creating
our tool and this is basically the tool that our agents are going to use to be
able to do some research if they want to okay we are
going by select tools dot buy
and inside our file we are going to import from lengthchain tools i'm gonna
import tool and then from taveli i'm gonna import
our taveli clients okay it looks like we did not add taveli
so we are going to do that now and then we are going to sync our project
perfect we are going to clear what we have
now our vscode recognize it my client and then i'm gonna import
my load very good and then at the end i'm gonna
import logging because it's gonna be so nice to see what's happening in the cli
once we can actually know oh okay this basically this tool is being used etc
i'm going to configure my logging and then i'm gonna say logging dot
basic configure level logging info this is just telling me okay
give me info and then the format is going to be as follow it's a bit
of it's a bit it's a bit annoying this part but it's okay
this part is best just basically we are configuring how
we would like our logging to look like so don't worry a lot
if you don't really understand this part this is
generally just a preference that i use and then
one more thing message s and then level okay
this is just configuring and now let's do the actual
ai engineering work loading and then family client
is going to be family client and then now we are going to put
our tool annotation to basically tell that this is a tool we are going to
define our function and once again guys if you feel like we
are going too fast please do check our link chain my link chain
video it goes way smoother on this and way
way slower and i would like to keep this project
this video actually for the people who already understand and would like to
create an amazing project so now we created our function and we
put the tool annotation to tell basically this is a tool that we can
later on pass in our link chain agents don't forget
basically we are going to use the annotation to explain what
does this do the web for a given topic
and return the results and one more thing here i would like to
say okay i remember i used to do this
just give me a second
um i don't think so but okay no problem we will continue we'll
continue with that and then here we are going to logging
you remember we got the logging for this exact reason
where we are saying searching the web for topic
and then okay basically whenever an our agent is using our
tool we will be logging it to understand what
is our agent actually searching and this is where it's going to get really really
beautiful because we can see what are sub-agents working
and what is the main agent dedicating to the sub-agents and what are they
searching so we are searching for this topic and
then we return the search basically it's a functionality from tabuli that
will basically run an api call to search the web for a specific topic
and it will return the information about this specific topic
very good now that we have our tool inset we created our tool let's check
the tools that we do have our tools are in check
and let's move to our agent preparations in our agent
we are going to create two different sub-agents
and these agents are basically going to be also used as tools
why because we are going to give our main agent
two sub-agents and we're going to tell it okay use these sub-agents as tools
to do whatever you feel is good to achieve the goal that we are going to
give you which is creating our wedding plan okay so
agents import create agent we are also also from
linkchain.tools import tool from linkchain.messages
import human message from models import openai model this is
basically the one that we created from tools
import search web which is our functionality that
we created also and at the end we're gonna
import logging and we are going to basically do the same thing
so we are going to take configuration of this one
we are going to put it here and then we are going to create our sub-agents now
sub-agents we are going to log.info and we are saying initializing
agent one and then here we are going to say
sub-agent one is going to be create agent the model
that this agent will rely on is exactly the model that we created
model tools we are going to allow it to have the search web tool
and then name we are going to call it sub-agent
one so this is basically the name that this is basically the name
that our main agents will be able to call
this one we are going to copy this and then we are going to change some
new things perfect now we have two sub-agents
and now let's call it tool and this tool basically
is going to be delegating tasks for our agent okay so i will
create and then i will explain it to you
i'm gonna be like delegate sub-agent one and then we are going to give it a
query and then it's going to actually give me
a string back and then it's going to be like search
the web for a given topic by delegating
the task to sub-agent one
to do so and then as usual i would like to be
logging this information to be able to track what is actually
happening behind the scenes going to put an f
string and then we are going to be delegating
query to sub-agent one and this is the query
and then response is going to be a sub-agent one
dot invoke we are going to give it messages and inside of messages we are
going to have an array of messages and we are going to put a human message
and inside the human message we are going to say that the content
is the query at the end we are going to return
the response messages minus one so only defer the last
message i would like to have and then i would like to have the
content of that last message so what are we doing guys we are creating
an agent this agent is based on the model that we created
and it also has a tool that is searching the web then we are creating this tool
this tool is basically to delegate subject to
sub-agent one so whenever our main agent would like to
give a task to another agent it all it has to do
it simply use this tool give the query that what the main agent would like to
search this query then will be given to our
sub-agent by invoking our agent one and telling it that this is what we
would like to know this is what we would like to search
the sub-agent then is going to search using the search web
and give us the respond and this is the content that we will be receiving
and then returning to the main agent to do whatever
he pleases with okay we are going to do the exact same thing
but for sub-agent two and the reason why we are
creating two tools there's basically kind of do the same thing is because
in in a wedding or in an any different project
we might actually be wanting to give an agent just one thing to do at
the time and this will allow our main agent to
know that which topic is coming from which
which agent without really having to have a lot of
things to do itself so all it has to do is to think about the task and if it has
to do any other task we would like to give
the sub-agents to do it so it can just focus on the task that we have
now that we have this we uh let me see what do we have on our here
sub-agent and the main great we have our sub-agents preparation
so it's good to move to our main agent now
very good for our main agent i'm gonna use the main actually
i'm gonna go to main and then here where the magic all the magic is going to
so this is where we are going to create our main agent give our main agent
the prompts and also i'm gonna give it the servants which
are like sub-agents to do whatever it sees
fit okay so first we're gonna get the prompt
so obviously we have wedding planner and user
second from linkchain.agents i'm gonna import create agent
third i'm gonna get some models open ai models and this is the beauty guys of
not having to repeat yourself because whenever at any point i would
like to have multiple models i can simply just come here create the
models that i want if right now i would like all my agents
to be just based on gpt5 i can just remove this and it will work
perfectly i don't need to do hundreds of changes okay this is the
good thing about not repeating yourself this is the right way
to code and now from agents i'm gonna import
delegate to sub-agent one and delegate to sub-agent two these are the two tools
that we created that are based on our sub-agent and then
i'm gonna import logging and then from linkchain
messages i'm gonna import human messages and human messages is basically telling
the agent that this message is coming from a human
for it to do the job not from an ai or not from a system
okay again i'm going to repeat the basic logging configuration and then
here i'm gonna be asking user for their
requirements for their wedding and then i'm gonna be logging the
information and this information i'm gonna be like
telling basically in my cli that we are asking user
for their requirements and then user requirements don't forget
that in our prompts we created a part that we can inject the
requirements we are going to be asking please
enter your requirements and references
for your wedding and then at the end i'm just gonna put
slash n so we can go to the to the line another thing i'm
going to be like i'm going to updating the system prompt
so the system prompt is going to be updated with
updated with a new requirement that we have
and then it's going to be from our wedding planner
format and then inside it we're gonna be
requirements the prompt take the requirement
and then basically just like that okay very good and next i'm gonna
create our main agent and then i'm gonna be logging the
information initializing
main wedding planner agent
and then main wedding
planner agent is going to be create agent the model is going to be
openai model tools are going to be delegate
one delegate two name is going to be
main wedding planner agent
and then i would like my system prompt to be
the updated system prompt very good you see guys how we're creating a
really good very big project in very short amount of
time because we understand how to manipulate
link chain and if you feel like we are going very
fast please double check the link chain course it would really help
you to understand everything we are doing
okay and then at the end invoke main agent so basically we are calling
the main agent we are logging the info again and then
we are saying that we are invoking
main wedding planner agent main wedding planner asian dot invoke
and then we are going to give it uh we are going to give it the
messages the messages and
we are going to give it a list of messages which is a human content and
then the human message and then the content
is going to be basically the user prompt for main okay so we are basically
creating our agent on the model giving it the sub
agents to use how it please giving the system prompt where i'm telling
him okay i would like you to create this beautiful wedding plan and then we
are running the agent by telling it hey user
prompt is like please help me with my wedding
and then it understand that it's a wedding planner okay
very good now just as a last thing we are going to print
the response of the main agent and then
print and planner and then here main wedding planner
and we're gonna get messages and we're gonna get
the last message and only the content of the
okay so let's see if this whole thing is going to work
and then we will explain what happened okay
so we're gonna run python main and then let's see what we will have so
first of all we see that we are initializing some agents
some agents too we are asking for the requirements
and then here we are saying please enter requirement of preference
okay i don't have a preference but i do have a very
small i mean that's not small but a small budget of
10k us dollars i mean it's a definitely not small but
okay so let's remove small a budget of 10k us dollars
okay so we are initializing our wedding planner agents we are invoking our
wedding planner agents see how beautiful it is
it's we are really understanding what's going on behind the scenes
so let's see what's actually going to happen are
is our main agents going to use our sub agents let's see
and we will know in a bit so now okay we do have an issue and the
issue is that so our issue is
with the messages okay very good let's solve that issue
so we are they are saying that main wedding planner messages
content state graph object not subscribable okay very good
oh did we do a mistake did i give the right messages
i did give the right messages i did give human prompt
object is not subscribable okay so make sure that
it is an agent that we created oh okay makes sense makes sense makes
sense it's not it's actually the response of
main agent that we need okay so what happened here guys is that
yes of course the response is not in our agent it's actually in the response of
our agent okay so i'm going to say like this
and then we are going to remove this and then
okay now it should be fine let's run it again
it's a bit uh yes let's give it the same preference
so we did get a nice response however we did not get we did not see
that the sub agents have are being used so
let's see what's going on in here okay so basically after
i've seen after i rerun the same i didn't change anything
but i did change my preference and i realized that our preference
attack it was so small that it didn't really need to delegate any
of the tasks however when i said my preference is
places on the beach we can see that delegating query to sub agents best
and you can see how the agents are working in the background and this is
fascinating guys it's fascinating how these agents are working together
look how sub agents is also searching for wedding venues
and here's wedding destination and at the end we can see that
it got all the things all the things that
from sub agents one and two to come up with
the experience that we have so it's such an amazing project guys
i really hope that you like it because so far everything that we have here
is what you are going to be to be doing as a
ai engineer okay let's go here and actually finish this one and since we
actually added the logins as well so i hope you like it now for the ui
it is not really important for you to finish the ui part
because the ui is simply just for you to see it
but if you are interested i would highly recommend for you
to come to my github and please come and check
my project and you will see here this project that
i'm just explaining to you go to our app and simply copy the whole thing
because it has a lot of streamlit applications and a lot of css
it's not really important for you to showcase that
but it is for sure and nice to have if you are interested
in me showing that please write it in the comments below
i have created multiple projects so far and i didn't
receive any comments saying that someone is interested in actually
learning the the ui part so if it's still the
case perfect i will simply be doing this often
because i think not a lot of people are interested in the ui
so all you have to do is bring the ui copy
and make sure to star my project guys so come here
and make sure you star it okay so i know you've been here
go to our agent we are going to create app.py and then we are going to
our project and then here we are going to say
uv run streamlit app and before we are going to add streamlit
you see guys how we are facing the mistakes we are learning in without
really relying on ai because this is how you learn okay it's
very important we are going to sync our application
and then we are going to try again and here you go
this is the project that i told you about you can simply generate
and it will generate the wedding okay and you will have
exactly what we have in the cli okay guys
let's just put two more here and then finally the project is done you
have created this project right here we are
taking the streamlit the command line apps the wedding requirements
the prompts the wedding agents the wedding agent is delegating to sub
agents the sub agents are using the search web
tools the search web tools are going to the api taverly
we are sharing the openai model between different sub agents between our main
agents we are going we are using the gpt5 nano
the final wedding we are printing it in the cli we are also printing it
in our ui i hope you guys really really enjoyed this project a lot
i if you reach this level then really congratulations
i'm really proud of you i'm really proud of the work you are doing
and this is just the beginning guys i promise you this is just the beginning
you can see here all the api going on in the background
guys this is one of the projects that is really makes you love working with
agents it makes you love working it makes you
really love being an ai engineer i have a lot to teach you i have a lot
to inform you so if you really like it i would really
appreciate the support because if i can see more support i can
probably put more effort into this because it
takes hours and hours just to plan these
projects to make them sure to make sure they are people are interested in these
projects before even going into the details
with that being said i really hope you enjoy it please subscribe
please like and i'll see you on the next one and if you have
any project ideas please leave them in the comments below
have a good one and i'll see you in the next project
happy learning