[00:08]
that had been hiding in Earth's atmosphere all along. They called it Argon, a name derived from the Greek word Argos, meaning lazy or inactive, because it barely reacts with other elements. Now, more than 130
[00:23]
years later, Google has given the exact name to one of its powerful AI models. And here's the irony. While the chemical element Argon is famous for doing almost nothing, Google Gemini Argon 4 is designed to tackle some of the most
[00:38]
complicated challenges. Whether we are talking about debugging a code, solving applications, and handling tasks that require multiple steps of reasoning. Google has even used Argon internally to optimize code and improve efficiency of
[00:53]
its data centers. So, how capable is this model when we actually put it to work? And most importantly, how can you start using it in your own projects? And that's what we are going to explore
[01:05]
in today's video. With that being said, I welcome you all to today's video on Gemini Argon 4 at Simply Learn. Now, before you move ahead, here is our First, we're going to look at the introduction to Gemini 4 Argon and look
[01:19]
at its capabilities. Then we are going to set up the API keys, billing, and project. After that, we are going to make first API request. Then we are going to explore the thinking levels like low, medium, and high. After that,
[01:31]
we are going to manage conversations and build a chatbot. And finally, we will try building something. So guys, this tutorial will be hands-on, so watch this ahead, just a quick info guys, if you want to build complete AI applications
[01:45]
and intelligent agents, then Simply Learn offers a advanced executive program in applied generative AI in collaboration with IITM Pravartak Technology of Innovation Hub of IIT Madras with Microsoft as its industry
[01:58]
program that gives you practical experience with over 29 AI tools including LangChain, LangGraph, CrewAI, AutoGen, and Azure AI. You're also going to work through more than 90 hands-on demonstrations and build 10 real-world
[02:12]
AI projects including a capstone one. You'll also get the opportunity to attend 2-day campus immersion at IIT Madras Research Park and learn from the serious about building a career in generative AI and agentic AI, check out
[02:26]
the program through the link in the description box. Now, here is a short quiz to test your knowledge. And the question is, which thinking level you should generally start with when you are using Gemini 4 Argon for simple coding
[02:39]
task? And your options are high, medium, low, or background. Please mention your answers in the comment section below. So, let's get started. So guys, as you can see on my screen, there is amazing game and
[02:52]
it's snowing all around over there and you can just play this game. You have to make sure move in the right direction and uh it seems pretty interesting. All you have to do is you have to clear the
[03:04]
snow. And you have to uh try to avoid uh these uh you know, obstacles because they will be trying to you know, take your life something like that. With that concept, this game is built. And you can see this is a mini
[03:19]
built. And you can see this is a mini game, but uh it's very uh interesting. Anyone who starts playing, especially the kids, they will get hooked to it. Now, what if I told you that I did not build this at all? And this is actually
[03:34]
built by Gemini Argon by itself. Sounds pretty interesting, right? Now, let me close this game and let us come back to the agenda of our today's session. What
[03:46]
exactly is Gemini Argon? Let's try to understand its capabilities because the game which you saw was so interesting and it it it has a beautiful UI and it's a very amazing game if you see. Now, let me show you other things also. For
[04:01]
example, let's try to see this anatomy. So, let it get loaded. So guys, uh let's say if I clicked on skeletal, so it's showing me skeletal all over here. Let's say I want to see the organs.
[04:16]
So, all the organs uh would be shown. Let's say I want to see the nerves. So, you can see the nerves are also shown. So, let's say if I click organs, so you
[04:28]
can see all the organs have started to appear. So, let's say I give it as a rest. So, you can see there's a back option. So, basically it's a human uh anatomy and it's trying to show you various uh sections of the
[04:45]
let's say human body. Now, this is also built by Gemini Argon. Now, there are various use cases if you go to the official website of Gemini. So, you're going to find these interesting examples just to showcase you what is a
[04:59]
capability of Gemini for Argon. So guys, it's Google's newest and smartest AI model. Google built it for hard work, things like tricky coding, math, science, and multi-step task where the model has to plan before it acts. When
[05:14]
you use it in your code, you will call it by its model ID. A model ID is just a short name which tells Google which model you want. And for Argon, we have Gemini for Argon. All in small letters, which we are going to see when we are
[05:28]
trying to use this model. So, you'll type that name in today's demo and definitely you're going to get an idea how to use it in your code. Now, there are four ideas I actually want you to understand before we write any code. The
[05:42]
idea number one is that Argon thinks before it actually answers. It thinks about how you solve a hard math problem. You don't write the answer straightaway. You work it out in your head or on a rough paper first.
[05:56]
Argon does the same thing. And before it gives you a reply, it reasons through a problem quietly. And here is a The part, you can choose how much it thinks. The setting is called thinking level. There are three choices, low, medium, and
[06:10]
high. Low is quick and cheap, high is slow and careful, and medium is the middle. If you don't choose anything, Argon uses the medium mode for you. Next thing which I want to discuss is tokens. That is your idea number two. And what
[06:26]
this is all about? You can think in such a way that AI models don't read text word by word, the way we do. They break text into small pieces called tokens, and token is usually a small part of a word. A short word, that might be one
[06:41]
token. A long word might be two or three token. Now, why this actually matters? Because almost everything in the API is counted in tokens. And how much you can send, and how much it can write back, and how much you should pay, all is
[06:56]
calculated in this way. So, whenever you hear the word token, just think about it as a small piece of text. Idea number three, that is context window. The context window is the model's short-term memory. It is the
[07:10]
total amount of text a model can keep in its mind at one time. For Argon, that is about 1 million tokens, and that is actually a lot. Now, I'll give you a rough idea what I want to say. Means, you can fit several long books in there.
[07:25]
But, here's something to remember. The space is shared. Your question, Argon's thinking, and Argon's answer all have to fit inside that 1 million. So, that's why it's a shared space. Idea number four, that Argon can work in the
[07:41]
background also. Now, that's pretty interesting. Normally, you ask a question and wait for the answer, but some jobs are big. They can take several minutes. For those, you can hand the job to Argon, walk away, and come back later
[07:55]
to collect the result. Well, we are going to do it exactly in our today's tutorial. And one last thing before we move on, using Argon through the API is not free. You need to pay for the tokens you use. Right now, Google has an
[08:09]
introductory price. So, you can see all over here. Let's go to the subscriptions page. And let us try to explore all these pricing. So, here in this for zero you are going to get a Gemini app, access to
[08:24]
a flash elite model, image generation. And here also you're going to get flash model, but Google AI Pro has an Argon. So, you can access Gemini for Argon. It has a pro model. You can still use flash model all
[08:40]
over here. And you're going to get four times higher usage limits. And if you're using Google Flow, Google Search, Google Anti-gravity, Gemini Notebook, if you are integrating Gemini in Docs, emails, or widgets, then definitely you can
[08:57]
access Argon all over there. And the price for that is 1,950 rupees. Kind of pretty interesting as compared to our models. Let's say if you talk about Claude, so you roughly play around 2,300 per month. And similarly,
[09:13]
around 2,300 per month. And similarly, if you're using Chat GPT Sol or Astra, if you're using Chat GPT Sol or Astra, it roughly costs around 2,400 to 500. Plus if you're using API key, it depends on the tokens you are using. So,
[09:26]
remember what I said earlier, tokens are kind of the words. And that is uh the window has a shared space. So, you can fill 1 million tokens. In that 1 million tokens, the Gemini has to think and also answer. So, if you're someone
[09:42]
who is planning to use this and explore how Gemini Argon is actually working, you can get started with this subscription. Now guys, let us go to the subscription. Now guys, let us go to the API page all over here for Google
[09:56]
Gemini. And it's basically I'm using Google AI Studio. And here you will see a key like icon. So, that is your API key. Now, click on create API and key. Now, click on create API and let's say we call it as a demo tutorial.
[10:11]
So, we can just right-click all over here and our API key will be created. Let us wait for some time. So, make sure to copy the API key and paste it somewhere. Keep that API key secured. Do not expose it to anyone because if
[10:27]
somebody has started doing all those things, so you might be paying the price for that and if somebody is doing a very intensive task without your doing a very intensive task without your approval, then that might create some
[10:42]
lot of financial bills, I would say that. So, please use it judiciously. So, let us paste our API key all over here. So, you can store it on a Google Doc and keep it safe. So, this is my API key. Now, we are going to use this API key
[10:58]
Now, we are going to use this API key and we are going to build something. So, that is one of the thing. So, we have got our API key. That's pretty fine. Now, you have to decide what tool you will be using. But before I directly
[11:12]
deep dive into the hands-on session, let me first explain what exactly is an API key. So, if you're unaware about that, so you can think of it as a pass card. When your code talks to Google, it shows this card and Google checks it and says,
[11:28]
"Okay, I know who you are and you can use this model and use its capability in your coding and make sure that you can access this API key from the Google AI
[11:40]
Studio where I showed you the key symbol which directs you toward creating a new API key. Now, one important thing I would like to also say that when you are creating a project, make sure that your key must have billing turn on. If you
[11:56]
have not done that, then you have to understand that Argan is a paid model and it is going to simply refuse your request and you are going to get an error. So, make sure the billing is turned on when you are using the Argan.
[12:08]
Now, let us try to set up our project and I'll use VS code, so I'll have some installed thing already present in my system. So, let's try to open VS code,
[12:21]
and uh I'll try to use JavaScript in this uh given project. So, make sure that you have Node.js installed on your system. So, guys, we'll be making this game using Gemini Argan. This is a pretty
[12:35]
what exactly is happening. So, you can see all over here. This is a car uh racing game, and uh all over here, all you have to do is, guys, uh don't collide with this car cars, otherwise it's going to uh you know, ask you to
[12:51]
replay again. So, let's say I did it multiple times, and this is what exactly happened. So, let us get back to the tutorial, and let's try to do the setup where I'll explain you this is a Node.js based project, and how to set up your
[13:05]
API keys, what kind of folders you need to create, we're going to do that. So, the first command is try to install all the node modules. Make sure you have Node.js installed on your system, and this is npm install. Uh first, make sure
[13:18]
that you use this given command, npm install, so it is going to install all the node modules. Then, create one folder called Argan, and inside this add uh create a file called .env, and generate game.js and racinggame.html.
[13:35]
So, this is empty for now, and here I have added the Gemini API key, just you can use it requiredly all over here. Now, let me show you uh the first phase of the thing, how we are going to set up using this JavaScript
[13:50]
file. So, first you have to import Google GenAI. So, I have already installed this. Let me show you the command to uh install the required thing. So, the given command is npm install Google GenAI. So, it is going to
[14:06]
install that library, and you can see you can use it all the way in your code with the import statement, Google GenAI, all over here. Then uh you have to also
[14:18]
make sure that you have promises installed on your system. Since I don't have it currently, so I will install it. So guys, this is the official package of promise and NPM is the package manager. The given command is NPM I promise. Just
[14:34]
copy paste this, but it's not showing. Okay, all over here. Let's install promise. Now, we can see all over here it's been installed and uh
[14:48]
it's been installed and uh Now guys, I've created uh object of Google Gen AI and let's give this state as AI as a variable. Now, let us declare a variable called const prompt and here we are going to write the prompt. For
[15:02]
example, create a playable car racing game called Neon Rush. Uh game design 3D styling game, third-person camera behind the red sports car, neon city highway at night, 3D lane road, moving traffic, smooth driving animations. So, you can
[15:16]
smooth driving animations. So, you can give your uh requirements uh based on this all over here in this prompt, whatever you want in the game. And make sure to give by the given dash sign. Now, here is a gameplay. Uh player
[15:28]
control the car, avoid oncoming traffic. Uh three lives, collision detection, score counter, increasing speed. So, these are the required gameplay that I have added. Now, here are the required controls. Uh left arrow A, right arrow
[15:44]
D, up arrow, down arrow, all those things. And believe me, if you are facing difficulty, just go to the chat GPT to give you the required prompt. Or you can go to Gemini also and it is going to give you these requirement.
[15:57]
But, let's say if you are little bit customizing your project, so I would suggest you based on your uh gaming experience, you can add uh all these required things. So, very basic controls. Now, what are the technical
[16:11]
requirement? Complete HTML 5 game, all HTML, CSS, JavaScript in one file, use HTML canvas, use request animation frame for the animation, add smooth physics and collision, and game must be fully functional. Return only the complete
[16:25]
HTML code. Now, that is the required thing. So, I'm doing it from the scratch. I've already done it. So, that's why the game was running. And um I've kept this basic. So, agenda all over here is to use the API key. Okay?
[16:41]
Now, we are going to use API key from the .env folder. I'll also explain you that. Now guys, in next part, we are writing a asynchronous function. And let me tell you about why do we use async. So, this is very important concept of
[16:55]
So, this is very important concept of JavaScript. And um let's take uh a common example. Let's say I am trying to execute these lines of code. And uh let's say one part of my code is fetching an API. Let's say uh we are
[17:11]
taking the data from any weather app. And we are calling that API. Now, definitely in order to get response, it is going to take some time. So guys, when you see whole application like a weather app, so while the time it is
[17:25]
components of that application should work together. So, it should not be like the application freezes. Other individual parts should be working. And when it gets the data, it is going to return it. And there you will see the
[17:40]
required output, weather of a particular city most probably. When we are actually city most probably. When we are actually waiting for certain data from requesting from any API, which is fetching the data from a server, so wait time is involved.
[17:54]
And we don't want the rest of the lines of the code stop working. So, for that purpose, we give this thing called an async function. Now, the function name async function. Now, the function name is generate game. And um since our agent
[18:08]
it will it is going to create the required game. Now, I was trying to tell you earlier that what you had to write. Basically, in the The you have Gemini I4
[18:20]
arg. So, this you have to give it. And with a sync, there is a very important await. And this is the required module that we are using, basically a function ai.interactions.create.
[18:34]
So, if you go above, we have imported something, Google GenAI. And from GenAI, are getting this function ai.interactions. And dot create. So, basically this is going to give our agent the required
[18:51]
thing. So, if you see the configuration, we have the model name, input we have to give the prompt, earlier we have declared it. Background is true means it can work on the background. And general configuration thinking level I have put
[19:03]
it to high because we are building game. And maximum output tokens is the limit what I have set all over here. These are very very important parameters when you are building let's say any application using Gemini
[19:16]
interaction interaction ID. So, your interaction ID will be generated, that will be logged up, and you will be seeing on the terminal. Now, here are some conditionals while interaction.status queued and
[19:29]
progress. So, you can see there is a strict inequality applied all over here. And then we are printing the interaction status. Now, we are resolving this with our promise. So, that's why we actually downloaded the library npm i
[19:46]
promise. And basically this is the asynchronous process, and there is a promise involved in this. Very important concept. After Very important concept. After status is you have you know, is in the
[19:58]
progress. And there are two equality you can see all over here, queued and progress. And when you are getting your interaction status means your agent has interacted and it has done given you some output. And finally
[20:12]
you are printing the interaction ID. Now, here we we need to also take care of another scenario also. Let's say if the interaction status is not completed, then we have to also give generation field. So, we are basically modeling our
[20:26]
agent's behavior. Agent is going to do most of the task, but for this case scenario, we have to take care of two things. First, to see the interaction status, what it is, whether it is queued or in progress, and if it is not
[20:41]
completed, then we need to throw an error, which is very much important. So, programmatically, we have to take care of that. Now, here we are creating the HTML file, uh and here you can see we are using filter, filter map, dot map,
[20:54]
dot join. So, these are all JavaScript function, guys, and if it seems very new to you, then I would definitely request you to go to our channel and watch JavaScript course. And this are very important thing, and here you can see uh
[21:09]
we are using regular expressions and trying to create that HTML file, through which what you were seeing uh currently, that the game you were playing. Now, we are writing the file. The gaming file name is so if if after the agent has
[21:23]
worked on, and uh you have got the required HTML file generated, so racinggame.html file is the name, and the format is UTF-8. So, that is our language what we are using, the latest language. And finally, we are logging
[21:39]
our game. Game has generated successfully. Open racinggame.html. And this is the error generated. Now, you can generate this code with the help of ChatGPT also, or Claude also, or Gemini also. But, I would definitely
[21:54]
advise you to understand what is actually going on programmatically. certain things, then you can play with these codes. Since we all know we are in the era of AI, so we don't have to hardcode anything, but understanding the
[22:10]
given codes is very much important to give you a direction where what you are make sure that you have Node installed in your system, and generated, which I was showing you earlier. And just you need to run on the
[22:27]
terminal node and the file name is generate game.js. So guys, you can see all over here. This is a game that we are having and the output is generated. And if you want to play this game, just in a very simple way you can play this.
[22:42]
And you can create actually more interesting game also. So based on whatever you like. So this is a very old arcade type game which I had created. And it is going to give you all the stats. So this is the power of Argan 4
[22:56]
which I can say which has created a minimal video game, but you can definitely try to create even more interesting project with this. So guys, with that we have come to the end of the session. I hope so you have enjoyed our
[23:09]
today's video on Gemini Argan 4. Thank you guys for watching this video.