I was building a customer relationship agent and ran into a problem:

The agent knew the current conversation, but it didn't really remember the customer.

My first approach was to keep adding more customer history to the prompt. That worked with small amounts of data, but I didn't like the direction.

So I built FUEGO, an open-source customer relationship memory agent.

Stack

• Next.js
• FastAPI
• SQLite
• Hindsight
• Groq

The main architectural decision was separating structured data from long-term memory.

SQLite stores customers, meetings, support tickets, statuses, solutions, and outcomes.

Hindsight handles historical context that needs to be retrieved when it becomes relevant.

The mental model became:

retain → recall → reflect

Instead of sending every old interaction to the LLM, I can retain useful customer context and recall relevant history for a specific question.

For example, a customer might have reported a slow analytics dashboard.

Later, a solution was implemented using aggregated tables and a simplified semantic model, and the outcome was positive.

Another issue might have had additional monitoring added, but the outcome was still unconfirmed.

That distinction matters:

“We tried this” isn't the same as “this worked.”

So FUEGO tracks:

• Worked
• Partially worked
• Not confirmed

I also deliberately kept SQLite as the source of truth.

For example:

SQLite:
Ticket GGL-302 is Open.

while memory might contain:

Monitoring gaps were previously discussed
and additional alerting was attempted.

Those are related, but they serve different purposes.

The result is an agent that can answer questions like:

What solutions worked for this customer?

What did we promise them?

What should I know before the next meeting?

The biggest thing I learned was that agent memory isn't really about storing everything.

It's about retrieving the right context at the right time.

GitHub:
https://github.com/Samraatrichy/fuego-customer-memory-agent

I'm particularly interested in feedback on the architecture around SQLite + Hindsight + LLM retrieval.

How are you handling long-term memory in your open-source AI projects?

This version is much more likely to fit an open-source developer audience because it gives people something technical to discuss instead of just asking them to look at a project.