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.9 ou version ultérieure

Installez les packages requis :

pip install anthropic streamlit python-dotenv



Avant de développer avec Claude



Décider si Claude convient pour le chat de support

Voici quelques indicateurs clés suggérant que vous devriez utiliser un 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 contextuelles 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 préfabriquées ni nécessiter une programmation exhaustive des permutations d'énoncés utilisateur.
• Vous avez besoin d'un support multilingue évolutif : les capacités multilingues de Claude lui permettent d'engager des conversations dans plus de 200 langues sans avoir besoin 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 attendez 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 pour 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 non liés 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 collectées auprès de l'utilisateur
  • Claude : Reçoit les informations de réponse de l'utilisation d'outils API, synthétise les informations en une réponse naturelle et présente le devis fourni à l'utilisateur
• Client : Pose des questions de suivi
  • Claude : Répond aux questions de suivi 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 l'exécution d'actions sur demande, le tout regroupé dans une seule interaction client. Avant de commencer à développer, décomposez votre interaction client idéale en chaque tâche que vous souhaitez que Claude puisse effectuer. Cela garantit que vous pouvez créer des prompts et évaluer Claude pour chaque tâche, et vous donne une bonne idée de l'éventail d'interactions que vous devez prendre en 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
     

     Cela nécessitera que Claude dispose des informations nécessaires dans son contexte, et pourrait impliquer qu'une intégration RAG soit nécessaire.
   • Répondre aux questions liées aux besoins spécifiques de l'assurance pour véhicules électriques
   • Répondre aux questions de suivi sur le devis ou les détails de l'assurance
   • Proposer des liens vers des 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 collectées à 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 références et des objectifs mesurables.

Voici des critères et des références 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 références qui peuvent être utilisés pour évaluer l'impact commercial de l'utilisation 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 coût, précision et temps de réponse.

Pour le chat de support client, Claude Opus 4.8 est bien adapté pour équilibrer intelligence, « latency » (latence) et coût. 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 à contexte long, Claude Haiku 4.5 peut être plus approprié pour optimiser la latence.



Construire un prompt solide

L'utilisation de 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 gérer un large éventail de demandes clients.

Commencez par rédiger les éléments d'un prompt solide, en commençant par une 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 d'écrire 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 allez écrire progressivement 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 pour 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 avez 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 garde-fous, des appels d'outils, etc.

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 qu'il faut faire et ne pas faire concernant la manière dont Claude doit interagir avec le client. Cela peut 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 en utilisant la fonctionnalité d'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 outil pour calculer le devis.

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

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"""
    # Vous pouvez appeler un point de terminaison HTTP ou une base de données pour obtenir la cotation.
    # Ici, nous simulons un délai de 1 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 bien sans le déployer dans un environnement de production de test et exécuter des évaluations. Créez une petite application en utilisant le prompt, le SDK Anthropic et Streamlit pour une interface utilisateur.

Dans un fichier appelé chatbot.py, commencez par configurer la classe ChatBot, qui encapsulera les interactions avec le SDK Anthropic.

La classe doit avoir deux méthodes principales : generate_message et 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")



Construire votre interface utilisateur

Testez le déploiement de ce code avec Streamlit en utilisant une méthode principale. Cette fonction main() configure une interface de chat basée sur Streamlit.

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

Le prompting nécessite souvent des tests et une optimisation pour être prêt pour la production. Pour déterminer si votre solution est prête, évaluez les performances du chatbot en utilisant un processus systématique combinant des méthodes quantitatives et qualitatives. Créer 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 standard d'ingénierie de prompts et des stratégies d'implémentation de garde-fous. Voici quelques scénarios courants :



Réduire la latence des contextes longs 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, l'implémentation 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'embeddings comme Voyage pour convertir les informations en représentations vectorielles, vous pouvez créer un système plus évolutif et réactif. Cette approche permet une récupération dynamique des informations pertinentes en fonction de la requête actuelle, plutôt que d'inclure tout le contexte possible dans chaque prompt.

Il a été démontré que l'implémentation 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 les soldes de compte ou les détails de police, les approches RAG basées sur les embeddings ne sont pas suffisantes. À la place, l'utilisation d'outils peut améliorer la capacité de votre chatbot à fournir des réponses précises et en temps réel. Par exemple, vous pouvez utiliser l'utilisation d'outils pour rechercher des informations client, récupérer les détails de commande et annuler des commandes au nom du client.

Cette approche, décrite dans la recette d'utilisation d'outils : agent de service client, vous permet d'intégrer des données en direct dans les réponses de Claude et de fournir une expérience client plus personnalisée et 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 mauvaise utilisation, aux requêtes hors périmètre et aux réponses inappropriées. Bien que Claude soit intrinsèquement résilient à de tels scénarios, voici des étapes supplémentaires pour renforcer les garde-fous de votre chatbot :

• Réduire les hallucinations : implémentez 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 ou ne conclut pas d'accords qu'il n'est pas autorisé à prendre.
• 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 : implémentez un filtre de mention des concurrents pour maintenir l'accent sur la marque et ne mentionner aucun produit ou service d'un 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é, supprimez 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, l'implémentation 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 implémenter 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. Implémentez 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 l'utilisation de 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 moins exhaustives suivantes :

• Assurez-vous de tirer le meilleur parti de vos prompts et d'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 gère des tâches incroyablement variées, vous pourriez envisager d'ajouter un classificateur d'intention distinct pour router la requête client initiale. Pour l'application existante, cela impliquerait de créer un arbre de décision qui routerait les requêtes 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 API : développez un wrapper 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 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 : l'implémentation de la mise en cache peut améliorer les temps de réponse et réduire les appels API inutiles.
   • Rétention du contexte : maintenir le contexte lorsqu'un utilisateur quitte la page et revient est important pour la continuité des conversations.

2. Construire une interface web : implémentez une interface web conviviale pour interagir avec l'agent propulsé par Claude.



Prochaines étapes