How We Built Cross-Platform AI Context Persistence (So You Never Lose an Important Conversation Again)

We built this on top of AIHub, our Laravel-based central hub that manages AI interactions across multiple projects. It integrates with Gemini, Claude, and DeepSeek APIs. Now it's also the persistent memory layer for all those conversations.

The stack: Laravel as the central hub, Model Context Protocol as the bridge between AI platforms and AIHub, RAG without chunking because conversations are naturally long-form atomic units, a multi-model strategy where Gemini handles synthesis and Claude handles development, PostgreSQL with pgvector for vector search, and S3 for large transcript storage with MariaDB for metadata.

Here's how storing works. You finish a conversation with Claude or Gemini or Antigravity. You tell the system "save this conversation to AIHub." An MCP tool called 'store-conversation' triggers. The full transcript gets sent to Gemini, which generates a structured summary: topic, key decisions, open questions, participants, date, and a readable summary. The system creates a vector embedding of that summary plus metadata, stores the full transcript in S3 if it's large or in the database if it's small, and returns a wiki_id for future reference.

Here's how retrieving works. You start a new conversation. You say "check AIHub for RAG discussions." An MCP tool called 'retrieve-context' triggers. Vector search through PostgreSQL's pgvector finds the five most relevant conversation IDs based on semantic similarity, loads the full transcripts from S3 or the database, sends everything to Gemini with instructions to synthesize the context, and returns a brief that says "based on your previous discussions, you decided X, you were concerned about Y, here's how you solved Z." The AI now has full historical context. Your conversation continues with complete context.

The key design decisions:

• No chunking because conversations are already atomic units with context that flows: you don't want "chunk 47 of a conversation about databases," you want the whole discussion
• Smart summaries over dumb fragments: instead of storing random sentence fragments, Gemini generates structured metadata about what was discussed, what was decided, what questions remain open, who participated
• S3 for scale, databases for speed: small conversations under 10k tokens live in MariaDB for instant access, large transcripts go to S3 with references in the metadata
• MCP lets AIs participate: the AI models themselves can request context, store insights, and link related conversations. They're not just consuming a database, they're actively participating in building institutional memory

Conversations are perfect for this kind of system.

They're naturally long-form. A 10,000-word conversation about implementing OAuth in Laravel is exactly the kind of thing that shouldn't be chunked. The context flows. The decisions build on each other. Breaking it into fragments destroys the narrative.

Context matters more than keywords. Traditional search looks for exact matches. Vector search understands that a conversation about "user authentication" and a conversation about "login security" are related, even if they don't share terms.

Temporal relevance matters. Recent conversations about a topic are usually more valuable than old ones. Your thinking evolves. Your projects change. The system understands recency.

Cross-pollination works. A discussion with Claude about RAG implementation can inform a discussion with Gemini about database optimization. The synthesis layer connects dots across platforms.

Every stored conversation gets rich metadata:

{
  "source": "claude|gemini|antigravity",
  "conversation_id": "original-platform-id",
  "participants": ["User", "Claude"],
  "topics": ["RAG", "Vector Search", "S3"],
  "decisions_made": [
    "No chunking approach",
    "Use Gemini 2.5 for synthesis"
  ],
  "action_items": [
    "Implement MCP tools for storage",
    "Test S3 latency"
  ],
  "related_conversations": ["wiki_id_123", "wiki_id_456"]
}

Here's what this looks like in practice.

You're refactoring a subsystem in your application. You know you discussed the observer/listener pattern with Claude before, but you can't remember the specifics.

Before AIHub: Search chat history for "observer" (12 results), search for "listener" (8 results), search for "Laravel events" (15 results), give up and ask the question again, realize 30 minutes in that you already solved this.

After AIHub: You say "check AIHub for Laravel observer discussions." Vector search finds three relevant conversations. Gemini synthesizes: "Based on your previous discussions, you decided to use observers for model events and listeners for cross-cutting concerns. You specifically noted that FileObserver should handle upload validation, while IngestCompletedListener should trigger the processing pipeline. You were concerned about circular dependencies here's how you solved it." You continue with full context in 30 seconds.

The difference: time saved, momentum maintained, context preserved.