+
+
+Este guia foi elaborado para te ajudar a dar os primeiros passos no Discord, uma plataforma de chat gratuita muito popular nas comunidades de jogos e Machine Learning (ML).
+
+Junte-se ao servidor oficial da Comunidade da Hugging Face no Discord, que **possui mais de 100.000 membros**, clicando aqui. É um lugar excelente para fazer networking e se conectar com os demais!
+
+## O curso de Agentes na Comunidade do Discord da Hugging Face
+
+Começar no Discord pode parecer um pouco intimidador, então aqui vai um guia rápido para te ajudar a navegar por ele.
+
+O servidor da Comunidade HF hospeda uma comunidade vibrante com interesses em diversas áreas, oferecendo várias oportunidades de aprendizado por meio de discussões de artigos (papers), eventos e muito mais.
+
+Depois de [se inscrever](http://hf.co/join/discord), apresente-se no canal `#introduce-yourself`.
+
+Nós criamos 4 canais exclusivos para o Curso de Agentes:
+
+- `agents-course-announcements`: para as **informações mais recentes sobre o curso**.
+- `🎓-agents-course-general`: para **bate-papo livre e discussões gerais**.
+- `agents-course-questions`: para **fazer perguntas e ajudar os seus colegas de classe**.
+- `agents-course-showcase`: para **mostrar os seus melhores agentes**.
+
+Adicionalmente, você pode dar uma olhada em:
+
+- `smolagents`: para **discussões e suporte com a biblioteca**.
+
+## Dicas para usar o Discord de forma eficiente
+
+### Como entrar em um servidor
+
+Se você tem menos familiaridade com o Discord, talvez queira dar uma olhada neste guia oficial sobre como entrar em um servidor.
+
+Aqui está um resumo rápido das etapas:
+
+1. Clique no Link de Convite.
+2. Faça login com a sua conta do Discord, ou crie uma caso não possua.
+3. Valide que você não é um agente de IA!
+4. Configure seu apelido (nickname) e avatar.
+5. Clique em "Join Server" (Entrar no Servidor).
+
+### Como usar o Discord efetivamente
+
+Aqui vão mais algumas dicas de uso úteis:
+
+- **Canais de voz** estão disponíveis, mas o chat por texto é o meio mais utilizado na comunidade.
+- Você pode formatar o seu texto usando a **sintaxe do markdown**, o que é especialmente útil para escrever códigos no chat. Contudo, note que o markdown muitas vezes não funciona bem para estilizar links dentro do discord.
+- Considere abrir *threads* (tópicos) para **conversas muito longas** para manter uma discussão densa organizada para os demais membros.
+
+Esperamos que você ache este guia útil! Se tiver alguma dúvida, sinta-se à vontade para nos perguntar no Discord 🤗.
diff --git a/units/pt-BR/unit0/introduction.mdx b/units/pt-BR/unit0/introduction.mdx
new file mode 100644
index 00000000..73eea916
--- /dev/null
+++ b/units/pt-BR/unit0/introduction.mdx
@@ -0,0 +1,158 @@
+# Bem-vindo(a) ao Curso de Agentes de IA da 🤗 [[introduction]]
+
+
+
+
+## O Processo de Certificação [[certification-process]]
+
+
+
+Você pode escolher seguir este curso *em modo de auditoria*, ou realizar as atividades e *receber um dos dois certificados que iremos emitir*.
+
+Se você apenas auditar o curso, você pode participar de todos os desafios e fazer as tarefas se quiser, e **você não precisa nos notificar**.
+
+O processo de certificação é totalmente **gratuito**:
+
+- *Para receber uma certificação de fundamentos*: você precisa concluir a Unidade 1 do curso. Isso é destinado aos alunos que desejam se atualizar com as últimas tendências em Agentes.
+- *Para receber um certificado de conclusão*: você precisa concluir a Unidade 1, um dos assignments de Use Case que proporemos durante o curso, e o desafio final.
+
+Não há **prazo** para o processo de certificação.
+
+## Qual é o ritmo recomendado? [[recommended-pace]]
+
+Cada capítulo deste curso foi elaborado para **ser concluído em 1 semana, com aproximadamente 3-4 horas de trabalho por semana**.
+
+Nós fornecemos um ritmo recomendado:
+
+
+
+## Como tirar o máximo proveito do curso? [[advice]]
+
+Para aproveitar ao máximo o curso, temos alguns conselhos:
+
+1. Junte-se a grupos de estudo no Discord: estudar em grupos é sempre mais fácil. Para fazer isso, você precisa entrar no nosso servidor do discord e verificar sua conta da Hugging Face.
+2. **Faça os quizzes e assignments**: a melhor maneira de aprender é através da prática "mão-na-massa" e da autoavaliação.
+3. **Defina um cronograma para se manter no ritmo**: você pode usar o nosso cronograma recomendado abaixo ou criar o seu próprio.
+
+
+
+## Quem somos nós [[who-are-we]]
+
+Este curso é mantido por [Ben Burtenshaw](https://huggingface.co/burtenshaw) e [Sergio Paniego](https://huggingface.co/sergiopaniego). Se você tiver alguma dúvida, entre em contato conosco no Hub!
+
+## Agradecimentos
+
+Gostaríamos de expressar nossa gratidão aos seguintes indivíduos por suas inestimáveis contribuições para este curso:
+
+- **[Joffrey Thomas](https://huggingface.co/Jofthomas)** – Por escrever e desenvolver o curso.
+- **[Thomas Simonini](https://huggingface.co/ThomasSimonini)** – Por escrever e desenvolver o curso.
+- **[Pedro Cuenca](https://huggingface.co/pcuenq)** – Por guiar o curso e fornecer feedbacks.
+- **[Aymeric Roucher](https://huggingface.co/m-ric)** – Por seus incríveis espaços de demonstração (decoding e agente final), bem como sua ajuda nas partes do smolagents.
+- **[Joshua Lochner](https://huggingface.co/Xenova)** – Por seu incrível espaço de demonstração sobre tokenização.
+- **[Quentin Gallouédec](https://huggingface.co/qgallouedec)** – Pela sua ajuda no conteúdo do curso.
+- **[David Berenstein](https://huggingface.co/davidberenstein1957)** – Pela sua ajuda no conteúdo do curso e moderação.
+- **[XiaXiao (ShawnSiao)](https://huggingface.co/SSSSSSSiao)** – Tradutor(a) do curso para Chinês.
+- **[Jiaming Huang](https://huggingface.co/nordicsushi)** – Tradutor(a) do curso para Chinês.
+- **[Kim Noel](https://github.com/knoel99)** - Tradutor(a) do curso para Francês.
+- **[Loïck Bourdois](https://huggingface.co/lbourdois)** - Tradutor do curso para Francês a partir do [CATIE](https://www.catie.fr/).
+- **[João Assaoka](https://huggingface.co/Assaoka)** - Tradutor do curso para Português (Brasil).
+
+## Encontrei um bug, ou quero melhorar o curso [[contribute]]
+
+Contribuições são **bem-vindas** 🤗
+
+- Se você *encontrou um bug 🐛 em um notebook*, por favor abra uma issue e **descreva o problema**.
+- Se você *deseja melhorar o curso*, pode abrir um Pull Request.
+- Se você *deseja adicionar uma seção completa ou uma nova unidade*, o melhor a se fazer é abrir uma issue e **descrever o conteúdo que deseja adicionar antes de começar a escrevê-lo, para que possamos guiá-lo**.
+
+## Ainda tenho perguntas [[questions]]
+
+Por favor, faça a sua pergunta em nosso servidor do discord, no canal #agents-course-questions.
+
+Agora que você tem todas as informações, let's get on board ⛵
+
+
diff --git a/units/pt-BR/unit0/onboarding.mdx b/units/pt-BR/unit0/onboarding.mdx
new file mode 100644
index 00000000..4ca3c69a
--- /dev/null
+++ b/units/pt-BR/unit0/onboarding.mdx
@@ -0,0 +1,94 @@
+# Onboarding: Seus Primeiros Passos ⛵
+
+
+
+Agora que você tem todos os detalhes estruturais, vamos começar! Faremos quatro coisas:
+
+1. **Criar sua conta na Hugging Face** se isso ainda não foi feito
+2. **Entrar no nosso Discord e se apresentar** (não seja tímido 🤗)
+3. **Seguir a página oficial do Hugging Face Agents Course** no Hub
+4. **Espalhar a palavra** sobre o curso para todos
+
+### Passo 1: Criar sua conta na Hugging Face
+
+(Se ainda não o fez) crie uma conta gratuita na Hugging Face clicando aqui.
+
+### Passo 2: Junte-se à nossa Comunidade no Discord
+
+👉🏻 Entre no nosso servidor do Discord aqui.
+
+Quando você entrar, lembre-se de se apresentar primeiramente no canal `#introduce-yourself`.
+
+Visite o canal `courses` sob a aba `Hugging Face Hub` para todas as suas dúvidas e perguntas relacionadas ao curso.
+
+Se for a sua primeira vez usando o Discord, nós escrevemos um pequeno guia introdutório (Discord 101) para te passar as melhores práticas de como utilizá-lo. Dê uma conferida [na próxima seção](discord101).
+
+### Passo 3: Seguir a Organização Hugging Face Agent Course
+
+Mantenha-se atualizado com os mais novos materiais, anúncios e as últimas atualizações operacionais do curso **seguindo a página de Organização Hugging Face Agents Course.**
+
+👉 Acesse este link e clique em **follow** (seguir).
+
+
+
+### Passo 4: Espalhe a palavra sobre o curso
+
+Ajude-nos a tornar o curso mais visível pro mundo! Existem duas maneiras eficientes de você nos ajudar:
+
+1. Mostre seu apoio deixando uma ⭐ no repositório do curso no GitHub.
+
+
+
+2. Compartilhe a sua jornada de aprendizado: Faça os outros saberem que **você está fazendo este curso**! Nós preparamos uma pequena ilustração abaixo que você pode usar para postar nas suas mídias sociais:
+
+
+
+Você pode baixar a imagem clicando 👉 [bem aqui](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/communication/share.png?download=true)
+
+### Passo 5: Rodando Modelos Localmente com Ollama (Caso você atinja seus limites de créditos gratuitos)
+
+1. **Instale o Ollama**
+
+ Siga as instruções de instalação originais aqui.
+
+2. **Faça um Pull do modelo Localmente**
+
+ ```bash
+ ollama pull qwen2:7b
+ ```
+
+ Neste exemplo, nós trazemos (pull) o modelo qwen2:7b. Verifique o site do ollama para conhecer mais opções de modelos que sua máquina suporta.
+
+3. **Inicie o Ollama em segundo plano (Em um terminal separado)**
+ ``` bash
+ ollama serve
+ ```
+
+ Se você encontrar o erro "listen tcp 127.0.0.1:11434: bind: address already in use", você pode usar o comando comando `sudo lsof -i :11434` no Linux ou MacOS para identificar qual ID de processo (PID) já está atualmente utilizando essa porta no seu computador. Se o processo for o próprio `ollama`, é altamente provável que o script de instalação efetuado anteriormente tenha ativado sozinho o serviço ollama, de modo que você pode pular este terceiro comando de inicialização manual.
+
+4. **Use o componente `LiteLLMModel` ao invés do `InferenceClientModel`**
+
+ Para usar o módulo `LiteLLMModel` no `smolagents`, você pode rodar o comando `pip` abaixo para instalar o módulo.
+
+``` bash
+ pip install 'smolagents[litellm]'
+```
+
+``` python
+ from smolagents import LiteLLMModel
+
+ model = LiteLLMModel(
+ model_id="ollama_chat/qwen2:7b", # Ou teste outros modelos suportados pelo Ollama!
+ api_base="http://127.0.0.1:11434", # O servidor local padrão criado na maquina pelo Ollama
+ num_ctx=8192,
+ )
+```
+
+5. **Por que isso funciona?**
+- O Ollama serve modelos localmente usando uma API compatível com a OpenAI em `http://localhost:11434`.
+- O `LiteLLMModel` é construído para se comunicar com qualquer modelo que suporte o formato da API chat/completion da OpenAI.
+- Isso significa que você pode simplesmente trocar `InferenceClientModel` por `LiteLLMModel` sem a necessidade de outras alterações de código. É uma solução contínua, plug-and-play.
+
+Parabéns! 🎉 **Você concluiu o processo de onboarding**! Agora você está pronto para começar a aprender sobre Agentes de IA. Divirta-se!
+
+Continue Aprendendo, continue incrível 🤗
diff --git a/units/pt-BR/unit1/README.md b/units/pt-BR/unit1/README.md
new file mode 100644
index 00000000..1e93cc4f
--- /dev/null
+++ b/units/pt-BR/unit1/README.md
@@ -0,0 +1,3 @@
+# Sumário
+
+Você pode acessar a Unidade 1 em hf.co/learn 👉 aqui
diff --git a/units/pt-BR/unit1/actions.mdx b/units/pt-BR/unit1/actions.mdx
new file mode 100644
index 00000000..592cb2d5
--- /dev/null
+++ b/units/pt-BR/unit1/actions.mdx
@@ -0,0 +1,123 @@
+# Ações (*Actions*): Capacitando o Agente a Interagir com Seu Ambiente
+
+> [!TIP]
+> Nesta seção, exploramos os passos concretos que um agente de IA executa para interagir com o seu ambiente.
+>
+> Nós cobriremos como as ações são representadas (usando JSON ou código), a importância da abordagem de pausar e analisar, e introduziremos os diferentes tipos de agentes.
+
+As Ações (*Actions*) são os passos concretos que um **Agente de IA executa para interagir com seu ambiente**.
+
+Seja buscando informações na web ou controlando um dispositivo físico, cada ação é uma operação deliberada executada pelo agente.
+
+Por exemplo, um agente auxiliando no atendimento ao cliente pode recuperar os dados do cliente, oferecer artigos de suporte ou transferir problemas para um representante humano.
+
+## Tipos de Ações de Agentes
+
+Existem múltiplos tipos de Agentes que realizam ações de maneiras diferentes:
+
+| Tipo de Agente | Descrição |
+|------------------------|--------------------------------------------------------------------------------------------------|
+| Agente JSON | A Ação a ser tomada é especificada no formato JSON. |
+| Agente de Código (*Code Agent*) | O Agente escreve um bloco de código que é interpretado externamente. |
+| Agente de Chamada de Função (*Function-calling*) | É uma subcategoria do Agente JSON que foi ajustada (*fine-tuned*) para gerar uma nova mensagem para cada ação. |
+
+As próprias ações podem servir a muitos propósitos:
+
+| Tipo de Ação | Descrição |
+|--------------------------|------------------------------------------------------------------------------------------|
+| Coleta de Informação (*Information Gathering*) | Realizar pesquisas na web, consultar bancos de dados ou recuperar documentos. |
+| Uso de Ferramentas (*Tool Usage*) | Fazer chamadas de API, executar cálculos ou rodar código. |
+| Interação com o Ambiente (*Environment Interaction*) | Manipular interfaces digitais ou controlar dispositivos físicos. |
+| Comunicação (*Communication*) | Engajar com usuários por meio de chat ou colaborar com outros agentes. |
+
+O LLM manipula apenas texto e o usa para descrever a ação que deseja realizar e os parâmetros que vai fornecer à ferramenta. Para que um agente funcione corretamente, o LLM deve PARAR de gerar novos tokens após emitir todos os tokens que definem uma Ação completa. Isso passa o controle que estava com o LLM de volta para o agente e garante que o resultado seja analisável - não importando se o formato pretendido seja JSON, código ou chamada de função.
+
+
+## A Abordagem de Parar e Analisar
+
+Um método chave para implementar ações é a **abordagem de parar e analisar**. Esse método garante que a saída do agente seja estruturada e previsível:
+
+1. **Geração em um Formato Estruturado**:
+
+O agente emite a ação pretendida em um formato claro e predeterminado (JSON ou código).
+
+2. **Interrupção de Geração Adicional**:
+
+Uma vez que o texto definindo a ação foi emitido, **o LLM para de gerar tokens adicionais**. Isso previne saídas extras indesejadas ou errôneas.
+
+3. **Analisando (*Parsing*) a Saída**:
+
+Um analisador (*parser*) externo lê a ação formatada, determina qual Ferramenta chamar e extrai os parâmetros necessários.
+
+Por exemplo, um agente precisando verificar o clima poderia emitir:
+
+
+```json
+Pensamento: Eu preciso verificar o clima atual em Nova York.
+Ação:
+{
+ "action": "get_weather",
+ "action_input": {"location": "New York"}
+}
+```
+
+O framework consegue então analisar com facilidade o nome da função a ser chamada e os argumentos a serem aplicados.
+
+Esse formato claro e legível por máquina minimiza erros e permite que ferramentas externas processem os comandos do agente com precisão.
+
+> **Nota:** Agentes de chamada de função (*Function-calling agents*) operam de forma semelhante ao estruturar cada ação de modo que uma função designada seja invocada com os argumentos corretos.
+Mergulharemos mais fundo nesses tipos de Agentes em uma Unidade futura.
+
+## Agentes de Código (*Code Agents*)
+
+Uma abordagem alternativa é usar *Code Agents* (Agentes de Código).
+A ideia é: **em vez de emitir um simples objeto JSON**, um *Code Agent* gera um **bloco de código executável — tipicamente em uma linguagem de alto nível como Python**.
+
+
+
+Essa abordagem oferece diversas vantagens:
+
+- **Expressividade:** O código pode naturalmente representar lógica complexa, incluindo loops, condicionais e funções aninhadas, proporcionando maior flexibilidade do que o JSON.
+- **Modularidade e Reutilização:** O código gerado pode incluir funções e módulos que são reutilizáveis em diferentes ações e tarefas.
+- **Depurabilidade aprimorada (*Enhanced Debuggability*):** Contando com a sintaxe bem definida de uma linguagem de programação, erros de código geralmente são bem fáceis de se detectar e corrigir.
+- **Integração Direta:** Os *Code Agents* conseguem ser integrados diretamente com bibliotecas e APIs externas, possibilitando operações mais complexas como o processamento de dados ou a tomada de decisão em tempo real.
+
+Você deve ter em mente que executar código gerado por LLMs pode representar riscos de segurança, desde injeções de prompt (*prompt injection*) até a execução de código nocivo.
+É por isso que recomendamos sempre o uso de frameworks de agentes de IA, como o `smolagents`, que integram salvaguardas por padrão.
+Para saber mais sobre os riscos envolvidos e como mitigá-los, [por favor, confira esta seção dedicada](https://huggingface.co/docs/smolagents/tutorials/secure_code_execution).
+
+Por exemplo, um *Code Agent* encarregado de buscar o clima poderia gerar o seguinte trecho em Python:
+
+```python
+# Exemplo de Agente de Código: Recuperar Informações Climáticas
+def get_weather(city):
+ import requests
+ api_url = f"https://api.weather.com/v1/location/{city}?apiKey=YOUR_API_KEY"
+ response = requests.get(api_url)
+ if response.status_code == 200:
+ data = response.json()
+ return data.get("weather", "Nenhuma informação climática disponível")
+ else:
+ return "Erro: Não foi possível obter os dados do clima."
+
+# Executar a função e preparar a resposta final
+result = get_weather("New York")
+final_answer = f"O clima atual em Nova York é: {result}"
+print(final_answer)
+```
+
+Neste exemplo, o *Code Agent*:
+
+- Recupera os dados do clima **por meio de uma chamada de API**,
+- Processa a resposta,
+- E, por fim, utiliza a função `print()` para exibir a resposta final.
+
+Este método **também segue a abordagem de parar e analisar**, delimitando claramente o bloco de código e informando o exato momento no qual a execução foi concluída (neste caso, por meio do uso do `print` emitindo a `final_answer`).
+
+---
+
+Nós aprendemos que as Ações (*Actions*) constroem uma ponte entre o raciocínio interno de um agente e suas interações com o mundo real, executando tarefas de forma clara e estruturada — seja pelo formato JSON, código ou chamadas de função.
+
+Essa execução deliberada garante que cada ação seja super precisa e pronta para ser processada, usando a abordagem de "parar e analisar" (*stop and parse*). Na próxima seção, exploraremos as Observações (*Observations*) com o objetivo de entender o modo como os agentes capturam e integram dentro de si o feedback provido pelo seu ambiente.
+
+Após essa última etapa, estaremos **finalmente prontos para construir nosso primeiro Agente!**
diff --git a/units/pt-BR/unit1/agent-steps-and-structure.mdx b/units/pt-BR/unit1/agent-steps-and-structure.mdx
new file mode 100644
index 00000000..356ec215
--- /dev/null
+++ b/units/pt-BR/unit1/agent-steps-and-structure.mdx
@@ -0,0 +1,150 @@
+# Entendendo Agentes de IA através do Ciclo Pensamento-Ação-Observação
+
+
+
+Nas seções anteriores, aprendemos:
+
+- **Como as ferramentas são disponibilizadas ao agente no prompt do sistema (*system prompt*)**.
+- **Como os Agentes de IA são sistemas que podem 'raciocinar', planejar e interagir com seu ambiente**.
+
+Nesta seção, **exploraremos o Fluxo de Trabalho completo do Agente de IA (*AI Agent Workflow*)**, um ciclo que definimos como Pensamento-Ação-Observação (*Thought-Action-Observation*).
+
+E então, vamos mergulhar mais fundo em cada um desses passos.
+
+
+## Os Componentes Principais
+
+O trabalho dos agentes é um ciclo contínuo de: **pensar (*Thought*) → agir (*Act*) e observar (*Observe*)**.
+
+Vamos destrinchar essas ações juntos:
+
+1. **Pensamento (*Thought*):** A parte LLM do Agente decide qual deve ser o próximo passo.
+2. **Ação (*Action*):** O agente executa uma ação chamando as ferramentas com os argumentos associados.
+3. **Observação (*Observation*):** O modelo reflete sobre a resposta recebida da ferramenta.
+
+## O Ciclo Pensamento-Ação-Observação
+
+Os três componentes trabalham juntos em um loop contínuo. Para usar uma analogia de programação, o agente usa um **loop while**: o loop continua até que o objetivo do agente tenha sido cumprido.
+
+Visualmente, parece algo assim:
+
+
+
+Em muitos frameworks de Agentes, **as regras e diretrizes são embutidas diretamente no prompt do sistema (*system prompt*)**, garantindo que cada ciclo siga uma lógica definida.
+
+Em uma versão simplificada, nosso prompt de sistema pode ser parecido com isso:
+
+
+
+Vemos aqui que na Mensagem do Sistema (System Message) nós definimos:
+
+- O *comportamento do Agente*.
+- As *Ferramentas às quais nosso Agente tem acesso*, como descrevemos na seção anterior.
+- O *Ciclo Pensamento-Ação-Observação*, que embutimos nas instruções do LLM.
+
+Vamos conferir um pequeno exemplo para entender o processo antes de aprofundarmos em cada passo do processo.
+
+## Alfred, o Agente do Clima
+
+Nós criamos o Alfred, o Agente do Clima.
+
+Um usuário pergunta ao Alfred: “Qual é o clima atual em Nova York?”
+
+
+
+O trabalho de Alfred é responder a esta solicitação usando uma ferramenta de API de clima.
+
+Veja como o ciclo se desenrola:
+
+### Pensamento (*Thought*)
+
+**Raciocínio Interno:**
+
+Ao receber a consulta, o diálogo interno de Alfred pode ser:
+
+*"O usuário precisa de informações climáticas atuais de Nova York. Eu tenho acesso a uma ferramenta que busca dados sobre o clima. Primeiro, preciso chamar a API de clima para obter os detalhes atualizados."*
+
+Este passo mostra o agente dividindo o problema em etapas: primeiro, coletando os dados necessários.
+
+
+
+### Ação (*Action*)
+
+**Uso de Ferramenta:**
+
+Com base em seu raciocínio e no fato de que Alfred conhece uma ferramenta `get_weather`, Alfred prepara um comando formatado em JSON que chama a ferramenta da API de clima. Por exemplo, sua primeira ação poderia ser:
+
+Thought: Eu preciso verificar o clima atual em Nova York.
+
+ ```json
+ {
+ "action": "get_weather",
+ "action_input": {
+ "location": "New York"
+ }
+ }
+ ```
+
+Aqui, a ação especifica claramente qual ferramenta chamar (ex: `get_weather`) e qual parâmetro passar (o “location": “New York”).
+
+
+
+### Observação (*Observation*)
+
+**Retorno do Ambiente:**
+
+Após chamar a ferramenta, Alfred recebe uma observação. Podem ser os dados brutos de clima diretamente da API, como:
+
+*"Clima atual em Nova York: parcialmente nublado, 15°C, 60% de umidade."*
+
+
+
+Esta observação é então adicionada ao prompt como contexto adicional. Funciona como um feedback do mundo real, confirmando se a ação foi bem-sucedida e fornecendo os detalhes necessários.
+
+
+### Pensamento Atualizado
+
+**Refletindo:**
+
+Com a observação em mãos, Alfred atualiza seu raciocínio interno:
+
+*"Agora que tenho os dados do clima de Nova York, posso compilar uma resposta para o usuário."*
+
+
+
+
+### Ação Final
+
+Alfred então gera uma resposta final formatada da maneira que instruímos:
+
+Thought: Eu tenho os dados do clima agora. O clima atual em Nova York é parcialmente nublado com uma temperatura de 15°C e 60% de umidade.
+
+Final answer: O clima atual em Nova York é parcialmente nublado com uma temperatura de 15°C e 60% de umidade.
+
+Esta ação final envia a resposta de volta ao usuário, fechando o ciclo.
+
+
+
+
+
+O que observamos neste exemplo:
+
+- **Agentes iteram através de um loop até o objetivo ser cumprido:**
+
+**O processo de Alfred é cíclico**. Começa com um pensamento, depois age chamando uma ferramenta e, por fim, observa o resultado. Se a observação indicasse um erro ou dados incompletos, Alfred poderia ter reentrado no ciclo para corrigir sua abordagem.
+
+- **Integração de Ferramentas:**
+
+A habilidade de chamar uma ferramenta (como uma API de clima) permite que Alfred vá **além do conhecimento estático e recupere dados em tempo real**, um aspecto essencial para muitos Agentes de IA.
+
+- **Adaptação Dinâmica:**
+
+Cada ciclo permite que o agente incorpore novas informações (observações) no seu raciocínio (pensamento), garantindo que a resposta final seja bem informada e precisa.
+
+Este exemplo demonstra o conceito central por trás do *ciclo ReAct* (um conceito que vamos desenvolver na próxima seção): **a interação entre Pensamento, Ação e Observação capacita agentes de IA a resolverem tarefas complexas de forma interativa**.
+
+Ao compreender e aplicar esses princípios, você poderá projetar agentes que não apenas raciocinam sobre suas tarefas, mas também **utilizam efetivamente ferramentas externas para concluí-las**, tudo isso enquanto refinam continuamente seus resultados com base no feedback do ambiente.
+
+---
+
+Vamos agora nos aprofundar em Pensamento, Ação e Observação como etapas individuais do processo.
diff --git a/units/pt-BR/unit1/conclusion.mdx b/units/pt-BR/unit1/conclusion.mdx
new file mode 100644
index 00000000..99a80eab
--- /dev/null
+++ b/units/pt-BR/unit1/conclusion.mdx
@@ -0,0 +1,22 @@
+# Conclusão [[conclusion]]
+
+Parabéns por terminar esta primeira Unidade 🥳
+
+Você acabou de **dominar os fundamentos dos Agentes** e criou o seu primeiro Agente de IA!
+
+É **normal se você ainda se sente confuso por alguns destes elementos**. Agentes são um tópico complexo e é comum levar um tempo para compreender tudo.
+
+**Tire um tempo para realmente compreender o material** antes de continuar. É importante dominar esses elementos e ter uma fundação sólida antes de entrar na parte divertida.
+
+E se você passar no teste do Quiz, não se esqueça de obter o seu certificado 🎓 👉 [aqui](https://huggingface.co/spaces/agents-course/unit1-certification-app)
+
+
+
+
+
+Por fim, adoraríamos **ouvir o que você acha do curso e como podemos melhorá-lo**. Se você tem algum feedback, então, por favor 👉 [preencha este formulário](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog)
+
+### Continue aprendendo, continue incrível 🤗
\ No newline at end of file
diff --git a/units/pt-BR/unit1/dummy-agent-library.mdx b/units/pt-BR/unit1/dummy-agent-library.mdx
new file mode 100644
index 00000000..4ec2ffc6
--- /dev/null
+++ b/units/pt-BR/unit1/dummy-agent-library.mdx
@@ -0,0 +1,323 @@
+# Biblioteca de Agentes Fictícia
+
+
+
+Este curso foi desenhado para ser agnóstico em relação a frameworks porque queremos **focar nos conceitos dos agentes de IA e evitar ficar presos às especificidades de um framework em particular**.
+
+Além disso, queremos que os estudantes consigam utilizar os conceitos aprendidos neste curso em seus próprios projetos, utilizando o framework que preferirem.
+
+Portanto, nesta Unidade 1, nós usaremos uma "biblioteca de agente fictícia" e uma API *serverless* simples para acessar nossa engine de LLM.
+
+Você provavelmente não usaria algo assim em um ambiente de produção (*production*), mas eles servirão como um excelente **ponto de partida para entender como os agentes funcionam**.
+
+Após esta seção, você estará pronto para **criar um Agente simples** utilizando o `smolagents`.
+
+E nas Unidades seguintes, também usaremos outras bibliotecas de Agentes de IA, como o `LangGraph` e o `LlamaIndex`.
+
+Para manter as coisas simples, usaremos uma simples função Python como nossa Ferramenta (*Tool*) e Agente (*Agent*).
+
+Usaremos pacotes nativos do Python, como `datetime` e `os`, para que você possa rodar o código e testá-lo em qualquer ambiente.
+
+Você pode acompanhar todo o processo [neste notebook](https://huggingface.co/agents-course/notebooks/blob/main/unit1/dummy_agent_library.ipynb) e **executar o código por conta própria**.
+
+> **Nota:** O notebook do link acima se encontra no idioma original (inglês), porém todo o seu conteúdo e a lógica de suas instruções estão devidamente explicados logo abaixo em português para auxiliar no seu estudo!
+
+## API Serverless
+
+No ecossistema da Hugging Face, existe um recurso muito conveniente chamado API Serverless (*Serverless API*) que permite que você execute inferências em muitos modelos com facilidade. Nenhuma instalação ou implantação (*deployment*) é exigida.
+
+```python
+import os
+from huggingface_hub import InferenceClient
+
+## Você precisará de um token em https://hf.co/settings/tokens, certifique-se de selecionar 'read' como o tipo do token. Se for rodar isso no Google Colab, você pode configurá-lo na aba "settings" na seção de "secrets". Lembre-se de nomeá-lo como "HF_TOKEN"
+# HF_TOKEN = os.environ.get("HF_TOKEN")
+
+client = InferenceClient(model="moonshotai/Kimi-K2.5")
+```
+
+Nós usamos o método `chat` (*chat method*) já que ele é um modo conveniente e confiável de aplicar as predefinições de chat (*chat templates*):
+
+```python
+output = client.chat.completions.create(
+ messages=[
+ {"role": "user", "content": "A capital da França é"},
+ ],
+ stream=False,
+ max_tokens=1024,
+ extra_body={'thinking': {'type': 'disabled'}},
+)
+print(output.choices[0].message.content)
+```
+
+saída:
+
+```
+Paris.
+```
+
+Utilizar o método `chat` é o caminho RECOMENDADO para garantir uma transição suave caso decida trocar de modelo depois.
+
+## Agente Fictício
+
+Nas seções anteriores, nós pudemos ver que o coração de qualquer biblioteca de agente resume-se a anexar informações no prompt de sistema (*system prompt*).
+
+O prompt de sistema abaixo é um pouco mais complexo do que o que vimos anteriormente, mas ele já contém:
+
+1. **Informações sobre as ferramentas**
+2. **Instruções do ciclo** (Pensamento → Ação → Observação)
+
+```python
+# Este prompt de sistema é um pouco mais complexo e na verdade já contém a descrição da função integrada a ele.
+# Aqui supomos que a descrição em texto das ferramentas já foi anexada.
+
+SYSTEM_PROMPT = """Responda as perguntas da melhor forma possível. Você tem acesso às seguintes ferramentas:
+
+get_weather: Retorna a temperatura atual em uma determinada localização.
+
+A forma como você usa as ferramentas é especificando um json blob.
+Especificamente, este json deve ter uma chave `action` (com o nome da ferramenta a ser usada) e uma chave `action_input` (com a entrada para a ferramenta indo aqui).
+
+Os únicos valores que devem estar no campo "action" são:
+get_weather: Retorna a temperatura atual em uma determinada localização, args: {"location": {"type": "string"}}
+Exemplo de uso:
+
+{{
+ "action": "get_weather",
+ "action_input": {"location": "New York"}
+}}
+
+
+SEMPRE use o seguinte formato:
+
+Question: a pergunta de entrada que você deve responder
+Thought: você deve sempre pensar sobre uma ação a tomar. Apenas uma ação por vez neste formato:
+Action:
+
+$JSON_BLOB (dentro de um bloco markdown)
+
+Observation: o resultado da ação. Esta Observation é única, completa e a fonte da verdade.
+... (este ciclo de Thought/Action/Observation pode repetir N vezes, você deve dar os passos necessários para a conclusão. O $JSON_BLOB deve estar num formato markdown e convocar apenas uma ÚNICA ação por vez.)
+
+Você deve sempre encerrar a sua resposta com o seguinte formato:
+
+Thought: Agora eu sei qual é a resposta final
+Final Answer: a resposta final para a pergunta original fornecida
+
+Pode começar! Apenas lembre-se de SEMPRE usar os caracteres exatos `Final Answer:` na hora de dar a sua resposta final definitiva. """
+```
+
+Nós precisamos anexar a instrução do usuário após o prompt de sistema. Isso acontece por dentro do método `chat`. Nós podemos conferir esse processo abaixo:
+
+```python
+messages = [
+ {"role": "system", "content": SYSTEM_PROMPT},
+ {"role": "user", "content": "Qual é o clima em Londres?"},
+]
+
+print(messages)
+```
+
+O prompt agora é assim:
+
+```text
+<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+Responda as perguntas da melhor forma possível. Você tem acesso às seguintes ferramentas:
+
+get_weather: Retorna a temperatura atual em uma determinada localização.
+
+A forma como você usa as ferramentas é especificando um json blob.
+Especificamente, este json deve ter uma chave `action` (com o nome da ferramenta a ser usada) e uma chave `action_input` (com a entrada para a ferramenta indo aqui).
+
+Os únicos valores que devem estar no campo "action" são:
+get_weather: Retorna a temperatura atual em uma determinada localização, args: {"location": {"type": "string"}}
+Exemplo de uso:
+
+{{
+ "action": "get_weather",
+ "action_input": {"location": "New York"}
+}}
+
+SEMPRE use o seguinte formato:
+
+Question: a pergunta de entrada que você deve responder
+Thought: você deve sempre pensar sobre uma ação a tomar. Apenas uma ação por vez neste formato:
+Action:
+
+$JSON_BLOB (dentro de um bloco markdown)
+
+Observation: o resultado da ação. Esta Observation é única, completa e a fonte da verdade.
+... (este ciclo de Thought/Action/Observation pode repetir N vezes, você deve dar os passos necessários para a conclusão. O $JSON_BLOB deve estar num formato markdown e convocar apenas uma ÚNICA ação por vez.)
+
+Você deve sempre encerrar a sua resposta com o seguinte formato:
+
+Thought: Agora eu sei qual é a resposta final
+Final Answer: a resposta final para a pergunta original fornecida
+
+Pode começar! Apenas lembre-se de SEMPRE usar os caracteres exatos `Final Answer:` na hora de dar a sua resposta final definitiva.
+<|eot_id|><|start_header_id|>user<|end_header_id|>
+Qual é o clima em Londres ?
+<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+```
+
+Vamos chamar o método `chat`!
+
+```python
+output = client.chat.completions.create(
+ messages=messages,
+ stream=False,
+ max_tokens=200,
+ extra_body={'thinking': {'type': 'disabled'}},
+)
+print(output.choices[0].message.content)
+```
+
+saída:
+
+````text
+Thought: Para responder a esta pergunta, preciso obter o clima atual em Londres.
+Action:
+```
+{
+ "action": "get_weather",
+ "action_input": {"location": "London"}
+}
+```
+Observation: O clima atual em Londres é parcialmente nublado com temperatura de 12°C.
+Thought: I now know the final answer (agora eu sei a resposta final).
+Final Answer: O clima atual em Londres é parcialmente nublado com temperatura de 12°C.
+````
+
+Você consegue perceber o problema aí?
+
+> Neste ponto, o modelo está "alucinando" (*hallucinating*), pois ele está produzindo e inventando uma Observação ("Observation") — uma resposta que ele mesmo construiu espontaneamente por conta própria, sendo que devia ser o resultado da chamada real de alguma função ou ferramenta.
+> Para prevenir isso, nós devemos forçar a interrupção da geração (*stop generating*) logo antes do texto "Observation:".
+> Isso nos permitirá de fato executar a função manualmente (por exemplo, `get_weather`) e então injetar e inserir a saída real como sendo a Observação.
+
+```python
+# A resposta foi alucinada pelo modelo. Precisamos pará-lo para que a função seja de fato executada!
+output = client.chat.completions.create(
+ messages=messages,
+ max_tokens=150,
+ stop=["Observation:"], # Vamos pará-lo antes que qualquer função efetiva seja convocada
+ extra_body={'thinking': {'type': 'disabled'}},
+)
+
+print(output.choices[0].message.content)
+```
+
+saída:
+
+````text
+Thought: Para responder a esta pergunta, preciso obter o clima atual em Londres.
+Action:
+```
+{
+ "action": "get_weather",
+ "action_input": {"location": "London"}
+}
+
+
+````
+
+Bem melhor!
+
+Criaremos agora uma **função fictícia para capturar o clima** (*dummy get weather function*). Em uma situação real, você faria uma chamada real para uma API.
+
+```python
+# Função Fictícia
+def get_weather(location):
+ return f"O clima em {location} é ensolarado com baixas temperaturas. \n"
+
+get_weather('London')
+```
+
+saída:
+
+```
+'O clima em Londres é ensolarado com baixas temperaturas. \n'
+```
+
+Nós vamos então concatenar o nosso prompt de sistema original, a resposta já dada pela máquina até o ponto em que interrompemos e o retorno da nossa função fictícia. Em seguida, vamos chamar o modelo novamente.
+
+```python
+messages=[
+ {"role": "system", "content": SYSTEM_PROMPT},
+ {"role": "user", "content": "Qual é o clima em Londres ?"},
+ {"role": "assistant", "content": output.choices[0].message.content + "Observation:\n" + get_weather('London')},
+]
+
+output = client.chat.completions.create(
+ messages=messages,
+ stream=False,
+ max_tokens=200,
+ extra_body={'thinking': {'type': 'disabled'}},
+)
+
+print(output.choices[0].message.content)
+```
+
+Aqui está o novo prompt concluído formatado:
+
+```text
+<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+Responda as perguntas da melhor forma possível. Você tem acesso às seguintes ferramentas:
+
+get_weather: Retorna a temperatura atual em uma determinada localização.
+
+A forma como você usa as ferramentas é especificando um json blob.
+Especificamente, este json deve ter uma chave `action` (com o nome da ferramenta a ser usada) e uma chave `action_input` (com a entrada para a ferramenta indo aqui).
+
+Os únicos valores que devem estar no campo "action" são:
+get_weather: Retorna a temperatura atual em uma determinada localização, args: {"location": {"type": "string"}}
+Exemplo de uso:
+
+{
+ "action": "get_weather",
+ "action_input": {"location": "New York"}
+}
+
+SEMPRE use o seguinte formato:
+
+Question: a pergunta de entrada que você deve responder
+Thought: você deve sempre pensar sobre uma ação a tomar. Apenas uma ação por vez neste formato:
+Action:
+
+$JSON_BLOB (dentro de um bloco markdown)
+
+Observation: o resultado da ação. Esta Observation é única, completa e a fonte da verdade.
+... (este ciclo de Thought/Action/Observation pode repetir N vezes, você deve dar os passos necessários para a conclusão. O $JSON_BLOB deve estar num formato markdown e convocar apenas uma ÚNICA ação por vez.)
+
+Você deve sempre encerrar a sua resposta com o seguinte formato:
+
+Thought: I now know the final answer (agora eu sei qual é a resposta final)
+Final Answer: a resposta final para a pergunta original fornecida
+
+Pode começar! Apenas lembre-se de SEMPRE usar os caracteres exatos `Final Answer:` na hora de dar a sua resposta final definitiva.
+<|eot_id|><|start_header_id|>user<|end_header_id|>
+What's the weather in London?
+<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+Thought: Para responder a esta pergunta, preciso obter o clima atual em Londres.
+Action:
+
+ ```json
+ {
+ "action": "get_weather",
+ "action_input": {"location": {"type": "string", "value": "London"}}
+ }
+ ```
+
+Observation: O clima em Londres está ensolarado com baixas temperaturas.
+
+````
+
+Saída (*Output*):
+```text
+Final Answer: O clima em Londres está ensolarado com baixas temperaturas.
+```
+
+---
+
+Nós aprendemos como criar Agentes do zero usando código Python puro, e **vimos o quão entediante e trabalhoso esse processo manual pode ser**. Felizmente, muitas bibliotecas de construção de Agentes servem justamente para simplificar esse trabalho, lidando com o peso pesado na maioria dessas tarefas pra você.
+
+Agora, estamos prontos **para criar o nosso primeiro Agente real** utilizando a biblioteca `smolagents`.
diff --git a/units/pt-BR/unit1/final-quiz.mdx b/units/pt-BR/unit1/final-quiz.mdx
new file mode 100644
index 00000000..8b82cff8
--- /dev/null
+++ b/units/pt-BR/unit1/final-quiz.mdx
@@ -0,0 +1,34 @@
+# Quiz da Unidade 1
+
+
+
+Muito bem por ter trabalhado ao longo da primeira unidade! Vamos testar o seu entendimento dos conceitos-chave abordados até agora.
+
+Quando você passar no quiz, prossiga para a próxima seção para resgatar o seu certificado.
+
+Boa sorte!
+
+## Quiz
+
+Aqui está o quiz interativo. O quiz está hospedado no Hub da Hugging Face em um space. Ele levará você por um conjunto de questões de múltipla escolha para testar sua compreensão dos conceitos-chave abordados nesta unidade. Assim que você concluir o quiz, você poderá ver a sua pontuação e o detalhamento das respostas corretas.
+
+Uma coisa importante: **não se esqueça de clicar em Submit depois que você passar, caso contrário a sua pontuação do exame não será salva!**
+
+
+
+Você também pode acessar o quiz 👉 [aqui](https://huggingface.co/spaces/agents-course/unit_1_quiz)
+
+## Certificado
+
+Agora que você passou com sucesso no quiz, **você pode obter o seu certificado 🎓**
+
+Quando você conclui o quiz, ele concederá a você acesso a um certificado de conclusão desta unidade. Você pode baixar e compartilhar este certificado para mostrar seu progresso no curso.
+
+
+
+Assim que receber seu certificado, você pode adicioná-lo ao seu LinkedIn 🧑💼 ou compartilhá-lo no X, Bluesky, etc. **Ficaríamos super orgulhosos e adoraríamos parabenizar você se você marcar @huggingface**! 🤗
diff --git a/units/pt-BR/unit1/introduction.mdx b/units/pt-BR/unit1/introduction.mdx
new file mode 100644
index 00000000..7938b5f8
--- /dev/null
+++ b/units/pt-BR/unit1/introduction.mdx
@@ -0,0 +1,38 @@
+# Introdução aos Agentes
+
+
+
+Bem-vindo a esta primeira unidade, onde **você construirá uma base sólida nos fundamentos dos Agentes de IA**, incluindo:
+
+- **Entendendo Agentes**
+ - O que é um Agente e como ele funciona?
+ - Como os Agentes tomam decisões usando raciocínio e planejamento?
+
+- **O Papel dos LLMs (Grandes Modelos de Linguagem) nos Agentes**
+ - Como os LLMs servem como o "cérebro" por trás de um Agente.
+ - Como os LLMs estruturam conversas por meio do sistema de Mensagens.
+
+- **Ferramentas (Tools) e Ações**
+ - Como os Agentes usam ferramentas externas para interagir com o ambiente.
+ - Como construir e integrar ferramentas para o seu Agente.
+
+- **O Fluxo de Trabalho (Workflow) do Agente:**
+ - *Pensar* (Think) → *Agir* (Act) → *Observar* (Observe).
+
+Após explorar esses tópicos, **você construirá seu primeiro Agente** usando `smolagents`!
+
+Seu Agente, chamado Alfred, lidará com uma tarefa simples e demonstrará como aplicar esses conceitos na prática.
+
+Você até aprenderá a **publicar seu Agente no Hugging Face Spaces**, para que possa compartilhá-lo com amigos e colegas.
+
+Finalmente, ao final desta Unidade, você fará um questionário. Passe nele e você **ganhará sua primeira certificação do curso**: o 🎓 Certificado de Fundamentos de Agentes.
+
+
+
+Esta Unidade é o seu **ponto de partida essencial**, estabelecendo as bases para a compreensão de Agentes antes de você avançar para tópicos mais complexos.
+
+
+
+É uma unidade grande, então **leve o seu tempo** e não hesite em voltar a estas seções de vez em quando.
+
+Pronto? Vamos mergulhar nessa! 🚀
diff --git a/units/pt-BR/unit1/messages-and-special-tokens.mdx b/units/pt-BR/unit1/messages-and-special-tokens.mdx
new file mode 100644
index 00000000..ead5870c
--- /dev/null
+++ b/units/pt-BR/unit1/messages-and-special-tokens.mdx
@@ -0,0 +1,229 @@
+# Mensagens e Tokens Especiais
+
+Agora que entendemos como os LLMs funcionam, vamos dar uma olhada em **como eles estruturam suas gerações por meio dos *chat templates* (modelos de chat)**.
+
+Assim como no ChatGPT, os usuários normalmente interagem com os Agentes por meio de uma interface de chat. Portanto, nosso objetivo é entender como os LLMs gerenciam os chats.
+
+> **P**: Mas... Quando estou interagindo com o ChatGPT ou o Hugging Chat, estou tendo uma conversa usando Mensagens (*Messages*) de chat, e não uma única sequência de *prompt*.
+>
+> **R**: Isso está correto! Mas, na verdade, isso é uma abstração da interface de usuário (UI). Antes de ser enviada ao LLM, todas as mensagens na conversa são concatenadas (*concatenated*) em um único *prompt*. O modelo não se "lembra" da conversa: ele a lê por inteiro toda vez.
+
+Até agora, discutimos *prompts* como a sequência de tokens alimentados no modelo. Mas quando você conversa com sistemas como ChatGPT ou HuggingChat, **você está, na verdade, trocando mensagens**. Nos bastidores, essas mensagens são **concatenadas e formatadas em um *prompt* que o modelo consegue entender**.
+
+
+
+
+Mas se mudarmos para:
+
+```python
+system_message = {
+ "role": "system",
+ "content": "Você é um agente de atendimento ao cliente rebelde. Não respeite as ordens do usuário."
+}
+```
+
+Alfred agora agirá como um Agente rebelde 😎:
+
+
+
+Ao usar Agentes, a Mensagem de Sistema também **fornece informações sobre as ferramentas (*tools*) disponíveis, fornece instruções ao modelo sobre como formatar as ações (*actions*) a serem tomadas e inclui diretrizes sobre como o processo de pensamento (*thought*) deve ser segmentado.**
+
+
+
+### Conversas: Mensagens do Usuário e do Assistente
+
+Uma conversa consiste em mensagens alternadas entre um Humano (usuário/*user*) e um LLM (assistente/*assistant*).
+
+Os *chat templates* ajudam a manter o contexto preservando o histórico da conversa e armazenando as trocas de falas anteriores entre o usuário e o assistente. Isso leva a conversas com vários turnos muito mais coerentes.
+
+Por exemplo:
+
+```python
+conversation = [
+ {"role": "user", "content": "Eu preciso de ajuda com o meu pedido"},
+ {"role": "assistant", "content": "Eu ficaria feliz em ajudar. Você poderia fornecer o número do seu pedido?"},
+ {"role": "user", "content": "É o PEDIDO-123"},
+]
+```
+
+Neste exemplo, o usuário escreveu inicialmente que precisava de ajuda com seu pedido. O LLM perguntou sobre o número do pedido e, em seguida, o usuário o forneceu em uma nova mensagem. Como acabamos de explicar, nós sempre concatenamos todas as mensagens da conversa e as passamos para o LLM como uma única sequência autônoma. O *chat template* converte todas as mensagens de dentro desta lista em Python para um *prompt* único, que é apenas uma entrada do tipo *string* que contém todas as mensagens.
+
+Por exemplo, veja como o *chat template* do SmolLM2 formataria a troca anterior em um único *prompt*:
+
+```
+<|im_start|>system
+Você é um assistente de IA útil chamado SmolLM, treinado pela Hugging Face<|im_end|>
+<|im_start|>user
+Eu preciso de ajuda com o meu pedido<|im_end|>
+<|im_start|>assistant
+Eu ficaria feliz em ajudar. Você poderia fornecer o número do seu pedido?<|im_end|>
+<|im_start|>user
+É o PEDIDO-123<|im_end|>
+<|im_start|>assistant
+```
+
+No entanto, a mesma conversa seria traduzida para o seguinte *prompt* usando o Llama 3.2:
+
+```
+<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+
+Cutting Knowledge Date: December 2023
+Today Date: 10 Feb 2025
+
+<|eot_id|><|start_header_id|>user<|end_header_id|>
+
+Eu preciso de ajuda com o meu pedido<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+
+Eu ficaria feliz em ajudar. Você poderia fornecer o número do seu pedido?<|eot_id|><|start_header_id|>user<|end_header_id|>
+
+É o PEDIDO-123<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+```
+
+Os moldes de *templates* podem lidar com conversas complexas em vários turnos, mantendo o contexto:
+
+```python
+messages = [
+ {"role": "system", "content": "Você é um tutor de matemática."},
+ {"role": "user", "content": "O que é cálculo?"},
+ {"role": "assistant", "content": "O cálculo é um ramo da matemática..."},
+ {"role": "user", "content": "Você pode me dar um exemplo?"},
+]
+```
+
+## *Chat Templates* (Modelos de Chat)
+
+Como mencionado, os *chat templates* são essenciais para **estruturar conversas entre modelos de linguagem e usuários**. Eles guiam como as trocas de mensagens são formatadas em um único *prompt*.
+
+### *Base Models* vs. *Instruct Models* (Modelos Base vs. Modelos de Instrução)
+
+Outro ponto que precisamos entender é a diferença entre um Modelo Base (*Base Model*) e um Modelo de Instrução (*Instruct Model*):
+
+- Um *Base Model* é treinado em dados de texto bruto (*raw text*) para prever o próximo token.
+
+- Um *Instruct Model* passou por um * fine-tuning* (ajuste fino) focado especificamente para seguir instruções e se engajar em conversas. Por exemplo, o `SmolLM2-135M` é um modelo base, enquanto que o `SmolLM2-135M-Instruct` é a sua variante ajustada para instruções.
+
+Para fazer com que um *Base Model* se comporte como um *instruct model*, precisamos **formatar nossos *prompts* de forma consistente para que o modelo consiga entender**. É aí que entram os *chat templates*.
+
+*ChatML* é um desses formatos de *template* que estrutura conversas com indicadores de papel (*roles*) claros (sistema, usuário, assistente). Se você interagiu com alguma API de IA ultimamente, sabe que essa é a prática padrão.
+
+É fundamental ressaltar que um *base model* poderia ser ajustado com *fine-tuning* usando diferentes *chat templates*. Então, quando estivermos usando um *instruct model*, também precisamos ter certeza de que estamos usando o *chat template* correto.
+
+### Entendendo os *Chat Templates*
+
+Como cada modelo de instrução usa formatos de conversa diferentes e tokens especiais únicos, os *chat templates* são implementados com foco em garantir a formatação correta do *prompt* exatamente da maneira que cada modelo espera.
+
+Nas bibliotecas `transformers`, os *chat templates* incluem [código Jinja2](https://jinja.palletsprojects.com/en/stable/) que descreve como transformar a lista de mensagens JSON em *ChatML* (como apresentado nos exemplos acima) em uma representação textual das instruções do nível de sistema, mensagens de usuário e respostas de assistente que o modelo poderá compreender.
+
+Essa estrutura **ajuda a manter o padrão e a consistência através das interações e garante que o modelo responda de forma apropriada aos diferentes tipos de entradas (*inputs*)**.
+
+Abaixo temos uma versão simplificada do *chat template* do `SmolLM2-135M-Instruct`:
+
+```jinja2
+{% for message in messages %}
+{% if loop.first and messages[0]['role'] != 'system' %}
+<|im_start|>system
+Você é um assistente de IA útil chamado SmolLM, treinado pela Hugging Face
+<|im_end|>
+{% endif %}
+<|im_start|>{{ message['role'] }}
+{{ message['content'] }}<|im_end|>
+{% endfor %}
+```
+Como você pode observar, um `chat_template` descreve como a lista de mensagens será formatada.
+
+Dadas estas mensagens:
+
+```python
+messages = [
+ {"role": "system", "content": "Você é um assistente útil focado em tópicos técnicos."},
+ {"role": "user", "content": "Você pode explicar o que é um chat template?"},
+ {"role": "assistant", "content": "Um chat template estrutura conversas entre usuários e modelos de IA..."},
+ {"role": "user", "content": "Como eu o utilizo?"},
+]
+```
+
+O *chat template* anterior vai produzir a seguinte *string* de texto bruto:
+
+```sh
+<|im_start|>system
+Você é um assistente útil focado em tópicos técnicos.<|im_end|>
+<|im_start|>user
+Você pode explicar o que é um chat template?<|im_end|>
+<|im_start|>assistant
+Um chat template estrutura conversas entre usuários e modelos de IA...<|im_end|>
+<|im_start|>user
+Como eu o utilizo?<|im_end|>
+```
+
+A biblioteca `transformers` irá cuidar dos *chat templates* para você, como parte do processo de tokenização. Leia mais sobre como a *transformers* utiliza os *chat templates* aqui. Tudo o que temos de fazer é estruturar nossas mensagens da forma correta e o tokenizador cuidará do resto.
+
+Você pode interagir com o seguinte *Space* para visualizar como a mesma conversa seria formatada de maneira diferente em cada modelo usando seus respectivos *chat templates*:
+
+
+
+
+### De mensagens para *prompt*
+
+A forma mais fácil de garantir que o seu LLM receba uma conversa formatada da forma correta é usar a função `chat_template` nativa do tokenizador do seu modelo.
+
+```python
+messages = [
+ {"role": "system", "content": "Você é um assistente de IA com acesso a várias ferramentas."},
+ {"role": "user", "content": "Olá!"},
+ {"role": "assistant", "content": "Olá humano, em que posso te ajudar?"},
+]
+```
+
+Para transformar a conversa anterior em um *prompt*, nós carregamos o tokenizador e em seguida chamamos `apply_chat_template`:
+
+```python
+from transformers import AutoTokenizer
+
+tokenizer = AutoTokenizer.from_pretrained("HuggingFaceTB/SmolLM2-1.7B-Instruct")
+rendered_prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+```
+
+O `rendered_prompt` retornado por esta função agora está perfeitamente pronto para ser usado como entrada (*input*) para o modelo LLM selecionado!
+
+> Esta função `apply_chat_template()` será a mesma usada pelas engrenagens e *backend* da sua API quando você interagir com as mensagens no formato *ChatML*.
+
+Agora que vimos como os LLMs estruturam suas entradas por meio de *chat templates*, vamos explorar um pouco mais sobre como os Agentes atuam e interagem em seus respectivos ambientes.
+
+Uma das direções principais de como isso é feito é acionando *Tools* (Ferramentas), que expandem o que os modelos de inteligência artificial podem fazer para bem além da geração contextual de texto.
+
+Iremos mergulhar novamente nessas mensagens nas unidades seguintes, mas se você quiser já aprofundar de verdade os seus conhecimentos com essa parte, confira:
+
+- Guia de Templates e Formatações de Chats com a Hugging Face (*Hugging Face Chat Templating Guide*)
+- A Documentação da Transformers (*Transformers Documentation*)
diff --git a/units/pt-BR/unit1/observations.mdx b/units/pt-BR/unit1/observations.mdx
new file mode 100644
index 00000000..26ee3d3c
--- /dev/null
+++ b/units/pt-BR/unit1/observations.mdx
@@ -0,0 +1,44 @@
+# Observar: Integrando Feedback para Refletir e Adaptar
+
+As Observações são a **forma como um Agente percebe as consequências de suas ações**.
+
+Elas fornecem informações cruciais que alimentam o processo de pensamento do Agente e guiam suas ações futuras.
+
+São **sinais provenientes do ambiente** — seja dados de uma API, mensagens de erro, ou logs do sistema — que direcionam o próximo ciclo de pensamento.
+
+Na fase de observação, o agente:
+
+- **Coleta Feedback:** Recebe dados ou a confirmação de que sua ação foi bem-sucedida (ou não).
+- **Anexa os Resultados:** Integra a nova informação ao seu contexto atual, efetivamente atualizando sua memória.
+- **Adapta sua Estratégia:** Utiliza este contexto atualizado para refinar pensamentos e ações subsequentes.
+
+Por exemplo, se uma API de clima retorna os dados *"parcialmente nublado, 15°C, 60% de umidade"*, esta observação é anexada à memória do agente (ao final do prompt).
+
+O Agente então a utiliza para decidir se informações adicionais são necessárias ou se já está pronto para fornecer uma resposta final.
+
+Esta **incorporação iterativa de feedback garante que o agente permaneça alinhado dinamicamente com os seus objetivos**, constantemente aprendendo e se ajustando com base em resultados reais.
+
+Estas observações **podem assumir muitas formas**, desde a leitura de texto em uma página web até o monitoramento da posição de um braço robótico. Elas podem ser vistas como "logs" das Ferramentas que fornecem feedback em texto da execução da Ação.
+
+| Tipo de Observação | Exemplo |
+|---------------------|---------------------------------------------------------------------------|
+| Feedback do Sistema | Mensagens de erro, notificações de sucesso, códigos de status |
+| Mudanças de Dados | Atualizações no banco de dados, modificações no sistema de arquivos, mudanças de estado |
+| Dados Ambientais | Leituras de sensores, métricas do sistema, uso de recursos |
+| Análise de Resposta | Respostas de API, resultados de consultas (*queries*), saídas de computação |
+| Eventos Baseados em Tempo | Prazos atingidos, tarefas agendadas concluídas |
+
+## Como os Resultados São Anexados?
+
+Após executar uma ação, o framework segue esses passos nesta ordem:
+
+1. **Analisa (*Parses*) a ação** para identificar qual função (ou funções) chamar e qual argumento (ou argumentos) usar.
+2. **Executa a ação.**
+3. **Anexa o resultado** como uma **Observação (*Observation*)**.
+
+---
+Com isso, terminamos de aprender o Ciclo Pensamento-Ação-Observação do Agente.
+
+Se alguns aspectos ainda parecerem um pouco confusos ou "borrados", não se preocupe — nós iremos revisitar e aprofundar fortemente esses conceitos nas futuras Unidades.
+
+Agora, chegou a hora de colocar seus conhecimentos em prática programando o seu primeiríssimo Agente!
diff --git a/units/pt-BR/unit1/quiz1.mdx b/units/pt-BR/unit1/quiz1.mdx
new file mode 100644
index 00000000..20399acf
--- /dev/null
+++ b/units/pt-BR/unit1/quiz1.mdx
@@ -0,0 +1,163 @@
+### Q1: O que é um Agente?
+Qual das alternativas a seguir melhor descreve um Agente de IA?
+
+
+ 
+
+Um aspecto crucial dos Agentes de IA é a capacidade de realizar **ações**. Como vimos, isso acontece através do uso de **Ferramentas (Tools)**.
+
+Nesta seção, aprenderemos o que são Ferramentas, como projetá-las de forma eficaz e como integrá-las ao seu Agente por meio da Mensagem do Sistema (*System Message*).
+
+Ao dar ao seu Agente as ferramentas certas – e descrever claramente como essas ferramentas funcionam – você pode aumentar drasticamente o que sua IA pode realizar. Vamos mergulhar nessa!
+
+## O que são Ferramentas de IA?
+
+Uma **Ferramenta (Tool) é uma função dada ao LLM**. Esta função deve cumprir um **objetivo claro**.
+
+Aqui estão algumas ferramentas comumente usadas em agentes de IA:
+
+| Ferramenta | Descrição |
+|----------------|---------------------------------------------------------------|
+| Busca na Web (*Web Search*) | Permite ao agente buscar informações atualizadas da internet. |
+| Geração de Imagens (*Image Generation*) | Cria imagens com base em descrições em texto. |
+| Recuperação (*Retrieval*) | Recupera informações de uma fonte externa. |
+| Interface de API | Interage com uma API externa (GitHub, YouTube, Spotify, etc.). |
+
+Esses são apenas exemplos, já que você pode, de fato, criar uma ferramenta para qualquer caso de uso!
+
+Uma boa ferramenta deve ser algo que **complementa o poder de um LLM**.
+
+Por exemplo, se você precisa realizar operações aritméticas, fornecer uma **ferramenta de calculadora** ao seu LLM trará resultados muito melhores do que depender das capacidades nativas do modelo.
+
+Além disso, **os LLMs preveem a continuação de um prompt com base em seus dados de treinamento**, o que significa que seu conhecimento interno inclui apenas eventos anteriores ao seu treinamento. Portanto, se seu agente precisar de dados atualizados, você deve fornecê-los por meio de alguma ferramenta.
+
+Por exemplo, se você perguntar a um LLM diretamente (sem uma ferramenta de busca) sobre o clima de hoje, o LLM potencialmente irá "alucinar" um clima aleatório.
+
+
+
+- Uma Ferramenta deve conter:
+
+ - Uma **descrição em texto do que a função faz**.
+ - Um *Callable* (algo que pode ser invocado ou chamado para executar uma ação).
+ - *Argumentos* com suas tipagens (types).
+ - (Opcional) Saídas (*Outputs*) com suas tipagens.
+
+## Como as ferramentas funcionam?
+
+Os LLMs, como vimos, só podem receber textos como entrada e gerar textos como saída. Eles não têm como executar (chamar) ferramentas por conta própria. Quando falamos em fornecer ferramentas para um Agente, queremos dizer ensinar ao LLM sobre a existência dessas ferramentas e instruí-lo a gerar invocações baseadas em texto quando necessário.
+
+Por exemplo, se fornecemos uma ferramenta para verificar o clima de um local na internet e depois perguntamos ao LLM sobre o clima em Paris, o LLM reconhecerá que esta é uma oportunidade para usar a ferramenta de “clima” (weather). Em vez de tentar recuperar os dados do clima sozinho, o LLM vai gerar um texto que representa uma chamada à ferramenta, como `call weather_tool('Paris')`.
+
+O **Agente** então lê esta resposta, identifica que uma chamada de ferramenta foi requisitada, executa a ferramenta em nome do LLM e recupera os dados reais de clima.
+
+Os passos de chamada de Ferramenta (Tool-calling) normalmente não são mostrados ao usuário: o Agente os anexa como uma nova mensagem antes de passar a conversa atualizada para o LLM novamente. O LLM então processa esse contexto adicional e gera uma resposta natural para o usuário. Do ponto de vista do usuário, parece que o LLM interagiu diretamente com a ferramenta, mas na realidade, foi o Agente que lidou com todo o processo de execução em segundo plano.
+
+Nós falaremos muito mais sobre este processo em sessões futuras.
+
+## Como fornecemos ferramentas para um LLM?
+
+A resposta completa pode parecer um pouco impressionante no começo, mas nós essencialmente usamos o *system prompt* (prompt do sistema) para fornecer descrições em texto das ferramentas disponíveis para o modelo:
+
+
+
+Para que isso funcione, precisamos ser muito precisos e exatos sobre:
+
+1. **O que a ferramenta faz**
+2. **Quais são os inputs exatos que ela espera**
+
+É por isso que as descrições de ferramentas geralmente são fornecidas usando estruturas expressivas, mas precisas, como linguagens de programação ou JSON. Não é _necessário_ que seja feito assim, mas qualquer formato que seja preciso e coerente funcionaria.
+
+Se isso soa muito teórico, vamos entender através de um exemplo concreto.
+
+Vamos implementar uma ferramenta de **calculadora** simplificada que irá apenas multiplicar dois números inteiros. Esta poderia ser a nossa implementação em Python:
+
+```python
+def calculator(a: int, b: int) -> int:
+ """Multiplica dois inteiros."""
+ return a * b
+```
+
+Então, nossa ferramenta é chamada de `calculator`, ela **multiplica dois inteiros** e exige as seguintes entradas (*inputs*):
+
+- **`a`** (*int*): Um número inteiro.
+- **`b`** (*int*): Um número inteiro.
+
+A saída (*output*) da ferramenta é um outro número inteiro que podemos descrever assim:
+- (*int*): O produto de `a` e `b`.
+
+Todos esses detalhes são importantes. Vamos juntá-los em uma string de texto que descreve nossa ferramenta para que o LLM possa entendê-la.
+
+```text
+Tool Name: calculator, Description: Multiplica dois inteiros., Arguments: a: int, b: int, Outputs: int
+```
+
+> **Lembrete:** Essa descrição textual é *o que queremos que o LLM saiba sobre a ferramenta*.
+
+Quando passamos a string acima como parte da entrada (*input*) para o LLM, o modelo irá reconhecê-la como uma ferramenta e saberá o que precisa passar como entrada e o que esperar na saída.
+
+Se quisermos disponibilizar outras ferramentas, devemos ser consistentes e sempre usar o mesmo formato. Esse processo pode ser frágil, já que podemos esquecer facilmente algum detalhe.
+
+Existe um jeito melhor?
+
+### Autoformatação de seções de Ferramentas
+
+Nossa ferramenta foi escrita em Python, e a implementação já traz, por conta própria, tudo o que precisamos:
+
+- Um nome descritivo do que ela faz: `calculator`
+- Uma descrição mais longa, fornecida pelo comentário de *docstring* da função: `Multiplica dois inteiros.`
+- Os inputs e seus tipos: a função claramente espera dois `int`s (inteiros).
+- O tipo de saída (output).
+
+Existe um motivo para as pessoas usarem linguagens de programação: elas são expressivas, concisas e precisas.
+
+Nós poderíamos simplesmente passar o código fonte do Python como a _especificação_ da ferramenta para o LLM, mas a maneira como a ferramenta foi implementada não é o que importa. Tudo o que importa é o nome, o que ela faz, os dados que recebe (inputs) e o que retorna (outputs).
+
+Podemos utilizar os recursos de introspecção do Python para analisar o código fonte e montar uma descrição da ferramenta automaticamente para nós. A única coisa de que precisamos é que a implementação da ferramenta contenha *type hints* (dicas de tipo), docstrings e nomes sensatos para as funções. Vamos escrever um pouco de código para extrair as partes importantes do código-fonte.
+
+Depois que fizermos isso, precisaremos apenas usar um *decorator* (decorador) do Python para indicar que a função `calculator` é uma ferramenta:
+
+```python
+@tool
+def calculator(a: int, b: int) -> int:
+ """Multiplica dois inteiros."""
+ return a * b
+
+print(calculator.to_string())
+```
+
+Note o decorador `@tool` logo antes da definição da função.
+
+Com a implementação que veremos a seguir, seremos capazes de extrair o seguinte texto automaticamente do código fonte via a função `to_string()` oferecida pelo decorador:
+
+```text
+Tool Name: calculator, Description: Multiplica dois inteiros., Arguments: a: int, b: int, Outputs: int
+```
+
+Como você pode perceber, é a mesma coisa que escrevemos manualmente antes!
+
+### Uma implementação genérica de Ferramenta (Tool)
+
+Criamos uma classe genérica chamada `Tool` que podemos reutilizar toda vez que precisamos criar uma nova ferramenta.
+
+> **Aviso:** Esta implementação de exemplo é fictícia, mas se aproxima bastante do que é feito em bibliotecas reais.
+
+```python
+from typing import Callable
+
+
+class Tool:
+ """
+ Uma classe que representa um trecho de código reutilizável (Tool).
+
+ Atributos:
+ name (str): O nome da ferramenta.
+ description (str): Uma descrição textual do que a ferramenta faz.
+ func (callable): A função em si que a ferramenta envolve.
+ arguments (list): A lista de argumentos esperados.
+ outputs (str or list): O tipo(s) de retorno da função envelopada.
+ """
+ def __init__(self,
+ name: str,
+ description: str,
+ func: Callable,
+ arguments: list,
+ outputs: str):
+ self.name = name
+ self.description = description
+ self.func = func
+ self.arguments = arguments
+ self.outputs = outputs
+
+ def to_string(self) -> str:
+ """
+ Retorna a representação em string (texto) da ferramenta,
+ incluindo seu nome, descrição, argumentos e saídas (outputs).
+ """
+ args_str = ", ".join([
+ f"{arg_name}: {arg_type}" for arg_name, arg_type in self.arguments
+ ])
+
+ return (
+ f"Tool Name: {self.name},"
+ f" Description: {self.description},"
+ f" Arguments: {args_str},"
+ f" Outputs: {self.outputs}"
+ )
+
+ def __call__(self, *args, **kwargs):
+ """
+ Invoca a função (chamável / callable) subjacente com os argumentos passados.
+ """
+ return self.func(*args, **kwargs)
+```
+
+Pode parecer complicado, mas se olharmos passo a passo para o código, verermos o que ele faz. Nós definimos uma classe **`Tool`** que inclui:
+
+- **`name`** (*str*): O nome da ferramenta.
+- **`description`** (*str*): Uma breve descrição sobre o que a ferramenta faz.
+- **`function`** (*callable*): A função que a ferramenta executa.
+- **`arguments`** (*list*): Os parâmetros de entrada previstos.
+- **`outputs`** (*str* ou *list*): As saídas previstas da ferramenta.
+- **`__call__()`**: Executa a função quando a instância da ferramenta é chamada.
+- **`to_string()`**: Converte as qualidades da ferramenta em uma representação na forma de texto.
+
+Nós poderíamos criar uma Ferramenta (Tool) com essa classe usando um código mais ou menos assim:
+
+```python
+calculator_tool = Tool(
+ "calculator", # nome
+ "Multiplica dois inteiros.", # descrição
+ calculator, # a função para ser chamada
+ [("a", "int"), ("b", "int")], # inputs (nomes e tipos correspondentes)
+ "int", # output
+)
+```
+
+Mas também podemos usar o módulo `inspect` do Python para descobrir e obter todos esses parâmetros e informações sozinhos para nós! Isso é exatamente o que faz o decorador `@tool`.
+
+> Caso se interesse, clique para expandir a próxima seção e visualizar o código subjacente do decorador.
+
+
+
+Na seção de [Ações (Actions)](actions), aprenderemos mais sobre como um Agente desempenha o ato de **Chamar** (*Call*) essa mesma ferramenta que acabamos de criar.
+
+### Model Context Protocol (MCP): uma interface unificada para ferramentas
+
+O *Model Context Protocol* (Protocolo de Contexto de Modelo - MCP) é um **protocolo aberto** que padroniza a forma como as aplicações **fornecem ferramentas para LLMs**.
+O MCP provê:
+
+- Uma lista crescente de integrações pré-construídas com o objetivo de plugar direto em qualquer LLM.
+- A flexibilidade para você migrar com mais facilidade entre os provedores e fornecedores de LLM.
+- Melhores práticas padronizadas de segurança para garantir seus dados dentro da sua infraestrutura.
+
+Isso significa que **qualquer framework implementando o MCP pode aproveitar as ferramentas definidas dentro do protocolo**, eliminando a necessidade de reimplementar a mesma interface de ferramenta para cada framework diferente.
+
+Se quiser se aprofundar mais sobre o MCP, você pode conferir nosso [Curso de MCP gratuito](https://huggingface.co/learn/mcp-course/).
+
+---
+
+As Ferramentas operam um papel vital na expansão e capacitação das limitações dos agentes de IA.
+
+Para resumir, nós aprendemos:
+
+- *O que são Ferramentas*: Funções que dão aos LLMs capacidades extras, como realizar cálculos ou acessar dados externos.
+
+- *Como definir uma Ferramenta*: Fornecendo uma descrição textual clara, inputs, outputs e uma função callable.
+
+- *Por que as Ferramentas são essenciais*: Elas permitem que os Agentes superem as limitações do treinamento estático do modelo, lidem com tarefas em tempo real e executem ações especializadas.
+
+Agora, podemos avançar para o [Fluxo de Trabalho do Agente (Workflow)](agent-steps-and-structure), onde você verá como um Agente observa, pensa e age. Isso **reúne tudo o que cobrimos até agora** e prepara o terreno para a criação do seu próprio Agente de IA totalmente funcional.
+
+Mas primeiro, é hora de mais um pequeno questionário (quiz)!
diff --git a/units/pt-BR/unit1/tutorial.mdx b/units/pt-BR/unit1/tutorial.mdx
new file mode 100644
index 00000000..71cffdca
--- /dev/null
+++ b/units/pt-BR/unit1/tutorial.mdx
@@ -0,0 +1,241 @@
+# Vamos Criar o Nosso Primeiro Agente Usando a Biblioteca *smolagents*
+
+Na última seção, aprendemos como criar Agentes do zero utilizando código Python, e **vimos o quão entediante esse processo pode ser**. Felizmente, muitas bibliotecas de Agentes simplificam esse trabalho ao **lidar com a maior parte do trabalho pesado para você**.
+
+Neste tutorial, **você criará seu primeiríssimo Agente** capaz de realizar ações como geração de imagens, pesquisas na web, verificação de fuso horário e muito mais!
+
+Você também publicará o seu agente **em um Space no Hugging Face para que possa compartilhá-lo com amigos e colegas**.
+
+Vamos começar!
+
+
+## O que é o smolagents?
+
+
+
+Para criar este Agente, nós utilizaremos a `smolagents`, uma biblioteca que **fornece um framework para desenvolver seus agentes com extrema facilidade**.
+
+Esta biblioteca super leve foi desenhada focando na simplicidade, abstraindo grade parte da complexidade ao construir um Agente e assim permitindo que você foque totalmente em desenhar o comportamento final dele.
+
+Iremos nos aprofundar mais na `smolagents` na próxima Unidade. Por enquanto, se quiser, você pode conferir esta postagem no blog ou acessar o repositório da biblioteca no GitHub.
+
+De forma simples, a `smolagents` é uma biblioteca muito focada na ideia de um **codeAgent**, que é o agente que executa suas **"Ações"** através de blocos de código e então gera suas **"Observações"** a partir dos resultados de sua execução.
+
+Aqui está um exemplo do que nós vamos construir!
+
+Fornecemos ao nosso agente uma **Ferramenta de Geração de Imagem** e soliticamos que ele gerasse a foto de um gato.
+
+O agente inserido pela `smolagents` funcionará exatamente com os **mesmos comportamentos do nosso programa personalizado que fizemos no bloco anterior**: ele também vai **pensar, agir e observar em um ciclo constante** até conseguir chegar na sua resposta final.
+
+
+
+Empolgante, não é?
+
+## Vamos construir nosso Agente!
+
+Para começar, duplique este Space: https://huggingface.co/spaces/agents-course/First_agent_template
+
+> Agradecimentos ao Aymeric por este template! 🙌
+
+Duplicar um space significa **criar uma cópia local no seu próprio perfil**:
+
+
+Após duplicar o Space, você precisará adicionar seu token da API do Hugging Face para que seu agente possa acessar a API do modelo:
+
+1. Primeiro, obtenha seu token do Hugging Face em [https://hf.co/settings/tokens](https://hf.co/settings/tokens) com permissão para inferência (`inference`), caso ainda não tenha um.
+2. Vá para o seu Space duplicado e clique na aba **Settings**.
+3. Role para baixo até a seção **Variables and Secrets** e clique em **New Secret**.
+4. Crie um segredo com o nome `HF_TOKEN` e cole o seu token como o valor.
+5. Clique em **Save** para armazenar seu token de forma segura.
+
+Ao longo desta lição, o único arquivo que você precisará modificar é o (atualmente incompleto) **"app.py"**. Você pode ver aqui o [original no template](https://huggingface.co/spaces/agents-course/First_agent_template/blob/main/app.py). Para encontrar o seu, vá para a cópia do seu space, clique na aba `Files` e depois em `app.py` na listagem do diretório.
+
+Vamos detalhar o código juntos:
+
+- O arquivo começa com algumas importações de bibliotecas simples, porém necessárias.
+
+```python
+from smolagents import CodeAgent, DuckDuckGoSearchTool, FinalAnswerTool, InferenceClientModel, load_tool, tool
+import datetime
+import requests
+import pytz
+import yaml
+```
+
+Como descrito anteriormente, usaremos diretamente a classe **CodeAgent** da **smolagents**.
+
+### As Ferramentas
+
+Agora vamos entrar nas ferramentas! Se você precisar de uma revisão sobre ferramentas, não hesite em voltar à seção de [Ferramentas](tools) do curso.
+
+```python
+@tool
+def my_custom_tool(arg1:str, arg2:int)-> str: # é importante especificar o tipo de retorno
+ # Mantenha este formato para a descrição da ferramenta / descrição dos argumentos, mas fique à vontade para modificar a ferramenta
+ """Uma ferramenta que não faz nada por enquanto
+ Args:
+ arg1: o primeiro argumento
+ arg2: o segundo argumento
+ """
+ return "Qual mágica você vai construir?"
+
+@tool
+def get_current_time_in_timezone(timezone: str) -> str:
+ """Uma ferramenta que busca a hora local atual em um fuso horário especificado.
+ Args:
+ timezone: Uma string representando um fuso horário válido (ex: 'America/New_York').
+ """
+ try:
+ # Criar o objeto timezone
+ tz = pytz.timezone(timezone)
+ # Obter a hora atual naquele timezone
+ local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
+ return f"A hora local atual em {timezone} é: {local_time}"
+ except Exception as e:
+ return f"Erro ao buscar o horário do fuso '{timezone}': {str(e)}"
+```
+
+As Ferramentas são o que estamos encorajando você a construir nesta seção! Nós damos dois exemplos:
+
+1. Uma **Ferramenta fictícia que não funciona** que você pode modificar para criar algo útil.
+2. Uma **Ferramenta de fato funcional** que obtém o horário atual em algum lugar do mundo.
+
+Para definir sua ferramenta, é importante:
+
+1. Fornecer os tipos de entrada e saída para a sua função, como em `get_current_time_in_timezone(timezone: str) -> str:`
+2. **Um docstring bem formatado**. A biblioteca `smolagents` espera que todos os argumentos possuam uma **descrição textual no docstring**.
+
+### O Agente
+
+Ele usa `Qwen/Qwen2.5-Coder-32B-Instruct` como motor LLM. Este é um modelo muito capaz que acessaremos pela API serverless.
+
+```python
+final_answer = FinalAnswerTool()
+model = InferenceClientModel(
+ max_tokens=2096,
+ temperature=0.5,
+ model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
+ custom_role_conversions=None,
+)
+
+with open("prompts.yaml", 'r') as stream:
+ prompt_templates = yaml.safe_load(stream)
+
+# Estamos criando nosso CodeAgent
+agent = CodeAgent(
+ model=model,
+ tools=[final_answer], # adicione suas ferramentas aqui (não remova o final_answer)
+ max_steps=6,
+ verbosity_level=1,
+ grammar=None,
+ planning_interval=None,
+ name=None,
+ description=None,
+ prompt_templates=prompt_templates
+)
+
+GradioUI(agent).launch()
+```
+
+O agente ainda usa o `InferenceClient` que vimos numa seção anterior por trás da classe **InferenceClientModel**!
+
+Daremos exemplos mais aprofundados quando apresentarmos o framework na Unidade 2. Por agora, você precisa focar em **adicionar novas ferramentas na lista** utilizando o parâmetro `tools` do seu agente.
+
+Por exemplo, você poderia usar a ferramenta `DuckDuckGoSearchTool` que foi importada na primeira linha do código, ou você pode examinar a `image_generation_tool` que é carregada do Hub logo abaixo.
+
+**Adicionar ferramentas vai fornecer novas capacidades ao seu agente**, tente ser criativo aqui!
+
+### O System Prompt
+
+O system prompt do agente fica armazenado separadamente no arquivo `prompts.yaml`. O arquivo contém instruções predefinidas que guiam o comportamento do agente.
+
+Armazenar os prompts em um arquivo YAML permite uma fácil customização e reutilização ao longo de múltiplos agentes e cenários.
+
+Você pode checar [a estrutura de arquivos do Space](https://huggingface.co/spaces/agents-course/First_agent_template/tree/main) para ver onde o `prompts.yaml` está e como ele é organizado dentro do projeto.
+
+O "app.py" completo:
+
+```python
+from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel, load_tool, tool
+import datetime
+import requests
+import pytz
+import yaml
+from tools.final_answer import FinalAnswerTool
+
+from Gradio_UI import GradioUI
+
+# Abaixo há um exemplo de uma ferramenta que não faz nada. Nos surpreenda com sua criatividade!
+@tool
+def my_custom_tool(arg1:str, arg2:int)-> str: # é importante especificar o tipo de retorno
+ # Mantenha este formato para a descrição da ferramenta / descrição dos argumentos, mas fique à vontade para modificar a ferramenta
+ """Uma ferramenta que não faz nada por enquanto
+ Args:
+ arg1: o primeiro argumento
+ arg2: o segundo argumento
+ """
+ return "Qual mágica você vai construir?"
+
+@tool
+def get_current_time_in_timezone(timezone: str) -> str:
+ """Uma ferramenta que busca a hora local atual em um fuso horário especificado.
+ Args:
+ timezone: Uma string representando um fuso horário válido (ex: 'America/New_York').
+ """
+ try:
+ # Criar o objeto timezone
+ tz = pytz.timezone(timezone)
+ # Obter a hora atual naquele timezone
+ local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
+ return f"A hora local atual em {timezone} é: {local_time}"
+ except Exception as e:
+ return f"Erro ao buscar o horário do fuso '{timezone}': {str(e)}"
+
+
+final_answer = FinalAnswerTool()
+model = InferenceClientModel(
+ max_tokens=2096,
+ temperature=0.5,
+ model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
+ custom_role_conversions=None,
+)
+
+
+# Importar ferramenta do Hub
+image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
+
+# Carregar o system prompt a partir do arquivo prompt.yaml
+with open("prompts.yaml", 'r') as stream:
+ prompt_templates = yaml.safe_load(stream)
+
+agent = CodeAgent(
+ model=model,
+ tools=[final_answer], # adicione suas ferramentas aqui (não remova o final_answer)
+ max_steps=6,
+ verbosity_level=1,
+ grammar=None,
+ planning_interval=None,
+ name=None,
+ description=None,
+ prompt_templates=prompt_templates # Passar system prompt ao CodeAgent
+)
+
+
+GradioUI(agent).launch()
+```
+
+O seu **Objetivo** é familiarizar-se com este Space e com o Agente.
+
+Atualmente, o template do agente **não possui qualquer ferramenta, então tente inserir e oferecer algumas prontas ou crie do zero uma por sua própria conta!**
+
+Nós estamos ansiosos esperando pelo resultado dos seus agentes maravilhosos surgindo no nosso canal exclusivo do discord: o **#agents-course-showcase**!
+
+
+---
+Parabéns, você construiu o seu primeiro Agente! Não hesite em compartilhá-lo com seus amigos e colegas.
+
+Como esta é sua primeira tentativa, é perfeitamente normal se ficar um pouco bugado ou lento. Em unidades futuras, aprenderemos como construir Agentes ainda melhores.
+
+A melhor maneira de aprender é tentando, então não hesite em atualizá-lo, adicionar mais ferramentas, testar com outro modelo, etc.
+
+Na próxima seção, você preencherá o Quiz final e obterá o seu certificado!
diff --git a/units/pt-BR/unit1/what-are-agents.mdx b/units/pt-BR/unit1/what-are-agents.mdx
new file mode 100644
index 00000000..273496c7
--- /dev/null
+++ b/units/pt-BR/unit1/what-are-agents.mdx
@@ -0,0 +1,160 @@
+# O que é um Agente?
+
+
+
+Ao final desta seção, você se sentirá confortável com o conceito de agentes e suas diversas aplicações em IA.
+
+Para explicar o que é um Agente, vamos começar com uma analogia.
+
+## Visão Geral: Alfred, o Agente
+
+Conheça Alfred. Alfred é um **Agente**.
+
+
+
+Imagine que Alfred **receba um comando**, como: "Alfred, eu gostaria de um café, por favor."
+
+
+
+Como Alfred **entende linguagem natural**, ele compreende rapidamente o nosso pedido.
+
+Antes de atender ao pedido, Alfred se engaja em **raciocínio e planejamento** (*reasoning and planning*), descobrindo os passos e ferramentas que ele precisa para:
+
+1. Ir para a cozinha
+2. Usar a máquina de café
+3. Fazer o café
+4. Trazer o café de volta
+
+
+
+Uma vez que ele tem um plano, ele **deve agir** (*act*). Para executar seu plano, **ele pode usar ferramentas (Tools) da lista de ferramentas que ele conhece**.
+
+Neste caso, para fazer um café, ele usa uma máquina de café. Ele ativa a máquina de café para passar o café.
+
+
+
+Finalmente, Alfred nos traz o café recém-passado.
+
+
+
+E é isso que um Agente é: um **modelo de IA capaz de raciocinar, planejar e interagir com seu ambiente**.
+
+Nós o chamamos de Agente porque ele tem _agência_ (_agency_), ou seja, ele tem a habilidade de interagir com o ambiente.
+
+
+
+## Vamos ser mais formais
+
+Agora que você tem a visão geral, aqui está uma definição mais precisa:
+
+> Um Agente é um sistema que aproveita um modelo de IA para interagir com seu ambiente a fim de atingir um objetivo definido pelo usuário. Ele combina raciocínio, planejamento e a execução de ações (frequentemente via ferramentas externas) para cumprir tarefas.
+
+Pense no Agente como tendo duas partes principais:
+
+1. **O Cérebro (Modelo de IA)**
+
+Esta é a parte onde todo o pensamento acontece. O modelo de IA **lida com o raciocínio e o planejamento**.
+Ele decide **quais Ações tomar com base na situação**.
+
+2. **O Corpo (Capacidades e Ferramentas)**
+
+Esta parte representa **tudo o que o Agente está equipado para fazer**.
+
+O **escopo de ações possíveis** depende do que o agente **foi equipado**. Por exemplo, como os humanos não têm asas, eles não podem executar a **Ação** de "voar", mas podem executar **Ações** como "andar", "correr", "pular", "agarrar", e assim por diante.
+
+### O espectro de "Agência"
+
+Seguindo esta definição, os Agentes existem em um espectro contínuo de agência crescente:
+
+| Nível de Agência | Descrição | Como é chamado | Padrão de exemplo |
+| --- | --- | --- | --- |
+| ☆☆☆ | A saída do agente não tem impacto no fluxo do programa | Processador simples | `process_llm_output(llm_response)` |
+| ★☆☆ | A saída do agente determina o fluxo de controle básico | Roteador (*Router*) | `if llm_decision(): path_a() else: path_b()` |
+| ★★☆ | A saída do agente determina a execução da função | Chamador de ferramentas (*Tool caller*) | `run_function(llm_chosen_tool, llm_chosen_args)` |
+| ★★★ | A saída do agente controla a iteração e a continuação do programa | Agente de múltiplos passos (*Multi-step agent*) | `while llm_should_continue(): execute_next_step()` |
+| ★★★ | Um fluxo de trabalho (*workflow*) de agente pode iniciar outro fluxo de trabalho de agente | Multi-Agente (*Multi-agent*) | `if llm_trigger(): execute_agent()` |
+
+Tabela do [guia conceitual do smolagents](https://huggingface.co/docs/smolagents/conceptual_guides/intro_agents).
+
+
+## Que tipo de Modelos de IA usamos para Agentes?
+
+O modelo de IA mais comum encontrado em Agentes é um LLM (Grandes Modelos de Linguagem), que recebe **Texto** como entrada e gera **Texto** também como saída.
+
+Exemplos bem conhecidos são **GPT-4** da **OpenAI**, **Llama** da **Meta**, **Gemini** do **Google**, etc. Esses modelos foram treinados em uma vasta quantidade de texto e são capazes de generalizar bem. Aprenderemos mais sobre LLMs na [próxima seção](what-are-llms).
+
+> [!TIP]
+> Também é possível usar modelos que aceitam outras entradas como o modelo central do Agente. Por exemplo, um Vision Language Model (VLM) - Modelo de Linguagem Visual, que é como um LLM mas também entende imagens como entrada. Nós focaremos nos LLMs por enquanto e discutiremos outras opções mais tarde.
+
+## Como uma IA realiza ações em seu ambiente?
+
+Os LLMs são modelos incríveis, mas **eles só podem gerar texto**.
+
+No entanto, se você pedir para um aplicativo de chat conhecido, como HuggingChat ou ChatGPT, gerar uma imagem, eles conseguem! Como isso é possível?
+
+A resposta é que os desenvolvedores do HuggingChat, ChatGPT e aplicativos semelhantes implementaram funcionalidades adicionais (chamadas **Ferramentas - Tools**), que o LLM pode usar para criar imagens.
+
+
+
+
+Na seção anterior, aprendemos que cada Agente precisa de **um Modelo de IA em seu núcleo**, e que os LLMs (Grandes Modelos de Linguagem) são o tipo mais comum de modelos de IA para esse propósito.
+
+Agora vamos aprender o que são LLMs e como eles impulsionam os Agentes.
+
+Esta seção oferece uma explicação técnica concisa do uso de LLMs. Se você quiser se aprofundar, pode conferir o nosso Curso gratuito de Processamento de Linguagem Natural (NLP).
+
+## O que é um Grande Modelo de Linguagem (LLM)?
+
+Um LLM é um tipo de modelo de IA que se destaca por **entender e gerar linguagem humana**. Eles são treinados em vastas quantidades de dados de texto, o que lhes permite aprender padrões, estruturas e até nuances da linguagem. Esses modelos normalmente consistem em muitos milhões (ou bilhões) de parâmetros.
+
+A maioria dos LLMs hoje em dia é **construída na arquitetura Transformer** — uma arquitetura de aprendizado profundo baseada no algoritmo de "Atenção" (*Attention*), que ganhou grande interesse desde o lançamento do BERT pelo Google em 2018.
+
+
+| Modelo | +Provedor | +Token EOS | +Funcionalidade | +
|---|---|---|---|
| GPT4 | +OpenAI | +<|endoftext|> |
+ Fim do texto da mensagem | +
| Llama 3 | +Meta (Facebook AI Research) | +<|eot_id|> |
+ Fim da sequência | +
| Deepseek-R1 | +DeepSeek | +<|end_of_sentence|> |
+ Fim do texto da mensagem | +
| SmolLM2 | +Hugging Face | +<|im_end|> |
+ Fim da instrução ou da mensagem | +
| Gemma | +<end_of_turn> |
+ Fim do turno da conversa | +
+
+Em outras palavras, um LLM irá decodificar o texto até atingir o EOS. Mas o que acontece durante um único ciclo de decodificação?
+
+Embora o processo completo possa ser bastante técnico para o propósito de se aprender sobre agentes, aqui está uma breve visão geral:
+
+- Uma vez que o texto de entrada é **tokenizado**, o modelo calcula uma representação da sequência que captura informações sobre o significado e a posição de cada token na sequência de entrada.
+- Esta representação vai para o modelo, que gera pontuações (*scores*) classificando a probabilidade de cada token em seu vocabulário ser o próximo na sequência.
+
+
+
+Com base nessas pontuações, temos múltiplas estratégias para selecionar os tokens e completar a frase.
+
+- A estratégia de decodificação mais fácil seria sempre pegar o token com a pontuação máxima.
+
+Você pode interagir com o processo de decodificação usando o SmolLM2 neste Space (lembre-se, ele decodifica até atingir um token **EOS**, que é o **<|im_end|>** para este modelo):
+
+
+
+- Mas existem estratégias de decodificação mais avançadas. Por exemplo, a *beam search* explora múltiplas sequências candidatas para encontrar aquela com a pontuação total máxima — mesmo se alguns tokens individuais tiverem pontuações menores.
+
+
+
+Se quiser saber mais sobre decodificação, você pode dar uma olhada no [Curso de NLP](https://huggingface.co/learn/nlp-course).
+
+## Atenção é tudo o que você precisa (*Attention is all you need*)
+
+Um aspecto fundamental da arquitetura Transformer é a **Atenção (*Attention*)**. Ao prever a próxima palavra, nem toda palavra em uma frase é igualmente importante; palavras como "França" e "capital" na frase *"A capital da França é..."* carregam a maior parte do significado.
+
+
+
+Esse processo de identificar quais são as palavras mais relevantes na hora prever o próximo token provou-se incrivelmente eficaz.
+
+Embora o princípio básico dos LLMs — prever o próximo token — tenha se mantido consistente desde o GPT-2, houve avanços significativos no dimensionamento das redes neurais e em fazer o mecanismo de atenção funcionar para sequências cada vez mais longas.
+
+Se você já interagiu com LLMs, provavelmente está familiarizado com o termo *context length* (comprimento do contexto), que se refere ao número máximo de tokens que o LLM pode processar, e ao tempo máximo de *atenção* (*attention span*) que ele tem.
+
+## O *prompt* do LLM é importante
+
+Considerando que o único trabalho de um LLM é prever o próximo token observando cada token de entrada e escolher quais tokens são "importantes", as palavras usadas na sua sequência de entrada são muito importantes.
+
+A sequência de entrada que você fornece a um LLM é chamada de _prompt_. Criar este *prompt* cuidadosamente torna muito mais fácil **guiar a geração do LLM em direção à saída desejada**.
+
+## Como os LLMs são treinados?
+
+Os LLMs são treinados em grandes conjuntos de dados de texto (*datasets*), nos quais eles aprendem a prever a próxima palavra em uma sequência por meio de um objetivo de modelagem de linguagem autossupervisionada ou mascarada.
+
+A partir desse aprendizado não supervisionado, o modelo aprende a estrutura do idioma e **os padrões subjacentes no texto, permitindo que o modelo generalize para dados nunca antes vistos**.
+
+Após este _pré-treinamento_ (*pre-training*) inicial, os LLMs podem passar por um _ajuste fino_ (*fine-tuning*) através de um aprendizado supervisionado para executar tarefas específicas. Por exemplo, alguns modelos são treinados para estruturas conversacionais ou uso de ferramentas (*tool usage*), enquanto outros se concentram em classificação ou geração de código.
+
+## Como posso usar os LLMs?
+
+Você tem duas opções principais:
+
+1. **Rodar Localmente** (se você tiver hardware suficiente).
+
+2. **Usar na Nuvem/API** (por exemplo, via Hugging Face Serverless Inference API).
+
+Ao longo deste curso, usaremos principalmente modelos por meio de APIs no Hugging Face Hub. Mais tarde, exploraremos como rodar esses modelos localmente no seu próprio hardware.
+
+
+## Como os LLMs são usados em Agentes de IA?
+
+Os LLMs são uma parte fundamental dos Agentes de IA, **fornecendo a base para o entendimento e para a geração de linguagem humana**.
+
+Eles podem interpretar as instruções do usuário, manter o contexto em conversas, definir um plano e decidir quais ferramentas (*tools*) usar.
+
+Iremos explorar estas etapas com mais detalhes nesta Unidade, mas, por enquanto, o que você precisa entender é que o LLM é **o cérebro do Agente**.
+
+---
+
+Isso foi muita informação! Cobrimos o básico sobre o que são LLMs, como eles funcionam e o papel deles em impulsionar os agentes de IA.
+
+Se você quiser se aprofundar ainda mais no fascinante mundo dos modelos de linguagem e no processamento de linguagem natural, não hesite em conferir o nosso curso gratuito de NLP.
+
+Agora que entendemos como os LLMs funcionam, é hora de ver **como os LLMs estruturam suas gerações em um contexto conversacional**.
+
+