Curso rápido da API Gemini 4 Argon

Ver no idioma original →

Autoria: freeCodeCamp.org · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: Gemini 4 Argon API Crash Course · Canal: freeCodeCamp.org · 10:22 · Assistir no YouTube

Tópicos: Agentes de IA, Engenharia de software com IA, Ferramentas de desenvolvimento com IA, Geração de conteúdo com IA

Resumo

O vídeo apresenta o Gemini 4 Argon e ensina a usá-lo por meio da API, desde a configuração de uma chave até o envio de solicitações em JavaScript. Mostra como ajustar os thinking levels, manter uma conversa usando o ID da interação anterior e executar uma tarefa longa em background mode. Como demonstração, o modelo cria um jogo Breakout em um único arquivo HTML. No fim, um engenheiro do Google DeepMind comenta os pontos fortes do modelo em raciocínio, criação 3D e escrita criativa.

Pontos-chave

• O Gemini 4 Argon é acessado pelo ID do modelo e pode ser chamado usando o SDK oficial @google/genai.
• A chave da API deve ser armazenada em uma variável de ambiente, mantida fora do código e excluída do repo.
• O modelo oferece thinking levels baixo, médio e alto; mais pensamento pode aumentar o tempo de resposta e o custo.
• A recomendação apresentada é testar os três níveis e escolher o mais baixo que ainda produza bons resultados.
• O campo previous interaction ID permite continuar uma conversa, mantendo o contexto da interação anterior.
• Background mode permite iniciar tarefas longas e consultar seu status periodicamente.
• A demonstração usa background mode para gerar um jogo Breakout em um arquivo HTML.
• Segundo o engenheiro entrevistado, o modelo também se destaca em escrita criativa e em tarefas que combinam ferramentas como Blender e Blender MCP.

Capítulos

Início	Capítulo	Resumo
00:00	Apresentação do Gemini 4 Argon	O vídeo apresenta o modelo, seus principais recursos e o conteúdo do curso.
02:04	Configuração da API e primeira solicitação	O tutorial configura a chave, instala o SDK e envia uma solicitação simples em JavaScript.
04:10	Thinking levels e conversas com contexto	O exemplo compara níveis de pensamento para encontrar um bug e mostra como continuar uma conversa usando o ID da interação anterior.
06:13	Tarefas em background e criação de um jogo	O vídeo usa background mode para gerar um jogo Breakout e explica como consultar o andamento e salvar o resultado.
07:47	Entrevista e usos criativos	Jack Witherspoon comenta aplicações do modelo em raciocínio, criação 3D e escrita criativa.

Citações

Ele foi criado especificamente para as tarefas mais difíceis: programação complexa, matemática, ciência e muito mais. — 01:02

Mais pensamento é mais lento e mais caro. — 05:10

Se você for criar um chatbot, esta linha é basicamente como você dá memória a ele. — 06:13

O trabalho acontece nos servidores do Google, não no meu laptop. — 07:16

Para mim, é meu modelo favorito para escrita criativa ou escrita em geral. — 09:20

Conceitos e entidades

• Gemini 4 Argon (modelo): Modelo do Google apresentado no vídeo, com opções de thinking level e suporte a tarefas longas em background.
• @google/genai (ferramenta): SDK oficial do Google usado no exemplo para fazer chamadas à API.
• Google (empresa): Empresa responsável pelo Gemini 4 Argon e pela API demonstrada.
• Google DeepMind (empresa): Organização mencionada como parte da equipe de desenvolvimento do modelo.
• Jack Witherspoon (pessoa): Integrante da equipe de developer experience do Google DeepMind entrevistado no vídeo.
• Genevieve (pessoa): Integrante da equipe citada por uma demonstração que transformou a imagem de uma mesa em uma pista 3D.
• thinking level (conceito): Configuração que determina o nível de pensamento do modelo, com as opções baixo, médio e alto.
• context window (conceito): Memória de trabalho do modelo, compartilhada entre a entrada, o pensamento e a resposta.
• background mode (conceito): Modo para iniciar uma tarefa demorada e consultar seu andamento posteriormente.
• previous interaction ID (conceito): Identificador usado para continuar uma conversa a partir de uma interação anterior.
• Blender (ferramenta): Ferramenta usada na demonstração citada para construir componentes de uma pista 3D.
• Blender MCP (ferramenta): MCP citado como meio de usar o Blender na criação da demonstração 3D.

Tradução completa (pt-BR)

00:00 Olá, pessoal, sejam bem-vindos ao freecodecamp. O Google acabou de lançar o Gemini 4 Argon, seu modelo mais capaz até agora. E, nos próximos 10 minutos ou mais, vamos aprender a usá-lo de verdade. >> Ao final deste vídeo, você saberá como usar o Gemini 4 Argon, controlar o quanto ele pensa, ter uma conversa de ida e volta adequada com ele e até fazê-lo criar este jogo que você pode ver na tela, tudo isso em alguns arquivos pequenos de JavaScript. >> E hoje temos até um engenheiro do Google aqui com a gente. >> E, se você é relativamente novo em programação,

00:31 não se preocupe. Se você consegue escrever algumas funções em JavaScript, com certeza vai conseguir acompanhar. Vou explicar tudo bem devagar, passo a passo. >> Então, antes de começar, vamos dar uma olhada no que vamos abordar. Primeiro, vamos ver o que é o Gemini 4 Argon. Depois, vamos configurar uma API key e enviar nossa primeira solicitação. Vamos experimentar os níveis de pensamento, conversar com o modelo e terminar pedindo para ele criar um jogo para nós em segundo plano. >> O que é o Gemini 4 Argon? Então, o Gemini 4

01:02 Argon é o modelo mais recente e mais capaz do Google, desenvolvido especificamente para todas as tarefas difíceis. Programação complexa, matemática, ciência, você escolhe. Quando você o chama pelo seu código, usa o ID do modelo, que é apenas esta sequência aqui: Gemini 4 Argon. Agora, há três coisas sobre ele que vale a pena conhecer se você está começando. Primeiro, ele pensa antes de responder, e você decide quanto ele pensa usando uma configuração chamada nível de pensamento, que pode ser baixo, médio ou alto. Médio é

01:33 o padrão, e vamos experimentar os três daqui a pouco. Segundo, ele tem uma context window enorme, que é essencialmente a memória de trabalho do modelo. No caso do Argon, ela tem pouco mais de 4 milhões de tokens, compartilhados entre o que você envia, o que ele pensa e o que ele escreve de volta. E um token é, mais ou menos, um pequeno trecho de uma palavra. Terceiro, ele pode funcionar em segundo plano, então você pode passar uma tarefa grande para ele e voltar mais tarde para ver os resultados. >> Configurar a API key, o faturamento e o projeto.

02:04 Certo, vamos configurar tudo. Acesse o Google API Studio, entre com sua conta do Google e clique em “Get API key”. Crie uma chave e confira se o projeto ao qual ela pertence tem o faturamento ativado. Caso contrário, o Argon vai rejeitar sua solicitação. Copie essa chave e trate-a como uma senha. Não a cole no seu código nem a envie para o GitHub. E confira se o projeto ao qual ela pertence tem o faturamento ativado. Certo, agora vamos criar nosso projeto. Vou criar uma nova pasta, executar npm init e instalar

02:36 o SDK oficial do Google, que é o pacote @google/genai. Em seguida, no package.json, vou adicionar type module, o que nos permite usar import e top-level await. E, por fim, um arquivo .env com nossa chave, chamada gemini_api_key. O SDK procura essa variável por conta própria, então nunca precisamos mexer na chave no nosso código. E o .env vai direto para o .gitignore. >> Sua primeira solicitação. Certo, vamos falar com o

03:08 Argon. Primeiro, vamos criar um arquivo chamado hello.js. No início, importamos Google gen AI e criamos o client. O objeto vazio é usado porque ele encontra nossa chave no ambiente por conta própria, então não deixe de incluí-lo. Depois, chamamos client interactions.create. Uma interaction é essencialmente uma rodada de comunicação com o modelo: enviamos algo e recebemos algo de volta. Informamos o modelo, que neste caso é Gemini 4 Argon, e depois o input, que é nosso prompt. Estou pedindo para ele

03:39 explicar o que é uma API para alguém completamente iniciante. Depois, exibimos interaction_text, que é a resposta em texto puro. Agora, vamos executá-lo usando a opção de linha de comando .env do Node para carregar nossa chave. E pronto, nossa primeira resposta do Gemini 4 Argon. E esse é basicamente todo o padrão. Todo o resto deste curso usa o mesmo núcleo, com algumas opções extras. Agora, se estiver demorando um pouco mais do que o esperado, lembre-se de que, por

04:10 padrão, ele pensa no nível médio antes de dizer qualquer coisa. Então, vamos ver isso agora. >> Níveis de pensamento: baixo versus alto. Para ver o que os níveis de pensamento fazem, precisamos dar ao Argon algo para pensar. Aqui está uma função pequena que deveria calcular a média de algumas notas de prova. Passamos 80, 90 e 100. Então, deveríamos obter 90, certo? Mas recebemos NaN, ou “não é um número”. Tente descobrir o erro por conta própria. Certo, vamos ver se o Argon consegue encontrá-lo e quanto tempo leva em diferentes níveis de pensamento

04:40 . Então, em think.js, envolvi nossa chamada em uma função chamada hunt, que recebe um nível de pensamento. A única novidade é este objeto de configuração de geração, no qual definimos o nível de pensamento. Também estou cronometrando cada chamada e exibindo os tokens de pensamento de interaction.usage. Depois, chamamos hunt duas vezes: uma com nível baixo e outra com nível alto. E os dois encontraram o erro. O loop usa “menor ou igual a”, então executa uma vez

05:10 a mais. Scores I está indefinido, e somar um valor indefinido a um número resulta em NaN, ou “não é um número”. Mas veja a diferença entre os níveis de pensamento em termos de segundos e tokens. Então, será que devemos sempre usar o nível alto, só por segurança? Bem, não exatamente. A recomendação do Google é testar sua tarefa nos três níveis e escolher o mais baixo que ainda dê boas respostas. Isso porque os tokens de pensamento são cobrados como saída. Portanto, pensar mais é mais lento e mais caro. Para um

05:40 erro simples como o nosso, o nível baixo é suficiente. >> Conversas com o ID da interaction anterior. Até agora, cada conversa foi isolada, e o Argon não faz ideia do que perguntamos antes. Mas e se quisermos ter uma conversa? Então, em chat.js, primeiro pedimos para ele corrigir o erro e, em seguida, perguntamos o que deveria acontecer se o array estivesse vazio. Isso só faz sentido se o Argon se lembrar da nossa função, certo? Então, passamos previous interaction ID, definido como o ID da nossa primeira interaction, e o Google mantém a conversa do lado deles

06:13 para nós. E ele continua exatamente de onde paramos, adicionando uma verificação para não dividirmos por zero. Então, se você algum dia criar um chatbot, esta linha é, essencialmente, como você dá memória a ele. >> Modo em segundo plano. O Argon cria um jogo. Certo, agora vem a parte divertida. Vamos pedir ao Argon para criar um jogo de Breakout completo em um único arquivo HTML. Uma tarefa grande como essa pode levar alguns minutos, e uma solicitação normal pode expirar. Então, usamos o modo em segundo plano, que é a

06:45 mesma chamada create, com três mudanças. Background fica como true, o nível de pensamento é alto e max output tokens passa para 131.072. Vale observar que, sem max output tokens, o modo em segundo plano para em cerca de 64.000 tokens. Desta vez, create nos entrega uma interaction com o status queued ou in progress, então verificamos de novo a cada 5 segundos com client.interactions.get. Quando termina, as respostas do Argon ficam divididas

07:16 entre várias etapas. Então, juntamos o texto de todas as etapas de saída do modelo e o gravamos em game.html. O legal é que o trabalho está acontecendo nos servidores do Google, e não no meu laptop. Você pode fechar o laptop e voltar mais tarde. Certo, terminou. Vamos abrir game.html no navegador. E pronto: um jogo de Breakout funcional, com pontuação, vidas e um botão para reiniciar, tudo a partir de um único prompt. Isso é realmente incrível. >> Então, estamos aqui com nossos especialistas do Google.

07:47 Se puderem, apresentem-se para o público. >> Claro. Meu nome é Jack Witherspoon e faço parte da equipe de experiência para desenvolvedores aqui na Google DeepMind. >> E o que você mais gosta no modelo Gemini mais recente? >> Sim, acabamos de lançar o Gemini 4 Argon. Acho que o que mais gosto é que você pode simplesmente apresentar ideias a ele e ele consegue fazer bastante coisa muito bem: raciocinar de verdade e encontrar uma solução elegante para algo que talvez você mesmo ainda nem tenha pensado completamente. Você meio que dá uma ideia para ele: “Ei,

08:18 Aqui está o que quero tentar fazer. Você pode tentar criar isso?” Aí você volta e ele meio que já passou por todo o raciocínio. Ele pesquisou, fez buscas na web e criou uma solução realmente muito boa. >> E minha pergunta favorita: qual é a coisa mais incrível, mais impressionante que você criou com esse modelo até agora? >> Sim, acho que minha colega de equipe Genevieve fez uma demonstração incrível para o lançamento, que foi incluída no blog. Ela tirou uma foto da mesa no apartamento dela, enviou para o Gemini for Argon e pediu que ele a transformasse em uma espécie de pista de corrida 3D. E ele é realmente

08:50 bom em 3D, então usou o Blender com o Blender MCP e criou todos os componentes. Ele até recorreu a coisas como nano banana para conseguir texturas boas no carro e no cenário. Depois, também pesquisou na web sons de motores e acrescentou o próprio áudio ao jogo. Foi muito legal ver tudo ganhando forma. >> Uau, adorei. >> Então, aqui vai minha pergunta: qual é um caso de uso legal para o Argon, ou talvez algo que outras pessoas talvez não saibam, algo menos óbvio para o qual ele

09:20 seria bom que as pessoas conhecessem? >> Sim, com certeza. Para mim, pessoalmente, o que mais gostei e descobri sobre o Argon é que, para escrita criativa ou escrita em geral, ele é meu modelo favorito entre todos os que existem. Acho que ele é muito, muito bom em escrita criativa e em conseguir construir uma narrativa que não soe como IA nem tenha certos cacoetes que muitos modelos podem apresentar. Às vezes, você lê algo e pensa: “Certo, acho que sei em qual modelo isso se baseia, por causa de certas palavras que ele usa.”

09:50 E nossa equipe realmente dedicou tempo à fase de pesquisa e ao treinamento do modelo para escrita, e acho que isso ficou evidente. É um modelo realmente muito bom nisso. >> Muito obrigado por vir aqui e responder às nossas perguntas. >> Sim, obrigado pelo convite. >> Certo, pronto. Aprendemos a usar o Gemini for Argon. Aprendemos a usar a API para criar alguns programas, criar um jogo, e há muito mais que você pode fazer com ela. Então, recomendo que confira os links na descrição. Temos os links para o código

10:22 e outros links para você poder usar por conta própria e começar a descobrir para que pode usar isso nos seus próprios projetos.

Transcrição original

[00:00] Hey everyone, welcome to freecodecamp. Google just released Gemini 4 Argon, which is its most capable model yet. And in the next 10 minutes or so, we’re going to learn how to actually use it. >> By the end of this video, you will know how to use Gemini 4 Argon, control how hard it thinks, have a proper back and forth conversation with it, and even get it to build this game that you can see on screen, all in a few small JavaScript files. >> And we even have a Google engineer here with us today. >> And if you are fairly new to coding,

[00:31] don’t worry. If you can write a few JavaScript functions, you could definitely follow along with this. I’ll be saying everything super slow, step by step. >> So, before we get going, let’s have a look at what we will actually cover. First off, we will look at what Gemini 4 Argon actually is. After that, we will get set up with an API key, and then we will send our first request. We’ll play with the thinking levels, have a conversation with the model, and finish by letting it build a game for us in the background. >> What is Gemini 4 Argon? So, Gemini 4

[01:02] Argon is Google’s latest and most capable model, specifically built for all the hard stuff. So, complex coding, math, science, you name it. When you call it from your code, you refer to it by its model ID, which is just this string right here, Gemini 4 Argon. Now, there really are three things about it worth knowing as a beginner. First, it thinks before it answers, and you get to decide how much it thinks using a setting called the thinking level, which can be low, medium, or high. Medium is

[01:33] the default, and we will play all three in a moment. Second, it has a huge context window, which is essentially the model’s working memory. For Argon, that is just over 4 million tokens, shared between what you send in, what it thinks, and what it writes back. And a token is roughly a small chunk of a word. And third, it can run in the background, so you can hand it a big job and come back for the results later on. >> Set up API key, billing, and project.

[02:04] All right, let’s get set up. Head over to Google API Studio, sign in with your Google account, and click get API key. Create a key and make sure the project it belongs to has billing enabled. Otherwise, Argon will turn your request down. Copy that key and treat it like a password. Don’t paste it into your code and do not push it to GitHub. And make sure the project it belongs to has billing enabled. Okay, so now let’s make our project. I’m just going to make a new folder and run npm init and install

[02:36] Google’s official SDK, which is the package @google/genai. Next, in package.json, I’m adding type module, which lets us use import and top-level await. And finally, a .env file with our key in it called gemini_api_key. The SDK looks for that variable all by itself, so we never touch the key in our code. And .env goes straight into .gitignore. >> Your fast request. Right, let’s talk to

[03:08] Argon. First, let’s make a file called hello.js. So, at the top, we import Google gen AI and create client. The empty object is because it finds our key from the environment for us, so definitely put that in. Then, we call client interactions.create. An interaction is essentially one round trip with the model, so we send something in and we get something back. We give it the model, which in this case is Gemini for Argon, and then the input, which is our prompt. I’m asking it to

[03:39] explain what an API is to a complete beginner. Then, we log out interaction_text, which is the answer as plain text. Now, let’s run it using Node’s .env file flag to load our key. And there we go, our fast response from Gemini 4 Argon. And that is really the whole pattern. And everything else in this course is the same core with a few extra options. Now, if you’re just taking a little bit longer than expected, remember, by

[04:10] default, it’s thinking at medium before it says anything. So, let’s look at that next. >> Thinking levels low versus high. And to see what thinking levels do, we need to give Argon something to think about. Here’s a tiny function that should average some exam scores. We pass an 80, 90, and 100. So, we should get 90, right? But we get NaN, or not a number. See if you can spot the bug yourself. Okay, let’s see if Argon can find it and how long it takes at different thinking

[04:40] levels. So, in think.js, I have wrapped our call in a function called hunt, which takes a thinking level. The only new thing is this generation config object, where we set thinking level. I’m also timing each call and logging the thinking tokens from interaction.usage. Then we call hunt twice, once with low and once with high. And both of them found it. The loop uses less than or equal to, so it runs once

[05:10] too many. Scores I is undefined, and adding undefined to a number gives NaN, not a number. But look at the difference between the thinking levels in terms of seconds and tokens. So, should we always use high just to be safe? Well, not really. Google’s advice is to try your task at all three levels and pick the lowest one that still gives good answers. Because thinking tokens are billed as output. So, more thinking is slower and more expensive. For simple

[05:40] bug like ours, low is plenty. >> Conversations with previous interaction ID. Now, so far every conversation has been a one-off, and Argon has no idea what we asked before. But, what if we want a conversation? So, in chat.js, we first ask it to fix the bug, and then we follow up with what should happen if the array is empty. That only makes sense if Argon remembers our function, right? So, we pass in previous interaction ID set to the ID of our first interaction, and Google keeps the conversation on their

[06:13] side for us. And it picks up exactly where we left off, adding a check so we don’t divide by zero. So, if you ever build a chatbot, this one line is essentially how you give it a memory. >> Background mode. Argon builds a game. Okay, now for the fun one. We’re going to ask Argon to build an entire Breakout game in a single HTML file. Now, a big job like this can take a few minutes, and a normal request could time out. So, we use background mode, which is the

[06:45] same create call with three changes. Background is true, thinking level is high, and max output tokens goes up to 131,072. It’s worth noting that without max output tokens, background mode stops at about 64,000 tokens. This time, create hands us an interaction with a status queued or in progress, so we check back every 5 seconds with client.interactions.get. Once it finishes, Argon’s answers split

[07:16] across steps. So, we join the text from all the model output steps and write it to game.html. So, what’s cool is the work is happening on Google servers and not my laptop. You can close your laptop and come back for it later. Okay, it’s done. Let’s open game.html in our browser. And there we go, a working Breakout game with a score, lives, and a restart button, all from one prompt. This is truly incredible. >> So, here we are with our Google experts.

[07:47] If you could please introduce yourselves for the crowd. >> Yeah, for sure. My name is Jack Witherspoon and I am on the developer experience team here at Google DeepMind. >> And what is your favorite thing about the latest Gemini model? >> Yeah, so we just launched Gemini for Argon. I think the thing I like the most is that you can really kind of just throw ideas at it and it can do a lot of strong, you know, really reasoning and going out and actually finding an elegant solution to something that you might not even have fully thought through yourself. You just kind of give it an idea of, “Hey,

[08:18] here’s what I want to try to do. Can you go ahead and try to build this?” And then you come back and kind of has gone through all the reasoning. It’s gone and researched, searched the web and like built out a really nice kind of solution. >> And my favorite question, what is the most incredible, amazing thing that you’ve built with this model so far? >> Yeah, I think my teammate Genevieve did an awesome demo for the actual launch that was included in the blog where she took a picture of her desk in her apartment and sent it to Gemini for Argon and asked it to turn it into a kind of 3D racetrack. And it’s really

[08:50] good at 3D, so it went out and used Blender with the Blender MCP and built out all the components and even pulled in things like nano banana to actually get good textures on like the car and on the background. And it also then even went out and searched the web for kind of motor sounds and actually added its own audio to the game as well. It was really cool to see it come together. >> Wow, I love that. >> So, here’s my question. What’s a cool use case for Argon or maybe something that other people may not know about, something that’s not as obvious that it

[09:20] would be good for people to know about? >> Yeah, for sure. I think Argon, for me personally, what I’ve really enjoyed and found about it is that for like creative writing or just writing in general, it’s my favorite model to use out of all the models out there. I think it’s really, really strong at actually kind of creative writing and actually being able to weave a narrative together that doesn’t sound like AI or doesn’t have certain quirks that a lot of models can do. Like you know, sometimes you can read something and be like, “Okay, I think I know what model that is based

[09:50] off of certain words they say.” And our team’s really like took the time to do into the research phase and training the model in writing and I think it showed. It’s one that’s really really strong. >> Well, thank you so much for coming in and and ask answering our questions. >> Yes, thanks for having me. >> Okay, there we go. We learned how to use Gemini for Argon. We used we learned how to use the the API to create some programs, create a game, and there’s so much more you can do with it. So, I encourage you to check out the links in the description. We have the the code

[10:22] links and other links to be able to use it yourself and just start trying to figure out what you can use this for in your own projects.