NotebookLM × Antigravity — Building Context-Aware Codebase Knowledge Agents

// mcp/notebooklm-server.ts
import Anthropic from "@anthropic-ai/sdk";
 
interface NotebookQuery {
  notebook_id: string;
  query: string;
  max_results?: number;
  context_depth?: "shallow" | "deep"; // shallow: direct matches, deep: multi-hop relationships
  focus_area?: string; // e.g., "performance", "security", "migration"
}
 
interface ContextResult {
  source: string; // filename or section
  relevance: number; // 0.0 to 1.0
  excerpt: string; // relevant text, ~300-500 chars
  related_items: string[]; // other sections this connects to
  confidence: number; // how certain we are this answers the query
}
 
class NotebookLMMCPServer {
  private client: Anthropic;
  private notebookCache: Map<string, string> = new Map();
  private queryCache: Map<string, ContextResult[]> = new Map();
 
  async queryNotebook(req: NotebookQuery): Promise<ContextResult[]> {
    // Check cache first (queries are expensive)
    const cacheKey = `${req.notebook_id}:${req.query}:${req.context_depth}`;
    if (this.queryCache.has(cacheKey)) {
      return this.queryCache.get(cacheKey)!;
    }
 
    // Fetch the notebook content (pre-exported or via API)
    const notebookContent = await this.fetchNotebook(req.notebook_id);
 
    // Use Claude to search within the notebook
    const message = await this.client.messages.create({
      model: "claude-3-5-sonnet-20241022",
      max_tokens: 2000,
      system: `You are a specialized knowledge retrieval system for a codebase.
Given a notebook of codebase documentation, extract the most relevant information.
 
For each result, provide:
- source: exact section name or filename
- relevance: confidence 0.0-1.0
- excerpt: the key relevant text
- related_items: ["Section A", "Section B"] - what else is connected
- confidence: how certain this directly answers the user's question
 
Return results as a valid JSON array.`,
      messages: [
        {
          role: "user",
          content: `Documentation:\n\n${notebookContent}\n\nQuestion: ${req.query}\n\nFind the ${req.max_results || 5} most relevant results.${req.focus_area ? ` Focus on ${req.focus_area}.` : ""}`,
        },
      ],
    });
 
    const results = this.parseResults(message.content[0]);
 
    // Cache for future requests
    this.queryCache.set(cacheKey, results);
    if (this.queryCache.size > 1000) {
      // LRU eviction if cache grows too large
      const firstKey = this.queryCache.keys().next().value;
      this.queryCache.delete(firstKey);
    }
 
    return results;
  }
 
  private async fetchNotebook(notebookId: string): Promise<string> {
    if (this.notebookCache.has(notebookId)) {
      return this.notebookCache.get(notebookId)!;
    }
 
    // TODO: Integrate with NotebookLM API or load from storage
    // For now, assume pre-exported markdown
    const content = await this.loadFromFileSystem(notebookId);
    this.notebookCache.set(notebookId, content);
    return content;
  }
 
  private parseResults(content: any): ContextResult[] {
    try {
      const parsed = JSON.parse(content.text);
      return Array.isArray(parsed) ? parsed : [];
    } catch {
      console.error("Failed to parse NotebookLM response");
      return [];
    }
  }
}
 
export default NotebookLMMCPServer;

// In Antigravity IDE
agent.registerMCPTool("notebook_query", {
  description: "Query the NotebookLM codebase knowledge base",
  inputSchema: {
    type: "object",
    properties: {
      query: {
        type: "string",
        description: "Natural language question about codebase architecture, patterns, or decisions",
      },
      context_depth: {
        type: "string",
        enum: ["shallow", "deep"],
        default: "shallow",
      },
      focus_area: {
        type: "string",
        enum: ["performance", "security", "reliability", "maintainability"],
      },
    },
    required: ["query"],
  },
});
 
// Agent uses it autonomously
agent.think(
  "I need to refactor getUserData(). Let me check what the current design expects."
);
 
// Internally executes:
const context = await agent.callMCPTool("notebook_query", {
  query: "getUserData function: responsibilities, dependencies, error handling patterns",
  context_depth: "deep",
  focus_area: "reliability",
});
 
// Returns with specific knowledge about this function's role
console.log(context);
// [
//   {
//     source: "ARCHITECTURE.md",
//     relevance: 0.95,
//     excerpt: "Data retrieval layer handles async operations with Suspense...",
//     related_items: ["ERROR_HANDLING.md", "TESTING_STRATEGY.md"]
//   },
//   ...
// ]

// Antigravity Manager Surface
class CodebaseCoordinationManager {
  async refactorComponentWithFullAnalysis(
    componentPath: string,
    refactoringGoal: string
  ): Promise<ComprehensiveRefactoringPlan> {
    // 1. Architecture Agent: What are the blast radius & dependencies?
    const architectureAnalysis = await this.architectureAgent.analyze({
      query: `What components depend on ${componentPath}?
              What would break if we change this?
              Which systems would this affect?`,
      focus_area: "reliability",
    });
 
    // 2. Code Quality Agent: What's the best approach?
    const implementationStrategy = await this.codeQualityAgent.generate({
      query: `${refactoringGoal} for ${componentPath}.
              Follow our project patterns.
              Include tests.`,
      context: architectureAnalysis,
    });
 
    // 3. Performance Agent: What's the impact?
    const performanceReview = await this.performanceAgent.evaluate({
      proposed_code: implementationStrategy,
      baseline_metrics: await this.getMetrics(componentPath),
      query: "Will this improve or degrade performance? Bundle size?",
    });
 
    // 4. Security Agent: Any risks?
    const securityReview = await this.securityAgent.review({
      changes: implementationStrategy,
      affected_systems: architectureAnalysis.dependencies,
    });
 
    // 5. Documentation Agent: Update guides
    const docUpdates = await this.documentationAgent.generate({
      changes: implementationStrategy,
      reason: refactoringGoal,
    });
 
    // Synthesize into a comprehensive plan
    return {
      architecture: architectureAnalysis,
      implementation: implementationStrategy,
      performance: performanceReview,
      security: securityReview,
      documentation: docUpdates,
      executionOrder: this.determineExecutionOrder([
        architectureAnalysis,
        implementationStrategy,
        performanceReview,
        securityReview,
      ]),
      rollbackStrategy: await this.planRollback(
        architectureAnalysis.dependencies
      ),
      approvalCheckpoints: this.identifyHumanCheckpoints(
        performanceReview,
        securityReview
      ),
    };
  }
}

# State Management Architecture
 
## Current System (Redux)
- Redux store location: `src/store/redux/`
- Selectors: `src/selectors/*` (48 files, 3000+ lines)
- Actions: `src/actions/*` (32 files, 2500+ lines)
- Test coverage: 89%
 
**Pain points:**
- Boilerplate: 1 action = 5-8 files (action, type, reducer, selector)
- DevTools coupling: Redux DevTools middleware required
- Bundle size: Redux + middleware = 45KB (gzipped)
 
## Target System (Zustand)
- Store files: `src/stores/zustand/*.ts`
- Philosophy: Minimal boilerplate, functional API
- Bundle size estimate: 12KB (gzipped)
 
## Migration Strategy
 
### Phase 1: Global State (Week 1-2)
- User authentication store
- Theme/preferences store
- Global UI state (modals, notifications)
 
### Phase 2: Domain Stores (Week 3-4)
- Product management (currently Redux ProductSlice)
- Cart management (Redux CartSlice)
- Orders (Redux OrdersSlice)
 
### Phase 3: Local State Conversion (Week 5)
- Complex local Redux stores → Zustand
- Cleanup: Remove Redux library
 
## Pattern Equivalency Guide
 
### Redux Selector → Zustand Pattern
```typescript
// Redux: const user = useSelector(selectUser)
// Zustand: const user = useUserStore(s => s.user)

// Redux: dispatch(setUser(data))
// Zustand: useUserStore.setState({user: data})

// Execute migration in manageable chunks with continuous learning
 
for (const phase of refactoringPlan.phases) {
  console.log(`Executing: ${phase.name}`);
 
  // Generate and review code
  const generatedCode = await agent.generate(phase);
  const review = await human_review(generatedCode); // Developer reviews in IDE
 
  // Run tests
  const testResults = await runTests(phase.affected_files);
 
  if (!testResults.allPassed) {
    // **Learn from failures**: Update NotebookLM with lessons
    await notebookLM.addNote({
      title: `Migration Issue: ${testResults.failedTest}`,
      root_cause: await agent.analyze(testResults.failure),
      resolution: "...",
      lesson_for_next_phase: "When handling store subscriptions, remember...",
    });
 
    // **Adjust next phase** based on what we learned
    const nextPhaseAdjustments = await archAgent.replan({
      lessons_learned: notebookLM.getRecentNotes(),
      original_plan: refactoringPlan.phases[i + 1],
    });
 
    refactoringPlan.phases[i + 1] = nextPhaseAdjustments;
  }
 
  // Measure actual vs predicted metrics
  const actualMetrics = await measure({
    bundleSize: "after compilation",
    performance: "run lighthouse",
    coverage: "run coverage report",
  });
 
  const prediction = perfPredictions[phase];
  const accuracy = calculateAccuracy(prediction, actualMetrics);
 
  // Store metrics for next refactoring's accuracy improvement
  await notebookLM.recordMetrics({
    phase: phase.name,
    predicted: prediction,
    actual: actualMetrics,
    accuracy: accuracy,
  });
}

// Daily sync pipeline
class NotebookSyncManager {
  async runDailySync() {
    // 1. Detect what changed in the codebase
    const gitDiff = await git.getDiff("HEAD~1", "HEAD", [
      "src/",
      "docs/",
      ".adr-dir/",
    ]);
 
    // 2. Classify changes (some require doc updates, others don't)
    for (const change of gitDiff) {
      const classification = await classifyImpact(change);
 
      if (classification === "ARCHITECTURE_CHANGE") {
        // e.g., new module, major refactor
        const updatedArchDoc = await autoGenerate.architecture(change);
        await updateFile("docs/ARCHITECTURE.md", updatedArchDoc);
      } else if (classification === "API_CHANGE") {
        // e.g., public interface modified
        const updatedAPI = await autoGenerate.publicAPI(change);
        await updateFile("docs/PUBLIC_API.md", updatedAPI);
      } else if (classification === "PATTERN_CHANGE") {
        // e.g., new pattern adopted
        const updatedPatterns = await autoGenerate.patterns(change);
        await updateFile("docs/CODE_PATTERNS.md", updatedPatterns);
      }
    }
 
    // 3. Push updated docs to NotebookLM
    await notebookLM.sync({
      updateSections: Object.keys(changedDocs),
      retainHistory: true, // Keep version history
    });
 
    console.log(`Synced ${Object.keys(changedDocs).length} doc sections`);
  }
}
 
// Run daily (e.g., via GitHub Actions)
schedule.daily("03:00 UTC", () => new NotebookSyncManager().runDailySync());

import { NotebookLMClient } from "@google-cloud/notebooklm";
 
const nlm = new NotebookLMClient({ apiKey: process.env.NOTEBOOKLM_API_KEY });
 
// 1. Generate Podcast: Turn architecture docs into audio guides
const podcast = await nlm.generatePodcast({
  notebookId: "antigravity-codebase",
  sourceDocuments: ["ARCHITECTURE.md", "DESIGN_PATTERNS.md"],
  audienceLevel: "advanced_engineer",
  style: "discussion", // 2 speakers discussing the topic
  duration: 30, // minutes
});
 
// Use for onboarding new team members
await onboarding.addResource({
  type: "audio",
  url: podcast.publicUrl,
  title: "Architecture Overview (30 min)",
  assignedTo: newEngineer,
});
 
// 2. Manage Notebook Collections: Connect related notebooks
await nlm.createCollection({
  name: "Antigravity Codebase",
  description: "All documentation and knowledge for the Antigravity IDE codebase",
  notebooks: [
    { id: "arch-notebook", role: "source_of_truth" },
    { id: "performance-notebook", role: "derived_analysis" },
    { id: "migration-notebook", role: "execution_plan" },
    { id: "decision-records", role: "historical" },
  ],
  enableCrossReferences: true,
});
 
// Now queries can reference across notebooks
const query = await nlm.query({
  collectionId: "Antigravity Codebase",
  question: "How does the migration to Zustand impact performance according to ARCHITECTURE.md and PERFORMANCE_TUNING.md?",
});