@deepseek-ai/dsh-memory-connect

跨会话记忆插件 — 让 AI Agent 拥有持久记忆
Cross-session memory plugin for DeepSeek Harness (DSH)

English | 中文

Overview

dsh-memory-connect is a cross-session memory sharing plugin for DeepSeek Harness. It automatically extracts, stores, and recalls memories across sessions, giving your AI agent persistent, intelligent memory with context explosion prevention.

Zero-config — works out of the box with SQLite FTS5 and DSH's built-in LLM.

Features

Architecture

┌──────────────────────────────────────────────────────────────────────────┐
│                    Memory Plugin Data Flow                                │
├──────────────────────────────────────────────────────────────────────────┤
│                                                                           │
│  ┌──────────┐    session/event    ┌──────────────────┐                   │
│  │ Session  │ ──────────────────→ │ MemoryExtractor  │                   │
│  │ Engine   │                     │ (Rule-based)     │                   │
│  └──────────┘                     └────────┬─────────┘                   │
│                                            │                             │
│                                            ▼                             │
│                                   ┌──────────────────┐                   │
│                                   │  SQLite FTS5     │                   │
│                                   │  memories        │                   │
│                                   │  + memory_fts    │                   │
│                                   └────────┬─────────┘                   │
│                                            │                             │
│  ┌──────────┐   session/created   ┌────────▼─────────┐                   │
│  │ New      │ ←────────────────── │ ContextInjector  │                   │
│  │ Session  │                     │ (Token Budget)   │                   │
│  └──────────┘                     └──────────────────┘                   │
│                                                                           │
│  ┌──────────────────────┐  ┌─────────────────────┐                      │
│  │   MemoryScheduler    │  │ SemanticConsolidator │                      │
│  │  (setInterval)       │→ │ (Tag+Word+Temporal)  │                      │
│  │  • Decay (1h)        │  │ + ctx.llm merge     │                      │
│  │  • Consolidate (6h)  │  └─────────────────────┘                      │
│  └──────────────────────┘                                                │
│                                                                           │
│  ┌────────────────────────────────────────────────────────────────────┐  │
│  │                    Context Explosion Prevention                     │  │
│  │  • TokenCounter: Estimate tokens (EN/CN/Mixed)                     │  │
│  │  • Smart Prioritization: Relevance × Recency × Frequency           │  │
│  │  • Budget Management: maxContextTokens limit                        │  │
│  │  • Memory Compression: Auto-truncate when approaching limits       │  │
│  └────────────────────────────────────────────────────────────────────┘  │
│                                                                           │
└──────────────────────────────────────────────────────────────────────────┘

Installation

npm install @deepseek-ai/dsh-memory-connect

Add to your DSH composition:

# agent.cordis.yml
- id: memory
  name: '@deepseek-ai/dsh-memory-connect'
  config:
    path: ~/.dsh/memory.db

Configuration

Basic Options

Scheduler Options

Context Explosion Prevention Options

Full configuration example:

- id: memory
  name: '@deepseek-ai/dsh-memory-connect'
  config:
    path: ~/.dsh/memory.db
    openAt: startup
    maxRecallCount: 10
    decayRate: 0.02
    journalMode: wal
    schedulerEnabled: true
    schedulerDecayIntervalMs: 3600000
    schedulerConsolidateIntervalMs: 21600000
    similarityThreshold: 0.5
    maxContextTokens: 4000
    reservedTokens: 8000
    smartPrioritization: true
    enableCompression: true

API

Search Memories

const memories = await ctx.crossSessionMemory.searchMemories({
  query: 'TypeScript configuration',
  types: ['fact', 'decision'],
  limit: 5,
})

Recall for Session

const memories = await ctx.crossSessionMemory.recallForSession(
  'session-123',
  'Setting up a new React project',
  10
)

Store Memory

await ctx.crossSessionMemory.storeMemory({
  type: 'preference',
  content: 'User prefers functional programming style',
  sessionId: 'session-123',
  tags: ['coding-style', 'preference'],
})

Manual Maintenance

// Trigger a full maintenance cycle (decay + consolidation)
const result = await ctx.crossSessionMemory.triggerMaintenance()

// Or run individually
await ctx.crossSessionMemory.runDecay()
await ctx.crossSessionMemory.consolidate()

Inspect & Monitor

// Scheduler status
const status = ctx.crossSessionMemory.getSchedulerStatus()

// Find similar memories (without merging)
const pairs = await ctx.crossSessionMemory.findSimilarMemories(0.6)

// Consolidation history
const log = await ctx.crossSessionMemory.getConsolidationLog(10)

// Statistics
const stats = await ctx.crossSessionMemory.getStats()

Context Explosion Prevention

How It Works

1. Token Counting — Estimates tokens for English (1 token ≈ 4 chars), Chinese (1 token ≈ 2 chars), and mixed text
2. Smart Prioritization — Ranks memories by: relevance × 50% + recency × 30% + frequency × 20%
3. Budget Management — Enforces maxContextTokens limit (default: 4000)
4. Memory Compression — Automatically truncates or summarizes when approaching limits

Output Example

## Related Memories from Previous Sessions

- [preference] User prefers TypeScript
- [decision] Chose PostgreSQL over MySQL
- [fact] Project uses React 18

> 💾 Memory: 3/10 memories | 150/4000 tokens

Token Budget Flow

Recall memories (up to maxRecallCount)
    ↓
Smart prioritization (relevance × recency × frequency)
    ↓
Token budget check
    ├── Under limit → Add directly
    └── Over limit → Compress then add
    ↓
Generate context with budget info
    ↓
Inject into session

Memory Types

Decay Formula

score = importance × e^(-λ × days) × log(access_count + 1)

Semantic Consolidation

Multi-signal similarity scoring:

When similarity ≥ threshold (default 0.5), memories are automatically merged using LLM.

Development

git clone https://github.com/Asher-2000/dsh-memory-connect.git
cd dsh-memory-connect
npm install
npm test

License

MIT

中文

概述

dsh-memory-connect 是 DeepSeek Harness 的跨会话记忆共享插件。它自动从对话中提取、存储和检索记忆，让 AI Agent 拥有持久化的智能记忆能力，并防止上下文爆炸。

零配置 — 基于 SQLite FTS5 和 DSH 内置 LLM，开箱即用。

核心功能

上下文爆炸防护

工作原理

1. Token 计数 — 估算中英文混合文本的 token 数
2. 智能优先级 — 按 相关性 × 50% + 时间衰减 × 30% + 访问频率 × 20% 排序
3. 预算管理 — 强制执行 maxContextTokens 限制（默认 4000）
4. 记忆压缩 — 接近限制时自动截断或摘要

输出示例

## 来自之前会话的相关记忆

- [偏好] 用户偏好 TypeScript
- [决策] 选择 PostgreSQL 而非 MySQL
- [事实] 项目使用 React 18

> 💾 记忆: 3/10 条 | 150/4000 tokens

快速开始

npm install @deepseek-ai/dsh-memory-connect

添加到 DSH 配置：

# agent.cordis.yml
- id: memory
  name: '@deepseek-ai/dsh-memory-connect'
  config:
    path: ~/.dsh/memory.db

配置示例

- id: memory
  name: '@deepseek-ai/dsh-memory-connect'
  config:
    path: ~/.dsh/memory.db
    maxRecallCount: 10
    maxContextTokens: 4000
    smartPrioritization: true
    enableCompression: true
    schedulerEnabled: true

API 示例

// 搜索记忆
const memories = await ctx.crossSessionMemory.searchMemories({
  query: 'TypeScript 配置',
  types: ['fact'],
})

// 为新会话召回相关记忆
await ctx.crossSessionMemory.recallForSession('session-123', '搭建 React 项目')

// 手动触发维护
await ctx.crossSessionMemory.triggerMaintenance()

// 查看统计
const stats = await ctx.crossSessionMemory.getStats()

许可证

MIT