Historique des discussions pour les applications IA avec le SDK Go d’Azure Cosmos DB

Ce billet de blog couvre comment construire une implémentation de l’historique de chat en utilisant Azure Cosmos DB pour le SDK NoSQL Go et LangChainGo. Si vous êtes nouveau dans le SDK Go, l’application chatbot d’exemple présentée dans le blog sert d’introduction pratique, couvrant des opérations de base telles que la lecture, l’upsert, etc. Il démontre également l’utilisation de l’émulateur Azure Cosmos DB basé sur Linux (en version de prévisualisation au moment de la rédaction) pour des tests d’intégration avec Testcontainers pour Go.

Les développeurs Go souhaitant créer des applications d’IA peuvent utiliser LangChainGo, qui est un framework pour les applications alimentées par LLM. Il fournit des API plug-in pour des composants tels que le magasin de vecteurs, l’incorporation, le chargement de documents, les chaînes (pour composer plusieurs opérations), l’historique de chat, et plus encore.

Avant de plonger, prenons du recul pour comprendre les bases.

Qu’est-ce que l’historique de chat, et pourquoi est-il important pour les applications d’IA modernes?

Une exigence courante pour les applications d’IA conversationnelle est de pouvoir stocker et récupérer des messages échangés dans le cadre de conversations. On parle souvent de « historique de chat. » Si vous avez utilisé des applications comme ChatGPT (qui utilise également Azure Cosmos DB, d’ailleurs!), vous êtes peut-être familier avec ce concept.

Lorsqu’un utilisateur se connecte, il peut commencer à discuter, et les messages échangés dans le cadre de la conversation sont enregistrés. Lorsqu’ils se reconnectent, ils peuvent voir leurs conversations précédentes et reprendre là où ils se sont arrêtés.

L’historique des discussions est évidemment important pour les utilisateurs finaux de l’application, mais n’oublions pas les LLMs ! Aussi intelligents que puissent paraître les LLMs, ils ne peuvent pas se rappeler des interactions passées en raison d’un manque de mémoire intégrée (du moins pour l’instant). L’utilisation de l’historique des discussions comble cette lacune en fournissant les conversations précédentes comme contexte supplémentaire, permettant aux LLMs de générer des réponses plus pertinentes et de haute qualité. Cela améliore le déroulement naturel des conversations et améliore significativement l’expérience utilisateur.

Un exemple simple illustre ceci : Supposez que vous demandiez à un LLM via une API, « Parlez-moi d’Azure Cosmos DB, » et qu’il réponde avec un long paragraphe. Si vous faites ensuite un autre appel API en disant, « Présentez ceci sous forme de points pour une lecture plus facile, » le LLM pourrait être confus car il lui manque le contexte de l’interaction précédente.

Cependant, si vous incluez le message précédent comme partie du contexte dans le second appel API, le LLM est plus susceptible de fournir une réponse précise (bien que non garantie, car les sorties des LLM sont intrinsèquement non déterministes).

Comment exécuter le Chatbot

Comme je l’ai mentionné précédemment, l’application d’exemple est un moyen utile pour explorer langchaingo, l’implémentation de l’historique de chat Azure Cosmos DB, ainsi que le Go SDK.

Avant d’explorer les détails de l’implémentation, il est bon de voir l’application en action. Reportez-vous à la section README du dépôt GitHub, qui fournit des instructions sur la configuration, l’exécution et le démarrage de la conversation avec le chatbot.

Aperçu de l’application

L’application de chat suit un modèle de domaine simple : les utilisateurs peuvent initier plusieurs conversations, et chaque conversation peut contenir plusieurs messages. Construite en Go, l’application comprend à la fois des composants backend et frontend.

Backend

Il comporte plusieurs sous-parties :

• L’implémentation de l’historique de chat Azure Cosmos DB.
• Les opérations de base telles que le démarrage d’une conversation, l’envoi/réception de messages et la récupération de l’historique des conversations sont exposées via une API REST.
• L’API REST utilise une chaîne langchaingo pour gérer les messages des utilisateurs. La chaîne intègre automatiquement l’historique des discussions afin de garantir que les conversations passées sont envoyées au LLM. langchaingo gère toute l’orchestration – invocation du LLM, inclusion de l’historique des discussions, et plus encore sans nécessiter d’implémentation manuelle.

Frontend

Il est construit en utilisant JavaScript, HTML, et CSS. Il est intégré dans le serveur web Go (en utilisant le package embed) et invoque les API REST backend en réponse aux interactions des utilisateurs.

Mise en œuvre de l’historique des discussions utilisant Azure Cosmos DB

LangChainGo est un framework modulable, incluant son composant d’historique des discussions (ou mémoire). Pour intégrer Azure Cosmos DB, vous devez implémenter l’interface schema.ChatMessageHistory, qui fournit des méthodes pour gérer l’historique des discussions :

• AddMessage pour ajouter des messages à une conversation (ou en commencer une nouvelle).
• Messages pour récupérer tous les messages d’une conversation.
• Clear pour supprimer tous les messages d’une conversation.

Bien que vous puissiez instancier directement une instance de CosmosDBChatMessageHistory et utiliser ces méthodes, l’approche recommandée est de l’intégrer dans l’application langchaingo. Voici un exemple d’utilisation de l’historique de chat Azure Cosmos DB avec un LLMChain:

// Créer une instance d'historique de chat
cosmosChatHistory, err := cosmosdb.NewCosmosDBChatMessageHistory(cosmosClient, databaseName, containerName, req.SessionID, req.UserID)
if err != nil {
    log.Printf("Error creating chat history: %v", err)
    sendErrorResponse(w, "Failed to create chat session", http.StatusInternalServerError)
    return
}

// Créer une mémoire avec l'historique de chat
chatMemory := memory.NewConversationBuffer(
    memory.WithMemoryKey("chat_history"),
    memory.WithChatHistory(cosmosChatHistory),
)

// Créer une chaîne LLM
chain := chains.LLMChain{
    Prompt:       promptsTemplate,
    LLM:          llm,
    Memory:       chatMemory,
    OutputParser: outputparser.NewSimple(),
    OutputKey:    "text",
}

En ce qui concerne Azure Cosmos DB, notez que l’implémentation dans cet exemple n’est qu’une parmi de nombreuses options possibles. Celle montrée ici est basée sur une combinaison de l’ID utilisateur comme clé de partition et l’ID de conversation (également appelé parfois ID de session) comme clé unique (id d’un élément Azure Cosmos DB).

Cela permet à une application de:

• Obtenir tous les messages pour une conversation. Il s’agit d’une lecture ponctuelle en utilisant l’ID unique (ID de conversation) et la clé de partition (ID utilisateur).
• Ajoutez un nouveau message à une conversation. Cela utilise une opération upsert (au lieu de create) pour éviter la nécessité d’une read avant l’écriture.
• Supprimez une conversation spécifique. Cela utilise l’opération delete pour supprimer une conversation (et tous ses messages).

Bien que l’interface langchaingo ne l’expose pas, lors de l’intégration de cela dans le cadre d’une application, vous pouvez également émettre une requête séparée pour obtenir toutes les conversations d’un utilisateur. Cela est également efficace car c’est limité à une seule partition.

Simplifiez les tests avec Azure Cosmos DB Emulator et Testcontainers

L’application de démonstration comprend des cas de test de base pour l’historique de chat Azure Cosmos DB et l’application principale. Il convient de souligner l’utilisation de testcontainers-go pour intégrer le conteneur Docker émulateur Azure Cosmos DB basé sur Linux.

C’est idéal pour les tests d’intégration car la base de données est disponible localement et les tests s’exécutent beaucoup plus rapidement (sans oublier les économies de coûts également!). La cerise sur le gâteau est que vous n’avez pas besoin de gérer manuellement le cycle de vie du conteneur Docker. Cela est pris en charge dans le cadre de la suite de tests, grâce à l’API testcontainers-go qui facilite le démarrage du conteneur avant l’exécution des tests et sa terminaison une fois qu’ils sont terminés.

Vous pouvez consulter les cas de test dans l’application de démonstration pour plus de détails. Voici un extrait de la façon dont testcontainers-go est utilisé :

func setupCosmosEmulator(ctx context.Context) (testcontainers.Container, error) {
    req := testcontainers.ContainerRequest{
        Image:        emulatorImage,
        ExposedPorts: []string{emulatorPort + ":8081", "1234:1234"},
        WaitingFor:   wait.ForListeningPort(nat.Port(emulatorPort)),
    }

    container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
        ContainerRequest: req,
        Started:         true,
    })
    if err != nil {
        return nil, fmt.Errorf("failed to start container: %w", err)
    }

    // Donnez à l'émulateur un peu plus de temps pour s'initialiser complètement
    time.Sleep(5 * time.Second)

    return container, nil
}

Si vous êtes intéressé par l’utilisation de l’émulateur Azure Cosmos DB dans des pipelines CI, consultez le billet de blog.

Conclusion

Pouvoir stocker l’historique des conversations est une partie importante des applications AI conversationnelles. Elles peuvent servir de complément idéal aux techniques existantes telles que RAG (génération augmentée par récupération). N’hésitez pas à essayer l’application de chatbot et à nous faire part de vos impressions !

Bien que l’implémentation dans l’application d’exemple soit relativement simple, la façon dont vous modélisez les données de l’historique des conversations dépend des exigences. Un tel scénario qui a été présenté est ce superbe article de blog sur la façon dont Microsoft Copilot passe à l’échelle pour des millions d’utilisateurs avec Azure Cosmos DB.

Certaines de vos exigences pourraient inclure :

• Stocker des métadonnées, telles que les réactions (en plus des messages)
• Afficher les N messages récents les plus importants
• Tenir compte de la période de conservation des données de l’historique des conversations (en utilisant TTL)
• Incorporer des analyses supplémentaires (sur les interactions des utilisateurs) basées sur les données de l’historique des conversations et plus encore.

Indépendamment de l’implémentation, assurez-vous toujours d’incorporer les meilleures pratiques pour la modélisation des données. Consultez ici pour des directives.

Utilisez-vous déjà ou prévoyez-vous d’utiliser Azure Cosmos DB pour vos applications Go ? Nous aimerions avoir de vos nouvelles ! Envoyez-nous vos questions et vos retours.