NotebookLM × Antigravity — コードベース知識ベースとAIエージェントの高度な連携

// mcp/notebooklm-server.ts
import Anthropic from "@anthropic-ai/sdk";
 
interface NotebookQuery {
  notebook_id: string;
  query: string;
  max_results?: number;
  context_depth?: "shallow" | "deep"; // 浅い = 直接関連, 深い = 多層的関連性
}
 
interface ContextResult {
  source: string;
  relevance: number; // 0.0 ~ 1.0
  content: string;
  related_items: string[];
}
 
class NotebookLMMCPServer {
  private client: Anthropic;
  private notebookCache: Map<string, string> = new Map();
 
  async queryNotebook(req: NotebookQuery): Promise<ContextResult[]> {
    // 1. NotebookLMに存在するノートブックから該当セッションを取得
    const notebookContent = await this.fetchNotebook(req.notebook_id);
 
    // 2. Claudeに「コンテキストウィンドウ内で」検索を実行
    const message = await this.client.messages.create({
      model: "claude-3-5-sonnet-20241022",
      max_tokens: 2000,
      system: `You are a knowledge retrieval specialist for a codebase documented in NotebookLM.
Your task is to search the provided codebase documentation and return relevant context.
For each result, include:
- source: the file/section name
- relevance: a confidence score 0.0-1.0
- content: the actual relevant text (max 500 chars each)
- related_items: references to connected concepts`,
      messages: [
        {
          role: "user",
          content: `Codebase Documentation:\n\n${notebookContent}\n\nQuery: ${req.query}\n\nReturn up to ${req.max_results || 5} most relevant items as JSON array.`,
        },
      ],
    });
 
    // 3. 結果をパース＆標準化
    return this.parseResults(message.content[0]);
  }
 
  private async fetchNotebook(notebookId: string): Promise<string> {
    // NotebookLM Enterprise API or stored export
    if (this.notebookCache.has(notebookId)) {
      return this.notebookCache.get(notebookId)!;
    }
 
    // TODO: Call NotebookLM API to fetch notebook
    // For now, assume pre-exported markdown/PDF content
    const content = await this.loadFromStorage(notebookId);
    this.notebookCache.set(notebookId, content);
    return content;
  }
 
  private parseResults(content: any): ContextResult[] {
    // Parse Claude's structured response into ContextResult[]
    try {
      return JSON.parse(content.text);
    } catch {
      return [];
    }
  }
}
 
export default NotebookLMMCPServer;

// Antigravity agent にMCPツールを登録
agent.registerMCPTool("notebook_query", {
  description: "Query the NotebookLM codebase knowledge base",
  inputSchema: {
    type: "object",
    properties: {
      query: {
        type: "string",
        description: "Natural language question about the codebase",
      },
      context_depth: {
        type: "string",
        enum: ["shallow", "deep"],
        description: "How deep to search for related concepts",
      },
    },
  },
});

// Antigravity Manager Surface 統合例
class CodebaseCoordinationManager {
  async refactorComponent(
    componentPath: string,
    requirement: string
  ): Promise<RefactoringPlan> {
    // 1. Architecture Agent: 影響範囲の特定
    const impactAnalysis = await this.architectureAgent.analyze(
      `What components depend on ${componentPath}?`
    );
 
    // 2. Code Quality Agent: 最適な実装パターン
    const implementationPattern = await this.codeQualityAgent.suggest(
      `Refactor ${componentPath} to: ${requirement}`
    );
 
    // 3. Performance Agent: 性能上の懸念事項
    const perfReview = await this.performanceAgent.review(
      implementationPattern,
      impactAnalysis
    );
 
    // 4. すべての意見を統合
    return this.synthesizeResults({
      impact: impactAnalysis,
      implementation: implementationPattern,
      performance: perfReview,
    });
  }
}

# state-management-migration.md
 
## Current State (Redux)
- Store structure: src/store/redux/*
- Selectors pattern: src/selectors/*
- Action creators: src/actions/*
- Key pain points: [boilerplate, DevTools dependency]
 
## Target State (Context + Zustand)
- Design: stores/zustand/*.ts
- Integration points with React components
- Migration path: phase 1 (global state) → phase 2 (local modules)
 
## Affected Components & Dependencies Graph
[自動生成されたDOT形式のグラフ]
 
## ADR: Why Zustand?
Decision: 2026-03-15
Rationale: Better DX, smaller bundle, no boilerplate
Trade-offs: [...]
 
## Migration Checklist by Priority
[priority] Module → [estimated effort] → [risk level]

// Antigravity IDE のコマンドパレット例
> Refactor: Redux → Zustand (全体)
 
Manager Surface が以下を実行：
 
1. [Architecture Agent]
   Query: "redux状態管理全体の依存関係とセレクター一覧"
   → NotebookLM から store structure を取得
 
2. [Code Quality Agent]
   Query: "reduxのactionCreatorパターンから等価なZustandアクションを生成"
   → migration pattern に基づいて batch refactoring プラン作成
 
3. [Performance Agent]
   Query: "新しいアーキテクチャでバンドルサイズとレンダリング性能は改善されるか"
   → 影響分析、metrics 予測
 
4. [Documentation Agent]
   Query: "この移行に伴う開発ガイド更新"
   → MIGRATION_GUIDE.md 自動生成
 
↓ Manager が統合
 
Refactoring Plan:
├─ Phase 1: Global Store Migration (70 files)
├─ Phase 2: Module-Local State (43 files)
├─ Phase 3: Cleanup & Tests (automated)
├─ Rollback strategy & checkpoints
└─ Performance metrics baseline → post-migration

// Antigravity UI での段階的実行
for (const phase of refactoringPlan.phases) {
  const results = await executePhase(phase);
 
  // テスト実行
  const testResults = await runTests();
 
  if (!testResults.passed) {
    // NotebookLMに学習フィードバック
    await notebookLM.addNote(
      `Migration Issue: ${testResults.failedTest}
       Root Cause: [分析結果]
       Solution Applied: [修正内容]
       Lessons for next phase: [...]`
    );
 
    // 次フェーズの計画を再調整
    refactoringPlan.phases[i+1] = await
      archAgent.replan(notebookLM.getUpdatedKnowledge());
  }
}

// 継続的同期パイプライン
class NotebookSyncPipeline {
  async runDailySync() {
    // 1. ソースコード変更の検出
    const changes = await git.getDailyDiff([
      "src/",
      "docs/",
      ".adr-dir/"
    ]);
 
    // 2. 変更が「ドキュメント更新が必要」な種類か判定
    for (const change of changes) {
      const needsUpdate = await this.classifyChange(change);
 
      if (needsUpdate === "ARCHITECTURE_CHANGE") {
        // ARCHITECTURE.md + ADR を自動生成
        await this.updateArchitectureDoc(change);
      } else if (needsUpdate === "INTERFACE_CHANGE") {
        // interfaces.md, API_REFERENCE.md を自動生成
        await this.updateInterfaceDoc(change);
      }
    }
 
    // 3. 更新されたドキュメントをNotebookLMに投入
    await notebookLM.sync({
      replaceSections: updatedSections,
      retainHistory: true, // 過去の推移も保持
    });
  }
}

// NotebookLM Enterprise API 利用例
import { NotebookLMClient } from "@google-cloud/notebooklm";
 
const client = new NotebookLMClient({
  apiKey: process.env.NOTEBOOKLM_API_KEY,
});
 
// 1. Podcast generation API: 設計書から音声ガイドを生成
const podcast = await client.generatePodcast({
  notebookId: "my-codebase-notebook",
  sourceDocuments: ["ARCHITECTURE.md", "MIGRATION_GUIDE.md"],
  audienceLevel: "advanced_developer",
  format: "discussion", // narrator + expert discussion
});
 
// 生成されたポッドキャストを新規チームメンバーのオンボーディングで活用
await onboarding.addResource({
  type: "audio",
  url: podcast.publicUrl,
  title: "Architecture Deep Dive",
});
 
// 2. Notebook management API: ノートブック間の参照構造を管理
await client.createNotebookCollection({
  name: "Antigravity Codebase",
  notebooks: [
    { id: "arch-notebook", role: "source_of_truth" },
    { id: "performance-notebook", role: "derived_analysis" },
    { id: "migration-notebook", role: "execution_plan" },
  ],
  crossReferences: true, // ノートブック間の相互参照を有効化
});