0Pricing
AI Agents · Lekcja

Kierowanie zgłoszeń i logika eskalacji

Klasyfikowanie intencji, kierowanie do wyspecjalizowanych agentów i wyzwalacze eskalacji.

Kierowanie zgłoszeń i logika eskalacji to bezpłatna lekcja AI Agents na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Agents, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Agents zawiera 4 lekcji w sumie.

Problem kierowania zgłoszeń

Agent obsługi klienta codziennie otrzymuje tysiące różnorodnych wiadomości: spory dotyczące płatności, resetowania haseł, wad produktów, opóźnień w dostawie oraz próśb o nowe funkcje. Wysyłanie każdej wiadomości do tego samego modułu prowadzi do powolnych odpowiedzi niskiej jakości.

Kierowanie zgłoszeń polega na klasyfikowaniu każdej wiadomości i wysyłaniu jej do zespołu najlepiej przygotowanego do rozwiązania danego problemu.

Klasyfikacja intencji za pomocą LLM

Warstwa kierowania wywołuje LLM z użyciem promptu klasyfikacyjnego. Model zwraca ustrukturyzowaną odpowiedź zawierającą etykietę intent oraz wynik confidence.

import openai, json

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

INTENTS = ['billing', 'technical_support', 'returns_refunds',
           'account_access', 'shipping', 'general_inquiry']

def classify_intent(message: str) -> dict:
    prompt = (
        f'Classify this customer message into exactly one intent.\n'
        f'Intents: {INTENTS}\n'
        f'Message: "{message}"\n'
        f'Respond with JSON: {{"intent": "...", "confidence": 0.0-1.0}}'
    )
    resp = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}],
        response_format={'type': 'json_object'}
    )
    return json.loads(resp.choices[0].message.content)

Kierowanie do kolejek specjalistycznych

Po ustaleniu intencji należy skierować zgłoszenie do odpowiedniej kolejki specjalistycznej. Każda kolejka ma własne szablony odpowiedzi, umowy SLA oraz reguły eskalacji.

ROUTING_MAP = {
    'billing':           'queue_billing',
    'technical_support': 'queue_tech',
    'returns_refunds':   'queue_returns',
    'account_access':    'queue_tech',
    'shipping':          'queue_fulfillment',
    'general_inquiry':   'queue_general'
}

def route_ticket(ticket: dict) -> str:
    result = classify_intent(ticket['message'])
    intent = result['intent']
    confidence = result['confidence']
    queue = ROUTING_MAP.get(intent, 'queue_general')
    ticket['intent'] = intent
    ticket['confidence'] = confidence
    ticket['queue'] = queue
    return queue

Próg pewności uruchamiający eskalację

Jeśli klasyfikator jest niepewny (wartość confidence poniżej 0,7), automatyczne kierowanie może być błędne. Zgłoszenia o niskim poziomie pewności należy przekazywać człowiekowi do ręcznej analizy zamiast automatycznie kierować je do specjalisty.

CONFIDENCE_THRESHOLD = 0.70

def route_with_escalation(ticket: dict) -> dict:
    result = classify_intent(ticket['message'])
    intent = result['intent']
    confidence = result['confidence']

    if confidence < CONFIDENCE_THRESHOLD:
        return {
            'ticket_id': ticket['id'],
            'action': 'escalate_to_human',
            'reason': f'Low confidence: {confidence:.2f}',
            'suggested_intent': intent
        }

    queue = ROUTING_MAP.get(intent, 'queue_general')
    return {
        'ticket_id': ticket['id'],
        'action': 'route_to_queue',
        'queue': queue,
        'intent': intent,
        'confidence': confidence
    }

Eskalacja priorytetu na podstawie SLA

Nawet automatycznie skierowane zgłoszenia mogą naruszyć SLA, jeśli nie zostaną rozwiązane na czas. Zadanie działające w tle sprawdza wiek zgłoszeń względem celów SLA i przekazuje przeterminowane zgłoszenia do kolejki przełożonego.

from datetime import datetime, timezone

SLA_HOURS = {
    'queue_billing':      4,
    'queue_tech':         8,
    'queue_returns':      24,
    'queue_fulfillment':  12,
    'queue_general':      48
}

def check_sla_breach(ticket: dict) -> bool:
    created = datetime.fromisoformat(ticket['created_at'])
    age_hours = (datetime.now(timezone.utc) - created).total_seconds() / 3600
    sla = SLA_HOURS.get(ticket['queue'], 24)
    if age_hours > sla and ticket['status'] == 'open':
        ticket['queue'] = 'queue_supervisor_escalation'
        ticket['escalation_reason'] = f'SLA breach: {age_hours:.1f}h > {sla}h'
        return True
    return False

if __name__ == '__main__':
    from datetime import datetime, timedelta, timezone
    old_ticket = {
        'created_at': (datetime.now(timezone.utc) - timedelta(hours=10)).isoformat(),
        'queue': 'queue_billing',
        'status': 'open',
    }
    breached = check_sla_breach(old_ticket)
    print(f'SLA breached: {breached}')
    if breached:
        print('Escalation reason:', old_ticket['escalation_reason'])

Kierowanie z wieloma etykietami dla złożonych zgłoszeń

Niektóre wiadomości dotyczą wielu obszarów: „Moje zamówienie dotarło uszkodzone, a ponadto obciążono mnie podwójną opłatą”. Klasyfikator wieloetykietowy zwraca wiele intencji; zgłoszenie jest duplikowane i trafia do obu kolejek, a agenci współpracują nad jego rozwiązaniem.

def classify_multi_intent(message: str) -> list[dict]:
    prompt = (
        f'A customer message may have multiple intents.\n'
        f'Intents: {INTENTS}\n'
        f'Message: "{message}"\n'
        f'Return JSON array: [{{"intent": "...", "confidence": 0.0}}]\n'
        f'Include only intents with confidence > 0.5'
    )
    resp = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}],
        response_format={'type': 'json_object'}
    )
    data = json.loads(resp.choices[0].message.content)
    return data.get('intents', [])

# Route to multiple queues
def route_multi(ticket: dict) -> list[str]:
    intents = classify_multi_intent(ticket['message'])
    return [ROUTING_MAP.get(i['intent'], 'queue_general') for i in intents]

Wyodrębnianie metadanych zgłoszenia

Przed skierowaniem zgłoszenia należy wyodrębnić z wiadomości metadane pomocne specjalistom: numery zamówień, nazwy produktów oraz identyfikatory kont. Przyspiesza to rozwiązanie problemu, eliminując pierwszą rundę pytań doprecyzowujących.

def extract_metadata(message: str) -> dict:
    prompt = (
        f'Extract structured metadata from this customer message.\n'
        f'Return JSON: {{"order_id": null, "product": null, "account_email": null}}\n'
        f'Use null for fields not mentioned.\n'
        f'Message: "{message}"'
    )
    resp = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}],
        response_format={'type': 'json_object'}
    )
    return json.loads(resp.choices[0].message.content)

meta = extract_metadata('My order #A12345 for the blue headphones never arrived.')
print(meta)  # {'order_id': 'A12345', 'product': 'blue headphones', 'account_email': None}

Zwiększanie priorytetu na podstawie nastroju

Rozgniewani klienci częściej rezygnują z usług. Należy wykrywać negatywny nastrój i zwiększać priorytet zgłoszenia, aby niezadowoleni klienci otrzymywali szybsze odpowiedzi, nawet jeśli ich czas SLA jeszcze nie upłynął.

def detect_sentiment(message: str) -> str:
    prompt = f'Classify sentiment as positive/neutral/negative.\nMessage: "{message}"\nReturn JSON: {{"sentiment": "..."}}'
    resp = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}],
        response_format={'type': 'json_object'}
    )
    return json.loads(resp.choices[0].message.content)['sentiment']

def set_priority(ticket: dict) -> str:
    sentiment = detect_sentiment(ticket['message'])
    if sentiment == 'negative':
        ticket['priority'] = 'high'
    elif sentiment == 'positive':
        ticket['priority'] = 'low'
    else:
        ticket['priority'] = 'normal'
    return ticket['priority']

Definiowanie łańcucha eskalacji

Należy zdefiniować jasny łańcuch eskalacji, aby każda kolejka miała ścieżkę awaryjną. Gdy kolejka pierwszej linii nie rozwiąże problemu w czasie określonym przez SLA, zgłoszenie przechodzi do poziomu 2, następnie poziomu 3 (starszego specjalisty), a na końcu do przełożonego.

ESCALATION_CHAIN = {
    'queue_tech':              'queue_tech_tier2',
    'queue_tech_tier2':        'queue_tech_senior',
    'queue_tech_senior':       'queue_supervisor_escalation',
    'queue_billing':           'queue_billing_senior',
    'queue_billing_senior':    'queue_supervisor_escalation',
    'queue_returns':           'queue_supervisor_escalation',
    'queue_fulfillment':       'queue_supervisor_escalation',
    'queue_general':           'queue_supervisor_escalation',
    'queue_supervisor_escalation': None  # terminal — human manager
}

def escalate(ticket: dict) -> str | None:
    next_queue = ESCALATION_CHAIN.get(ticket['queue'])
    if next_queue:
        ticket['queue'] = next_queue
    return next_queue

if __name__ == '__main__':
    ticket = {'queue': 'queue_tech'}
    for _ in range(3):
        nxt = escalate(ticket)
        print(f"Escalated to: {ticket['queue']}")
        if nxt is None:
            break

Pełny potok kierowania zgłoszeń

Należy połączyć klasyfikację, wyodrębnianie metadanych, analizę nastroju i sprawdzanie SLA w jeden potok uruchamiany dla każdego przychodzącego zgłoszenia.

def process_ticket(raw_ticket: dict) -> dict:
    ticket = dict(raw_ticket)

    # Step 1: Classify and route
    routing = route_with_escalation(ticket)
    ticket.update(routing)

    # Step 2: Extract metadata
    ticket['metadata'] = extract_metadata(ticket['message'])

    # Step 3: Set priority from sentiment
    ticket['priority'] = set_priority(ticket)

    # Step 4: Check if already breaching SLA
    if ticket.get('created_at'):
        check_sla_breach(ticket)

    return ticket

result = process_ticket({
    'id': 'T001',
    'message': 'I was charged twice for my subscription last month!',
    'created_at': '2026-05-28T10:00:00+00:00',
    'status': 'open'
})
print(result)

Monitorowanie dokładności kierowania

Należy śledzić dokładność kierowania, wybierając do kontroli przez człowieka określony odsetek zgłoszeń skierowanych automatycznie. Gdy specjalista przekierowuje zgłoszenie do innej kolejki, oznacza to błąd kierowania. Wykryte błędy należy wykorzystywać do ulepszania promptu lub dostrajania klasyfikatora.

import random

def log_routing_decision(ticket: dict, final_queue: str):
    was_correct = ticket.get('queue') == final_queue
    if not was_correct:
        print(f'[ROUTING_ERROR] ticket={ticket["id"]} '
              f'predicted={ticket["queue"]} actual={final_queue} '
              f'confidence={ticket.get("confidence", 0):.2f}')

# Specialist reassigns ticket: log the discrepancy
def specialist_reassign(ticket: dict, new_queue: str):
    log_routing_decision(ticket, new_queue)
    ticket['queue'] = new_queue
    return ticket

if __name__ == '__main__':
    ticket = {'id': 'T-1001', 'queue': 'queue_billing', 'confidence': 0.62}
    specialist_reassign(ticket, 'queue_tech')

Jaki próg pewności powinien uruchamiać eskalację do człowieka zamiast automatycznego kierowania?

Wybór właściwego progu pewności równoważy poziom automatyzacji i dokładność kierowania. Zbyt wysoki próg prowadzi do nadmiernej eskalacji, a zbyt niski — do błędnego kierowania.

Podsumowanie kierowania zgłoszeń

Skuteczne kierowanie zgłoszeń łączy klasyfikację intencji przez LLM z użyciem progu pewności uruchamiającego eskalację do człowieka, wyodrębnianiem metadanych w celu szybszego rozwiązywania problemów, ustalaniem priorytetu na podstawie nastroju w przypadku klientów zagrożonych odejściem oraz łańcuchem eskalacji opartym na SLA, który gwarantuje, że żadne zgłoszenie nie zostanie pominięte.

Często zadawane pytania

Czy lekcja „Kierowanie zgłoszeń i logika eskalacji” jest bezpłatna?

Tak — pełny tekst „Kierowanie zgłoszeń i logika eskalacji” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Agents, przejdź na CoddyKit PRO. Kurs AI Agents zawiera 4 lekcji w sumie.

Co nauczysz się w „Kierowanie zgłoszeń i logika eskalacji”?

Klasyfikowanie intencji, kierowanie do wyspecjalizowanych agentów i wyzwalacze eskalacji. Ćwiczysz AI Agents z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć AI Agents?

Nie wymagamy żadnego doświadczenia. AI Agents w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Kierowanie zgłoszeń i logika eskalacji”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji AI Agents?

Tak. Każda lekcja AI Agents zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Kierowanie zgłoszeń i logika eskalacji
  2. Integracja z CRM: Salesforce i HubSpot
  3. Protokoły przekazywania obsługi człowiekowi
  4. Zarządzanie kontekstem i historią klienta
← Powrót do AI Agents