Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Beispiel: Automatisierter CRM

Lektion 13 von 14 Aktualisiert am 2. November 2026 Entwickler
Auf dieser Seite
  1. Ein CRM, das von Gesprächen gesteuert wird
  2. Die simulierte Datenbank
  3. Die CRUD-Funktionen
  4. JSON-Werkzeugspezifikationen
  5. Dispatch und der Schleifenlauf
  6. Vier Szenarien und ihre Lehren
  7. In die Produktion übergehen, ohne alles neu zu schreiben
  8. Kernaussagen

Ein CRM, das von Gesprächen gesteuert wird

Stellen Sie sich ein CRM vor, in dem Vertriebsmitarbeiter keine komplexen Oberflächen mehr durchnavigieren müssen. Sie sprechen mit einem Assistenten, der Kontakte automatisch erstellt, aktualisiert und abruft. Genau das können Sie mit Funktionsaufrufen (function calling) bauen. Der Unterschied zum Zahlungsverfolgungs-Tracker der vorherigen Lektion ist erheblich: Bisher konnte das Modell nur Daten lesen. Hier schreibt es Daten, was den Fokus der Übung auf Validierung, Bestätigung und die Verwaltung von Duplikaten verlagert.

Sie implementieren ein konversationelles CRM mit CRUD-Operationen (Erstellen, Lesen, Aktualisieren, Löschen) auf einer Kontakt-Datenbank.

Die simulierte Datenbank

Ein Python-Dict dient als Datenbank für diese Demonstration. Zwei Kontakte reichen aus: ein Kunde und ein Interessent. Diese Einrichtung ermöglicht es uns, später in der Lektion einen Statuswechsel zu testen.

import json
import os
from mistralai.client import Mistral

# In-Memory-Kontakt-Datenbank (in der Produktion: PostgreSQL, MongoDB usw.)
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  # Zähler für neue Kontakte

Die CRUD-Funktionen

get_contact und search_contacts übernehmen die Leseoperationen. Letztere akzeptiert ein Argument für das Suchfeld, um das Erstellen mehrerer fast identischer Funktionen zu vermeiden. create_contact ist die erste Funktion, die den Systemzustand ändert, und sie illustriert eine Regel, die im konversationellen Modus oft übersehen wird: Uniquitätsprüfungen müssen im Code leben, niemals im Prompt, der dem Modell gegeben wird. Nichts hindert einen Vertriebsmitarbeiter daran, denselben Kontakt zweimal zu diktieren; die E-Mail-Verifikation am Anfang der Funktion gibt duplicate_email mit der bestehenden ID zurück, sodass das Modell die Ablehnung präzise erklären kann.

update_contact verwendet einen optionalen Feld-Ansatz: Nur bereitgestellte Felder werden geändert, und die Funktion gibt eine Liste zurück, was tatsächlich geändert wurde. Diese Liste ist nicht dekorativ – sie ermöglicht es dem Assistenten, die Änderung mit einem exakten Satz zu bestätigen, anstatt einer vagen „Fertig”-Mitteilung.

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

Der Parameter ensure_ascii=False, der in mehreren Rückgaben vorhanden ist, ist kein kosmetisches Detail: Ohne ihn wird „Interested” in den Kontext des Modells zu einer Reihe von Unicode-Escape-Sequenzen, was weniger lesbar und teurer in Tokens ist.

JSON-Werkzeugspezifikationen

Zwei Mechanismen tragen hier den Großteil der Zuverlässigkeit. Das enum für status verhindert, dass das Modell Werte erfindet: Es muss sich zwischen prospect, client, partner und inactive entscheiden, wodurch die Datenintegrität ohne zusätzliche Validierung geschützt wird. Das required-Array übernimmt den Rest, indem es zwischen Pflicht- und Optionalfeldern unterscheidet – für create_contact macht ein Kontakt ohne Namen, E-Mail oder Firma keinen Sinn, während eine Telefonnummer später kommen kann.

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 und der Schleifenlauf

Da die Funktionen keine externen Objekte benötigen, reduziert sich das Dispatch-Dictionary auf eine direkte Zuordnung. Die Systemnachricht trägt jedoch zwei Verhaltensbeschränkungen, die im Code nicht vorhanden sind: Bestätigen Sie jede Erstellungs- oder Aktualisierungsaktion mit Details und fordern Sie fehlende Informationen an, bevor Sie einen Kontakt erstellen. Ohne diese zweite Anweisung neigt das Modell dazu, Pflichtfelder mit plausiblen Werten zu füllen.

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

Vier Szenarien und ihre Lehren

Das erste Szenario zeigt, wie das Modell field="company" eigenständig auswählt, obwohl der Benutzer nichts angegeben hat: Das Schema-enum lieferte die Optionen, und die Formulierung der Frage erledigte den Rest. Das zweite Szenario liefert Informationen in einem Durcheinander ohne Labels, und das Modell verteilt sie korrekt unter Name, E-Mail, Firma und Titel. Das dritte Szenario ist das reichhaltigste: „Switch Pierre Martin to client” enthält keine ID, sodass das Modell eine Suche und dann eine Aktualisierung verketten muss und dabei die kontextuelle Notiz ableitet. Das vierte Szenario erinnert uns daran, dass das Modell eine Funktion von ihrem wörtlichen Gebrauch hernehmen kann, um eine Zählungsfrage zu beantworten.

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

In die Produktion übergehen, ohne alles neu zu schreiben

Das in-Memory-Dictionary verschwindet offensichtlich, sobald es mehrere Benutzer gibt. Der Ersatz durch eine echte Datenbank erfordert jedoch nur die Änderung einer Ebene: Die Funktion fragt die ORM oder API Ihres CRMs ab und gibt immer noch dieselbe JSON-String zurück.

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

Der Rest des Codes – Werkzeuge, Dispatch, Gesprächsschleife – bleibt identisch. Das ist die Stärke dieser Architektur: Nur die Geschäftslogik-Funktionen ändern sich, und die konversationelle Ebene bleibt unabhängig von Ihren Persistenzentscheidungen.

Kernaussagen

  • Funktionsaufrufe verwandeln ein LLM in eine natürliche Schnittstelle für ein CRM
  • CRUD-Operationen entsprechen direkt Funktionen mit JSON-Schema
  • Das Modell kann ketten Suche und Aktualisierung innerhalb eines einzigen Gesprächs
  • Die Architektur ist entkoppelt: Ändern Sie die Datenbank, ohne die Gesprächslogik zu berühren
  • Die Systemnachricht ist entscheidend, um das Modell bei Bestätigungen und fehlenden Informationen zu führen