Agent Memory, Persistent Private On-Device Memory for .NET Agents, LM-Kit

Why memory matters

Stateless agents forget. Yours won't.

Most AI agents treat every conversation as their first. They forget user preferences, lose track of project context, and repeat the same questions. Agent memory solves this by giving your agents persistent, structured recall that survives across sessions.

From stateless to stateful in one API

LM-Kit's AgentMemory integrates directly with MultiTurnConversation and the Agent framework. Memory is RAG-backed, KV-cache aware, and designed for production multi-user deployments.

Automatic learning

The agent extracts facts, events, and procedures from every conversation turn without manual intervention.

Private by design

All memory storage and retrieval runs 100% on-device. No data leaves your infrastructure. HIPAA and GDPR ready.

Persistent across sessions

Serialize memory to disk and restore it at any time. Share memory states between agents and deployments.

Without agent memory

Agent asks the same onboarding questions every session
User preferences lost after every restart
Document processing agents forget previous analysis results
No personalization across multi-user deployments
Cloud memory services leak sensitive data and add latency

LM-Kit Agent Memory

Persistent, private, structured memory that lives on your hardware. Three memory types, automatic extraction, smart consolidation, and multi-user isolation out of the box.

Memory types

Three types of memory, one unified API.

Modeled after human cognitive memory. Each type serves a distinct purpose, enabling agents to store the right kind of knowledge in the right way.

Type 01 · Facts & knowledge

Semantic memory

General knowledge, facts, and definitions that remain true over time. The foundation for grounded, accurate responses. User profiles, product catalogs, domain expertise, and configuration details.

User preferences Product specs Domain rules Contact info

Type 02 · Events & interactions

Episodic memory

Specific events, interactions, and experiences anchored in time. Enables agents to reference past conversations and track evolving situations. Support tickets, project milestones, and conversation history.

Past conversations Meeting notes Support tickets Project events

Type 03 · How-to & workflows

Procedural memory

Learned processes, workflows, and step-by-step procedures. Enables agents to remember how users like things done. Runbooks, deployment checklists, troubleshooting guides, and personal routines.

Deployment steps Approval flows User routines Troubleshooting

Learn more about AI Agent Memory in the Glossary →

Capabilities

Everything for production memory.

From automatic learning to enterprise-grade capacity management. Every feature you need to ship memory-powered agents at scale.

Capability New

Automatic extraction

LLM-based fact extraction classifies memories by type and importance. Deduplication via vector similarity prevents redundant entries.

Capability New

Memory consolidation

LLM-powered clustering merges semantically similar memories into concise summaries. Reduces storage while preserving knowledge.

Capability New

Time-decay scoring

Exponential decay ensures recent memories rank higher in retrieval. Configurable half-life from hours to months.

Capability New

Multi-user isolation

UserScopedMemory namespaces data by user ID. One shared store, fully isolated retrieval, per-user cleanup.

Capability New

Capacity & eviction

Set maximum entries and choose eviction policies: oldest first, lowest importance first, or a combined strategy. Cancel evictions via events.

Capability

Serialize & restore

Persist memory to binary files and reload across sessions, deployments, and machines. Share memory states between agents.

Code examples

Memory in five lines of code.

Add persistent memory to any agent or conversation. Automatic extraction, consolidation, multi-user scoping, and persistence are all configured through simple properties.

BasicMemory.cs

using LMKit.Model;
using LMKit.Agents;
using LMKit.TextGeneration;

// Load models
var chatModel  = LM.LoadFromModelID("qwen3.5:9b");
var embedModel = LM.LoadFromModelID("qwen3-embedding:0.6b");

// Create memory and store facts
var memory = new AgentMemory(embedModel);
await memory.SaveInformationAsync("profile", "User prefers dark mode", "prefs");
await memory.SaveInformationAsync("profile", "User's name is Sarah", "name");

// Attach to conversation - auto-recalled
var chat = new MultiTurnConversation(chatModel) {
    Memory = memory
};
var r = chat.Submit("What do you know about me?");
// Recalls: "Your name is Sarah and you prefer dark mode."

AutoExtraction.cs

// Enable automatic fact extraction from conversations
var memory = new AgentMemory(embedModel) {
    ExtractionMode = MemoryExtractionMode.LlmBased,
    ExtractionModel = chatModel,
    MaxExtractionsPerTurn = 5,
    DeduplicationThreshold = 0.85f
};

// Inspect what gets extracted before storage
memory.BeforeMemoryStored += (sender, e) => {
    foreach (var m in e.Memories)
        Console.WriteLine($"[{m.MemoryType}] {m.Text}");
};

var chat = new MultiTurnConversation(chatModel) {
    Memory = memory
};

// Every turn, agent auto-extracts and stores memories
chat.Submit("I'm working on the Acme project. I prefer TypeScript.");
// Extracted: [Semantic] User prefers TypeScript
// Extracted: [Episodic] User is working on the Acme project

MultiUser.cs

using LMKit.Agents.Memory;

// Shared memory store for all users
var sharedMemory = new AgentMemory(embedModel);

// User-scoped views - data is fully isolated
var aliceMemory = new UserScopedMemory(sharedMemory, "alice");
var bobMemory   = new UserScopedMemory(sharedMemory, "bob");

// Store per-user data
await aliceMemory.SaveInformationAsync("prefs", "Prefers dark mode", "theme");
await bobMemory.SaveInformationAsync("prefs", "Prefers light mode", "theme");

// Apply user scope - only their data is recalled
aliceMemory.ApplyFilter();
var chat = new MultiTurnConversation(chatModel) {
    Memory = sharedMemory
};

// Persist all users in a single file
sharedMemory.Serialize("all_users_memory.bin");

FullLifecycle.cs

// Full lifecycle: extraction, capacity, decay, consolidation
var memory = new AgentMemory(embedModel) {
    ExtractionMode = MemoryExtractionMode.LlmBased,
    ExtractionModel = chatModel,
    MaxMemoryEntries = 500,
    EvictionPolicy = MemoryEvictionPolicy.OldestLowestImportanceFirst,
    TimeDecayHalfLife = TimeSpan.FromDays(30)
};

// Consolidate similar memories into concise summaries
memory.ConsolidationSimilarityThreshold = 0.7f;
var result = await memory.ConsolidateAsync(chatModel);
Console.WriteLine($"Merged {result.ClustersMerged} clusters, " +
                  $"freed {result.EntriesRemoved} entries");

// Summarize a conversation into episodic memory
var summary = await memory.SummarizeConversationAsync(
    chat.ChatHistory, chatModel);

// Persist and restore
memory.Serialize("agent_memory.bin");
var restored = AgentMemory.Deserialize("agent_memory.bin", embedModel);

Demos & samples

See memory in action.

Runnable samples that demonstrate every memory capability. Clone, build, and ship.

Memory

Persistent memory assistant

Full-featured demo showcasing auto-extraction, capacity limits, eviction, consolidation, conversation summarization, time-decay, and persistence.

Memory

Multi-turn chat with memory

Side-by-side comparison: conversations with and without memory. Pre-built customer profile with semantic recall.

RAG

RAG chatbot

Chat with eBooks, PDFs, and documents using retrieval-augmented generation. The foundation of memory-powered document intelligence.

Session

Persistent session

Save and restore full conversation state to disk. Resume sessions across application restarts with full context.

Agent

Research assistant

ReAct planning agent with web search. Combine memory with reasoning and tools for complex multi-step research tasks.

Integration

Semantic Kernel + memory

LM-Kit.NET as the LLM backend for Microsoft Semantic Kernel with persistent memory integration.

All samples GitHub repository

How-to guides

Step-by-step implementation guides.

Detailed walkthroughs covering every aspect of agent memory, from basic setup to advanced production patterns.

GuideUse Agent Memory for long-term knowledge GuideEnable automatic memory extraction GuideBuild a conversational assistant with memory GuideSave and restore conversation sessions GuideBuild a RAG pipeline over your documents GuideBuild semantic search with embeddings GuideOptimize memory with context recycling GuideBuild a persistent document knowledge base

API reference

Key API classes.

The core types that power agent memory in LM-Kit.NET.

Class

AgentMemory

Core memory storage, retrieval, extraction, and consolidation.

Class

UserScopedMemory

Multi-user isolation with namespace prefixing.

Enum

MemoryType

Semantic, Episodic, Procedural enum.

Enum

MemoryExtractionMode

None or LlmBased automatic extraction.

Enum

MemoryEvictionPolicy

Oldest, LowestImportance, or combined.

Class

MultiTurnConversation

Conversation engine with Memory property.

Glossary

Core concepts.

Foundational concepts behind agent memory, retrieval, and knowledge management.

TermAI agent memory TermRetrieval-augmented generation TermEmbeddings TermSemantic similarity TermVector database TermContext windows TermAI agents TermKV-cache

Explore more

Related capabilities.

Planning strategies, multi-agent workflows, and the full agent framework that memory powers.

Explore AI agents

Combine memory with 70+ built-in tools, custom ITool implementations, and [LMFunction] bindings. Agents that remember and act.

Explore tools

Trace memory recalls, consolidations, and evictions. OpenTelemetry GenAI semantic conventions out of the box.

Explore observability

Multi-turn conversations, agentic reasoning, and the chatbot capabilities powered by agent memory.

Explore chatbots

Document processing agents that remember previous analysis results and build persistent knowledge bases.

Explore documents

The retrieval-augmented generation engine that powers agent memory's semantic search and recall.

Explore RAG

Why on-device memory matters for HIPAA, GDPR, and enterprise deployments with zero data leakage.

Learn more

Demos & docs

Build it. Read it. Try it.

Working console demos on GitHub, step-by-step how-to guides on the docs site, and the API reference for the classes used on this page.

Demo

Install the SDK

Build agents that actually remember.

Add persistent, private memory to your .NET agents in minutes.

Download View pricing

Build AI agents that remember, learn and evolve.

From stateless to stateful in one API

Semantic memory

Episodic memory

Procedural memory

Automatic extraction

Memory consolidation

Time-decay scoring

Multi-user isolation

Capacity & eviction

Serialize & restore

Persistent memory assistant

Multi-turn chat with memory

RAG chatbot

Persistent session

Research assistant

Semantic Kernel + memory

AgentMemory

UserScopedMemory

MemoryType

MemoryExtractionMode

MemoryEvictionPolicy

MultiTurnConversation

AI agent orchestration

Tools & function calling

Observability

Conversational AI

Document intelligence

RAG pipelines

Privacy & compliance

Persistent memory assistant

Multi-turn chat with agent memory

Use agent memory for long-term knowledge

Enable automatic memory extraction