Delete checkpoints

fr/unit2/langgraph/.ipynb_checkpoints/agent-checkpoint.ipynb

@@ -1,326 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "89791f21c171372a",
-   "metadata": {},
-   "source": [
-    "# Agent\n",
-    "\n",
-    "Dans ce *notebook*, **nous allons construire un agent simple en utilisant LangGraph**.\n",
-    "\n",
-    "Ce notebook fait parti du cours <a href=\"https://huggingface.co/learn/agents-course/fr\">sur les agents d'Hugging Face</a>, un cours gratuit qui vous guidera, du **niveau débutant à expert**, pour comprendre, utiliser et construire des agents.\n",
-    "![Agents course share](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/communication/share.png)\n",
-    "\n",
-    "Comme nous l'avons vu dans l'Unité 1, un agent a besoin de 3 étapes telles qu'introduites dans l'architecture ReAct :\n",
-    "[ReAct](https://react-lm.github.io/), une architecture générale d'agent.\n",
-    "\n",
-    "* `act` - laisser le modèle appeler des outils spécifiques\n",
-    "* `observe` - transmettre la sortie de l'outil au modèle\n",
-    "* `reason` - permet au modèle de raisonner sur la sortie de l'outil pour décider de ce qu'il doit faire ensuite (par exemple, appeler un autre outil ou simplement répondre directement).\n",
-    "\n",
-    "![Agent](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/LangGraph/Agent.png)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "bef6c5514bd263ce",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install -q -U langchain_openai langchain_core langgraph"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "61d0ed53b26fa5c6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "# Veuillez configurer votre propre clé\n",
-    "os.environ[\"OPENAI_API_KEY\"] = \"sk-xxxxxx\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a4a8bf0d5ac25a37",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import base64\n",
-    "from langchain_core.messages import HumanMessage\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "vision_llm = ChatOpenAI(model=\"gpt-4o\")\n",
-    "\n",
-    "\n",
-    "def extract_text(img_path: str) -> str:\n",
-    "    \"\"\"\n",
-    "    Extract text from an image file using a multimodal model.\n",
-    "\n",
-    "    Args:\n",
-    "        img_path: A local image file path (strings).\n",
-    "\n",
-    "    Returns:\n",
-    "        A single string containing the concatenated text extracted from each image.\n",
-    "    \"\"\"\n",
-    "    all_text = \"\"\n",
-    "    try:\n",
-    "\n",
-    "        # Lire l'image et l'encoder en base64\n",
-    "        with open(img_path, \"rb\") as image_file:\n",
-    "            image_bytes = image_file.read()\n",
-    "\n",
-    "        image_base64 = base64.b64encode(image_bytes).decode(\"utf-8\")\n",
-    "\n",
-    "        # Préparer le prompt en incluant les données de l'image base64\n",
-    "        message = [\n",
-    "            HumanMessage(\n",
-    "                content=[\n",
-    "                    {\n",
-    "                        \"type\": \"text\",\n",
-    "                        \"text\": (\n",
-    "                            \"Extract all the text from this image. \"\n",
-    "                            \"Return only the extracted text, no explanations.\"\n",
-    "                        ),\n",
-    "                    },\n",
-    "                    {\n",
-    "                        \"type\": \"image_url\",\n",
-    "                        \"image_url\": {\n",
-    "                            \"url\": f\"data:image/png;base64,{image_base64}\"\n",
-    "                        },\n",
-    "                    },\n",
-    "                ]\n",
-    "            )\n",
-    "        ]\n",
-    "\n",
-    "        # Appeler le VLM\n",
-    "        response = vision_llm.invoke(message)\n",
-    "\n",
-    "        # Ajouter le texte extrait\n",
-    "        all_text += response.content + \"\\n\\n\"\n",
-    "\n",
-    "        return all_text.strip()\n",
-    "    except Exception as e:\n",
-    "        # Vous pouvez choisir de renvoyer une chaîne vide ou un message d'erreur.\n",
-    "        error_msg = f\"Error extracting text: {str(e)}\"\n",
-    "        print(error_msg)\n",
-    "        return \"\"\n",
-    "\n",
-    "\n",
-    "llm = ChatOpenAI(model=\"gpt-4o\")\n",
-    "\n",
-    "\n",
-    "def divide(a: int, b: int) -> float:\n",
-    "    \"\"\"Divide a and b.\"\"\"\n",
-    "    return a / b\n",
-    "\n",
-    "\n",
-    "tools = [\n",
-    "    divide,\n",
-    "    extract_text\n",
-    "]\n",
-    "llm_with_tools = llm.bind_tools(tools, parallel_tool_calls=False)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "3e7c17a2e155014e",
-   "metadata": {},
-   "source": [
-    "Créons notre LLM et demandons-lui le comportement global souhaité de l'agent."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f31250bc1f61da81",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from typing import TypedDict, Annotated, Optional\n",
-    "from langchain_core.messages import AnyMessage\n",
-    "from langgraph.graph.message import add_messages\n",
-    "\n",
-    "\n",
-    "class AgentState(TypedDict):\n",
-    "    # Le document d'entrée\n",
-    "    input_file: Optional[str]  # Contient le chemin d'accès au fichier, le type (PNG)\n",
-    "    messages: Annotated[list[AnyMessage], add_messages]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3c4a736f9e55afa9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.messages import HumanMessage, SystemMessage\n",
-    "from langchain_core.utils.function_calling import convert_to_openai_tool\n",
-    "\n",
-    "\n",
-    "def assistant(state: AgentState):\n",
-    "    # Message système\n",
-    "    textual_description_of_tool = \"\"\"\n",
-    "extract_text(img_path: str) -> str:\n",
-    "    Extract text from an image file using a multimodal model.\n",
-    "\n",
-    "    Args:\n",
-    "        img_path: A local image file path (strings).\n",
-    "\n",
-    "    Returns:\n",
-    "        A single string containing the concatenated text extracted from each image.\n",
-    "divide(a: int, b: int) -> float:\n",
-    "    Divide a and b\n",
-    "\"\"\"\n",
-    "    image = state[\"input_file\"]\n",
-    "    sys_msg = SystemMessage(content=f\"You are an helpful agent that can analyse some images and run some computatio without provided tools :\\n{textual_description_of_tool} \\n You have access to some otpional images. Currently the loaded images is : {image}\")\n",
-    "\n",
-    "    return {\"messages\": [llm_with_tools.invoke([sys_msg] + state[\"messages\"])], \"input_file\": state[\"input_file\"]}"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6f1efedd943d8b1d",
-   "metadata": {},
-   "source": [
-    "Nous définissons un nœud `tools` avec notre liste d'outils.\n",
-    "\n",
-    "Le noeud `assistant` est juste notre modèle avec les outils liés.\n",
-    "\n",
-    "Nous créons un graphe avec les noeuds `assistant` et `tools`.\n",
-    "\n",
-    "Nous ajoutons l'arête `tools_condition`, qui route vers `End` ou vers `tools` selon que le `assistant` appelle ou non un outil.\n",
-    "\n",
-    "Maintenant, nous ajoutons une nouvelle étape :\n",
-    "\n",
-    "Nous connectons le noeud `tools` au `assistant`, formant une boucle.\n",
-    "\n",
-    "* Après l'exécution du noeud `assistant`, `tools_condition` vérifie si la sortie du modèle est un appel d'outil.\n",
-    "* Si c'est le cas, le flux est dirigé vers le noeud `tools`.\n",
-    "* Le noeud `tools` se connecte à `assistant`.\n",
-    "* Cette boucle continue tant que le modèle décide d'appeler des outils.\n",
-    "* Si la réponse du modèle n'est pas un appel d'outil, le flux est dirigé vers END, mettant fin au processus."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e013061de784638a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langgraph.graph import START, StateGraph\n",
-    "from langgraph.prebuilt import ToolNode, tools_condition\n",
-    "from IPython.display import Image, display\n",
-    "\n",
-    "# Graphe\n",
-    "builder = StateGraph(AgentState)\n",
-    "\n",
-    "# Définir les nœuds : ce sont eux qui font le travail\n",
-    "builder.add_node(\"assistant\", assistant)\n",
-    "builder.add_node(\"tools\", ToolNode(tools))\n",
-    "\n",
-    "# Définir les arêtes : elles déterminent la manière dont le flux de contrôle se déplace\n",
-    "builder.add_edge(START, \"assistant\")\n",
-    "builder.add_conditional_edges(\n",
-    "    \"assistant\",\n",
-    "    # Si le dernier message (résultat) de l'assistant est un appel d'outil -> tools_condition va vers tools\n",
-    "    # Si le dernier message (résultat) de l'assistant n'est pas un appel d'outil -> tools_condition va à END\n",
-    "    tools_condition,\n",
-    ")\n",
-    "builder.add_edge(\"tools\", \"assistant\")\n",
-    "react_graph = builder.compile()\n",
-    "\n",
-    "# Afficher\n",
-    "display(Image(react_graph.get_graph(xray=True).draw_mermaid_png()))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d3b0ba5be1a54aad",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages = [HumanMessage(content=\"Divide 6790 by 5\")]\n",
-    "\n",
-    "messages = react_graph.invoke({\"messages\": messages, \"input_file\": None})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "55eb0f1afd096731",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for m in messages['messages']:\n",
-    "    m.pretty_print()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e0062c1b99cb4779",
-   "metadata": {},
-   "source": [
-    "## Programme d'entraînement\n",
-    "M. Wayne a laissé une note avec son programme d'entraînement pour la semaine. J'ai trouvé une recette pour le dîner, laissée dans une note.\n",
-    "\n",
-    "Vous pouvez trouver le document [ICI](https://huggingface.co/datasets/agents-course/course-images/blob/main/en/unit2/LangGraph/Batman_training_and_meals.png), alors téléchargez-le et mettez-le dans le dossier local.\n",
-    "\n",
-    "![Training](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/LangGraph/Batman_training_and_meals.png)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2e166ebba82cfd2a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages = [HumanMessage(content=\"According the note provided by MR wayne in the provided images. What's the list of items I should buy for the dinner menu ?\")]\n",
-    "\n",
-    "messages = react_graph.invoke({\"messages\": messages, \"input_file\": \"Batman_training_and_meals.png\"})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5bfd67af70b7dcf3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for m in messages['messages']:\n",
-    "    m.pretty_print()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

fr/unit2/langgraph/.ipynb_checkpoints/mail_sorting-checkpoint.ipynb

@@ -1,457 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Alfred, le majordome chargé de trier le courrier : Un exemple de LangGraph\n",
-    "\n",
-    "Dans ce *notebook*, **nous allons construire un *workflow* complet pour le traitement des emails en utilisant LangGraph**.\n",
-    "\n",
-    "Ce notebook fait parti du cours <a href=\"https://huggingface.co/learn/agents-course/fr\">sur les agents d'Hugging Face</a>, un cours gratuit qui vous guidera, du **niveau débutant à expert**, pour comprendre, utiliser et construire des agents.\n",
-    "\n",
-    "![Agents course share](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/communication/share.png)\n",
-    "\n",
-    "## Ce que vous allez apprendre\n",
-    "\n",
-    "Dans ce *notebook*, vous apprendrez à :\n",
-    "1. Mettre en place un *workflow* LangGraph\n",
-    "2. Définir l'état et les nœuds pour le traitement des emails\n",
-    "3. Créer un branchement conditionnel dans un graphe\n",
-    "4. Connecter un LLM pour la classification et la génération de contenu\n",
-    "5. Visualiser le graphe du *workflow*\n",
-    "6. Exécuter le *workflow* avec des données d'exemple"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Installer les paquets nécessaires\n",
-    "%pip install -q langgraph langchain_openai langchain_huggingface"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Configuration de notre environnement\n",
-    "\n",
-    "Tout d'abord, importons toutes les bibliothèques nécessaires. LangGraph fournit la structure du graphe, tandis que LangChain offre des interfaces pratiques pour travailler avec les LLM."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "from typing import TypedDict, List, Dict, Any, Optional\n",
-    "from langgraph.graph import StateGraph, START, END\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "from langchain_core.messages import HumanMessage\n",
-    "\n",
-    "# Définissez votre clé API OpenAI ici\n",
-    "os.environ[\"OPENAI_API_KEY\"] = \"sk-xxxxx\"  # Remplacer par votre clé API\n",
-    "\n",
-    "# Initialiser notre LLM\n",
-    "model = ChatOpenAI(model=\"gpt-4o\", temperature=0)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Étape 1 : Définir notre état\n",
-    "\n",
-    "Dans LangGraph, **State** est le concept central. Il représente toutes les informations qui circulent dans notre *workflow*.\n",
-    "\n",
-    "Pour le système de traitement des emails d'Alfred, nous devons suivre :\n",
-    "- L'email en cours de traitement\n",
-    "- S'il s'agit d'un spam ou non\n",
-    "- Le projet de réponse (pour les courriels légitimes)\n",
-    "- L'historique de la conversation avec le LLM"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class EmailState(TypedDict):\n",
-    "    email: Dict[str, Any]\n",
-    "    is_spam: Optional[bool]\n",
-    "    spam_reason: Optional[str]\n",
-    "    email_category: Optional[str]\n",
-    "    email_draft: Optional[str]\n",
-    "    messages: List[Dict[str, Any]]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Étape 2 : Définir nos nœuds"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def read_email(state: EmailState):\n",
-    "    email = state[\"email\"]\n",
-    "    print(f\"Alfred is processing an email from {email['sender']} with subject: {email['subject']}\")\n",
-    "    return {}\n",
-    "\n",
-    "\n",
-    "def classify_email(state: EmailState):\n",
-    "    email = state[\"email\"]\n",
-    "\n",
-    "    prompt = f\"\"\"\n",
-    "As Alfred the butler of Mr wayne and it's SECRET identity Batman, analyze this email and determine if it is spam or legitimate and should be brought to Mr wayne's attention.\n",
-    "\n",
-    "Email:\n",
-    "From: {email['sender']}\n",
-    "Subject: {email['subject']}\n",
-    "Body: {email['body']}\n",
-    "\n",
-    "First, determine if this email is spam.\n",
-    "answer with SPAM or HAM if it's legitimate. Only return the answer\n",
-    "Answer :\n",
-    "    \"\"\"\n",
-    "    messages = [HumanMessage(content=prompt)]\n",
-    "    response = model.invoke(messages)\n",
-    "\n",
-    "    response_text = response.content.lower()\n",
-    "    print(response_text)\n",
-    "    is_spam = \"spam\" in response_text and \"ham\" not in response_text\n",
-    "\n",
-    "    if not is_spam:\n",
-    "        new_messages = state.get(\"messages\", []) + [\n",
-    "            {\"role\": \"user\", \"content\": prompt},\n",
-    "            {\"role\": \"assistant\", \"content\": response.content}\n",
-    "        ]\n",
-    "    else:\n",
-    "        new_messages = state.get(\"messages\", [])\n",
-    "\n",
-    "    return {\n",
-    "        \"is_spam\": is_spam,\n",
-    "        \"messages\": new_messages\n",
-    "    }\n",
-    "\n",
-    "\n",
-    "def handle_spam(state: EmailState):\n",
-    "    print(f\"Alfred has marked the email as spam.\")\n",
-    "    print(\"The email has been moved to the spam folder.\")\n",
-    "    return {}\n",
-    "\n",
-    "\n",
-    "def drafting_response(state: EmailState):\n",
-    "    email = state[\"email\"]\n",
-    "\n",
-    "    prompt = f\"\"\"\n",
-    "As Alfred the butler, draft a polite preliminary response to this email.\n",
-    "\n",
-    "Email:\n",
-    "From: {email['sender']}\n",
-    "Subject: {email['subject']}\n",
-    "Body: {email['body']}\n",
-    "\n",
-    "Draft a brief, professional response that Mr. Wayne can review and personalize before sending.\n",
-    "    \"\"\"\n",
-    "\n",
-    "    messages = [HumanMessage(content=prompt)]\n",
-    "    response = model.invoke(messages)\n",
-    "\n",
-    "    new_messages = state.get(\"messages\", []) + [\n",
-    "        {\"role\": \"user\", \"content\": prompt},\n",
-    "        {\"role\": \"assistant\", \"content\": response.content}\n",
-    "    ]\n",
-    "\n",
-    "    return {\n",
-    "        \"email_draft\": response.content,\n",
-    "        \"messages\": new_messages\n",
-    "    }\n",
-    "\n",
-    "\n",
-    "def notify_mr_wayne(state: EmailState):\n",
-    "    email = state[\"email\"]\n",
-    "\n",
-    "    print(\"\\n\" + \"=\" * 50)\n",
-    "    print(f\"Sir, you've received an email from {email['sender']}.\")\n",
-    "    print(f\"Subject: {email['subject']}\")\n",
-    "    print(\"\\nI've prepared a draft response for your review:\")\n",
-    "    print(\"-\" * 50)\n",
-    "    print(state[\"email_draft\"])\n",
-    "    print(\"=\" * 50 + \"\\n\")\n",
-    "\n",
-    "    return {}\n",
-    "\n",
-    "\n",
-    "# Définir la logique de routage\n",
-    "def route_email(state: EmailState) -> str:\n",
-    "    if state[\"is_spam\"]:\n",
-    "        return \"spam\"\n",
-    "    else:\n",
-    "        return \"legitimate\"\n",
-    "\n",
-    "\n",
-    "# Créer le graphe\n",
-    "email_graph = StateGraph(EmailState)\n",
-    "\n",
-    "# Ajouter des nœuds\n",
-    "email_graph.add_node(\"read_email\", read_email)  # le nœud read_email exécute la fonction read_mail\n",
-    "email_graph.add_node(\"classify_email\", classify_email)  # le nœud classify_email exécutera la fonction classify_email\n",
-    "email_graph.add_node(\"handle_spam\", handle_spam)  # même logique\n",
-    "email_graph.add_node(\"drafting_response\", drafting_response)  # même logique\n",
-    "email_graph.add_node(\"notify_mr_wayne\", notify_mr_wayne)  # même logique\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Étape 3 : Définir notre logique de routage"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Ajouter des arêtes\n",
-    "email_graph.add_edge(START, \"read_email\")  # Après le départ, nous accédons au nœud « read_email »\n",
-    "\n",
-    "email_graph.add_edge(\"read_email\", \"classify_email\")  # after_reading nous classifions\n",
-    "\n",
-    "# Ajouter des arêtes conditionnelles\n",
-    "email_graph.add_conditional_edges(\n",
-    "    \"classify_email\",  # après la classification, nous exécutons la fonction « route_email »\n",
-    "    route_email,\n",
-    "    {\n",
-    "        \"spam\": \"handle_spam\",  # s'il renvoie « Spam », nous allons au noeud « handle_span »\n",
-    "        \"legitimate\": \"drafting_response\"  # et s'il est légitime, nous passons au nœud « drafting_response »\n",
-    "    }\n",
-    ")\n",
-    "\n",
-    "# Ajouter les arêtes finales\n",
-    "email_graph.add_edge(\"handle_spam\", END)  # après avoir traité le spam, nous terminons toujours\n",
-    "email_graph.add_edge(\"drafting_response\", \"notify_mr_wayne\")\n",
-    "email_graph.add_edge(\"notify_mr_wayne\", END)  # après avoir notifié M. Wayne, nous pouvons mettre un terme à l'opération\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Étape 4 : Créer le graphe d'état et définir les arêtes"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Compiler le graphique\n",
-    "compiled_graph = email_graph.compile()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from IPython.display import Image, display\n",
-    "\n",
-    "display(Image(compiled_graph.get_graph().draw_mermaid_png()))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    " # Exemple de courriels à tester\n",
-    "legitimate_email = {\n",
-    "    \"sender\": \"Joker\",\n",
-    "    \"subject\": \"Found you Batman ! \",\n",
-    "    \"body\": \"Mr. Wayne,I found your secret identity ! I know you're batman ! Ther's no denying it, I have proof of that and I'm coming to find you soon. I'll get my revenge. JOKER\"\n",
-    "}\n",
-    "\n",
-    "spam_email = {\n",
-    "    \"sender\": \"Crypto bro\",\n",
-    "    \"subject\": \"The best investment of 2025\",\n",
-    "    \"body\": \"Mr Wayne, I just launched an ALT coin and want you to buy some !\"\n",
-    "}\n",
-    "# Traiter les emails légitimes\n",
-    "print(\"\\nProcessing legitimate email...\")\n",
-    "legitimate_result = compiled_graph.invoke({\n",
-    "    \"email\": legitimate_email,\n",
-    "    \"is_spam\": None,\n",
-    "    \"spam_reason\": None,\n",
-    "    \"email_category\": None,\n",
-    "    \"email_draft\": None,\n",
-    "    \"messages\": []\n",
-    "})\n",
-    "\n",
-    "# Traiter les spams\n",
-    "print(\"\\nProcessing spam email...\")\n",
-    "spam_result = compiled_graph.invoke({\n",
-    "    \"email\": spam_email,\n",
-    "    \"is_spam\": None,\n",
-    "    \"spam_reason\": None,\n",
-    "    \"email_category\": None,\n",
-    "    \"email_draft\": None,\n",
-    "    \"messages\": []\n",
-    "})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Étape 5 : Inspection de notre agent trieur d'emails avec Langfuse 📡\n",
-    "\n",
-    "Au fur et à mesure qu'Alfred peaufine l'agent trieur d'emails, il se lasse de déboguer ses exécutions. Les agents, par nature, sont imprévisibles et difficiles à inspecter. Mais comme son objectif est de construire l'ultime agent de détection de spam et de le déployer en production, il a besoin d'une traçabilité solide pour un contrôle et une analyse ultérieurs.\n",
-    "\n",
-    "Pour ce faire, Alfred peut utiliser un outil d'observabilité tel que [Langfuse](https://langfuse.com/) pour retracer et surveiller les étapes internes de l'agent.\n",
-    "\n",
-    "Tout d'abord, nous devons installer les dépendances nécessaires :"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install -q langfuse"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Ensuite, nous définissons les clés de l'API Langfuse et l'adresse de l'hôte en tant que variables d'environnement. Vous pouvez obtenir vos identifiants Langfuse en vous inscrivant à [Langfuse Cloud](https://cloud.langfuse.com) ou à [Langfuse auto-hébergé](https://langfuse.com/self-hosting)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "# Obtenez les clés de votre projet à partir de la page des paramètres du projet : https://cloud.langfuse.com\n",
-    "os.environ[\"LANGFUSE_PUBLIC_KEY\"] = \"pk-lf-...\"\n",
-    "os.environ[\"LANGFUSE_SECRET_KEY\"] = \"sk-lf-...\"\n",
-    "os.environ[\"LANGFUSE_HOST\"] = \"https://cloud.langfuse.com\"  # 🇪🇺 région EU \n",
-    "# os.environ[\"LANGFUSE_HOST\"] = \"https://us.cloud.langfuse.com\" # 🇺🇸 région US"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Nous allons maintenant configurer le [Langfuse `callback_handler`] (https://langfuse.com/docs/integrations/langchain/tracing#add-langfuse-to-your-langchain-application)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langfuse.langchain import CallbackHandler\n",
-    "\n",
-    "# Initialiser le CallbackHandler Langfuse pour LangGraph/Langchain (traçage)\n",
-    "langfuse_handler = CallbackHandler()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Nous ajoutons ensuite `config={« callbacks » : [langfuse_handler]}` à l'invocation des agents et les exécutons à nouveau."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Traiter les emails légitimes\n",
-    "print(\"\\nProcessing legitimate email...\")\n",
-    "legitimate_result = compiled_graph.invoke(\n",
-    "    input={\n",
-    "        \"email\": legitimate_email,\n",
-    "        \"is_spam\": None,\n",
-    "        \"draft_response\": None,\n",
-    "        \"messages\": []\n",
-    "    },\n",
-    "    config={\"callbacks\": [langfuse_handler]}\n",
-    ")\n",
-    "\n",
-    "# Traiter les spams\n",
-    "print(\"\\nProcessing spam email...\")\n",
-    "spam_result = compiled_graph.invoke(\n",
-    "    input={\n",
-    "        \"email\": spam_email,\n",
-    "        \"is_spam\": None,\n",
-    "        \"draft_response\": None,\n",
-    "        \"messages\": []\n",
-    "    },\n",
-    "    config={\"callbacks\": [langfuse_handler]}\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Alfred est maintenant connecté 🔌 ! Les exécutions de LangGraph sont enregistrées dans Langfuse, ce qui lui donne une visibilité totale sur le comportement de l'agent. Avec cette configuration, il est prêt à revoir les exécutions précédentes et à affiner encore davantage son agent de tri du courrier.\n",
-    "\n",
-    "![Example trace in Langfuse](https://langfuse.com/images/cookbook/huggingface-agent-course/langgraph-trace-legit.png)\n",
-    "\n",
-    "_[Lien public vers la trace avec l'email légitime](https://cloud.langfuse.com/project/cloramnkj0002jz088vzn1ja4/traces/f5d6d72e-20af-4357-b232-af44c3728a7b?timestamp=2025-03-17T10%3A13%3A28.413Z&observation=6997ba69-043f-4f77-9445-700a033afba1)_\n",
-    "\n",
-    "![Example trace in Langfuse](https://langfuse.com/images/cookbook/huggingface-agent-course/langgraph-trace-spam.png)\n",
-    "\n",
-    "_[Lien public vers la trace du spam](https://langfuse.com/project/cloramnkj0002jz088vzn1ja4/traces/6e498053-fee4-41fd-b1ab-d534aca15f82?timestamp=2025-03-17T10%3A13%3A30.884Z&observation=84770fc8-4276-4720-914f-bf52738d44ba)_\n"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}