AI Agents · Lektion

Kundenkontext und -historie verwalten

Personalisierte Antworten auf Grundlage früherer Käufe, Tickets und Präferenzen erstellen.

Kundenkontext und -historie verwalten ist eine kostenlose AI Agents-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Agents-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.

Warum Kontext Agenten menschlich wirken lässt

Der Unterschied zwischen einem mittelmäßigen und einem hervorragenden Kundenservice-Agenten liegt im Kontext. Wenn ein Agent sagt: „Ich sehe, dass Ihr Abonnement nächste Woche verlängert wird — möchten Sie es vorher pausieren?“, fühlt sich der Kunde verstanden und nicht bloß abgefertigt.

Diese Lektion behandelt den Aufbau einer umfassenden Kundenkontextschicht für Ihre Agenten.

Schema des Kundenprofils

Definieren Sie ein standardisiertes Kundenprofil, das Daten aus mehreren Quellen zusammenführt. Der Agent erhält dieses Dict zu Beginn jedes Gesprächs.

from dataclasses import dataclass, field
from datetime import date

@dataclass
class CustomerProfile:
    customer_id: str
    name: str
    email: str
    join_date: date
    subscription_tier: str          # 'free', 'pro', 'enterprise'
    account_age_days: int
    lifetime_value_usd: float
    previous_tickets: list[dict] = field(default_factory=list)
    recent_purchases: list[dict]  = field(default_factory=list)
    preferences: dict             = field(default_factory=dict)

    @property
    def is_long_term_customer(self) -> bool:
        return self.account_age_days > 365

if __name__ == '__main__':
    from datetime import date
    profile = CustomerProfile(
        customer_id='cust_1', name='Jane Doe', email='jane@example.com',
        join_date=date(2023, 1, 15), subscription_tier='pro',
        account_age_days=400, lifetime_value_usd=1250.50,
    )
    print(f'{profile.name} ({profile.subscription_tier}) - long-term customer: {profile.is_long_term_customer}')

Kaufhistorie abrufen

Rufen Sie die letzten N Bestellungen aus Ihrem E-Commerce-Backend ab. Schließen Sie Bestelldatum, Artikel, Gesamtbetrag und Status ein. So weiß der Agent, was der Kunde gekauft hat und ob bei kürzlich aufgegebenen Bestellungen Probleme aufgetreten sind.

import requests

SHOP_API = 'https://api.yourshop.com'
SHOP_KEY  = 'YOUR_SHOP_API_KEY'

def get_purchase_history(customer_id: str, limit: int = 10) -> list[dict]:
    resp = requests.get(
        f'{SHOP_API}/customers/{customer_id}/orders',
        headers={'Authorization': f'Bearer {SHOP_KEY}'},
        params={'limit': limit, 'sort': '-created_at'}
    )
    resp.raise_for_status()
    orders = resp.json()['orders']
    return [
        {
            'order_id':   o['id'],
            'date':       o['created_at'][:10],
            'total_usd':  o['total'],
            'status':     o['status'],
            'items':      [i['name'] for i in o['line_items']]
        }
        for o in orders
    ]

Frühere Support-Tickets abrufen

Rufen Sie die letzten N Support-Tickets ab, um wiederkehrende Probleme zu erkennen. Wenn dasselbe Problem des Kunden bereits dreimal gelöst wurde, handelt es sich um ein Produktproblem – eskalieren Sie es und markieren Sie es entsprechend.

def get_support_history(customer_id: str, limit: int = 5) -> list[dict]:
    resp = requests.get(
        f'{SHOP_API}/customers/{customer_id}/tickets',
        headers={'Authorization': f'Bearer {SHOP_KEY}'},
        params={'limit': limit, 'sort': '-created_at'}
    )
    resp.raise_for_status()
    tickets = resp.json()['tickets']
    return [
        {
            'ticket_id': t['id'],
            'subject':   t['subject'],
            'status':    t['status'],
            'resolved':  t.get('resolved_at', ''),
            'category':  t.get('category', 'general')
        }
        for t in tickets
    ]

def has_recurring_issue(tickets: list[dict], category: str) -> bool:
    return sum(1 for t in tickets if t['category'] == category) >= 3

Abonnementstufe und -status auslesen

Die Abonnementstufe bestimmt, worauf der Kunde Anspruch hat. Ein Pro-Kunde, der nach einer in seinem Tarif nicht verfügbaren Funktion fragt, benötigt eine andere Antwort als ein Enterprise-Kunde mit derselben Frage.

def get_subscription_info(customer_id: str) -> dict:
    resp = requests.get(
        f'{SHOP_API}/customers/{customer_id}/subscription',
        headers={'Authorization': f'Bearer {SHOP_KEY}'}
    )
    if resp.status_code == 404:
        return {'tier': 'free', 'status': 'active', 'renewal_date': None}
    resp.raise_for_status()
    sub = resp.json()
    return {
        'tier':         sub['plan'],
        'status':       sub['status'],        # active / past_due / canceled
        'renewal_date': sub.get('current_period_end', '')[:10],
        'cancel_at':    sub.get('cancel_at_period_end', False)
    }

Kontoalter berechnen

Das Kontoalter gibt Aufschluss über die Kundentreue. Ein Kunde, der seit 2021 bei Ihnen ist, sollte anders behandelt werden als jemand, der sich gestern registriert hat. Erwähnen Sie die bisherige Kundendauer, wenn es passend ist, um eine persönliche Beziehung aufzubauen.

from datetime import datetime, timezone

def calculate_account_age(join_date_str: str) -> dict:
    join = datetime.fromisoformat(join_date_str.replace('Z', '+00:00'))
    now  = datetime.now(timezone.utc)
    delta = now - join
    years  = delta.days // 365
    months = (delta.days % 365) // 30
    return {
        'days':   delta.days,
        'years':  years,
        'months': months,
        'label':  f'{years} year(s) and {months} month(s)' if years else f'{months} month(s)'
    }

age = calculate_account_age('2021-03-15T00:00:00Z')
print(age['label'])  # e.g. '5 year(s) and 2 month(s)'

Kontext-String für das LLM erstellen

Wandeln Sie das Kundenprofil in einen kompakten Kontextblock um, der in den System-Prompt eingefügt wird. Halten Sie ihn kurz – nehmen Sie nur Fakten auf, die für die aktuelle Sitzung direkt relevant sind.

def build_context_block(profile: CustomerProfile) -> str:
    recent_order = profile.recent_purchases[0] if profile.recent_purchases else None
    last_ticket  = profile.previous_tickets[0]  if profile.previous_tickets  else None
    parts = [
        f'Customer: {profile.name} ({profile.email})',
        f'Account age: {profile.account_age_days} days | Tier: {profile.subscription_tier}',
        f'Lifetime value: USD {profile.lifetime_value_usd:.0f}',
    ]
    if recent_order:
        parts.append(
            f'Last order: {recent_order["date"]} — '
            f'{', '.join(recent_order["items"][:2])} ({recent_order["status"]})'
        )
    if last_ticket:
        parts.append(f'Last ticket: "{last_ticket["subject"]}" ({last_ticket["status"]})')
    return '\n'.join(parts)

Antworten mit Kontext personalisieren

Fügen Sie den Kontextblock in den System-Prompt ein, damit das LLM in seinen Antworten ganz natürlich darauf Bezug nimmt, ohne ausdrücklich dazu aufgefordert zu werden.

import openai

client = openai.OpenAI(api_key='YOUR_OPENAI_KEY')

def respond_with_context(user_message: str, profile: CustomerProfile) -> str:
    context = build_context_block(profile)
    system_prompt = (
        f'You are a helpful customer service agent for ShopCo.\n'
        f'Customer context:\n{context}\n\n'
        f'Be warm and personal. Reference their history when relevant. '
        f'Address the customer by first name.'
    )
    resp = client.chat.completions.create(
        model='gpt-4o',
        messages=[
            {'role': 'system', 'content': system_prompt},
            {'role': 'user',   'content': user_message}
        ]
    )
    return resp.choices[0].message.content

Kundenkontext zwischenspeichern

Profildaten bei jeder Nachricht aus mehreren APIs abzurufen, ist langsam und teuer. Zwischenspeichern Sie das Profil zu Beginn der Unterhaltung und aktualisieren Sie nur die Felder, die sich ändern können, etwa Bestellstatus und Ticketstatus.

import time

profile_cache: dict[str, dict] = {}  # customer_id -> {profile, fetched_at}
CACHE_TTL = 300  # 5 minutes

def get_cached_profile(customer_id: str) -> CustomerProfile | None:
    entry = profile_cache.get(customer_id)
    if entry and time.time() - entry['fetched_at'] < CACHE_TTL:
        return entry['profile']
    return None

def set_cached_profile(customer_id: str, profile: CustomerProfile):
    profile_cache[customer_id] = {
        'profile': profile,
        'fetched_at': time.time()
    }

Sensible Situationen anhand der Historie erkennen

Die Historie kann Muster offenlegen, die eine besondere Behandlung erfordern: ein Kunde, dessen letzte drei Bestellungen mangelhaft waren, jemand, der letzten Monat mit einer Kündigung gedroht hat, oder ein Nutzer, der seit sieben Jahren bei Ihnen ist.

def assess_risk_flags(profile: CustomerProfile) -> list[str]:
    flags = []

    # Check for cancellation risk
    cancel_keywords = ['cancel', 'unsubscribe', 'quit', 'competitor']
    for ticket in profile.previous_tickets:
        if any(kw in ticket.get('subject', '').lower() for kw in cancel_keywords):
            flags.append('cancellation_risk')
            break

    # Defective product pattern
    defective = sum(1 for o in profile.recent_purchases if o.get('status') == 'refunded')
    if defective >= 2:
        flags.append('product_quality_issue')

    # High-value customer
    if profile.lifetime_value_usd > 5000:
        flags.append('high_value_customer')

    return flags

Vollständige Pipeline zum Zusammenstellen des Kontexts

Führen Sie alle Datenquellen in einer einzigen Funktion assemble_context() zusammen, die einmal zu Beginn der Unterhaltung aufgerufen wird.

from datetime import date

def assemble_context(email: str) -> CustomerProfile:
    # Try cache first
    # In production: look up customer_id from email in your user DB
    customer_id = 'CUST_123'

    cached = get_cached_profile(customer_id)
    if cached:
        return cached

    # Fetch from all sources
    sub    = get_subscription_info(customer_id)
    orders = get_purchase_history(customer_id)
    tickets = get_support_history(customer_id)

    profile = CustomerProfile(
        customer_id=customer_id,
        name='Alice Smith',
        email=email,
        join_date=date(2021, 3, 15),
        subscription_tier=sub['tier'],
        account_age_days=calculate_account_age('2021-03-15T00:00:00Z')['days'],
        lifetime_value_usd=1240.00,
        previous_tickets=tickets,
        recent_purchases=orders
    )
    set_cached_profile(customer_id, profile)
    return profile

Welcher Teil des Kundenkontexts ermöglicht es dem Agenten am direktesten zu sagen: „Ich sehe, dass Sie seit 2021 bei uns sind“?

Um Antworten zu personalisieren, müssen bestimmte Datenpunkte aus dem Kundenprofil herangezogen werden. Zu erkennen, welches Feld diese Aussage ermöglicht, ist eine praktische Frage zum Erinnern und Abrufen von Wissen.

Zusammenfassung des Kundenkontexts

Ein hervorragender Kundenservice-Agent erstellt ein umfassendes Profil aus Kaufhistorie, Support-Tickets, Abonnementstufe und Kontoalter. Fügen Sie einen kompakten Kontextblock in den System-Prompt ein, speichern Sie ihn für die Sitzung zwischen und verwenden Sie Risikoflags, um sensible Situationen zu erkennen, bevor sie eskalieren.

Häufig gestellte Fragen

Ist die Lektion „Kundenkontext und -historie verwalten“ kostenlos?

Ja — der vollständige Text von „Kundenkontext und -historie verwalten“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Agents-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Kundenkontext und -historie verwalten“?

Personalisierte Antworten auf Grundlage früherer Käufe, Tickets und Präferenzen erstellen. Du übst AI Agents mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Agents zu starten?

Keine Vorkenntnisse erforderlich. AI Agents auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Kundenkontext und -historie verwalten“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Agents-Lektion Code schreiben und ausführen?

Ja. Jede AI Agents-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu AI Agents