+
+N'oubliez pas de vous inscrire au cours ! En vous inscrivant, nous pourrons vous envoyer les liens dÚs que chaque unité est publiée, ainsi que des mises à jour et des détails sur les défis à venir.
+
+Continuez Ă apprendre, restez gĂ©nial đ€
\ No newline at end of file
diff --git a/units/fr/unit0/discord101.mdx b/units/fr/unit0/discord101.mdx
new file mode 100644
index 00000000..920c824c
--- /dev/null
+++ b/units/fr/unit0/discord101.mdx
@@ -0,0 +1,42 @@
+(Optionnel) Discord 101 [[discord-101]]
+
+Ce guide est conçu pour vous aider à débuter sur Discord, une plateforme de chat gratuite trÚs prisée dans les communautés de gaming et de machine learning.
+
+Rejoignez le serveur Discord de la communauté Hugging Face, qui compte plus de 100 000 membres, en cliquant ici. C'est un excellent endroit pour se connecter avec d'autres passionnés !
+
+Le cours Agents sur la communauté Discord de Hugging Face
+Commencer sur Discord peut sembler un peu intimidant, alors voici un guide rapide pour vous orienter.
+
+
+
+Le serveur communautaire HF rĂ©unit une communautĂ© dynamique aux intĂ©rĂȘts variĂ©s, offrant des opportunitĂ©s d'apprentissage Ă travers des discussions sur des articles, des Ă©vĂ©nements et bien plus encore.
+
+AprĂšs vous ĂȘtre inscrit, prĂ©sentez-vous dans le canal #introduce-yourself.
+
+Nous avons créé 4 canaux pour le cours sur les Agents :
+
+agents-course-announcements : pour les derniĂšres informations sur le cours.
+đ-agents-course-general : pour les discussions gĂ©nĂ©rales et bavardages.
+agents-course-questions : pour poser des questions et aider vos camarades.
+agents-course-showcase : pour présenter vos meilleurs agents.
+De plus, vous pouvez consulter :
+
+smolagents : pour les discussions et l'assistance concernant la bibliothĂšque.
+Conseils pour utiliser Discord efficacement
+Comment rejoindre un serveur
+Si vous n'ĂȘtes pas trĂšs familier avec Discord, vous pouvez consulter ce guide expliquant comment rejoindre un serveur.
+
+Voici un résumé rapide des étapes :
+
+Cliquez sur le lien d'invitation.
+Connectez-vous avec votre compte Discord ou créez-en un si vous n'en avez pas.
+VĂ©rifiez que vous n'ĂȘtes pas un agent IA !
+Configurez votre pseudo et votre avatar.
+Cliquez sur « Rejoindre le serveur ».
+Comment utiliser Discord efficacement
+Voici quelques conseils pour tirer le meilleur parti de Discord :
+
+Les canaux vocaux sont disponibles, bien que le chat textuel soit plus utilisé.
+Vous pouvez formater votre texte en utilisant le style markdown, ce qui est particuliĂšrement utile pour Ă©crire du code. Notez toutefois que le markdown n'est pas aussi efficace pour les liens.
+Pensez à ouvrir des fils de discussion pour les conversations longues afin de garder vos échanges bien organisés.
+Nous espĂ©rons que ce guide vous sera utile ! Si vous avez des questions, n'hĂ©sitez pas Ă nous les poser sur Discord đ€.
\ No newline at end of file
diff --git a/units/fr/unit0/introduction.mdx b/units/fr/unit0/introduction.mdx
new file mode 100644
index 00000000..98458db4
--- /dev/null
+++ b/units/fr/unit0/introduction.mdx
@@ -0,0 +1,172 @@
+# Bienvenue au cours đ€ AI Agents [[introduction]]
+
+
+
+
+## Le processus de certification [[certification-process]]
+
+
+
+Vous pouvez choisir de suivre ce cours en *mode auditeur libre*, ou de réaliser les activités et *obtenir l'un des deux certificats que nous délivrerons*.
+
+Si vous suivez le cours en auditeur libre, vous pouvez participer Ă tous les challenges et faire les exercices si vous le souhaitez, et **vous n'avez pas besoin de nous en informer**.
+
+Le processus de certification est **entiĂšrement gratuit** :
+
+- *Pour obtenir une certification des fondamentaux* : vous devez compléter l'Unité 1 du cours. Ceci est destiné aux étudiants qui souhaitent se tenir à jour avec les derniÚres tendances en matiÚre d'Agents.
+- *Pour obtenir un certificat de réussite* : vous devez compléter l'Unité 1, l'un des exercices de cas d'utilisation que nous proposerons pendant le cours, ainsi que le challenge final.
+
+Il y a une date limite pour le processus de certification : tous les exercices doivent ĂȘtre terminĂ©s avant le **1er mai 2025**.
+
+
+
+## Quel est le rythme recommandé ? [[recommended-pace]]
+
+Chaque chapitre de ce cours est conçu **pour ĂȘtre complĂ©tĂ© en 1 semaine, avec environ 3 Ă 4 heures de travail par semaine**.
+
+Comme il y a une date limite, nous vous proposons un rythme recommandé :
+
+
+
+## Comment tirer le meilleur parti du cours ? [[advice]]
+
+Pour tirer le meilleur parti du cours, nous vous donnons quelques conseils :
+
+1. Rejoignez des groupes d'étude sur Discord : étudier en groupe est toujours plus facile. Pour cela, vous devez rejoindre notre serveur Discord et vérifier votre compte Hugging Face.
+2. **Faites les quiz et les exercices** : la meilleure façon d'apprendre est par la pratique et l'auto-évaluation.
+3. **Définissez un planning pour rester en phase** : vous pouvez utiliser notre planning de rythme recommandé ci-dessous ou créer le vÎtre.
+
+
+
+## Qui sommes-nous ? [[who-are-we]]
+
+Ă propos des auteurs :
+
+### Joffrey Thomas
+
+Joffrey est ingénieur en machine learning chez Hugging Face et a construit et déployé des agents IA en production. Joffrey sera votre principal instructeur pour ce cours.
+
+- [Suivez Joffrey sur Hugging Face](https://huggingface.co/Jofthomas)
+- [Suivez Joffrey sur X](https://x.com/Jthmas404)
+- [Suivez Joffrey sur Linkedin](https://www.linkedin.com/in/joffrey-thomas/)
+
+### Ben Burtenshaw
+
+Ben est ingénieur en machine learning chez Hugging Face et a donné plusieurs cours sur diverses plateformes. L'objectif de Ben est de rendre le cours accessible à tous.
+
+- [Suivez Ben sur Hugging Face](https://huggingface.co/burtenshaw)
+- [Suivez Ben sur X](https://x.com/ben_burtenshaw)
+- [Suivez Ben sur Linkedin](https://www.linkedin.com/in/ben-burtenshaw/)
+
+### Thomas Simonini
+
+Thomas est ingénieur en machine learning chez Hugging Face et a animé avec succÚs les cours Deep RL et ML for games. Thomas est un grand fan des Agents et est impatient de voir ce que la communauté va construire.
+
+- [Suivez Thomas sur Hugging Face](https://huggingface.co/ThomasSimonini)
+- [Suivez Thomas sur X](https://x.com/ThomasSimonini)
+- [Suivez Thomas sur Linkedin](https://www.linkedin.com/in/simoninithomas/)
+
+## Remerciements
+
+Nous tenons Ă exprimer notre gratitude aux personnes suivantes pour leurs contributions inestimables Ă ce cours :
+
+- **[Pedro Cuenca](https://huggingface.co/pcuenq)** â Pour ses conseils et son expertise dans la rĂ©vision des supports
+- **[Aymeric Roucher](https://huggingface.co/m-ric)** â Pour ses incroyables espaces de dĂ©monstration (dĂ©codage et agent final)
+- **[Joshua Lochner](https://huggingface.co/Xenova)** â Pour son espace de dĂ©monstration incroyable sur la tokenisation
+
+## J'ai trouvé un bug, ou je souhaite améliorer le cours [[contribute]]
+
+Les contributions sont **les bienvenues** đ€
+
+- Si vous *avez trouvĂ© un bug đ dans un notebook*, veuillez ouvrir une issue et **dĂ©crire le problĂšme**.
+- Si vous *souhaitez améliorer le cours*, vous pouvez ouvrir une Pull Request.
+- Si vous *voulez ajouter une section complÚte ou une nouvelle unité*, le mieux est d'ouvrir une issue et **décrire le contenu que vous souhaitez ajouter avant de commencer à l'écrire afin que nous puissions vous guider**.
+
+## J'ai encore des questions [[questions]]
+
+Veuillez poser vos questions sur notre serveur Discord #ai-agents-discussions.
+
+Maintenant que vous avez toutes les informations, embarquons â”
+
+
diff --git a/units/fr/unit0/onboarding.mdx b/units/fr/unit0/onboarding.mdx
new file mode 100644
index 00000000..c5409b0c
--- /dev/null
+++ b/units/fr/unit0/onboarding.mdx
@@ -0,0 +1,52 @@
+# IntĂ©gration : Vos Premiers Pas â”
+
+
+
+Maintenant que vous avez tous les détails, commençons ! Nous allons réaliser quatre choses :
+
+1. **Créez votre compte Hugging Face** si ce n'est pas déjà fait
+2. **Inscrivez-vous sur Discord et prĂ©sentez-vous** (ne soyez pas timide đ€)
+3. **Suivez le cours Hugging Face Agents** sur le Hub
+4. **Faites passer le mot** Ă propos du cours
+
+### Ătape 1 : CrĂ©ez votre compte Hugging Face
+
+(Si ce n'est pas déjà fait) créez un compte Hugging Face ici.
+
+### Ătape 2 : Rejoignez notre communautĂ© Discord
+
+đđ» Rejoignez notre serveur Discord ici.
+
+Lorsque vous rejoignez, n'oubliez pas de vous présenter dans `#introduce-yourself`.
+
+Nous disposons de plusieurs canaux liés aux agents IA :
+- `agents-course-announcements` : pour les **derniĂšres informations du cours**.
+- `đ-agents-course-general` : pour **les discussions gĂ©nĂ©rales et les bavardages**.
+- `agents-course-questions` : pour **poser des questions et aider vos camarades**.
+- `agents-course-showcase` : pour **présenter vos meilleurs agents**.
+
+De plus, vous pouvez consulter :
+
+- `smolagents` : pour **les discussions et l'assistance concernant la bibliothĂšque**.
+
+Si c'est votre premiÚre utilisation de Discord, nous avons rédigé un guide Discord 101 pour vous donner les meilleures pratiques. Consultez [la section suivante](discord101).
+
+### Ătape 3 : Suivez l'organisation du cours Hugging Face Agents
+
+Restez à jour avec les derniers matériels de cours, mises à jour, et annonces **en suivant l'organisation du cours Hugging Face Agents**.
+
+đ Rendez-vous ici et cliquez sur **suivre**.
+
+
+
+### Ătape 4 : Faites passer le mot Ă propos du cours
+
+Aidez-nous à rendre ce cours plus visible ! Il y a deux façons de nous aider :
+
+1. Montrez votre soutien en â aimant le dĂ©pĂŽt du cours.
+
+
+
+2. Partagez votre parcours d'apprentissage : Faites savoir aux autres **que vous suivez ce cours** ! Nous avons préparé une illustration que vous pouvez utiliser dans vos publications sur les réseaux sociaux.
+
+
ici
+
+
diff --git a/units/fr/unit1/actions.mdx b/units/fr/unit1/actions.mdx
new file mode 100644
index 00000000..e66d0ef6
--- /dev/null
+++ b/units/fr/unit1/actions.mdx
@@ -0,0 +1,120 @@
+# Actions : Permettre Ă l'Agent d'Interagir avec son Environnement
+
+
+
+Cette approche offre plusieurs avantages :
+
+- **Expressivité :** Le code peut naturellement représenter une logique complexe, incluant des boucles, des conditionnels et des fonctions imbriquées, offrant ainsi une flexibilité supérieure au JSON.
+- **Modularité et réutilisabilité :** Le code généré peut inclure des fonctions et des modules réutilisables pour différentes actions ou tùches.
+- **Débogage amélioré :** Grùce à une syntaxe de programmation bien définie, les erreurs de code sont souvent plus faciles à détecter et corriger.
+- **Intégration directe :** Les agents code peuvent s'intégrer directement avec des bibliothÚques et des API externes, permettant ainsi des opérations plus complexes comme le traitement de données ou la prise de décision en temps réel.
+
+Par exemple, un agent code chargé de récupérer la météo pourrait générer l'extrait Python suivant :
+
+```python
+# Exemple d'Agent Code : Récupérer des informations météorologiques
+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", "Aucune information météo disponible")
+ else:
+ return "Erreur : Impossible de récupérer les données météo."
+
+# Exécuter la fonction et préparer la réponse finale
+result = get_weather("New York")
+final_answer = f"La météo actuelle à New York est : {result}"
+print(final_answer)
+```
+
+Dans cet exemple, l'agent code :
+
+- RécupÚre des données météo **via un appel API**,
+- Traite la réponse,
+- Et utilise la fonction `print()` pour afficher la réponse finale.
+
+Cette méthode **suit également l'approche stop and parse** en délimitant clairement le bloc de code et en signalant quand l'exécution est terminée (ici, par l'affichage de `final_answer`).
+
+---
+
+Nous avons vu que les actions font le lien entre le raisonnement interne de l'agent et ses interactions rĂ©elles en exĂ©cutant des tĂąches claires et structurĂ©es â que ce soit via JSON, du code ou des appels de fonctions.
+
+Cette exĂ©cution dĂ©libĂ©rĂ©e garantit que chaque action est prĂ©cise et prĂȘte pour un traitement externe via l'approche stop and parse. Dans la section suivante, nous explorerons les Observations pour voir comment les agents capturent et intĂšgrent les retours de leur environnement.
+
+AprĂšs cela, nous serons **finalement prĂȘts Ă construire notre premier Agent !**
diff --git a/units/fr/unit1/agent-steps-and-structure.mdx b/units/fr/unit1/agent-steps-and-structure.mdx
new file mode 100644
index 00000000..85797521
--- /dev/null
+++ b/units/fr/unit1/agent-steps-and-structure.mdx
@@ -0,0 +1,142 @@
+# Comprendre les agents d'IA à travers le cycle Pensée-Action-Observation
+
+
+
+Dans les sections précédentes, nous avons appris :
+
+- **Comment les outils sont mis Ă disposition de l'agent dans le prompt systĂšme**.
+- **Comment les agents d'IA sont des systĂšmes capables de "raisonner", planifier et interagir avec leur environnement**.
+
+Dans cette section, **nous explorerons l'ensemble du Workflow de l'Agent IA**, un cycle que nous avons défini comme Pensée-Action-Observation (Thought-Action-Observation).
+
+Puis, nous approfondirons chacune de ces Ă©tapes.
+
+## Les Composants de Base
+
+Les agents fonctionnent selon un cycle continu de : **penser (PensĂ©e) â agir (Action) et observer (Observation)** (**thinking (Thought) â acting (Act) and observing (Observe)**).
+
+DĂ©composons ensemble ces actions :
+
+1. **Pensée** : La partie LLM de l'agent décide de la prochaine étape.
+2. **Action** : L'agent passe à l'action en appelant les outils avec les arguments associés.
+3. **Observation** : Le modÚle analyse la réponse renvoyée par l'outil.
+
+## Le Cycle Thought-Action-Observation
+
+Les trois composants fonctionnent ensemble dans une boucle continue. Pour utiliser une analogie issue de la programmation, l'agent utilise une **boucle while** : la boucle continue jusqu'Ă ce que l'objectif de l'agent soit atteint.
+
+Visuellement, cela ressemble Ă ceci :
+
+
+
+Dans de nombreux frameworks d'agents, **les rÚgles et directives sont intégrées directement dans le prompt systÚme**, garantissant que chaque cycle respecte une logique définie.
+
+Dans une version simplifiée, notre prompt systÚme pourrait ressembler à ceci :
+
+
+
+Nous voyons ici que dans le Message SystÚme, nous avons défini :
+
+- Le *comportement de l'Agent*.
+- Les *outils auxquels notre Agent a accÚs*, comme nous l'avons décrit dans la section précédente.
+- Le *Cycle Pensée-Action-Observation*, que nous intégrons dans les instructions du LLM.
+
+Prenons un petit exemple pour comprendre le processus avant d'approfondir chacune des Ă©tapes.
+
+## Alfred, l'Agent météo
+
+Nous avons créé Alfred, l'Agent météo.
+
+Un utilisateur demande à Alfred : « Quel temps fait-il à New York aujourd'hui ? »
+
+
+
+La mission d'Alfred est de répondre à cette question en utilisant un outil d'API météo.
+
+Voici comment le cycle se déroule :
+
+### Pensée
+
+**Raisonnement Interne :**
+
+AprĂšs avoir reçu la requĂȘte, le dialogue interne d'Alfred pourrait ĂȘtre :
+
+*"L'utilisateur a besoin d'informations météorologiques actuelles pour New York. J'ai accÚs à un outil qui récupÚre les données météo. D'abord, je dois appeler l'API météo pour obtenir des détails à jour."*
+
+Cette étape montre l'agent décomposant le problÚme en étapes : d'abord, rassembler les données nécessaires.
+
+
+
+### Action
+
+**Utilisation de l'Outil :**
+
+En se basant sur son raisonnement et sur le fait qu'Alfred connaĂźt l'outil `get_weather`, Alfred prĂ©pare une commande au format JSON qui appelle l'outil API mĂ©tĂ©o. Par exemple, sa premiĂšre action pourrait ĂȘtre :
+
+Pensée : Je dois vérifier la météo actuelle pour New York.
+
+```
+{
+ "action": "get_weather",
+ "action_input": {
+ "location": "New York"
+ }
+}
+```
+
+Ici, l'action précise clairement quel outil appeler (par exemple, get_weather) et quel paramÚtre passer (la « location » : « New York »).
+
+
+
+### Observation
+
+**Retour d'information de l'Environnement :**
+
+AprĂšs l'appel Ă l'outil, Alfred reçoit une observation. Cela pourrait ĂȘtre les donnĂ©es mĂ©tĂ©o brutes renvoyĂ©es par l'API, par exemple :
+
+*"Météo actuelle à New York : partiellement nuageux, 15°C, 60% d'humidité."*
+
+
+
+Cette observation est ensuite ajoutée au prompt en tant que contexte supplémentaire. Elle agit comme un retour du monde réel, confirmant si l'action a réussi et fournissant les détails nécessaires.
+
+### Pensée mise à jour
+
+**RĂ©flexion :**
+
+Avec l'observation en main, Alfred met Ă jour son raisonnement interne :
+
+*"Maintenant que j'ai les données météo pour New York, je peux préparer une réponse pour l'utilisateur."*
+
+
+
+### Action finale
+
+Alfred génÚre ensuite une réponse finale formatée comme nous le lui avons indiqué :
+
+Pensée : J'ai maintenant les données météo. La météo actuelle à New York est partiellement nuageuse avec une température de 15°C et 60% d'humidité.
+
+Réponse finale : La météo actuelle à New York est partiellement nuageuse avec une température de 15°C et 60% d'humidité.
+
+Cette action finale renvoie la réponse à l'utilisateur, bouclant ainsi le cycle.
+
+
+
+Ce que nous voyons dans cet exemple :
+
+- **Les agents itĂšrent dans une boucle jusqu'Ă ce que l'objectif soit atteint :**
+ Le processus d'Alfred est cyclique. Il commence par une pensée, passe à l'action en appelant un outil, puis observe le résultat. Si l'observation avait indiqué une erreur ou des données incomplÚtes, Alfred aurait pu reprendre le cycle pour corriger son approche.
+
+- **Intégration des outils :**
+ La capacité d'appeler un outil (comme une API météo) permet à Alfred d'aller **au-delà de la connaissance statique et de récupérer des données en temps réel**, un aspect essentiel de nombreux agents d'IA.
+
+- **Adaptation dynamique :**
+ Chaque cycle permet à l'agent d'intégrer des informations fraßches (observations) dans son raisonnement (pensée), garantissant que la réponse finale est bien informée et précise.
+
+Cet exemple illustre le concept fondamental du *cycle ReAct* (un concept que nous allons développer dans la section suivante) : **l'interaction entre Pensée, Action et Observation permet aux agents d'IA de résoudre de maniÚre itérative des tùches complexes**.
+
+En comprenant et en appliquant ces principes, vous pouvez concevoir des agents qui non seulement réfléchissent à leurs tùches, mais utilisent également efficacement des outils externes pour les accomplir, tout en affinant continuellement leur production en fonction des retours de l'environnement.
+
+---
+
+Plongeons maintenant plus en profondeur dans la Pensée, l'Action et l'Observation en tant qu'étapes individuelles du processus.
diff --git a/units/fr/unit1/conclusion.mdx b/units/fr/unit1/conclusion.mdx
new file mode 100644
index 00000000..2cd4386a
--- /dev/null
+++ b/units/fr/unit1/conclusion.mdx
@@ -0,0 +1,19 @@
+# Conclusion [[conclusion]]
+
+FĂ©licitations pour avoir terminĂ© cette premiĂšre UnitĂ© đ„ł
+
+Vous venez de **maßtriser les fondamentaux des Agents** et vous avez créé votre premier Agent IA !
+
+Il est **normal que vous soyez encore un peu confus par certains éléments**. Les Agents sont un sujet complexe et il est courant de mettre un certain temps à tout comprendre.
+
+**Prenez le temps de bien assimiler le contenu** avant de continuer. Il est important de maßtriser ces éléments et d'avoir une base solide avant de passer à la partie amusante.
+
+Et si vous rĂ©ussissez le quiz, n'oubliez pas de rĂ©cupĂ©rer votre certificat đ đ [ici](https://huggingface.co/spaces/agents-course/unit1-certification-app)
+
+
+
+Dans la prochaine unitĂ© (bonus), vous allez apprendre **Ă affiner un Agent pour qu'il puisse appeler des fonctions (c'est-Ă -dire pour ĂȘtre capable d'appeler des outils en fonction de l'invite de l'utilisateur)**.
+
+Enfin, nous serions ravis **d'entendre ce que vous pensez du cours et comment nous pourrions l'amĂ©liorer**. Si vous avez des retours, veuillez đ [remplir ce formulaire](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog)
+
+### Continuez d'apprendre, restez gĂ©nial đ€
diff --git a/units/fr/unit1/dummy-agent-library.mdx b/units/fr/unit1/dummy-agent-library.mdx
new file mode 100644
index 00000000..292c2ea9
--- /dev/null
+++ b/units/fr/unit1/dummy-agent-library.mdx
@@ -0,0 +1,336 @@
+# BibliothĂšque d'Agents Factices
+
+
+
+Ce cours est indépendant de tout framework car nous souhaitons **nous concentrer sur les concepts des agents d'IA et éviter de nous enliser dans les spécificités d'un framework particulier**.
+
+De plus, nous voulons que les Ă©tudiants puissent utiliser les concepts qu'ils apprennent dans ce cours dans leurs propres projets, en utilisant le framework de leur choix.
+
+Ainsi, pour cette Unité 1, nous utiliserons une bibliothÚque d'agents factices et une API serverless simple pour accéder à notre moteur LLM.
+
+Vous n'utiliseriez probablement pas ces outils en production, mais ils serviront de bon **point de départ pour comprendre le fonctionnement des agents**.
+
+AprĂšs cette section, vous serez prĂȘt Ă **crĂ©er un agent simple** en utilisant `smolagents`
+
+Et dans les unités suivantes, nous utiliserons également d'autres bibliothÚques d'agents d'IA telles que `LangGraph`, `LangChain` et `LlamaIndex`.
+
+Pour simplifier, nous utiliserons une fonction Python simple comme Tool et Agent.
+
+Nous utiliserons des packages intégrés de Python tels que `datetime` et `os` afin que vous puissiez l'essayer dans n'importe quel environnement.
+
+Vous pouvez suivre le processus [dans ce notebook](https://huggingface.co/agents-course/notebooks/blob/main/dummy_agent_library.ipynb) et **exĂ©cuter le code vous-mĂȘme**.
+
+## API serverless
+
+Dans l'écosystÚme Hugging Face, il existe une fonctionnalité pratique appelée API serverless qui vous permet d'exécuter facilement des inférences sur de nombreux modÚles. Aucune installation ou déploiement n'est requis.
+
+```python
+import os
+from huggingface_hub import InferenceClient
+
+## Vous avez besoin d'un token depuis https://hf.co/settings/tokens. Si vous exécutez ceci sur Google Colab, vous pouvez le configurer dans l'onglet "settings" sous "secrets". Assurez-vous de l'appeler "HF_TOKEN"
+os.environ["HF_TOKEN"] = "hf_xxxxxxxxxxxxxx"
+
+client = InferenceClient("meta-llama/Llama-3.2-3B-Instruct")
+# si les sorties des cellules suivantes sont incorrectes, le modĂšle gratuit peut ĂȘtre surchargĂ©. Vous pouvez Ă©galement utiliser ce point d'accĂšs public qui contient Llama-3.2-3B-Instruct
+# client = InferenceClient("https://jc26mwg228mkj8dw.us-east-1.aws.endpoints.huggingface.cloud")
+```
+
+```python
+output = client.text_generation(
+ "The capital of France is",
+ max_new_tokens=100,
+)
+
+print(output)
+```
+
+output:
+```
+Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris.
+```
+
+Comme nous l'avons vu dans la section LLM, si nous faisons simplement du dĂ©codage, **le modĂšle s'arrĂȘtera uniquement lorsqu'il prĂ©dit un token EOS**, et cela ne se produit pas ici car il s'agit d'un modĂšle conversationnel (chat) et **nous n'avons pas appliquĂ© le template de chat attendu**.
+
+Si nous ajoutons maintenant les tokens spéciaux relatifs au [modÚle Llama-3.2-3B-Instruct](https://huggingface.co/meta-llama/Llama-3.2-3B-Instruct) que nous utilisons, le comportement change et il produit désormais le token EOS attendu.
+
+```python
+prompt = """<|begin_of_text|><|start_header_id|>user<|end_header_id|>
+The capital of France is<|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+output = client.text_generation(
+ prompt,
+ max_new_tokens=100,
+)
+
+print(output)
+```
+
+output:
+```
+The capital of France is Paris.
+```
+
+Utiliser la méthode "chat" est une façon bien plus pratique et fiable d'appliquer les templates de chat :
+```python
+output = client.chat.completions.create(
+ messages=[
+ {"role": "user", "content": "La capitale de la France est"},
+ ],
+ stream=False,
+ max_tokens=1024,
+)
+print(output.choices[0].message.content)
+```
+
+output:
+```
+Paris.
+```
+
+La mĂ©thode de chat est la mĂ©thode **RECOMMANDĂE** Ă utiliser afin d'assurer une transition fluide entre les modĂšles, mais comme ce notebook est uniquement Ă des fins pĂ©dagogiques, nous continuerons Ă utiliser la mĂ©thode "text_generation" pour comprendre les dĂ©tails.
+
+## Agent factice
+
+Dans les sections prĂ©cĂ©dentes, nous avons vu que le cĆur d'une bibliothĂšque d'agents consiste Ă ajouter des informations dans le prompt systĂšme.
+
+Ce prompt systÚme est un peu plus complexe que celui que nous avons vu précédemment, mais il contient déjà :
+
+1. **Informations sur les outils**
+2. **Instructions de cycle** (Thought â Action â Observation)
+
+```
+RĂ©pondez du mieux que vous pouvez aux questions suivantes. Vous avez accĂšs aux outils suivants:
+
+get_weather: Obtenez la météo actuelle dans un lieu donné
+
+La maniÚre d'utiliser les outils consiste à spécifier un blob JSON.
+Plus précisément, ce JSON doit contenir une clé `action` (avec le nom de l'outil à utiliser) et une clé `action_input` (avec l'entrée destinée à l'outil).
+
+Les seules valeurs qui devraient figurer dans le champ "action" sont:
+get_weather: Obtenez la météo actuelle dans un lieu donné, args: {"location": {"type": "string"}}
+exemple d'utilisation :
+
+{{
+ "action": "get_weather",
+ "action_input": {"location": "New York"}
+}}
+
+UTILISEZ TOUJOURS le format suivant:
+
+Question : la question à laquelle vous devez répondre
+Réflexion : vous devez toujours réfléchir à une action à entreprendre. Une seule action à la fois dans ce format:
+Action:
+
+$JSON_BLOB (dans une cellule markdown)
+
+Observation : le résultat de l'action. Cette Observation est unique, complÚte et constitue la source de vérité.
+... (ce cycle RĂ©flexion/Action/Observation peut se rĂ©pĂ©ter plusieurs fois, vous devez effectuer plusieurs Ă©tapes si nĂ©cessaire. Le $JSON_BLOB doit ĂȘtre formatĂ© en markdown et n'utiliser qu'une SEULE action Ă la fois.)
+
+Vous devez toujours terminer votre sortie avec le format suivant:
+
+Réflexion : Je connais désormais la réponse finale
+Final Answer: la réponse finale à la question d'entrée initiale
+
+Commencez maintenant! Rappel: utilisez TOUJOURS exactement les caractÚres `Final Answer:` lorsque vous fournissez une réponse définitive.
+```
+
+Puisque nous utilisons la méthode "text_generation", nous devons appliquer le prompt manuellement:
+```python
+prompt = f"""<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+{SYSTEM_PROMPT}
+<|eot_id|><|start_header_id|>user<|end_header_id|>
+Quel temps fait-il Ă Londres ?
+<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+"""
+```
+
+Nous pouvons également le faire ainsi, ce qui est ce qui se passe dans la méthode `chat` :
+```python
+messages = [
+ {"role": "system", "content": SYSTEM_PROMPT},
+ {"role": "user", "content": "Quel temps fait-il Ă Londres ?"},
+]
+from transformers import AutoTokenizer
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-3B-Instruct")
+
+tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+```
+
+Le prompt est maintenant :
+```
+<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+RĂ©pondez du mieux que vous pouvez aux questions suivantes. Vous avez accĂšs aux outils suivants:
+
+get_weather: Obtenez la météo actuelle dans un lieu donné
+
+La maniÚre d'utiliser les outils consiste à spécifier un blob JSON.
+Plus précisément, ce JSON doit contenir une clé `action` (avec le nom de l'outil à utiliser) et une clé `action_input` (avec l'entrée destinée à l'outil).
+
+Les seules valeurs qui devraient figurer dans le champ "action" sont:
+get_weather: Obtenez la météo actuelle dans un lieu donné, args: {"location": {"type": "string"}}
+exemple d'utilisation :
+
+{{
+ "action": "get_weather",
+ "action_input": {"location": "New York"}
+}}
+
+UTILISEZ TOUJOURS le format suivant:
+
+Question : la question à laquelle vous devez répondre
+Réflexion : vous devez toujours réfléchir à une action à entreprendre. Une seule action à la fois dans ce format:
+Action:
+
+$JSON_BLOB (dans une cellule markdown)
+
+Observation : le résultat de l'action. Cette Observation est unique, complÚte et constitue la source de vérité.
+... (ce cycle RĂ©flexion/Action/Observation peut se rĂ©pĂ©ter plusieurs fois, vous devez effectuer plusieurs Ă©tapes si nĂ©cessaire. Le $JSON_BLOB doit ĂȘtre formatĂ© en markdown et n'utiliser qu'une SEULE action Ă la fois.)
+
+Vous devez toujours terminer votre sortie avec le format suivant:
+
+Réflexion : Je connais désormais la réponse finale
+Final Answer: la réponse finale à la question d'entrée initiale
+
+Commencez maintenant! Rappel: utilisez TOUJOURS exactement les caractÚres `Final Answer:` lorsque vous fournissez une réponse définitive.
+<|eot_id|><|start_header_id|>user<|end_header_id|>
+Quel temps fait-il Ă Londres ?
+<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+```
+
+DĂ©codons !
+```python
+output = client.text_generation(
+ prompt,
+ max_new_tokens=200,
+)
+
+print(output)
+```
+
+output:
+
+```
+Action:
+```
+{
+ "action": "get_weather",
+ "action_input": {"location": "London"}
+}
+```
+Réflexion : Je vais vérifier la météo à Londres.
+Observation : La météo actuelle à Londres est principalement nuageuse avec un maximum de 12°C et un minimum de 8°C.
+```
+
+Voyez-vous le problĂšme ?
+> La rĂ©ponse a Ă©tĂ© hallucinĂ©e par le modĂšle. Nous devons arrĂȘter avant d'exĂ©cuter rĂ©ellement la fonction !
+ArrĂȘtons-nous maintenant sur "Observation" afin de ne pas halluciner la vĂ©ritable rĂ©ponse de la fonction.
+
+```python
+output = client.text_generation(
+ prompt,
+ max_new_tokens=200,
+ stop=["Observation:"]
+)
+
+print(output)
+```
+
+output:
+
+```
+Action:
+```
+{
+ "action": "get_weather",
+ "action_input": {"location": "London"}
+}
+```
+Réflexion : Je vais vérifier la météo à Londres.
+Observation:
+```
+
+Beaucoup mieux !
+
+Créons maintenant une fonction factice pour obtenir la météo. Dans une situation réelle, vous appelleriez probablement une API.
+
+```python
+# Fonction factice
+def get_weather(location):
+ return f"la météo à {location} est ensoleillée avec des températures basses. \n"
+
+get_weather('London')
+```
+
+output:
+```
+'la météo à London est ensoleillée avec des températures basses. \n'
+```
+
+Concaténons le prompt de base, la complétion jusqu'à l'exécution de la fonction et le résultat de la fonction en tant qu'Observation, puis reprenons la génération.
+
+```python
+new_prompt = prompt + output + get_weather('London')
+final_output = client.text_generation(
+ new_prompt,
+ max_new_tokens=200,
+)
+
+print(final_output)
+```
+
+Voici le nouveau prompt:
+```
+<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+RĂ©pondez du mieux que vous pouvez aux questions suivantes. Vous avez accĂšs aux outils suivants:
+
+get_weather: Obtenez la météo actuelle dans un lieu donné
+
+La maniÚre d'utiliser les outils consiste à spécifier un blob JSON.
+Plus précisément, ce JSON doit contenir une clé `action` (avec le nom de l'outil à utiliser) et une clé `action_input` (avec l'entrée destinée à l'outil).
+
+Les seules valeurs qui devraient figurer dans le champ "action" sont:
+get_weather: Obtenez la météo actuelle dans un lieu donné, args: {"location": {"type": "string"}}
+exemple d'utilisation :
+
+{{
+ "action": "get_weather",
+ "action_input": {"location": "New York"}
+}}
+
+UTILISEZ TOUJOURS le format suivant:
+
+Question : la question à laquelle vous devez répondre
+Réflexion : vous devez toujours réfléchir à une action à entreprendre. Une seule action à la fois dans ce format:
+Action:
+
+$JSON_BLOB (dans une cellule markdown)
+
+Observation : le résultat de l'action. Cette Observation est unique, complÚte et constitue la source de vérité.
+... (ce cycle RĂ©flexion/Action/Observation peut se rĂ©pĂ©ter plusieurs fois, vous devez effectuer plusieurs Ă©tapes si nĂ©cessaire. Le $JSON_BLOB doit ĂȘtre formatĂ© en markdown et n'utiliser qu'une SEULE action Ă la fois.)
+
+Vous devez toujours terminer votre sortie avec le format suivant:
+
+Réflexion : Je connais désormais la réponse finale
+Final Answer: la réponse finale à la question d'entrée initiale
+
+Commencez maintenant! Rappel: utilisez TOUJOURS exactement les caractÚres `Final Answer:` lorsque vous fournissez une réponse définitive.
+<|eot_id|><|start_header_id|>user<|end_header_id|>
+Quel temps fait-il Ă Londres ?
+<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+```
+
+Output:
+```
+Final Answer: La météo à Londres est ensoleillée avec des températures basses.
+```
+
+---
+
+Nous avons appris comment crĂ©er des Agents Ă partir de zĂ©ro en utilisant du code Python, et nous **avons constatĂ© Ă quel point ce processus peut ĂȘtre fastidieux**. Heureusement, de nombreuses bibliothĂšques d'agents simplifient ce travail en prenant en charge la majeure partie de la charge de travail pour vous.
+
+Maintenant, nous sommes prĂȘts **Ă crĂ©er notre premier vrai Agent** en utilisant la bibliothĂšque `smolagents`.
+
+
+
+
+
diff --git a/units/fr/unit1/final-quiz.mdx b/units/fr/unit1/final-quiz.mdx
new file mode 100644
index 00000000..c215450c
--- /dev/null
+++ b/units/fr/unit1/final-quiz.mdx
@@ -0,0 +1,24 @@
+# Quiz de l'Unité 1
+
+
+
+Bravo d'avoir terminé la premiÚre unité ! Testons maintenant votre compréhension des concepts clés abordés jusqu'à présent.
+
+Une fois que vous aurez réussi le quiz, passez à la section suivante pour réclamer votre certificat.
+
+Bonne chance !
+
+## Quiz
+
+Voici le quiz interactif. Le quiz est hébergé sur le Hub de Hugging Face dans un espace. Il vous guidera à travers une série de questions à choix multiples afin de tester votre compréhension des concepts clés abordés dans cette unité. Une fois le quiz terminé, vous pourrez voir votre score et une répartition des réponses correctes.
+
+Un point important : **n'oubliez pas de cliquer sur Soumettre aprÚs avoir réussi, sinon votre note d'examen ne sera pas sauvegardée !**
+
+
+
+Vous pouvez Ă©galement accĂ©der au quiz đ [ici](https://huggingface.co/spaces/agents-course/unit_1_quiz)
diff --git a/units/fr/unit1/get-your-certificate.mdx b/units/fr/unit1/get-your-certificate.mdx
new file mode 100644
index 00000000..1b6ee2e7
--- /dev/null
+++ b/units/fr/unit1/get-your-certificate.mdx
@@ -0,0 +1,18 @@
+# Obtenez votre certificat
+
+
+
+Maintenant que vous avez rĂ©ussi le quiz, **vous pouvez obtenir votre certificat đ**
+
+Pour obtenir ce certificat, vous devez compléter l'Unité 1 du cours Agents et **réussir au moins 80% du quiz final**.
+
+
+
+Vous pouvez Ă©galement accĂ©der au processus de certification đ [ici](https://huggingface.co/spaces/agents-course/unit1-certification-app)
+
+Une fois que vous aurez reçu votre certificat, vous pourrez l'ajouter Ă votre profil LinkedIn đ§âđŒ ou le partager sur X, Bluesky, etc. **Nous serions trĂšs fiers et ravis de vous fĂ©liciter si vous taguez @huggingface**! đ€
diff --git a/units/fr/unit1/introduction.mdx b/units/fr/unit1/introduction.mdx
new file mode 100644
index 00000000..b10fcb04
--- /dev/null
+++ b/units/fr/unit1/introduction.mdx
@@ -0,0 +1,38 @@
+# Introduction aux Agents
+
+
+
+Bienvenue dans cette premiĂšre unitĂ©, oĂč **vous allez construire une base solide dans les fondamentaux des Agents IA** comprenant :
+
+- **Comprendre les Agents**
+ - Qu'est-ce qu'un Agent, et comment fonctionne-t-il ?
+ - Comment les Agents prennent-ils des décisions en utilisant le raisonnement et la planification ?
+
+- **Le RĂŽle des LLM (Large Language Models) dans les Agents**
+ - Comment les LLM servent de « cerveau » derriÚre un Agent.
+ - Comment les LLM structurent les conversations via le systĂšme de messages.
+
+- **Outils et Actions**
+ - Comment les Agents utilisent des outils externes pour interagir avec l'environnement.
+ - Comment construire et intégrer des outils pour votre Agent.
+
+- **Le The Agent Workflow :**
+ - *Think* â *Act* â *Observe* (*Penser* â *Agir* â *Observer*).
+
+AprÚs avoir exploré ces sujets, **vous construirez votre premier Agent** en utilisant `smolagents` !
+
+Votre Agent, nommé Alfred, réalisera une tùche simple et démontrera comment appliquer ces concepts en pratique.
+
+Vous apprendrez mĂȘme comment **publier votre Agent sur Hugging Face Spaces**, afin de le partager avec vos amis et collĂšgues.
+
+Enfin, Ă la fin de cette UnitĂ©, vous passerez un quiz. RĂ©ussissez-le, et vous **obtiendrez votre premiĂšre certification du cours** : le đ Certificat des Fondamentaux des Agents.
+
+
+
+Cette Unité est votre **point de départ essentiel**, posant les bases pour comprendre les Agents avant de passer à des sujets plus avancés.
+
+
+
+C'est une grande unité, alors **prenez votre temps** et n'hésitez pas à revenir sur ces sections de temps en temps.
+
+PrĂȘt ? Plongeons dans l'aventure ! đ
diff --git a/units/fr/unit1/messages-and-special-tokens.mdx b/units/fr/unit1/messages-and-special-tokens.mdx
new file mode 100644
index 00000000..de22f65c
--- /dev/null
+++ b/units/fr/unit1/messages-and-special-tokens.mdx
@@ -0,0 +1,33 @@
+# Messages et Tokens Spéciaux
+
+Maintenant que nous comprenons comment fonctionnent les LLMs, examinons **comment ils structurent leurs générations via des modÚles de chat**.
+
+Tout comme avec ChatGPT, les utilisateurs interagissent généralement avec les Agents via une interface de chat. Par conséquent, nous souhaitons comprendre comment les LLMs gÚrent les chats.
+
+> **Q** : Mais⊠Lorsque j'interagis avec ChatGPT/Hugging Chat, j'ai une conversation en utilisant des messages de chat, et non une seule séquence de prompt
+>
+> **A** : C'est exact ! Mais il s'agit en rĂ©alitĂ© d'une abstraction de l'interface utilisateur. Avant d'ĂȘtre injectĂ©s dans le LLM, tous les messages de la conversation sont concatĂ©nĂ©s en un seul prompt. Le modĂšle ne « se souvient » pas de la conversation : il la lit en intĂ©gralitĂ© Ă chaque fois.
+
+Jusqu'à présent, nous avons parlé des prompts comme étant la séquence de tokens envoyée dans le modÚle. Mais lorsque vous discutez avec des systÚmes tels que ChatGPT ou Hugging Chat, **vous échangez en réalité des messages**. Dans les coulisses, ces messages sont **concaténés et formatés en un prompt que le modÚle peut comprendre**.
+
+
+
+
+
+Un aspect crucial des agents d'IA est leur capacité à prendre des **actions**. Comme nous l'avons vu, cela se fait par l'utilisation des **outils**.
+
+Dans cette section, nous verrons ce que sont les outils, comment les concevoir efficacement, et comment les intégrer dans votre agent via le message systÚme.
+
+En fournissant Ă votre agent les bons outils â et en dĂ©crivant clairement le fonctionnement de ces outils â vous pouvez augmenter de maniĂšre spectaculaire ce que votre IA peut accomplir. Plongeons-nous dedans !
+
+## Qu'est-ce que les outils d'IA ?
+
+Un **outil est une fonction fournie au LLM**. Cette fonction doit remplir un **objectif clair**.
+
+Voici quelques outils couramment utilisés dans les agents d'IA :
+
+| Outil | Description |
+|---------------------|-------------------------------------------------------------------------------------------------|
+| Recherche Web | Permet à l'agent de récupérer des informations à jour depuis Internet. |
+| Génération d'images | Crée des images à partir de descriptions textuelles. |
+| Récupération | RécupÚre des informations à partir d'une source externe. |
+| Interface API | Interagit avec une API externe (GitHub, YouTube, Spotify, etc.). |
+
+Ce ne sont que des exemples, car en réalité, vous pouvez créer un outil pour n'importe quel cas d'utilisation !
+
+Un bon outil doit ĂȘtre quelque chose qui **complĂ©mente la puissance d'un LLM**.
+
+Par exemple, si vous devez effectuer des opérations arithmétiques, fournir un **outil calculatrice** à votre LLM donnera de meilleurs résultats que de se fier aux capacités natives du modÚle.
+
+De plus, **les LLMs prédisent la complétion d'une invite en se basant sur leurs données d'entraßnement**, ce qui signifie que leur connaissance interne n'inclut que les événements antérieurs à leur entraßnement. Par conséquent, si votre agent a besoin de données à jour, vous devez les fournir via un outil.
+
+Par exemple, si vous demandez directement à un LLM (sans outil de recherche) la météo d'aujourd'hui, le LLM pourrait inventer une météo aléatoire.
+
+
+
+- Un outil doit contenir :
+
+ - Une **description textuelle de ce que fait la fonction**.
+ - Un *callable* (quelque chose pour effectuer une action).
+ - Des *arguments* avec typage.
+ - (Optionnel) Des sorties avec typage.
+
+## Comment fonctionnent les outils ?
+
+Comme nous l'avons vu, les LLMs ne peuvent recevoir que des entrĂ©es textuelles et gĂ©nĂ©rer des sorties textuelles. Ils ne peuvent pas appeler des outils par eux-mĂȘmes. Par _fournir des outils Ă un Agent_, nous **enseignons** au LLM l'existence des outils et lui demandons de gĂ©nĂ©rer du texte qui invoquera ces outils lorsqu'il en aura besoin. Par exemple, si nous fournissons un outil pour vĂ©rifier la mĂ©tĂ©o d'un lieu via Internet, puis que nous demandons au LLM la mĂ©tĂ©o Ă Paris, le LLM reconnaĂźtra que cette question constitue une opportunitĂ© pertinente pour utiliser l'outil "mĂ©tĂ©o" que nous lui avons enseignĂ©. Le LLM gĂ©nĂ©rera du _texte_, sous forme de code, pour invoquer cet outil. Il incombe Ă l'**Agent** d'analyser la sortie du LLM, de reconnaĂźtre qu'un appel Ă un outil est requis, et d'invoquer l'outil au nom du LLM. La sortie de l'outil sera ensuite renvoyĂ©e au LLM, qui composera sa rĂ©ponse finale pour l'utilisateur.
+
+La sortie d'un appel d'outil est un autre type de message dans la conversation. Les étapes d'appel d'outil ne sont généralement pas montrées à l'utilisateur : l'Agent récupÚre la conversation, appelle l'(les) outil(s), obtient les sorties, les ajoute en tant que nouveau message dans la conversation, et renvoie la conversation mise à jour au LLM. Du point de vue de l'utilisateur, c'est comme si le LLM avait utilisé l'outil, mais en réalité, c'est notre code applicatif (l'**Agent**) qui l'a fait.
+
+Nous parlerons beaucoup plus de ce processus lors de sessions futures.
+
+## Comment fournir des outils Ă un LLM ?
+
+La réponse complÚte peut sembler complexe, mais nous utilisons essentiellement le prompt systÚme pour fournir au modÚle des descriptions textuelles des outils disponibles :
+
+
+
+Pour que cela fonctionne, nous devons ĂȘtre trĂšs prĂ©cis et rigoureux concernant :
+
+1. **Ce que fait l'outil**
+2. **Les entrées exactes qu'il attend**
+
+C'est la raison pour laquelle les descriptions d'outils sont généralement fournies en utilisant des structures expressives mais précises, telles que des langages informatiques ou du JSON. Il n'est pas _nécessaire_ de procéder ainsi, tout format précis et cohérent fonctionnerait.
+
+Si cela semble trop théorique, comprenons-le à travers un exemple concret.
+
+Nous allons implémenter un outil **calculatrice** simplifié qui se contentera de multiplier deux entiers. Voici une implémentation en Python :
+
+```python
+def calculator(a: int, b: int) -> int:
+ """Multiplie deux entiers."""
+ return a * b
+
+print(calculator.to_string())
+```
+
+Ainsi, notre outil s'appelle `calculator`, il **multiplie deux entiers**, et il requiert les entrées suivantes :
+
+- **`a`** (*int*): Un entier.
+- **`b`** (*int*): Un entier.
+
+La sortie de l'outil est un autre nombre entier que nous pouvons décrire ainsi :
+- (*int*): Le produit de `a` et `b`.
+
+Tous ces détails sont importants. Rassemblons-les dans une chaßne de texte qui décrit notre outil pour que le LLM puisse le comprendre.
+
+```
+Nom de l'outil: calculator, Description: Multiplie deux entiers., Arguments: a: int, b: int, Sorties: int
+```
+
+> **Rappel :** Cette description textuelle est *ce que nous voulons que le LLM sache Ă propos de l'outil*.
+
+Lorsque nous passons la chaßne précédente dans l'entrée du LLM, le modÚle la reconnaßtra comme un outil et saura quelles entrées fournir et ce qu'il doit attendre en sortie.
+
+Si nous souhaitons fournir des outils supplĂ©mentaires, nous devons rester cohĂ©rents et utiliser toujours le mĂȘme format. Ce processus peut ĂȘtre fragile, et nous pourrions accidentellement nĂ©gliger certains dĂ©tails.
+
+Existe-t-il une meilleure méthode ?
+
+### Sections d'auto-formatage des outils
+
+Notre outil a été écrit en Python, et l'implémentation fournit déjà tout ce dont nous avons besoin :
+
+- Un nom descriptif de ce qu'il fait : `calculator`
+- Une description plus détaillée, fournie par le commentaire docstring de la fonction : `Multiplie deux entiers.`
+- Les entrées et leur type : la fonction attend clairement deux `int`.
+- Le type de la sortie.
+
+Il y a une raison pour laquelle on utilise des langages de programmation : ils sont expressifs, concis et précis.
+
+Nous pourrions fournir le code source Python comme _spécification_ de l'outil pour le LLM, mais la maniÚre dont l'outil est implémenté n'a pas d'importance. Tout ce qui compte, c'est son nom, ce qu'il fait, les entrées qu'il attend et la sortie qu'il fournit.
+
+Nous tirerons parti des fonctionnalités d'introspection de Python pour exploiter le code source et construire automatiquement une description de l'outil. Tout ce dont nous avons besoin, c'est que l'implémentation de l'outil utilise des annotations de types, des docstrings et des noms de fonction pertinents. Nous écrirons un peu de code pour extraire les parties pertinentes du code source.
+
+Une fois cela fait, il nous suffira d'utiliser un décorateur Python pour indiquer que la fonction `calculator` est un outil :
+
+```python
+@tool
+def calculator(a: int, b: int) -> int:
+ """Multiplie deux entiers."""
+ return a * b
+
+print(calculator.to_string())
+```
+
+Notez le décorateur `@tool` avant la définition de la fonction.
+
+Avec l'implémentation que nous verrons ensuite, nous serons capables d'extraire automatiquement le texte suivant à partir du code source :
+
+```
+Nom de l'outil: calculator, Description: Multiplie deux entiers., Arguments: a: int, b: int, Sorties: int
+```
+
+Comme vous pouvez le constater, c'est la mĂȘme chose que nous avons Ă©crit manuellement prĂ©cĂ©demment !
+
+### Implémentation générique d'un outil
+
+Nous créons une classe générique `Tool` que nous pouvons réutiliser chaque fois que nous avons besoin d'utiliser un outil.
+
+> **Avertissement :** Cette implémentation d'exemple est fictive mais ressemble de prÚs aux implémentations réelles dans la plupart des bibliothÚques.
+
+```python
+class Tool:
+ """
+ Une classe représentant un morceau de code réutilisable (Outil).
+
+ Attributs:
+ name (str): Nom de l'outil.
+ description (str): Une description textuelle de ce que fait l'outil.
+ func (callable): La fonction que cet outil encapsule.
+ arguments (list): Une liste d'arguments.
+ outputs (str ou list): Le(s) type(s) de retour de la fonction encapsulée.
+ """
+ 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:
+ """
+ Retourne une représentation sous forme de chaßne de l'outil,
+ incluant son nom, sa description, ses arguments, et ses sorties.
+ """
+ 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):
+ """
+ Invoque la fonction sous-jacente (callable) avec les arguments fournis.
+ """
+ return self.func(*args, **kwargs)
+```
+
+Cela peut sembler compliqué, mais en y allant pas à pas, nous pouvons voir ce qu'elle fait. Nous définissons une classe **`Tool`** qui inclut :
+
+- **`name`** (*str*): Le nom de l'outil.
+- **`description`** (*str*): Une brĂšve description de ce que fait l'outil.
+- **`function`** (*callable*): La fonction que l'outil exécute.
+- **`arguments`** (*list*): Les paramÚtres d'entrée attendus.
+- **`outputs`** (*str* ou *list*): Les sorties attendues de l'outil.
+- **`__call__()`** : Appelle la fonction lorsque l'instance de l'outil est invoquée.
+- **`to_string()`** : Convertit les attributs de l'outil en une représentation textuelle.
+
+Nous pourrions créer un outil avec cette classe en utilisant le code suivant :
+
+```python
+calculator_tool = Tool(
+ "calculator", # nom
+ "Multiplie deux entiers.", # description
+ calculator, # fonction Ă appeler
+ [("a", "int"), ("b", "int")], # entrées (noms et types)
+ "int", # sortie
+)
+```
+
+Mais nous pouvons également utiliser le module `inspect` de Python pour récupérer toutes les informations pour nous ! C'est ce que fait le décorateur `@tool`.
+
+> Si cela vous intéresse, vous pouvez afficher la section suivante pour voir l'implémentation du décorateur.
+
+
+
+Dans la section [Actions](actions), nous en apprendrons plus sur la façon dont un Agent peut **appeler** cet outil que nous venons de créer.
+
+---
+
+Les outils jouent un rÎle crucial dans l'amélioration des capacités des agents d'IA.
+
+Pour résumer, nous avons appris :
+
+- *Ce que sont les outils* : des fonctions qui offrent des capacités supplémentaires aux LLMs, comme effectuer des calculs ou accéder à des données externes.
+- *Comment définir un outil* : en fournissant une description textuelle claire, des entrées, des sorties, et une fonction exécutable.
+- *Pourquoi les outils sont essentiels* : ils permettent aux Agents de surmonter les limites de l'entraßnement statique des modÚles, de gérer des tùches en temps réel, et d'effectuer des actions spécialisées.
+
+Maintenant, nous pouvons passer au [Workflow de l'Agent](agent-steps-and-structure) oĂč vous verrez comment un Agent observe, rĂ©flĂ©chit et agit. Cela **rassemble tout ce que nous avons vu jusqu'Ă prĂ©sent** et prĂ©pare le terrain pour crĂ©er votre propre Agent IA entiĂšrement fonctionnel.
+
+Mais d'abord, il est temps pour un autre court quiz !
diff --git a/units/fr/unit1/tutorial.mdx b/units/fr/unit1/tutorial.mdx
new file mode 100644
index 00000000..affddcc7
--- /dev/null
+++ b/units/fr/unit1/tutorial.mdx
@@ -0,0 +1,221 @@
+# Créons notre premier Agent avec smolagents
+
+Dans la section prĂ©cĂ©dente, nous avons appris comment crĂ©er des Agents Ă partir de zĂ©ro en utilisant du code Python, et nous avons **vu Ă quel point ce processus peut ĂȘtre fastidieux**. Heureusement, de nombreuses bibliothĂšques d'agents simplifient ce travail en **se chargeant de la majeure partie du travail lourd pour vous**.
+
+Dans ce tutoriel, **vous créerez votre tout premier Agent** capable d'exécuter des actions telles que la génération d'images, la recherche sur le web, la vérification de fuseaux horaires et bien plus encore !
+
+Vous publierez Ă©galement votre agent **sur un Hugging Face Space afin de le partager avec vos amis et collĂšgues**.
+
+C'est parti !
+
+## Qu'est-ce que smolagents ?
+
+
+
+Pour créer cet Agent, nous allons utiliser `smolagents`, une bibliothÚque qui **fournit un cadre facilitant le développement de vos agents**.
+
+Cette bibliothÚque légÚre est conçue pour la simplicité, tout en masquant une grande partie de la complexité liée à la construction d'un Agent, vous permettant ainsi de vous concentrer sur la conception du comportement de votre agent.
+
+Nous approfondirons smolagents dans la prochaine unité. En attendant, vous pouvez également consulter ce billet de blog ou le dépÎt GitHub de la bibliothÚque.
+
+En bref, `smolagents` est une bibliothÚque qui se concentre sur le **codeAgent**, un type d'agent qui exécute des **"Actions"** via des blocs de code, puis **"Observe"** les résultats en exécutant le code.
+
+Voici un exemple de ce que nous allons construire !
+
+Nous avons équipé notre agent d'un **outil de génération d'images** et lui avons demandé de générer une image d'un chat.
+
+L'agent dans `smolagents` aura les **mĂȘmes comportements que celui personnalisĂ© que nous avons construit prĂ©cĂ©demment** : il va **penser, agir et observer en cycle** jusqu'Ă atteindre une rĂ©ponse finale :
+
+
+
+Excitant, n'est-ce pas ?
+
+## Construisons notre Agent !
+
+Pour commencer, dupliquez ce Space : https://huggingface.co/spaces/agents-course/First_agent_template
+> Merci Ă Aymeric pour ce template ! đ
+
+Dupliquer cet Space signifie **créer une copie locale sur votre propre profil** :
+
+
+Tout au long de cette leçon, le seul fichier que vous aurez à modifier est le (actuellement incomplet) **"app.py"**. Vous pouvez consulter l'[original dans le template](https://huggingface.co/spaces/agents-course/First_agent_template/blob/main/app.py). Pour trouver le vÎtre, allez dans votre copie du Space, cliquez sur l'onglet `Files` puis sur `app.py` dans la liste des répertoires.
+
+Analysons le code ensemble :
+
+- Le fichier commence par quelques importations de bibliothÚques simples mais nécessaires
+
+```python
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
+import datetime
+import requests
+import pytz
+import yaml
+from tools.final_answer import FinalAnswerTool
+```
+
+Comme indiqué précédemment, nous utiliserons directement la classe **CodeAgent** de **smolagents**.
+
+### Les Outils
+
+Entrons maintenant dans le vif du sujet avec les outils ! Si vous souhaitez un rappel sur les outils, n'hésitez pas à consulter la section [Outils](tools) du cours.
+
+```python
+@tool
+def my_custom_tool(arg1: str, arg2: int) -> str: # il est important de spécifier le type de retour
+ # Conservez ce format pour la description de l'outil et des arguments, mais n'hésitez pas à modifier l'outil
+ """Un outil qui ne fait encore rien
+ Arguments:
+ arg1: le premier argument
+ arg2: le deuxiĂšme argument
+ """
+ return "Quelle magie allez-vous créer ?"
+
+@tool
+def get_current_time_in_timezone(timezone: str) -> str:
+ """Un outil qui récupÚre l'heure locale actuelle dans un fuseau horaire spécifié.
+ Arguments:
+ timezone: Une chaßne représentant un fuseau horaire valide (par exemple, 'America/New_York').
+ """
+ try:
+ # Créer l'objet fuseau horaire
+ tz = pytz.timezone(timezone)
+ # Obtenir l'heure actuelle dans ce fuseau horaire
+ local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
+ return f"L'heure locale actuelle dans {timezone} est : {local_time}"
+ except Exception as e:
+ return f"Erreur lors de la récupération de l'heure pour le fuseau horaire '{timezone}' : {str(e)}"
+```
+
+Les outils sont ce que nous vous encourageons Ă construire dans cette section ! Nous vous donnons deux exemples :
+
+1. Un **outil factice non fonctionnel** que vous pouvez modifier pour créer quelque chose d'utile.
+2. Un **outil réellement fonctionnel** qui récupÚre l'heure actuelle quelque part dans le monde.
+
+Pour définir votre outil, il est important de :
+
+1. Fournir des types d'entrée et de sortie pour votre fonction, comme dans `get_current_time_in_timezone(timezone: str) -> str:`
+2. Fournir une **docstring bien formatée**. `smolagents` s'attend à ce que tous les arguments aient une **description textuelle dans la docstring**.
+
+### L'Agent
+
+Il utilise [`Qwen/Qwen2.5-Coder-32B-Instruct`](https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct) comme moteur LLM. C'est un modÚle trÚs performant auquel nous accéderons via l'API serverless.
+
+```python
+final_answer = FinalAnswerTool()
+model = HfApiModel(
+ 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)
+
+# Nous créons notre CodeAgent
+agent = CodeAgent(
+ model=model,
+ tools=[final_answer], # ajoutez vos outils ici (ne supprimez pas final_answer)
+ max_steps=6,
+ verbosity_level=1,
+ grammar=None,
+ planning_interval=None,
+ name=None,
+ description=None,
+ prompt_templates=prompt_templates
+)
+
+GradioUI(agent).launch()
+```
+
+Cet Agent utilise toujours l'`InferenceClient` que nous avons vu dans une section précédente derriÚre la classe **HfApiModel** !
+
+Nous fournirons des exemples plus détaillés lors de la présentation du cadre dans l'Unité 2. Pour l'instant, vous devez vous concentrer sur **l'ajout de nouveaux outils à la liste des outils** en utilisant le paramÚtre `tools` de votre Agent.
+
+Par exemple, vous pourriez utiliser le `DuckDuckGoSearchTool` qui a été importé dans la premiÚre ligne du code, ou vous pouvez examiner le `image_generation_tool` qui est chargé depuis le Hub plus tard dans le code.
+
+**Ajouter des outils donnera de nouvelles capacités à votre agent**, alors soyez créatif !
+
+Le fichier complet **"app.py"** :
+
+```python
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
+import datetime
+import requests
+import pytz
+import yaml
+from tools.final_answer import FinalAnswerTool
+
+from Gradio_UI import GradioUI
+
+# Voici un exemple d'un outil qui ne fait encore rien. Ăpatez-nous avec votre crĂ©ativitĂ© !
+@tool
+def my_custom_tool(arg1: str, arg2: int) -> str: # il est important de spécifier le type de retour
+ # Conservez ce format pour la description de l'outil et des arguments, mais n'hésitez pas à modifier l'outil
+ """Un outil qui ne fait encore rien
+ Arguments:
+ arg1: le premier argument
+ arg2: le deuxiĂšme argument
+ """
+ return "Quelle magie allez-vous créer ?"
+
+@tool
+def get_current_time_in_timezone(timezone: str) -> str:
+ """Un outil qui récupÚre l'heure locale actuelle dans un fuseau horaire spécifié.
+ Arguments:
+ timezone: Une chaßne représentant un fuseau horaire valide (par exemple, 'America/New_York').
+ """
+ try:
+ # Créer l'objet fuseau horaire
+ tz = pytz.timezone(timezone)
+ # Obtenir l'heure actuelle dans ce fuseau horaire
+ local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
+ return f"L'heure locale actuelle dans {timezone} est : {local_time}"
+ except Exception as e:
+ return f"Erreur lors de la récupération de l'heure pour le fuseau horaire '{timezone}' : {str(e)}"
+
+
+final_answer = FinalAnswerTool()
+model = HfApiModel(
+ max_tokens=2096,
+ temperature=0.5,
+ model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
+ custom_role_conversions=None,
+)
+
+# Importer l'outil depuis le Hub
+image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
+
+with open("prompts.yaml", 'r') as stream:
+ prompt_templates = yaml.safe_load(stream)
+
+agent = CodeAgent(
+ model=model,
+ tools=[final_answer], # ajoutez vos outils ici (ne supprimez pas final_answer)
+ max_steps=6,
+ verbosity_level=1,
+ grammar=None,
+ planning_interval=None,
+ name=None,
+ description=None,
+ prompt_templates=prompt_templates
+)
+
+GradioUI(agent).launch()
+```
+
+Votre **objectif** est de vous familiariser avec le Space et l'Agent.
+
+Actuellement, l'agent dans le template **n'utilise aucun outil, alors essayez de lui fournir certains des outils prĂ©fabriquĂ©s ou mĂȘme de crĂ©er de nouveaux outils vous-mĂȘme !**
+
+Nous attendons avec impatience vos incroyables agents dans le canal Discord **#agents-course-showcase**!
+
+---
+
+Félicitations, vous avez construit votre premier Agent ! N'hésitez pas à le partager avec vos amis et collÚgues.
+
+Comme c'est votre premiÚre tentative, il est tout à fait normal qu'il soit un peu bogué ou lent. Dans les unités futures, nous apprendrons à construire des Agents encore meilleurs.
+
+La meilleure façon d'apprendre est d'essayer, alors n'hésitez pas à le mettre à jour, à ajouter plus d'outils, à essayer avec un autre modÚle, etc.
+
+Dans la prochaine section, vous allez remplir le quiz final et obtenir votre certificat !
diff --git a/units/fr/unit1/what-are-agents.mdx b/units/fr/unit1/what-are-agents.mdx
new file mode 100644
index 00000000..3867d689
--- /dev/null
+++ b/units/fr/unit1/what-are-agents.mdx
@@ -0,0 +1,44 @@
+# Qu'est-ce qu'un Agent ?
+
+
+
+Ă la fin de cette section, vous vous sentirez Ă l'aise avec le concept d'agents et leurs diverses applications dans l'IA.
+
+Pour expliquer ce qu'est un Agent, commençons par une analogie.
+
+## La Vue d'Ensemble : Alfred l'Agent
+
+Voici Alfred. Alfred est un **Agent**.
+
+
+
+Imaginez qu'Alfred **reçoive une commande**, par exemple : « Alfred, je voudrais un café s'il te plaßt. »
+
+
+
+Parce qu'Alfred **comprend le langage naturel**, il saisit rapidement notre demande.
+
+Avant de satisfaire la commande, Alfred se livre au **raisonnement et à la planification**, déterminant les étapes et les outils dont il a besoin pour :
+
+1. Aller Ă la cuisine
+2. Utiliser la machine à café
+3. Préparer le café
+4. Ramener le café
+
+
+
+Une fois qu'il a établi un plan, il **doit agir**. Pour exécuter son plan, **il peut utiliser les outils qu'il connaßt**.
+
+Dans ce cas, pour préparer un café, il utilise une machine à café. Il active la machine à café pour préparer le café.
+
+
+
+Enfin, Alfred nous apporte le café fraßchement préparé.
+
+
+
+Et voilĂ ce qu'est un Agent : un **modĂšle d'IA capable de raisonner, de planifier et d'interagir avec son environnement**.
+
+On l'appelle Agent parce qu'il possÚde de l'_agency_ (la capacité d'agir), autrement dit, il peut interagir avec l'environnement.
+
+
+| ModÚle | +Fournisseur | +Token EOS | +Fonctionnalité | +
|---|---|---|---|
| GPT4 | +OpenAI | +<|endoftext|> |
+ Fin du texte du message | +
| Llama 3 | +Meta (Facebook AI Research) | +<|eot_id|> |
+ Fin de la séquence | +
| Deepseek-R1 | +DeepSeek | +<|end_of_sentence|> |
+ Fin du texte du message | +
| SmolLM2 | +Hugging Face | +<|im_end|> |
+ Fin de l'instruction ou du message | +
| Gemma | +<end_of_turn> |
+ Fin du tour de conversation | +
+
+En d'autres termes, un LLM décodera le texte jusqu'à atteindre le token EOS. Mais que se passe-t-il lors d'une boucle de décodage unique ?
+
+Bien que le processus complet puisse ĂȘtre assez technique dans le cadre de l'apprentissage des agents, voici un aperçu succinct :
+
+- Une fois le texte d'entrée **tokenisé**, le modÚle calcule une représentation de la séquence qui capture des informations sur la signification et la position de chaque token.
+- Cette représentation est ensuite traitée par le modÚle, qui produit des scores classant la probabilité que chaque token de son vocabulaire soit le suivant dans la séquence.
+
+
+
+En se basant sur ces scores, plusieurs stratégies existent pour sélectionner les tokens afin de compléter la phrase.
+
+- La stratégie de décodage la plus simple serait de toujours choisir le token ayant le score maximum.
+
+Vous pouvez interagir vous-mĂȘme avec le processus de dĂ©codage grĂące Ă SmolLM2 dans cet espace (n'oubliez pas, il dĂ©code jusqu'Ă atteindre un token **EOS** qui est **<|im_end|>** pour ce modĂšle) :
+
+
+
+- Mais il existe des stratĂ©gies de dĂ©codage plus avancĂ©es. Par exemple, le *beam search* (recherche par faisceaux) explore plusieurs sĂ©quences candidates pour trouver celle ayant le score total maximum â mĂȘme si certains tokens individuels prĂ©sentent des scores plus faibles.
+
+
+
+Si vous souhaitez en savoir plus sur le dĂ©codage, vous pouvez jeter un Ćil au [cours de NLP](https://huggingface.co/learn/nlp-course).
+
+## L'attention est tout ce dont vous avez besoin
+
+Un aspect clĂ© de l'architecture Transformer est **l'Attention**. Lors de la prĂ©diction du mot suivant, tous les mots d'une phrase ne sont pas Ă©galement importants ; des mots comme "France" et "capitale" dans la phrase *"La capitale de la France est âŠ"* portent le plus de sens.
+
+
+
+Ce processus d'identification des mots les plus pertinents pour prédire le token suivant s'est révélé incroyablement efficace.
+
+Bien que le principe de base des LLMs â prĂ©dire le token suivant â soit restĂ© constant depuis GPT-2, des avancĂ©es significatives ont Ă©tĂ© rĂ©alisĂ©es dans la montĂ©e en Ă©chelle des rĂ©seaux de neurones et dans le fonctionnement du mĂ©canisme d'attention pour des sĂ©quences toujours plus longues.
+
+Si vous avez déjà interagi avec des LLMs, vous connaissez probablement le terme *longueur de contexte*, qui fait référence au nombre maximum de tokens que le LLM peut traiter, ainsi qu'à la _durée d'attention_ maximale dont il dispose.
+
+## L'importance de bien formuler les invites pour le LLM
+
+Ătant donnĂ© que la seule tĂąche d'un LLM est de prĂ©dire le token suivant en examinant chaque token d'entrĂ©e, et de choisir ceux qui sont "importants", la formulation de votre sĂ©quence d'entrĂ©e revĂȘt une importance capitale.
+
+La séquence d'entrée que vous fournissez à un LLM est appelée _prompt_. Une conception minutieuse du prompt facilite **l'orientation de la génération du LLM vers la sortie souhaitée**.
+
+## Comment sont entraßnés les LLMs ?
+
+Les LLMs sont entraĂźnĂ©s sur de grands ensembles de donnĂ©es textuelles, oĂč ils apprennent Ă prĂ©dire le mot suivant dans une sĂ©quence grĂące Ă un objectif d'apprentissage auto-supervisĂ© ou de modĂ©lisation de langage masquĂ©e.
+
+Grùce à cet apprentissage non supervisé, le modÚle apprend la structure de la langue et les **motifs sous-jacents du texte, ce qui lui permet de généraliser à des données inédites**.
+
+AprĂšs ce _prĂ©-entraĂźnement_ initial, les LLMs peuvent ĂȘtre ajustĂ©s via un apprentissage supervisĂ© pour rĂ©aliser des tĂąches spĂ©cifiques. Par exemple, certains modĂšles sont entraĂźnĂ©s pour des structures conversationnelles ou l'utilisation d'outils, tandis que d'autres se concentrent sur la classification ou la gĂ©nĂ©ration de code.
+
+## Comment puis-je utiliser les LLMs ?
+
+Vous avez deux options principales :
+
+1. **Exécuter localement** (si vous disposez du matériel nécessaire).
+
+2. **Utiliser un service Cloud/API** (par exemple, via l'API d'inférence sans serveur de Hugging Face).
+
+Tout au long de ce cours, nous utiliserons principalement des modÚles via des API sur le Hub de Hugging Face. Par la suite, nous explorerons comment exécuter ces modÚles localement sur votre matériel.
+
+## Comment les LLMs sont-ils utilisés dans les Agents IA ?
+
+Les LLMs sont un composant clé des Agents IA, **fournissant la base pour comprendre et générer le langage humain**.
+
+Ils peuvent interpréter les instructions de l'utilisateur, maintenir le contexte dans les conversations, définir un plan et décider quels outils utiliser.
+
+Nous explorerons ces étapes en détail dans cette Unité, mais pour l'instant, ce qu'il faut retenir, c'est que le LLM est **le cerveau de l'Agent**.
+
+---
+
+Cela fait beaucoup d'informations ! Nous avons couvert les bases de ce que sont les LLMs, comment ils fonctionnent, et leur rĂŽle dans l'alimentation des agents IA.
+
+Si vous souhaitez plonger encore plus profondément dans le monde fascinant des modÚles de langage et du traitement du langage naturel, n'hésitez pas à consulter notre cours gratuit de NLP.
+
+Maintenant que nous comprenons le fonctionnement des LLMs, il est temps de voir **comment les LLMs structurent leurs générations dans un contexte conversationnel**.
+
+Pour exécuter ce notebook, **vous avez besoin d'un token Hugging Face** que vous pouvez obtenir sur https://hf.co/settings/tokens.
+
+Vous devez Ă©galement demander l'accĂšs aux modĂšles Meta Llama.
diff --git a/units/fr/unit2/README.md b/units/fr/unit2/README.md
new file mode 100644
index 00000000..e69de29b
diff --git a/units/fr/unit3/README.md b/units/fr/unit3/README.md
new file mode 100644
index 00000000..e69de29b
diff --git a/units/fr/unit4/README.md b/units/fr/unit4/README.md
new file mode 100644
index 00000000..e69de29b