Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Exemple concret : CRM automatisé

Õppetund 13 / 14 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Un CRM piloté par la conversation
  2. La base de données simulée
  3. Les fonctions CRUD
  4. Spécifications des outils JSON
  5. Dispatch et boucle
  6. Quatre scénarios et leurs enseignements
  7. Passer en production sans tout réécrire
  8. Peamised punktid

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

# In-memory contact database (in 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  # Counter for new 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’email 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:
    """Retrieves information for a 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:
    """Searches for contacts by name, company, or status."""
    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:
    """Creates a new contact in the CRM."""
    global next_id

    # Check if email already exists
    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:
    """Updates one or more fields of an existing contact."""
    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, email 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"]
            }
        }
    }
]

Dispatch et boucle

Puisque les fonctions ne dépendent d’aucun objet externe, le dictionnaire de dispatch se réduit à un mappage direct. 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 alors que 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, email, 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 inférant 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.

# Scenario 1: Search for a contact
chat("Find me contacts at TechCorp")
# -> The model calls search_contacts(query="TechCorp", field="company")
# -> "I found 1 contact at TechCorp: Marie Dupont (CT001),
#     Chief Technology Officer, status client."

# Scenario 2: Create a contact
chat("Add a new contact: Sophie Laurent, [email protected], "
     "DataViz, Data Scientist")
# -> The model calls 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."

# Scenario 3: Update a status
chat("Switch Pierre Martin to client, he just signed")
# -> The model first searches for Pierre Martin, then calls
#    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."

# Scenario 4: Question without a dedicated function
chat("How many prospects do we have?")
# -> The model calls 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 cependant 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.

# Functions call your CRM's ORM or API
def get_contact_production(contact_id: str) -> str:
    """Production version with 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, dispatch, 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.

Peamised punktid

  • 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