Exemple concret : CRM automatisé
På denna sida
Un CRM piloté par la conversation
Imagine un CRM où les commerciaux n’ont plus besoin de naviguer dans des interfaces complexes. Ils parlent à un assistant qui crée, met à jour et récupère automatiquement les contacts. C’est exactement ce que l’appel de fonctions te permet de construire. La différence avec le suivi des paiements de la leçon précédente est significative : jusqu’ici, le modèle ne faisait que lire des données. Ici, il écrit des données, ce qui déplace le focus de l’exercice vers la validation, la confirmation et la gestion des doublons.
Tu vas implémenter un CRM conversationnel avec des opérations CRUD (Create, Read, Update, Delete) sur une base de données de contacts.
La base de données simulée
Un dictionnaire Python sert de base de données pour cette démonstration. Deux contacts suffisent : un client et un prospect. Cette configuration nous permet de tester une transition de statut plus tard dans la leçon.
import json
import os
from mistralai.client import Mistral
# Base de données de contacts en mémoire (en production : PostgreSQL, MongoDB, etc.)
contacts_db = {
"CT001": {
"name": "Marie Dupont",
"email": "[email protected]",
"company": "TechCorp",
"role": "Chief Technology Officer",
"phone": "+33 6 12 34 56 78",
"status": "client",
"notes": "Interested in the enterprise solution"
},
"CT002": {
"name": "Pierre Martin",
"email": "[email protected]",
"company": "StartupIO",
"role": "CEO",
"phone": "+33 6 98 76 54 32",
"status": "prospect",
"notes": "Meeting scheduled for April"
}
}
next_id = 3 # Compteur pour les nouveaux contacts
Les fonctions CRUD
get_contact et search_contacts gèrent les opérations de lecture. Cette dernière accepte un argument de champ de recherche pour éviter de créer plusieurs fonctions quasi identiques. create_contact est la première fonction qui modifie l’état du système, et elle illustre une règle souvent négligée dans les modes conversationnels : les vérifications d’unicité doivent résider dans ton code, jamais dans le prompt donné au modèle. Rien n’empêche un commercial de dicter deux fois le même contact ; la vérification de l’e-mail au début de la fonction renvoie duplicate_email avec l’ID existant, permettant au modèle d’expliquer précisément le refus.
update_contact utilise une approche de champs optionnels : seuls les champs fournis sont modifiés, et la fonction renvoie une liste de ce qui a réellement changé. Cette liste n’est pas décorative : elle permet à l’assistant de confirmer la modification par une phrase exacte plutôt que par un vague « fait ».
def get_contact(contact_id: str) -> str:
"""Récupère les informations d'un contact."""
if contact_id in contacts_db:
contact = contacts_db[contact_id].copy()
contact["contact_id"] = contact_id
return json.dumps(contact, ensure_ascii=False)
return json.dumps({"error": f"Contact {contact_id} not found"})
def search_contacts(query: str, field: str = "name") -> str:
"""Recherche des contacts par nom, entreprise ou statut."""
results = []
for cid, contact in contacts_db.items():
if field in contact and query.lower() in contact[field].lower():
entry = contact.copy()
entry["contact_id"] = cid
results.append(entry)
if results:
return json.dumps({"results": results, "count": len(results)},
ensure_ascii=False)
return json.dumps({"results": [], "count": 0,
"message": f"No contact found for '{query}' in '{field}'"})
def create_contact(name: str, email: str, company: str,
role: str = "", phone: str = "",
status: str = "prospect", notes: str = "") -> str:
"""Crée un nouveau contact dans le CRM."""
global next_id
# Vérifie si l'e-mail existe déjà
for cid, contact in contacts_db.items():
if contact["email"].lower() == email.lower():
return json.dumps({
"error": "duplicate_email",
"message": f"A contact with this email already exists: {cid}"
})
contact_id = f"CT{next_id:03d}"
next_id += 1
contacts_db[contact_id] = {
"name": name,
"email": email,
"company": company,
"role": role,
"phone": phone,
"status": status,
"notes": notes
}
return json.dumps({
"success": True,
"contact_id": contact_id,
"message": f"Contact {name} created with ID {contact_id}"
}, ensure_ascii=False)
def update_contact(contact_id: str, **fields) -> str:
"""Met à jour un ou plusieurs champs d'un contact existant."""
if contact_id not in contacts_db:
return json.dumps({"error": f"Contact {contact_id} not found"})
updated_fields = []
for key, value in fields.items():
if key in contacts_db[contact_id]:
contacts_db[contact_id][key] = value
updated_fields.append(key)
if updated_fields:
return json.dumps({
"success": True,
"contact_id": contact_id,
"updated_fields": updated_fields,
"message": f"Contact {contact_id} updated: {', '.join(updated_fields)}"
}, ensure_ascii=False)
return json.dumps({"error": "No valid fields to update"})
Le paramètre ensure_ascii=False présent dans plusieurs retours n’est pas un détail cosmétique : sans lui, « Interested » devient une chaîne de séquences d’échappement Unicode dans le contexte du modèle, ce qui est moins lisible et plus coûteux en tokens.
Spécifications des outils JSON
Deux mécanismes assurent ici l’essentiel de la fiabilité. L’enum sur status empêche le modèle d’inventer des valeurs : il doit choisir parmi prospect, client, partner et inactive, protégeant ainsi l’intégrité de tes données sans validation supplémentaire. Le tableau required fait le reste en distinguant les champs obligatoires des optionnels : pour create_contact, un contact sans nom, e-mail ou entreprise n’a aucun sens, tandis qu’un numéro de téléphone peut attendre.
tools = [
{
"type": "function",
"function": {
"name": "get_contact",
"description": "Retrieves all information for a contact by ID",
"parameters": {
"type": "object",
"properties": {
"contact_id": {
"type": "string",
"description": "Contact ID (e.g., CT001)"
}
},
"required": ["contact_id"]
}
}
},
{
"type": "function",
"function": {
"name": "search_contacts",
"description": "Searches for contacts by name, company, or status",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Search term"
},
"field": {
"type": "string",
"enum": ["name", "company", "status", "role"],
"description": "Field to search in (default: name)"
}
},
"required": ["query"]
}
}
},
{
"type": "function",
"function": {
"name": "create_contact",
"description": "Creates a new contact in the CRM",
"parameters": {
"type": "object",
"properties": {
"name": {
"type": "string",
"description": "Full name of the contact"
},
"email": {
"type": "string",
"description": "Email address of the contact"
},
"company": {
"type": "string",
"description": "Company name"
},
"role": {
"type": "string",
"description": "Job title or function within the company"
},
"phone": {
"type": "string",
"description": "Phone number"
},
"status": {
"type": "string",
"enum": ["prospect", "client", "partner", "inactive"],
"description": "Contact status"
},
"notes": {
"type": "string",
"description": "Free-form notes about the contact"
}
},
"required": ["name", "email", "company"]
}
}
},
{
"type": "function",
"function": {
"name": "update_contact",
"description": "Updates information for an existing contact",
"parameters": {
"type": "object",
"properties": {
"contact_id": {
"type": "string",
"description": "ID of the contact to modify (e.g., CT001)"
},
"name": {"type": "string", "description": "New name"},
"email": {"type": "string", "description": "New email"},
"company": {"type": "string", "description": "New company"},
"role": {"type": "string", "description": "New job title"},
"phone": {"type": "string", "description": "New phone number"},
"status": {
"type": "string",
"enum": ["prospect", "client", "partner", "inactive"],
"description": "New status"
},
"notes": {"type": "string", "description": "New notes"}
},
"required": ["contact_id"]
}
}
}
]
Répartition et boucle
Puisque les fonctions ne dépendent d’aucun objet externe, le dictionnaire de répartition se réduit à une correspondance directe. Le message système, en revanche, porte deux contraintes comportementales absentes du code : confirmer chaque action de création ou de mise à jour avec des détails, et demander les informations manquantes avant de créer un contact. Sans cette seconde instruction, le modèle a tendance à remplir les champs obligatoires avec des valeurs plausibles.
available_functions = {
"get_contact": get_contact,
"search_contacts": search_contacts,
"create_contact": create_contact,
"update_contact": update_contact,
}
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"
messages = [
{
"role": "system",
"content": "You are a CRM assistant. You help sales reps "
"manage their contacts. Respond in English. "
"When you create or modify a contact, confirm "
"the action with details. Request missing "
"information before creating a contact."
}
]
Quatre scénarios et leurs enseignements
Le premier scénario montre le modèle choisissant field="company" de lui-même même si l’utilisateur n’a rien spécifié : l’enum du schéma a fourni les options, et la formulation de la question a fait le reste. Le second fournit des informations en vrac, sans étiquettes, et le modèle les répartit correctement entre nom, e-mail, entreprise et titre. Le troisième est le plus riche : « Passe Pierre Martin en client, il vient de signer » ne contient aucun ID, donc le modèle doit enchaîner une recherche puis une mise à jour, en déduisant la note contextuelle au passage. Le quatrième nous rappelle que le modèle peut détourner une fonction de son usage littéral pour répondre à une question de décompte.
# Scénario 1 : Recherche d'un contact
chat("Find me contacts at TechCorp")
# -> Le modèle appelle search_contacts(query="TechCorp", field="company")
# -> "I found 1 contact at TechCorp: Marie Dupont (CT001),
# Chief Technology Officer, status client."
# Scénario 2 : Création d'un contact
chat("Add a new contact: Sophie Laurent, [email protected], "
"DataViz, Data Scientist")
# -> Le modèle appelle create_contact(name="Sophie Laurent",
# email="[email protected]", company="DataViz", role="Data Scientist")
# -> "Contact created successfully! Sophie Laurent (CT003) has been added
# as a prospect at DataViz."
# Scénario 3 : Mise à jour d'un statut
chat("Switch Pierre Martin to client, he just signed")
# -> Le modèle recherche d'abord Pierre Martin, puis appelle
# update_contact(contact_id="CT002", status="client",
# notes="Contract signed in April 2026")
# -> "Pierre Martin (CT002) is now marked as a client.
# I added a note about the contract signature."
# Scénario 4 : Question sans fonction dédiée
chat("How many prospects do we have?")
# -> Le modèle appelle search_contacts(query="prospect", field="status")
# -> "You currently have 1 prospect: Sophie Laurent at DataViz."
Passer en production sans tout réécrire
Le dictionnaire en mémoire disparaît évidemment dès qu’il y a plusieurs utilisateurs. Le remplacer par une vraie base de données nécessite toutefois de toucher une seule couche : la fonction interroge l’ORM ou l’API de ton CRM et renvoie toujours la même chaîne JSON.
# Les fonctions appellent l'ORM ou l'API de ton CRM
def get_contact_production(contact_id: str) -> str:
"""Version production avec PostgreSQL."""
contact = db.session.query(Contact).filter_by(id=contact_id).first()
if contact:
return json.dumps(contact.to_dict(), ensure_ascii=False)
return json.dumps({"error": f"Contact {contact_id} not found"})
Le reste du code — outils, répartition, boucle de conversation — reste identique. C’est là toute la force de cette architecture : seules les fonctions de logique métier changent, et la couche conversationnelle ignore tes choix de persistance.
Viktiga punkter
- L’appel de fonctions transforme un LLM en une interface naturelle pour un CRM
- Les opérations CRUD se mappent directement sur des fonctions avec un schéma JSON
- Le modèle peut enchaîner une recherche puis une mise à jour au sein d’une même conversation
- L’architecture est découplée : change la base de données sans toucher à la logique de conversation
- Le message système est crucial pour guider le modèle sur les confirmations et les informations manquantes