Use cases / Productivity & Workspace

Memory for productivity tools

A team assistant inside Slack, Notion, or Linear answers everyday questions: what did we decide, who owns this project, and what changed since last week. / ml connects your meetings, docs, and chat threads into one shared memory so your assistant always gives the current answer with a link to the source.

Main Problem Solved Outdated decisions & scattered apps
Lookup Speed ~10 ms
Token Savings 80% fewer prompt tokens
Permissions Scoped by user, team, and project

What you are building

How it works
1. Team tools
Slack, Notion, Linear, Zoom
Messages, docs, tickets, and call notes
2. / ml Memory
One shared team memory
Merges duplicates and keeps the latest decision
3. Team assistant
Answers with sources
Current owner, status, and link to the thread

An assistant that sits inside the collaboration tools your team already uses every day: Slack, Microsoft Teams, Linear, Notion, or internal management dashboards. It answers ordinary but crucial operational questions:

  • "What did we decide about the enterprise pricing tiers?"
  • "Who is currently leading the database migration after the team restructure?"
  • "What specific requirements did Acme Corp ask for on our Tuesday call?"
  • "What blockers were reported in yesterday's standup?"

Every one of these questions is answered from material spread across multiple systems: meeting transcripts, Google Docs, Slack threads, and project tickets. Without a dedicated memory architecture, these facts remain siloed and quickly drift out of date.

Why memory decides whether it works

Standard RAG fails in team workspaces because discussions are messy and decisions change:

  • Debate outranks the decision: Twenty messages debating a $49 price outweigh the one message confirming $79, so similarity search returns the rejected price.
  • Fragmented identities: One teammate appears under different names across Slack, Zoom, Linear, and Google Docs.
  • Reversed decisions linger: Old policies sit next to new ones in vector space, forcing the model to guess which is current.
  • Fragile trust: If an assistant misstates one decision in a leadership channel, the team stops using it.

What / ml provides

Keeps the Latest Decision

When a plan changes, / ml updates the record and merges duplicate notes across threads while saving a full log of what changed.

Fast ~10 ms Lookup

Memory lookups finish in about 10 ms, so your assistant replies in real time during live chats without lag.

Team & Project Permissions

Separate memories by user, team, or project so people only get answers from channels and docs they are allowed to see.

Links Back to the Source

Every memory keeps the original Slack channel, doc link, author, and date so teammates can verify any answer in one click.

Cost and token economics

Pasting full Slack channels or 40-minute meeting transcripts into every prompt wastes 6,000 to 12,000 tokens per question and slows down replies.

Tokens Used Per Question

Pasting full chat & call logs: ~6,956 tokens ($0.035 per question)

/ ml relevant facts only: ~1,400 tokens ($0.007 per question)

Result: 80% lower token cost and 4.1× faster replies.

At 50,000 team questions a month, / ml saves over $1,400 in monthly model costs while keeping old noise out of the prompt.

Getting there

1

Save messages, notes, and tickets

Send meeting notes, Slack messages, and project updates to / ml along with their channel name and date. You do not need to split text into chunks yourself.

2

Merge duplicate notes

Import existing history in batches and let / ml combine repeated updates across threads into clean, current records.

3

Fetch relevant facts before answering

When someone asks a question, search / ml for the matching team memories and pass only those verified facts into your prompt.

4

Ignore weak matches

Set a minimum match score so weak search results are dropped and your assistant says when a topic hasn't been decided yet.

Code example

Ingesting a meeting decision and recalling it with metadata filters via the Python SDK:

import os
from slashml import Memory

mem = Memory(api_key=os.environ["SLASHML_API_KEY"])

# 1. Ingest a workspace decision with team and timestamp metadata
mem.add(
    "Q4 pricing finalized: Enterprise tier set at $79/seat/mo, signed off by Dana.",
    user_id="workspace-acme",
    metadata={
        "channel": "cpo-announcements",
        "source": "slack",
        "team": "product-leads",
        "effective_date": "2026-10-15"
    }
)

# 2. Query workspace memory with team filter
results = mem.search(
    "What is the Q4 Enterprise pricing tier?",
    user_id="workspace-acme",
    filters={"team": "product-leads"}
)

for item in results["results"]:
    meta = item.get("metadata") or {}
    print(f"Decision: {item['memory']}")
    print(f"Effective Date: {meta.get('effective_date')}")
    print(f"Source: {meta.get('source')} (#{meta.get('channel')})")

Frequently asked questions

Q Does one teammate's private memory leak to another?

No. Every memory is separated by user, team, and project. Searches only return records that the person asking is allowed to see.

Q Do we need to split documents into chunks ourselves?

No. You send raw messages, meeting notes, or documents directly, and / ml pulls out the key facts and owners automatically.

Q What happens when a team changes a decision later?

You can update a decision in place or merge overlapping notes. / ml serves the new decision while keeping the older version in the change history.

Q Can we import past Slack messages and meeting notes?

Yes. You can upload up to 1,000 messages or documents per batch with their original dates, and / ml will merge duplicates automatically.

Build your workspace memory today

Start free with 10,000 ingests and 1,000 retrievals per month. Deploy in under 5 minutes with our Python SDK or native MCP server.