MemX × Kova × Lurus API

Créer un agent SAV IA avec mémoire

Objectif : en 30 minutes, faire tourner un agent SAV capable de se souvenir des questions passées de l’utilisateur, de récupérer automatiquement après un crash et de distiller les connaissances à la demande.

30 minutesObjectif de mise en route

6 étapesDes dépendances à la réécriture

3 servicesMemX · Kova · API

Schéma d’architecture

Chacun des trois services a son rôle : MemX gère le rappel et la distillation de la mémoire longue durée, Lurus API gère les appels au LLM, et Kova WAL gère la persistance de l’état et la récupération après crash.

Architecture d’un agent SAV IA avec mémoire

graph LR
  U[Utilisateur] --> W[Frontend Web]
  W -->|HTTP| A[Agent App]
  A -->|1. Rappel| M[MemX]
  A -->|2. LLM| L[Lurus API]
  A -->|3. État| K[Kova WAL]
  A -->|4. Écriture| M
  L --> A
  M --> A

Les 6 étapes

1. Préparer les dépendances

   pip install lurus memx-client kova-py lumen-ai openai

2. Initialiser les trois services

   from openai import OpenAI
   from memx import Memory
   from kova import KovaClient
   
   llm = OpenAI(base_url="https://hub.lurus.cn/v1", api_key="sk-...")
   mem = Memory(config={"ace_enabled": True})
   kova = KovaClient("kova://localhost")

3. Définir l’état de l’agent

   from typing import TypedDict, Annotated, Sequence
   
   class State(TypedDict):
       user_id: str
       messages: Annotated[Sequence, "chat history"]
       relevant_memory: list

4. Rappeler l’historique — récupérer depuis MemX les souvenirs liés à la question courante

   def retrieve_memory(state: State) -> State:
       last = state["messages"][-1]["content"]
       hits = mem.search(last, user_id=state["user_id"], limit=5)
       return {**state, "relevant_memory": hits}

5. Appeler le LLM et répondre — injecter les faits rappelés dans le system prompt

   def respond(state: State) -> State:
       context = "\n".join(h["text"] for h in state["relevant_memory"])
       resp = llm.chat.completions.create(
           model="deepseek-chat",
           messages=[
               {"role": "system", "content": f"已知事实:\n{context}"},
               *state["messages"],
           ],
       )
       reply = resp.choices[0].message.content
       return {**state, "messages": [*state["messages"], {"role": "assistant", "content": reply}]}

6. Distiller et réécrire — réécrire le nouveau dialogue dans MemX, prêt pour le prochain rappel

   def distill(state: State) -> State:
       mem.add(
           list(state["messages"][-2:]),
           user_id=state["user_id"],
           scope="support:general",
       )
       return state

Ajouter la récupération après crash avec Kova

Branchez Kova comme checkpointer de LangGraph : après un crash, l’agent reprend depuis le WAL sans rappeler le LLM :

from kova.langgraph import KovaCheckpointer

graph = wf.compile(checkpointer=KovaCheckpointer(kova))

Pourquoi ne pas rappeler le LLM

Kova écrit un journal en écriture anticipée (WAL) à chaque étape. Après un crash du processus, le moteur rejoue l’état d’exécution depuis le point d’arrêt : les appels LLM déjà effectués ne sont pas réémis — cela économise des tokens et garantit la cohérence des réponses.

Projet complet livré

Dépôt d’exemple

https://github.com/hanmahong5-arch/lurus-examples/tree/main/memory-agent — code complet, docker-compose.yml (MemX + Kova en local), tests Pytest couvrant les trois nœuds, .env.example.

Étapes suivantes

Étapes suivantes

Ajouter l’observabilité avec LumenApprofondir les concepts de MemXDéployer sur un cluster Kova