# Configuration Options for Vector Storage in AntSK: Disk, Memory, Qdrant, and Redis

> Explore AntSK vector storage options: Disk, Memory, Qdrant, and Redis. Learn how to configure storage for your AI applications with Kernel Memory.

- Repository: [AIDotNet/antsk](https://github.com/aidotnet/antsk)
- Tags: how-to-guide
- Published: 2026-02-24

---

**AntSK configures vector storage through the `KernelMemoryOption` static class, supporting Disk, Memory, Qdrant, Redis, PostgreSQL, and Azure AI Search via Microsoft's Kernel Memory library.**

AntSK is an open-source AI knowledge base application that leverages Microsoft's Kernel Memory to store and retrieve vector embeddings. The framework abstracts vector database selection through a simple configuration-based approach defined in [`src/AntSK.Domain/Options/KernelMemoryOption.cs`](https://github.com/aidotnet/antsk/blob/main/src/AntSK.Domain/Options/KernelMemoryOption.cs), allowing developers to switch between local file storage, in-memory caches, or dedicated vector databases like Qdrant and Redis without changing application code.

## How Vector Storage Configuration Works in AntSK

The vector storage system centers on three static properties in the `KernelMemoryOption` class:

```csharp
public static string VectorDb { get; set; }          // "Disk", "Memory", "Qdrant", "Redis", etc.
public static string ConnectionString { get; set; }  // Provider-specific connection details
public static string TableNamePrefix { get; set; }   // Used exclusively by PostgreSQL

```

These values are consumed by the `WithMemoryDbByVectorDB` method in [`src/AntSK.Domain/Domain/Service/KMService.cs`](https://github.com/aidotnet/antsk/blob/main/src/AntSK.Domain/Domain/Service/KMService.cs) (lines 37-79), which acts as a switch router. Based on the `VectorDb` value, this method invokes the appropriate extension method on the `KernelMemoryBuilder` to wire in the correct vector database implementation.

## Supported Vector Storage Providers

### Disk-Based Storage (SimpleVectorDb)

The **Disk** option persists vectors as binary files on the local file system using Kernel Memory's `SimpleVectorDb`.

| Configuration | Value |
|--------------|-------|
| `VectorDb` | `Disk` |
| `ConnectionString` | Not required |
| `TableNamePrefix` | Not required |

**Implementation Detail:** In [`KMService.cs`](https://github.com/aidotnet/antsk/blob/main/KMService.cs) (lines 52-56), the builder configures:

```csharp
memory.WithSimpleVectorDb(new SimpleVectorDbConfig { 
    StorageType = FileSystemTypes.Disk 
});

```

**Configuration Example:**

```json
{
  "KernelMemoryOption": {
    "VectorDb": "Disk"
  }
}

```

This mode is ideal for single-node deployments, development environments, or scenarios where external database infrastructure is unavailable.

### In-Memory Storage (Volatile)

The **Memory** option stores all vectors in RAM using a volatile, non-persistent cache.

| Configuration | Value |
|--------------|-------|
| `VectorDb` | `Memory` |
| `ConnectionString` | Not required |
| `TableNamePrefix` | Not required |

**Implementation Detail:** In [`KMService.cs`](https://github.com/aidotnet/antsk/blob/main/KMService.cs) (lines 60-64), the configuration uses:

```csharp
memory.WithSimpleVectorDb(new SimpleVectorDbConfig { 
    StorageType = FileSystemTypes.Volatile 
});

```

**Configuration Example:**

```json
{
  "KernelMemoryOption": {
    "VectorDb": "Memory"
  }
}

```

Use this for unit testing, ephemeral workloads, or high-performance temporary caching where data loss on restart is acceptable.

### Qdrant Vector Database

**Qdrant** is a dedicated vector database optimized for similarity search and AI applications.

| Configuration | Value |
|--------------|-------|
| `VectorDb` | `Qdrant` |
| `ConnectionString` | `"{host}|{apiKey}"` (pipe-separated) |
| `TableNamePrefix` | Not required |

**Implementation Detail:** In [`KMService.cs`](https://github.com/aidotnet/antsk/blob/main/KMService.cs) (lines 65-68), the connection string is parsed and passed to:

```csharp
var qdrantConfig = ConnectionString.Split("|");
memory.WithQdrantMemoryDb(qdrantConfig[0], qdrantConfig[1]);

```

- `qdrantConfig[0]` = Qdrant host URL (e.g., `http://localhost:6333`)
- `qdrantConfig[1]` = API key (optional; use empty string if authentication is disabled)

**Configuration Example:**

```json
{
  "KernelMemoryOption": {
    "VectorDb": "Qdrant",
    "ConnectionString": "http://localhost:6333|my-qdrant-api-key"
  }
}

```

Qdrant is recommended for production deployments requiring horizontal scalability and high-throughput vector search.

### Redis Vector Store

**Redis** supports vector similarity search through the RediSearch module, allowing reuse of existing Redis infrastructure.

| Configuration | Value |
|--------------|-------|
| `VectorDb` | `Redis` |
| `ConnectionString` | Standard Redis connection string |
| `TableNamePrefix` | Not required |

**Implementation Detail:** In [`KMService.cs`](https://github.com/aidotnet/antsk/blob/main/KMService.cs) (lines 70-74), the configuration is applied via:

```csharp
memory.WithRedisMemoryDb(new RedisConfig { 
    ConnectionString = ConnectionString 
});

```

**Configuration Example:**

```json
{
  "KernelMemoryOption": {
    "VectorDb": "Redis",
    "ConnectionString": "localhost:6379,password=MyRedisPwd,ssl=False"
  }
}

```

Redis is suitable for environments already running Redis clusters or requiring hybrid vector and key-value storage.

### PostgreSQL Vector Storage (Optional)

**PostgreSQL** with the `pgvector` extension provides relational vector storage.

| Configuration | Value |
|--------------|-------|
| `VectorDb` | `Postgres` |
| `ConnectionString` | Standard PostgreSQL connection string |
| `TableNamePrefix` | Optional prefix for KM tables |

**Implementation Detail:** In [`KMService.cs`](https://github.com/aidotnet/antsk/blob/main/KMService.cs) (lines 44-50):

```csharp
memory.WithPostgresMemoryDb(new PostgresConfig {
    ConnectionString = ConnectionString,
    TableNamePrefix = TableNamePrefix
});

```

**Configuration Example:**

```json
{
  "KernelMemoryOption": {
    "VectorDb": "Postgres",
    "ConnectionString": "Host=localhost;Port=5432;Database=km;Username=km_user;Password=km_pwd",
    "TableNamePrefix": "km_"
  }
}

```

### Azure AI Search (Optional)

**Azure AI Search** (formerly Cognitive Search) offers managed vector indexing.

| Configuration | Value |
|--------------|-------|
| `VectorDb` | `AzureAISearch` |
| `ConnectionString` | `"{serviceEndpoint}|{apiKey}"` (pipe-separated) |
| `TableNamePrefix` | Not required |

**Implementation Detail:** In [`KMService.cs`](https://github.com/aidotnet/antsk/blob/main/KMService.cs) (lines 75-78):

```csharp
var aisearchConfig = ConnectionString.Split("|");
memory.WithAzureAISearchMemoryDb(aisearchConfig[0], aisearchConfig[1]);

```

**Configuration Example:**

```json
{
  "KernelMemoryOption": {
    "VectorDb": "AzureAISearch",
    "ConnectionString": "https://mysearch.search.windows.net|my-azure-search-key"
  }
}

```

## Implementation Architecture

The vector storage initialization follows a consistent pattern in [`KMService.cs`](https://github.com/aidotnet/antsk/blob/main/KMService.cs). The `WithMemoryDbByVectorDB` method receives a `KernelMemoryBuilder` instance and applies the appropriate extension method based on the static `KernelMemoryOption.VectorDb` value.

Key source files:
- **[`src/AntSK.Domain/Options/KernelMemoryOption.cs`](https://github.com/aidotnet/antsk/blob/main/src/AntSK.Domain/Options/KernelMemoryOption.cs)** – Defines the static configuration properties (`VectorDb`, `ConnectionString`, `TableNamePrefix`)
- **[`src/AntSK.Domain/Domain/Service/KMService.cs`](https://github.com/aidotnet/antsk/blob/main/src/AntSK.Domain/Domain/Service/KMService.cs)** – Contains the `WithMemoryDbByVectorDB` method (lines 37-79) that routes to specific vector store implementations

## Summary

- AntSK uses **Microsoft's Kernel Memory** library for vector storage abstraction, configured through the static `KernelMemoryOption` class.
- **Six vector storage providers** are supported: Disk (file system), Memory (volatile RAM), Qdrant, Redis, PostgreSQL, and Azure AI Search.
- **Configuration is runtime-based**: Set `VectorDb` to the provider name and provide a `ConnectionString` in the format required by that specific backend.
- **Qdrant and Azure AI Search** use pipe-separated connection strings (`host|apiKey`), while **Redis and Postgres** use standard connection string formats.
- **Disk and Memory** require no connection strings, making them ideal for development or testing scenarios.

## Frequently Asked Questions

### How do I switch from Disk storage to Qdrant in AntSK?

Change the `VectorDb` value from `"Disk"` to `"Qdrant"` in your [`appsettings.json`](https://github.com/aidotnet/antsk/blob/main/appsettings.json) or environment variables, then provide the Qdrant endpoint and API key in the `ConnectionString` property using the pipe-separated format: `"http://localhost:6333|your-api-key"`. No code changes are required in [`KMService.cs`](https://github.com/aidotnet/antsk/blob/main/KMService.cs) because the `WithMemoryDbByVectorDB` method routes automatically based on the configuration value.

### What is the difference between Disk and Memory vector storage in AntSK?

**Disk** storage persists vectors as binary files on the local file system using `FileSystemTypes.Disk`, ensuring data survives application restarts but limiting scalability to single-node deployments. **Memory** storage uses `FileSystemTypes.Volatile` to keep all vectors in RAM, providing faster access but complete data loss when the process terminates, making it suitable only for testing or temporary caching.

### Does AntSK support PostgreSQL for vector storage?

Yes, AntSK supports PostgreSQL with the `pgvector` extension through the Kernel Memory library. Set `VectorDb` to `"Postgres"` and provide a standard PostgreSQL connection string. You can optionally specify a `TableNamePrefix` to namespace the tables created by Kernel Memory. The implementation uses `WithPostgresMemoryDb` in [`KMService.cs`](https://github.com/aidotnet/antsk/blob/main/KMService.cs) (lines 44-50).

### Is there a way to use Redis as a vector database in AntSK?

Yes, AntSK supports Redis as a vector store via the RediSearch module. Configure it by setting `VectorDb` to `"Redis"` and providing a standard Redis connection string (e.g., `"localhost:6379,password=secret"`). The `KMService.WithMemoryDbByVectorDB` method (lines 70-74) initializes the Redis backend using `WithRedisMemoryDb` with a `RedisConfig` object containing your connection string.