Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Eksempel: Automatiseret CRM

Lektion 13 af 14 Opdateret 2. november 2026 Udvikler
På denne side
  1. En samtalestyret CRM
  2. Den simulerede database
  3. CRUD-funktionerne
  4. JSON-værktøjsspecifikationer
  5. Dispatch og løkken
  6. Fire scenarier og hvad de lærer os
  7. Overgang til produktion uden at skulle omskrive alt
  8. Vigtige pointer

En samtalestyret CRM

Forestil dig en CRM, hvor sælgere ikke længere behøver at navigere i komplekse grænseflader. De taler med en assistent, der automatisk opretter, opdaterer og henter kontakter. Det er præcis det, function calling gør det muligt for dig at bygge. Forskellen fra betalingsmodulet i den forrige lektion er markant: Indtil nu har modellen kun læst data. Her skriver den data, hvilket flytter fokus i øvelsen mod validering, bekræftelse og håndtering af dubletter.

Du vil implementere en samtalebaseret CRM med CRUD-operationer (Create, Read, Update, Delete) på en kontaktdatabase.

Den simulerede database

Et Python-ordbog fungerer som database til denne demonstration. To kontakter er nok: én kunde og én potentiel kunde (prospect). Denne opsætning giver os mulighed for senere i lektionen at teste en statusovergang.

import json
import os
from mistralai.client import Mistral

# In-memory kontaktdatabase (i produktion: PostgreSQL, MongoDB osv.)
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  # Tæller for nye kontakter

CRUD-funktionerne

get_contact og search_contacts håndterer læseoperationer. Sidstnævnte accepterer et søgefelt-argument for at undgå at oprette flere næsten identiske funktioner. create_contact er den første funktion, der ændrer systemtilstanden, og den illustrerer en regel, der ofte overses i samtalemodi: Tjek af unikitet skal ligge i din kode, aldrig i prompten til modellen. Intet forhindrer en sælger i at diktere den samme kontakt to gange; e-mail-verifikationen i starten af funktionen returnerer duplicate_email med det eksisterende ID, hvilket giver modellen mulighed for præcist at forklare afvisningen.

update_contact bruger en tilgang med valgfrie felter: Kun angivne felter modificeres, og funktionen returnerer en liste over det, der faktisk er ændret. Denne liste er ikke blot dekorativ – den gør det muligt for assistenten at bekræfte ændringen med en præcis sætning i stedet for et vagt „udført”.

def get_contact(contact_id: str) -> str:
    """Henter informationer for en kontakt."""
    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:
    """Søger efter kontakter efter navn, virksomhed eller 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:
    """Opretter en ny kontakt i CRM'en."""
    global next_id

    # Tjek om e-mail allerede eksisterer
    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:
    """Opdaterer et eller flere felter for en eksisterende kontakt."""
    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"})

Parameteren ensure_ascii=False, der forekommer i flere return-værdier, er ikke en kosmetisk detalje: Uden den bliver „Interested” til en streng af Unicode-escape-sekvenser i modellens kontekst, hvilket er mindre læseligt og dyrere i tokens.

JSON-værktøjsspecifikationer

To mekanismer bærer hovedparten af pålideligheden her. enum på status forhindrer modellen i at opfinde værdier: Den skal vælge mellem prospect, client, partner og inactive, hvilket beskytter dine dataintegritet uden yderligere validering. required-arrayet gør resten ved at skelne mellem obligatoriske og valgfrie felter – for create_contact giver en kontakt uden navn, e-mail eller virksomhed ingen mening, mens et telefonnummer kan komme senere.

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 og løkken

Da funktionerne ikke afhænger af eksterne objekter, reduceres dispatch-ordbogen til en direkte mapping. Systembeskeden indeholder derimod to adfærdsmæssige begrænsninger, som ikke findes i koden: Bekræft hver oprettelses- eller opdateringshandling med detaljer, og anmod om manglende information, før du opretter en kontakt. Uden den anden instruktion har modellen tendens til at udfylde obligatoriske felter med plausible værdier.

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

Fire scenarier og hvad de lærer os

Det første scenarie viser, hvordan modellen selv vælger field="company", selvom brugeren ikke specificerede noget: Skemaets enum leverede mulighederne, og spørgsmålets formulering gjorde resten. Det andet giver information i en rodet rækkefølge uden labels, og modellen fordeler dem korrekt blandt navn, e-mail, virksomhed og titel. Det tredje er det rigeste: „Switch Pierre Martin to client” indeholder intet ID, så modellen skal kæde en søgning sammen med en opdatering og samtidig udlede den kontekstuelle note undervejs. Det fjerde minder os om, at modellen kan genbruge en funktion fra dens bogstavelige brug til at besvare et tællespørgsmål.

# Scenarie 1: Søg efter en kontakt
chat("Find me contacts at TechCorp")
# -> Modellen kalder search_contacts(query="TechCorp", field="company")
# -> "I found 1 contact at TechCorp: Marie Dupont (CT001),
#     Chief Technology Officer, status client."

# Scenarie 2: Opret en kontakt
chat("Add a new contact: Sophie Laurent, [email protected], "
     "DataViz, Data Scientist")
# -> Modellen kalder 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."

# Scenarie 3: Opdater en status
chat("Switch Pierre Martin to client, he just signed")
# -> Modellen søger først efter Pierre Martin og kalder derefter
#    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."

# Scenarie 4: Spørgsmål uden en dedikeret funktion
chat("How many prospects do we have?")
# -> Modellen kalder search_contacts(query="prospect", field="status")
# -> "You currently have 1 prospect: Sophie Laurent at DataViz."

Overgang til produktion uden at skulle omskrive alt

Ordbogen i hukommelsen forsvinder naturligvis, så snart der er flere brugere. At erstatte den med en rigtig database kræver dog kun, at man rører ved ét lag: Funktionen spørger din CRM’s ORM eller API og returnerer stadig den samme JSON-streng.

# Funktioner kalder din CRM's ORM eller API
def get_contact_production(contact_id: str) -> str:
    """Produktionsversion med 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"})

Resten af koden – værktøjer, dispatch, samtaleløkke – forbliver identisk. Det er styrken ved denne arkitektur: Kun forretningslogik-funktionerne ændres, og samtalelaget forbliver uvidende om dine valg af persistens.

Vigtige pointer

  • Function calling gør en LLM til en naturlig grænseflade for en CRM
  • CRUD-operationer mapper direkte til funktioner med JSON Schema
  • Modellen kan kæde søgning og derefter opdatering inden for én samtale
  • Arkitekturen er afkoblet: Skift databasen uden at røre ved samtalelogikken
  • Systembeskeden er afgørende for at vejlede modellen om bekræftelser og manglende information