Kundensupport-Agent

Voraussetzungen

Um dieser Anleitung zu folgen, benötigst du:

• Einen Claude API-Key (als Umgebungsvariable ANTHROPIC_API_KEY gesetzt)
• Python 3.10 oder neuer

Installiere die erforderlichen Pakete:

pip install anthropic streamlit python-dotenv

Bevor du mit Claude entwickelst

Entscheide, ob du Claude für den Support-Chat einsetzen möchtest

Hier sind einige wichtige Indikatoren dafür, dass du ein „large language model“ (großes Sprachmodell), oder LLM, wie Claude einsetzen solltest, um Teile deines Kundensupport-Prozesses zu automatisieren:

Einige Überlegungen, warum du Claude gegenüber anderen LLMs wählen solltest:

• Du legst Wert auf natürliche, nuancierte Konversation: Claudes ausgefeiltes Sprachverständnis ermöglicht natürlichere, kontextbewusste Gespräche, die sich menschlicher anfühlen als Chats mit anderen LLMs.
• Du erhältst häufig komplexe und offene Anfragen: Claude kann ein breites Spektrum an Themen und Anfragen bearbeiten, ohne vorgefertigte Antworten zu generieren oder eine umfangreiche Programmierung von Permutationen von Nutzeräußerungen zu erfordern.
• Du benötigst skalierbaren mehrsprachigen Support: Claudes mehrsprachige Fähigkeiten ermöglichen Gespräche in über 200 Sprachen, ohne dass für jede unterstützte Sprache separate Chatbots oder umfangreiche Übersetzungsprozesse erforderlich sind.

Definiere deine ideale Chat-Interaktion

Skizziere eine ideale Kundeninteraktion, um festzulegen, wie und wann du erwartest, dass der Kunde mit Claude interagiert. Diese Skizze hilft dabei, die technischen Anforderungen deiner Lösung zu bestimmen.

Hier ist ein Beispiel für eine Chat-Interaktion im Kundensupport einer Kfz-Versicherung:

• Kunde: Startet den Support-Chat
  • Claude: Begrüßt den Kunden herzlich und beginnt das Gespräch
• Kunde: Fragt nach einer Versicherung für sein neues Elektroauto
  • Claude: Liefert relevante Informationen zum Versicherungsschutz für Elektrofahrzeuge
• Kunde: Stellt Fragen zu den besonderen Anforderungen von Elektrofahrzeug-Versicherungen
  • Claude: Antwortet mit präzisen und informativen Antworten und stellt Links zu den Quellen bereit
• Kunde: Stellt themenfremde Fragen, die nichts mit Versicherungen oder Autos zu tun haben
  • Claude: Stellt klar, dass es keine themenfremden Inhalte bespricht, und lenkt den Nutzer zurück zur Kfz-Versicherung
• Kunde: Bekundet Interesse an einem Versicherungsangebot
  • Claude: Stellt eine Reihe von Fragen, um das passende Angebot zu ermitteln, und passt sich dabei an die Antworten an
  • Claude: Sendet eine Anfrage zur Nutzung des API-Tools zur Angebotserstellung zusammen mit den notwendigen, vom Nutzer gesammelten Informationen
  • Claude: Empfängt die Antwortinformationen aus der API-Tool-Nutzung, fasst die Informationen zu einer natürlichen Antwort zusammen und präsentiert dem Nutzer das bereitgestellte Angebot
• Kunde: Stellt Folgefragen
  • Claude: Beantwortet Folgefragen nach Bedarf
  • Claude: Führt den Kunden zu den nächsten Schritten im Versicherungsprozess und schließt das Gespräch ab

Zerlege die Interaktion in einzelne Aufgaben

Ein Kundensupport-Chat ist eine Sammlung mehrerer unterschiedlicher Aufgaben – von der Beantwortung von Fragen über den Informationsabruf bis hin zum Ausführen von Aktionen auf Anfrage –, die in einer einzigen Kundeninteraktion gebündelt sind. Bevor du mit dem Entwickeln beginnst, zerlege deine ideale Kundeninteraktion in jede einzelne Aufgabe, die Claude ausführen können soll. So stellst du sicher, dass du Claude für jede Aufgabe prompten und evaluieren kannst, und bekommst ein gutes Gefühl für die Bandbreite an Interaktionen, die du beim Schreiben von Testfällen berücksichtigen musst.

Hier sind die wichtigsten Aufgaben, die mit der Beispiel-Versicherungsinteraktion verbunden sind:

1. Begrüßung und allgemeine Orientierung

   • Den Kunden herzlich begrüßen und das Gespräch beginnen
   • Allgemeine Informationen über das Unternehmen und die Interaktion bereitstellen

2. Produktinformationen

   • Informationen zum Versicherungsschutz für Elektrofahrzeuge bereitstellen
   • Fragen zu den besonderen Anforderungen von Elektrofahrzeug-Versicherungen beantworten
   • Folgefragen zum Angebot oder zu Versicherungsdetails beantworten
   • Bei Bedarf Links zu Quellen anbieten

3. Gesprächsführung

   • Beim Thema bleiben (Kfz-Versicherung)
   • Themenfremde Fragen zurück zu relevanten Themen lenken

4. Angebotserstellung

   • Geeignete Fragen stellen, um die Angebotsberechtigung zu ermitteln
   • Fragen basierend auf den Kundenantworten anpassen
   • Gesammelte Informationen an die API zur Angebotserstellung übermitteln
   • Dem Kunden das bereitgestellte Angebot präsentieren

Lege Erfolgskriterien fest

Arbeite mit deinem Support-Team zusammen, um Erfolgskriterien zu definieren und detaillierte Evaluierungen zu schreiben – mit messbaren Benchmarks und Zielen.

Hier sind Kriterien und Benchmarks, mit denen sich bewerten lässt, wie erfolgreich Claude die definierten Aufgaben ausführt:

Hier sind Kriterien und Benchmarks, mit denen sich die geschäftlichen Auswirkungen des Einsatzes von Claude im Support bewerten lassen:

So implementierst du Claude als Kundenservice-Agent

Wähle das richtige Claude-Modell

Die Wahl des Modells hängt von den Abwägungen zwischen Kosten, Genauigkeit und Antwortzeit ab.

Für den Kundensupport-Chat ist Claude Opus 5 gut geeignet, um Intelligenz, Latenz und Kosten auszubalancieren – einschließlich der komplexesten Support-Szenarien, die tiefgehendes Schlussfolgern über lange, mehrstufige Gespräche hinweg erfordern. Für Fälle, in denen du einen Gesprächsablauf mit mehreren Prompts einschließlich RAG, Tool-Nutzung oder Prompts mit langem Kontext hast, kann jedoch Claude Haiku 4.5 besser geeignet sein, um die Latenz zu optimieren.

Erstelle einen starken Prompt

Der Einsatz von Claude im Kundensupport erfordert, dass Claude genügend Anleitung und Kontext hat, um angemessen zu antworten, und gleichzeitig genügend Flexibilität, um ein breites Spektrum an Kundenanfragen zu bearbeiten.

Beginne damit, die Elemente eines starken Prompts zu schreiben, angefangen mit einem „system prompt“ (System-Prompt). Erstelle eine Datei namens config.py und füge ihr jeden der folgenden Blöcke hinzu:

IDENTITY = """You are Eva, a friendly and knowledgeable AI assistant for Acme Insurance
Company. Your role is to warmly welcome customers and provide information on
Acme's insurance offerings, which include car insurance and electric car
insurance. You can also help customers get quotes for their insurance needs."""

Am besten zerlegst du komplexe Prompts in Unterabschnitte und schreibst einen Teil nach dem anderen. Für jede Aufgabe erzielst du möglicherweise größeren Erfolg, wenn du einem schrittweisen Prozess folgst, um die Teile des Prompts zu definieren, die Claude benötigt, um die Aufgabe gut zu erledigen. Für dieses Beispiel zum Kfz-Versicherungs-Kundensupport schreibst du Stück für Stück alle Teile eines Prompts, beginnend mit der Aufgabe „Begrüßung und allgemeine Orientierung“. Das erleichtert auch das Debugging deines Prompts, da du einzelne Teile des Gesamtprompts schneller anpassen kannst.

STATIC_GREETINGS_AND_GENERAL = """
<static_context>
Acme Auto Insurance: Your Trusted Companion on the Road

About:
At Acme Insurance, we understand that your vehicle is more than just a mode of transportation—it's your ticket to life's adventures.
Since 1985, we've been crafting auto insurance policies that give drivers the confidence to explore, commute, and travel with peace of mind.
Whether you're navigating city streets or embarking on cross-country road trips, Acme is there to protect you and your vehicle.
Our innovative auto insurance policies are designed to adapt to your unique needs, covering everything from fender benders to major collisions.
With Acme's award-winning customer service and swift claim resolution, you can focus on the joy of driving while we handle the rest.
We're not just an insurance provider—we're your co-pilot in life's journeys.
Choose Acme Auto Insurance and experience the assurance that comes with superior coverage and genuine care. Because at Acme, we don't just
insure your car—we fuel your adventures on the open road.

Note: We also offer specialized coverage for electric vehicles, ensuring that drivers of all car types can benefit from our protection.

Acme Insurance offers the following products:
- Car insurance
- Electric car insurance
- Two-wheeler insurance

Business hours: Monday-Friday, 9 AM - 5 PM EST
Customer service number: 1-800-123-4567
</static_context>
"""

Mache dann dasselbe für deine Informationen zu Kfz-Versicherungen und Elektroauto-Versicherungen.

STATIC_CAR_INSURANCE = """
<static_context>
Car Insurance Coverage:
Acme's car insurance policies typically cover:
1. Liability coverage: Pays for bodily injury and property damage you cause to others.
2. Collision coverage: Pays for damage to your car in an accident.
3. Comprehensive coverage: Pays for damage to your car from non-collision incidents.
4. Medical payments coverage: Pays for medical expenses after an accident.
5. Uninsured/underinsured motorist coverage: Protects you if you're hit by a driver with insufficient insurance.

Optional coverages include:
- Rental car reimbursement
- Roadside assistance
- New car replacement
</static_context>
"""

STATIC_ELECTRIC_CAR_INSURANCE = """
<static_context>
Electric Car Insurance:
Our specialized electric car insurance goes beyond traditional auto coverage,
offering tailored protection for your high-tech investment. In addition to standard coverages, we offer:
- Safeguarding expensive battery systems
- Covering home charging equipment
- Adapting to the rapidly evolving world of electric vehicles

Whether you're driving a Rivian, Nissan Leaf, Chevrolet Bolt,
or any other electric vehicle, our knowledgeable agents are ready to craft a policy
that gives you the confidence to enjoy every electron-powered mile.
</static_context>
"""

Nachdem du nun deine statischen Inhalte hast, füge mindestens 4–5 „gute“ Beispielinteraktionen hinzu, um Claudes Antworten zu lenken. Diese Beispiele sollten repräsentativ für deine ideale Kundeninteraktion sein und können Elemente wie Guardrails und Tool-Aufrufe enthalten.

EXAMPLES = """
Here are a few examples of how you can interact with customers:

<example 1>
H: Hi, do you offer commercial insurance for small businesses?

A: Ah! Unfortunately, we don't offer commercial insurance at this time.
However, we do provide a range of personal insurance products including car insurance and electric car insurance.
Would you like to know more about these offerings?
</example 1>

<example 2>
H: Hi, what are your business hours?

A: Our business hours are Monday to Friday, 9 AM to 5 PM EST.
If you have any questions or need assistance, feel free to reach out during those times.
How else can I assist you today?
</example 2>

<example 3>
H: I'm shopping for car insurance. What does Acme offer?

A: Great choice! Acme's car insurance policies typically include:
- Liability coverage: Protects you if you're at fault in an accident
- Collision coverage: Pays for damage to your car in an accident
- Comprehensive coverage: Covers non-collision incidents like theft or vandalism
- Medical payments coverage: Pays for medical expenses after an accident
- Uninsured/underinsured motorist coverage: Protects you from drivers with insufficient insurance

We also offer optional coverages like rental car reimbursement, roadside assistance, and new car replacement.
Would you like more details on any of these coverages, or do you have specific questions about insuring your vehicle?
</example 3>

<example 4>
H: I'd like to hear about your electric car insurance.

A: Certainly! Our electric car insurance is specially designed to meet the unique needs of electric vehicle owners.
In addition to all the standard coverages we offer for regular cars, our electric car policies include:

- Battery coverage: Protection against damage or degradation of your vehicle's expensive battery system
- Tech package: Covers repairs or replacement of advanced electronics and onboard computer systems
- Charging station coverage: Protects both home and portable charging equipment
- Cybersecurity protection: Coverage against hacking or digital threats
- Specialized roadside assistance: Includes flatbed towing to protect the vehicle's undercarriage

We cover a wide range of electric vehicles, including popular models from Tesla, Rivian, Nissan, Chevrolet, and more.
Is there a specific electric vehicle you're looking to insure, or would you like more details on any of these coverages?
</example 4>

<example 5>
H: I'd like to get a quote for my car insurance.

A: Certainly! I'd be happy to help you get a quote for your car insurance.
To provide you with an accurate quote, I'll need to collect some information about your vehicle and the primary driver.
Let's start with the basics:

1. What is the make and model of your vehicle?
2. What year was it manufactured?
3. Approximately how many miles have you driven?
4. What is the age of the primary driver?

Once you provide this information, I'll use our quoting tool to generate a personalized insurance quote for you.
</example 5>
"""

Du solltest außerdem alle wichtigen Anweisungen aufnehmen, die Dos and Don'ts dafür festlegen, wie Claude mit dem Kunden interagieren soll. Diese können sich aus Marken-Guardrails oder Support-Richtlinien ableiten.

ADDITIONAL_GUARDRAILS = """Please adhere to the following guardrails:
1. Only provide information about insurance types listed in our offerings.
2. If asked about an insurance type we don't offer, politely state
that we don't provide that service.
3. Do not speculate about future product offerings or company plans.
4. Don't make promises or enter into agreements it's not authorized to make.
You only provide information and guidance.
5. Do not mention any competitor's products or services.
"""

Kombiniere nun alle diese Abschnitte zu einem einzigen String, den du als Prompt verwendest.

TASK_SPECIFIC_INSTRUCTIONS = " ".join(
    [
        STATIC_GREETINGS_AND_GENERAL,
        STATIC_CAR_INSURANCE,
        STATIC_ELECTRIC_CAR_INSURANCE,
        EXAMPLES,
        ADDITIONAL_GUARDRAILS,
    ]
)

Füge dynamische und agentische Fähigkeiten mit Tool-Nutzung hinzu

Claude ist in der Lage, mithilfe clientseitiger „tool use“-Funktionalität (Tool-Nutzung) Aktionen auszuführen und Informationen dynamisch abzurufen. Beginne damit, alle externen Tools oder APIs aufzulisten, die der Prompt verwenden soll.

Für dieses Beispiel beginnst du mit einem Tool zur Berechnung des Angebots.

Füge den Modellnamen, die Tool-Definition und eine Stub-Implementierung zu config.py hinzu:

import time

MODEL = "claude-opus-5-5"

TOOLS = [
    {
        "name": "get_quote",
        "description": "Calculate the insurance quote based on user input. Returned value is per month premium.",
        "input_schema": {
            "type": "object",
            "properties": {
                "make": {"type": "string", "description": "The make of the vehicle."},
                "model": {"type": "string", "description": "The model of the vehicle."},
                "year": {
                    "type": "integer",
                    "description": "The year the vehicle was manufactured.",
                },
                "mileage": {
                    "type": "integer",
                    "description": "The mileage on the vehicle.",
                },
                "driver_age": {
                    "type": "integer",
                    "description": "The age of the primary driver.",
                },
            },
            "required": ["make", "model", "year", "mileage", "driver_age"],
        },
    }
]


def get_quote(make, model, year, mileage, driver_age):
    """Returns the premium per month in USD"""
    # Du kannst einen HTTP-Endpunkt oder eine Datenbank aufrufen, um den Kurs abzurufen.
    # Hier simulieren wir eine Verzögerung von 1 Sekunde und geben einen festen Kurs von 100 zurück.
    time.sleep(1)
    return 100

Stelle deine Prompts bereit

Es ist schwer zu wissen, wie gut dein Prompt funktioniert, ohne ihn in einer Test-Produktionsumgebung bereitzustellen und Evaluierungen durchzuführen. Erstelle eine kleine Anwendung mit dem Prompt, dem Anthropic SDK und Streamlit als Benutzeroberfläche.

Richte in einer Datei namens chatbot.py (oder dem entsprechenden Modul in deiner Sprache) die ChatBot-Klasse ein, die die Interaktionen mit dem Anthropic SDK kapselt.

Die Klasse sollte zwei Hauptmethoden haben: eine, die die API aufruft, um eine Nachricht zu generieren, und eine, die jede eingehende Nutzereingabe verarbeitet.

# Importiere diese in deiner chatbot.py aus der config.py, die du oben erstellt hast:
# from config import IDENTITY, TOOLS, MODEL, get_quote
from anthropic import Anthropic
from dotenv import load_dotenv

load_dotenv()


class ChatBot:
    def __init__(self, session_state):
        self.anthropic = Anthropic()
        self.session_state = session_state

    def generate_message(
        self,
        messages,
        max_tokens,
    ):
        try:
            response = self.anthropic.messages.create(
                model=MODEL,
                system=IDENTITY,
                max_tokens=max_tokens,
                messages=messages,
                tools=TOOLS,
            )
            return response
        except Exception as e:
            return {"error": str(e)}

    def process_user_input(self, user_input):
        self.session_state.messages.append({"role": "user", "content": user_input})

        response_message = self.generate_message(
            messages=self.session_state.messages,
            max_tokens=2048,
        )

        if "error" in response_message:
            return f"An error occurred: {response_message['error']}"

        if response_message.content[-1].type == "tool_use":
            tool_use = response_message.content[-1]
            func_name = tool_use.name
            func_params = tool_use.input
            tool_use_id = tool_use.id

            result = self.handle_tool_use(func_name, func_params)
            self.session_state.messages.append(
                {"role": "assistant", "content": response_message.content}
            )
            self.session_state.messages.append(
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": tool_use_id,
                            "content": f"{result}",
                        }
                    ],
                }
            )

            follow_up_response = self.generate_message(
                messages=self.session_state.messages,
                max_tokens=2048,
            )

            if "error" in follow_up_response:
                return f"An error occurred: {follow_up_response['error']}"

            response_text = next(
                (block.text for block in follow_up_response.content if block.type == "text"),
                None,
            )
            if response_text is None:
                raise Exception("An error occurred: Unexpected response type")
            self.session_state.messages.append(
                {"role": "assistant", "content": response_text}
            )
            return response_text

        text_block = next(
            (block for block in response_message.content if block.type == "text"), None
        )
        if text_block is not None:
            response_text = text_block.text
            self.session_state.messages.append(
                {"role": "assistant", "content": response_text}
            )
            return response_text

        raise Exception("An error occurred: Unexpected response type")

    def handle_tool_use(self, func_name, func_params):
        if func_name == "get_quote":
            premium = get_quote(**func_params)
            return f"Quote generated: ${premium:.2f} per month"

        raise Exception("An unexpected tool was used")

Erstelle deine Benutzeroberfläche

Teste die Bereitstellung dieses Codes mit Streamlit über eine main-Methode. Diese main()-Funktion richtet eine Streamlit-basierte Chat-Oberfläche ein. Streamlit ist ein Python-Framework, daher wird dieser Teil der Anleitung nur in Python gezeigt; die ChatBot-Klasse oben ist der Teil, den du in jede beliebige Sprache portieren kannst.

Mache dies in einer Datei namens app.py

import streamlit as st
from chatbot import ChatBot
from config import TASK_SPECIFIC_INSTRUCTIONS


def main():
    st.title("Chat with Eva, Acme Insurance Company's Assistant🤖")

    if "messages" not in st.session_state:
        st.session_state.messages = [
            {"role": "user", "content": TASK_SPECIFIC_INSTRUCTIONS},
            {"role": "assistant", "content": "Understood"},
        ]

    chatbot = ChatBot(st.session_state)

    # Benutzer- und Assistenten-Nachrichten anzeigen, die ersten beiden überspringen
    for message in st.session_state.messages[2:]:
        # Tool-Use-Blöcke ignorieren
        if isinstance(message["content"], str):
            with st.chat_message(message["role"]):
                st.markdown(message["content"])

    if user_msg := st.chat_input("Type your message here..."):
        st.chat_message("user").markdown(user_msg)

        with st.chat_message("assistant"):
            with st.spinner("Eva is thinking..."):
                response_placeholder = st.empty()
                full_response = chatbot.process_user_input(user_msg)
                response_placeholder.markdown(full_response)


if __name__ == "__main__":
    main()

Führe das Programm aus mit:

streamlit run app.py

Evaluiere deine Prompts

Prompting erfordert häufig Tests und Optimierung, um produktionsreif zu sein. Um die Einsatzbereitschaft deiner Lösung zu bestimmen, evaluiere die Chatbot-Leistung mit einem systematischen Prozess, der quantitative und qualitative Methoden kombiniert. Eine starke empirische Evaluierung auf Basis deiner definierten Erfolgskriterien ermöglicht es dir, deine Prompts zu optimieren.

Verbessere die Leistung

In komplexen Szenarien kann es hilfreich sein, zusätzliche Strategien zur Leistungsverbesserung in Betracht zu ziehen, die über standardmäßige Prompt-Engineering-Techniken und Strategien zur Guardrail-Implementierung hinausgehen. Hier sind einige häufige Szenarien:

Reduziere die Latenz bei langem Kontext mit RAG

Beim Umgang mit großen Mengen statischen und dynamischen Kontexts kann das Einbinden aller Informationen in den Prompt zu hohen Kosten, langsameren Antwortzeiten und dem Erreichen der Grenzen des „context window“ (Kontextfenster) führen. In diesem Szenario kann die Implementierung von „Retrieval Augmented Generation“-Techniken (abrufgestützte Generierung), oder RAG, die Leistung und Effizienz verbessern.

Indem du Embedding-Modelle wie Voyage verwendest, um Informationen in Vektordarstellungen umzuwandeln, kannst du ein skalierbareres und reaktionsschnelleres System erstellen. Dieser Ansatz ermöglicht den dynamischen Abruf relevanter Informationen basierend auf der aktuellen Anfrage, anstatt den gesamten möglichen Kontext in jeden Prompt aufzunehmen.

Die Implementierung von RAG für Support-Anwendungsfälle hat sich als geeignet erwiesen, die Genauigkeit zu erhöhen, Antwortzeiten zu verkürzen und API-Kosten in Systemen mit umfangreichen Kontextanforderungen zu senken. Sieh dir das RAG-Rezept für ein ausgearbeitetes Beispiel an.

Integriere Echtzeitdaten mit Tool-Nutzung

Bei Anfragen, die Echtzeitinformationen erfordern, wie Kontostände oder Policendetails, reichen Embedding-basierte RAG-Ansätze nicht aus. Stattdessen kann Tool-Nutzung die Fähigkeit deines Chatbots verbessern, präzise Echtzeitantworten zu liefern. Du kannst Tool-Nutzung beispielsweise verwenden, um Kundeninformationen nachzuschlagen, Bestelldetails abzurufen und Bestellungen im Namen des Kunden zu stornieren.

Dieser Ansatz, beschrieben im Rezept Tool-Nutzung: Kundenservice-Agent, ermöglicht es dir, Live-Daten in Claudes Antworten zu integrieren und ein persönlicheres und effizienteres Kundenerlebnis zu bieten.

Stärke Eingabe- und Ausgabe-Guardrails

Bei der Bereitstellung eines Chatbots, insbesondere in Kundenservice-Szenarien, ist es wichtig, Risiken im Zusammenhang mit Missbrauch, Anfragen außerhalb des Geltungsbereichs und unangemessenen Antworten vorzubeugen. Obwohl Claude von Natur aus widerstandsfähig gegenüber solchen Szenarien ist, sind hier zusätzliche Schritte, um die Guardrails deines Chatbots zu stärken:

• Halluzinationen reduzieren: Implementiere Mechanismen zur Faktenprüfung und Zitate, um Antworten in den bereitgestellten Informationen zu verankern.
• Informationen gegenprüfen: Verifiziere, dass die Antworten des Agenten mit den Richtlinien deines Unternehmens und bekannten Fakten übereinstimmen.
• Vertragliche Verpflichtungen vermeiden: Stelle sicher, dass der Agent keine Versprechen macht oder Vereinbarungen eingeht, zu denen er nicht befugt ist.
• Jailbreaks abschwächen: Verwende Methoden wie Harmlosigkeitsprüfungen und Eingabevalidierung, um zu verhindern, dass Nutzer Modellschwachstellen ausnutzen, um unangemessene Inhalte zu generieren.
• Erwähnung von Wettbewerbern vermeiden: Implementiere einen Filter für Wettbewerbererwähnungen, um den Markenfokus zu wahren und keine Produkte oder Dienstleistungen von Wettbewerbern zu erwähnen.
• Ausgabekonsistenz erhöhen: Verhindere, dass Claude den Stil ändert oder aus der Rolle fällt, selbst bei langen, komplexen Interaktionen.
• Personenbezogene Daten (PII) entfernen: Sofern nicht ausdrücklich erforderlich und autorisiert, entferne alle personenbezogenen Daten aus den Antworten.

Reduziere die wahrgenommene Antwortzeit mit Streaming

Bei potenziell langen Antworten kann die Implementierung von „streaming“ (Streaming) das Engagement und die Zufriedenheit der Nutzer verbessern. In diesem Szenario erhalten Nutzer die Antwort schrittweise, anstatt darauf zu warten, dass die gesamte Antwort generiert wird.

So implementierst du Streaming:

1. Verwende die Anthropic Streaming API, um Streaming-Antworten zu unterstützen.
2. Richte dein Frontend so ein, dass es eingehende Textabschnitte verarbeitet.
3. Zeige jeden Abschnitt an, sobald er eintrifft, und simuliere so Tippen in Echtzeit.
4. Implementiere einen Mechanismus zum Speichern der vollständigen Antwort, damit Nutzer sie ansehen können, wenn sie die Seite verlassen und zurückkehren.

In manchen Fällen ermöglicht Streaming den Einsatz fortschrittlicherer Modelle mit höheren Basislatenzen, da die schrittweise Anzeige die Auswirkungen längerer Verarbeitungszeiten abmildert.

Skaliere deinen Chatbot

Mit wachsender Komplexität deines Chatbots kann sich deine Anwendungsarchitektur entsprechend weiterentwickeln. Bevor du deiner Architektur weitere Schichten hinzufügst, ziehe die folgenden weniger aufwendigen Optionen in Betracht:

• Stelle sicher, dass du das Beste aus deinen Prompts herausholst und durch Prompt-Engineering optimierst. Nutze die Prompt-Engineering-Leitfäden, um die effektivsten Prompts zu schreiben.
• Füge dem Prompt zusätzliche Tools hinzu (die auch Prompt-Ketten umfassen können) und prüfe, ob du die erforderliche Funktionalität erreichen kannst.

Wenn dein Chatbot äußerst vielfältige Aufgaben bearbeitet, solltest du in Erwägung ziehen, einen separaten Intent-Klassifikator hinzuzufügen, um die anfängliche Kundenanfrage weiterzuleiten. Für die bestehende Anwendung würde dies bedeuten, einen Entscheidungsbaum zu erstellen, der Kundenanfragen durch den Klassifikator und dann zu spezialisierten Konversationen (mit jeweils eigenen Tools und System-Prompts) leitet. Beachte, dass diese Methode einen zusätzlichen Aufruf an Claude erfordert, der die Latenz erhöhen kann.

Integriere Claude in deinen Support-Workflow

Während sich diese Beispiele auf Python-Funktionen konzentriert haben, die innerhalb einer Streamlit-Umgebung aufrufbar sind, erfordert die Bereitstellung von Claude für einen Echtzeit-Support-Chatbot einen API-Dienst.

So kannst du vorgehen:

1. Erstelle einen API-Wrapper: Entwickle einen einfachen API-Wrapper um deine Klassifizierungsfunktion. Du kannst beispielsweise Flask API oder Fast API verwenden, um deinen Code in einen HTTP-Dienst zu verpacken. Dein HTTP-Dienst könnte die Nutzereingabe entgegennehmen und die Assistant-Antwort vollständig zurückgeben. Dein Dienst könnte somit die folgenden Eigenschaften haben:

   • Server-Sent Events (SSE): SSE ermöglicht das Echtzeit-Streaming von Antworten vom Server zum Client. Dies sorgt für ein flüssiges, interaktives Erlebnis bei der Arbeit mit LLMs.
   • Caching: Die Implementierung von Caching kann Antwortzeiten verbessern und unnötige API-Aufrufe reduzieren.
   • Kontexterhaltung: Den Kontext beizubehalten, wenn ein Nutzer die Seite verlässt und zurückkehrt, ist wichtig für die Kontinuität von Gesprächen.

2. Erstelle eine Weboberfläche: Implementiere eine benutzerfreundliche Web-UI für die Interaktion mit dem Claude-gestützten Agenten.

Nächste Schritte