Antigravity エージェントのメモリ設計パターン — セッションを超えてコンテキストを保持する実践ガイド

// memory/episode-store.ts
import { createClient } from '@supabase/supabase-js';
 
interface Episode {
  id: string;
  userId: string;
  sessionId: string;
  summary: string;
  keyFacts: string[];
  timestamp: string;
  embedding?: number[];
}
 
const supabase = createClient(
  process.env.SUPABASE_URL!,
  process.env.SUPABASE_KEY!
);
 
export async function saveEpisode(episode: Omit<Episode, 'id'>): Promise<void> {
  await supabase.from('episodes').insert(episode);
}
 
export async function recallRecentEpisodes(
  userId: string,
  limit = 5
): Promise<Episode[]> {
  const { data } = await supabase
    .from('episodes')
    .select('*')
    .eq('userId', userId)
    .order('timestamp', { ascending: false })
    .limit(limit);
 
  return data || [];
}

// skills/summarize-and-save.ts
export async function summarizeAndSave(
  conversationHistory: Message[],
  userId: string,
  sessionId: string
): Promise<void> {
  // Claude に要約させる
  const summary = await callClaude(`
    以下の会話を200字以内で要約し、重要な事実をJSON配列として抽出してください。
 
    会話履歴:
    ${conversationHistory.map(m => `${m.role}: ${m.content}`).join('\n')}
 
    レスポンス形式:
    {
      "summary": "...",
      "keyFacts": ["...", "..."]
    }
  `);
 
  const parsed = JSON.parse(summary);
 
  await saveEpisode({
    userId,
    sessionId,
    summary: parsed.summary,
    keyFacts: parsed.keyFacts,
    timestamp: new Date().toISOString(),
  });
}

// memory/semantic-store.ts
 
interface SemanticMemory {
  id: string;
  userId: string;
  content: string;
  embedding: number[];
  createdAt: string;
}
 
export async function embedAndStore(
  userId: string,
  fact: string
): Promise<void> {
  // OpenAI Embeddings API でベクトル化
  const embedding = await getEmbedding(fact);
 
  await supabase.from('semantic_memories').insert({
    userId,
    content: fact,
    embedding,
    createdAt: new Date().toISOString(),
  });
}
 
export async function recallRelevant(
  userId: string,
  query: string,
  topK = 5
): Promise<SemanticMemory[]> {
  const queryEmbedding = await getEmbedding(query);
 
  // pgvector の <=> 演算子でコサイン類似度検索
  const { data } = await supabase.rpc('match_memories', {
    query_embedding: queryEmbedding,
    match_user_id: userId,
    match_count: topK,
  });
 
  return data || [];
}

CREATE OR REPLACE FUNCTION match_memories(
  query_embedding vector(1536),
  match_user_id text,
  match_count int DEFAULT 5
)
RETURNS TABLE(
  id uuid,
  content text,
  similarity float
)
LANGUAGE sql
AS $$
  SELECT
    id,
    content,
    1 - (embedding <=> query_embedding) AS similarity
  FROM semantic_memories
  WHERE user_id = match_user_id
  ORDER BY embedding <=> query_embedding
  LIMIT match_count;
$$;

// agent/memory-augmented-agent.ts
export async function buildSystemPrompt(userId: string, currentQuery: string): Promise<string> {
  // 並列でメモリを取得
  const [recentEpisodes, relevantMemories] = await Promise.all([
    recallRecentEpisodes(userId, 3),
    recallRelevant(userId, currentQuery, 5),
  ]);
 
  const episodeContext = recentEpisodes.length > 0
    ? `## 最近のセッション記録\n${recentEpisodes.map(e => `- ${e.summary}`).join('\n')}`
    : '';
 
  const memoryContext = relevantMemories.length > 0
    ? `## 関連する記憶\n${relevantMemories.map(m => `- ${m.content}`).join('\n')}`
    : '';
 
  return `あなたはユーザーのパーソナルAIアシスタントです。
 
${episodeContext}
 
${memoryContext}
 
上記の記憶を参考にしながら、ユーザーを一貫して支援してください。
新しい重要な事実が出てきた場合は、それをメモとして記録することを提案してください。`;
}

// 30日経過したエピソードは自動削除
const EPISODE_TTL_DAYS = 30;
 
export async function cleanOldEpisodes(userId: string): Promise<void> {
  const cutoff = new Date();
  cutoff.setDate(cutoff.getDate() - EPISODE_TTL_DAYS);
 
  await supabase
    .from('episodes')
    .delete()
    .eq('userId', userId)
    .lt('timestamp', cutoff.toISOString());
}

export async function storeIfNovelFact(userId: string, fact: string): Promise<boolean> {
  const similar = await recallRelevant(userId, fact, 1);
 
  if (similar.length > 0 && similar[0].similarity > 0.92) {
    console.log('重複する記憶をスキップ:', fact);
    return false;
  }
 
  await embedAndStore(userId, fact);
  return true;
}

interface MemoryWithScore extends SemanticMemory {
  importanceScore: number;
  accessCount: number;
  lastAccessedAt: string;
}
 
// アクセスされるたびに重要度を更新
export async function accessMemory(memoryId: string): Promise<void> {
  await supabase.rpc('increment_importance', { memory_id: memoryId });
}

# Memory Manager Skill
 
## Description
ユーザーとのやりとりから重要な情報を抽出し、永続的なメモリに保存・参照するスキル。
 
## Triggers
- ユーザーが「覚えておいて」「メモして」と言ったとき
- 会話の中で新しいユーザープリファレンスが判明したとき
- セッション開始時・終了時
 
## Actions
1. **recall**: 現在のクエリに関連する記憶を取得
2. **store**: 新しい事実をセマンティック記憶に保存
3. **summarize**: セッション終了時にエピソード記憶を保存
4. **forget**: ユーザーが「忘れて」と言ったときに記憶を削除