My project - Persista

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built Persista, an AI memory infrastructure that gives AI applications a persistent memory layer.

I built it for a friend who uses AI tools frequently but kept running into the same problem: every new conversation started from zero. Important preferences, previous decisions, project context, and useful information were repeatedly lost between conversations.

Persista lets an application remember, search, and recall information across conversations instead of treating every interaction as completely independent.

The core idea is simple:

AI should remember the context that matters.

Persista provides semantic memory, hybrid retrieval, and knowledge-graph capabilities so an AI application can retrieve relevant context when it needs it.

Instead of sending an entire history to a model, the system can store useful memories and retrieve the most relevant information for the current interaction.

What Persista provides

• Persistent memory for AI applications
• Semantic search for finding conceptually related memories
• Hybrid retrieval combining different retrieval strategies
• Knowledge graph relationships between stored information
• Memory operations such as remember, search, recall, and graph
• MCP support so AI agents can interact with the memory layer through tools

The goal wasn't to build another chatbot.

It was to build the infrastructure that lets an AI application remember the person using it.

Demo

Live Demo: [https://persista-mu.vercel.app/]

The demo shows how information can be stored as memory and later retrieved when it becomes relevant to a new interaction.

Code

GitHub: https://github.com/yogesh201sits/persista

Persista is built as a backend-focused AI memory system rather than a single-purpose chatbot, so the memory layer can be integrated into different AI applications and agent workflows.

How I Built It

Persista is built around open-source AI components and an infrastructure-first architecture.

The system uses:

• Bun + TypeScript for the runtime and application layer
• Hono for the API
• PostgreSQL / Neon for persistent application data
• Prisma for database access
• Qdrant for vector-based semantic retrieval
• Neo4j for knowledge-graph relationships
• Hugging Face embeddings for semantic representations
• LangChain for AI/retrieval components
• Groq for model inference
• MCP for exposing memory capabilities to AI agents

At a high level, the flow looks like this:

AI Application / Agent
          │
          ▼
       Persista
          │
     ┌────┴─────┐
     │          │
  Memory     Retrieval
     │          │
     ▼          ▼
PostgreSQL   Qdrant
     │
     ▼
Knowledge Graph
     │
     ▼
   Neo4j

When an application wants to remember something, Persista stores the information and creates the representations required for later retrieval.

When the application needs context, Persista can search the stored memories and return the information most relevant to the current request.

The knowledge graph adds another dimension: instead of treating memories as isolated pieces of text, relationships between entities and concepts can also be represented and explored.

Why Does Open Innovation Matter?

AI memory is fundamentally about personal context.

That makes control over the underlying technology important.

Using open-source and open-weight components gives Persista the ability to choose and replace individual parts of the system instead of coupling the entire memory layer to one closed AI provider.

The embedding model can be changed.

The retrieval system can be changed.

The model used for inference can be changed.

The infrastructure can evolve independently.

This also makes experimentation much easier. I can test different models, retrieval strategies, embedding approaches, and storage systems without rebuilding the entire application around a single proprietary API.

For a personal memory system, this flexibility matters because the data belongs to the application and its user, not to a model provider.

Open innovation makes it possible to build the memory layer as an independent piece of infrastructure rather than treating memory as a feature locked inside a closed AI product.

My Agent Session

[Add DevRelay agent session here if available.]

Prize Categories

I am entering:

• Best Use of Gemma — if applicable to the submitted implementation
• Best Use of MongoDB Atlas — if applicable to the submitted implementation

Thanks for checking out Persista!