# What Information Is Stored in the L0 Memory Layer in TencentDB Agent Memory

> Discover what information resides in the L0 memory layer of TencentDB Agent Memory, including raw conversation records, session keys, message content, and metadata. Understand its role as the immutable source of truth.

- Repository: [Tencent Cloud/TencentDB-Agent-Memory](https://github.com/TencentCloud/TencentDB-Agent-Memory)
- Tags: deep-dive
- Published: 2026-08-24

---

**The L0 (Layer 0) memory layer serves as the foundational storage tier in TencentDB Agent Memory, persisting raw conversation records including session keys, message content, timestamps, roles, optional embedding vectors, and metadata—serving as the immutable source of truth for higher-level processing layers.**

The L0 memory layer acts as the primary ingestion and persistence tier for the `TencentCloud/TencentDB-Agent-Memory` repository. Unlike higher abstraction layers, L0 deliberately avoids summarization, capturing unprocessed conversation data that downstream components (L1-L3) later refine. Understanding what data resides in L0 is essential for debugging memory flows, optimizing retrieval performance, and implementing custom memory skills.

## Core Data Elements Stored in L0

### Session Identification and Grouping

Every L0 record contains a **`sessionKey`** field that groups messages belonging to the same conversation context. According to [`MemoryCore/src/core/store/tcvdb.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryCore/src/core/store/tcvdb.ts), this identifier enables session-scoped queries and ensures temporal continuity across multi-turn dialogues. The session key acts as the primary clustering mechanism, allowing the system to retrieve complete conversation histories for specific users or interaction threads.

### Raw Message Content and Role Metadata

The layer stores the original **`content`** (or `text`) of user and assistant utterances without transformation or compression. The **`role`** field indicates the message origin—normalized to values like `user`, `assistant`, `tool_call`, or `tool_result` as implemented in [`MemoryCore/src/core/skill/skill-extractor.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryCore/src/core/skill/skill-extractor.ts). This raw preservation ensures that higher layers can reprocess historical data with updated algorithms while maintaining an immutable audit trail of the exact inputs received.

### High-Resolution Temporal Data

Each entry includes a **`recordedAtMs`** timestamp (millisecond resolution) as defined in the storage schema. This field supports time-based retention policies, chronological replay, and expiration logic implemented in [`MemoryCore/src/utils/memory-cleaner.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryCore/src/utils/memory-cleaner.ts). The high precision enables accurate ordering of messages that arrive within the same second and supports sliding-window queries used by short-term memory processing.

### Vector Embeddings for Similarity Search

L0 optionally stores pre-computed **`embedding`** vectors—`Float32Array` representations of message content. As seen in [`MemoryCore/src/core/store/sqlite.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryCore/src/core/store/sqlite.ts), these vectors populate dedicated columns (e.g., `vec`) to enable fast similarity searches directly against raw records. The [`MemoryCore/src/core/store/embedding.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryCore/src/core/store/embedding.ts) module handles local generation of these vectors, which are then persisted alongside the original text to support semantic retrieval without requiring reconstruction from higher abstraction layers.

### Auxiliary Metadata and Lifecycle Flags

Additional key-value pairs supplied by clients—including message **`id`**, custom tags, or tool identifiers—are stored verbatim in metadata fields. The layer also maintains internal deletion markers such as **`expired`** or **`minRetain`** flags used by the memory cleaner to identify candidates for pruning. These flags enable soft-deletion workflows where L0 records can be marked for removal without immediate physical deletion, preserving referential integrity with downstream processing pipelines.

## L0 Architecture and Relationship to Higher Layers

Unlike L1-L3, which generate chunks, summaries, and skill-specific extracts, L0 deliberately functions as an **append-only log** (with soft deletes). It serves three primary architectural purposes: **source of truth** for downstream processing, **audit trail** for debugging memory decisions, and **replay buffer** for reconstructing conversation states. The [`MemoryCore/src/core/store/tcvdb.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryCore/src/core/store/tcvdb.ts) implementation exposes methods like `upsert()` and `queryForL1()` that explicitly bridge raw L0 data to the L1 chunking pipeline, ensuring a clear data lineage from raw ingestion to processed memory.

## Practical Code Examples for L0 Operations

Inserting raw messages into L0:

```typescript
import { L0Store } from '@/core/store/tcvdb';

const message = {
  sessionKey: 'session-12345',
  role: 'user',
  content: 'How does the memory service index messages?',
  recordedAtMs: Date.now(),
  // Optional: pre-computed embedding vector
  // embedding: Float32Array.from([0.1, 0.2, ...]),
};

await L0Store.upsert(message);

```

Querying L0 records for L1 processing:

```typescript
import { L0Store } from '@/core/store/tcvdb';

const records = await L0Store.queryForL1({
  sessionKey: 'session-12345',
  afterRecordedAtMs: Date.now() - 24 * 60 * 60 * 1000, // last 24 hours
});
// Returns array of raw messages with embeddings for L1 chunking

```

Performing vector similarity search on L0:

```typescript
import { L0Store } from '@/core/store/tcvdb';

const queryVec = await embed('memory indexing');
const results = await L0Store.search({
  queryEmbedding: queryVec,
  topK: 5,
});
// Returns most relevant raw messages based on embedding similarity

```

## Key Implementation Files

- **[`MemoryCore/src/core/store/tcvdb.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryCore/src/core/store/tcvdb.ts)**: Primary L0 implementation containing `upsert()`, batch operations, session queries, and expiration handling logic.
- **[`MemoryCore/src/core/store/sqlite.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryCore/src/core/store/sqlite.ts)**: SQLite-backed persistence layer defining the physical schema with `v` (raw text) and `vec` (embedding) columns.
- **[`MemoryCore/src/utils/memory-cleaner.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryCore/src/utils/memory-cleaner.ts)**: Retention policy enforcement and soft-deletion logic for L0 records based on age and flags.
- **[`MemoryCore/src/core/skill/skill-extractor.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryCore/src/core/skill/skill-extractor.ts)**: Role normalization pipeline ensuring standardized `user`, `assistant`, and tool-related role values before L0 insertion.
- **[`MemoryCore/src/core/store/embedding.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryCore/src/core/store/embedding.ts)**: Local embedding generation service that produces vectors stored alongside raw messages in L0.

## Summary

- The L0 memory layer stores **raw, unprocessed conversation data** including complete message text, session identifiers, and high-resolution timestamps.
- Each record contains **normalized role metadata** (`user`, `assistant`, `tool_call`, `tool_result`) and optional **embedding vectors** for similarity retrieval.
- **Millisecond-precision timestamps** (`recordedAtMs`) enable time-based queries and automated expiration via [`MemoryCore/src/utils/memory-cleaner.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryCore/src/utils/memory-cleaner.ts).
- L0 serves as the **immutable source of truth** for higher layers (L1-L3), supporting debugging, replay, and audit capabilities without abstraction overhead.
- Data persistence is handled through both vector database interfaces ([`tcvdb.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/tcvdb.ts)) and SQLite storage ([`sqlite.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/sqlite.ts)), ensuring deployment flexibility across environments.

## Frequently Asked Questions

### Does L0 store processed summaries or only raw text?

L0 exclusively stores raw message content and metadata. Summaries and abstractions are generated by L1 and L2 layers which consume L0 records as input. This architectural separation ensures L0 remains an immutable audit trail while allowing higher layers to evolve their processing logic independently without invalidating historical storage.

### How are embeddings managed in the L0 layer?

Embedding vectors are stored as optional `Float32Array` data alongside raw text in the `vec` column (SQLite) or equivalent vector database fields. The [`MemoryCore/src/core/store/embedding.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryCore/src/core/store/embedding.ts) module handles generation logic, while [`tcvdb.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/tcvdb.ts) manages persistence, indexing, and similarity search operations against these vectors.

### What determines when data is deleted from L0?

Deletion is governed by retention policies implemented in [`MemoryCore/src/utils/memory-cleaner.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryCore/src/utils/memory-cleaner.ts). Records are marked for removal based on age thresholds, session expiration, or manual deletion flags (`expired`, `minRetain`). L0 typically uses soft deletion to maintain referential integrity with downstream layers that may still reference raw record IDs.

### Can I query L0 directly for my application, or must I go through L1-L3?

While the architecture permits direct L0 queries via `L0Store.queryForL1()` or `L0Store.search()`, production applications should typically interact with higher layers that provide filtered, summarized, or skill-specific views. Direct L0 access is recommended primarily for debugging, data migration, or custom skill development requiring unprocessed historical data.