@telvok/librarian-mcp 1.1.0 → 1.3.0

package/dist/library/embeddings.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Get embedding for a text string.
+ * Returns a 384-dimensional normalized vector.
+ */
+export declare function getEmbedding(text: string): Promise<number[]>;
+/**
+ * Check if embeddings are available (model can load).
+ */
+export declare function isEmbeddingAvailable(): Promise<boolean>;
+/**
+ * Calculate cosine similarity between two vectors.
+ * Since vectors are normalized, this is just the dot product.
+ */
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+/**
+ * Split text into chunks at sentence boundaries.
+ * Aims for ~500 chars per chunk to preserve semantic meaning.
+ */
+export declare function chunkText(text: string, maxChars?: number): string[];
+export declare const EMBEDDING_MODEL_ID = "Xenova/all-MiniLM-L6-v2";
+export declare const EMBEDDING_DIMENSION = 384;

package/dist/library/embeddings.js

@@ -0,0 +1,86 @@
+import { pipeline, env } from '@huggingface/transformers';
+import * as path from 'path';
+import { getLibraryPath } from './storage.js';
+// ============================================================================
+// Configuration
+// ============================================================================
+// Cache model in .librarian/models
+env.allowRemoteModels = true;
+const MODEL_ID = 'Xenova/all-MiniLM-L6-v2';
+// ============================================================================
+// Embedding Generation
+// ============================================================================
+let embedder = null;
+/**
+ * Get embedding for a text string.
+ * Returns a 384-dimensional normalized vector.
+ */
+export async function getEmbedding(text) {
+    if (!embedder) {
+        // Set local model path on first call
+        const libraryPath = getLibraryPath();
+        env.localModelPath = path.join(libraryPath, 'models');
+        embedder = await pipeline('feature-extraction', MODEL_ID);
+    }
+    const result = await embedder(text, { pooling: 'mean', normalize: true });
+    return Array.from(result.data);
+}
+/**
+ * Check if embeddings are available (model can load).
+ */
+export async function isEmbeddingAvailable() {
+    try {
+        await getEmbedding('test');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ============================================================================
+// Similarity Calculation
+// ============================================================================
+/**
+ * Calculate cosine similarity between two vectors.
+ * Since vectors are normalized, this is just the dot product.
+ */
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error('Vectors must have same dimension');
+    }
+    return a.reduce((sum, val, i) => sum + val * b[i], 0);
+}
+// ============================================================================
+// Text Chunking
+// ============================================================================
+/**
+ * Split text into chunks at sentence boundaries.
+ * Aims for ~500 chars per chunk to preserve semantic meaning.
+ */
+export function chunkText(text, maxChars = 500) {
+    // Split at sentence boundaries (. ! ? followed by whitespace)
+    const sentences = text.split(/(?<=[.!?])\s+/);
+    const chunks = [];
+    let current = '';
+    for (const sentence of sentences) {
+        // If adding this sentence exceeds limit and we have content, start new chunk
+        if ((current + ' ' + sentence).length > maxChars && current.trim()) {
+            chunks.push(current.trim());
+            current = sentence;
+        }
+        else {
+            current = current ? current + ' ' + sentence : sentence;
+        }
+    }
+    // Don't forget the last chunk
+    if (current.trim()) {
+        chunks.push(current.trim());
+    }
+    // If no chunks created (e.g., no sentence boundaries), return original text
+    return chunks.length > 0 ? chunks : [text];
+}
+// ============================================================================
+// Constants
+// ============================================================================
+export const EMBEDDING_MODEL_ID = MODEL_ID;
+export const EMBEDDING_DIMENSION = 384;

package/dist/library/parsers/cursor.d.ts

@@ -0,0 +1,15 @@
+import type { ParseResult } from './types.js';
+/**
+ * Parse a Cursor Memory Bank folder (.cursor-memory/).
+ *
+ * Cursor Memory Bank typically contains:
+ * - activeContext.md - Current working context
+ * - progress.md - Progress log
+ * - projectBrief.md - Project overview
+ * - systemPatterns.md - System patterns
+ * - decisionLog.md - Decision history
+ * - techStack.md - Technology stack info
+ *
+ * Can also contain JSON files and subdirectories.
+ */
+export declare function parseCursorMemory(dirPath: string): Promise<ParseResult>;

package/dist/library/parsers/cursor.js

@@ -0,0 +1,168 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { glob } from 'glob';
+import matter from 'gray-matter';
+// ============================================================================
+// Cursor Memory Bank Parser
+// ============================================================================
+/**
+ * Parse a Cursor Memory Bank folder (.cursor-memory/).
+ *
+ * Cursor Memory Bank typically contains:
+ * - activeContext.md - Current working context
+ * - progress.md - Progress log
+ * - projectBrief.md - Project overview
+ * - systemPatterns.md - System patterns
+ * - decisionLog.md - Decision history
+ * - techStack.md - Technology stack info
+ *
+ * Can also contain JSON files and subdirectories.
+ */
+export async function parseCursorMemory(dirPath) {
+    const entries = [];
+    const errors = [];
+    let skipped = 0;
+    try {
+        const stats = await fs.stat(dirPath);
+        if (!stats.isDirectory()) {
+            errors.push(`${dirPath} is not a directory`);
+            return { entries, skipped, errors };
+        }
+        // Parse markdown files
+        const mdFiles = await glob(path.join(dirPath, '**/*.md'), { nodir: true });
+        for (const filePath of mdFiles) {
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const { data, content: body } = matter(content);
+                const trimmedBody = body.trim();
+                if (!trimmedBody) {
+                    skipped++;
+                    continue;
+                }
+                // Extract title from filename (convert camelCase/snake_case to Title Case)
+                const filename = path.basename(filePath, '.md');
+                const title = data.title || formatFilename(filename);
+                // Determine context based on filename
+                const context = data.context || inferContext(filename);
+                entries.push({
+                    title,
+                    content: trimmedBody,
+                    context,
+                    intent: data.intent,
+                    source: 'cursor',
+                    originalPath: filePath,
+                });
+            }
+            catch (fileError) {
+                errors.push(`${filePath}: ${fileError instanceof Error ? fileError.message : String(fileError)}`);
+                skipped++;
+            }
+        }
+        // Parse JSON files
+        const jsonFiles = await glob(path.join(dirPath, '**/*.json'), { nodir: true });
+        for (const filePath of jsonFiles) {
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const data = JSON.parse(content);
+                // Handle different JSON structures
+                if (Array.isArray(data)) {
+                    // Array of memory items
+                    for (const item of data) {
+                        if (typeof item === 'object' && item !== null) {
+                            const entry = extractFromJSON(item, filePath);
+                            if (entry) {
+                                entries.push(entry);
+                            }
+                            else {
+                                skipped++;
+                            }
+                        }
+                    }
+                }
+                else if (typeof data === 'object' && data !== null) {
+                    // Single memory object
+                    const entry = extractFromJSON(data, filePath);
+                    if (entry) {
+                        entries.push(entry);
+                    }
+                    else {
+                        skipped++;
+                    }
+                }
+            }
+            catch (fileError) {
+                errors.push(`${filePath}: ${fileError instanceof Error ? fileError.message : String(fileError)}`);
+                skipped++;
+            }
+        }
+    }
+    catch (dirError) {
+        errors.push(`Failed to access path: ${dirError instanceof Error ? dirError.message : String(dirError)}`);
+    }
+    return { entries, skipped, errors };
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Convert filename to readable title.
+ * activeContext -> Active Context
+ * system_patterns -> System Patterns
+ */
+function formatFilename(filename) {
+    return filename
+        // Handle camelCase
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        // Handle snake_case
+        .replace(/_/g, ' ')
+        // Handle kebab-case
+        .replace(/-/g, ' ')
+        // Capitalize first letter of each word
+        .replace(/\b\w/g, c => c.toUpperCase());
+}
+/**
+ * Infer context from Cursor Memory Bank filename patterns.
+ */
+function inferContext(filename) {
+    const lower = filename.toLowerCase();
+    if (lower.includes('context'))
+        return 'context';
+    if (lower.includes('progress'))
+        return 'progress';
+    if (lower.includes('brief') || lower.includes('overview'))
+        return 'project';
+    if (lower.includes('pattern'))
+        return 'patterns';
+    if (lower.includes('decision'))
+        return 'decisions';
+    if (lower.includes('stack') || lower.includes('tech'))
+        return 'technology';
+    return 'cursor-memory';
+}
+/**
+ * Extract a ParsedEntry from a JSON object.
+ */
+function extractFromJSON(obj, filePath) {
+    // Try various common keys for title
+    const title = obj.title ||
+        obj.name ||
+        obj.key ||
+        path.basename(filePath, '.json');
+    // Try various common keys for content
+    const content = obj.content ||
+        obj.description ||
+        obj.text ||
+        obj.value ||
+        obj.memory;
+    if (!content) {
+        return null;
+    }
+    return {
+        title,
+        content,
+        context: obj.context || obj.category || obj.type,
+        intent: obj.intent,
+        source: 'cursor',
+        originalPath: filePath,
+    };
+}

package/dist/library/parsers/index.d.ts

@@ -0,0 +1,4 @@
+export type { ParsedEntry, ParseResult } from './types.js';
+export { parseJSONL } from './jsonl.js';
+export { parseMarkdown } from './markdown.js';
+export { parseCursorMemory } from './cursor.js';

package/dist/library/parsers/index.js

@@ -0,0 +1,3 @@
+export { parseJSONL } from './jsonl.js';
+export { parseMarkdown } from './markdown.js';
+export { parseCursorMemory } from './cursor.js';

package/dist/library/parsers/jsonl.d.ts

@@ -0,0 +1,9 @@
+import type { ParseResult } from './types.js';
+/**
+ * Parse a JSONL file (Anthropic MCP Memory / mcp-knowledge-graph format).
+ *
+ * Input format:
+ * {"type":"entity","name":"Stripe Webhooks","entityType":"concept","observations":["Need idempotency checks"]}
+ * {"type":"relation","from":"Stripe Webhooks","to":"Payment Processing","relationType":"part_of"}
+ */
+export declare function parseJSONL(filePath: string): Promise<ParseResult>;

package/dist/library/parsers/jsonl.js

@@ -0,0 +1,53 @@
+import * as fs from 'fs/promises';
+/**
+ * Parse a JSONL file (Anthropic MCP Memory / mcp-knowledge-graph format).
+ *
+ * Input format:
+ * {"type":"entity","name":"Stripe Webhooks","entityType":"concept","observations":["Need idempotency checks"]}
+ * {"type":"relation","from":"Stripe Webhooks","to":"Payment Processing","relationType":"part_of"}
+ */
+export async function parseJSONL(filePath) {
+    const entries = [];
+    const errors = [];
+    let skipped = 0;
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lines = content.trim().split('\n').filter(line => line.trim());
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            try {
+                const item = JSON.parse(line);
+                // Skip safety markers and relations
+                if (item.type === '_aim' || item.type === 'relation') {
+                    skipped++;
+                    continue;
+                }
+                // Only process entities
+                if (item.type === 'entity' && item.name) {
+                    // Skip if no observations (empty content)
+                    if (!item.observations || item.observations.length === 0) {
+                        skipped++;
+                        continue;
+                    }
+                    entries.push({
+                        title: item.name,
+                        content: item.observations.join('\n\n'),
+                        context: item.entityType || undefined,
+                        source: 'jsonl',
+                    });
+                }
+                else {
+                    skipped++;
+                }
+            }
+            catch (parseError) {
+                errors.push(`Line ${i + 1}: Invalid JSON - ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                skipped++;
+            }
+        }
+    }
+    catch (fileError) {
+        errors.push(`Failed to read file: ${fileError instanceof Error ? fileError.message : String(fileError)}`);
+    }
+    return { entries, skipped, errors };
+}

package/dist/library/parsers/markdown.d.ts

@@ -0,0 +1,15 @@
+import type { ParseResult } from './types.js';
+/**
+ * Parse a folder of markdown files (Basic Memory MCP / Obsidian / any .md).
+ *
+ * Input format:
+ * ---
+ * title: API Rate Limits
+ * tags: [api, performance]
+ * ---
+ *
+ * # API Rate Limits
+ *
+ * Always implement exponential backoff...
+ */
+export declare function parseMarkdown(dirPath: string): Promise<ParseResult>;

package/dist/library/parsers/markdown.js

@@ -0,0 +1,77 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { glob } from 'glob';
+import matter from 'gray-matter';
+/**
+ * Parse a folder of markdown files (Basic Memory MCP / Obsidian / any .md).
+ *
+ * Input format:
+ * ---
+ * title: API Rate Limits
+ * tags: [api, performance]
+ * ---
+ *
+ * # API Rate Limits
+ *
+ * Always implement exponential backoff...
+ */
+export async function parseMarkdown(dirPath) {
+    const entries = [];
+    const errors = [];
+    let skipped = 0;
+    try {
+        // Handle both single file and directory
+        const stats = await fs.stat(dirPath);
+        const files = stats.isDirectory()
+            ? await glob(path.join(dirPath, '**/*.md'), { nodir: true })
+            : [dirPath];
+        for (const filePath of files) {
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const { data, content: body } = matter(content);
+                const frontmatter = data;
+                // Skip empty files
+                const trimmedBody = body.trim();
+                if (!trimmedBody) {
+                    skipped++;
+                    continue;
+                }
+                // Extract title from frontmatter, H1, or filename
+                let title = frontmatter.title;
+                if (!title) {
+                    const headingMatch = trimmedBody.match(/^#\s+(.+)$/m);
+                    if (headingMatch) {
+                        title = headingMatch[1].trim();
+                    }
+                    else {
+                        title = path.basename(filePath, '.md').replace(/-/g, ' ');
+                    }
+                }
+                // Extract context from tags or context field
+                let context;
+                if (frontmatter.context) {
+                    context = frontmatter.context;
+                }
+                else if (frontmatter.tags && Array.isArray(frontmatter.tags)) {
+                    context = frontmatter.tags.join(', ');
+                }
+                entries.push({
+                    title,
+                    content: trimmedBody,
+                    context,
+                    intent: frontmatter.intent,
+                    source: 'markdown',
+                    originalPath: filePath,
+                });
+            }
+            catch (fileError) {
+                errors.push(`${filePath}: ${fileError instanceof Error ? fileError.message : String(fileError)}`);
+                skipped++;
+            }
+        }
+    }
+    catch (dirError) {
+        errors.push(`Failed to access path: ${dirError instanceof Error ? dirError.message : String(dirError)}`);
+    }
+    return { entries, skipped, errors };
+}

package/dist/library/parsers/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A parsed memory entry ready to be converted to Librarian format.
+ */
+export interface ParsedEntry {
+    title: string;
+    content: string;
+    context?: string;
+    intent?: string;
+    reasoning?: string;
+    example?: string;
+    source: 'jsonl' | 'markdown' | 'cursor';
+    originalPath?: string;
+}
+/**
+ * Result of a parse operation.
+ */
+export interface ParseResult {
+    entries: ParsedEntry[];
+    skipped: number;
+    errors: string[];
+}

package/dist/library/parsers/types.js

@@ -0,0 +1,4 @@
+// ============================================================================
+// Shared Types for Memory Parsers
+// ============================================================================
+export {};

package/dist/library/storage.d.ts

@@ -9,8 +9,13 @@ export declare function getLibraryPath(): string;
 export declare function getLocalPath(libraryPath: string): string;
 /**
  * Get the imported entries path.
+ * @deprecated Use getPackagesPath for marketplace content
  */
 export declare function getImportedPath(libraryPath: string): string;
+/**
+ * Get the packages path (marketplace content from others).
+ */
+export declare function getPackagesPath(libraryPath: string): string;
 /**
  * Get the archived entries path.
  */

package/dist/library/storage.js

@@ -17,10 +17,17 @@ export function getLocalPath(libraryPath) {
 }
 /**
  * Get the imported entries path.
+ * @deprecated Use getPackagesPath for marketplace content
  */
 export function getImportedPath(libraryPath) {
     return path.join(libraryPath, 'imported');
 }
+/**
+ * Get the packages path (marketplace content from others).
+ */
+export function getPackagesPath(libraryPath) {
+    return path.join(libraryPath, 'packages');
+}
 /**
  * Get the archived entries path.
  */

package/dist/library/vector-index.d.ts

@@ -0,0 +1,55 @@
+export interface IndexEntry {
+    path: string;
+    title: string;
+    embedding: number[];
+    chunk: number;
+    preview: string;
+}
+export interface VectorIndex {
+    version: number;
+    rebuilt: string;
+    modelId: string;
+    entries: IndexEntry[];
+}
+export interface SemanticMatch {
+    path: string;
+    title: string;
+    similarity: number;
+    preview: string;
+}
+/**
+ * Load the vector index from disk.
+ * Returns empty index if file doesn't exist or is invalid.
+ */
+export declare function loadIndex(): Promise<VectorIndex>;
+/**
+ * Save the vector index to disk.
+ */
+export declare function saveIndex(index: VectorIndex): Promise<void>;
+/**
+ * Add or update an entry in the index.
+ * Chunks the content and generates embeddings for each chunk.
+ */
+export declare function addToIndex(index: VectorIndex, entryPath: string, title: string, content: string): Promise<void>;
+/**
+ * Remove an entry from the index.
+ */
+export declare function removeFromIndex(index: VectorIndex, entryPath: string): void;
+/**
+ * Search the index for entries semantically similar to the query.
+ * Returns paths ranked by similarity, deduped to best chunk per entry.
+ */
+export declare function semanticSearch(index: VectorIndex, query: string, limit?: number): Promise<SemanticMatch[]>;
+/**
+ * Check if the index might be stale (model changed).
+ */
+export declare function isIndexStale(index: VectorIndex): boolean;
+/**
+ * Get index statistics.
+ */
+export declare function getIndexStats(index: VectorIndex): {
+    entryCount: number;
+    chunkCount: number;
+    modelId: string;
+    rebuilt: string;
+};

package/dist/library/vector-index.js

@@ -0,0 +1,160 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { getLibraryPath } from './storage.js';
+import { getEmbedding, chunkText, cosineSimilarity, EMBEDDING_MODEL_ID } from './embeddings.js';
+// ============================================================================
+// Constants
+// ============================================================================
+const INDEX_FILENAME = 'index.json';
+const CURRENT_VERSION = 1;
+// ============================================================================
+// Index File Operations
+// ============================================================================
+/**
+ * Get path to the index file.
+ */
+function getIndexPath() {
+    return path.join(getLibraryPath(), INDEX_FILENAME);
+}
+/**
+ * Load the vector index from disk.
+ * Returns empty index if file doesn't exist or is invalid.
+ */
+export async function loadIndex() {
+    const indexPath = getIndexPath();
+    try {
+        const data = await fs.readFile(indexPath, 'utf-8');
+        const index = JSON.parse(data);
+        // Validate structure
+        if (!index.version || !Array.isArray(index.entries)) {
+            return createEmptyIndex();
+        }
+        return index;
+    }
+    catch {
+        // File doesn't exist or is invalid
+        return createEmptyIndex();
+    }
+}
+/**
+ * Save the vector index to disk.
+ */
+export async function saveIndex(index) {
+    const indexPath = getIndexPath();
+    // Update metadata
+    index.rebuilt = new Date().toISOString();
+    index.modelId = EMBEDDING_MODEL_ID;
+    // Ensure directory exists
+    await fs.mkdir(path.dirname(indexPath), { recursive: true });
+    // Write atomically by writing to temp file first
+    const tempPath = indexPath + '.tmp';
+    await fs.writeFile(tempPath, JSON.stringify(index, null, 2), 'utf-8');
+    await fs.rename(tempPath, indexPath);
+}
+/**
+ * Create an empty index.
+ */
+function createEmptyIndex() {
+    return {
+        version: CURRENT_VERSION,
+        rebuilt: '',
+        modelId: EMBEDDING_MODEL_ID,
+        entries: [],
+    };
+}
+// ============================================================================
+// Index Operations
+// ============================================================================
+/**
+ * Add or update an entry in the index.
+ * Chunks the content and generates embeddings for each chunk.
+ */
+export async function addToIndex(index, entryPath, title, content) {
+    // Remove any existing entries for this path
+    index.entries = index.entries.filter(e => e.path !== entryPath);
+    // Chunk the content
+    const chunks = chunkText(content);
+    // Generate embeddings for each chunk
+    for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        try {
+            const embedding = await getEmbedding(chunk);
+            index.entries.push({
+                path: entryPath,
+                title,
+                embedding,
+                chunk: i,
+                preview: chunk.slice(0, 100) + (chunk.length > 100 ? '...' : ''),
+            });
+        }
+        catch (error) {
+            // Log but don't fail - entry will still be searchable via keywords
+            console.error(`Failed to embed chunk ${i} for ${entryPath}:`, error);
+        }
+    }
+}
+/**
+ * Remove an entry from the index.
+ */
+export function removeFromIndex(index, entryPath) {
+    index.entries = index.entries.filter(e => e.path !== entryPath);
+}
+// ============================================================================
+// Semantic Search
+// ============================================================================
+/**
+ * Search the index for entries semantically similar to the query.
+ * Returns paths ranked by similarity, deduped to best chunk per entry.
+ */
+export async function semanticSearch(index, query, limit = 5) {
+    if (index.entries.length === 0) {
+        return [];
+    }
+    // Get query embedding
+    const queryEmbedding = await getEmbedding(query);
+    // Score all entries
+    const scored = index.entries.map(entry => ({
+        ...entry,
+        similarity: cosineSimilarity(queryEmbedding, entry.embedding),
+    }));
+    // Dedupe by path - keep the chunk with highest similarity
+    const byPath = new Map();
+    for (const entry of scored) {
+        const existing = byPath.get(entry.path);
+        if (!existing || entry.similarity > existing.similarity) {
+            byPath.set(entry.path, entry);
+        }
+    }
+    // Sort by similarity descending and apply limit
+    const results = [...byPath.values()]
+        .sort((a, b) => b.similarity - a.similarity)
+        .slice(0, limit)
+        .map(entry => ({
+        path: entry.path,
+        title: entry.title,
+        similarity: entry.similarity,
+        preview: entry.preview,
+    }));
+    return results;
+}
+// ============================================================================
+// Index Health
+// ============================================================================
+/**
+ * Check if the index might be stale (model changed).
+ */
+export function isIndexStale(index) {
+    return index.modelId !== EMBEDDING_MODEL_ID;
+}
+/**
+ * Get index statistics.
+ */
+export function getIndexStats(index) {
+    const uniquePaths = new Set(index.entries.map(e => e.path));
+    return {
+        entryCount: uniquePaths.size,
+        chunkCount: index.entries.length,
+        modelId: index.modelId,
+        rebuilt: index.rebuilt,
+    };
+}

package/dist/server.js

@@ -6,6 +6,8 @@ import { briefTool } from './tools/brief.js';
 import { recordTool } from './tools/record.js';
 import { adoptTool } from './tools/adopt.js';
 import { markHitTool } from './tools/mark-hit.js';
+import { importMemoriesTool } from './tools/import-memories.js';
+import { rebuildIndexTool } from './tools/rebuild-index.js';
 const server = new Server({
     name: 'librarian',
     version: '1.0.0',
@@ -38,6 +40,16 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 description: markHitTool.description,
                 inputSchema: markHitTool.inputSchema,
             },
+            {
+                name: importMemoriesTool.name,
+                description: importMemoriesTool.description,
+                inputSchema: importMemoriesTool.inputSchema,
+            },
+            {
+                name: rebuildIndexTool.name,
+                description: rebuildIndexTool.description,
+                inputSchema: rebuildIndexTool.inputSchema,
+            },
         ],
     };
 });
@@ -59,6 +71,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case 'mark_hit':
                 result = await markHitTool.handler(args);
                 break;
+            case 'import_memories':
+                result = await importMemoriesTool.handler(args);
+                break;
+            case 'rebuild_index':
+                result = await rebuildIndexTool.handler(args);
+                break;
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/dist/tools/brief.js

@@ -2,7 +2,8 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import matter from 'gray-matter';
 import { glob } from 'glob';
-import { getLibraryPath, getLocalPath, getImportedPath } from '../library/storage.js';
+import { getLibraryPath, getLocalPath, getImportedPath, getPackagesPath } from '../library/storage.js';
+import { loadIndex, semanticSearch, isIndexStale } from '../library/vector-index.js';
 // ============================================================================
 // Tool Definition
 // ============================================================================
@@ -38,7 +39,51 @@ Examples:
         const libraryPath = getLibraryPath();
         const localPath = getLocalPath(libraryPath);
         const importedPath = getImportedPath(libraryPath);
+        const packagesPath = getPackagesPath(libraryPath);
         let allEntries = [];
+        let useSemanticSearch = false;
+        let semanticMatches = [];
+        // Try semantic search if query is provided
+        if (query) {
+            try {
+                const index = await loadIndex();
+                // Only use semantic search if index has entries and isn't stale
+                if (index.entries.length > 0 && !isIndexStale(index)) {
+                    semanticMatches = await semanticSearch(index, query, limit);
+                    useSemanticSearch = semanticMatches.length > 0;
+                }
+            }
+            catch {
+                // Semantic search unavailable, fall back to keyword search
+                useSemanticSearch = false;
+            }
+        }
+        if (useSemanticSearch && semanticMatches.length > 0) {
+            // Load only the entries that matched semantically
+            const matchedPaths = new Set(semanticMatches.map(m => m.path));
+            for (const match of semanticMatches) {
+                const fullPath = path.join(libraryPath, match.path);
+                const entry = await readEntry(fullPath, libraryPath);
+                if (entry) {
+                    allEntries.push(entry);
+                }
+            }
+            // Sort by semantic similarity (order preserved from semanticSearch)
+            // Re-order allEntries to match semanticMatches order
+            const pathToEntry = new Map(allEntries.map(e => [e.path, e]));
+            allEntries = semanticMatches
+                .map(m => pathToEntry.get(m.path))
+                .filter((e) => e !== undefined);
+            const total = allEntries.length;
+            const entries = allEntries.slice(0, limit);
+            return {
+                entries,
+                total,
+                message: `Found ${total} ${total === 1 ? 'entry' : 'entries'} for "${query}" (semantic search).`,
+                libraryPath: localPath,
+            };
+        }
+        // Fall back to keyword search
         // Read local entries
         try {
             const localFiles = await glob(path.join(localPath, '**/*.md'), { nodir: true });
@@ -52,7 +97,7 @@ Examples:
         catch {
             // No local files yet
         }
-        // Read imported entries
+        // Read imported entries (legacy - deprecated)
         try {
             const importedFiles = await glob(path.join(importedPath, '**/*.md'), { nodir: true });
             for (const filePath of importedFiles) {
@@ -65,6 +110,19 @@ Examples:
         catch {
             // No imported files
         }
+        // Read packages entries (marketplace content)
+        try {
+            const packagesFiles = await glob(path.join(packagesPath, '**/*.md'), { nodir: true });
+            for (const filePath of packagesFiles) {
+                const entry = await readEntry(filePath, libraryPath);
+                if (entry) {
+                    allEntries.push(entry);
+                }
+            }
+        }
+        catch {
+            // No packages files
+        }
         // If no entries at all
         if (allEntries.length === 0) {
             return {

package/dist/tools/import-memories.d.ts

@@ -0,0 +1,32 @@
+export interface ImportResult {
+    success: boolean;
+    imported: number;
+    skipped: number;
+    errors: string[];
+    outputPath: string;
+    message: string;
+}
+export declare const importMemoriesTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            format: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            path: {
+                type: string;
+                description: string;
+            };
+            source_name: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler(args: unknown): Promise<ImportResult>;
+};

package/dist/tools/import-memories.js

@@ -0,0 +1,215 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { getLibraryPath, getLocalPath } from '../library/storage.js';
+import { loadIndex, saveIndex, addToIndex } from '../library/vector-index.js';
+import { parseJSONL, parseMarkdown, parseCursorMemory } from '../library/parsers/index.js';
+// ============================================================================
+// Tool Definition
+// ============================================================================
+export const importMemoriesTool = {
+    name: 'import_memories',
+    description: `Import memories from other AI tools into Librarian.
+
+Supported formats:
+- jsonl: Anthropic MCP Memory, mcp-knowledge-graph (.jsonl files)
+- markdown: Basic Memory, Obsidian, any .md files
+- cursor: Cursor Memory Bank (.cursor-memory/)
+
+Imports go to .librarian/local/[source-name]/ and are automatically indexed for semantic search.
+
+Examples:
+- import_memories({ format: "jsonl", path: "~/.aim/memory.jsonl", source_name: "anthropic-memory" })
+- import_memories({ format: "markdown", path: "~/basic-memory/", source_name: "basic-memory" })
+- import_memories({ format: "cursor", path: ".cursor-memory/", source_name: "cursor-memory" })`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            format: {
+                type: 'string',
+                enum: ['jsonl', 'markdown', 'cursor'],
+                description: 'Format of the source memories',
+            },
+            path: {
+                type: 'string',
+                description: 'Path to memory file or folder',
+            },
+            source_name: {
+                type: 'string',
+                description: 'Name for the import folder (e.g., "anthropic-memory"). Auto-generated if not provided.',
+            },
+        },
+        required: ['format', 'path'],
+    },
+    async handler(args) {
+        const { format, path: inputPath, source_name } = args;
+        if (!format || !inputPath) {
+            throw new Error('format and path are required');
+        }
+        // Expand ~ to home directory
+        const expandedPath = inputPath.replace(/^~/, process.env.HOME || '');
+        // Generate source name if not provided
+        const sourceName = source_name || generateSourceName(format, expandedPath);
+        // Setup output directory
+        const libraryPath = getLibraryPath();
+        const localPath = getLocalPath(libraryPath);
+        const outputPath = path.join(localPath, sourceName);
+        // Check if output directory already exists
+        try {
+            await fs.access(outputPath);
+            // Directory exists - we'll add to it but warn about potential duplicates
+        }
+        catch {
+            // Directory doesn't exist - create it
+            await fs.mkdir(outputPath, { recursive: true });
+        }
+        // Parse the source based on format
+        let parseResult;
+        switch (format) {
+            case 'jsonl':
+                parseResult = await parseJSONL(expandedPath);
+                break;
+            case 'markdown':
+                parseResult = await parseMarkdown(expandedPath);
+                break;
+            case 'cursor':
+                parseResult = await parseCursorMemory(expandedPath);
+                break;
+            default:
+                throw new Error(`Unknown format: ${format}`);
+        }
+        // Convert and save entries
+        const index = await loadIndex();
+        let imported = 0;
+        const errors = [...parseResult.errors];
+        for (const entry of parseResult.entries) {
+            try {
+                const relativePath = await saveEntry(entry, outputPath, libraryPath);
+                // Add to vector index
+                const fullContent = [
+                    entry.title,
+                    entry.intent || '',
+                    entry.content,
+                    entry.reasoning || '',
+                    entry.example || '',
+                    entry.context || '',
+                ].filter(Boolean).join('\n\n');
+                await addToIndex(index, relativePath, entry.title, fullContent);
+                imported++;
+            }
+            catch (saveError) {
+                errors.push(`Failed to save "${entry.title}": ${saveError instanceof Error ? saveError.message : String(saveError)}`);
+            }
+        }
+        // Save the updated index
+        await saveIndex(index);
+        const message = imported > 0
+            ? `Imported ${imported} entries from ${format} format into ${sourceName}/`
+            : `No entries imported. ${parseResult.skipped} skipped, ${errors.length} errors.`;
+        return {
+            success: imported > 0,
+            imported,
+            skipped: parseResult.skipped,
+            errors,
+            outputPath: path.relative(libraryPath, outputPath),
+            message,
+        };
+    },
+};
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Generate a source name from the format and path.
+ */
+function generateSourceName(format, inputPath) {
+    const basename = path.basename(inputPath, path.extname(inputPath));
+    switch (format) {
+        case 'jsonl':
+            if (basename.includes('memory')) {
+                return 'imported-memory';
+            }
+            return `imported-${basename}`;
+        case 'cursor':
+            return 'cursor-memory';
+        case 'markdown':
+            return basename.replace(/[^a-z0-9-]/gi, '-').toLowerCase() || 'imported-markdown';
+        default:
+            return `imported-${format}`;
+    }
+}
+/**
+ * Save a parsed entry to the output directory.
+ * Returns the relative path from library root.
+ */
+async function saveEntry(entry, outputPath, libraryPath) {
+    const slug = slugify(entry.title);
+    const created = new Date().toISOString();
+    // Handle filename collisions
+    let filename = `${slug}.md`;
+    let filePath = path.join(outputPath, filename);
+    let counter = 1;
+    while (await fileExists(filePath)) {
+        filename = `${slug}-${counter}.md`;
+        filePath = path.join(outputPath, filename);
+        counter++;
+    }
+    // Build frontmatter
+    const frontmatterLines = ['---'];
+    if (entry.intent) {
+        frontmatterLines.push(`intent: "${escapeYaml(entry.intent)}"`);
+    }
+    if (entry.context) {
+        frontmatterLines.push(`context: "${escapeYaml(entry.context)}"`);
+    }
+    frontmatterLines.push(`created: "${created}"`);
+    frontmatterLines.push(`updated: "${created}"`);
+    frontmatterLines.push(`source: "${entry.source}"`);
+    if (entry.originalPath) {
+        frontmatterLines.push(`original_path: "${escapeYaml(entry.originalPath)}"`);
+    }
+    frontmatterLines.push('hits: 0');
+    frontmatterLines.push('last_hit: null');
+    frontmatterLines.push('---');
+    // Build body
+    const bodyLines = [];
+    bodyLines.push(`# ${entry.title}`);
+    bodyLines.push('');
+    bodyLines.push(entry.content);
+    if (entry.reasoning) {
+        bodyLines.push('');
+        bodyLines.push('## Reasoning');
+        bodyLines.push('');
+        bodyLines.push(entry.reasoning);
+    }
+    if (entry.example) {
+        bodyLines.push('');
+        bodyLines.push('## Example');
+        bodyLines.push('');
+        bodyLines.push('```');
+        bodyLines.push(entry.example);
+        bodyLines.push('```');
+    }
+    // Combine and write
+    const fileContent = frontmatterLines.join('\n') + '\n\n' + bodyLines.join('\n') + '\n';
+    await fs.writeFile(filePath, fileContent, 'utf-8');
+    return path.relative(libraryPath, filePath);
+}
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 50);
+}
+function escapeYaml(text) {
+    return text.replace(/"/g, '\\"').replace(/\n/g, ' ');
+}
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/tools/index.d.ts

@@ -2,3 +2,5 @@ export { briefTool } from './brief.js';
 export { recordTool } from './record.js';
 export { adoptTool } from './adopt.js';
 export { markHitTool } from './mark-hit.js';
+export { importMemoriesTool } from './import-memories.js';
+export { rebuildIndexTool } from './rebuild-index.js';

package/dist/tools/index.js

@@ -2,3 +2,5 @@ export { briefTool } from './brief.js';
 export { recordTool } from './record.js';
 export { adoptTool } from './adopt.js';
 export { markHitTool } from './mark-hit.js';
+export { importMemoriesTool } from './import-memories.js';
+export { rebuildIndexTool } from './rebuild-index.js';

package/dist/tools/rebuild-index.d.ts

@@ -0,0 +1,23 @@
+export interface RebuildResult {
+    success: boolean;
+    indexed: number;
+    skipped: number;
+    errors: string[];
+    stats: {
+        entryCount: number;
+        chunkCount: number;
+        modelId: string;
+        rebuilt: string;
+    };
+    message: string;
+}
+export declare const rebuildIndexTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+        required: never[];
+    };
+    handler(_args: unknown): Promise<RebuildResult>;
+};

package/dist/tools/rebuild-index.js

@@ -0,0 +1,105 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { glob } from 'glob';
+import matter from 'gray-matter';
+import { getLibraryPath, getLocalPath, getImportedPath, getPackagesPath } from '../library/storage.js';
+import { saveIndex, addToIndex, getIndexStats } from '../library/vector-index.js';
+// ============================================================================
+// Tool Definition
+// ============================================================================
+export const rebuildIndexTool = {
+    name: 'rebuild_index',
+    description: `Rebuild the semantic search index for all library entries.
+
+Use this after:
+- Upgrading to v1.2.0 (existing entries need embeddings)
+- Importing memories from other tools
+- If semantic search seems broken
+
+Reads all .md entries and generates embeddings. May take a minute on first run.`,
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+    },
+    async handler(_args) {
+        const libraryPath = getLibraryPath();
+        const localPath = getLocalPath(libraryPath);
+        const importedPath = getImportedPath(libraryPath);
+        const packagesPath = getPackagesPath(libraryPath);
+        // Create a fresh index
+        const index = {
+            version: 1,
+            rebuilt: '',
+            modelId: '',
+            entries: [],
+        };
+        let indexed = 0;
+        let skipped = 0;
+        const errors = [];
+        // Collect all .md files from all directories
+        const allDirs = [localPath, importedPath, packagesPath];
+        const allFiles = [];
+        for (const dir of allDirs) {
+            try {
+                const files = await glob(path.join(dir, '**/*.md'), { nodir: true });
+                allFiles.push(...files);
+            }
+            catch {
+                // Directory doesn't exist, skip
+            }
+        }
+        // Process each file
+        for (const filePath of allFiles) {
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const { data, content: body } = matter(content);
+                // Skip empty files
+                if (!body.trim()) {
+                    skipped++;
+                    continue;
+                }
+                // Extract title
+                let title = data.title;
+                if (!title) {
+                    const headingMatch = body.match(/^#\s+(.+)$/m);
+                    if (headingMatch) {
+                        title = headingMatch[1].trim();
+                    }
+                    else {
+                        title = path.basename(filePath, '.md').replace(/-/g, ' ');
+                    }
+                }
+                // Build full content for embedding
+                const fullContent = [
+                    title,
+                    data.intent || '',
+                    body.trim(),
+                    data.context || '',
+                ].filter(Boolean).join('\n\n');
+                const relativePath = path.relative(libraryPath, filePath);
+                await addToIndex(index, relativePath, title, fullContent);
+                indexed++;
+            }
+            catch (error) {
+                const relativePath = path.relative(libraryPath, filePath);
+                errors.push(`${relativePath}: ${error instanceof Error ? error.message : String(error)}`);
+                skipped++;
+            }
+        }
+        // Save the index
+        await saveIndex(index);
+        const stats = getIndexStats(index);
+        const message = indexed > 0
+            ? `Rebuilt index with ${indexed} entries (${stats.chunkCount} chunks). ${skipped} skipped.`
+            : 'No entries found to index.';
+        return {
+            success: indexed > 0 || allFiles.length === 0,
+            indexed,
+            skipped,
+            errors,
+            stats,
+            message,
+        };
+    },
+};

package/dist/tools/record.js

@@ -1,6 +1,7 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { getLibraryPath, getLocalPath } from '../library/storage.js';
+import { loadIndex, saveIndex, addToIndex } from '../library/vector-index.js';
 // ============================================================================
 // Tool Definition
 // ============================================================================
@@ -140,6 +141,26 @@ Rich:
         const fileContent = frontmatterLines.join('\n') + '\n\n' + bodyLines.join('\n') + '\n';
         await fs.writeFile(filePath, fileContent, 'utf-8');
         const relativePath = path.relative(libraryPath, filePath);
+        // Add to vector index for semantic search
+        try {
+            const index = await loadIndex();
+            // Combine all text for embedding
+            const fullContent = [
+                title,
+                intent || '',
+                insight,
+                reasoning || '',
+                example || '',
+                context || '',
+            ].filter(Boolean).join('\n\n');
+            await addToIndex(index, relativePath, title, fullContent);
+            await saveIndex(index);
+        }
+        catch (embeddingError) {
+            // Don't fail the record operation if embedding fails
+            // Entry is still saved and searchable via keywords
+            console.error('Failed to add embedding:', embeddingError);
+        }
         return {
             success: true,
             path: relativePath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telvok/librarian-mcp",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Knowledge capture MCP server - remember what you learn with AI",
   "type": "module",
   "main": "dist/server.js",
@@ -26,11 +26,12 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/telvokdev/librarian.git"
+    "url": "git+https://github.com/telvokdev/librarian.git"
   },
   "author": "Telvok",
   "license": "MIT",
   "dependencies": {
+    "@huggingface/transformers": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "glob": "^11.0.0",
     "gray-matter": "^4.0.3",