Implementing Long-Term Memory for AI Agents with Semantic Kernel and PostgreSQL

Introduction

One of the biggest limitations of traditional AI applications is their inability to remember information across conversations. Most Large Language Models (LLMs) operate within a limited context window and forget previous interactions once a session ends.

For example, a user might tell an AI assistant:

My preferred programming language is C#.

Later, in a new conversation:

What programming language do I prefer?

Without memory, the AI cannot answer correctly.

This limitation becomes even more significant in enterprise applications, customer support systems, personal assistants, and autonomous AI agents that need to maintain context over days, weeks, or even months.

Long-term memory enables AI agents to store, retrieve, and use relevant information from previous interactions. By combining Semantic Kernel with PostgreSQL, developers can create AI agents that learn from past experiences and provide more personalized and context-aware responses.

In this article, you'll learn how long-term memory works, how Semantic Kernel supports memory-driven workflows, and how PostgreSQL can be used as a scalable memory store for AI agents.

Why AI Agents Need Long-Term Memory

Most AI systems operate like this:

User Question
      |
      v
LLM
      |
      v
Response

The model only sees information provided in the current prompt.

Once the conversation ends:

Context Lost

This creates several challenges:

Repeated questions
Lack of personalization
Poor user experience
Inconsistent responses
Limited reasoning across sessions

Long-term memory solves these issues.

Understanding AI Memory

Human memory consists of different types of information.

AI memory can be modeled similarly.

Short-Term Memory

Stores information during the current session.

Example:

Current Conversation

Long-Term Memory

Stores information across sessions.

Example:

User Preferences
Past Conversations
Learned Facts

Long-term memory allows agents to retain important information over time.

Types of Long-Term Memory

Different memory categories can be stored.

User Preferences

Example:

Preferred Language: C#
Preferred Cloud: Azure

Historical Conversations

Example:

Previous Support Requests

Business Knowledge

Example:

Company Policies
Internal Documentation

Agent Experiences

Example:

Past Decisions
Successful Workflows

These memory types improve agent performance.

Memory Architecture

A typical memory architecture looks like this:

User Interaction
        |
        v
Semantic Kernel
        |
        v
Memory Service
        |
        v
PostgreSQL
        |
        v
Memory Retrieval

The database stores information while Semantic Kernel orchestrates retrieval and usage.

Why PostgreSQL?

PostgreSQL is a popular choice for AI memory systems.

Benefits include:

Open source
Highly scalable
Reliable
Cloud-friendly
Supports vector storage
Strong indexing capabilities

It works well for both traditional data and AI-related workloads.

Memory Workflow

A typical workflow looks like this:

User Message
      |
      v
Extract Facts
      |
      v
Store Memory
      |
      v
Future Query
      |
      v
Retrieve Memory
      |
      v
Generate Response

The agent continuously learns from interactions.

Creating a Memory Model

Let's start with a simple memory entity.

public class MemoryRecord
{
    public Guid Id { get; set; }

    public string UserId { get; set; }
        = string.Empty;

    public string Content { get; set; }
        = string.Empty;

    public DateTime CreatedAt
    {
        get;
        set;
    }
}

This model stores user-related memories.

Creating the PostgreSQL Database

A simple memory table might look like this:

CREATE TABLE MemoryRecords
(
    Id UUID PRIMARY KEY,
    UserId TEXT,
    Content TEXT,
    CreatedAt TIMESTAMP
);

The table stores memory entries for future retrieval.

Configuring Entity Framework Core

Install PostgreSQL support.

dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL

This package enables PostgreSQL integration with .NET applications.

Creating the DbContext

Define a database context.

public class MemoryDbContext
    : DbContext
{
    public MemoryDbContext(
        DbContextOptions<
            MemoryDbContext> options)
        : base(options)
    {
    }

    public DbSet<MemoryRecord>
        MemoryRecords => Set<MemoryRecord>();
}

The DbContext provides access to stored memories.

Registering the Database

Configure PostgreSQL in Program.cs.

builder.Services.AddDbContext<
    MemoryDbContext>(
    options =>
    options.UseNpgsql(
        configuration
        .GetConnectionString(
            "MemoryDatabase")));

The application can now interact with PostgreSQL.

Creating a Memory Service

Create a service for storing memories.

public interface IMemoryService
{
    Task SaveAsync(
        MemoryRecord memory);

    Task<List<MemoryRecord>>
        GetMemoriesAsync(
            string userId);
}

This abstraction simplifies memory management.

Saving Memories

Example implementation:

public async Task SaveAsync(
    MemoryRecord memory)
{
    _dbContext.MemoryRecords
        .Add(memory);

    await _dbContext
        .SaveChangesAsync();
}

The service stores information for future use.

Retrieving Memories

Example retrieval method:

public async Task<List<MemoryRecord>>
    GetMemoriesAsync(
        string userId)
{
    return await _dbContext
        .MemoryRecords
        .Where(x =>
            x.UserId == userId)
        .ToListAsync();
}

Retrieved memories can be injected into prompts.

Integrating Memory with Semantic Kernel

The workflow becomes:

User Question
      |
      v
Retrieve Memories
      |
      v
Semantic Kernel
      |
      v
LLM
      |
      v
Response

The model now receives additional context.

Example Memory Retrieval

Stored memory:

User prefers Azure cloud services.

User asks:

Which cloud platform should I learn?

Retrieved memory:

User prefers Azure cloud services.

Generated response:

Since you prefer Azure,
learning Azure services
would be a strong choice.

The response becomes more personalized.

Using Semantic Search for Memory

As memory grows, simple keyword matching becomes insufficient.

Example:

Stored:
User enjoys ASP.NET Core.

Query:

What web framework should I use?

Keyword matching may fail.

Semantic search improves retrieval quality.

Combining PostgreSQL with Vector Search

Modern PostgreSQL deployments can support vector embeddings.

Workflow:

Memory
   |
Embedding
   |
PostgreSQL Vector Storage
   |
Similarity Search

Benefits include:

Semantic retrieval
Better relevance
Improved personalization

This is especially useful for large memory collections.

Memory Consolidation

Not all memories should be stored forever.

Example:

Temporary Question

versus

Long-Term Preference

A memory management process should:

Remove duplicates
Merge related memories
Archive outdated information

This keeps memory efficient.

Building a Personal AI Assistant

Consider a personal assistant workflow.

Conversation
      |
      v
Memory Extraction
      |
      v
PostgreSQL
      |
      v
Memory Retrieval
      |
      v
Personalized Response

The assistant becomes increasingly useful over time.

Multi-Agent Shared Memory

Organizations often use multiple agents.

Example:

Support Agent
      |
      v
Shared Memory Store
      |
      v
Sales Agent

Shared memory allows agents to collaborate effectively.

Benefits include:

Consistent responses
Knowledge sharing
Better coordination

This pattern is becoming increasingly common.

Security Considerations

Memory systems often contain sensitive information.

Authenticate Users

Use:

JWT
OAuth
OpenID Connect

Encrypt Sensitive Data

Protect information at rest and in transit.

Apply Access Controls

Users should only access their own memories.

Audit Access

Track:

Memory creation
Memory updates
Memory retrieval

Security should be built into every layer.

Monitoring Memory Systems

Track key metrics.

Examples:

Memory count
Retrieval latency
Query performance
Storage growth
Personalization effectiveness

Example:

Average Retrieval Time:
75 ms

Stored Memories:
1.2 Million

Monitoring helps maintain performance.

Best Practices

Store Only Useful Information

Avoid saving unnecessary data.

Use Semantic Retrieval

Improve memory relevance.

Periodically Clean Memory

Remove outdated information.

Secure Sensitive Data

Protect personal information carefully.

Monitor Storage Growth

Memory stores expand quickly.

Validate Retrieved Context

Ensure retrieved memories remain accurate.

These practices improve memory quality.

Common Challenges

Memory Explosion

Storage requirements can grow rapidly.

Retrieval Accuracy

Irrelevant memories may be returned.

Privacy Concerns

User data requires careful handling.

Data Governance

Organizations may have retention policies.

Cost Management

Large memory systems require infrastructure planning.

Proper architecture helps address these challenges.

Real-World Use Cases

Long-term memory is useful across many domains.

Personal Assistants

Remember user preferences and habits.

Customer Support

Retain support history and context.

Enterprise Knowledge Systems

Store organizational knowledge.

Healthcare Applications

Maintain patient-related context.

AI Agent Ecosystems

Enable shared learning across agents.

These use cases continue to expand as agentic AI evolves.

Conclusion

Long-term memory is one of the most important capabilities for building truly intelligent AI agents. Without memory, AI systems are limited to isolated interactions and cannot learn from previous experiences or personalize their responses effectively.

By combining Semantic Kernel with PostgreSQL, developers can create scalable memory architectures that store, retrieve, and utilize contextual information across conversations and workflows. Whether implemented through traditional relational storage, semantic search, or vector-based retrieval, memory transforms AI agents from simple assistants into persistent, context-aware systems.

As AI applications continue to move toward autonomous and agent-based architectures, long-term memory will become a foundational component for delivering personalized, efficient, and intelligent user experiences in modern .NET applications.