Build a personal assistant

Build an AI assistant that remembers each user's preferences, history, and context for personalized responses.

Build an assistant that learns and remembers each user's preferences, history, and context. Every response is personalized — the assistant knows what the user likes, what they've done, and what they need.

Prerequisites

A MemoryKit API key (get one here)
Node.js 18+ or Python 3.8+
A user authentication system (to get user IDs)

Step 1: Register users

Create users in MemoryKit so memories can be scoped per person.

import { MemoryKit } from "memorykit";
const mk = new MemoryKit({ apiKey: process.env.MEMORYKIT_API_KEY! });
 
// Upsert is idempotent — safe to call on every login
async function onUserLogin(user: { id: string; name: string; email: string }) {
  await mk.users.upsert({
    id: user.id,
    name: user.name,
    email: user.email,
    metadata: { plan: "pro", timezone: "America/New_York" },
  });
}

Step 2: Store per-user memories

Every memory is scoped to a user with userId. Users never see each other's data.

// Store user preferences
await mk.memories.create({
  content: "Prefers dark mode, metric units, and concise answers. Favorite programming language: Python.",
  userId: "user_123",
  tags: ["preferences"],
});
 
// Store conversation context
await mk.memories.create({
  content: "Working on a React migration from class components to hooks. Started last week.",
  userId: "user_123",
  tags: ["project-context"],
});
 
// Store learned facts from interactions
await mk.memories.create({
  content: "User is a senior engineer at Acme Corp. Team lead for the frontend team.",
  userId: "user_123",
  tags: ["profile"],
});

Step 3: Personalized search

Pass userId and MemoryKit only retrieves that user's memories. Feed the results into your own LLM with custom instructions for personalized responses.

async function searchForUser(userId: string, question: string) {
  return mk.memories.search({
    query: question,
    userId,
    limit: 5,
  });
}
 
const results = await searchForUser("user_123", "hooks migration commit message");
// Feed results into your own LLM with personalization instructions
for (const hit of results.results) {
  console.log(`[${hit.score.toFixed(2)}] ${hit.content}`);
}

Step 4: Search across user context

Use search to retrieve user-specific context for each interaction. Combine multiple searches to gather preferences, project context, and history.

// Search user's memories for relevant context
const priorities = await mk.memories.search({
  query: "current projects and priorities",
  userId: "user_123",
  limit: 5,
});
 
const preferences = await mk.memories.search({
  query: "response preferences and style",
  userId: "user_123",
  limit: 3,
  tags: "preferences",
});
 
// Feed both into your LLM for a personalized response
console.log("Context:", priorities.results.map((r) => r.content));
console.log("Preferences:", preferences.results.map((r) => r.content));

Step 5: Track interactions with events

Log user actions as events to enrich future personalization.

// Track what the user does
await mk.users.createEvent("user_123", {
  type: "query",
  data: { question: "hooks migration commit message", helpful: true },
});
 
await mk.users.createEvent("user_123", {
  type: "preference_update",
  data: { key: "response_length", value: "concise" },
});
 
// Review events later for analytics
const events = await mk.users.listEvents("user_123", { type: "query", limit: 50 });
console.log(`User made ${events.length} queries`);

Step 6: Learn from interactions

After each conversation, extract and store new facts about the user. Use your own LLM to extract facts, then store them as memories.

// After a conversation, store learned facts as new memories
async function learnFromConversation(userId: string, extractedFacts: string) {
  await mk.memories.create({
    content: extractedFacts,
    userId,
    tags: ["learned", "auto-extracted"],
    metadata: { source: "conversation", extracted_at: new Date().toISOString() },
  });
}
 
// Example: your LLM extracts facts, then you store them
const facts = "User is working on a React hooks migration. Prefers bullet-point summaries.";
await learnFromConversation("user_123", facts);

When a user requests data deletion, one call removes everything.

// Delete user and ALL associated data (memories, events, chats)
await mk.users.delete("user_123", { cascade: true });

Summary

What	How
Register users	`users.upsert()` on login
Per-user memory	`memories.create()` with `userId`
Personalized search	`search()` with `userId`
Search across context	Multiple `search()` calls with filters
Track behavior	`users.createEvent()`
Learn over time	Extract facts → store as memories
GDPR delete	`users.delete(id, { cascade: true })`

Key features used: Users, User-scoped search, Events, GDPR erasure

Build a personal assistant

On this page