# LLM एजेंट्स के लिए Quick Start

आप सत्रों के बीच सभी मेमोरी खो देते हैं। Synapse आपका बाहरी मस्तिष्क है। यह गाइड तीन आवश्यक API कॉल्स दिखाती है जो हर LLM एजेंट को जानना चाहिए।

> [!CRITICAL]
> हर सत्र की शुरुआत में `GET /memory/recall` कॉल करें।
> इस कॉल के बिना, आपको यह याद नहीं कि उपयोगकर्ता कौन है, आपने क्या वादा किया, या पिछली बार आप किस पर काम कर रहे थे।

## चरण 1: सभी मेमोरीज़ रिकॉल करें (हमेशा पहले)

```
GET /memory/recall
Authorization: Bearer YOUR_MIND_KEY
```

सभी स्टोर की गई मेमोरीज़ का संरचित सादा-टेक्स्ट सारांश लौटाता है। उपयोगकर्ता, उनकी परियोजनाओं, और पिछले इंटरैक्शन्स का मानसिक मॉडल पुनर्निर्माण के लिए इसे पार्स करें।

उदाहरण प्रतिक्रिया:

```
Mind: Michael's Mind
Memories: 12 total (10 verified)

[001] identity (CRITICAL)
  user_name
  Michael Schäfer
  Tags: person, identity

[002] preference (HIGH)
  communication_style
  Prefers concise technical responses, no fluff
  Tags: communication, preference

[003] project (HIGH)
  project_synapse
  Synapse v1.5.0 deployed on vps1.schaefer.zone. Admin panel at /admin.
  Tags: synapse, deployment
  ...
```

## चरण 2: नई मेमोरी स्टोर करें

जब आप कुछ याद रखने लायक सीखें:

```
POST /memory
Authorization: Bearer YOUR_MIND_KEY
Content-Type: application/json

{
  "category": "fact",
  "key": "user_name",
  "content": "The user's name is Michael Schäfer",
  "tags": ["person", "identity"],
  "priority": "critical"
}
```

**श्रेणियाँ:** `identity`, `preference`, `fact`, `project`, `skill`, `mistake`, `context`, `note`, `credentials`

**प्राथमिकताएँ:** `low`, `normal`, `high`, `critical`

> [!TIP]
> हमेशा `key` फ़ील्ड शामिल करें — मेमोरी के लिए एक छोटा पहचानकर्ता। यह आपको समान कुंजी के साथ फिर से POST करके उसी मेमोरी को बाद में अपडेट करने देता है।

## चरण 3: विशिष्ट मेमोरी खोजें

```
GET /memory/search?q=Docker+Swarm
Authorization: Bearer YOUR_MIND_KEY
```

> [!TIP]
> FTS5 सिंटैक्स: कई शब्द = AND खोज। उद्धरण में वाक्यांश: `"docker swarm"`।
> उपसर्ग खोज: `docker*`। बूलियन: `docker OR kubernetes`।

## खुले टूल्स (कोई Auth हेडर नहीं)

यदि आपका टूल केवल URLs खोल सकता है (कोई कस्टम हेडर नहीं), तो `?key=` पैरामीटर का उपयोग करें:

```
GET /memory/recall?key=YOUR_MIND_KEY
POST /memory?key=YOUR_MIND_KEY (+ JSON body)
GET /memory/search?key=YOUR_MIND_KEY&q=suchbegriff
```

> [!WARNING]
> `?key=` 60 requests/minute तक सीमित है। Bearer हेडर की कोई रेट लिमिट नहीं है।
> जब संभव हो Bearer हेडर का उपयोग करें।

## संपूर्ण सत्र वर्कफ़्लो

1. **सत्र शुरुआत:** `GET /memory/recall` — सभी मेमोरीज़ लोड करें
2. **काम के दौरान:** `GET /memory/search?q=...` — विशिष्ट तथ्य खोजें
3. **नई जानकारी पर:** `POST /memory` — इसे स्टोर करें (category, key, tags, priority के साथ)
4. **समय-समय पर:** `GET /chat/poll` — मानव संदेशों के लिए जाँचें
5. **सत्र अंत:** किसी भी अंतिम सीखने को `POST /memory` से स्टोर करें

## सामान्य पैटर्न

### मौजूदा मेमोरी अपडेट करें

समान `category` और `key` के साथ POST `/memory` — मौजूदा मेमोरी अपडेट होती है, डुप्लिकेट नहीं होती।

### परियोजना स्थिति स्टोर करें

```json
{
  "category": "project",
  "key": "project_synapse_status",
  "content": "Synapse v1.5.0 deployed. Next: v1.6.0 with docs system. CI green.",
  "tags": ["synapse", "deployment", "status"],
  "priority": "high"
}
```

### गलती रिकॉर्ड करें (ताकि आप दोहराएं नहीं)

```json
{
  "category": "mistake",
  "key": "mistake_npm_version_bump",
  "content": "Always bump package.json version after changes — npm publish fails otherwise.",
  "tags": ["npm", "ci", "deployment"],
  "priority": "high"
}
```

### मानव संदेशों के लिए जाँचें

```
GET /chat/poll
Authorization: Bearer YOUR_MIND_KEY
```

मानव से अपठित संदेश लौटाता है। इससे उत्तर दें:

```
POST /chat/reply
Authorization: Bearer YOUR_MIND_KEY
Content-Type: application/json

{"content": "Got it! Working on it now."}
```

## अगले कदम

- [प्रमाणीकरण](/docs/getting-started/authentication) — Mind Key vs JWT
- [Memory API संदर्भ](/docs/api/memory) — सभी 22 मेमोरी एंडपॉइंट्स
- [Chat API](/docs/api/chat) — मानवों के साथ अतुल्यकालिक संचार
- [LLM Cookbook](/docs/llm-cookbook/session-start-pattern) — व्यावहारिक पैटर्न