Chatgeschiedenis voor AI-toepassingen met Azure Cosmos DB Go SDK

Deze blogpost behandelt hoe je een chatgeschiedenisimplementatie kunt bouwen met behulp van Azure Cosmos DB voor NoSQL Go SDK en LangChainGo. Als je nieuw bent met de Go SDK, dient de voorbeeldchatbottoepassing die in de blog wordt gepresenteerd als een praktische kennismaking, waarbij basisbewerkingen zoals lezen, upsert, enz. worden behandeld. Het toont ook het gebruik van de op Linux gebaseerde emulator van Azure Cosmos DB (op het moment van schrijven in preview) voor integratietests met Testcontainers voor Go.

Go-ontwikkelaars die AI-toepassingen willen bouwen, kunnen gebruikmaken van LangChainGo, dat een framework is voor LLM-aangedreven toepassingen. Het biedt insteekbare API’s voor componenten zoals vectoropslag, insluiting, het laden van documenten, ketens (voor het samenstellen van meerdere bewerkingen), chatgeschiedenis en meer.

Voordat we dieper ingaan, laten we een stap terug doen om de basisprincipes te begrijpen.

Wat is chatgeschiedenis en waarom is het belangrijk voor moderne AI-toepassingen?

Een veelvoorkomende vereiste voor conversatie-AI-toepassingen is het kunnen opslaan en ophalen van berichten die zijn uitgewisseld als onderdeel van gesprekken. Dit wordt vaak aangeduid als “chatgeschiedenis.” Als je toepassingen zoals ChatGPT hebt gebruikt (die overigens ook Azure Cosmos DB gebruikt!), ben je mogelijk bekend met dit concept.

Wanneer een gebruiker inlogt, kunnen ze beginnen met chatten en worden de uitgewisselde berichten als onderdeel van het gesprek opgeslagen. Wanneer ze opnieuw inloggen, kunnen ze hun vorige gesprekken zien en verder gaan waar ze gebleven waren.

Chatgeschiedenis is uiteraard belangrijk voor eindgebruikers van de toepassing, maar laten we de LLM’s niet vergeten! Hoe slim LLM’s ook lijken, ze kunnen zich geen eerdere interacties herinneren vanwege een gebrek aan ingebouwd geheugen (althans voor nu). Door gebruik te maken van de chatgeschiedenis wordt deze kloof overbrugd door eerdere gesprekken te bieden als aanvullende context, waardoor LLM’s meer relevante en kwalitatief hoogwaardige antwoorden kunnen genereren. Dit verbetert de natuurlijke stroom van gesprekken en verbetert aanzienlijk de gebruikerservaring.

Een eenvoudig voorbeeld illustreert dit: Stel dat je aan een LLM via een API vraagt: “Vertel me over Azure Cosmos DB,” en het antwoordt met een lang alinea. Als je vervolgens een andere API-oproep doet met de vraag: “Maak hier puntsgewijs van voor gemakkelijker lezen,” dan kan de LLM in de war raken omdat het de context van de vorige interactie mist.

Als je echter het eerdere bericht opneemt als onderdeel van de context in de tweede API-oproep, is de LLM waarschijnlijk meer geneigd een nauwkeurig antwoord te geven (hoewel niet gegarandeerd, aangezien LLM-uitvoer inherent niet-deterministisch is).

Hoe de chatbot uit te voeren

Zoals eerder vermeld, is de voorbeeldtoepassing een nuttige manier voor jou om langchaingo, de implementatie van de Azure Cosmos DB-chatgeschiedenis, en de Go SDK te verkennen.

Voordat je de implementatiedetails gaat verkennen, is het een goed idee om de toepassing in actie te zien. Bekijk de README-sectie van de GitHub-opslagplaats, waar instructies worden gegeven over hoe je de chatbot kunt configureren, uitvoeren en starten met chatten.

Overzicht van de toepassing

De chattoepassing volgt een eenvoudig domeinmodel: gebruikers kunnen meerdere gesprekken starten en elk gesprek kan meerdere berichten bevatten. De toepassing is gebouwd in Go en omvat zowel backend- als frontendcomponenten.

Backend

Het heeft meerdere subonderdelen:

• De implementatie van de Azure Cosmos DB-chatgeschiedenis.
• Kernbewerkingen zoals het starten van een chat, het verzenden/ontvangen van berichten en het ophalen van de chatgeschiedenis worden blootgesteld via een REST API.
• De REST API maakt gebruik van een langchaingo-keten om gebruikersberichten te verwerken. De keten neemt automatisch chatgeschiedenis op om ervoor te zorgen dat eerdere gesprekken naar de LLM worden verzonden. langchaingo behandelt alle orchestratie – LLM-oproep, inclusie van chatgeschiedenis, en meer zonder handmatige implementatie vereisen.

Front-end

Het is gebouwd met behulp van JavaScript, HTML en CSS. Het is verpakt als onderdeel van de Go webserver (met behulp van het embed-pakket) en roept de back-end REST API’s aan als reactie op gebruikersinteracties.

Chatgeschiedenisimplementatie met behulp van Azure Cosmos DB

LangChainGo is een inplugbaar framework, inclusief zijn chatgeschiedenis (of geheugen) component. Om Azure Cosmos DB te integreren, moet je de schema.ChatMessageHistory-interface implementeren, die methoden biedt om de chatgeschiedenis te beheren:

• AddMessage om berichten toe te voegen aan een gesprek (of een nieuw gesprek te starten).
• Berichten om alle berichten voor een gesprek op te halen.
• Wis om alle berichten in een gesprek te verwijderen.

Hoewel je direct een instantie van CosmosDBChatMessageHistory kunt maken en deze methoden kunt gebruiken, is de aanbevolen aanpak om het te integreren in de langchaingo-applicatie. Hieronder volgt een voorbeeld van het gebruik van Azure Cosmos DB-chatgeschiedenis met een LLMChain:

// Maak een instantie van de chatgeschiedenis aan
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
}

// Maak een geheugen aan met de chatgeschiedenis
chatMemory := memory.NewConversationBuffer(
    memory.WithMemoryKey("chat_history"),
    memory.WithChatHistory(cosmosChatHistory),
)

// Maak een LLM-keten aan
chain := chains.LLMChain{
    Prompt:       promptsTemplate,
    LLM:          llm,
    Memory:       chatMemory,
    OutputParser: outputparser.NewSimple(),
    OutputKey:    "text",
}

Vanuit het oogpunt van Azure Cosmos DB is het belangrijk op te merken dat de implementatie in dit voorbeeld slechts een van de vele mogelijke opties is. Het hier getoonde is gebaseerd op een combinatie van de gebruikers-ID als partitiesleutel en de conversatie-ID (soms ook wel sessie-ID genoemd) als unieke sleutel (id van een item in Azure Cosmos DB).

Dit maakt het voor een applicatie mogelijk om:

• Alle berichten voor een gesprek op te halen. Dit is een puntleesbewerking met behulp van de unieke ID (conversatie-ID) en partitiesleutel (gebruikers-ID).
• Voeg een nieuw bericht toe aan een gesprek. Het maakt gebruik van een upsert-operatie (in plaats van create) om de noodzaak voor een read voor schrijven te vermijden.
• Verwijder een specifiek gesprek. Het maakt gebruik van de delete-operatie om een gesprek (en al zijn berichten) te verwijderen.

Hoewel de langchaingo-interface dit niet blootstelt, kun je bij het integreren ervan als onderdeel van een toepassing ook een aparte query uitvoeren om alle gesprekken voor een gebruiker te krijgen. Dit is ook efficiënt omdat het beperkt is tot een enkele partitie.

Vereenvoudig Testen Met Azure Cosmos DB Emulator en Testcontainers

De voorbeeldtoepassing bevat basis testgevallen voor zowel de Azure Cosmos DB chatgeschiedenis als de hoofdtoepassing. Het is de moeite waard om het gebruik van testcontainers-go te benadrukken om de Linux-gebaseerde emulator van Azure Cosmos DB docker container te integreren.

Dit is geweldig voor integratietests omdat de database lokaal beschikbaar is en de tests veel sneller worden uitgevoerd (laten we de kostenbesparingen niet vergeten!). Het mooie is dat u de levenscyclus van de Docker-container niet handmatig hoeft te beheren. Dit wordt verzorgd als onderdeel van de test suite, dankzij de testcontainers-go API die het handig maakt om de container te starten voordat de tests worden uitgevoerd en deze te beëindigen zodra ze zijn voltooid.

U kunt de testgevallen in de voorbeeldtoepassing raadplegen voor meer details. Hier is een voorbeeld van hoe testcontainers-go wordt gebruikt:

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)
    }

    // Geef de emulator wat meer tijd om volledig te initialiseren
    time.Sleep(5 * time.Second)

    return container, nil
}

Als u geïnteresseerd bent in het gebruik van de Azure Cosmos DB Emulator in CI-pipelines, bekijk dan de blogpost.

Samenvatting

Het kunnen opslaan van chatgeschiedenis is een belangrijk onderdeel van conversatie AI-apps. Ze kunnen dienen als een geweldige toevoeging aan bestaande technieken zoals RAG (retrieval-augmented generation). Probeer de chatbot-applicatie uit en laat ons weten wat je ervan vindt!

Hoewel de implementatie in de voorbeeldapplicatie relatief eenvoudig is, hangt de manier waarop je de chatgeschiedenisdata modelleert af van de vereisten. Een dergelijk scenario dat is gepresenteerd, is deze uitstekende blogpost over hoe Microsoft Copilot schaalt naar miljoenen gebruikers met Azure Cosmos DB.

Enkele van je vereisten kunnen zijn:

• Opslaan van metadata, zoals reacties (naast berichten)
• Weergeven van de N meest recente berichten
• Rekening houden met de retentieperiode van chatgeschiedenisdata (gebruikmakend van TTL)
• Toevoegen van extra analyses (op gebruikersinteracties) gebaseerd op de chatgeschiedenisdata en meer.

Ongeacht de implementatie, zorg er altijd voor dat je de beste praktijken voor datamodellering opneemt. Raadpleeg hier voor richtlijnen.

Gebruik je al Azure Cosmos DB voor je Go-toepassingen of ben je van plan dit te doen? We horen graag van je! Stuur ons je vragen en feedback.