MemX × Kova × Lurus API

Crea un agente de soporte con memoria

Objetivo: poner en marcha en 30 minutos un agente de soporte que recuerde el historial de preguntas del usuario, se recupere automáticamente tras un fallo y destile conocimiento bajo demanda.

30 minutosObjetivo de puesta en marcha

6 pasosDe las dependencias a la reescritura

3 serviciosMemX · Kova · API

Diagrama de arquitectura

Cada uno de los tres servicios cumple su función: MemX se encarga de la recuperación y destilación de la memoria a largo plazo, Lurus API gestiona las llamadas al LLM y Kova WAL se ocupa de la persistencia del estado y la recuperación ante fallos.

Arquitectura del agente de soporte con memoria

graph LR
  U[Usuario] --> W[Frontend web]
  W -->|HTTP| A[Agent App]
  A -->|1. Recuperar| M[MemX]
  A -->|2. LLM| L[Lurus API]
  A -->|3. Estado| K[Kova WAL]
  A -->|4. Escribir| M
  L --> A
  M --> A

6 pasos

1. Preparar las dependencias

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

2. Inicializar los tres servicios

   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. Definir el estado del agente

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

4. Recuperar el historial — obtén de MemX los recuerdos relacionados con la pregunta actual

   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. Llamar al LLM y responder — inyecta los hechos recuperados en el 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. Destilar y reescribir — vuelve a escribir la nueva conversación en MemX para que esté disponible en la próxima recuperación

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

Añadir recuperación ante fallos con Kova

Conecta Kova como checkpointer de LangGraph: tras un fallo, el agente se recupera desde el WAL sin volver a llamar al LLM:

from kova.langgraph import KovaCheckpointer

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

Por qué no se vuelve a llamar al LLM

Kova escribe un registro de escritura anticipada (WAL) en cada paso. Tras un fallo del proceso, el motor reproduce el estado de ejecución desde el punto de interrupción y las llamadas al LLM ya completadas no se vuelven a emitir: así se ahorran tokens y se garantiza la consistencia de las respuestas.

Artefactos completos del proyecto

Repositorio de ejemplo

https://github.com/hanmahong5-arch/lurus-examples/tree/main/memory-agent — incluye la versión completa del código, docker-compose.yml (levanta MemX + Kova en local), Pytest que cubre los tres nodos y .env.example.

Siguientes pasos

Próximos pasos

Añadir observabilidad con LumenProfundizar en los conceptos de MemXDesplegar en un clúster de Kova