Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Créer un agent avec l'API Python

Lezione 4 di 18 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. Ton premier agent Mistral
  2. Prérequis
  3. Créer un agent minimal
  4. Définir le comportement avec des instructions
  5. Contrôler la génération
  6. Équiper l’agent d’outils
  7. Gérer le cycle de vie de l’agent
  8. Exemple complet
  9. Punti chiave

Ton premier agent Mistral

Les trois leçons précédentes ont établi le vocabulaire ; celle-ci te met les mains dans le cambouis. Tu vas créer un agent via l’API Python, en l’enrichissant progressivement d’instructions, de paramètres de génération et d’outils, puis tu lanceras une conversation avec lui. La progression est volontairement incrémentale : chaque ajout modifie un comportement observable, te montrant pourquoi la même méthode create() peut produire soit un assistant générique, soit un expert au style verrouillé.

Prérequis

L’installation se fait en deux étapes. D’abord, le SDK officiel.

pip install mistralai

Ensuite, rends ta clé API disponible dans l’environnement plutôt que de la coder en dur dans ton code. Commeter par erreur une clé dans un dépôt est le premier incident de sécurité pour tout projet LLM.

export MISTRAL_API_KEY="your-api-key"

Tu construis ensuite le client en une seule ligne. Cet objet client sert de point d’entrée pour le reste de la leçon.

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

Créer un agent minimal

La méthode client.beta.agents.create() prend trois paramètres obligatoires et plusieurs optionnels. Commençons par le strict minimum.

agent = client.beta.agents.create(
    model="mistral-medium-latest",
    name="Simple Assistant",
    description="A conversational agent with persistent state."
)

print(f"Agent created: {agent.id}")

Cet agent est minimaliste : pas d’instructions spécifiques, pas d’outils, pas de garde-fous. Il se comporte comme un point de terminaison Chat Completions amélioré avec persistance. Note l’identifiant renvoyé dans agent.id : c’est ce que tu stockes côté application, car c’est la seule référence stable à cette configuration.

Définir le comportement avec des instructions

Les instructions agissent comme l’invite système (system prompt) et constituent le levier principal pour contrôler le comportement. L’exemple ci-dessous transforme un assistant générique en expert juridique dont le périmètre, le format et les limites sont explicitement bornés.

agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="Legal Expert",
    description="Agent specialized in French business law.",
    instructions="""You are an expert in French business law.

Rules:
- Always respond in French
- Cite relevant legal articles
- Specify when a question requires a lawyer's opinion
- Structure your responses with headings and lists
- Never give definitive legal advice"""
)

Observe la structure de cette invite : une définition de rôle au début, suivie de règles numérotées. Cette organisation sectionnelle aide le modèle à hiérarchiser les contraintes. Sois précis sur le rôle, le ton et les limites plutôt que d’écrire « sois utile ». Surtout, anticipe les cas limites : que doit faire l’agent si la question sort de son domaine ? La ligne concernant la demande d’avis juridique répond précisément à ce besoin. Enfin, traite les instructions comme du code : tu devras les tester et les réviser plusieurs fois avant qu’elles ne produisent le comportement attendu.

Contrôler la génération

Les completion_args configurent l’échantillonneur, c’est-à-dire la façon dont le modèle choisit ses mots. Un agent chargé de reformuler des faits n’a pas besoin de la même liberté qu’un agent de brainstorming.

agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="Precise Agent",
    description="Agent with controlled generation parameters.",
    instructions="Respond factually and concisely.",
    completion_args={
        "temperature": 0.2,    # Less creativity, more precision
        "top_p": 0.9,          # Probability nucleus
        "max_tokens": 2048     # Response length limit
    }
)
  • temperature — Varie de 0,0 (déterministe) à 1,0 (créatif). Pour les tâches factuelles, privilégie 0,1–0,3.
  • top_p — Filtrage par probabilité cumulative. 0,9 est une bonne valeur par défaut.
  • max_tokens — Limite stricte sur le nombre de tokens de sortie.

Équiper l’agent d’outils

Un agent devient véritablement autonome lorsqu’il peut agir au-delà du texte. La configuration suivante lui donne à la fois accès au web et capacité d’exécution de code : face à une question comparant les taux du jour, il ira chercher les valeurs et calculera le résultat sans ton intervention.

agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="Research Agent",
    description="Agent with web search and code execution.",
    instructions="Use web search for current information and code for calculations.",
    tools=[
        {"type": "web_search"},
        {"type": "code_interpreter"}
    ],
    completion_args={"temperature": 0.3, "top_p": 0.95}
)

Les outils disponibles incluent : web_search, web_search_premium, code_interpreter, image_generation, document_library.

Gérer le cycle de vie de l’agent

Tes agents sont des ressources persistantes côté Mistral, et tu les administreras comme n’importe quelle autre ressource : les trouver, les modifier, les supprimer. La liste est particulièrement utile durant le développement, où tu te retrouves rapidement avec des dizaines d’agents de test dont tu as perdu les identifiants.

# List all your agents
agents = client.beta.agents.list()
for a in agents.data:
    print(f"{a.name} ({a.id})")

# Retrieve an agent by its ID
agent = client.beta.agents.get(agent_id="ag-xxxxxxxx")

Les mises à jour sont partielles : seuls les champs fournis sont modifiés ; les autres restent tels quels. Cela te permet d’affiner les instructions en production sans redéclarer toute la configuration.

agent = client.beta.agents.update(
    agent_id=agent.id,
    instructions="New updated instructions.",
    tools=[{"type": "web_search"}, {"type": "code_interpreter"}]
)

La suppression, en revanche, est définitive.

client.beta.agents.delete(agent_id=agent.id)

Exemple complet

Rassemblons le tout dans un agent entièrement fonctionnel : création, conversation et lecture de la réponse. Tu peux utiliser ce script tel quel ; change simplement le nom et les instructions, et tu auras ton propre analyste opérationnel en quelques minutes.

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

# Create the agent
agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="Tech Analyst",
    description="Analyzes technology trends with web sources.",
    instructions="""You are a technology analyst.
- Use web search for recent data
- Always cite your sources
- Structure your analyses into key points""",
    tools=[{"type": "web_search"}],
    completion_args={"temperature": 0.3}
)

# Start a conversation
response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="What are the latest advancements in agentic AI in 2026?"
)

# Display the response
for entry in response.outputs:
    if hasattr(entry, "content"):
        print(entry.content)

La boucle finale mérite un instant d’attention : elle itère sur response.outputs au lieu de lire un seul champ, car un agent équipé d’outils produit plusieurs entrées — l’exécution de la recherche, puis le texte. C’est le point clé à surveiller dans la prochaine leçon.

Punti chiave

  • client.beta.agents.create() crée un agent avec un modèle, un nom et une description (obligatoires)
  • Les instructions définissent le comportement : c’est le levier principal
  • completion_args contrôlent la génération (température, top_p, max_tokens)
  • Un agent peut avoir plusieurs outils activés simultanément
  • Les agents sont des configurations réutilisables, pas des instances de conversation