Kundensupport-Agent



Voraussetzungen

Um dieser Anleitung zu folgen, benötigst du:

• Einen Claude API-Key (gesetzt als Umgebungsvariable ANTHROPIC_API_KEY)
• Python 3.9 oder höher

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 solltest

Hier sind einige wichtige Indikatoren dafür, dass du ein LLM wie Claude einsetzen solltest, um Teile deines Kundensupport-Prozesses zu automatisieren:

Einige Überlegungen bei der Wahl von Claude gegenüber anderen LLMs:

• 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 separate Chatbots oder umfangreiche Übersetzungsprozesse für jede unterstützte Sprache erforderlich sind.



Definiere deine ideale Chat-Interaktion

Skizziere eine ideale Kundeninteraktion, um zu definieren, wie und wann der Kunde mit Claude interagieren soll. Diese Skizze hilft dir, die technischen Anforderungen deiner Lösung zu bestimmen.

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

• Kunde: Startet die Support-Chat-Erfahrung
  • 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 zur Versicherung von Elektrofahrzeugen
• Kunde: Stellt Fragen zu besonderen Anforderungen bei 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 Themen bespricht, und lenkt den Nutzer zurück zur Kfz-Versicherung
• Kunde: Zeigt Interesse an einem Versicherungsangebot
  • Claude: Stellt eine Reihe von Fragen, um das passende Angebot zu ermitteln, und passt sich dabei den Antworten an
  • Claude: Sendet eine Anfrage zur Nutzung des API-Tools zur Angebotserstellung zusammen mit den vom Nutzer gesammelten notwendigen Informationen
  • Claude: Erhält 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 beendet das Gespräch



Zerlege die Interaktion in einzelne Aufgaben

Kundensupport-Chat ist eine Sammlung mehrerer verschiedener Aufgaben – von der Beantwortung von Fragen über das Abrufen von Informationen bis hin zum Ausführen von Aktionen auf Anfragen –, die in einer einzigen Kundeninteraktion zusammengefasst sind. Bevor du mit der Entwicklung beginnst, zerlege deine ideale Kundeninteraktion in jede Aufgabe, die Claude ausführen können soll. Dies stellt sicher, dass du Claude für jede Aufgabe prompten und evaluieren kannst, und gibt dir 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 dem Beispiel der 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 zur Versicherung von Elektrofahrzeugen bereitstellen
     

     Dies erfordert, dass Claude die notwendigen Informationen in seinem Kontext hat, und könnte bedeuten, dass eine RAG-Integration erforderlich ist.
   • Fragen zu besonderen Anforderungen bei 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

   • Passende Fragen stellen, um die Angebotsberechtigung zu ermitteln
   • Fragen basierend auf Kundenantworten anpassen
   • Gesammelte Informationen an die API zur Angebotserstellung übermitteln
   • Das bereitgestellte Angebot dem Kunden präsentieren



Erfolgskriterien festlegen

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 bewertet werden kann, wie erfolgreich Claude die definierten Aufgaben ausführt:

Hier sind Kriterien und Benchmarks, mit denen die geschäftlichen Auswirkungen des Einsatzes von Claude für den Support bewertet werden können:



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 Kundensupport-Chat ist Claude Opus 4.8 gut geeignet, um Intelligenz, Latenz und Kosten auszubalancieren. Für Fälle, in denen du einen Gesprächsablauf mit mehreren Prompts hast, einschließlich RAG, Tool-Nutzung oder Prompts mit langem Kontext, könnte Claude Haiku 4.5 jedoch besser geeignet sein, um die Latenz zu optimieren.



Erstelle einen starken Prompt

Die Verwendung von Claude für den Kundensupport erfordert, dass Claude genügend Anweisungen und Kontext hat, um angemessen zu reagieren, 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. Erstelle eine Datei namens config.py und füge 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."""

Es ist am besten, komplexe Prompts in Unterabschnitte zu zerlegen und jeweils einen Teil zu schreiben. Für jede Aufgabe könntest du mehr Erfolg haben, 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 des Kfz-Versicherungs-Kundensupports schreibst du Stück für Stück alle Teile für einen Prompt, beginnend mit der Aufgabe „Begrüßung und allgemeine Orientierung". Dies erleichtert auch das Debuggen deines Prompts, da du einzelne Teile des Gesamt-Prompts 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 zur Kfz-Versicherung und zur Elektroauto-Versicherung.

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 deinen statischen Inhalt hast, füge mindestens 4–5 Beispiele für „gute" Interaktionen hinzu, um Claudes Antworten zu steuern. Diese Beispiele sollten repräsentativ für deine ideale Kundeninteraktion sein und können Guardrails, Tool-Aufrufe usw. 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 auch alle wichtigen Anweisungen einfügen, die Dos und Don'ts dafür beschreiben, 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 all diese Abschnitte zu einem einzigen String, den du als deinen 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 der clientseitigen 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-4-8"

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 das Angebot abzurufen.
    # Hier simulieren wir eine Verzögerung von 1 Sekunde und geben ein festes Angebot von 100 zurück.
    time.sleep(1)
    return 100



Deploye deine Prompts

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

Beginne in einer Datei namens chatbot.py damit, die ChatBot-Klasse einzurichten, die die Interaktionen mit dem Anthropic SDK kapselt.

Die Klasse sollte zwei Hauptmethoden haben: generate_message und process_user_input.

from anthropic import Anthropic
from config import IDENTITY, TOOLS, MODEL, get_quote
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 = follow_up_response.content[0].text
            self.session_state.messages.append(
                {"role": "assistant", "content": response_text}
            )
            return response_text

        elif response_message.content[0].type == "text":
            response_text = response_message.content[0].text
            self.session_state.messages.append(
                {"role": "assistant", "content": response_text}
            )
            return response_text

        else:
            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 das Deployment dieses Codes mit Streamlit unter Verwendung einer Main-Methode. Diese main()-Funktion richtet eine Streamlit-basierte Chat-Oberfläche ein.

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)

    # Zeige Benutzer- und Assistenten-Nachrichten an, überspringe die ersten beiden
    for message in st.session_state.messages[2:]:
        # Ignoriere tool_use-Blöcke
        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 oft Tests und Optimierung, damit es produktionsreif ist. Um die Reife deiner Lösung zu bestimmen, evaluiere die Chatbot-Leistung mit einem systematischen Prozess, der quantitative und qualitative Methoden kombiniert. Das Erstellen einer starken empirischen Evaluierung basierend auf deinen 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 über die standardmäßigen Prompt-Engineering-Techniken und Guardrail-Implementierungsstrategien hinaus in Betracht zu ziehen. Hier sind einige häufige Szenarien:



Reduziere die Latenz bei langem Kontext mit RAG

Wenn du mit großen Mengen an statischem und dynamischem Kontext arbeitest, kann das Einbeziehen aller Informationen in den Prompt zu hohen Kosten, langsameren Antwortzeiten und dem Erreichen der Kontextfenster-Grenzen führen. In diesem Szenario kann die Implementierung von „Retrieval Augmented Generation" (RAG)-Techniken die Leistung und Effizienz verbessern.

Durch die Verwendung von Embedding-Modellen wie Voyage, um Informationen in Vektordarstellungen umzuwandeln, kannst du ein skalierbareres und reaktionsschnelleres System erstellen. Dieser Ansatz ermöglicht das dynamische Abrufen relevanter Informationen basierend auf der aktuellen Anfrage, anstatt allen möglichen Kontext in jeden Prompt einzubeziehen.

Die Implementierung von RAG für Support-Anwendungsfälle hat nachweislich die Genauigkeit erhöht, Antwortzeiten reduziert und API-Kosten in Systemen mit umfangreichen Kontextanforderungen gesenkt. Siehe das RAG-Rezept für ein ausgearbeitetes Beispiel.



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, genaue Echtzeitantworten zu liefern. Du kannst beispielsweise Tool-Nutzung 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 personalisierteres und effizienteres Kundenerlebnis zu bieten.



Stärke Input- und Output-Guardrails

Beim Deployment eines Chatbots, insbesondere in Kundenservice-Szenarien, ist es wichtig, Risiken im Zusammenhang mit Missbrauch, themenfremden Anfragen und unangemessenen Antworten zu verhindern. Obwohl Claude von Natur aus widerstandsfähig gegenüber solchen Szenarien ist, findest du hier zusätzliche Schritte zur Stärkung deiner Chatbot-Guardrails:

• Halluzinationen reduzieren: Implementiere Faktenprüfungsmechanismen und Zitate, um Antworten auf bereitgestellte Informationen zu stützen.
• Informationen gegenprüfen: Überprüfe, ob die Antworten des Agenten mit den Richtlinien und bekannten Fakten deines Unternehmens übereinstimmen.
• Vertragliche Verpflichtungen vermeiden: Stelle sicher, dass der Agent keine Versprechen macht oder Vereinbarungen eingeht, zu denen er nicht autorisiert ist.
• Jailbreaks abschwächen: Verwende Methoden wie Harmlosigkeitsprüfungen und Input-Validierung, 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.
• Output-Konsistenz 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 PII aus den Antworten.



Reduziere die wahrgenommene Antwortzeit mit Streaming

Bei potenziell langen Antworten kann die Implementierung von Streaming das Nutzerengagement und die Zufriedenheit 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 Textblöcke verarbeitet.
3. Zeige jeden Block an, sobald er ankommt, und simuliere so Echtzeit-Tippen.
4. Implementiere einen Mechanismus zum Speichern der vollständigen Antwort, damit Nutzer sie sehen können, wenn sie wegnavigieren und zurückkehren.

In einigen Fällen ermöglicht Streaming die Verwendung fortschrittlicherer Modelle mit höheren Basis-Latenzen, da die progressive Anzeige die Auswirkungen längerer Verarbeitungszeiten abmildert.



Skaliere deinen Chatbot

Wenn die Komplexität deines Chatbots wächst, kann sich deine Anwendungsarchitektur entsprechend weiterentwickeln. Bevor du weitere Schichten zu deiner Architektur 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. Verwende die Prompt-Engineering-Leitfäden, um die effektivsten Prompts zu schreiben.
• Füge dem Prompt zusätzliche Tools hinzu (die auch Prompt-Ketten enthalten können) und prüfe, ob du die erforderliche Funktionalität erreichen kannst.

Wenn dein Chatbot unglaublich vielfältige Aufgaben bearbeitet, solltest du in Betracht ziehen, einen separaten Intent-Klassifikator hinzuzufügen, um die anfängliche Kundenanfrage zu routen. Für die bestehende Anwendung würde dies das Erstellen eines Entscheidungsbaums beinhalten, der Kundenanfragen durch den Klassifikator und dann zu spezialisierten Gesprächen (mit ihrem eigenen Satz von 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 in einer Streamlit-Umgebung aufrufbar sind, erfordert das Deployment von Claude für einen Echtzeit-Support-Chatbot einen API-Service.

So kannst du dabei 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-Service zu verpacken. Dein HTTP-Service könnte die Nutzereingabe akzeptieren und die Assistant-Antwort vollständig zurückgeben. Dein Service könnte somit die folgenden Eigenschaften haben:

   • Server-Sent Events (SSE): SSE ermöglicht das Echtzeit-Streaming von Antworten vom Server zum Client. Dies bietet ein reibungsloses, interaktives Erlebnis bei der Arbeit mit LLMs.
   • Caching: Die Implementierung von Caching kann Antwortzeiten verbessern und unnötige API-Aufrufe reduzieren.
   • Kontexterhaltung: Das Beibehalten des Kontexts, wenn ein Nutzer wegnavigiert und zurückkehrt, ist wichtig für die Kontinuität in Gesprächen.

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



Nächste Schritte