LangSmith + Kronvex: Adding Persistent Memory to Your LangChain Observability Stack

import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from kronvex import Kronvex

# LangSmith tracing is enabled via environment variables
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "your-langsmith-api-key"
os.environ["LANGCHAIN_PROJECT"] = "my-agent-with-memory"

# Kronvex client
kv = Kronvex(api_key="kv-your-api-key")

llm = ChatOpenAI(model="gpt-4o", temperature=0)
output_parser = StrOutputParser()

def run_agent(user_id: str, user_message: str) -> str:
    agent = kv.agent(user_id)

    # 1. Retrieve relevant memories (semantic search, top 5)
    context = agent.inject_context(user_message, top_k=5)

    # 2. Build prompt with injected memory
    prompt = ChatPromptTemplate.from_messages([
        ("system", """You are a helpful B2B assistant.

{memory_context}

Use the above context to personalize your response. If no context is
provided, respond normally."""),
        ("human", "{user_message}")
    ])

    # 3. Build and run chain — LangSmith traces this automatically
    chain = prompt | llm | output_parser
    response = chain.invoke({
        "memory_context": context or "No prior context available.",
        "user_message": user_message
    })

    # 4. Extract and store key facts from this interaction
    # In production, you'd use an LLM to extract facts selectively
    # Here we store the user message as a simple example
    if len(user_message) > 20:  # skip trivial messages
        agent.remember(f"User said: {user_message}")

    return response


# Usage
response = run_agent("user_42", "We're migrating to PostgreSQL next quarter")
print(response)

# Next run — agent will remember the PostgreSQL migration
response2 = run_agent("user_42", "What database should I use for this new service?")
print(response2)  # Will reference PostgreSQL migration context

from langchain_core.prompts import PromptTemplate

EXTRACT_FACTS_PROMPT = PromptTemplate.from_template("""
Extract key facts worth remembering from this conversation.
Return a JSON list of strings. Return an empty list [] if nothing is worth storing.
Only extract facts about the user's context, preferences, or plans — not general knowledge.

User message: {user_message}
Assistant response: {assistant_response}

Facts (JSON list):
""")

def extract_and_store_facts(agent, user_message: str, response: str):
    chain = EXTRACT_FACTS_PROMPT | llm | output_parser
    raw = chain.invoke({
        "user_message": user_message,
        "assistant_response": response
    })
    import json
    try:
        facts = json.loads(raw.strip())
        for fact in facts:
            if fact.strip():
                agent.remember(fact)
    except json.JSONDecodeError:
        pass  # LLM didn't return valid JSON, skip

from langsmith import Client
from langsmith.evaluation import evaluate, LangChainStringEvaluator

ls_client = Client()

# Create an eval dataset: questions that require prior context to answer well
eval_dataset = ls_client.create_dataset("memory-quality-evals")
ls_client.create_examples(
    inputs=[
        {"user_id": "eval_user_1", "message": "What database did I say we're migrating to?"},
        {"user_id": "eval_user_1", "message": "What's our tech stack preference?"},
        {"user_id": "eval_user_2", "message": "What project were we discussing last time?"},
    ],
    outputs=[
        {"expected": "PostgreSQL"},
        {"expected": "Python, FastAPI"},
        {"expected": "The CRM integration project"},
    ],
    dataset_id=eval_dataset.id
)

# Seed memories for eval users
kv.agent("eval_user_1").remember("We are migrating our database to PostgreSQL next quarter")
kv.agent("eval_user_1").remember("Our tech stack is Python with FastAPI")
kv.agent("eval_user_2").remember("We are working on a CRM integration project")

# Define the chain to evaluate
def agent_with_memory(inputs):
    return {"output": run_agent(inputs["user_id"], inputs["message"])}

# Run evaluation
results = evaluate(
    agent_with_memory,
    data=eval_dataset.name,
    evaluators=[LangChainStringEvaluator("qa")],
    experiment_prefix="memory-injection-v1"
)
print(results)

# LangSmith
LANGCHAIN_TRACING_V2=true
LANGCHAIN_API_KEY=ls__your_key
LANGCHAIN_PROJECT=your-project-name
LANGCHAIN_ENDPOINT=https://api.smith.langchain.com

# Kronvex
KRONVEX_API_KEY=kv-your_key

# OpenAI (used by both LangChain and Kronvex for embeddings)
OPENAI_API_KEY=sk-your_key

import asyncio
from kronvex import AsyncKronvex

async_kv = AsyncKronvex(api_key="kv-your-key")

async def handle_message(user_id: str, message: str) -> str:
    agent = async_kv.agent(user_id)

    # Memory recall blocks (we need the context before calling LLM)
    context = await agent.inject_context(message, top_k=5)

    # ... build prompt, call LLM ...
    response = "LLM response here"

    # Memory write is fire-and-forget — don't await, don't block
    asyncio.create_task(agent.remember(f"User said: {message}"))

    return response

from langchain_core.callbacks import collect_runs

memories = agent.recall(user_message, top_k=5)

with collect_runs() as cb:
    response = chain.invoke({...})
    # Tag the run with memory count
    run_id = cb.traced_runs[0].id
    ls_client.create_feedback(
        run_id,
        key="memory_count",
        score=len(memories)
    )