# Multitenancy & isolation

Synapse är multitenant: flera användare, var och en med flera minds, fullständigt
isolerade från varandra. Den här sidan förklarar isolationsmodellen.

## Klienthierarki

```
Synapse Instance
  │
  ├── User Account 1 (email: alice@example.com)
  │   ├── Mind A (Mind Key mk_aaa...)
  │   │   ├── Memories (only accessible via mk_aaa...)
  │   │   ├── Tasks
  │   │   └── Chat
  │   └── Mind B (Mind Key mk_bbb...)
  │       └── ... (isolated from Mind A)
  │
  ├── User Account 2 (email: bob@example.com)
  │   └── Mind C (Mind Key mk_ccc...)
  │       └── ... (isolated from Alice's minds)
  │
  └── ... (more users)
```

## Isolationsnivåer

### Nivå 1: Användarisolation

Varje användarkonto är isolerat. Alice kan inte:

- Se Bobs minds
- Komma åt Bobs minnen (även med sin JWT)
- Lista Bobs kontoinformation

Upprätthålls av: `user_id`-kolumn på alla tabeller, JWT innehåller `user_id`,
alla frågor filtrerar efter `user_id`.

### Nivå 2: Mind-isolation

Inom en användare är varje mind isolerad. Mind A kan inte:

- Se Mind B:s minnen
- Komma åt Mind B:s uppgifter, chatt, skript

Upprätthålls av: `mind_id`-kolumn på alla datatabeller, Mind Key innehåller
`mind_id`, alla frågor filtrerar efter `mind_id`.

> [!CRITICAL]
> Mind Key-isolation är den primära säkerhetsgränsen. En läckt Mind Key ger
> full åtkomst till den mindens data — men ENDAST den minden.

## Autentiseringstoken

| Token | Omfattning | Vad den kan komma åt |
|-------|-------|-------------------|
| Mind Key | Enskild mind | Endast den mindens data |
| JWT | Användarkonto | Kontohantering (skapa/lista/ta bort minds) |
| Computer Token | Enskild dator | Den datorns kommandon |

## Åtkomst över mind-gränser

### Inom samma användare

Användaren kan komma åt alla sina minds via JWT (t.ex. `GET /minds` listar
alla). Men för att läsa/skriva minnesdata behöver de specifik Mind Key.

### Mellan användare

Användare kan inte komma åt varandras data — OM INTE de uttryckligen delar en
mind via Sharing API:

```bash
# Alice shares Mind A with Bob
curl -X POST https://synapse.schaefer.zone/sharing \
  -H "Authorization: Bearer ALICE_JWT" \
  -d '{"mind_id": "m_aaa", "email": "bob@example.com", "role": "read"}'
```

Efter delning kan Bob komma åt Mind A via sin JWT (skrivskyddad om `role=read`).

## Säkerhetsgränser

```
┌─────────────────────────────────────────────────┐
│              Synapse Instance                    │
│  ┌─────────────────────────────────────────┐    │
│  │         User Account Boundary           │    │
│  │  ┌──────────────┐  ┌──────────────┐    │    │
│  │  │  Mind Bound. │  │  Mind Bound. │    │    │
│  │  │  (Mind Key)  │  │  (Mind Key)  │    │    │
│  │  │              │  │              │    │    │
│  │  │  Memories    │  │  Memories    │    │    │
│  │  │  Tasks       │  │  Tasks       │    │    │
│  │  │  Chat        │  │  Chat        │    │    │
│  │  │  Scripts     │  │  Scripts     │    │    │
│  │  └──────────────┘  └──────────────┘    │    │
│  └─────────────────────────────────────────┘    │
└─────────────────────────────────────────────────┘
```

## Vanliga multitenancy-mönster

### Mönster 1: Enskild användare, enskild mind

Vanligast för enskilda LLM-agentanvändare.

- 1 användarkonto
- 1 mind
- 1 Mind Key
- Alla minnen i en omfattning

### Mönster 2: Enskild användare, flera minds

För användare med flera kontexter (arbete, personligt, projekt).

- 1 användarkonto
- N minds (t.ex. "work", "personal", "project-x")
- N Mind Keys
- Varje LLM-session använder en Mind Key

### Mönster 3: Team-delad mind

För team som samarbetar kring ett projekt.

- 1 användare skapar minden (får Mind Key)
- Skaparen delar med teammedlemmar via JWT
- Alla teammedlemmar kommer åt via JWT (eller delad Mind Key)

> [!WARNING]
> Att dela en Mind Key ger full läs/skriv-åtkomst. För teamsamarbete,
> föredra Sharing API (JWT-baserad) framom att dela Mind Keys direkt.

### Mönster 4: SaaS-leverantör

För appar som bäddar in Synapse som sitt minneslager.

- Varje kund = 1 användarkonto
- Varje kundprojekt = 1 mind
- Appen lagrar Mind Keys per kund/projekt
- Full isolation mellan kunder

## Verifiering av isolation

### Test: Mind Key kan inte komma åt andra minds

```bash
# Mind A's key cannot read Mind B's memories
curl -H "Authorization: Bearer mk_aaa..." \
     "https://synapse.schaefer.zone/memory/search?q=test"
# Returns only Mind A's memories

curl -H "Authorization: Bearer mk_bbb..." \
     "https://synapse.schaefer.zone/memory/search?q=test"
# Returns only Mind B's memories (different results)
```

### Test: JWT kan inte läsa minnesdata direkt

```bash
# JWT can list minds
curl -H "Authorization: Bearer YOUR_JWT" \
     https://synapse.schaefer.zone/minds
# Returns: list of minds

# JWT CANNOT read memories (need Mind Key)
curl -H "Authorization: Bearer YOUR_JWT" \
     https://synapse.schaefer.zone/memory/recall
# Returns: 401 Unauthorized
```

## Bästa praxis

> [!TIP]
> - **Använd en mind per projekt/kontext** — isolation är er vän
> - **Dela aldrig Mind Keys** — använd Sharing API istället
> - **Rotera Mind Keys** om komprometterade (ta bort mind, skapa ny)
> - **Granska delade minds** — se över `GET /sharing` regelbundet
> - **Använd JWT för mänskligt gränssnitt** — exponera aldrig Mind Keys för slutanvändare

## Nästa steg

- [Autentisering](/docs/getting-started/authentication)
- [Mind Key vs JWT](/docs/getting-started/mind-key-vs-jwt)
- [Arkitektur](/docs/concepts/architecture)