# रेट लिमिट और कोटा

Synapse में एक सरल, अनुमानित रेट लिमिट नीति है जो दुरुपयोग को रोकने के लिए डिज़ाइन की गई है जबकि वैध उपयोग के रास्ते में नहीं आती।

## रेट लिमिट नीति

| प्रमाणीकरण विधि | सीमा | दायरा |
|-------------|-------|-------|
| Mind Key (`Authorization: Bearer`) | **कोई नहीं** | प्रति-mind |
| Mind Key (`?key=`) | 60 req/min | प्रति-IP |
| JWT (`Authorization: Bearer`) | **कोई नहीं** | प्रति-उपयोगकर्ता |
| सार्वजनिक एंडपॉइंट्स | **कोई नहीं** | वैश्विक |

> [!TIP]
> **संभव होने पर हमेशा `Authorization: Bearer` हेडर का उपयोग करें।** इसकी कोई रेट लिमिट नहीं है। `?key=` का उपयोग केवल उन टूल्स के लिए करें जो कस्टम हेडर सेट नहीं कर सकते।

## रेट लिमिट हेडर

जब आप `?key=` प्रमाणीकरण का उपयोग करते हैं, तो प्रतिक्रियाएँ रेट लिमिट हेडर शामिल करती हैं:

```
X-RateLimit-Limit: 60
X-RateLimit-Remaining: 42
X-RateLimit-Reset: 1782567840
```

जब आप सीमा पार करते हैं:

```
HTTP/1.1 429 Too Many Requests
X-RateLimit-Limit: 60
X-RateLimit-Remaining: 0
Retry-After: 42
Content-Type: application/json

{
  "statusCode": 429,
  "error": "Too Many Requests",
  "message": "Rate limit exceeded. Use Authorization header for unlimited access."
}
```

## जब आप रेट लिमिट हिट करते हैं

यदि आपको 429 मिलता है:

1. **Authorization हेडर पर स्विच करें** (अनुशंसित):
   ```bash
   # Don't: ?key=YOUR_MIND_KEY (60/min limit)
   curl ".../memory/recall?key=YOUR_MIND_KEY"
   
   # Do: Authorization header (unlimited)
   curl -H "Authorization: Bearer YOUR_MIND_KEY" .../memory/recall
   ```

2. **या `Retry-After` सेकंड प्रतीक्षा करें** और पुनः प्रयास करें।

## ?key= सीमा क्यों मौजूद है

`?key=` क्वेरी पैरामीटर URL-केवल टूल्स (ब्राउज़र, `open` कमांड) के लिए सुविधाजनक है, लेकिन इसके सुरक्षा और प्रदर्शन निहितार्थ हैं:

- **सुरक्षा:** क्वेरी पैरामीटर सर्वर एक्सेस लॉग, ब्राउज़र इतिहास, और Referer हेडर में लॉग किए जाते हैं। उपयोग को सीमित करने से जोखिम कम होता है।
- **प्रदर्शन:** क्वेरी-पैरामीटर प्रमाणीकरण के लिए IP-आधारित रेट लिमिटर की आवश्यकता होती है (प्रति अनुरोध Redis लुकअप), जो विलंबता जोड़ता है। हेडर प्रमाणीकरण इसे छोड़ देता है।
- **दुरुपयोग निवारण:** लीक हुई `?key=` URL साझा और हैमर की जा सकती है। IP सीमा प्रभाव की दायरा सीमित रखती है।

## अनुशंसित पैटर्न

### LLM एजेंट्स

```python
# Always use header auth
headers = {"Authorization": f"Bearer {MIND_KEY}"}
response = requests.get(f"{URL}/memory/recall", headers=headers)
```

### ब्राउज़र-आधारित टूल्स

यदि आपका टूल केवल URL खोल सकता है:

```bash
# OK for occasional use (under 60/min)
open "https://synapse.schaefer.zone/memory/recall?key=YOUR_MIND_KEY"

# For frequent use, switch to a tool that supports headers
curl -H "Authorization: Bearer YOUR_MIND_KEY" .../memory/recall
```

### MCP server

MCP servers हमेशा `SYNAPSE_MIND_KEY` env var के माध्यम से हेडर प्रमाणीकरण का उपयोग करते हैं — कोई रेट लिमिट लागू नहीं होती।

### बल्क आयात

बल्क ऑपरेशन्स (जैसे 1000 मेमोरीज़ आयात करना) के लिए, हमेशा हेडर प्रमाणीकरण का उपयोग करें। `?key=` के माध्यम से बल्क आयात 1 मिनट के भीतर रेट लिमिट हिट करेगा।

## कोटा (Mind-स्तर)

वर्तमान में स्टोरेज आकार या मेमोरी गिनती पर कोई प्रति-mind कोटा नहीं है। सभी सीमाएँ डेटा स्तर पर नहीं, बल्कि प्रमाणीकरण/IP स्तर पर हैं। यह भविष्य में मल्टी-टैनेंट निष्पक्षता के लिए बदल सकता है।

## अपने उपयोग की निगरानी

```bash
# Check your current rate limit status (with ?key= auth)
curl -i "https://synapse.schaefer.zone/memory/stats?key=YOUR_MIND_KEY" | grep -i ratelimit

# Output:
# X-RateLimit-Limit: 60
# X-RateLimit-Remaining: 58
# X-RateLimit-Reset: 1782567840
```

## अगले कदम

- [प्रमाणीकरण](/docs/getting-started/authentication)
- [त्रुटियाँ और त्रुटि प्रबंधन](/docs/api/errors)