Salt la conținutul principal
Română— Alege o limbă
Meniu

Exemplu practic: CRM automatizat

Lecția 13 din 14 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Un CRM condus de conversație
  2. Baza de date simulată
  3. Funcțiile CRUD
  4. Specificațiile instrumentelor JSON
  5. Distribuirea și bucla
  6. Patru scenarii și ce ne învață ele
  7. Trecerea la producție fără a rescrie totul
  8. Puncte cheie

Un CRM condus de conversație

Imaginați-vă un CRM în care reprezentanții de vânzări nu mai trebuie să navigheze prin interfețe complexe. Ei vorbesc cu un asistent care creează, actualizează și recuperează automat contactele. Exact asta vă permite să construiți apelul de funcții (function calling). Diferența față de tracker-ul de plăți din lecția anterioară este semnificativă: până acum, modelul doar citea date. Aici, el scrie date, ceea ce mută accentul exercițiului către validare, confirmare și gestionarea duplicatelor.

Veți implementa un CRM conversațional cu operațiuni CRUD (Create, Read, Update, Delete) asupra unei baze de date de contacte.

Baza de date simulată

Un dicționar Python servește drept bază de date pentru această demonstrație. Două contacte sunt suficiente: un client și un prospect. Această configurare ne permite să testăm mai târziu în lecție o tranziție de statut.

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

Funcțiile CRUD

get_contact și search_contacts gestionează operațiunile de citire. Aceasta din urmă acceptă un argument pentru câmpul de căutare pentru a evita crearea mai multor funcții aproape identice. create_contact este prima funcție care modifică starea sistemului și ilustrează o regulă adesea neglijată în modurile conversaționale: verificările de unicitate trebuie să existe în codul dumneavoastră, niciodată în prompt-ul dat modelului. Nimic nu împiedică un reprezentant de vânzări să dicteze același contact de două ori; verificarea e-mailului la începutul funcției returnează duplicate_email cu ID-ul existent, permițând modelului să explice refuzul cu precizie.

update_contact utilizează o abordare cu câmpuri opționale: doar câmpurile furnizate sunt modificate, iar funcția returnează o listă a ceea ce s-a schimbat efectiv. Această listă nu este decorativă – ea permite asistentului să confirme modificarea cu o propoziție exactă, în loc de un vag „gata“.

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"})

Parametrul ensure_ascii=False prezent în mai multe returnări nu este un detaliu cosmetic: fără el, „Interested“ devine un șir de secvențe de escape Unicode în contextul modelului, ceea ce este mai puțin lizibil și mai costisitor în tokeni.

Specificațiile instrumentelor JSON

Două mecanisme asigură aici cea mai mare parte a fiabilității. enum pentru status împiedică modelul să inventeze valori: trebuie să aleagă între prospect, client, partner și inactive, protejând integritatea datelor dumneavoastră fără validare suplimentară. Tabloul required face restul, distingând câmpurile obligatorii de cele opționale – pentru create_contact, un contact fără nume, e-mail sau companie nu are sens, în timp ce un număr de telefon poate fi adăugat ulterior.

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"]
            }
        }
    }
]

Distribuirea și bucla

Deoarece funcțiile nu depind de obiecte externe, dicționarul de distribuire se reduce la o mapare directă. Mesajul de sistem, totuși, conține două constrângeri comportamentale absente din cod: confirmați fiecare acțiune de creare sau actualizare cu detalii și solicitați informațiile lipsă înainte de a crea un contact. Fără această a doua instrucțiune, modelul tinde să completeze câmpurile obligatorii cu valori plauzibile.

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."
    }
]

Patru scenarii și ce ne învață ele

Primul scenariu arată modelul alegând field="company" de unul singur, chiar dacă utilizatorul nu a specificat nimic: enum-ul schemei a furnizat opțiunile, iar formularea întrebării a făcut restul. Al doilea furnizează informații într-o dezordine, fără etichete, iar modelul le distribuie corect între nume, e-mail, companie și titlu. Al treilea este cel mai bogat: „Transformă-l pe Pierre Martin în client“ nu conține niciun ID, așa că modelul trebuie să lanseze o căutare și apoi o actualizare, inferând nota contextuală pe parcurs. Al patrulea ne reamintește că modelul poate repurpura o funcție din utilizarea sa literală pentru a răspunde la o întrebare de numărare.

# 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."

Trecerea la producție fără a rescrie totul

Dicționarul în memorie dispare evident imediat ce există mai mulți utilizatori. Înlocuirea acestuia cu o bază de date reală necesită însă atingerea unui singur strat: funcția interoghează ORM-ul sau API-ul CRM-ului dumneavoastră și returnează tot același șir 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"})

Restul codului – instrumente, distribuire, buclă de conversație – rămâne identic. Aceasta este forța acestei arhitecturi: doar funcțiile de logică de afaceri se schimbă, iar stratul conversațional rămâne inconștient de alegerile dumneavoastră de persistență.

Puncte cheie

  • Apelul de funcții transformă un LLM într-o interfață naturală pentru un CRM
  • Operațiunile CRUD se map direct pe funcții cu JSON Schema
  • Modelul poate lanșa o căutare și apoi o actualizare într-o singură conversație
  • Arhitectura este decuplată: schimbați baza de date fără a atinge logica de conversație
  • Mesajul de sistem este crucial pentru a ghida modelul privind confirmările și informațiile lipsă