So the first decision I made while building Client Desk, an assistant that writes emails, quotes and follow-ups for freelancers, wasn’t about prompts or models. It was about where memory lives.

What it does

Client Desk is a small Flask app. You pick a client, ask for a draft (“write a quote for the next phase”), and it writes one using everything it remembers about that client. You teach it new facts in plain sentences, and a Brief button summarizes a client before a call. Text generation runs on Groq’s openai/gpt-oss-120b. Memory runs on Hindsight through Hindsight Cloud. The code is in the project repository.

The decision: one bank per client

Hindsight organizes memory into banks. Instead of one big bank where I’d have to filter by a client tag on every read, I give each client their own bank:

def bank(name):
    return "client-" + name.strip().lower().replace(" ", "-")

“Northwind” becomes client-northwind. Every read and write goes through that one function, so there is no code path where a recall can wander into another client’s facts. Isolation is built into the structure instead of being something I have to remember to enforce.

Three calls run the whole app

The app uses three Hindsight operations, all described in the Hindsight docs.

Retain runs when you save a note:

hs.retain(bank_id=bank(d["client"]), content=d["note"])

Hindsight turns a plain sentence into stored facts and links the people in it. I saved “Acme’s CEO Priya hates long emails and always wants a price breakdown” and got back separate facts: Priya is the CEO of Acme, she dislikes long emails, and she requires a price breakdown.\

Recall runs before every draft:

mem = hs.recall(bank_id=bank(client), query=msg)
facts = [r.text for r in mem.results]

The query is the user’s own request, so “write a quote” pulls budget and payment facts while “send the invoice” pulls PO-number and CC rules. According to the docs, recall runs semantic, keyword, graph and temporal search in parallel, and I didn’t have to build any of it.

Reflect powers the Brief button:

ans = hs.reflect(bank_id=bank(c), query=f"Give me a short briefing on {c}: ...")

Before and after

With an empty bank, the facts block in my prompt reads “(nothing known yet)” and the draft is generic, mostly placeholders. With memory, the same request, “Write a quote for the next phase”, produced very different results for two sample clients I seeded:

Northwind: a formal email to Meera, a quote framed under the stored 2 lakh quarterly cap, and a request for a PO number.

Bluepeak: a few casual lines with emoji, and an offer of the same 10 percent discount Dev got last time.

I didn’t change the prompt between them. Only the bank changed.

Things I’d warn you about

The bank key comes from the name you type. “Acme” and “Acme Ltd” become two banks, and a typo quietly creates a new empty one. A real deployment needs stable client IDs.

I had planned to self-host Hindsight with a free Groq key. The docs note that Groq’s free tier allows about 8,000 tokens per minute, far below what a single retain call needs, so I used Hindsight Cloud for memory and kept Groq only for writing drafts.

There is no authentication yet, so it’s a single-user tool.

What happens when I click Write draft

The important part of this workflow happens before the language model starts writing. When I click Write draft, the frontend sends the selected client name and my request to the Flask backend through the /api/chat endpoint.

The backend uses the selected client's bank name to call Hindsight's recall operation. It then collects the returned memory results and converts them into a facts list. If nothing relevant is returned, the application uses a simple message saying that nothing is known yet.

These facts are added to the system prompt along with instructions about how the assistant should behave. For example, it must follow the client's communication preferences, use only relevant information and avoid inventing invoice numbers, amounts or dates.

The request is then sent to Groq using the openai/gpt-oss-120b model. The generated response is returned to the frontend and displayed as a draft. The recalled facts are also sent back to the interface, where they appear in the "What I remember" panel.

I wanted this panel to be visible because memory should not feel like a hidden process. The user should be able to see which client information influenced the response and understand why the assistant produced a particular draft.

Takeaways

Make isolation structural: one bank per tenant beats a filter you must never forget.

Use the user’s request as the recall query.

Derive bank names from stable IDs, not typed names.

Check your LLM provider’s rate limits against your memory system’s needs before choosing a stack.

If you want the background on the idea, Vectorize has a good explainer on agent memory.