Files
Rohit Ghumare f7803183bf chore: release v1.14.0
Features:
- Smart Context Generation: AI-powered skill generation with multi-source context
  - Multi-provider LLM support (Claude, GPT-4, Gemini, Ollama, OpenRouter)
  - 4 context sources: docs, codebase, marketplace skills, memory
  - Agent-specific optimization for 32 agents
  - Trust scoring and compatibility matrix
  - Skill composition via natural language search

Documentation:
- Added Generate Command section to CLI reference
- Updated README with AI skill generation feature
- Updated website with AI Generate in Advanced Features
2026-02-05 15:43:33 +00:00
..
2026-02-05 15:43:33 +00:00

@skillkit/memory

npm version License

Semantic memory with embeddings for SkillKit - CozoDB-backed persistent memory with vector search for AI agents.

Installation

npm install @skillkit/memory

Key Features

  • CozoDB Backend: Embedded graph database with HNSW vector index
  • Semantic Search: Cosine similarity search over embeddings
  • Xenova Transformers: Local embedding generation (no API keys)
  • Observations & Learnings: Store raw observations and compressed learnings
  • Memory Compression: Extract patterns from observations
  • Persistent Storage: SQLite-backed durability
  • Memory Reinforcement: Boost memory relevance through usage

Usage

Basic Memory Operations

import { MemoryStore, EmbeddingEncoder } from '@skillkit/memory';

// Initialize encoder
const encoder = new EmbeddingEncoder();
await encoder.init();

// Create memory store
const store = new MemoryStore('./my-project/.skillkit/memory');
await store.init();

// Store an observation
await store.addObservation({
  content: 'User prefers TypeScript strict mode',
  tags: ['typescript', 'preferences'],
  source: 'conversation',
});

// Search memories
const results = await store.search('typescript configuration', { limit: 5 });

Memory Compression

import { MemoryCompressor } from '@skillkit/memory';

// Compress observations into learnings
const compressor = new MemoryCompressor(store);
const learnings = await compressor.compress({
  minObservations: 3,
  maxAge: 7 * 24 * 60 * 60 * 1000, // 7 days
});
// Get embedding for a query
const embedding = await encoder.encode('React best practices');

// Search by vector
const results = await store.searchByVector(embedding, {
  limit: 10,
  threshold: 0.7,
});

Export Memories as Skills

import { MemoryExporter } from '@skillkit/memory';

// Export memories to a skill file
const exporter = new MemoryExporter(store);
const skill = await exporter.toSkill({
  name: 'project-patterns',
  tags: ['patterns', 'best-practices'],
});

API Reference

MemoryStore

interface MemoryStore {
  init(): Promise<void>;
  addObservation(obs: Observation): Promise<string>;
  addLearning(learning: Learning): Promise<string>;
  search(query: string, options?: SearchOptions): Promise<Memory[]>;
  searchByVector(embedding: number[], options?: SearchOptions): Promise<Memory[]>;
  reinforce(id: string): Promise<void>;
  close(): Promise<void>;
}

EmbeddingEncoder

interface EmbeddingEncoder {
  init(): Promise<void>;
  encode(text: string): Promise<number[]>;
  encodeBatch(texts: string[]): Promise<number[][]>;
  dispose(): Promise<void>;
}

Types

interface Observation {
  content: string;
  tags?: string[];
  source?: string;
  metadata?: Record<string, unknown>;
}

interface Learning {
  title: string;
  content: string;
  tags?: string[];
  confidence?: number;
}

interface Memory {
  id: string;
  content: string;
  embedding: number[];
  score?: number;
  createdAt: Date;
}

Documentation

Full documentation: https://github.com/rohitg00/skillkit

License

Apache-2.0