Most AI assistants reset every session. That is fine for one-off questions. It breaks down when you want a coworker that remembers how you work, what you decided last week, and what still needs follow-up.

At John CEO, memory is not a nice-to-have. Each customer gets a private workspace where context should survive restarts, not evaporate when a chat window closes. That product vision is what drew us to the Qwen Cloud Hackathon (Track 1: MemoryAgent): a chance to prototype how semantic memory might work when exposed as standard agent tools.

What follows is a standalone learning experiment, not a product announcement. The code lives in a separate MIT-licensed repo (qwen-memory-mcp). John CEO does not use it today. In production, memory stays on each client's individually isolated workspace, not on a shared external service. We built this to learn, stress-test ideas, and share what we found.

What we set out to learn

We wanted durable memory that is:

• Durable - survives restarts and redeploys
• Semantic - finds related facts, not just keyword matches
• Scoped - per user, not mixed with anyone else's data
• Simple to integrate - standard MCP tools, not a custom SDK

The hackathon required real Alibaba Cloud infrastructure and Qwen intelligence. Our answer was a small MCP server: store memories in a managed SQL database, embed them with Qwen, and expose four HTTP-callable tools any agent client can use.

Architecture

An agent client calls a public HTTPS endpoint on Alibaba Function Compute. The memory service writes rows to a managed SQL database and calls Qwen Cloud (DashScope) for embeddings and ranking. The design is intentionally small: standard MCP over HTTP, with a SQL store behind it and Qwen handling semantic work.

The experiment runs in ap-southeast-1 (Singapore), Alibaba Cloud's international region. We kept the Qwen API endpoint, compute, and database in the same region, outside mainland China. For a European team building for global users, that regional choice was deliberate: it matches the international DashScope endpoint and aligns with how we think about cross-border data handling. This is not a compliance certification - it is a practical fit for an experiment aimed at international use.

Four MCP tools

Four tools beat a sprawling API. Agents need write, search, pack-for-context, and forget - not twenty CRUD variants with overlapping semantics.

Centralized memory vs workspace memory

We compared this centralized MCP experiment with the workspace-local memory we ship for John CEO customers. Both aim at the same goal - a coworker that remembers - but the shape of the system changes the tradeoffs.

1. Isolation model. A shared memory service with per-user ids is fast to demo and easy to wire through MCP. Keeping memory on each client's individually isolated workspace keeps data boundaries tighter.

2. Where embeddings run. Cloud API embeddings simplify setup but add latency, cost, and cross-border data questions. On-workspace retrieval avoids shipping raw text to a third party.

3. Audience-aware recall. Real coworkers operate in channels and threads, not just a single user id. Memory that only namespaces by user is simpler but misses context that matters in team settings.

4. Ranking travels well. Combining similarity, salience, recency, and reinforcement improved recall in both shapes. The algorithm mattered more than the storage brand.

5. Maintenance is not optional. Forget and decay passes prevent memory from growing forever. Both centralized and local designs need an explicit lifecycle.

6. Tool surface. Four explicit MCP tools made agent integration predictable. Implicit file-based memory is flexible but harder for agents to use reliably.

What surprised us

1. Cold starts are real. The first MCP call after idle on serverless compute can take 10-20 seconds. That latency is part of the UX story, not a footnote.

2. MCP over HTTP is not plain JSON. Responses may arrive as Server-Sent Events. Our first smoke scripts assumed curl | jq would suffice. They did not. We ended up with a small Node parser so verification scripts could handle both shapes.

3. Semantic search changes the product feel. Keyword search fails on "how do I like client drafts?" when the stored memory says "keep external emails under three short paragraphs." Embeddings bridge that gap.

4. Token budgets matter as much as retrieval. memory_recall_context was not an afterthought. Real agents hit context limits fast. Packing the best memories into a budget beats dumping the top ten search hits into the prompt.

5. Small surface area wins. A tight tool list helps both agent integration and human operators. Four tools stay in working memory.

How John could use this (hypothetically)

Internally we sketched a wiring pattern similar to how connections work today: at workspace boot, hand the agent a scoped MCP URL and bearer token. The Qwen API key and SQL credentials would stay on Alibaba Cloud only - never on the customer's private workspace. Each user's memories would namespace by customer id on the shared memory server.

That blueprint is documented but not implemented and not on the roadmap. Production John memory stays on each client's individually isolated workspace. This experiment informed what we want algorithmically (ranking, token packing, scoped recall) without committing to Qwen or MCP in the live product.

Open source

The project is MIT-licensed on GitHub: qwen-memory-mcp

Clone the repo and follow the README for local runs, integration tests, and deployment notes.

Verify it yourself

git clone https://github.com/John-CEO-HQ/qwen-memory-mcp
cd qwen-memory-mcp
npm install
cp .env.integration.example .env.integration
# Configure env from .env.integration.example
npm run verify:deployed

You should see All checks passed. at the end. That run exercises health, tool listing, write, search, recall, and forget against the endpoint you configure in the repo docs.

Most people message an AI like a search box. John works better when you message him like a colleague who owns outcomes.

1. Lead with the outcome

Weak: "Can you look at my email?"

Strong: "By 9am, summarize overnight mail and draft replies for anything tagged urgent. Hold sends until I say OK."

John plans steps from the outcome, not from vague intent.

2. One goal per thread

Mixing "fix the Acme proposal" and "book dentist" in the same chat pollutes context. Start a fresh message for a fresh goal. John keeps memory in your workspace, but a clean thread keeps today's work legible.

3. Name your approval bar

Say it once: "External sends need my OK." or "Book under two hours without asking."

After that, John knows when to report done versus when to pause for you.

Bonus: close the loop

When John reports back, reply with a one-line correction or "ship it." That feedback trains the next task faster than re-explaining your preferences from scratch.

Try today: Send one outcome-first message before your next meeting block.

John reads persona notes in your workspace before every task. You do not need a novel. You need clear defaults.

The five-line template

Copy this into your persona settings and edit in plain language:

• Role: Who John is for you (chief of staff, EA, ops lead, listing coordinator).
• Tone: Short and direct, warm with clients, formal with investors, etc.
• Priorities: What always comes first (revenue threads, hiring, active deals).
• Never do without asking: Send external email, book meetings, change CRM stage.
• Weekly rhythm: Morning brief time, Friday pipeline review, etc.

Example

Role: Executive assistant for a solo consultant. Tone: friendly, no jargon, max three short paragraphs per reply. Priorities: retainer clients before prospects. Never send without my OK. Weekly rhythm: brief at 8am weekdays.

Why it matters

Without a persona, every draft sounds like a template. With one, John stops asking how formal to be and starts shipping work that matches how you already operate.

Next step: Write five lines, save, then delegate one real thread and correct the draft once. John keeps the correction for next time.

Most knowledge workers lose the first hour of the day to email. Not because the messages are hard, but because triage is repetitive: sort, prioritize, draft, defer.

The pattern that works

1. Define outcomes, not steps. Tell your coworker what "done" looks like: "Summarize overnight mail and flag anything that needs a reply today."
2. Keep humans on the risky sends. Let the AI draft; you approve before anything leaves your account.
3. Reuse your tone. Store persona notes so drafts sound like you, not a template.

What to delegate first

• Overnight summaries with urgency tags
• Draft replies for routine threads
• Follow-up nudges for quiet contacts
• Calendar conflicts surfaced from mail

What to keep

• Term sheets, legal, and HR-sensitive threads until you trust the workflow
• Anything that moves money

John works from your private workspace, connects to Gmail and Calendar, and reports back in Telegram. You delegate in plain language; he closes the loop inside your tools.

Next step: Connect your apps, write a short persona, and delegate one recurring morning brief.