Agent de support client

Prérequis

Pour suivre ce guide, vous avez besoin de :

• Une clé API Claude (définie comme variable d'environnement ANTHROPIC_API_KEY)
• Python 3.10 ou version ultérieure

Installez les paquets requis :

pip install anthropic streamlit python-dotenv

Avant de construire avec Claude

Décider d'utiliser ou non Claude pour le chat de support

Voici quelques indicateurs clés montrant que vous devriez employer un « large language model » (grand modèle de langage), ou LLM, comme Claude pour automatiser certaines parties de votre processus de support client :

Quelques considérations pour choisir Claude plutôt que d'autres LLM :

• Vous privilégiez une conversation naturelle et nuancée : la compréhension sophistiquée du langage de Claude permet des conversations plus naturelles et sensibles au contexte, qui semblent plus humaines que les échanges avec d'autres LLM.
• Vous recevez souvent des requêtes complexes et ouvertes : Claude peut traiter un large éventail de sujets et de demandes sans générer de réponses toutes faites ni nécessiter une programmation extensive des permutations d'énoncés des utilisateurs.
• Vous avez besoin d'un support multilingue évolutif : les capacités multilingues de Claude lui permettent de mener des conversations dans plus de 200 langues sans qu'il soit nécessaire de disposer de chatbots distincts ou de processus de traduction étendus pour chaque langue prise en charge.

Définir votre interaction de chat idéale

Esquissez une interaction client idéale pour définir comment et quand vous vous attendez à ce que le client interagisse avec Claude. Cette esquisse aidera à déterminer les exigences techniques de votre solution.

Voici un exemple d'interaction de chat pour le support client d'une assurance automobile :

• Client : Lance l'expérience de chat de support
  • Claude : Accueille chaleureusement le client et engage la conversation
• Client : Pose des questions sur l'assurance de sa nouvelle voiture électrique
  • Claude : Fournit des informations pertinentes sur la couverture des véhicules électriques
• Client : Pose des questions liées aux besoins spécifiques des assurances pour véhicules électriques
  • Claude : Répond avec des réponses précises et informatives et fournit des liens vers les sources
• Client : Pose des questions hors sujet sans rapport avec l'assurance ou les voitures
  • Claude : Précise qu'il ne discute pas de sujets sans rapport et ramène l'utilisateur vers l'assurance automobile
• Client : Exprime son intérêt pour un devis d'assurance
  • Claude : Pose une série de questions pour déterminer le devis approprié, en s'adaptant aux réponses
  • Claude : Envoie une requête pour utiliser l'outil API de génération de devis avec les informations nécessaires recueillies auprès de l'utilisateur
  • Claude : Reçoit les informations de réponse issues de l'utilisation de l'outil API, synthétise les informations en une réponse naturelle et présente le devis fourni à l'utilisateur
• Client : Pose des questions complémentaires
  • Claude : Répond aux questions complémentaires selon les besoins
  • Claude : Guide le client vers les prochaines étapes du processus d'assurance et clôt la conversation

Décomposer l'interaction en tâches distinctes

Le chat de support client est un ensemble de plusieurs tâches différentes, allant de la réponse aux questions à la récupération d'informations, en passant par la prise de mesures suite aux demandes, le tout regroupé dans une seule interaction client. Avant de commencer à construire, décomposez votre interaction client idéale en chacune des tâches que vous souhaitez que Claude puisse accomplir. Cela garantit que vous pouvez rédiger des prompts et évaluer Claude pour chaque tâche, et vous donne une bonne idée de l'éventail des interactions dont vous devez tenir compte lors de la rédaction des cas de test.

Voici les tâches clés associées à l'exemple d'interaction d'assurance :

1. Accueil et orientation générale

   • Accueillir chaleureusement le client et engager la conversation
   • Fournir des informations générales sur l'entreprise et l'interaction

2. Informations sur les produits

   • Fournir des informations sur la couverture des véhicules électriques
   • Répondre aux questions liées aux besoins spécifiques d'assurance des véhicules électriques
   • Répondre aux questions complémentaires sur le devis ou les détails de l'assurance
   • Proposer des liens vers les sources lorsque cela est approprié

3. Gestion de la conversation

   • Rester dans le sujet (assurance automobile)
   • Rediriger les questions hors sujet vers des sujets pertinents

4. Génération de devis

   • Poser les questions appropriées pour déterminer l'éligibilité au devis
   • Adapter les questions en fonction des réponses du client
   • Soumettre les informations recueillies à l'API de génération de devis
   • Présenter le devis fourni au client

Établir des critères de réussite

Travaillez avec votre équipe de support pour définir des critères de réussite et rédiger des évaluations détaillées avec des repères et des objectifs mesurables.

Voici des critères et des repères qui peuvent être utilisés pour évaluer dans quelle mesure Claude accomplit avec succès les tâches définies :

Voici des critères et des repères qui peuvent être utilisés pour évaluer l'impact commercial de l'emploi de Claude pour le support :

Comment implémenter Claude en tant qu'agent de service client

Choisir le bon modèle Claude

Le choix du modèle dépend des compromis entre le coût, la précision et le temps de réponse.

Pour le chat de support client, Claude Opus 5 est bien adapté pour équilibrer intelligence, latence et coût, y compris pour les scénarios de support les plus complexes qui nécessitent un raisonnement approfondi au fil de longues conversations en plusieurs étapes. Cependant, dans les cas où vous avez un flux de conversation avec plusieurs prompts incluant du RAG, de l'utilisation d'outils ou des prompts à long contexte, Claude Haiku 4.5 peut être plus adapté pour optimiser la latence.

Construire un prompt solide

Utiliser Claude pour le support client nécessite que Claude dispose de suffisamment de directives et de contexte pour répondre de manière appropriée, tout en ayant suffisamment de flexibilité pour traiter un large éventail de demandes clients.

Commencez par rédiger les éléments d'un prompt solide, en commençant par un « system prompt » (invite système). Créez un fichier appelé config.py et ajoutez-y chacun des blocs suivants :

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

Il est préférable de décomposer les prompts complexes en sous-sections et de rédiger une partie à la fois. Pour chaque tâche, vous pourriez obtenir de meilleurs résultats en suivant un processus étape par étape pour définir les parties du prompt dont Claude aurait besoin pour bien accomplir la tâche. Pour cet exemple de support client d'assurance automobile, vous rédigerez morceau par morceau toutes les parties d'un prompt en commençant par la tâche « Accueil et orientation générale ». Cela facilite également le débogage de votre prompt, car vous pouvez ajuster plus rapidement les parties individuelles du prompt global.

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

Faites ensuite de même pour vos informations sur l'assurance automobile et l'assurance des voitures électriques.

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

Maintenant que vous disposez de votre contenu statique, ajoutez au moins 4 à 5 exemples de « bonnes » interactions pour guider les réponses de Claude. Ces exemples doivent être représentatifs de votre interaction client idéale et peuvent inclure des éléments tels que des garde-fous et des appels d'outils.

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

Vous voudrez également inclure toutes les instructions importantes décrivant ce que Claude doit faire et ne pas faire dans ses interactions avec le client. Celles-ci peuvent s'inspirer des garde-fous de la marque ou des politiques de support.

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

Combinez maintenant toutes ces sections en une seule chaîne de caractères à utiliser comme prompt.

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

Ajouter des capacités dynamiques et agentiques avec l'utilisation d'outils

Claude est capable d'effectuer des actions et de récupérer des informations de manière dynamique grâce à la fonctionnalité de « tool use » (utilisation d'outils) côté client. Commencez par lister tous les outils externes ou API que le prompt doit utiliser.

Pour cet exemple, commencez avec un seul outil pour calculer le devis.

Ajoutez le nom du modèle, la définition de l'outil et une implémentation factice à config.py :

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"""
    # Vous pouvez appeler un endpoint HTTP ou une base de données pour obtenir la cotation.
    # Ici, nous simulons un délai d'une seconde et renvoyons une cotation fixe de 100.
    time.sleep(1)
    return 100

Déployer vos prompts

Il est difficile de savoir dans quelle mesure votre prompt fonctionne sans le déployer dans un environnement de test de production et sans exécuter des évaluations. Construisez une petite application utilisant le prompt, le SDK Anthropic et Streamlit pour l'interface utilisateur.

Dans un fichier appelé chatbot.py (ou le module équivalent dans votre langage), configurez la classe ChatBot, qui encapsulera les interactions avec le SDK Anthropic.

La classe doit avoir deux méthodes principales : une qui appelle l'API pour générer un message, et une qui traite chaque entrée utilisateur reçue.

# Dans votre chatbot.py, importez-les depuis le config.py que vous avez écrit ci-dessus :
# 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")

Construire votre interface utilisateur

Testez le déploiement de ce code avec Streamlit à l'aide d'une méthode principale. Cette fonction main() configure une interface de chat basée sur Streamlit. Streamlit est un framework Python, cette partie du guide est donc présentée uniquement en Python ; la classe ChatBot ci-dessus est l'élément que vous pouvez porter dans n'importe quel langage.

Faites cela dans un fichier appelé 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)

    # Afficher les messages utilisateur et assistant en ignorant les deux premiers
    for message in st.session_state.messages[2:]:
        # ignorer les blocs d'utilisation d'outils
        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()

Exécutez le programme avec :

streamlit run app.py

Évaluer vos prompts

Les prompts nécessitent souvent des tests et une optimisation pour être prêts pour la production. Pour déterminer si votre solution est prête, évaluez les performances du chatbot à l'aide d'un processus systématique combinant des méthodes quantitatives et qualitatives. La création d'une évaluation empirique solide basée sur vos critères de réussite définis vous permettra d'optimiser vos prompts.

Améliorer les performances

Dans des scénarios complexes, il peut être utile d'envisager des stratégies supplémentaires pour améliorer les performances au-delà des techniques d'ingénierie de prompts standard et des stratégies de mise en œuvre de garde-fous. Voici quelques scénarios courants :

Réduire la latence des longs contextes avec le RAG

Lorsque vous traitez de grandes quantités de contexte statique et dynamique, inclure toutes les informations dans le prompt peut entraîner des coûts élevés, des temps de réponse plus lents et l'atteinte des limites de la « context window » (fenêtre de contexte). Dans ce scénario, la mise en œuvre de techniques de « Retrieval Augmented Generation » (génération augmentée par récupération), ou RAG, peut améliorer les performances et l'efficacité.

En utilisant des modèles d'embedding comme Voyage pour convertir les informations en représentations vectorielles, vous pouvez créer un système plus évolutif et plus réactif. Cette approche permet la récupération dynamique des informations pertinentes en fonction de la requête en cours, plutôt que d'inclure tout le contexte possible dans chaque prompt.

Il a été démontré que la mise en œuvre du RAG pour les cas d'usage de support augmente la précision, réduit les temps de réponse et réduit les coûts d'API dans les systèmes ayant des exigences de contexte étendues. Consultez la recette RAG pour un exemple détaillé.

Intégrer des données en temps réel avec l'utilisation d'outils

Lorsque vous traitez des requêtes nécessitant des informations en temps réel, telles que des soldes de compte ou des détails de police, les approches RAG basées sur les embeddings ne suffisent pas. À la place, l'utilisation d'outils peut améliorer la capacité de votre chatbot à fournir des réponses précises en temps réel. Par exemple, vous pouvez recourir à l'utilisation d'outils pour rechercher des informations client, récupérer les détails d'une commande et annuler des commandes au nom du client.

Cette approche, décrite dans la recette utilisation d'outils : agent de service client, vous permet d'intégrer des données en direct dans les réponses de Claude et d'offrir une expérience client plus personnalisée et plus efficace.

Renforcer les garde-fous d'entrée et de sortie

Lors du déploiement d'un chatbot, en particulier dans des scénarios de service client, il est important de prévenir les risques associés à une utilisation abusive, aux requêtes hors périmètre et aux réponses inappropriées. Bien que Claude soit intrinsèquement résilient face à de tels scénarios, voici des mesures supplémentaires pour renforcer les garde-fous de votre chatbot :

• Réduire les hallucinations : mettez en œuvre des mécanismes de vérification des faits et des citations pour ancrer les réponses dans les informations fournies.
• Recouper les informations : vérifiez que les réponses de l'agent sont conformes aux politiques de votre entreprise et aux faits connus.
• Éviter les engagements contractuels : assurez-vous que l'agent ne fait pas de promesses et ne conclut pas d'accords qu'il n'est pas autorisé à conclure.
• Atténuer les jailbreaks : utilisez des méthodes telles que les filtres d'innocuité et la validation des entrées pour empêcher les utilisateurs d'exploiter les vulnérabilités du modèle dans le but de générer du contenu inapproprié.
• Éviter de mentionner les concurrents : mettez en œuvre un filtre de mention des concurrents pour rester centré sur la marque et ne mentionner aucun produit ou service concurrent.
• Augmenter la cohérence des sorties : empêchez Claude de changer de style ou de sortir de son personnage, même lors d'interactions longues et complexes.
• Supprimer les informations personnelles identifiables (PII) : sauf si cela est explicitement requis et autorisé, retirez toute PII des réponses.

Réduire le temps de réponse perçu avec le streaming

Lorsque vous traitez des réponses potentiellement longues, la mise en œuvre du « streaming » (streaming) peut améliorer l'engagement et la satisfaction des utilisateurs. Dans ce scénario, les utilisateurs reçoivent la réponse progressivement au lieu d'attendre que la réponse entière soit générée.

Voici comment mettre en œuvre le streaming :

1. Utilisez l'API de streaming Anthropic pour prendre en charge les réponses en streaming.
2. Configurez votre frontend pour gérer les fragments de texte entrants.
3. Affichez chaque fragment à son arrivée, simulant une saisie en temps réel.
4. Mettez en œuvre un mécanisme pour enregistrer la réponse complète, permettant aux utilisateurs de la consulter s'ils quittent la page et reviennent.

Dans certains cas, le streaming permet d'utiliser des modèles plus avancés avec des latences de base plus élevées, car l'affichage progressif atténue l'impact des temps de traitement plus longs.

Faire évoluer votre chatbot

À mesure que la complexité de votre chatbot augmente, l'architecture de votre application peut évoluer en conséquence. Avant d'ajouter des couches supplémentaires à votre architecture, envisagez les options suivantes, moins exhaustives :

• Assurez-vous de tirer le meilleur parti de vos prompts et de les optimiser grâce à l'ingénierie de prompts. Utilisez les guides d'ingénierie de prompts pour rédiger les prompts les plus efficaces.
• Ajoutez des outils supplémentaires au prompt (qui peuvent inclure des chaînes de prompts) et voyez si vous pouvez obtenir la fonctionnalité requise.

Si votre chatbot traite des tâches extrêmement variées, vous pouvez envisager d'ajouter un classificateur d'intention distinct pour acheminer la requête initiale du client. Pour l'application existante, cela impliquerait de créer un arbre de décision qui acheminerait les requêtes des clients via le classificateur, puis vers des conversations spécialisées (avec leur propre ensemble d'outils et d'invites système). Notez que cette méthode nécessite un appel supplémentaire à Claude qui peut augmenter la latence.

Intégrer Claude dans votre flux de travail de support

Bien que ces exemples se soient concentrés sur des fonctions Python appelables dans un environnement Streamlit, le déploiement de Claude pour un chatbot de support en temps réel nécessite un service API.

Voici comment vous pouvez aborder cela :

1. Créer un wrapper d'API : développez un wrapper d'API simple autour de votre fonction de classification. Par exemple, vous pouvez utiliser Flask API ou Fast API pour encapsuler votre code dans un service HTTP. Votre service HTTP pourrait accepter l'entrée de l'utilisateur et renvoyer la réponse de l'Assistant dans son intégralité. Ainsi, votre service pourrait avoir les caractéristiques suivantes :

   • Server-Sent Events (SSE) : les SSE permettent le streaming en temps réel des réponses du serveur vers le client. Cela offre une expérience fluide et interactive lors de l'utilisation de LLM.
   • Mise en cache : la mise en œuvre de la mise en cache peut améliorer les temps de réponse et réduire les appels d'API inutiles.
   • Conservation du contexte : le maintien du contexte lorsqu'un utilisateur quitte la page et revient est important pour la continuité des conversations.

2. Construire une interface web : mettez en œuvre une interface web conviviale pour interagir avec l'agent propulsé par Claude.

Prochaines étapes