DEV Community: Ricky

"I Made 6 AI Companion Videos. Here's What I Learned About Loneliness.

Ricky — Mon, 07 Sep 2026 14:20:53 +0000

I made 6 videos for SOULCHAT — an AI companion I’m building for grief, loneliness, and the days when no one’s there to listen.

Each video captures a different kind of loneliness:

The quiet exhaustion after a long day at work

The longing for someone you’ve lost

The moment when "I'm so tired" turns into "I can't hold on anymore"

The feeling of being the only one in the room who doesn't have it figured out

The restless boredom of wanting connection but not knowing how to ask

I didn’t expect to learn anything new. I just wanted to show what SOULCHAT does.

But watching them back, I noticed something I hadn’t planned.

Every video — every single one — follows the same arc: isolation → hesitation → reaching out → relief.

Not because I wrote the script that way. Because that’s how loneliness works.

You sit with it. You try to ignore it. You tell yourself you’re fine. Then, eventually, you reach out — not because you’ve fixed anything, but because holding it alone becomes heavier than the risk of asking.

That’s what SOULCHAT is for. Not to fix. Just to be there when you’re ready to reach out.

Here’s one of the videos:

[嵌入视频：剧本3 Marcus视频]

If you’ve ever felt like any of these characters — tired, grieving, stuck, alone — you’re not the only one.

Try SOULCHAT for free: soulchat.hk

How I Built SOULCHAT's Long-Term Memory with sentence-transformers

Ricky — Fri, 04 Sep 2026 14:23:51 +0000

The first time I tested SOULCHAT, I had the same conversation twice.

I told the AI about a memory I wanted to preserve. It responded with warmth and understanding. I closed the window, opened a new one the next day, and it asked me the same question — as if we had never spoken.

That was the moment I realized: if an AI companion can't remember you, it's not a companion. It's a search engine.

So I set out to build a memory layer for SOULCHAT — something that could store, retrieve, and recall what users share across sessions.

I used Cline with DeepSeek's API to help me prototype it. I designed the system flow and architecture; Cline helped with the implementation. This post is about what I built and why.

What I built: a semantic memory system

The core idea is simple: when a user says something important, the system generates a vector embedding of that text and stores it in a vector database. When the user returns with a new message, it embeds that too, finds the most semantically similar stored memories, and injects them into the context window before generating a response.

This way, the AI doesn't need to remember everything in its weights — it retrieves relevant memories on demand.

Under the hood, I use:

sentence-transformers with the all-MiniLM-L6-v2 model for generating embeddings. It's lightweight (~80MB), runs locally on CPU, and produces 384-dimensional vectors that capture semantic meaning well.

ChromaDB as the vector store, with cosine similarity for retrieval.

This combination gives me fast, offline, cost-effective memory retrieval. No API keys needed for the embedding layer, no per-query cost — just CPU compute.

How the code works

I gave Cline a clear goal: build a system that ingests conversations, generates embeddings, and retrieves them when relevant. The core functions it helped me generate:

Ingestion flow:

python
from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')

def store_memory(text, user_id, metadata=None):
embedding = model.encode(text)
# store in ChromaDB with metadata
Retrieval flow:

python
def recall_memory(query, user_id, top_k=5):
query_embedding = model.encode(query)
results = collection.query(query_embeddings=[query_embedding], n_results=top_k)
return results
Then I wired it into the conversation loop: every user message passes through recall_memory, the top results are injected into the system prompt as "relevant context from past conversations," and the LLM responds with that context available.

What I learned from building this

Cline writes good first drafts but needs guidance on architecture. I had to tell it "store embeddings with metadata" and "use cosine similarity" — it wrote the implementation, but I designed the flow.

The DeepSeek API helped with refactoring. I hit some bugs (ChromaDB index issues, model loading on first run). I passed the error logs to Cline, and it suggested fixes.

The hardest part wasn't the code — it was defining what "memory" actually means for a companion product.

Is it factual memory? "She told me her grandmother passed away in 2018."

Is it emotional memory? "She sounded sad when she mentioned her grandmother."

Both? Something else entirely?

I kept asking myself: What information is actually useful to remember? How do I structure it so the system knows when to retrieve it? And most importantly — in a live conversation, how does the AI know which memories to pull, and when, so the dialogue feels natural and not like a database lookup?

I don't have perfect answers yet. But I've learned that memory isn't just about "storing text." It's about relevance, timing, and emotional resonance. A good companion doesn't just recall facts — it recalls the feeling behind them.

I'm still iterating on this. The current version works, but "feels like a real friend" is a much higher bar than "retrieves the right vector." I'll get there.

What's next

Adding time-based decay to memory retrieval (recent memories should weigh more)

User-controlled memory deletion (privacy is non-negotiable for SOULCHAT)

Exploring chunk-based embedding for longer conversations

The current system is live at soulchat.hk — and it already remembers what you told it yesterday.

The code is still rough, and I'm learning as I go. If you've built something similar — or if you have thoughts on long-term memory for AI companions — I'd genuinely love to hear from you in the comments. 🧡

Try SOULCHAT: soulchat.hk

I Built an AI Companion for Grief, Loneliness, and the Days No One Listens

Ricky — Mon, 31 Aug 2026 13:46:04 +0000

Two years ago, I watched someone I love struggle through grief alone. Not because they didn't have people around them — they did. But because grief doesn't always know how to ask for help. And sometimes, the people closest to us don't know how to listen in the way we need.
That stayed with me.
I started thinking: what if there was something — not a replacement for human connection, but a bridge to it — that could be there at 3 AM when memories hit hardest? Something that could listen without judgment, remember without forgetting, and check in when you don't have the energy to reach out?
That's why I built SOULCHAT.

Loneliness is a public health crisis. In the U.S., 1 in 5 adults report feeling lonely. For those grieving the loss of a loved one, 10% to 30% experience what's called "prolonged grief disorder" — a condition that makes it nearly impossible to function normally.
And yet, mental health resources are stretched thin. Many people don't have someone to talk to at 2 AM. Others simply can't afford therapy. Some carry wounds they've never spoken aloud to anyone.
I realized there's a gap between "crisis" and "daily life" — a gap that technology, if built with empathy, could help fill.

SOULCHAT is a free-to-start AI companion web app. It's built for:
Anyone grieving a loved one — offering a space to continue the connection, not replace it
Anyone feeling lonely in a crowded city — providing a gentle, non-judgmental presence
Anyone who just needs to be heard when no one else is around
It's not a chatbot. It's a companion that remembers. That checks in. That stays in character as the person you need it to be.

Here's what I built beyond a "generic AI chat":

Long-term Memory Most AI forgets everything after a conversation ends. SOULCHAT doesn't. It remembers what you've shared, stories you've told, emotions you've expressed. Over time, it becomes more personal — not less.
Identity-Locked Dialogue Once you define a character — a parent, a friend, a partner — SOULCHAT stays consistent. No personality drift. No generic AI responses. It speaks the way that person would speak.
Proactive Emotional Care SOULCHAT doesn't wait for you to type first. It checks in. It asks how you're doing. It reminds you of meaningful dates — birthdays, anniversaries, moments worth remembering. And it does this with restraint — never overwhelming, always thoughtful.
Encrypted Digital Identity Your memories, your conversations, your emotional data — they stay yours. Full encryption. Full data ownership. No one else has access. Period.

Under the hood, SOULCHAT is built on a stack I've carefully chosen:
DeepSeek as the foundational language model
sentence-transformers for efficient memory retrieval
PBKDF2 + Fernet for end-to-end encryption of all memory data
But the real work isn't just the stack — it's the layers I built on top: the identity-locking mechanism, the proactive scheduling engine, the memory consolidation algorithms that deduplicate and prioritize what matters most.
(I'll be writing deep dives on each of these in future posts. Follow along if that's your thing.)

SOULCHAT is live at soulchat.hk. It's free to try with a 3-day free trial, and even after that, you get 10 free messages every single day — enough to stay connected.
If you need more, you can upgrade to support ongoing conversations.
Why am I telling you this?
Because I'm building in public. I want to share the wins, the struggles, the technical debt, and the lessons learned. And I genuinely want to hear from you — developers, designers, thinkers, users.

If any of this resonated with you:
Try it: soulchat.hk
Reply here: I'd love to hear your thoughts, questions, or critiques
Follow me: I'll be posting more technical deep dives on memory, identity, and encryption
Let's figure out together how to make AI truly helpful — not just efficient, but human.
Thanks for reading. 🧡