# मल्टी-टैनेंसी और आइसोलेशन

Synapse मल्टी-टैनेंट है: कई उपयोगकर्ता, प्रत्येक के पास कई minds, जो एक-दूसरे से पूरी तरह अलग हैं। यह पृष्ठ आइसोलेशन मॉडल की व्याख्या करता है।

## टैनेंट पदानुक्रम

```
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)
```

## आइसोलेशन स्तर

### स्तर 1: उपयोगकर्ता आइसोलेशन

प्रत्येक उपयोगकर्ता खाता अलग है। Alice नहीं कर सकती:

- Bob के minds देख सकती है
- Bob की मेमोरीज़ एक्सेस कर सकती है (अपने JWT के साथ भी)
- Bob की खाता जानकारी सूचीबद्ध कर सकती है

लागू द्वारा: सभी तालिकाओं पर `user_id` कॉलम, JWT में `user_id` शामिल, सभी क्वेरीज़ `user_id` द्वारा फ़िल्टर करती हैं।

### स्तर 2: Mind आइसोलेशन

किसी उपयोगकर्ता के भीतर, प्रत्येक mind अलग है। Mind A नहीं कर सकता:

- Mind B की मेमोरीज़ देख सकता है
- Mind B के कार्य, चैट, स्क्रिप्ट्स एक्सेस कर सकता है

लागू द्वारा: सभी डेटा तालिकाओं पर `mind_id` कॉलम, Mind Key में `mind_id` शामिल, सभी क्वेरीज़ `mind_id` द्वारा फ़िल्टर करती हैं।

> [!CRITICAL]
> Mind Key आइसोलेशन प्राथमिक सुरक्षा सीमा है। लीक हुई Mind Key उस mind के डेटा तक पूर्ण पहुँच प्रदान करती है — लेकिन केवल उसी mind तक।

## प्रमाणीकरण टोकन

| टोकन | दायरा | क्या एक्सेस कर सकता है |
|-------|-------|-------------------|
| Mind Key | एकल mind | केवल उस mind का डेटा |
| JWT | उपयोगकर्ता खाता | खाता प्रबंधन (minds बनाएँ/सूचीबद्ध करें/हटाएँ) |
| Computer Token | एकल कंप्यूटर | उस कंप्यूटर के कमांड्स |

## क्रॉस-Mind एक्सेस

### उसी उपयोगकर्ता के भीतर

उपयोगकर्ता JWT के माध्यम से अपने सभी minds एक्सेस कर सकता है (जैसे `GET /minds` सभी को सूचीबद्ध करता है)।
लेकिन मेमोरी डेटा पढ़ने/लिखने के लिए, उन्हें विशिष्ट Mind Key की आवश्यकता है।

### उपयोगकर्ताओं के बीच

उपयोगकर्ता एक-दूसरे के डेटा को एक्सेस नहीं कर सकते — जब तक वे Sharing API के माध्यम से स्पष्ट रूप से कोई mind साझा न करें:

```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"}'
```

साझाकरण के बाद, Bob अपने JWT के माध्यम से Mind A एक्सेस कर सकता है (केवल पढ़ने के लिए यदि `role=read`)।

## सुरक्षा सीमाएँ

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

## सामान्य मल्टी-टैनेंसी पैटर्न

### पैटर्न 1: एकल उपयोगकर्ता, एकल Mind

व्यक्तिगत LLM एजेंट उपयोगकर्ताओं के लिए सबसे सामान्य।

- 1 उपयोगकर्ता खाता
- 1 mind
- 1 Mind Key
- सभी मेमोरीज़ एक दायरे में

### पैटर्न 2: एकल उपयोगकर्ता, कई Minds

कई संदर्भों (कार्य, व्यक्तिगत, परियोजनाएँ) वाले उपयोगकर्ताओं के लिए।

- 1 उपयोगकर्ता खाता
- N minds (जैसे "work", "personal", "project-x")
- N Mind Keys
- प्रत्येक LLM सत्र एक Mind Key का उपयोग करता है

### पैटर्न 3: टीम साझा Mind

किसी परियोजना पर सहयोग करने वाली टीमों के लिए।

- 1 उपयोगकर्ता mind बनाता है (Mind Key प्राप्त करता है)
- निर्माता JWT के माध्यम से टीम के सदस्यों के साथ साझा करता है
- सभी टीम के सदस्य JWT (या साझा Mind Key) के माध्यम से एक्सेस करते हैं

> [!WARNING]
> Mind Key साझा करना पूर्ण पढ़ने/लिखने का एक्सेस देता है। टीम सहयोग के लिए, सीधे Mind Keys साझा करने के बजाय Sharing API (JWT-आधारित) को प्राथमिकता दें।

### पैटर्न 4: SaaS प्रदाता

उन ऐप्स के लिए जो Synapse को अपनी मेमोरी परत के रूप में एम्बेड करते हैं।

- प्रत्येक ग्राहक = 1 उपयोगकर्ता खाता
- प्रत्येक ग्राहक परियोजना = 1 mind
- ऐप प्रति ग्राहक/परियोजना Mind Keys स्टोर करता है
- ग्राहकों के बीच पूर्ण आइसोलेशन

## आइसोलेशन सत्यापन

### परीक्षण: Mind Key अन्य 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)
```

### परीक्षण: JWT सीधे मेमोरी डेटा नहीं पढ़ सकता

```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
```

## सर्वोत्तम प्रथाएँ

> [!TIP]
> - **प्रति परियोजना/संदर्भ एक mind का उपयोग करें** — आइसोलेशन आपका मित्र है
> - **Mind Keys कभी साझा न करें** — इसके बजाय Sharing API का उपयोग करें
> - **समझौता होने पर Mind Keys रोटेट करें** (mind हटाएँ, नया बनाएँ)
> - **साझा minds का ऑडिट करें** — समय-समय पर `GET /sharing` समीक्षा करें
> - **मानव UI के लिए JWT का उपयोग करें** — अंतिम उपयोगकर्ताओं को Mind Keys कभी एक्सपोज़ न करें

## अगले कदम

- [प्रमाणीकरण](/docs/getting-started/authentication)
- [Mind Key vs JWT](/docs/getting-started/mind-key-vs-jwt)
- [आर्किटेक्चर](/docs/concepts/architecture)