THREE TIER AI LEARNING ARCHITECTURE
Ecosistema completo para organización y gestión de contenido con interfaces espaciales
🧠 Three-Tier AI Learning Architecture
Vision: AI That Learns at Every Level
GoGrab Space will have three distinct AI learning tiers, each serving different purposes but using the same proven methodology:
┌──────────────────────────────────────────────────────────────────────────────┐
│ THREE-TIER AI LEARNING SYSTEM │
├──────────────────────────────────────────────────────────────────────────────┤
│ │
│ TIER 1: DEVELOPMENT AI (Cursor/Claude) │
│ ┌────────────────────────────────────────────────────────────────────────┐ │
│ │ Purpose: Help developers build GoGrab Space better │ │
│ │ Learns: Codebase patterns, architecture decisions, what works here │ │
│ │ Storage: Workspace-level (local or project-specific MongoDB) │ │
│ │ Beneficiary: YOU (the developer) + AI assistants (Claude, etc.) │ │
│ └────────────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ TIER 2: PLATFORM AI (GoGrab Services) │
│ ┌────────────────────────────────────────────────────────────────────────┐ │
│ │ Purpose: Power AI features in GoGrab Space platform │ │
│ │ Learns: User interaction patterns, successful generations, prompts │ │
│ │ Storage: ai-agents database (central) │ │
│ │ Beneficiary: All users of GoGrab Space platform │ │
│ └────────────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ TIER 3: TENANT AI (Per-User Learning) │
│ ┌────────────────────────────────────────────────────────────────────────┐ │
│ │ Purpose: Personalized AI for each tenant's users │ │
│ │ Learns: User preferences, style, history, individual patterns │ │
│ │ Storage: tenant-specific collections (isolated) │ │
│ │ Beneficiary: Individual users within each tenant │ │
│ └────────────────────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
Table of Contents
- Tier 1: Development AI (Cursor/Claude)
- Tier 2: Platform AI (GoGrab Services)
- Tier 3: Tenant AI (Per-User Learning)
- Integration Points
- Database Architecture
- Implementation Roadmap
Tier 1: Development AI
What Is This?
When you work with Claude in Cursor on the GoGrab Space codebase, Claude should remember what works and what doesn't. This tier captures that learning.
Purpose
| Goal | How We Achieve It |
|---|---|
| Claude remembers codebase patterns | Store successful architectural decisions |
| Claude knows project conventions | Learn from code review feedback |
| Claude avoids repeated mistakes | Track what failed and why |
| Claude improves over time | Pattern mining on development decisions |
What Gets Learned
// Example: Development AI Decision
{
tier: "development",
context: "GoGrab Space codebase",
decision: {
question: "How should I structure a new Angular service?",
chosen: "Use inject() function, providedIn: root, follow existing patterns",
reasoning: "Project uses standalone components, inject() preferred over constructor DI",
confidence: 0.95,
},
codebaseContext: {
relevantFiles: ["CLAUDE.md", "libs/core/...", "existing-service.ts"],
conventions: ["standalone-only", "inject-function", "signals-first"],
patterns: ["service-structure-pattern-1", "error-handling-pattern-3"],
},
outcome: {
wasAccepted: true,
developerFeedback: "Perfect, exactly what I needed",
qualityRating: 5,
}
}
Storage Options for Development AI
| Option | Pros | Cons | Recommendation |
|---|---|---|---|
| Local JSON files | Simple, no setup | Not persistent across machines | Development only |
| Workspace MongoDB | Persistent, queryable | Requires local MongoDB | Good for solo dev |
| Cloud MongoDB | Shared across team | Requires connection | Best for teams |
| MCP Context Files | Native Cursor support | Limited structure | Supplement |
How Cursor/Claude Uses This
┌─────────────────────────────────────────────────────────────────────────┐
│ Developer asks: "Add a new service for handling user notifications" │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ 1. RETRIEVE RELEVANT KNOWLEDGE │
│ • Search: "service creation in GoGrab Space" │
│ • Found: 15 similar past decisions │
│ • Top pattern: "Injectable service with Signals" (94% success) │
│ │
│ 2. RETRIEVE CODEBASE CONVENTIONS │
│ • Must use inject() function │
│ • Must use OnPush change detection │
│ • Must follow file naming: kebab-case │
│ │
│ 3. RETRIEVE ANTI-PATTERNS │
│ • Don't use constructor injection (failed 3 times) │
│ • Don't create NgModules (not used in this codebase) │
│ │
│ 4. GENERATE WITH KNOWLEDGE │
│ Claude generates service following all learned patterns │
│ │
│ 5. LOG THIS DECISION │
│ Store for future learning │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Implementation: Cursor MCP Integration
We can create a custom MCP server that Claude in Cursor can use:
// tools/mcp-development-ai/src/server.ts
import { McpServer } from '@modelcontextprotocol/sdk';
const server = new McpServer({
name: 'gograb-development-ai',
version: '1.0.0',
});
// Tool: Log a development decision
server.tool('log_decision', async (params) => {
await developmentMemory.storeDecision({
question: params.question,
chosen: params.chosen,
reasoning: params.reasoning,
files: params.relevantFiles,
});
return { success: true };
});
// Tool: Find similar past decisions
server.tool('find_similar', async (params) => {
const similar = await developmentMemory.findSimilar(params.query);
return { decisions: similar };
});
// Tool: Get codebase conventions
server.tool('get_conventions', async () => {
return await developmentMemory.getConventions();
});
// Tool: Report outcome
server.tool('report_outcome', async (params) => {
await developmentMemory.updateOutcome(params.decisionId, params.outcome);
return { success: true };
});
Benefits for You (The Developer)
- Claude remembers what works in YOUR codebase
- No more repeating the same instructions
- Claude learns your preferences over time
- Mistakes are recorded and avoided
- New developers benefit from accumulated knowledge
Tier 2: Platform AI
What Is This?
The AI services that power GoGrab Space features (ai-chat, vibe-coding, prompt system). This tier learns what works for ALL users of the platform.
Components That Use Platform AI
| Component | Location | Current State | Learning Opportunity |
|---|---|---|---|
| AI Chat | @libs-ai/gograb-ai-lib |
Basic chat | Learn successful conversations |
| Vibe Coding | @libs-ai/gograb-ai-lib |
Exists | Learn successful generations |
| Prompt System | @libs-ai/prompt-system |
Template-based | Learn effective prompts |
| Widget Generator | Backend | New | Learn widget patterns |
| Module Generator | Backend | New | Learn module patterns |
What Gets Learned
// Example: Platform AI Learning
{
tier: "platform",
source: "ai-chat",
interaction: {
userRequest: "Create a dashboard widget showing sales data",
aiResponse: "Here's a dashboard widget with chart...",
generatedCode: "...",
},
metadata: {
taskType: "widget-generation",
technologies: ["angular", "charts", "dashboard"],
complexity: "medium",
},
outcome: {
wasUsed: true,
wasModified: false,
userRating: 5,
deployedToProduction: true,
},
patterns: {
successfulApproaches: ["Used signal-based state", "Applied existing theme"],
improvements: [],
}
}
Storage
Database: ai-agents (already set up!)
Collections:
agent_tasks- Task historyagent_embeddings- Semantic searchagent_patterns- Learned patternsagent_calibrations- Confidence calibration
Integration Points in libs-ai
libs/libs-ai/
├── gograb-ai/
│ ├── services/
│ │ ├── ai-chat.service.ts ← ADD: Log conversations
│ │ ├── vibe-coding-orchestrator.service.ts ← ADD: Log generations
│ │ ├── anthropic.service.ts ← ADD: Track API usage
│ │ └── openai.service.ts ← ADD: Track API usage
│ └── components/
│ └── ai-chat/ ← ADD: Feedback collection UI
│
├── prompt-system/
│ └── services/
│ ├── prompt-manager.service.ts ← ADD: Track prompt effectiveness
│ └── prompt-templates.service.ts ← ADD: Learn from usage
│
└── agent-orchestrator/
└── services/
├── agent-vibe-coding-bridge.service.ts ← EXISTING: Bridge
└── agent-platform-learning.service.ts ← NEW: Platform learning
Tier 3: Tenant AI
What Is This?
Personalized AI for each user within each tenant. Every user gets an AI that remembers THEIR preferences, style, and history.
The Vision
┌─────────────────────────────────────────────────────────────────────────┐
│ TENANT AI LEARNING │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ Tenant: "Acme Corp" │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ User: [email protected] │ │
│ │ ────────────────────────────────────────────────────────────────│ │
│ │ AI Knows: │ │
│ │ • Prefers dark theme │ │
│ │ • Likes detailed explanations │ │
│ │ • Works on e-commerce projects │ │
│ │ • Uses React (not Angular) │ │
│ │ • Prefers TypeScript strict mode │ │
│ │ • Common request: "Add product listings" │ │
│ │ │ │
│ │ Past Successful Interactions: 156 │ │
│ │ Learned Patterns: 23 │ │
│ │ Satisfaction Rating: 4.7/5 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ User: [email protected] │ │
│ │ ────────────────────────────────────────────────────────────────│ │
│ │ AI Knows: │ │
│ │ • Prefers light theme │ │
│ │ • Likes concise responses │ │
│ │ • Works on admin dashboards │ │
│ │ • Uses Angular │ │
│ │ • Prefers minimal dependencies │ │
│ │ • Common request: "Add data tables" │ │
│ │ │ │
│ │ Past Successful Interactions: 89 │ │
│ │ Learned Patterns: 15 │ │
│ │ Satisfaction Rating: 4.9/5 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
What Gets Learned Per User
// User Preference Learning
interface UserAIProfile {
userId: string;
tenantId: string;
// Communication preferences
preferences: {
responseStyle: 'detailed' | 'concise' | 'balanced';
technicalLevel: 'beginner' | 'intermediate' | 'expert';
preferredLanguage: string;
timezone: string;
};
// Technical preferences
techStack: {
frameworks: string[]; // ['angular', 'react', ...]
languages: string[]; // ['typescript', 'python', ...]
stylePreferences: Record<string, string>; // {'indentation': '2-spaces', ...}
};
// Behavioral patterns
patterns: {
commonRequests: string[]; // Most frequent request types
peakHours: number[]; // When they typically work
averageSessionLength: number;
};
// Learned from interactions
successfulApproaches: {
approach: string;
context: string;
successRate: number;
}[];
// Things to avoid
antiPatterns: {
approach: string;
reason: string;
occurrences: number;
}[];
// Satisfaction tracking
metrics: {
totalInteractions: number;
avgSatisfactionRating: number;
improvementTrend: number; // Is AI getting better for this user?
};
}
Database Architecture for Tenant AI
┌─────────────────────────────────────────────────────────────────────────┐
│ TENANT AI DATABASE STRUCTURE │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ Database per tenant: tenant_{tenantId}_ai │
│ OR │
│ Shared database with tenant isolation: gograb_tenant_ai │
│ │
│ Collections: │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ user_profiles │ │
│ │ ─────────────────────────────────────────────────────────────── │ │
│ │ • userId (indexed) │ │
│ │ • tenantId (indexed) │ │
│ │ • preferences │ │
│ │ • techStack │ │
│ │ • patterns │ │
│ │ • metrics │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ user_interactions │ │
│ │ ─────────────────────────────────────────────────────────────── │ │
│ │ • userId (indexed) │ │
│ │ • tenantId (indexed) │ │
│ │ • timestamp │ │
│ │ • request │ │
│ │ • response │ │
│ │ • feedback │ │
│ │ • embedding (vector) │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ user_embeddings │ │
│ │ ─────────────────────────────────────────────────────────────── │ │
│ │ • userId (indexed) │ │
│ │ • tenantId (indexed) │ │
│ │ • interactionId │ │
│ │ • embedding (vector - 1536 dims) │ │
│ │ • qualityRating │ │
│ │ • wasSuccessful │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ user_patterns │ │
│ │ ─────────────────────────────────────────────────────────────── │ │
│ │ • userId (indexed) - OR null for tenant-wide patterns │ │
│ │ • tenantId (indexed) │ │
│ │ • pattern │ │
│ │ • successRate │ │
│ │ • supportCount │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
How Tenant AI Works
┌─────────────────────────────────────────────────────────────────────────┐
│ User "[email protected]" asks: "Build me a product catalog" │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ 1. LOAD USER PROFILE │
│ • Tenant: Acme Corp │
│ • Preferences: Detailed responses, React, TypeScript │
│ • Past success: E-commerce components (92% satisfaction) │
│ │
│ 2. SEARCH USER'S MEMORY │
│ • Similar past requests from THIS user │
│ • "Built product grid last month" - user liked card layout │
│ • "Built inventory list" - user preferred data tables │
│ │
│ 3. SEARCH TENANT PATTERNS (shared across Acme users) │
│ • Acme standard: Use company design system │
│ • Acme standard: Include accessibility features │
│ │
│ 4. PERSONALIZED GENERATION │
│ AI generates using: │
│ • John's preferred framework (React) │
│ • John's past successful patterns (card layouts) │
│ • Acme's standards (design system, a11y) │
│ • Detailed explanation (John's preference) │
│ │
│ 5. LEARN FROM THIS INTERACTION │
│ • Store interaction │
│ • Update patterns if feedback positive │
│ • Adjust preferences if user modifies │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Privacy & Isolation
| Concern | Solution |
|---|---|
| User data isolation | Strict tenantId filtering on ALL queries |
| Cross-tenant leakage | Separate vector search indexes per tenant |
| Data retention | Configurable per tenant (30d, 90d, 1y, forever) |
| Right to delete | Full deletion API for GDPR compliance |
| Opt-out | Users can disable learning for their account |
Integration Points
Where Learning Gets Triggered
┌─────────────────────────────────────────────────────────────────────────┐
│ AI LEARNING INTEGRATION MAP │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ FRONTEND (gograb-space app) │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ AI Chat Component │ │
│ │ └─ On message send → Log interaction │ │
│ │ └─ On response received → Log response │ │
│ │ └─ On feedback (👍/👎) → Update outcome │ │
│ │ │ │
│ │ Vibe Coding Interface │ │
│ │ └─ On generation request → Create task │ │
│ │ └─ On code generated → Log decision + embed │ │
│ │ └─ On user accepts/modifies → Update outcome │ │
│ │ │ │
│ │ Widget Builder │ │
│ │ └─ On AI assist → Log assistance │ │
│ │ └─ On widget saved → Record success pattern │ │
│ │ │ │
│ │ Module Builder │ │
│ │ └─ On AI generation → Log generation decision │ │
│ │ └─ On deployment → Record production success │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ BACKEND (backend-api) │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ AI Agents Module (/api/ai-agents) │ │
│ │ └─ Task creation → Embed & store │ │
│ │ └─ Session management → Track decisions │ │
│ │ └─ Feedback submission → Correlate outcomes │ │
│ │ │ │
│ │ Widget Generation Agent │ │
│ │ └─ Generation → Log decision with reasoning │ │
│ │ └─ Success → Extract pattern │ │
│ │ │ │
│ │ Module Generation Agent │ │
│ │ └─ Generation → Log decision with reasoning │ │
│ │ └─ Success → Extract pattern │ │
│ │ │ │
│ │ AI Chat Endpoints (/api/ai/chat) │ │
│ │ └─ Every message → Log + embed │ │
│ │ └─ Context building → Retrieve similar │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ CURSOR/DEVELOPMENT (MCP Server) │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Development AI MCP │ │
│ │ └─ Code generation → Log decision │ │
│ │ └─ Architecture decisions → Log reasoning │ │
│ │ └─ File operations → Track patterns │ │
│ │ └─ Error fixes → Learn anti-patterns │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Database Architecture
Complete Database Map
┌─────────────────────────────────────────────────────────────────────────┐
│ DATABASE ARCHITECTURE │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ MongoDB Atlas Cluster │
│ ├─────────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ DATABASE: ai-agents (TIER 2 - Platform) │ │
│ │ ════════════════════════════════════════ │ │
│ │ • agent_tasks - Platform-wide tasks │ │
│ │ • agent_decisions - Platform-wide decisions │ │
│ │ • agent_embeddings - Platform decision vectors │ │
│ │ • agent_patterns - Platform patterns │ │
│ │ • agent_calibrations - Platform calibrations │ │
│ │ • agent_metrics - Platform metrics │ │
│ │ │ │
│ ├─────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ DATABASE: ai-tenants (TIER 3 - Tenant) │ │
│ │ ════════════════════════════════════════ │ │
│ │ • user_profiles - Per-user preferences │ │
│ │ • user_interactions - Per-user history │ │
│ │ • user_embeddings - Per-user decision vectors │ │
│ │ • user_patterns - Per-user & tenant patterns │ │
│ │ • tenant_settings - Tenant AI configuration │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ Local/Workspace Storage (TIER 1 - Development) │
│ ├─────────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ OPTION A: Local MongoDB │ │
│ │ DATABASE: ai-mcp-dev │ │
│ │ • dev_decisions - Development decisions │ │
│ │ • dev_patterns - Codebase patterns │ │
│ │ • dev_conventions - Project conventions │ │
│ │ │ │
│ │ OPTION B: JSON Files (simpler) │ │
│ │ .cursor/ai-memory/ │ │
│ │ • decisions.json - Development decisions │ │
│ │ • patterns.json - Codebase patterns │ │
│ │ • conventions.json - Project conventions │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Implementation Roadmap
Phase 1: Foundation ✅ COMPLETED (December 2025)
- Vector Memory Service (Tier 2)
- Outcome Correlation Service (Tier 2)
- Pattern Mining Service (Tier 2)
- Multi-provider embedding support
- MongoDB Atlas Vector Search optimized (20x numCandidates for optimal recall)
- Available on M0 FREE tier - no upgrade needed!
Phase 2: Platform Integration ✅ COMPLETED
- AI Chat logging integration (
AIChatLearningService) - Vibe Coding logging integration (
VibeCodingLearningService) - Prompt System effectiveness tracking (
PromptLearningService) - Frontend feedback collection (via learning services)
- Admin monitoring dashboard (
AILearningDashboardComponent) -
AgentPlatformLearningService- Central platform learning
Phase 3: Tenant AI ✅ COMPLETED
- User profile schema (
TenantUserProfileDocument) - Per-user interaction schema (
TenantUserInteractionDocument) - Per-user embedding storage
- User preference learning (
TenantAIServicebackend) - Tenant isolation implementation
- User-facing "AI Memory" settings (in dashboard)
- Frontend
TenantAIServiceclient
Phase 4: Development AI ✅ COMPLETED
- MCP Server for Cursor (
MCP/mcp-development-ai) - Development decision logging
- Codebase convention learning
- Pattern extraction for this repo
- Local + MongoDB storage support
Phase 5: Advanced Features ✅ PARTIALLY COMPLETED
- Cross-tier pattern sharing (successful platform patterns → tenant default)
- Federated learning (aggregate without sharing data)
- A/B testing framework
- Self-improvement automation
- AI Learning Dashboard component (
AILearningDashboardComponent)
Why This Sets You Apart
| Competitor | What They Have | What GoGrab Will Have |
|---|---|---|
| ChatGPT | No memory between sessions | Persistent learning at 3 tiers |
| Claude | Limited memory | Full semantic memory |
| Copilot | Code completion | Learning code patterns |
| Cursor | File context | Codebase-wide learning |
| GoGrab | All of the above | Plus user personalization, platform learning, pattern mining |
The Competitive Moat
- Platform learns from ALL users → Better for everyone
- Users get personalized AI → Sticky, hard to leave
- Developers get smarter tools → Faster iteration
- Patterns compound over time → Gets better every day
- Multi-tenant isolation → Enterprise-ready
Summary
| Tier | Purpose | Storage | Scope |
|---|---|---|---|
| Tier 1 | Help developers build GoGrab | Local/workspace | This codebase |
| Tier 2 | Power platform AI features | ai-agents | All users |
| Tier 3 | Personalize per user | ai-tenants | Individual users |
All three tiers use the same methodology:
- Vector embeddings for semantic search
- Outcome correlation for learning
- Pattern mining for knowledge extraction
- Confidence calibration for accuracy
Result: AI that genuinely learns and improves at every level.
Document Created: December 2025 Status: Architecture Defined, Ready for Implementation