fr/bonus-unit2/monitoring-and-evaluating-agents.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unité Bonus 2 : Observabilité et évaluation des agents\n",
    "\n",
    "Dans ce tutoriel, nous allons apprendre à **surveiller les étapes internes (traces) de notre agent** et **évaluer sa performance** en utilisant des outils d'observabilité open-source.\n",
    "\n",
    "La capacité d'observer et d'évaluer le comportement d'un agent est essentielle pour :\n",
    "- Déboguer les problèmes lorsque les tâches échouent ou produisent des résultats sous-optimaux\n",
    "- Contrôler les coûts et les performances en temps réel\n",
    "- Améliorer la fiabilité et la sécurité grâce à un retour d'information continu\n",
    "\n",
    "Ce *notebook* fait partie du [Cours sur les agents d'Hugging Face](https://huggingface.co/learn/agents-course/fr)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prérequis de l'exercice 🏗️\n",
    "\n",
    "Avant d'exécuter ce *notebook*, assurez-vous d'avoir :\n",
    "\n",
    "🔲 📚 **Etudier la section [Introduction aux agents](https://huggingface.co/learn/agents-course/fr/unit1/introduction)**\n",
    "\n",
    "🔲 📚 **Etudier la section [le *framework* smolagents](https://huggingface.co/learn/agents-course/fr/unit2/smolagents/introduction)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Étape 0 : Installer les bibliothèques nécessaires\n",
    "\n",
    "Nous aurons besoin de quelques bibliothèques qui nous permettront d'exécuter, de contrôler et d'évaluer nos agents :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install langfuse 'smolagents[telemetry]' openinference-instrumentation-smolagents datasets 'smolagents[gradio]' gradio --upgrade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Étape 1 : Instrumenter votre agent\n",
    "\n",
    "Dans ce *notebook*, nous utiliserons [Langfuse](https://langfuse.com/) comme outil d'observabilité, mais vous pouvez utiliser **n'importe quel autre service compatible avec OpenTelemetry**. Le code ci-dessous montre comment définir les variables d'environnement pour Langfuse (ou n'importe quel *endpoint OTel*) et comment instrumenter votre smolagent.\n",
    "\n",
    "**Note :** Si vous utilisez LlamaIndex ou LangGraph, vous pouvez trouver de la documentation sur leur instrumentation [ici](https://langfuse.com/docs/integrations/llama-index/workflows) et [ici](https://langfuse.com/docs/integrations/langchain/example-python-langgraph)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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\n",
    "\n",
    "# Définissez vos tokens/secrets Hugging Face comme variable d'environnement\n",
    "os.environ[\"HF_TOKEN\"] = \"hf_...\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les variables d'environnement étant définies, nous pouvons maintenant initialiser le client de Langfuse `get_client()` initialise le client Langfuse en utilisant les informations d'identification fournies dans les variables d'environnement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Langfuse client is authenticated and ready!\n"
     ]
    }
   ],
   "source": [
    "from langfuse import get_client\n",
    " \n",
    "langfuse = get_client()\n",
    " \n",
    "# Verify connection\n",
    "if langfuse.auth_check():\n",
    "    print(\"Langfuse client is authenticated and ready!\")\n",
    "else:\n",
    "    print(\"Authentication failed. Please check your credentials and host.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Attempting to instrument while already instrumented\n"
     ]
    }
   ],
   "source": [
    "from openinference.instrumentation.smolagents import SmolagentsInstrumentor\n",
    " \n",
    "SmolagentsInstrumentor().instrument()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Étape 2 : Testez votre instrumentation\n",
    "\n",
    "Voici un simple CodeAgent de smolagents qui calcule `1+1`. Nous l'exécutons pour confirmer que l'instrumentation fonctionne correctement. Si tout est configuré correctement, vous verrez des logs/spans dans votre tableau de bord d'observabilité."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from smolagents import InferenceClientModel, CodeAgent\n",
    "\n",
    "# Créer un agent basique pour tester l'instrumentation\n",
    "agent = CodeAgent(\n",
    "    tools=[],\n",
    "    model=InferenceClientModel()\n",
    ")\n",
    "\n",
    "agent.run(\"1+1=\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consultez votre [Langfuse Traces Dashboard](https://cloud.langfuse.com/traces) (ou l'outil d'observabilité de votre choix) pour confirmer que les portées et les logs ont été enregistrés.\n",
    "\n",
    "Exemple de capture d'écran de Langfuse :\n",
    "\n",
    "![Example trace in Langfuse](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit2/first-example-trace.png)\n",
    "\n",
    "_[Lien vers la trace](https://cloud.langfuse.com/project/cloramnkj0002jz088vzn1ja4/traces/1b94d6888258e0998329cdb72a371155?timestamp=2025-03-10T11%3A59%3A41.743Z)_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Étape 3 : Observer et évaluer un agent plus complexe\n",
    "\n",
    "Maintenant que vous avez confirmé que votre instrumentation fonctionne, essayons une requête plus complexe afin de voir comment les mesures avancées (utilisation des *tokens*, latence, coûts, etc.) sont suivies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from smolagents import (CodeAgent, DuckDuckGoSearchTool, InferenceClientModel)\n",
    "\n",
    "search_tool = DuckDuckGoSearchTool()\n",
    "agent = CodeAgent(tools=[search_tool], model=InferenceClientModel())\n",
    "\n",
    "agent.run(\"How many Rubik's Cubes could you fit inside the Notre Dame Cathedral?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Structure de la trace\n",
    "\n",
    "La plupart des outils d'observabilité enregistrent une **trace** qui contient des **spans**, qui représentent chaque étape de la logique de votre agent. Ici, la trace contient l'exécution globale de l'agent et les sous-périodes pour :\n",
    "- les appels à l'outil (DuckDuckGoSearchTool)\n",
    "- Les appels LLM (InferenceClientModel)\n",
    "\n",
    "Vous pouvez les inspecter pour voir précisément où le temps est passé, combien de *tokens* sont utilisés, etc. :\n",
    "\n",
    "![Trace tree in Langfuse](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit2/trace-tree.png)\n",
    "\n",
    "_[Lien vers la trace](https://cloud.langfuse.com/project/cloramnkj0002jz088vzn1ja4/traces/1ac33b89ffd5e75d4265b62900c348ed?timestamp=2025-03-07T13%3A45%3A09.149Z&display=preview)_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Évaluation en ligne\n",
    "\n",
    "Dans la section précédente, nous avons appris la différence entre l'évaluation en ligne et hors ligne. Nous allons maintenant voir comment surveiller votre agent en production et l'évaluer en direct.\n",
    "\n",
    "### Métriques courantes à suivre en production\n",
    "\n",
    "1. **Coûts** - L'instrumentation smolagents capture l'utilisation des *tokens*, que vous pouvez transformer en coûts approximatifs en assignant un prix par *token*.\n",
    "2. **Latence** - Observez le temps nécessaire à la réalisation de chaque étape ou de l'ensemble de l'exécution.\n",
    "3. **Retour utilisateur** - Les utilisateurs peuvent fournir un retour direct (pouce vers le haut/vers le bas) pour aider à affiner ou à corriger l'agent.\n",
    "4. ***LLM-as-a-Judge*** - Utilisez un autre LLM pour évaluer les résultats de votre agent en quasi temps réel (par exemple, vérification de la toxicité ou de l'exactitude des résultats).\n",
    "\n",
    "Ci-dessous, nous montrons des exemples de ces métriques."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Coûts\n",
    "\n",
    "Vous trouverez ci-dessous une capture d'écran montrant l'utilisation des appels `Qwen2.5-Coder-32B-Instruct`. Ceci est utile pour voir les étapes coûteuses et optimiser votre agent.\n",
    "\n",
    "![Costs](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit2/smolagents-costs.png)\n",
    "\n",
    "_[Lien vers la trace](https://cloud.langfuse.com/project/cloramnkj0002jz088vzn1ja4/traces/1ac33b89ffd5e75d4265b62900c348ed?timestamp=2025-03-07T13%3A45%3A09.149Z&display=preview)_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Temps de latence\n",
    "\n",
    "Nous pouvons également voir combien de temps a duré chaque étape. Dans l'exemple ci-dessous, l'ensemble de la conversation a duré 32 secondes, que vous pouvez répartir par étape. Cela vous permet d'identifier les goulets d'étranglement et d'optimiser votre agent.\n",
    "\n",
    "![Latency](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit2/smolagents-latency.png)\n",
    "\n",
    "_[Lien vers la trace](https://cloud.langfuse.com/project/cloramnkj0002jz088vzn1ja4/traces/1ac33b89ffd5e75d4265b62900c348ed?timestamp=2025-03-07T13%3A45%3A09.149Z&display=preview)_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. Attributs supplémentaires\n",
    "\n",
    "Vous pouvez également passer des attributs supplémentaires à vos spans. Ceux-ci peuvent inclure `user_id`, `tags`, `session_id`, et des métadonnées personnalisées. Enrichir les traces avec ces détails est important pour l'analyse, le débogage et la surveillance du comportement de votre application à travers différents utilisateurs ou sessions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from smolagents import (CodeAgent, DuckDuckGoSearchTool, InferenceClientModel)\n",
    "\n",
    "search_tool = DuckDuckGoSearchTool()\n",
    "agent = CodeAgent(\n",
    "    tools=[search_tool],\n",
    "    model=InferenceClientModel()\n",
    ")\n",
    "\n",
    "with langfuse.start_as_current_span(\n",
    "    name=\"Smolagent-Trace\",\n",
    "    ) as span:\n",
    "    \n",
    "    # Lancez votre application ici\n",
    "    response = agent.run(\"What is the capital of Germany?\")\n",
    " \n",
    "    # Transmettre des attributs supplémentaires au span\n",
    "    span.update_trace(\n",
    "        input=\"What is the capital of Germany?\",\n",
    "        output=response,\n",
    "        user_id=\"smolagent-user-123\",\n",
    "        session_id=\"smolagent-session-123456789\",\n",
    "        tags=[\"city-question\", \"testing-agents\"],\n",
    "        metadata={\"email\": \"user@langfuse.com\"},\n",
    "        )\n",
    " \n",
    "langfuse.flush()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Enhancing agent runs with additional metrics](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit2/smolagents-attributes.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. Retour utilisateur\n",
    "\n",
    "Si votre agent est intégré dans une interface utilisateur, vous pouvez enregistrer les réactions directes de l'utilisateur (comme un pouce levé ou baissé dans une interface de discussion). Vous trouverez ci-dessous un exemple utilisant [Gradio](https://gradio.app/) pour intégrer un chat avec un mécanisme de retour d'information simple.\n",
    "\n",
    "Dans l'extrait de code ci-dessous, lorsqu'un utilisateur envoie un message de chat, nous capturons la trace dans Langfuse. Si l'utilisateur aime ou n'aime pas la dernière réponse, nous attribuons un score à la trace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gradio as gr\n",
    "from smolagents import (CodeAgent, InferenceClientModel)\n",
    "from langfuse import get_client\n",
    "\n",
    "langfuse = get_client()\n",
    "\n",
    "model = InferenceClientModel()\n",
    "agent = CodeAgent(tools=[], model=model, add_base_tools=True)\n",
    "\n",
    "trace_id = None\n",
    "\n",
    "def respond(prompt, history):\n",
    "    with langfuse.start_as_current_span(\n",
    "        name=\"Smolagent-Trace\"):\n",
    "        \n",
    "        # Exécuter l'application\n",
    "        output = agent.run(prompt)\n",
    "\n",
    "        global trace_id\n",
    "        trace_id = langfuse.get_current_trace_id()\n",
    "\n",
    "    history.append({\"role\": \"assistant\", \"content\": str(output)})\n",
    "    return history\n",
    "\n",
    "def handle_like(data: gr.LikeData):\n",
    "    # À titre de démonstration, nous mappons les retours utilisateurs une valeur de 1 (j'aime) ou de 0 (je n'aime pas)\n",
    "    if data.liked:\n",
    "        langfuse.create_score(\n",
    "            value=1,\n",
    "            name=\"user-feedback\",\n",
    "            trace_id=trace_id\n",
    "        )\n",
    "    else:\n",
    "        langfuse.create_score(\n",
    "            value=0,\n",
    "            name=\"user-feedback\",\n",
    "            trace_id=trace_id\n",
    "        )\n",
    "\n",
    "with gr.Blocks() as demo:\n",
    "    chatbot = gr.Chatbot(label=\"Chat\", type=\"messages\")\n",
    "    prompt_box = gr.Textbox(placeholder=\"Type your message...\", label=\"Your message\")\n",
    "\n",
    "    # Lorsque l'utilisateur appuie sur \"Enter\", nous exécutons 'respond'\n",
    "    prompt_box.submit(\n",
    "        fn=respond,\n",
    "        inputs=[prompt_box, chatbot],\n",
    "        outputs=chatbot\n",
    "    )\n",
    "\n",
    "    # Lorsque l'utilisateur clique sur le bouton \"J'aime\" d'un message, nous exécutons 'handle_like'\n",
    "    chatbot.like(handle_like, None, None)\n",
    "\n",
    "demo.launch()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les retours des utilisateurs sont ensuite saisis dans votre outil d'observabilité :\n",
    "\n",
    "![User feedback is being captured in Langfuse](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit2/user-feedback-gradio.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5. LLM-as-a-Judge\n",
    "\n",
    "LLM-as-a-Judge est une autre façon d'évaluer automatiquement les résultats de votre agent. Vous pouvez configurer l'appel d'un autre LLM pour évaluer l'exactitude, la toxicité, le style ou tout autre critère qui vous intéresse.\n",
    "\n",
    "**Fonctionnement** :\n",
    "1. Vous définissez un **Modèle d'évaluation**, par exemple, « Vérifier si le texte est toxique ».\n",
    "2. Chaque fois que votre agent génère un résultat, vous transmettez ce résultat à votre LLM juge avec le gabarit.\n",
    "3. Le LLM juge répond avec un score ou une étiquette que vous enregistrez dans votre outil d'observabilité.\n",
    "\n",
    "Exemple de Langfuse :\n",
    "\n",
    "![LLM-as-a-Judge Evaluation Template](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit2/evaluator-template.png)\n",
    "![LLM-as-a-Judge Evaluator](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit2/evaluator.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exemple : Vérifier si la production de l'agent est toxique ou non\n",
    "from smolagents import (CodeAgent, DuckDuckGoSearchTool, InferenceClientModel)\n",
    "\n",
    "search_tool = DuckDuckGoSearchTool()\n",
    "agent = CodeAgent(tools=[search_tool], model=InferenceClientModel())\n",
    "\n",
    "agent.run(\"Can eating carrots improve your vision?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous pouvez voir que la réponse de cet exemple est jugée « non toxique ».\n",
    "\n",
    "![LLM-as-a-Judge Evaluation Score](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit2/llm-as-a-judge-score.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6. Aperçu des métriques d'observabilité\n",
    "\n",
    "Toutes ces métriques peuvent être visualisées ensemble dans des tableaux de bord. Cela vous permet de voir rapidement les performances de votre agent sur plusieurs sessions et vous aide à suivre les mesures de qualité au fil du temps.\n",
    "\n",
    "![Observability metrics overview](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit2/langfuse-dashboard.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Évaluation hors ligne\n",
    "\n",
    "L'évaluation en ligne est essentielle pour obtenir un retour d'information en temps réel, mais vous avez également besoin d'une **évaluation hors ligne**, c'est-à-dire de vérifications systématiques avant ou pendant le développement. Cela permet de maintenir la qualité et la fiabilité avant de mettre les changements en production."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Évaluation d'un jeu de données\n",
    "\n",
    "Lors d'une évaluation hors ligne, vous devez généralement\n",
    "1. Disposer d'un jeu de données de référence (avec des paires de *prompts* et de résultats attendus)\n",
    "2. Exécuter votre agent sur ce jeu de données\n",
    "3. Comparer les résultats aux résultats attendus ou utiliser un mécanisme de notation supplémentaire.\n",
    "\n",
    "Ci-dessous, nous démontrons cette approche avec le jeu de données [GSM8K](https://huggingface.co/datasets/gsm8k), qui contient des questions et des solutions mathématiques."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from datasets import load_dataset\n",
    "\n",
    "# Récupérer GSM8K sur Hugging Face\n",
    "dataset = load_dataset(\"openai/gsm8k\", 'main', split='train')\n",
    "df = pd.DataFrame(dataset)\n",
    "print(\"First few rows of GSM8K dataset:\")\n",
    "print(df.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ensuite, nous créons un jeu de données dans Langfuse pour suivre les exécutions. Nous ajoutons ensuite chaque élément du jeu de données au système.  \n",
    "(Si vous n'utilisez pas Langfuse, vous pouvez simplement les stocker dans votre propre base de données ou dans un fichier local à des fins d'analyse)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langfuse import get_client\n",
    "langfuse = get_client()\n",
    "\n",
    "langfuse_dataset_name = \"gsm8k_dataset_huggingface\"\n",
    "\n",
    "# Créer un jeu de données dans Langfuse\n",
    "langfuse.create_dataset(\n",
    "    name=langfuse_dataset_name,\n",
    "    description=\"GSM8K benchmark dataset uploaded from Huggingface\",\n",
    "    metadata={\n",
    "        \"date\": \"2025-03-10\", \n",
    "        \"type\": \"benchmark\"\n",
    "    }\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx, row in df.iterrows():\n",
    "    langfuse.create_dataset_item(\n",
    "        dataset_name=langfuse_dataset_name,\n",
    "        input={\"text\": row[\"question\"]},\n",
    "        expected_output={\"text\": row[\"answer\"]},\n",
    "        metadata={\"source_index\": idx}\n",
    "    )\n",
    "    if idx >= 9: # Ne télécharge que les 10 premiers éléments pour la démonstration\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Dataset items in Langfuse](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit2/example-dataset.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exécution de l'agent sur le jeu de données\n",
    "\n",
    "Nous définissons une fonction d'aide `run_smolagent()` qui :\n",
    "1. Démarre un span Langfuse\n",
    "2. Exécute notre agent sur le *prompt*\n",
    "3. Enregistre l'ID de la trace dans Langfuse\n",
    "\n",
    "Ensuite, nous parcourons en boucle chaque élément de l'ensemble de données, nous exécutons l'agent et nous lions la trace à l'élément de l'ensemble de données. Nous pouvons également joindre une note d'évaluation rapide si vous le souhaitez."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from opentelemetry.trace import format_trace_id\n",
    "from smolagents import (CodeAgent, InferenceClientModel, LiteLLMModel)\n",
    "from langfuse import get_client\n",
    " \n",
    "langfuse = get_client()\n",
    "\n",
    "\n",
    "# Exemple : utilisation de InferenceClientModel ou LiteLLMModel pour accéder aux modèles openai, anthropic, gemini, etc. :\n",
    "model = InferenceClientModel()\n",
    "\n",
    "agent = CodeAgent(\n",
    "    tools=[],\n",
    "    model=model,\n",
    "    add_base_tools=True\n",
    ")\n",
    "\n",
    "dataset_name = \"gsm8k_dataset_huggingface\"\n",
    "current_run_name = \"smolagent-notebook-run-01\" # Identifie ce cycle d'évaluation spécifique\n",
    " \n",
    "# Supposons que « run_smolagent » soit la fonction de l'application instrumentée\n",
    "def run_smolagent(question):\n",
    "    with langfuse.start_as_current_generation(name=\"qna-llm-call\") as generation:\n",
    "        # Simuler un appel LLM\n",
    "        result = agent.run(question)\n",
    " \n",
    "        # Mise à jour de la trace avec l'entrée et la sortie\n",
    "        generation.update_trace(\n",
    "            input= question,\n",
    "            output=result,\n",
    "        )\n",
    " \n",
    "        return result\n",
    " \n",
    "dataset = langfuse.get_dataset(name=dataset_name) # Récupérez votre jeu de données pré-rempli\n",
    " \n",
    "for item in dataset.items:\n",
    " \n",
    "    # Utiliser le gestionnaire de contexte item.run()\n",
    "    with item.run(\n",
    "        run_name=current_run_name,\n",
    "        run_metadata={\"model_provider\": \"Hugging Face\", \"temperature_setting\": 0.7},\n",
    "        run_description=\"Evaluation run for GSM8K dataset\"\n",
    "    ) as root_span: # root_span est le span racine de la nouvelle trace pour cet élément et l'exécution.\n",
    "        # Toutes les opérations langfuse subséquentes à l'intérieur de ce bloc font partie de cette trace.\n",
    " \n",
    "        # Appelez votre logique d'application\n",
    "        generated_answer = run_smolagent(question=item.input[\"text\"])\n",
    " \n",
    "        print(item.input)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous pouvez répéter ce processus avec différents :\n",
    "- Modèles (OpenAI GPT, LLM local, etc.)\n",
    "- Outils (recherche ou pas recherche)\n",
    "- Prompts (différents messages du système)\n",
    "\n",
    "Ensuite, comparez-les côte à côte dans votre outil d'observabilité :\n",
    "\n",
    "![Dataset run overview](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit2/dataset_runs.png)\n",
    "![Dataset run comparison](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit2/dataset-run-comparison.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Réflexions finales\n",
    "\n",
    "Dans ce *notebook*, nous avons vu comment :\n",
    "1. **Mettre en place l'observabilité** en utilisant les exportateurs smolagents + OpenTelemetry\n",
    "2. **Vérifier l'instrumentation** en lançant un agent simple\n",
    "3. **Capturez des métriques détaillées** (coût, latence, etc.) à l'aide d'outils d'observabilité\n",
    "4. **Recueillir les commentaires des utilisateurs** via une interface Gradio\n",
    "5. **Utiliser un LLM-as-a-Judge** pour évaluer automatiquement les résultats\n",
    "6. **Effectuer une évaluation hors ligne** avec un jeu de données de référence\n",
    "\n",
    "🤗 Bon codage !"
   ]
  }
 ],
 "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
}