EchoMind

Inspiration: Most AI assistants are powerful, but their conversations often feel temporary. A user may explain their project, goals, preferences, or previous decisions in one conversation, only to repeat the same information later.

We wanted to build something different — an AI companion that actually remembers.

This idea led us to create EchoMind — an AI Memory Companion, designed to maintain long-term context across conversations. Instead of treating every interaction as an isolated chat, EchoMind continuously builds a personalized memory of the user's experiences, goals, knowledge, and important conversations.

The core idea is simple:

An AI becomes significantly more useful when it can remember what matters.

For this reason, we made CockroachDB the persistent memory layer of EchoMind and used AWS for the cloud backend and serverless infrastructure.

What is EchoMind?

EchoMind is a context-aware AI Memory Companion that stores, retrieves, and uses meaningful information from previous interactions.

A user can simply have a normal conversation with EchoMind. Important information can become part of the user's long-term memory, allowing the system to retrieve relevant context in future conversations.

For example, a user might say:

“I'm building EchoMind for the CockroachDB × AWS Hackathon. My goal is to create a reliable AI memory system.”

Later, instead of repeating all that information, the user can simply ask:

“What do you know about my project?”

EchoMind can retrieve the relevant context and use it to generate a personalized response.

This transforms the interaction from:

User → Question → Answer

into:

User → Conversation → Memory → Retrieval → Context-aware Answer → New Memory.

How the Memory System Works

Memory is the central part of EchoMind.

When a user interacts with the system, the backend processes the conversation and identifies useful contextual information. Relevant information can then be stored as persistent memory.

EchoMind organizes memory into concepts such as:

-Long-Term Episodic Memory — important past interactions and experiences -User Context — information relevant to the user's ongoing activities -Active Goals — objectives and progress the user is working toward -Learning Graph — relationships between concepts, projects, goals, and experiences -Semantic Retrieval — finding relevant information instead of simply searching through raw conversation history

When a new question arrives, EchoMind retrieves relevant memories and provides them as context to the AI model.

This allows the response to be personalized and context-aware rather than stateless.

Why CockroachDB?

CockroachDB is not simply being used as a traditional database in EchoMind.

It serves as the persistent memory layer and system of record for the application.

EchoMind uses the database to maintain information such as:

-User context -Episodic memories -Goals -Knowledge relationships -Retrieval information -Persistent application state

This is important because an AI memory system needs persistence. If the application restarts or a conversation ends, important user context should not simply disappear.

The architecture therefore separates the responsibilities clearly:

CockroachDB → Persistent memory and data

AI model → Reasoning and response generation

This makes memory an actual architectural component of the agent rather than an afterthought.

The hackathon specifically asks projects to demonstrate CockroachDB as a meaningful persistent memory layer, including state, embeddings, context, or transactional data.

Why AWS?

AWS provides the cloud infrastructure required to run EchoMind as a scalable application.

Our backend architecture uses:

-AWS API Gateway — exposes the backend API -AWS Lambda — provides serverless backend execution -AWS infrastructure — supports deployment and scalability

The frontend communicates with the backend through APIs, while the backend coordinates memory retrieval, database operations, and AI responses.

How We Built It

EchoMind was developed as a full-stack AI application.

Frontend

We built the user-facing application using:

-React -Vite -TypeScript -Modern responsive UI

The interface provides access to the conversational assistant and memory-related features.

Backend

The backend is built with:

-Python -FastAPI -REST APIs -Modular AI and memory services

The backend is responsible for:

-Receiving user requests -Retrieving relevant memory -Building contextual information -Communicating with the AI model -Generating the response -Persisting useful information -Returning the response to the frontend -AI Layer

EchoMind uses an LLM through OpenRouter, with our tested configuration using GPT-4o-mini.

The AI model is not expected to remember everything by itself.

Instead:

CockroachDB remembers. EchoMind retrieves. The LLM reasons with the retrieved context.

This separation makes the architecture more controllable and easier to extend.

Real-World Impact

Persistent AI memory can make AI assistants much more useful in real-world workflows.

🎓 Education

EchoMind can remember:

-Learning progress -Subjects being studied -Previous questions -Long-term learning goals

This can turn an AI chatbot into a continuous learning companion.

💼 Professional Work

A professional could use a memory-aware assistant to retain:

-Project context -Decisions -Meeting information -Tasks -Technical discussions

Instead of repeatedly explaining the same project, the assistant can continue from previous context.

👤 Personal Productivity

EchoMind can remember:

-Preferences -Important tasks -Personal goals -Ongoing activities

This allows the assistant to become more personalized over time.

🧠 Knowledge Management

Teams can potentially use persistent AI memory to maintain relationships between projects, concepts, documents, decisions, and tasks

CockroachDB + AWS Integration

The most important architectural decision in EchoMind was to give each platform a meaningful role:

CockroachDB provides durable, persistent memory.

AWS provides the cloud execution and API infrastructure.

EchoMind connects them with the AI reasoning layer.

This makes the system more than a chatbot with a database attached. The database directly contributes to the agent's ability to maintain context across interactions.

The hackathon requires at least two CockroachDB tools and at least one AWS service, so in the separate Devpost tool-selection fields, select only the CockroachDB tools you actually used and can demonstrate.