smritea-mcp 0.1.1

package/dist/tools/memory.js

@@ -0,0 +1,77 @@
+import { SmriteaError, SmriteaRateLimitError } from 'smritea-sdk';
+export function formatMemory(memory) {
+    return JSON.stringify(memory, null, 2);
+}
+export function formatSearchResult(result) {
+    return JSON.stringify({ score: result.score, memory: result.memory }, null, 2);
+}
+export function formatError(err) {
+    if (err instanceof SmriteaRateLimitError && err.retryAfter !== undefined) {
+        return `${err.message} (retry after ${err.retryAfter}s)`;
+    }
+    if (err instanceof SmriteaError) {
+        return err.message;
+    }
+    return String(err);
+}
+export async function handleAddMemory(client, input, firstPersonUserId) {
+    try {
+        const memory = await client.add(input.content, {
+            userId: input.user_id ?? firstPersonUserId,
+            metadata: input.metadata,
+        });
+        return {
+            content: [{ type: 'text', text: formatMemory(memory) }],
+        };
+    }
+    catch (err) {
+        return { isError: true, content: [{ type: 'text', text: formatError(err) }] };
+    }
+}
+export async function handleSearchMemories(client, input, firstPersonUserId) {
+    try {
+        const results = await client.search(input.query, {
+            userId: input.user_id ?? firstPersonUserId,
+            limit: input.limit,
+            method: input.method,
+            threshold: input.threshold,
+            graphDepth: input.graph_depth,
+            conversationId: input.conversation_id,
+        });
+        if (results.length === 0) {
+            return {
+                content: [{ type: 'text', text: 'No memories found.' }],
+            };
+        }
+        const formatted = JSON.stringify(results.map((r) => ({ score: r.score, memory: r.memory })), null, 2);
+        return {
+            content: [{ type: 'text', text: formatted }],
+        };
+    }
+    catch (err) {
+        return { isError: true, content: [{ type: 'text', text: formatError(err) }] };
+    }
+}
+export async function handleGetMemory(client, input) {
+    try {
+        const memory = await client.get(input.memory_id);
+        return {
+            content: [{ type: 'text', text: formatMemory(memory) }],
+        };
+    }
+    catch (err) {
+        return { isError: true, content: [{ type: 'text', text: formatError(err) }] };
+    }
+}
+export async function handleDeleteMemory(client, input) {
+    try {
+        await client.delete(input.memory_id);
+        return {
+            content: [{ type: 'text', text: `Memory ${input.memory_id} deleted.` }],
+        };
+    }
+    catch (err) {
+        return { isError: true, content: [{ type: 'text', text: formatError(err) }] };
+    }
+}
+//# sourceMappingURL=memory.js.map

package/dist/types.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+export declare const AddMemoryInput: z.ZodObject<{
+    content: z.ZodString;
+    user_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    user_id?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    content: string;
+    user_id?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export type AddMemoryInput = z.infer<typeof AddMemoryInput>;
+export declare const SearchMemoriesInput: z.ZodObject<{
+    query: z.ZodString;
+    user_id: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    method: z.ZodOptional<z.ZodString>;
+    threshold: z.ZodOptional<z.ZodNumber>;
+    graph_depth: z.ZodOptional<z.ZodNumber>;
+    conversation_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    user_id?: string | undefined;
+    limit?: number | undefined;
+    method?: string | undefined;
+    threshold?: number | undefined;
+    graph_depth?: number | undefined;
+    conversation_id?: string | undefined;
+}, {
+    query: string;
+    user_id?: string | undefined;
+    limit?: number | undefined;
+    method?: string | undefined;
+    threshold?: number | undefined;
+    graph_depth?: number | undefined;
+    conversation_id?: string | undefined;
+}>;
+export type SearchMemoriesInput = z.infer<typeof SearchMemoriesInput>;
+export declare const GetMemoryInput: z.ZodObject<{
+    memory_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    memory_id: string;
+}, {
+    memory_id: string;
+}>;
+export type GetMemoryInput = z.infer<typeof GetMemoryInput>;
+export declare const DeleteMemoryInput: z.ZodObject<{
+    memory_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    memory_id: string;
+}, {
+    memory_id: string;
+}>;
+export type DeleteMemoryInput = z.infer<typeof DeleteMemoryInput>;
+export declare const SelectAppInput: z.ZodObject<{
+    app_id: z.ZodString;
+    app_name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    app_id: string;
+    app_name?: string | undefined;
+}, {
+    app_id: string;
+    app_name?: string | undefined;
+}>;
+export type SelectAppInput = z.infer<typeof SelectAppInput>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;;;;;;;;;;;EAIzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;EAQ9B,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE,eAAO,MAAM,cAAc;;;;;;EAEzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,eAAO,MAAM,iBAAiB;;;;;;EAE5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,eAAO,MAAM,cAAc;;;;;;;;;EAGzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/types.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export const AddMemoryInput = z.object({
+    content: z.string().min(1).describe('The memory content to store'),
+    user_id: z.string().optional().describe('User ID to associate with this memory'),
+    metadata: z.record(z.string(), z.unknown()).optional().describe('Optional key-value metadata'),
+});
+export const SearchMemoriesInput = z.object({
+    query: z.string().min(1).describe('Natural language search query'),
+    user_id: z.string().optional().describe('Filter memories by user ID'),
+    limit: z.number().int().positive().optional().describe('Maximum number of results'),
+    method: z.string().optional().describe('Search method: quick_search, deep_search, context_aware_search'),
+    threshold: z.number().min(0).max(1).optional().describe('Minimum relevance score (0.0-1.0)'),
+    graph_depth: z.number().int().positive().optional().describe('Graph traversal depth override'),
+    conversation_id: z.string().optional().describe('Filter to a specific conversation'),
+});
+export const GetMemoryInput = z.object({
+    memory_id: z.string().min(1).describe('The memory ID to retrieve'),
+});
+export const DeleteMemoryInput = z.object({
+    memory_id: z.string().min(1).describe('The memory ID to delete'),
+});
+export const SelectAppInput = z.object({
+    app_id: z.string().min(1).describe('The smritea app ID to use for this project'),
+    app_name: z.string().optional().describe('Optional display name for the app'),
+});
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "smritea-mcp",
+  "version": "0.1.1",
+  "description": "MCP server for smritea AI memory system",
+  "type": "module",
+  "bin": {
+    "smritea-mcp": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "smritea-sdk": "latest",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "eslint": "^8.57.0",
+    "typescript": "^5.5.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/config.ts

@@ -0,0 +1,67 @@
+/**
+ * Two-tier configuration for smritea-mcp.
+ *
+ * User-scoped  (~/.smritea/mcp-config.json): api_key, base_url
+ * Project-scoped (.smritea/config.json):     app_id, app_name
+ *
+ * Environment variable overrides:
+ *   SMRITEA_API_KEY, SMRITEA_BASE_URL, SMRITEA_APP_ID
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export interface UserConfig {
+  api_key: string;
+  base_url: string;
+  first_person_user_id?: string;
+}
+
+export interface ProjectConfig {
+  app_id: string;
+  app_name?: string;
+}
+
+export interface ResolvedConfig {
+  apiKey: string;
+  baseUrl: string;
+  appId: string;
+  /** Used as user_id when the user refers to themselves ("I prefer…", "I like…"). */
+  firstPersonUserId?: string;
+}
+
+const USER_CONFIG_PATH = join(homedir(), '.smritea', 'mcp-config.json');
+const PROJECT_CONFIG_PATH = join(process.cwd(), '.smritea', 'config.json');
+
+function readJsonFile<T>(path: string): T | null {
+  if (!existsSync(path)) return null;
+  const raw = readFileSync(path, 'utf-8');
+  return JSON.parse(raw) as T;
+}
+
+export function loadConfig(): ResolvedConfig {
+  const user = readJsonFile<UserConfig>(USER_CONFIG_PATH);
+  const project = readJsonFile<ProjectConfig>(PROJECT_CONFIG_PATH);
+
+  const apiKey = process.env['SMRITEA_API_KEY'] ?? user?.api_key;
+  const baseUrl = process.env['SMRITEA_BASE_URL'] ?? user?.base_url ?? 'https://api.smritea.ai';
+  const appId = process.env['SMRITEA_APP_ID'] ?? project?.app_id;
+  const firstPersonUserId = process.env['SMRITEA_FIRST_PERSON_USER_ID'] ?? user?.first_person_user_id;
+
+  if (!apiKey) {
+    throw new Error(
+      'smritea API key not configured. Run: npx smritea-mcp init\n' +
+      `Or set SMRITEA_API_KEY env var.\n` +
+      `Config file expected at: ${USER_CONFIG_PATH}`
+    );
+  }
+  if (!appId) {
+    throw new Error(
+      'smritea app ID not configured. Run: npx smritea-mcp select-app <app_id>\n' +
+      `Or set SMRITEA_APP_ID env var.\n` +
+      `Config file expected at: ${PROJECT_CONFIG_PATH}`
+    );
+  }
+
+  return { apiKey, baseUrl, appId, firstPersonUserId };
+}

package/src/errors.ts

@@ -0,0 +1,15 @@
+export class McpConfigError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'McpConfigError';
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export class McpToolError extends Error {
+  constructor(message: string, public readonly cause?: unknown) {
+    super(message);
+    this.name = 'McpToolError';
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}

package/src/index.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { startServer } from './server.js';
+import { createInterface } from 'node:readline/promises';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+async function runInit(): Promise<void> {
+  const configDir = join(homedir(), '.smritea');
+  const configPath = join(configDir, 'mcp-config.json');
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const baseUrlAnswer = await rl.question('API base URL [https://api.smritea.ai]: ');
+    const baseUrl = baseUrlAnswer.trim() || 'https://api.smritea.ai';
+
+    const apiKeyAnswer = await rl.question('API key: ');
+    const apiKey = apiKeyAnswer.trim();
+    if (!apiKey) {
+      console.error('Error: API key is required.');
+      process.exit(1);
+    }
+
+    const firstPersonUserIdAnswer = await rl.question(
+      'Your name or user ID (used when you say "I prefer…", "I like…") [optional]: ',
+    );
+    const firstPersonUserId = firstPersonUserIdAnswer.trim() || undefined;
+
+    mkdirSync(configDir, { recursive: true });
+    const configData: Record<string, string> = { api_key: apiKey, base_url: baseUrl };
+    if (firstPersonUserId !== undefined) {
+      configData['first_person_user_id'] = firstPersonUserId;
+    }
+    writeFileSync(configPath, JSON.stringify(configData, null, 2) + '\n');
+
+    console.error('✓ Config saved to ' + configPath);
+    if (firstPersonUserId !== undefined) {
+      console.error(`✓ First-person user ID set to: ${firstPersonUserId}`);
+    }
+    console.error('Next: use the select_app tool in your AI assistant to set an app ID.');
+  } finally {
+    rl.close();
+  }
+}
+
+const subcommand = process.argv[2];
+
+if (subcommand === 'serve' || subcommand === undefined) {
+  startServer().catch((err: unknown) => {
+    console.error('Fatal:', err);
+    process.exit(1);
+  });
+} else if (subcommand === 'init') {
+  runInit().catch((err: unknown) => {
+    console.error('Init failed:', err);
+    process.exit(1);
+  });
+} else {
+  console.error(`Unknown subcommand: ${subcommand}`);
+  console.error('Usage: smritea-mcp [serve|init]');
+  process.exit(1);
+}

package/src/server.ts

@@ -0,0 +1,119 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { SmriteaClient } from 'smritea-sdk';
+import { loadConfig } from './config.js';
+import { AddMemoryInput, SearchMemoriesInput, GetMemoryInput, DeleteMemoryInput, SelectAppInput } from './types.js';
+import {
+  handleAddMemory,
+  handleSearchMemories,
+  handleGetMemory,
+  handleDeleteMemory,
+} from './tools/memory.js';
+import { handleSelectApp, handleListApps } from './tools/app.js';
+
+export async function startServer(): Promise<void> {
+  const config = loadConfig();
+
+  const client = new SmriteaClient({
+    apiKey: config.apiKey,
+    appId: config.appId,
+    baseUrl: config.baseUrl,
+  });
+
+  const server = new McpServer(
+    { name: 'smritea', version: '0.1.0' },
+    {
+      instructions:
+        'smritea is a persistent AI memory system. Use it to remember facts, preferences, ' +
+        'decisions, and context across conversations. Proactively store anything the user tells ' +
+        'you that they would want recalled later. Before starting work on a task, search memories ' +
+        'to surface relevant context the user may not have re-stated. When the user says "remember" ' +
+        'or "don\'t forget", always call add_memory immediately.',
+    },
+  );
+
+  const firstPersonUserId = config.firstPersonUserId;
+
+  server.tool(
+    'add_memory',
+    'Store a memory in smritea. Call this whenever the user shares a preference, decision, fact ' +
+    'about themselves, or anything they would want recalled in a future conversation. Do not wait ' +
+    'to be asked — if the user says "I prefer X", "my X is Y", "remember that", or "don\'t forget", ' +
+    'call this immediately. If the user says "I" or refers to themselves, omit user_id — it is ' +
+    'automatically set to the configured default.',
+    AddMemoryInput.shape,
+    async (input) => handleAddMemory(client, AddMemoryInput.parse(input), firstPersonUserId),
+  );
+
+  server.tool(
+    'search_memories',
+    'Search smritea memories by natural language query. Call this at the start of a new task or ' +
+    'topic to surface relevant context — user preferences, past decisions, stated constraints — ' +
+    'without waiting for the user to re-explain them. Also call when the user asks "do you remember", ' +
+    '"what do you know about", or "remind me". Omit user_id when searching for the current user\'s ' +
+    'own memories — it defaults to the configured user automatically.',
+    SearchMemoriesInput.shape,
+    async (input) => handleSearchMemories(client, SearchMemoriesInput.parse(input), firstPersonUserId),
+  );
+
+  server.tool(
+    'get_memory',
+    'Retrieve a specific memory by its ID. Use when you already have a memory_id from a previous ' +
+    'search result and need the full memory object.',
+    GetMemoryInput.shape,
+    async (input) => handleGetMemory(client, GetMemoryInput.parse(input)),
+  );
+
+  server.tool(
+    'delete_memory',
+    'Permanently delete a memory by its ID. Use when the user explicitly asks to forget something ' +
+    'or says a stored fact is no longer true. This action is irreversible — confirm the memory_id ' +
+    'from a search result before deleting.',
+    DeleteMemoryInput.shape,
+    async (input) => handleDeleteMemory(client, DeleteMemoryInput.parse(input)),
+  );
+
+  server.tool(
+    'select_app',
+    'Set the active smritea app for this project. Writes a project-scoped config to ' +
+    '.smritea/config.json so all subsequent memory operations use this app. Call this once ' +
+    'when setting up smritea in a new project.',
+    SelectAppInput.shape,
+    (input) => handleSelectApp(SelectAppInput.parse(input)),
+  );
+
+  server.tool(
+    'list_apps',
+    'Show the currently configured smritea app for this project. Useful for confirming which ' +
+    'app memories are being stored under.',
+    {},
+    () => handleListApps(config),
+  );
+
+  server.prompt(
+    'recall',
+    'Search your smritea memories and surface everything relevant to the current topic or task. ' +
+    'Use this at the start of a conversation or when switching context.',
+    { topic: z.string().describe('The topic, task, or question to search memories for') },
+    ({ topic }) => ({
+      messages: [
+        {
+          role: 'user' as const,
+          content: {
+            type: 'text' as const,
+            text:
+              `Search my smritea memories for everything relevant to: "${topic}"\n\n` +
+              'Retrieve the most relevant results and summarise what you find before we continue. ' +
+              'If you find preferences, constraints, or past decisions related to this topic, ' +
+              'apply them proactively without waiting for me to re-state them.',
+          },
+        },
+      ],
+    }),
+  );
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('smritea MCP server running (stdio)');
+}

package/src/tools/app.ts

@@ -0,0 +1,59 @@
+import { mkdirSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { SelectAppInput } from '../types.js';
+import type { ResolvedConfig } from '../config.js';
+
+const SMRITEA_DIR = join(process.cwd(), '.smritea');
+const CONFIG_PATH = join(SMRITEA_DIR, 'config.json');
+const GITIGNORE_PATH = join(SMRITEA_DIR, '.gitignore');
+
+export function handleSelectApp(input: SelectAppInput): CallToolResult {
+  mkdirSync(SMRITEA_DIR, { recursive: true });
+
+  const config: { app_id: string; app_name?: string } = { app_id: input.app_id };
+  if (input.app_name !== undefined) {
+    config.app_name = input.app_name;
+  }
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+
+  // Prevent committing the project-scoped config — it is machine/project-local
+  if (!existsSync(GITIGNORE_PATH)) {
+    writeFileSync(GITIGNORE_PATH, 'config.json\n', 'utf-8');
+  }
+
+  const name = input.app_name !== undefined ? ` (${input.app_name})` : '';
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `App selected: ${input.app_id}${name}\nConfig written to: ${CONFIG_PATH}\nAll memory operations in this project will now use this app.`,
+      },
+    ],
+  };
+}
+
+/**
+ * list_apps — stub.
+ *
+ * Listing apps via API key is not yet supported by the smritea SDK API.
+ * API key auth is scoped to a single app; a dedicated /api/v1/sdk/apps
+ * endpoint is needed before this can enumerate all apps for an organisation.
+ *
+ * For now, returns the currently active app from config.
+ */
+export function handleListApps(config: ResolvedConfig): CallToolResult {
+  return {
+    content: [
+      {
+        type: 'text',
+        text: [
+          `Currently active app: ${config.appId}`,
+          '',
+          'Note: listing all apps is not yet available via API key auth.',
+          'To switch apps, use the select_app tool with the desired app ID.',
+        ].join('\n'),
+      },
+    ],
+  };
+}

package/src/tools/memory.ts

@@ -0,0 +1,102 @@
+import { SmriteaClient, SmriteaError, SmriteaRateLimitError } from 'smritea-sdk';
+import type { Memory, SearchResult } from 'smritea-sdk';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { AddMemoryInput, SearchMemoriesInput, GetMemoryInput, DeleteMemoryInput } from '../types.js';
+
+export function formatMemory(memory: Memory): string {
+  return JSON.stringify(memory, null, 2);
+}
+
+export function formatSearchResult(result: SearchResult): string {
+  return JSON.stringify({ score: result.score, memory: result.memory }, null, 2);
+}
+
+export function formatError(err: unknown): string {
+  if (err instanceof SmriteaRateLimitError && err.retryAfter !== undefined) {
+    return `${err.message} (retry after ${err.retryAfter}s)`;
+  }
+  if (err instanceof SmriteaError) {
+    return err.message;
+  }
+  return String(err);
+}
+
+export async function handleAddMemory(
+  client: SmriteaClient,
+  input: AddMemoryInput,
+  firstPersonUserId?: string,
+): Promise<CallToolResult> {
+  try {
+    const memory = await client.add(input.content, {
+      userId: input.user_id ?? firstPersonUserId,
+      metadata: input.metadata,
+    });
+    return {
+      content: [{ type: 'text', text: formatMemory(memory) }],
+    };
+  } catch (err) {
+    return { isError: true, content: [{ type: 'text', text: formatError(err) }] };
+  }
+}
+
+export async function handleSearchMemories(
+  client: SmriteaClient,
+  input: SearchMemoriesInput,
+  firstPersonUserId?: string,
+): Promise<CallToolResult> {
+  try {
+    const results = await client.search(input.query, {
+      userId: input.user_id ?? firstPersonUserId,
+      limit: input.limit,
+      method: input.method,
+      threshold: input.threshold,
+      graphDepth: input.graph_depth,
+      conversationId: input.conversation_id,
+    });
+
+    if (results.length === 0) {
+      return {
+        content: [{ type: 'text', text: 'No memories found.' }],
+      };
+    }
+
+    const formatted = JSON.stringify(
+      results.map((r) => ({ score: r.score, memory: r.memory })),
+      null,
+      2,
+    );
+    return {
+      content: [{ type: 'text', text: formatted }],
+    };
+  } catch (err) {
+    return { isError: true, content: [{ type: 'text', text: formatError(err) }] };
+  }
+}
+
+export async function handleGetMemory(
+  client: SmriteaClient,
+  input: GetMemoryInput,
+): Promise<CallToolResult> {
+  try {
+    const memory = await client.get(input.memory_id);
+    return {
+      content: [{ type: 'text', text: formatMemory(memory) }],
+    };
+  } catch (err) {
+    return { isError: true, content: [{ type: 'text', text: formatError(err) }] };
+  }
+}
+
+export async function handleDeleteMemory(
+  client: SmriteaClient,
+  input: DeleteMemoryInput,
+): Promise<CallToolResult> {
+  try {
+    await client.delete(input.memory_id);
+    return {
+      content: [{ type: 'text', text: `Memory ${input.memory_id} deleted.` }],
+    };
+  } catch (err) {
+    return { isError: true, content: [{ type: 'text', text: formatError(err) }] };
+  }
+}

package/src/types.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+
+export const AddMemoryInput = z.object({
+  content: z.string().min(1).describe('The memory content to store'),
+  user_id: z.string().optional().describe('User ID to associate with this memory'),
+  metadata: z.record(z.string(), z.unknown()).optional().describe('Optional key-value metadata'),
+});
+export type AddMemoryInput = z.infer<typeof AddMemoryInput>;
+
+export const SearchMemoriesInput = z.object({
+  query: z.string().min(1).describe('Natural language search query'),
+  user_id: z.string().optional().describe('Filter memories by user ID'),
+  limit: z.number().int().positive().optional().describe('Maximum number of results'),
+  method: z.string().optional().describe('Search method: quick_search, deep_search, context_aware_search'),
+  threshold: z.number().min(0).max(1).optional().describe('Minimum relevance score (0.0-1.0)'),
+  graph_depth: z.number().int().positive().optional().describe('Graph traversal depth override'),
+  conversation_id: z.string().optional().describe('Filter to a specific conversation'),
+});
+export type SearchMemoriesInput = z.infer<typeof SearchMemoriesInput>;
+
+export const GetMemoryInput = z.object({
+  memory_id: z.string().min(1).describe('The memory ID to retrieve'),
+});
+export type GetMemoryInput = z.infer<typeof GetMemoryInput>;
+
+export const DeleteMemoryInput = z.object({
+  memory_id: z.string().min(1).describe('The memory ID to delete'),
+});
+export type DeleteMemoryInput = z.infer<typeof DeleteMemoryInput>;
+
+export const SelectAppInput = z.object({
+  app_id: z.string().min(1).describe('The smritea app ID to use for this project'),
+  app_name: z.string().optional().describe('Optional display name for the app'),
+});
+export type SelectAppInput = z.infer<typeof SelectAppInput>;